Init
This commit is contained in:
528
physx/snippets/snippettriggers/SnippetTriggers.cpp
Normal file
528
physx/snippets/snippettriggers/SnippetTriggers.cpp
Normal file
@ -0,0 +1,528 @@
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions
|
||||
// are met:
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above copyright
|
||||
// notice, this list of conditions and the following disclaimer in the
|
||||
// documentation and/or other materials provided with the distribution.
|
||||
// * Neither the name of NVIDIA CORPORATION nor the names of its
|
||||
// contributors may be used to endorse or promote products derived
|
||||
// from this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY
|
||||
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
||||
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
||||
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
||||
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Copyright (c) 2008-2021 NVIDIA Corporation. All rights reserved.
|
||||
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
|
||||
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
|
||||
|
||||
// ****************************************************************************
|
||||
// This snippet illustrates the use of built-in triggers, and how to emulate
|
||||
// them with regular shapes if you need CCD or trigger-trigger notifications.
|
||||
//
|
||||
// ****************************************************************************
|
||||
|
||||
#include "PxPhysicsAPI.h"
|
||||
|
||||
#include "../snippetutils/SnippetUtils.h"
|
||||
#include "../snippetcommon/SnippetPrint.h"
|
||||
#include "../snippetcommon/SnippetPVD.h"
|
||||
|
||||
using namespace physx;
|
||||
|
||||
enum TriggerImpl
|
||||
{
|
||||
// Uses built-in triggers (PxShapeFlag::eTRIGGER_SHAPE).
|
||||
REAL_TRIGGERS,
|
||||
|
||||
// Emulates triggers using a filter shader. Needs one reserved value in PxFilterData.
|
||||
FILTER_SHADER,
|
||||
|
||||
// Emulates triggers using a filter callback. Doesn't use PxFilterData but needs user-defined way to mark a shape as a trigger.
|
||||
FILTER_CALLBACK,
|
||||
};
|
||||
|
||||
struct ScenarioData
|
||||
{
|
||||
TriggerImpl mImpl;
|
||||
bool mCCD;
|
||||
bool mTriggerTrigger;
|
||||
};
|
||||
|
||||
#define SCENARIO_COUNT 9
|
||||
|
||||
static ScenarioData gData[SCENARIO_COUNT] = {
|
||||
{REAL_TRIGGERS, false, false},
|
||||
{FILTER_SHADER, false, false},
|
||||
{FILTER_CALLBACK, false, false},
|
||||
{REAL_TRIGGERS, true, false},
|
||||
{FILTER_SHADER, true, false},
|
||||
{FILTER_CALLBACK, true, false},
|
||||
{REAL_TRIGGERS, false, true},
|
||||
{FILTER_SHADER, false, true},
|
||||
{FILTER_CALLBACK, false, true},
|
||||
};
|
||||
|
||||
static PxU32 gScenario = 0;
|
||||
|
||||
static PX_FORCE_INLINE TriggerImpl getImpl() { return gData[gScenario].mImpl; }
|
||||
static PX_FORCE_INLINE bool usesCCD() { return gData[gScenario].mCCD; }
|
||||
static PX_FORCE_INLINE bool usesTriggerTrigger() { return gData[gScenario].mTriggerTrigger; }
|
||||
|
||||
static PxDefaultAllocator gAllocator;
|
||||
static PxDefaultErrorCallback gErrorCallback;
|
||||
|
||||
static PxFoundation* gFoundation = NULL;
|
||||
static PxPhysics* gPhysics = NULL;
|
||||
|
||||
static PxDefaultCpuDispatcher* gDispatcher = NULL;
|
||||
static PxScene* gScene = NULL;
|
||||
static PxMaterial* gMaterial = NULL;
|
||||
static PxPvd* gPvd = NULL;
|
||||
|
||||
static bool gPause = false;
|
||||
static bool gOneFrame = false;
|
||||
|
||||
// Detects a trigger using the shape's simulation filter data. See createTriggerShape() function.
|
||||
bool isTrigger(const PxFilterData& data)
|
||||
{
|
||||
if(data.word0!=0xffffffff)
|
||||
return false;
|
||||
if(data.word1!=0xffffffff)
|
||||
return false;
|
||||
if(data.word2!=0xffffffff)
|
||||
return false;
|
||||
if(data.word3!=0xffffffff)
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool isTriggerShape(PxShape* shape)
|
||||
{
|
||||
const TriggerImpl impl = getImpl();
|
||||
|
||||
// Detects native built-in triggers.
|
||||
if(impl==REAL_TRIGGERS && (shape->getFlags() & PxShapeFlag::eTRIGGER_SHAPE))
|
||||
return true;
|
||||
|
||||
// Detects our emulated triggers using the simulation filter data. See createTriggerShape() function.
|
||||
if(impl==FILTER_SHADER && ::isTrigger(shape->getSimulationFilterData()))
|
||||
return true;
|
||||
|
||||
// Detects our emulated triggers using the simulation filter callback. See createTriggerShape() function.
|
||||
if(impl==FILTER_CALLBACK && shape->userData)
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
static PxFilterFlags triggersUsingFilterShader(PxFilterObjectAttributes /*attributes0*/, PxFilterData filterData0,
|
||||
PxFilterObjectAttributes /*attributes1*/, PxFilterData filterData1,
|
||||
PxPairFlags& pairFlags, const void* /*constantBlock*/, PxU32 /*constantBlockSize*/)
|
||||
{
|
||||
// printf("contactReportFilterShader\n");
|
||||
|
||||
PX_ASSERT(getImpl()==FILTER_SHADER);
|
||||
|
||||
// We need to detect whether one of the shapes is a trigger.
|
||||
const bool isTriggerPair = isTrigger(filterData0) || isTrigger(filterData1);
|
||||
|
||||
// If we have a trigger, replicate the trigger codepath from PxDefaultSimulationFilterShader
|
||||
if(isTriggerPair)
|
||||
{
|
||||
pairFlags = PxPairFlag::eTRIGGER_DEFAULT;
|
||||
|
||||
if(usesCCD())
|
||||
pairFlags |= PxPairFlag::eDETECT_CCD_CONTACT;
|
||||
|
||||
return PxFilterFlag::eDEFAULT;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Otherwise use the default flags for regular pairs
|
||||
pairFlags = PxPairFlag::eCONTACT_DEFAULT;
|
||||
return PxFilterFlag::eDEFAULT;
|
||||
}
|
||||
}
|
||||
|
||||
static PxFilterFlags triggersUsingFilterCallback(PxFilterObjectAttributes /*attributes0*/, PxFilterData /*filterData0*/,
|
||||
PxFilterObjectAttributes /*attributes1*/, PxFilterData /*filterData1*/,
|
||||
PxPairFlags& pairFlags, const void* /*constantBlock*/, PxU32 /*constantBlockSize*/)
|
||||
{
|
||||
// printf("contactReportFilterShader\n");
|
||||
|
||||
PX_ASSERT(getImpl()==FILTER_CALLBACK);
|
||||
|
||||
pairFlags = PxPairFlag::eCONTACT_DEFAULT;
|
||||
|
||||
if(usesCCD())
|
||||
pairFlags |= PxPairFlag::eDETECT_CCD_CONTACT|PxPairFlag::eNOTIFY_TOUCH_CCD;
|
||||
|
||||
return PxFilterFlag::eCALLBACK;
|
||||
}
|
||||
|
||||
class TriggersFilterCallback : public PxSimulationFilterCallback
|
||||
{
|
||||
virtual PxFilterFlags pairFound(PxU32 /*pairID*/,
|
||||
PxFilterObjectAttributes /*attributes0*/, PxFilterData /*filterData0*/, const PxActor* /*a0*/, const PxShape* s0,
|
||||
PxFilterObjectAttributes /*attributes1*/, PxFilterData /*filterData1*/, const PxActor* /*a1*/, const PxShape* s1,
|
||||
PxPairFlags& pairFlags)
|
||||
{
|
||||
// printf("pairFound\n");
|
||||
|
||||
if(s0->userData || s1->userData) // See createTriggerShape() function
|
||||
{
|
||||
pairFlags = PxPairFlag::eTRIGGER_DEFAULT;
|
||||
|
||||
if(usesCCD())
|
||||
pairFlags |= PxPairFlag::eDETECT_CCD_CONTACT|PxPairFlag::eNOTIFY_TOUCH_CCD;
|
||||
}
|
||||
else
|
||||
pairFlags = PxPairFlag::eCONTACT_DEFAULT;
|
||||
|
||||
return PxFilterFlags();
|
||||
}
|
||||
|
||||
virtual void pairLost(PxU32 /*pairID*/,
|
||||
PxFilterObjectAttributes /*attributes0*/,
|
||||
PxFilterData /*filterData0*/,
|
||||
PxFilterObjectAttributes /*attributes1*/,
|
||||
PxFilterData /*filterData1*/,
|
||||
bool /*objectRemoved*/)
|
||||
{
|
||||
// printf("pairLost\n");
|
||||
}
|
||||
|
||||
virtual bool statusChange(PxU32& /*pairID*/, PxPairFlags& /*pairFlags*/, PxFilterFlags& /*filterFlags*/)
|
||||
{
|
||||
// printf("statusChange\n");
|
||||
return false;
|
||||
}
|
||||
}gTriggersFilterCallback;
|
||||
|
||||
class ContactReportCallback: public PxSimulationEventCallback
|
||||
{
|
||||
void onConstraintBreak(PxConstraintInfo* /*constraints*/, PxU32 /*count*/)
|
||||
{
|
||||
printf("onConstraintBreak\n");
|
||||
}
|
||||
|
||||
void onWake(PxActor** /*actors*/, PxU32 /*count*/)
|
||||
{
|
||||
printf("onWake\n");
|
||||
}
|
||||
|
||||
void onSleep(PxActor** /*actors*/, PxU32 /*count*/)
|
||||
{
|
||||
printf("onSleep\n");
|
||||
}
|
||||
|
||||
void onTrigger(PxTriggerPair* pairs, PxU32 count)
|
||||
{
|
||||
// printf("onTrigger: %d trigger pairs\n", count);
|
||||
while(count--)
|
||||
{
|
||||
const PxTriggerPair& current = *pairs++;
|
||||
if(current.status & PxPairFlag::eNOTIFY_TOUCH_FOUND)
|
||||
printf("Shape is entering trigger volume\n");
|
||||
if(current.status & PxPairFlag::eNOTIFY_TOUCH_LOST)
|
||||
printf("Shape is leaving trigger volume\n");
|
||||
}
|
||||
}
|
||||
|
||||
void onAdvance(const PxRigidBody*const*, const PxTransform*, const PxU32)
|
||||
{
|
||||
printf("onAdvance\n");
|
||||
}
|
||||
|
||||
void onContact(const PxContactPairHeader& /*pairHeader*/, const PxContactPair* pairs, PxU32 count)
|
||||
{
|
||||
// printf("onContact: %d pairs\n", count);
|
||||
|
||||
while(count--)
|
||||
{
|
||||
const PxContactPair& current = *pairs++;
|
||||
|
||||
// The reported pairs can be trigger pairs or not. We only enabled contact reports for
|
||||
// trigger pairs in the filter shader, so we don't need to do further checks here. In a
|
||||
// real-world scenario you would probably need a way to tell whether one of the shapes
|
||||
// is a trigger or not. You could e.g. reuse the PxFilterData like we did in the filter
|
||||
// shader, or maybe use the shape's userData to identify triggers, or maybe put triggers
|
||||
// in a hash-set and test the reported shape pointers against it. Many options here.
|
||||
|
||||
if(current.events & (PxPairFlag::eNOTIFY_TOUCH_FOUND|PxPairFlag::eNOTIFY_TOUCH_CCD))
|
||||
printf("Shape is entering trigger volume\n");
|
||||
if(current.events & PxPairFlag::eNOTIFY_TOUCH_LOST)
|
||||
printf("Shape is leaving trigger volume\n");
|
||||
|
||||
if(isTriggerShape(current.shapes[0]) && isTriggerShape(current.shapes[1]))
|
||||
printf("Trigger-trigger overlap detected\n");
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
static ContactReportCallback gContactReportCallback;
|
||||
|
||||
static PxShape* createTriggerShape(const PxGeometry& geom, bool isExclusive)
|
||||
{
|
||||
const TriggerImpl impl = getImpl();
|
||||
|
||||
PxShape* shape = nullptr;
|
||||
if(impl==REAL_TRIGGERS)
|
||||
{
|
||||
const PxShapeFlags shapeFlags = PxShapeFlag::eVISUALIZATION | PxShapeFlag::eTRIGGER_SHAPE;
|
||||
shape = gPhysics->createShape(geom, *gMaterial, isExclusive, shapeFlags);
|
||||
}
|
||||
else if(impl==FILTER_SHADER)
|
||||
{
|
||||
PxShapeFlags shapeFlags = PxShapeFlag::eVISUALIZATION | PxShapeFlag::eSIMULATION_SHAPE;
|
||||
shape = gPhysics->createShape(geom, *gMaterial, isExclusive, shapeFlags);
|
||||
|
||||
// For this method to work, you need a way to mark shapes as triggers without using PxShapeFlag::eTRIGGER_SHAPE
|
||||
// (so that trigger-trigger pairs are reported), and without calling a PxShape function (so that the data is
|
||||
// available in a filter shader).
|
||||
//
|
||||
// One way is to reserve a special PxFilterData value/mask for triggers. It may not always be possible depending
|
||||
// on how you otherwise use the filter data).
|
||||
const PxFilterData triggerFilterData(0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff);
|
||||
shape->setSimulationFilterData(triggerFilterData);
|
||||
}
|
||||
else if(impl==FILTER_CALLBACK)
|
||||
{
|
||||
// We will have access to shape pointers in the filter callback so we just mark triggers in an arbitrary way here,
|
||||
// for example using the shape's userData.
|
||||
shape = gPhysics->createShape(geom, *gMaterial, isExclusive);
|
||||
shape->userData = shape; // Arbitrary rule: it's a trigger if non null
|
||||
}
|
||||
return shape;
|
||||
}
|
||||
|
||||
static void createDefaultScene()
|
||||
{
|
||||
const bool ccd = usesCCD();
|
||||
|
||||
// Create trigger shape
|
||||
{
|
||||
const PxVec3 halfExtent(10.0f, ccd ? 0.01f : 1.0f, 10.0f);
|
||||
PxShape* shape = createTriggerShape(PxBoxGeometry(halfExtent), false);
|
||||
|
||||
if(shape)
|
||||
{
|
||||
PxRigidStatic* body = gPhysics->createRigidStatic(PxTransform(0.0f, 10.0f, 0.0f));
|
||||
body->attachShape(*shape);
|
||||
gScene->addActor(*body);
|
||||
shape->release();
|
||||
}
|
||||
}
|
||||
|
||||
// Create falling rigid body
|
||||
{
|
||||
const PxVec3 halfExtent(ccd ? 0.1f : 1.0f);
|
||||
|
||||
PxShape* shape = gPhysics->createShape(PxBoxGeometry(halfExtent), *gMaterial);
|
||||
|
||||
PxRigidDynamic* body = gPhysics->createRigidDynamic(PxTransform(0.0f, ccd ? 30.0f : 20.0f, 0.0f));
|
||||
body->attachShape(*shape);
|
||||
|
||||
PxRigidBodyExt::updateMassAndInertia(*body, 1.0f);
|
||||
gScene->addActor(*body);
|
||||
shape->release();
|
||||
|
||||
if(ccd)
|
||||
{
|
||||
body->setRigidBodyFlag(PxRigidBodyFlag::eENABLE_CCD, true);
|
||||
body->setLinearVelocity(PxVec3(0.0f, -140.0f, 0.0f));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void createTriggerTriggerScene()
|
||||
{
|
||||
struct Local
|
||||
{
|
||||
static void createSphereActor(const PxVec3& pos, const PxVec3& linVel)
|
||||
{
|
||||
PxShape* sphereShape = gPhysics->createShape(PxSphereGeometry(1.0f), *gMaterial, false);
|
||||
|
||||
PxRigidDynamic* body = gPhysics->createRigidDynamic(PxTransform(pos));
|
||||
body->attachShape(*sphereShape);
|
||||
|
||||
PxShape* triggerShape = createTriggerShape(PxSphereGeometry(4.0f), true);
|
||||
body->attachShape(*triggerShape);
|
||||
|
||||
const bool isTriggershape = triggerShape->getFlags() & PxShapeFlag::eTRIGGER_SHAPE;
|
||||
if(!isTriggershape)
|
||||
triggerShape->setFlag(PxShapeFlag::eSIMULATION_SHAPE, false);
|
||||
PxRigidBodyExt::updateMassAndInertia(*body, 1.0f);
|
||||
if(!isTriggershape)
|
||||
triggerShape->setFlag(PxShapeFlag::eSIMULATION_SHAPE, true);
|
||||
gScene->addActor(*body);
|
||||
sphereShape->release();
|
||||
triggerShape->release();
|
||||
|
||||
body->setLinearVelocity(linVel);
|
||||
}
|
||||
};
|
||||
|
||||
Local::createSphereActor(PxVec3(-5.0f, 1.0f, 0.0f), PxVec3( 1.0f, 0.0f, 0.0f));
|
||||
Local::createSphereActor(PxVec3( 5.0f, 1.0f, 0.0f), PxVec3(-1.0f, 0.0f, 0.0f));
|
||||
}
|
||||
|
||||
static void initScene()
|
||||
{
|
||||
const TriggerImpl impl = getImpl();
|
||||
|
||||
PxSceneDesc sceneDesc(gPhysics->getTolerancesScale());
|
||||
// sceneDesc.flags &= ~PxSceneFlag::eENABLE_PCM;
|
||||
sceneDesc.cpuDispatcher = gDispatcher;
|
||||
sceneDesc.gravity = PxVec3(0, -9.81f, 0);
|
||||
sceneDesc.simulationEventCallback = &gContactReportCallback;
|
||||
if(impl==REAL_TRIGGERS)
|
||||
{
|
||||
sceneDesc.filterShader = PxDefaultSimulationFilterShader;
|
||||
printf("- Using built-in triggers.\n");
|
||||
}
|
||||
else if(impl==FILTER_SHADER)
|
||||
{
|
||||
sceneDesc.filterShader = triggersUsingFilterShader;
|
||||
printf("- Using regular shapes emulating triggers with a filter shader.\n");
|
||||
}
|
||||
else if(impl==FILTER_CALLBACK)
|
||||
{
|
||||
sceneDesc.filterShader = triggersUsingFilterCallback;
|
||||
sceneDesc.filterCallback = &gTriggersFilterCallback;
|
||||
printf("- Using regular shapes emulating triggers with a filter callback.\n");
|
||||
}
|
||||
|
||||
if(usesCCD())
|
||||
{
|
||||
sceneDesc.flags |= PxSceneFlag::eENABLE_CCD;
|
||||
printf("- Using CCD.\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("- Using no CCD.\n");
|
||||
}
|
||||
|
||||
gScene = gPhysics->createScene(sceneDesc);
|
||||
|
||||
PxPvdSceneClient* pvdClient = gScene->getScenePvdClient();
|
||||
if(pvdClient)
|
||||
pvdClient->setScenePvdFlag(PxPvdSceneFlag::eTRANSMIT_CONTACTS, true);
|
||||
|
||||
PxRigidStatic* groundPlane = PxCreatePlane(*gPhysics, PxPlane(0,1,0,0), *gMaterial);
|
||||
gScene->addActor(*groundPlane);
|
||||
|
||||
if(usesTriggerTrigger())
|
||||
createTriggerTriggerScene();
|
||||
else
|
||||
createDefaultScene();
|
||||
}
|
||||
|
||||
static void releaseScene()
|
||||
{
|
||||
PX_RELEASE(gScene);
|
||||
}
|
||||
|
||||
void stepPhysics(bool /*interactive*/)
|
||||
{
|
||||
if(gPause && !gOneFrame)
|
||||
return;
|
||||
gOneFrame = false;
|
||||
|
||||
if(gScene)
|
||||
{
|
||||
gScene->simulate(1.0f/60.0f);
|
||||
gScene->fetchResults(true);
|
||||
}
|
||||
}
|
||||
|
||||
void initPhysics(bool /*interactive*/)
|
||||
{
|
||||
printf("Press keys F1 to F9 to select a scenario.\n");
|
||||
|
||||
gFoundation = PxCreateFoundation(PX_PHYSICS_VERSION, gAllocator, gErrorCallback);
|
||||
gPvd = PxCreatePvd(*gFoundation);
|
||||
PxPvdTransport* transport = PxDefaultPvdSocketTransportCreate(PVD_HOST, 5425, 10);
|
||||
gPvd->connect(*transport,PxPvdInstrumentationFlag::eALL);
|
||||
gPhysics = PxCreatePhysics(PX_PHYSICS_VERSION, *gFoundation, PxTolerancesScale(),true,gPvd);
|
||||
PxInitExtensions(*gPhysics,gPvd);
|
||||
const PxU32 numCores = SnippetUtils::getNbPhysicalCores();
|
||||
gDispatcher = PxDefaultCpuDispatcherCreate(numCores == 0 ? 0 : numCores - 1);
|
||||
gMaterial = gPhysics->createMaterial(1.0f, 1.0f, 0.0f);
|
||||
|
||||
initScene();
|
||||
}
|
||||
|
||||
void cleanupPhysics(bool /*interactive*/)
|
||||
{
|
||||
releaseScene();
|
||||
|
||||
PX_RELEASE(gDispatcher);
|
||||
PxCloseExtensions();
|
||||
PX_RELEASE(gPhysics);
|
||||
if(gPvd)
|
||||
{
|
||||
PxPvdTransport* transport = gPvd->getTransport();
|
||||
PX_RELEASE(gPvd);
|
||||
PX_RELEASE(transport);
|
||||
}
|
||||
PX_RELEASE(gFoundation);
|
||||
|
||||
printf("SnippetTriggers done.\n");
|
||||
}
|
||||
|
||||
void keyPress(unsigned char key, const PxTransform& /*camera*/)
|
||||
{
|
||||
if(key=='p' || key=='P')
|
||||
gPause = !gPause;
|
||||
|
||||
if(key=='o' || key=='O')
|
||||
{
|
||||
gPause = true;
|
||||
gOneFrame = true;
|
||||
}
|
||||
|
||||
if(gScene)
|
||||
{
|
||||
if(key>=1 && key<=SCENARIO_COUNT)
|
||||
{
|
||||
gScenario = key-1;
|
||||
releaseScene();
|
||||
initScene();
|
||||
}
|
||||
|
||||
if(key=='r' || key=='R')
|
||||
{
|
||||
releaseScene();
|
||||
initScene();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int snippetMain(int, const char*const*)
|
||||
{
|
||||
#ifdef RENDER_SNIPPET
|
||||
extern void renderLoop();
|
||||
renderLoop();
|
||||
#else
|
||||
initPhysics(false);
|
||||
for(PxU32 i=0; i<250; i++)
|
||||
stepPhysics(false);
|
||||
cleanupPhysics(false);
|
||||
#endif
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
198
physx/snippets/snippettriggers/SnippetTriggersRender.cpp
Normal file
198
physx/snippets/snippettriggers/SnippetTriggersRender.cpp
Normal file
@ -0,0 +1,198 @@
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions
|
||||
// are met:
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above copyright
|
||||
// notice, this list of conditions and the following disclaimer in the
|
||||
// documentation and/or other materials provided with the distribution.
|
||||
// * Neither the name of NVIDIA CORPORATION nor the names of its
|
||||
// contributors may be used to endorse or promote products derived
|
||||
// from this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY
|
||||
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
||||
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
||||
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
||||
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Copyright (c) 2008-2021 NVIDIA Corporation. All rights reserved.
|
||||
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
|
||||
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
|
||||
|
||||
#ifdef RENDER_SNIPPET
|
||||
|
||||
#include <vector>
|
||||
|
||||
#include "PxPhysicsAPI.h"
|
||||
#include "../snippetrender/SnippetRender.h"
|
||||
#include "../snippetrender/SnippetCamera.h"
|
||||
|
||||
using namespace physx;
|
||||
|
||||
extern void initPhysics(bool interactive);
|
||||
extern void stepPhysics(bool interactive);
|
||||
extern void cleanupPhysics(bool interactive);
|
||||
extern void keyPress(unsigned char key, const PxTransform& camera);
|
||||
bool isTrigger(const PxFilterData& data);
|
||||
bool isTriggerShape(PxShape* shape);
|
||||
|
||||
namespace
|
||||
{
|
||||
Snippets::Camera* sCamera;
|
||||
|
||||
void motionCallback(int x, int y)
|
||||
{
|
||||
sCamera->handleMotion(x, y);
|
||||
}
|
||||
|
||||
void keyboardCallback(unsigned char key, int x, int y)
|
||||
{
|
||||
if(key==27)
|
||||
exit(0);
|
||||
|
||||
if(!sCamera->handleKey(key, x, y))
|
||||
keyPress(key, sCamera->getTransform());
|
||||
}
|
||||
|
||||
void keyboardCallback2(int key, int /*x*/, int /*y*/)
|
||||
{
|
||||
keyPress(key, sCamera->getTransform());
|
||||
}
|
||||
|
||||
void mouseCallback(int button, int state, int x, int y)
|
||||
{
|
||||
sCamera->handleMouse(button, state, x, y);
|
||||
}
|
||||
|
||||
void idleCallback()
|
||||
{
|
||||
glutPostRedisplay();
|
||||
}
|
||||
|
||||
static void InitLighting()
|
||||
{
|
||||
glEnable(GL_COLOR_MATERIAL);
|
||||
|
||||
const float zero[] = { 0.0f, 0.0f, 0.0f, 0.0f };
|
||||
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, zero);
|
||||
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, zero);
|
||||
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, zero);
|
||||
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, zero);
|
||||
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 0.0f);
|
||||
|
||||
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, zero);
|
||||
|
||||
glEnable(GL_LIGHTING);
|
||||
PxVec3 Dir(-1.0f, 1.0f, 0.5f);
|
||||
// PxVec3 Dir(0.0f, 1.0f, 0.0f);
|
||||
Dir.normalize();
|
||||
|
||||
const float AmbientValue = 0.3f;
|
||||
const float ambientColor0[] = { AmbientValue, AmbientValue, AmbientValue, 0.0f };
|
||||
glLightfv(GL_LIGHT0, GL_AMBIENT, ambientColor0);
|
||||
|
||||
const float specularColor0[] = { 0.0f, 0.0f, 0.0f, 0.0f };
|
||||
glLightfv(GL_LIGHT0, GL_SPECULAR, specularColor0);
|
||||
|
||||
const float diffuseColor0[] = { 0.7f, 0.7f, 0.7f, 0.0f };
|
||||
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuseColor0);
|
||||
|
||||
const float position0[] = { Dir.x, Dir.y, Dir.z, 0.0f };
|
||||
glLightfv(GL_LIGHT0, GL_POSITION, position0);
|
||||
|
||||
glEnable(GL_LIGHT0);
|
||||
|
||||
// glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
|
||||
// glColor4f(0.0f, 0.0f, 0.0f, 0.0f);
|
||||
|
||||
if(0)
|
||||
{
|
||||
glEnable(GL_FOG);
|
||||
glFogi(GL_FOG_MODE,GL_LINEAR);
|
||||
//glFogi(GL_FOG_MODE,GL_EXP);
|
||||
//glFogi(GL_FOG_MODE,GL_EXP2);
|
||||
glFogf(GL_FOG_START, 0.0f);
|
||||
glFogf(GL_FOG_END, 100.0f);
|
||||
glFogf(GL_FOG_DENSITY, 0.005f);
|
||||
// glClearColor(0.2f, 0.2f, 0.2f, 1.0);
|
||||
// const PxVec3 FogColor(0.2f, 0.2f, 0.2f);
|
||||
const PxVec3 FogColor(1.0f);
|
||||
glFogfv(GL_FOG_COLOR, &FogColor.x);
|
||||
}
|
||||
}
|
||||
|
||||
class MyTriggerRender : public Snippets::TriggerRender
|
||||
{
|
||||
public:
|
||||
virtual bool isTrigger(physx::PxShape* shape) const
|
||||
{
|
||||
return ::isTriggerShape(shape);
|
||||
}
|
||||
};
|
||||
|
||||
void renderCallback()
|
||||
{
|
||||
stepPhysics(true);
|
||||
|
||||
if(0)
|
||||
{
|
||||
PxVec3 camPos = sCamera->getEye();
|
||||
PxVec3 camDir = sCamera->getDir();
|
||||
printf("camPos: (%ff, %ff, %ff)\n", double(camPos.x), double(camPos.y), double(camPos.z));
|
||||
printf("camDir: (%ff, %ff, %ff)\n", double(camDir.x), double(camDir.y), double(camDir.z));
|
||||
}
|
||||
|
||||
Snippets::startRender(sCamera->getEye(), sCamera->getDir());
|
||||
InitLighting();
|
||||
|
||||
PxScene* scene;
|
||||
PxGetPhysics().getScenes(&scene,1);
|
||||
PxU32 nbActors = scene->getNbActors(PxActorTypeFlag::eRIGID_DYNAMIC | PxActorTypeFlag::eRIGID_STATIC);
|
||||
if(nbActors)
|
||||
{
|
||||
std::vector<PxRigidActor*> actors(nbActors);
|
||||
scene->getActors(PxActorTypeFlag::eRIGID_DYNAMIC | PxActorTypeFlag::eRIGID_STATIC, reinterpret_cast<PxActor**>(&actors[0]), nbActors);
|
||||
|
||||
MyTriggerRender tr;
|
||||
Snippets::renderActors(&actors[0], static_cast<PxU32>(actors.size()), true, PxVec3(0.0f, 0.75f, 0.0f), &tr);
|
||||
}
|
||||
|
||||
Snippets::finishRender();
|
||||
}
|
||||
|
||||
void exitCallback(void)
|
||||
{
|
||||
delete sCamera;
|
||||
cleanupPhysics(true);
|
||||
}
|
||||
}
|
||||
|
||||
void renderLoop()
|
||||
{
|
||||
sCamera = new Snippets::Camera(PxVec3(8.757190f, 12.367847f, 23.541956f), PxVec3(-0.407947f, -0.042438f, -0.912019f));
|
||||
|
||||
Snippets::setupDefaultWindow("PhysX Snippet Triggers");
|
||||
Snippets::setupDefaultRenderState();
|
||||
|
||||
glutIdleFunc(idleCallback);
|
||||
glutDisplayFunc(renderCallback);
|
||||
glutKeyboardFunc(keyboardCallback);
|
||||
glutSpecialFunc(keyboardCallback2);
|
||||
glutMouseFunc(mouseCallback);
|
||||
glutMotionFunc(motionCallback);
|
||||
motionCallback(0,0);
|
||||
|
||||
atexit(exitCallback);
|
||||
|
||||
initPhysics(true);
|
||||
glutMainLoop();
|
||||
}
|
||||
#endif
|
||||
Reference in New Issue
Block a user