//------------------------------------------------------------
/*static*/ void PhysXFactoryInterface::releaseScene( NxScene *&scene )
{
NxPhysicsSDK *sdk = System::MainController::getSingleton().getNxPhysicsSDK();
if( sdk && scene )
{
sdk->releaseScene(*scene);
}
scene = 0;
}
void ModuleClothing::ClothingBackendFactory::releaseCookedInstances(NxParameterized::Interface* _cookedData, bool tetraMesh)
{
if (_cookedData != NULL)
{
PX_ASSERT(strcmp(_cookedData->className(), ClothingCookedParam::staticClassName()) == 0);
ClothingCookedParam* cookedData = static_cast<ClothingCookedParam*>(_cookedData);
#if NX_SDK_VERSION_MAJOR == 2
NxPhysicsSDK* pSDK = NiGetApexSDK()->getPhysXSDK();
#endif
for (PxI32 i = 0; i < cookedData->convexMeshPointers.arraySizes[0]; i++)
{
#if NX_SDK_VERSION_MAJOR == 2
NxConvexMesh* convexMesh = reinterpret_cast<NxConvexMesh*>(cookedData->convexMeshPointers.buf[i]);
if (convexMesh != NULL)
{
pSDK->releaseConvexMesh(*convexMesh);
}
#elif NX_SDK_VERSION_MAJOR == 3
PX_ALWAYS_ASSERT();
#endif
cookedData->convexMeshPointers.buf[i] = NULL;
}
for (PxI32 i = 0; i < cookedData->cookedPhysicalSubmeshes.arraySizes[0]; i++)
{
if (tetraMesh)
{
#if NX_SDK_VERSION_MAJOR == 2
NxSoftBodyMesh* mesh = reinterpret_cast<NxSoftBodyMesh*>(cookedData->cookedPhysicalSubmeshes.buf[i].deformableMeshPointer);
if (mesh != NULL)
{
pSDK->releaseSoftBodyMesh(*mesh);
}
#elif NX_SDK_VERSION_MAJOR == 3
PX_ALWAYS_ASSERT();
#endif
}
else
{
#if NX_SDK_VERSION_MAJOR == 2
NxClothMesh* mesh = reinterpret_cast<NxClothMesh*>(cookedData->cookedPhysicalSubmeshes.buf[i].deformableMeshPointer);
if (mesh != NULL)
{
pSDK->releaseClothMesh(*mesh);
}
#elif NX_SDK_VERSION_MAJOR == 3
PX_ALWAYS_ASSERT();
#endif
}
cookedData->cookedPhysicalSubmeshes.buf[i].deformableMeshPointer = NULL;
PX_ASSERT(cookedData->cookedPhysicalSubmeshes.buf[i].deformableMeshPointer == NULL);
}
}
}
//------------------------------------------------------------
/*static*/ NxScene* PhysXFactoryInterface::createScene( const NxSceneDesc &desc )
{
NxPhysicsSDK *sdk = System::MainController::getSingleton().getNxPhysicsSDK();
NxScene *scene(0);
if( sdk )
{
scene = sdk->createScene(desc);
}
return scene;
}
void applyOptions()
{
if(!sdk || !scene)
return;
//bool visualizeCollisionShapes = featureMap[PhysicsLib::VISUALIZE_COLLISION_SHAPES];
//bool visualizeDynamic = featureMap[PhysicsLib::VISUALIZE_DYNAMIC];
//bool visualizeStatic = featureMap[PhysicsLib::VISUALIZE_STATIC];
//bool visualizeCollisionContacts = featureMap[PhysicsLib::VISUALIZE_COLLISION_CONTACTS];
bool visualizeFluids = featureMap[PhysicsLib::VISUALIZE_FLUIDS];
bool visualizeJoints = featureMap[PhysicsLib::VISUALIZE_JOINTS];
//bool visualizeCCD = featureMap[PhysicsLib::VISUALIZE_CCD];
sdk->setParameter(NX_VISUALIZE_FLUID_POSITION, visualizeFluids);
sdk->setParameter(NX_VISUALIZE_FLUID_BOUNDS, visualizeFluids);
sdk->setParameter(NX_VISUALIZE_FLUID_PACKETS, visualizeFluids);
sdk->setParameter(NX_VISUALIZE_FLUID_KERNEL_RADIUS, visualizeFluids);
sdk->setParameter(NX_VISUALIZE_JOINT_LIMITS, visualizeJoints);
//sdk->setParameter(NX_VISUALIZE_JOINT_WORLD_AXES, visualizeJoints);
}
~Data()
{
removeFluidContainmentSphere();
#ifdef PROJECT_CLAW_PROTO
unitMaterial = NULL;
#endif
if(physicslib_fluid_containment_actor != NULL)
{
if(scene && physicslib_fluid_containment_actor)
{
assert(scene->isWritable());
scene->releaseActor(*physicslib_fluid_containment_actor);
}
physicslib_fluid_containment_actor = NULL;
physicslib_fluid_containment_shape = NULL;
}
if(sdk && scene)
{
#ifndef NDEBUG
int actors = scene->getNbActors();
assert(actors == 1 || actors == 2);
#ifndef NX_DISABLE_FLUIDS
int fluids = scene->getNbFluids();
assert(fluids == 0);
#endif
#endif
scene->shutdownWorkerThreads();
sdk->releaseScene(*scene);
}
if(sdk)
sdk->release();
}
// Core dump globals
NxPhysicsSDK* CreatePhysics()
{
NxPhysicsSDK* pSDK = NxCreatePhysicsSDK(NX_PHYSICS_SDK_VERSION, gAllocator);
if (!pSDK) return NULL;
// Set the physics parameters
pSDK->setParameter(NX_SKIN_WIDTH, 0.01);
// Set the debug visualization parameters
pSDK->setParameter(NX_VISUALIZATION_SCALE, 1);
pSDK->setParameter(NX_VISUALIZE_COLLISION_SHAPES, 1);
pSDK->setParameter(NX_VISUALIZE_ACTOR_AXES, 1);
pSDK->setParameter(NX_VISUALIZE_COLLISION_FNORMALS, 1);
return pSDK;
}
void VisualDebugger::setVisualisationMode(NxOgre::Enums::VisualDebugger dm)
{
NxPhysicsSDK* sdk = NxGetPhysicsSDK();
if (dm == NxOgre::Enums::VisualDebugger_ShowNone)
{
sdk->setParameter(NX_VISUALIZATION_SCALE, 0);
return;
}
sdk->setParameter(NX_VISUALIZATION_SCALE, 1.0f);
sdk->setParameter(NX_VISUALIZE_WORLD_AXES, true);
sdk->setParameter(NX_VISUALIZE_BODY_AXES, true);
sdk->setParameter(NX_VISUALIZE_BODY_MASS_AXES, true);
sdk->setParameter(NX_VISUALIZE_BODY_LIN_VELOCITY, true);
sdk->setParameter(NX_VISUALIZE_BODY_ANG_VELOCITY, true);
sdk->setParameter(NX_VISUALIZE_BODY_JOINT_GROUPS, true);
sdk->setParameter(NX_VISUALIZE_JOINT_LOCAL_AXES, true);
sdk->setParameter(NX_VISUALIZE_JOINT_WORLD_AXES, true);
sdk->setParameter(NX_VISUALIZE_JOINT_LIMITS, true);
sdk->setParameter(NX_VISUALIZE_CONTACT_POINT, true);
sdk->setParameter(NX_VISUALIZE_CONTACT_NORMAL, true);
sdk->setParameter(NX_VISUALIZE_CONTACT_ERROR, true);
sdk->setParameter(NX_VISUALIZE_CONTACT_FORCE, true);
sdk->setParameter(NX_VISUALIZE_ACTOR_AXES, true);
sdk->setParameter(NX_VISUALIZE_COLLISION_AABBS, true);
sdk->setParameter(NX_VISUALIZE_COLLISION_SHAPES, true);
sdk->setParameter(NX_VISUALIZE_COLLISION_AXES, true);
sdk->setParameter(NX_VISUALIZE_COLLISION_COMPOUNDS, true);
sdk->setParameter(NX_VISUALIZE_COLLISION_VNORMALS, true);
sdk->setParameter(NX_VISUALIZE_COLLISION_FNORMALS, true);
sdk->setParameter(NX_VISUALIZE_COLLISION_EDGES, true);
sdk->setParameter(NX_VISUALIZE_COLLISION_SPHERES, true);
#if (NX_SDK_VERSION_NUMBER < 280)
sdk->setParameter(NX_VISUALIZE_COLLISION_SAP, true);
#endif
sdk->setParameter(NX_VISUALIZE_COLLISION_STATIC, true);
sdk->setParameter(NX_VISUALIZE_COLLISION_DYNAMIC, true);
sdk->setParameter(NX_VISUALIZE_COLLISION_FREE, true);
sdk->setParameter(NX_VISUALIZE_COLLISION_CCD, true);
sdk->setParameter(NX_VISUALIZE_COLLISION_SKELETONS, true);
sdk->setParameter(NX_VISUALIZE_FLUID_EMITTERS, true);
sdk->setParameter(NX_VISUALIZE_FLUID_POSITION, true);
sdk->setParameter(NX_VISUALIZE_FLUID_VELOCITY, true);
sdk->setParameter(NX_VISUALIZE_FLUID_KERNEL_RADIUS, true);
sdk->setParameter(NX_VISUALIZE_FLUID_BOUNDS, true);
sdk->setParameter(NX_VISUALIZE_FLUID_PACKETS, true);
sdk->setParameter(NX_VISUALIZE_FLUID_MOTION_LIMIT, true);
sdk->setParameter(NX_VISUALIZE_FLUID_DYN_COLLISION, true);
sdk->setParameter(NX_VISUALIZE_FLUID_STC_COLLISION, true);
sdk->setParameter(NX_VISUALIZE_FLUID_MESH_PACKETS, true);
sdk->setParameter(NX_VISUALIZE_FLUID_DRAINS, true);
sdk->setParameter(NX_VISUALIZE_FLUID_PACKET_DATA, true);
sdk->setParameter(NX_VISUALIZE_CLOTH_MESH, true);
sdk->setParameter(NX_VISUALIZE_CLOTH_COLLISIONS, true);
sdk->setParameter(NX_VISUALIZE_CLOTH_SELFCOLLISIONS, true);
sdk->setParameter(NX_VISUALIZE_CLOTH_WORKPACKETS, true);
sdk->setParameter(NX_VISUALIZE_CLOTH_SLEEP, true);
sdk->setParameter(NX_VISUALIZE_CLOTH_TEARABLE_VERTICES, true);
sdk->setParameter(NX_VISUALIZE_CLOTH_TEARING, true);
sdk->setParameter(NX_VISUALIZE_CLOTH_ATTACHMENT, true);
sdk->setParameter(NX_VISUALIZE_SOFTBODY_MESH, true);
sdk->setParameter(NX_VISUALIZE_SOFTBODY_COLLISIONS, true);
sdk->setParameter(NX_VISUALIZE_SOFTBODY_WORKPACKETS, true);
sdk->setParameter(NX_VISUALIZE_SOFTBODY_SLEEP, true);
sdk->setParameter(NX_VISUALIZE_SOFTBODY_TEARABLE_VERTICES, true);
sdk->setParameter(NX_VISUALIZE_SOFTBODY_TEARING, true);
sdk->setParameter(NX_VISUALIZE_SOFTBODY_ATTACHMENT, true);
}
Data(bool useHardware, bool useHardwareOnly, bool useMultithreading, PhysicsParams *params)
: sdk(0),
scene(0),
crashed(false),
statsNumActors(0),
statsNumDynamicActors(0),
statsNumDynamicActorsInAwakeGroups(0),
statsMaxDynamicActorsInAwakeGroups(0),
statsSimulationTime(0),
statsSimulationWaitTime(0),
statsSimulationStartWaitTime(0),
startSimulationTime(0),
statsContacts(0),
ccd(false),
ccdMaxThickness(0.5f),
runningInHardware(false),
physicslib_fluid_containment_actor(0),
physicslib_fluid_containment_shape(0),
physicslib_fluid_containment_sphere_actor(0),
physicslib_fluid_containment_sphere_shape(0)
{
if (params == NULL)
{
params = &physics_defaultParams;
::Logger::getInstance()->debug("PhysicsLib - No physics params given, using defaults.");
}
if (params->scriptRunner == NULL)
{
::Logger::getInstance()->warning("PhysicsLib - No script runner given, collision groups, etc. will be initialized to default values.");
}
NxPhysicsSDKDesc sdkDesc;
if(!useHardware)
sdkDesc.flags |= NX_SDKF_NO_HARDWARE;
sdk = NxCreatePhysicsSDK(NX_PHYSICS_SDK_VERSION, 0, getLogger(), sdkDesc);
//sdk = NxCreatePhysicsSDK(NX_PHYSICS_SDK_VERSION);
// HACK: ...
physxSDK = sdk;
if(sdk)
{
if(sdk->getHWVersion() == NX_HW_VERSION_NONE)
useHardware = false;
if (params->ccd)
{
sdk->setParameter(NX_CONTINUOUS_CD, true);
sdk->setParameter(NX_CCD_EPSILON, 0.001f);
}
this->ccd = params->ccd;
this->ccdMaxThickness = params->ccdMaxThickness;
NxSceneDesc sceneDesc;
sceneDesc.gravity = NxVec3(params->gravity.x, params->gravity.y, params->gravity.z);
sceneDesc.userContactReport = &contactReport;
//sceneDesc.userNotify = &userNotify;
if(useHardware)
{
sceneDesc.simType = NX_SIMULATION_HW;
if (useHardwareOnly)
{
sceneDesc.flags |= NX_SF_RESTRICTED_SCENE;
}
}
else
{
sceneDesc.simType = NX_SIMULATION_SW;
}
if (!useMultithreading)
{
// Disable threading
sceneDesc.flags = 0;
}
runningInHardware = useHardware;
sceneDesc.flags |= NX_SF_ENABLE_ACTIVETRANSFORMS;
scene = sdk->createScene(sceneDesc);
if(scene)
{
NxMaterial *defaultMaterial = scene->getMaterialFromIndex(0);
defaultMaterial->setStaticFriction(params->defaultStaticFriction);
defaultMaterial->setDynamicFriction(params->defaultDynamicFriction);
defaultMaterial->setRestitution(params->defaultRestitution);
#ifdef PROJECT_CLAW_PROTO
// Create material for cops (larger friction, no restitution)
NxMaterialDesc materialDesc;
materialDesc.restitution = 0.0f;
materialDesc.restitutionCombineMode = NX_CM_MIN;
materialDesc.staticFriction = 10.0f;
materialDesc.dynamicFriction = 10.0f;
unitMaterial = scene->createMaterial(materialDesc);
#endif
sdk->setParameter(NX_VISUALIZATION_SCALE, 1.f);
#ifndef PROJECT_SHADOWGROUNDS
sdk->setParameter(NX_SKIN_WIDTH, 0.01f);
#endif
// NEW: the new scriptable collision/contact group initialization
int contactFlags1 = NX_NOTIFY_ON_START_TOUCH | NX_NOTIFY_ON_TOUCH | NX_NOTIFY_FORCES;
#ifdef PHYSICS_FEEDBACK
int contactFlags2 = NX_NOTIFY_ON_START_TOUCH | NX_NOTIFY_ON_TOUCH | NX_NOTIFY_FORCES;
#else
int contactFlags2 = NX_NOTIFY_ON_START_TOUCH | NX_NOTIFY_FORCES;
#endif
if (params->scriptRunner != NULL)
{
bool ok = params->scriptRunner->runPhysicsLibScript("physics_init", "set_contacts");
if (!ok)
::Logger::getInstance()->error("PhysicsLib - Failed to run physics_init:set_contacts script (script/sub may not be loaded or did not return expected value).");
}
for (int i = 0; i < PHYSICS_MAX_COLLISIONGROUPS; i++)
{
for (int j = 0; j < PHYSICS_MAX_COLLISIONGROUPS; j++)
{
if (physicslib_group_cont[i][j] != physicslib_group_cont[j][i])
{
::Logger::getInstance()->error("PhysicsLib - Improperly mirrored physics contacts data (group1 -> group2 does not have same flag as group2 -> group1).");
::Logger::getInstance()->debug("contacts data group numbers follow:");
::Logger::getInstance()->debug(int2str(i));
::Logger::getInstance()->debug(int2str(j));
}
if (physicslib_group_cont[i][j] == PHYSICSLIB_GROUP_CONTACT_FLAGS1)
scene->setActorGroupPairFlags(i, j, contactFlags1);
else if (physicslib_group_cont[i][j] == PHYSICSLIB_GROUP_CONTACT_FLAGS2)
scene->setActorGroupPairFlags(i, j, contactFlags2);
}
}
if (params->scriptRunner != NULL)
{
bool ok = params->scriptRunner->runPhysicsLibScript("physics_init", "set_collisions");
if (!ok)
::Logger::getInstance()->error("PhysicsLib - Failed to run physics_init:set_collision script (script/sub may not be loaded or did not return expected value).");
}
for (int i = 0; i < PHYSICS_MAX_COLLISIONGROUPS; i++)
{
for (int j = 0; j < PHYSICS_MAX_COLLISIONGROUPS; j++)
{
if (physicslib_group_coll[i][j] != physicslib_group_coll[j][i])
{
::Logger::getInstance()->error("PhysicsLib - Improperly mirrored physics collision data (group1 -> group2 does not have same flag as group2 -> group1).");
::Logger::getInstance()->debug("collision data group numbers follow:");
::Logger::getInstance()->debug(int2str(i));
::Logger::getInstance()->debug(int2str(j));
}
scene->setGroupCollisionFlag(i, j, physicslib_group_coll[i][j]);
}
}
// OLD SCHEISSE...
/*
// Contact groups
{
int contactFlags1 = NX_NOTIFY_ON_START_TOUCH | NX_NOTIFY_ON_TOUCH | NX_NOTIFY_FORCES;
#ifdef PHYSICS_FEEDBACK
int contactFlags2 = NX_NOTIFY_ON_START_TOUCH | NX_NOTIFY_ON_TOUCH | NX_NOTIFY_FORCES;
#else
int contactFlags2 = NX_NOTIFY_ON_START_TOUCH | NX_NOTIFY_FORCES;
#endif
//int contactFlags3 = NX_NOTIFY_ON_START_TOUCH | NX_NOTIFY_FORCES;
scene->setActorGroupPairFlags(PHYSICS_COLLISIONGROUP_STATIC, PHYSICS_COLLISIONGROUP_MODEL_PARTICLES_WO_UNIT_COLL, contactFlags2);
scene->setActorGroupPairFlags(PHYSICS_COLLISIONGROUP_STATIC, PHYSICS_COLLISIONGROUP_MODEL_PARTICLES, contactFlags2);
scene->setActorGroupPairFlags(PHYSICS_COLLISIONGROUP_STATIC, PHYSICS_COLLISIONGROUP_DYNAMIC_TERRAINOBJECTS, contactFlags1);
scene->setActorGroupPairFlags(PHYSICS_COLLISIONGROUP_MODEL_PARTICLES_WO_UNIT_COLL, PHYSICS_COLLISIONGROUP_DYNAMIC_TERRAINOBJECTS, contactFlags2);
scene->setActorGroupPairFlags(PHYSICS_COLLISIONGROUP_MODEL_PARTICLES, PHYSICS_COLLISIONGROUP_DYNAMIC_TERRAINOBJECTS, contactFlags2);
//scene->setActorGroupPairFlags(PHYSICS_COLLISIONGROUP_DYNAMIC_TERRAINOBJECTS, PHYSICS_COLLISIONGROUP_DYNAMIC_TERRAINOBJECTS, contactFlags2);
scene->setActorGroupPairFlags(PHYSICS_COLLISIONGROUP_DYNAMIC_TERRAINOBJECTS, PHYSICS_COLLISIONGROUP_DYNAMIC_TERRAINOBJECTS, contactFlags1);
scene->setActorGroupPairFlags(PHYSICS_COLLISIONGROUP_DYNAMIC_TERRAINOBJECTS, PHYSICS_COLLISIONGROUP_UNITS, contactFlags2);
scene->setActorGroupPairFlags(PHYSICS_COLLISIONGROUP_STATIC, PHYSICS_COLLISIONGROUP_UNITS, contactFlags2);
scene->setActorGroupPairFlags(PHYSICS_COLLISIONGROUP_CLAW, PHYSICS_COLLISIONGROUP_STATIC, contactFlags1);
//scene->setActorGroupPairFlags(PHYSICS_COLLISIONGROUP_DYNAMIC_TERRAINOBJECTS, PHYSICS_COLLISIONGROUP_UNITS, contactFlags3);
}
// Collision groups
{
// claw
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_CLAW, PHYSICS_COLLISIONGROUP_CLAW, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_CLAW, PHYSICS_COLLISIONGROUP_NOCOLLISION, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_NOCOLLISION, PHYSICS_COLLISIONGROUP_CLAW, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_CLAW, PHYSICS_COLLISIONGROUP_MODEL_PARTICLES_WO_UNIT_COLL, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_CLAW, PHYSICS_COLLISIONGROUP_MODEL_PARTICLES, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_CLAW, PHYSICS_COLLISIONGROUP_MODEL_PARTICLES_WO_UNIT_COLL_NO_SOUND, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_CLAW, PHYSICS_COLLISIONGROUP_MODEL_PARTICLES_NO_SOUND, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_CLAW, PHYSICS_COLLISIONGROUP_FLUID_CONTAINMENT_PLANES, false);
// Model particles
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_MODEL_PARTICLES_WO_UNIT_COLL, PHYSICS_COLLISIONGROUP_MODEL_PARTICLES_WO_UNIT_COLL, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_MODEL_PARTICLES_WO_UNIT_COLL, PHYSICS_COLLISIONGROUP_MODEL_PARTICLES, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_MODEL_PARTICLES_WO_UNIT_COLL, PHYSICS_COLLISIONGROUP_MODEL_PARTICLES_WO_UNIT_COLL_NO_SOUND, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_MODEL_PARTICLES_WO_UNIT_COLL, PHYSICS_COLLISIONGROUP_MODEL_PARTICLES_NO_SOUND, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_MODEL_PARTICLES, PHYSICS_COLLISIONGROUP_MODEL_PARTICLES, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_MODEL_PARTICLES, PHYSICS_COLLISIONGROUP_MODEL_PARTICLES_WO_UNIT_COLL_NO_SOUND, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_MODEL_PARTICLES, PHYSICS_COLLISIONGROUP_MODEL_PARTICLES_NO_SOUND, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_MODEL_PARTICLES_WO_UNIT_COLL_NO_SOUND, PHYSICS_COLLISIONGROUP_MODEL_PARTICLES_WO_UNIT_COLL_NO_SOUND, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_MODEL_PARTICLES_WO_UNIT_COLL_NO_SOUND, PHYSICS_COLLISIONGROUP_MODEL_PARTICLES_NO_SOUND, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_MODEL_PARTICLES_NO_SOUND, PHYSICS_COLLISIONGROUP_MODEL_PARTICLES_NO_SOUND, false);
// Doors
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_DOORS, PHYSICS_COLLISIONGROUP_DOORS, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_DOORS, PHYSICS_COLLISIONGROUP_STATIC, false);
// Units and model particles
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_UNITS, PHYSICS_COLLISIONGROUP_MODEL_PARTICLES_WO_UNIT_COLL_NO_SOUND, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_UNITS, PHYSICS_COLLISIONGROUP_MODEL_PARTICLES_WO_UNIT_COLL, false);
// Fluids
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_FLUIDS, PHYSICS_COLLISIONGROUP_MODEL_PARTICLES_WO_UNIT_COLL, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_FLUIDS, PHYSICS_COLLISIONGROUP_MODEL_PARTICLES, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_FLUIDS, PHYSICS_COLLISIONGROUP_MODEL_PARTICLES_WO_UNIT_COLL_NO_SOUND, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_FLUIDS, PHYSICS_COLLISIONGROUP_MODEL_PARTICLES_NO_SOUND, false);
// Fluids w/ detailed collision
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_FLUIDS_DETAILED, PHYSICS_COLLISIONGROUP_MODEL_PARTICLES_WO_UNIT_COLL, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_FLUIDS_DETAILED, PHYSICS_COLLISIONGROUP_MODEL_PARTICLES, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_FLUIDS_DETAILED, PHYSICS_COLLISIONGROUP_MODEL_PARTICLES_WO_UNIT_COLL_NO_SOUND, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_FLUIDS_DETAILED, PHYSICS_COLLISIONGROUP_MODEL_PARTICLES_NO_SOUND, false);
// Fluid containment
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_FLUID_CONTAINMENT_PLANES, PHYSICS_COLLISIONGROUP_STATIC, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_FLUID_CONTAINMENT_PLANES, PHYSICS_COLLISIONGROUP_MODEL_PARTICLES_WO_UNIT_COLL, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_FLUID_CONTAINMENT_PLANES, PHYSICS_COLLISIONGROUP_MODEL_PARTICLES, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_FLUID_CONTAINMENT_PLANES, PHYSICS_COLLISIONGROUP_MODEL_PARTICLES_WO_UNIT_COLL_NO_SOUND, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_FLUID_CONTAINMENT_PLANES, PHYSICS_COLLISIONGROUP_MODEL_PARTICLES_NO_SOUND, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_FLUID_CONTAINMENT_PLANES, PHYSICS_COLLISIONGROUP_UNITS, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_FLUID_CONTAINMENT_PLANES, PHYSICS_COLLISIONGROUP_DOORS, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_FLUID_CONTAINMENT_PLANES, PHYSICS_COLLISIONGROUP_DYNAMIC_TERRAINOBJECTS, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_FLUID_CONTAINMENT_PLANES, PHYSICS_COLLISIONGROUP_FLUID_CONTAINMENT_PLANES, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_FLUID_CONTAINMENT_PLANES, PHYSICS_COLLISIONGROUP_FLUIDS_DETAILED, false);
// No collision
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_NOCOLLISION, PHYSICS_COLLISIONGROUP_STATIC, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_NOCOLLISION, PHYSICS_COLLISIONGROUP_MODEL_PARTICLES_WO_UNIT_COLL, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_NOCOLLISION, PHYSICS_COLLISIONGROUP_MODEL_PARTICLES, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_NOCOLLISION, PHYSICS_COLLISIONGROUP_MODEL_PARTICLES_WO_UNIT_COLL_NO_SOUND, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_NOCOLLISION, PHYSICS_COLLISIONGROUP_MODEL_PARTICLES_NO_SOUND, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_NOCOLLISION, PHYSICS_COLLISIONGROUP_UNITS, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_NOCOLLISION, PHYSICS_COLLISIONGROUP_DOORS, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_NOCOLLISION, PHYSICS_COLLISIONGROUP_DYNAMIC_TERRAINOBJECTS, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_NOCOLLISION, PHYSICS_COLLISIONGROUP_FLUID_CONTAINMENT_PLANES, false);
scene->setGroupCollisionFlag(PHYSICS_COLLISIONGROUP_NOCOLLISION, PHYSICS_COLLISIONGROUP_NOCOLLISION, false);
}
*/
}
}
}
int main(int argc, char **argv)
{
//init and PVD
bool initialized = false;
NxPhysicsSDK *physicsSDK = NxCreatePhysicsSDK(NX_PHYSICS_SDK_VERSION);
if (!physicsSDK)
return 0;
else
physicsSDK->getFoundationSDK().getRemoteDebugger()->connect("localhost", 5425);
physicsSDK->setParameter(NX_CONTINUOUS_CD, true);
initialized = true;
//create a scene
bool sceneInit = false;
NxSceneDesc sceneDesc;
sceneDesc.gravity.set(0, -9.81f, 0);
gScene = physicsSDK->createScene(sceneDesc);
if (gScene != NULL)
sceneInit = true;
//create a plane
{
NxActorDesc actorDesc;
NxPlaneShapeDesc planeDesc;
//planeDesc.normal = NxVec3(0, 0, 1);
//planeDesc.d = -10.0f;
actorDesc.shapes.pushBack(&planeDesc);
gScene->createActor(actorDesc);
}
//create material
NxMaterial *defaultMaterial = gScene->getMaterialFromIndex(0);
defaultMaterial->setRestitution(0.3f);
defaultMaterial->setStaticFriction(0.5f);
defaultMaterial->setDynamicFriction(0.5f);
//create a box
{
NxActorDesc actorDesc;
NxBodyDesc bodyDesc;
bodyDesc.angularDamping = 0.5;
bodyDesc.linearVelocity = NxVec3(1, 0, 0);
actorDesc.body = &bodyDesc;
NxBoxShapeDesc boxDesc;
boxDesc.dimensions = NxVec3(2.0f, 3.0f, 4.0f);
actorDesc.shapes.pushBack(&boxDesc);
actorDesc.density = 10.0f;
actorDesc.globalPose.t = NxVec3(10.0f, 10.0f, 10.0f);
gScene->createActor(actorDesc)->userData = NULL;
}
//create a cloth
{
// Create the objects in the scene
NxActor* sphere1 = CreateSphere(NxVec3(-1, 0, -0.5), 1, 10);
NxActor* box1 = CreateBox(NxVec3(1, 0, -1), NxVec3(1, 1, 1), 10);
NxActor* box2 = CreateBox(NxVec3(0, 6.5, 0), NxVec3(5, 0.5, 0.5), 10);
NxActor* box3 = CreateBox(NxVec3(0, 6.5, -7), NxVec3(5, 0.5, 0.5), 10);
box2->setLinearDamping(5);
box3->setLinearDamping(5);
NxD6JointDesc d6Desc;
d6Desc.actor[0] = NULL;
d6Desc.actor[1] = box2;
NxVec3 globalAnchor(0, 7, 0);
d6Desc.localAnchor[0] = globalAnchor;
box2->getGlobalPose().multiplyByInverseRT(globalAnchor, d6Desc.localAnchor[1]);
box2->raiseBodyFlag(NX_BF_DISABLE_GRAVITY);
box3->getGlobalPose().multiplyByInverseRT(globalAnchor, d6Desc.localAnchor[1]);
box3->raiseBodyFlag(NX_BF_DISABLE_GRAVITY);
d6Desc.localAxis[0] = NxVec3(1, 0, 0);
d6Desc.localNormal[0] = NxVec3(0, 1, 0);
d6Desc.localAxis[1] = NxVec3(1, 0, 0);
d6Desc.localNormal[1] = NxVec3(0, 1, 0);
d6Desc.twistMotion = NX_D6JOINT_MOTION_LOCKED;
d6Desc.swing1Motion = NX_D6JOINT_MOTION_LOCKED;
d6Desc.swing2Motion = NX_D6JOINT_MOTION_LOCKED;
d6Desc.xMotion = NX_D6JOINT_MOTION_FREE;
d6Desc.yMotion = NX_D6JOINT_MOTION_FREE;
d6Desc.zMotion = NX_D6JOINT_MOTION_FREE;
NxJoint* d6Joint = gScene->createJoint(d6Desc);
NxClothDesc clothDesc;
clothDesc.globalPose.t = NxVec3(4, 7, 0);
clothDesc.thickness = 0.2;
//clothDesc.density = 1;
clothDesc.bendingStiffness = 0.5;
clothDesc.stretchingStiffness = 1;
//clothDesc.dampingCoefficient = 0.5;
clothDesc.friction = 0.5;
//clothDesc.collisionResponseCoefficient = 1;
//clothDesc.attachmentResponseCoefficient = 1;
//clothDesc.solverIterations = 5;
//clothDesc.flags |= NX_CLF_STATIC;
//clothDesc.flags |= NX_CLF_DISABLE_COLLISION;
//clothDesc.flags |= NX_CLF_VISUALIZATION;
//clothDesc.flags |= NX_CLF_GRAVITY;
clothDesc.flags |= NX_CLF_BENDING;
//clothDesc.flags |= NX_CLF_BENDING_ORTHO;
clothDesc.flags |= NX_CLF_DAMPING;
//clothDesc.flags |= NX_CLF_COMDAMPING;
clothDesc.flags |= NX_CLF_COLLISION_TWOWAY;
clothDesc.flags &= ~NX_CLF_HARDWARE;
clothDesc.flags |= NX_CLF_FLUID_COLLISION;
clothDesc.selfCollisionThickness = 10.0f;
NxReal w = 8;
NxReal h = 7;
NxReal d = 0.05;
NxClothMeshDesc meshDesc;
bool mInitDone = false;
int numX = (int)(w / d) + 1;
int numY = (int)(h / d) + 1;
meshDesc.numVertices = (numX + 1) * (numY + 1);
meshDesc.numTriangles = numX*numY * 2;
meshDesc.pointStrideBytes = sizeof(NxVec3);
meshDesc.triangleStrideBytes = 3 * sizeof(NxU32);
meshDesc.vertexMassStrideBytes = sizeof(NxReal);
meshDesc.vertexFlagStrideBytes = sizeof(NxU32);
meshDesc.points = (NxVec3*)malloc(sizeof(NxVec3)*meshDesc.numVertices);
meshDesc.triangles = (NxU32*)malloc(sizeof(NxU32)*meshDesc.numTriangles * 3);
meshDesc.vertexMasses = 0;
meshDesc.vertexFlags = 0;
meshDesc.flags = 0;
int i, j;
NxVec3 *p = (NxVec3*)meshDesc.points;
for (i = 0; i <= numY; i++) {
for (j = 0; j <= numX; j++) {
p->set(-d*j, 0.0f, -d*i);
p++;
}
}
NxU32 *id = (NxU32*)meshDesc.triangles;
for (i = 0; i < numY; i++) {
for (j = 0; j < numX; j++) {
NxU32 i0 = i * (numX + 1) + j;
NxU32 i1 = i0 + 1;
NxU32 i2 = i0 + (numX + 1);
NxU32 i3 = i2 + 1;
if ((j + i) % 2) {
*id++ = i0;
*id++ = i2;
*id++ = i1;
*id++ = i1;
*id++ = i2;
*id++ = i3;
}
else {
*id++ = i0;
*id++ = i2;
*id++ = i3;
*id++ = i0;
*id++ = i3;
*id++ = i1;
}
}
}
// if we want tearing we must tell the cooker
// this way it will generate some space for particles that will be generated during tearing
if (meshDesc.flags & NX_CLF_TEARABLE)
meshDesc.flags |= NX_CLOTH_MESH_TEARABLE;
//cooking
static NxCookingInterface *gCooking = 0;
gCooking = NxGetCookingLib(NX_PHYSICS_SDK_VERSION);
gCooking->NxInitCooking();
gCooking->NxCookClothMesh(meshDesc, UserStream("e:\\cooked.bin", false));
//Meshdata Buffers
NxMeshData mReceiveBuffers;
// here we setup the buffers through which the SDK returns the dynamic cloth data
// we reserve more memory for vertices than the initial mesh takes
// because tearing creates new vertices
// the SDK only tears cloth as long as there is room in these buffers
NxU32 numVertices = meshDesc.numVertices;
NxU32 numTriangles = meshDesc.numTriangles;
NxU32 maxVertices = 2 * numVertices;
mReceiveBuffers.verticesPosBegin = (NxVec3*)malloc(sizeof(NxVec3)*maxVertices);
mReceiveBuffers.verticesNormalBegin = (NxVec3*)malloc(sizeof(NxVec3)*maxVertices);
mReceiveBuffers.verticesPosByteStride = sizeof(NxVec3);
mReceiveBuffers.verticesNormalByteStride = sizeof(NxVec3);
mReceiveBuffers.maxVertices = maxVertices;
mReceiveBuffers.numVerticesPtr = (NxU32*)malloc(sizeof(NxU32));
// the number of triangles is constant, even if the cloth is torn
NxU32 maxIndices = 3 * numTriangles;
mReceiveBuffers.indicesBegin = (NxU32*)malloc(sizeof(NxU32)*maxIndices);
mReceiveBuffers.indicesByteStride = sizeof(NxU32);
mReceiveBuffers.maxIndices = maxIndices;
mReceiveBuffers.numIndicesPtr = (NxU32*)malloc(sizeof(NxU32));
// the parent index information would be needed if we used textured cloth
NxU32 maxParentIndices = maxVertices;
mReceiveBuffers.parentIndicesBegin = (NxU32*)malloc(sizeof(NxU32)*maxParentIndices);
mReceiveBuffers.parentIndicesByteStride = sizeof(NxU32);
mReceiveBuffers.maxParentIndices = maxParentIndices;
mReceiveBuffers.numParentIndicesPtr = (NxU32*)malloc(sizeof(NxU32));
// init the buffers in case we want to draw the mesh
// before the SDK as filled in the correct values
*mReceiveBuffers.numVerticesPtr = 0;
*mReceiveBuffers.numIndicesPtr = 0;
clothDesc.clothMesh = physicsSDK->createClothMesh(UserStream("e:\\cooked.bin", true));
clothDesc.meshData = mReceiveBuffers;
NxCloth *mCloth;
mCloth = gScene->createCloth(clothDesc);
mCloth->attachToShape(*box2->getShapes(), NX_CLOTH_ATTACHMENT_TWOWAY);
mCloth->attachToShape(*box3->getShapes(), NX_CLOTH_ATTACHMENT_TWOWAY);
}
//create fluid 1
{
//fluid = CreateFluid(NxVec3(0, 12, -3.5), 15, 0.1, gScene);
}
//create fluid 2
{
//Create a set of initial particles
ParticleSDK* initParticles = new ParticleSDK[max_particles];
unsigned initParticlesNum = 0;
//Create particle filled sphere in buffer.
NxVec3 fluidPos(0, 2, 0);
NxVec3 offsetPos(0, 12, -3.5);
float distance = 0.1f;
//#ifdef __PPCGEKKO__
// unsigned sideNum = 12;
//#else
unsigned sideNum = 16;
//#endif
//Setup structure to pass initial particles.
NxParticleData initParticleData;
initParticlesNum = 0;
initParticleData.numParticlesPtr = &initParticlesNum;
initParticleData.bufferPos = &initParticles[0].position.x;
initParticleData.bufferPosByteStride = sizeof(ParticleSDK);
initParticleData.bufferVel = &initParticles[0].velocity.x;
initParticleData.bufferVelByteStride = sizeof(ParticleSDK);
CreateParticleSphere(initParticleData, max_particles, false, offsetPos, NxVec3(0, 0, 0), 0.0f, distance, sideNum);
//Setup fluid descriptor
NxFluidDesc fluidDesc;
fluidDesc.maxParticles = max_particles;
fluidDesc.kernelRadiusMultiplier = 2.0f;
fluidDesc.restParticlesPerMeter = 10.0f;
fluidDesc.motionLimitMultiplier = 3.0f;
fluidDesc.packetSizeMultiplier = 8;
fluidDesc.collisionDistanceMultiplier = 0.1;
fluidDesc.stiffness = 50.0f;
fluidDesc.viscosity = 40.0f;
fluidDesc.restDensity = 1000.0f;
fluidDesc.damping = 0.0f;
fluidDesc.restitutionForStaticShapes = 0.0f;
fluidDesc.dynamicFrictionForStaticShapes = 0.05f;
fluidDesc.simulationMethod = NX_F_SPH;
fluidDesc.flags &= ~NX_FF_HARDWARE;
//Add initial particles to fluid creation.
fluidDesc.initialParticleData = initParticleData;
//Create user fluid.
//- create NxFluid in NxScene
//- setup the buffers to read from data from the SDK
//- set NxFluid::userData field to MyFluid instance
bool trackUserData = false;
bool provideCollisionNormals = false;
MyFluid* fluid = new MyFluid(gScene, fluidDesc, trackUserData, provideCollisionNormals, NxVec3(0.4f, 0.5f, 0.9f), 0.03f);
assert(fluid);
gMyFluids.pushBack(fluid);
}
//simulate
for (int i = 0; i < 3000; i++)
{
gScene->simulate(1.0f / 60.f);
gScene->flushStream();
//GetPhysicsResults
gScene->fetchResults(NX_RIGID_BODY_FINISHED, true);
// update fluid status
if (i == 400)
{
MyFluid* fluid = gMyFluids[0];
const ParticleSDK* particles = fluid->getParticles();
unsigned particlesNum = fluid->getParticlesNum();
if (!gUpdates)
{
gUpdates = new ParticleUpdateSDK[max_particles];
}
for (unsigned i = 0; i < particlesNum; i++)
{
ParticleUpdateSDK& update = gUpdates[i];
NxVec3& force = update.force;
force.set(0, 0, 0);
NxU32& flags = update.flags;
if (i >= particlesNum/2)
{
flags = 0;
flags |= NX_FP_DELETE;
}
else
{
flags = 0;
}
}
//在这里更改粒子的属性
NxParticleUpdateData updateData;
updateData.bufferFlag = &gUpdates[0].flags;
updateData.bufferFlagByteStride = sizeof(ParticleUpdateSDK);
fluid->getNxFluid()->updateParticles(updateData);
}
}
//release
if (physicsSDK != NULL)
{
if (gScene != NULL)
physicsSDK->releaseScene(*gScene);
gScene = NULL;
NxReleasePhysicsSDK(physicsSDK);
physicsSDK = NULL;
}
return 1;
}
virtual ~CNxPhysConvexMesh() { m_pPhysicsSDK->releaseConvexMesh(*m_pNxConvexMesh); }
bool processMenu(HWND hwnd,unsigned int cmd,NxBounds3 &bounds)
{
bool ret = false;
const char *fname = 0;
bool groundPlane = false;
switch ( cmd )
{
case MO_EXPORT_SURFACE:
if ( 1 )
{
gSoftBodySystem->processCommand(SBC_EXPORT_SURFACE,1,0);
}
break;
case MO_RUN_SCRIPT:
if ( 1 )
{
CPARSER.Parse("PsScript");
}
break;
case MO_IMPORT_OBJ:
gSoftBodySystem->processCommand(SBC_RESET_SCENE,1,0);
gSoftBodySystem->processCommand(SBC_IMPORT_OBJ,1,0);
fname = gSoftBodySystem->getImportName(bounds);
groundPlane = true;
break;
case MO_IMPORT_PSK:
initCallback_LoadSoftMeshPSK();
gSoftBodySystem->processCommand(SBC_RESET_SCENE,1,0);
gSoftBodySystem->processCommand(SBC_IMPORT_PSK,1,0);
fname = gSoftBodySystem->getImportName(bounds);
groundPlane = true;
break;
case MO_IMPORT_EZM:
gSoftBodySystem->processCommand(SBC_RESET_SCENE,1,0);
gSoftBodySystem->processCommand(SBC_IMPORT_EZM,1,0);
fname = gSoftBodySystem->getImportName(bounds);
groundPlane = true;
break;
case MO_IMPORT_XML:
gSoftBodySystem->processCommand(SBC_RESET_SCENE,1,0);
gSoftBodySystem->processCommand(SBC_IMPORT_XML,1,0);
groundPlane = true;
break;
case MO_IMPORT_COLLADA:
gSoftBodySystem->processCommand(SBC_RESET_SCENE,1,0);
gSoftBodySystem->processCommand(SBC_IMPORT_COLLADA,1,0);
groundPlane = true;
break;
case MO_IMPORT_NXB:
gSoftBodySystem->processCommand(SBC_RESET_SCENE,1,0);
gSoftBodySystem->processCommand(SBC_IMPORT_NXB,1,0);
groundPlane = true;
break;
case MO_EXPORT_OBJ:
gSoftBodySystem->processCommand(SBC_EXPORT_OBJ,1,0);
break;
case MO_EXPORT_EZM:
gSoftBodySystem->processCommand(SBC_EXPORT_EZM,1,0);
break;
case MO_EXPORT_XML:
gSoftBodySystem->processCommand(SBC_EXPORT_XML,1,0);
break;
case MO_CORE_DUMP_XML:
gSoftBodySystem->processCommand(SBC_CORE_DUMP_XML,1,0);
break;
case MO_CORE_DUMP_DAE:
gSoftBodySystem->processCommand(SBC_CORE_DUMP_DAE,1,0);
break;
case MO_CORE_DUMP_NXB:
gSoftBodySystem->processCommand(SBC_CORE_DUMP_NXB,1,0);
break;
case MO_EXIT:
SendMessage(hwnd,WM_CLOSE,0,0);
break;
case MO_VISUALIZE_NONE:
if ( 1 )
{
NxPhysicsSDK *sdk = getSDK();
if ( sdk )
{
for (unsigned int i=0; i<MO_VISUALIZE_COUNT; i++)
{
NxParameter p = (NxParameter) (i+NX_VISUALIZE_BODY_AXES);
sdk->setParameter(p,0);
mVstate[i] = 0;
CheckMenuItem(mVisualization, i+1, MF_BYPOSITION | MF_UNCHECKED );
}
}
}
break;
case MO_CORE_DUMP_ACTIVE_STATE:
if ( 1 )
{
NxU32 index = MO_CORE_DUMP_ACTIVE_STATE - MO_IMPORT_OBJ;
if ( gSoftBodySystem->isActiveState() )
{
gSoftBodySystem->setActiveState(false);
CheckMenuItem(mFileMenu, index, MF_BYPOSITION | MF_UNCHECKED );
}
else
{
gSoftBodySystem->setActiveState(true);
CheckMenuItem(mFileMenu, index, MF_BYPOSITION | MF_CHECKED );
}
}
break;
case MO_VISUALIZE_BODY_AXES:
case MO_VISUALIZE_BODY_MASS_AXES:
case MO_VISUALIZE_BODY_LIN_VELOCITY:
case MO_VISUALIZE_BODY_ANG_VELOCITY:
case MO_VISUALIZE_BODY_JOINT_GROUPS:
case MO_VISUALIZE_JOINT_LOCAL_AXES:
case MO_VISUALIZE_JOINT_WORLD_AXES:
case MO_VISUALIZE_JOINT_LIMITS:
case MO_VISUALIZE_CONTACT_POINT:
case MO_VISUALIZE_CONTACT_NORMAL:
case MO_VISUALIZE_CONTACT_ERROR:
case MO_VISUALIZE_CONTACT_FORCE:
case MO_VISUALIZE_ACTOR_AXES:
case MO_VISUALIZE_COLLISION_AABBS:
case MO_VISUALIZE_COLLISION_SHAPES:
case MO_VISUALIZE_COLLISION_AXES:
case MO_VISUALIZE_COLLISION_COMPOUNDS:
case MO_VISUALIZE_COLLISION_VNORMALS:
case MO_VISUALIZE_COLLISION_FNORMALS:
case MO_VISUALIZE_COLLISION_EDGES:
case MO_VISUALIZE_COLLISION_SPHERES:
#if NX_SDK_VERSION_NUMBER < 280
case MO_VISUALIZE_COLLISION_SAP:
#endif
case MO_VISUALIZE_COLLISION_STATIC:
case MO_VISUALIZE_COLLISION_DYNAMIC:
case MO_VISUALIZE_COLLISION_FREE:
case MO_VISUALIZE_COLLISION_CCD:
case MO_VISUALIZE_COLLISION_SKELETONS:
case MO_VISUALIZE_FLUID_EMITTERS:
case MO_VISUALIZE_FLUID_POSITION:
case MO_VISUALIZE_FLUID_VELOCITY:
case MO_VISUALIZE_FLUID_KERNEL_RADIUS:
case MO_VISUALIZE_FLUID_BOUNDS:
case MO_VISUALIZE_FLUID_PACKETS:
case MO_VISUALIZE_FLUID_MOTION_LIMIT:
case MO_VISUALIZE_FLUID_DYN_COLLISION:
#if NX_SDK_VERSION_NUMBER >= 270
case MO_VISUALIZE_FLUID_STC_COLLISION:
case MO_VISUALIZE_FLUID_MESH_PACKETS:
#endif
case MO_VISUALIZE_FLUID_DRAINS:
#if NX_SDK_VERSION_NUMBER >= 270
case MO_VISUALIZE_CLOTH_MESH:
#endif
case MO_VISUALIZE_CLOTH_COLLISIONS:
case MO_VISUALIZE_CLOTH_SELFCOLLISIONS:
case MO_VISUALIZE_CLOTH_WORKPACKETS:
#if NX_SDK_VERSION_NUMBER >= 270
case MO_VISUALIZE_CLOTH_SLEEP:
case MO_VISUALIZE_CLOTH_TEARABLE_VERTICES:
case MO_VISUALIZE_CLOTH_TEARING:
case MO_VISUALIZE_CLOTH_ATTACHMENT:
#endif
#if NX_USE_SOFBODY_API
case MO_VISUALIZE_SOFTBODY_MESH:
case MO_VISUALIZE_SOFTBODY_COLLISIONS:
case MO_VISUALIZE_SOFTBODY_WORKPACKETS:
case MO_VISUALIZE_SOFTBODY_SLEEP:
case MO_VISUALIZE_SOFTBODY_TEARABLE_VERTICES:
case MO_VISUALIZE_SOFTBODY_TEARING:
case MO_VISUALIZE_SOFTBODY_ATTACHMENT:
#endif
if ( 1 )
{
float v;
unsigned int index = cmd - MO_VISUALIZE_BODY_AXES;
if ( mVstate[index] )
{
mVstate[index] = 0;
v = 0;
CheckMenuItem(mVisualization, index+1, MF_BYPOSITION | MF_UNCHECKED );
}
else
{
v = 1;
mVstate[index] = 1;
CheckMenuItem(mVisualization, index+1, MF_BYPOSITION | MF_CHECKED );
}
NxPhysicsSDK *sdk = getSDK();
if ( sdk )
{
NxParameter p = getParameter((MenuOptions)cmd);
sdk->setParameter(p,v);
}
const char *showDebug = "false";
for (unsigned int i=0; i<MO_VISUALIZE_COUNT; i++)
{
if ( mVstate[i] )
{
showDebug = "true";
break;
}
}
const char *argv[2];
argv[0] = "null";
argv[1] = showDebug;
gSoftBodySystem->processCommand(SBC_DEBUG_VISUALIZATION, 2, argv );
}
break;
case MO_STATIC:
case MO_DISABLE_COLLISION:
case MO_SELFCOLLISION:
case MO_VISUALIZATION:
case MO_GRAVITY:
case MO_VOLUME_CONSERVATION:
case MO_DAMPING:
case MO_COLLISION_TWOWAY:
case MO_TEARABLE:
case MO_HARDWARE:
case MO_COMDAMPING:
case MO_FLUID_COLLISION:
if ( 1 )
{
SoftBodyCommand sbc;
switch ( cmd )
{
case MO_STATIC: sbc = SBC_STATIC; break;
case MO_DISABLE_COLLISION: sbc = SBC_DISABLE_COLLISION; break;
case MO_SELFCOLLISION: sbc = SBC_SELFCOLLISION; break;
case MO_VISUALIZATION: sbc = SBC_VISUALIZATION; break;
case MO_GRAVITY: sbc = SBC_GRAVITY; break;
case MO_VOLUME_CONSERVATION: sbc = SBC_VOLUME_CONSERVATION; break;
case MO_DAMPING: sbc = SBC_DAMPING; break;
case MO_COLLISION_TWOWAY: sbc = SBC_COLLISION_TWOWAY; break;
case MO_TEARABLE: sbc = SBC_TEARABLE; break;
case MO_HARDWARE: sbc = SBC_HARDWARE; break;
case MO_COMDAMPING: sbc = SBC_COMDAMPING; break;
case MO_FLUID_COLLISION: sbc = SBC_FLUID_COLLISION; break;
}
const char *argv[2];
argv[0] = "null";
unsigned int index = cmd - MO_DUMMY0;
unsigned int flag = 1<<(index);
if ( mFlags & flag )
{
argv[1] = "false";
mFlags&=~flag;
CheckMenuItem(mSoftbodyFlags, index-1, MF_BYPOSITION | MF_UNCHECKED );
}
else
{
argv[1] = "true";
mFlags|=flag;
CheckMenuItem(mSoftbodyFlags, index-1, MF_BYPOSITION | MF_CHECKED );
}
gSoftBodySystem->processCommand(sbc,2,argv);
}
break;
}
if ( fname )
{
CPARSER.Parse("/cd_mesh \"%s\"",fname );
ret = true;
}
if ( groundPlane )
px_createGroundPlane();
return ret;
}
MyMenu(void)
{
mMainMenu = CreateMenu();
HMENU m = CreatePopupMenu();
mFileMenu = m;
AppendMenu( mMainMenu, MF_POPUP, (UINT_PTR)m, L"&File" );
AppendMenu( m, MF_STRING, MO_IMPORT_OBJ, L"Import Graphics Wavefront OBJ");
AppendMenu( m, MF_STRING, MO_IMPORT_PSK, L"Import Graphics Unreal PSK");
AppendMenu( m, MF_STRING, MO_IMPORT_EZM, L"Import Graphics EZ-Mesh");
AppendMenu( m, MF_STRING, MO_IMPORT_XML, L"Import NxuStream XML");
AppendMenu( m, MF_STRING, MO_IMPORT_COLLADA, L"Import COLLADA DAE");
AppendMenu( m, MF_STRING, MO_IMPORT_NXB, L"Import NxuStream NXB");
AppendMenu( m, MF_STRING, MO_EXPORT_OBJ, L"Export as Wavefront OBJ and TET");
AppendMenu( m, MF_STRING, MO_EXPORT_EZM, L"Export as EZ-Mesh");
AppendMenu( m, MF_STRING, MO_EXPORT_XML, L"Export as NxuStream");
AppendMenu( m, MF_STRING, MO_EXPORT_SURFACE, L"Export Surface Mesh as OBJ");
AppendMenu( m, MF_STRING, MO_CORE_DUMP_XML, L"CoreDump XML");
AppendMenu( m, MF_STRING, MO_CORE_DUMP_NXB, L"CoreDump NXB");
AppendMenu( m, MF_STRING, MO_CORE_DUMP_DAE, L"CoreDump DAE (COLLADA)");
AppendMenu( m, MF_STRING | MF_UNCHECKED, MO_CORE_DUMP_ACTIVE_STATE, L"CoreDump ActiveState");
AppendMenu( m, MF_STRING, MO_RUN_SCRIPT, L"Run Demo Script");
AppendMenu( m, MF_STRING, MO_EXIT, L"E&xit");
#if NX_USE_SOFTBODY_API
m = CreatePopupMenu();
mSoftbodyFlags = m;
AppendMenu( mMainMenu, MF_POPUP, (UINT_PTR)m, L"&SoftBody Flags" );
AppendMenu( m, MF_STRING | MF_UNCHECKED, MO_STATIC, L"SBF_STATIC");
AppendMenu( m, MF_STRING | MF_UNCHECKED, MO_DISABLE_COLLISION, L"SBF_DISABLE_COLLISION");
AppendMenu( m, MF_STRING | MF_UNCHECKED, MO_SELFCOLLISION, L"SBF_SELFCOLLISION");
AppendMenu( m, MF_STRING | MF_CHECKED, MO_VISUALIZATION, L"SBF_VISUALIZATION");
AppendMenu( m, MF_STRING | MF_CHECKED, MO_GRAVITY, L"SBF_GRAVITY");
AppendMenu( m, MF_STRING | MF_CHECKED, MO_VOLUME_CONSERVATION, L"SBF_VOLUME_CONSERVATION");
AppendMenu( m, MF_STRING | MF_UNCHECKED, MO_DAMPING, L"SBF_DAMPING");
AppendMenu( m, MF_STRING | MF_UNCHECKED, MO_COLLISION_TWOWAY, L"SBF_COLLISION_TWOWAY");
AppendMenu( m, MF_STRING | MF_UNCHECKED, MO_TEARABLE, L"SBF_TEARABLE");
AppendMenu( m, MF_STRING | MF_UNCHECKED, MO_HARDWARE, L"SBF_HARDWARE");
AppendMenu( m, MF_STRING | MF_UNCHECKED, MO_COMDAMPING, L"SBF_COMDAMPING");
AppendMenu( m, MF_STRING | MF_UNCHECKED, MO_FLUID_COLLISION, L"SBF_FLUID_COLLISION");
#endif
#if NX_USE_SOFTBODY_API
mFlags = NX_SBF_GRAVITY | NX_SBF_VOLUME_CONSERVATION;
#else
mFlags = 0;
#endif
m = CreatePopupMenu();
mVisualization = m;
AppendMenu( mMainMenu, MF_POPUP, (UINT_PTR)m, L"&Debug Visualization Flags" );
AppendMenu(m,MF_STRING, MO_VISUALIZE_NONE,L"VISUALIZE NONE");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_BODY_AXES,L"BODY_AXES");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_BODY_MASS_AXES,L"BODY_MASS_AXES");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_BODY_LIN_VELOCITY,L"BODY_LIN_VELOCITY");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_BODY_ANG_VELOCITY,L"BODY_ANG_VELOCITY");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_BODY_JOINT_GROUPS,L"BODY_JOINT_GROUPS");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_JOINT_LOCAL_AXES,L"JOINT_LOCAL_AXES");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_JOINT_WORLD_AXES,L"JOINT_WORLD_AXES");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_JOINT_LIMITS,L"JOINT_LIMITS");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_CONTACT_POINT,L"CONTACT_POINT");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_CONTACT_NORMAL,L"CONTACT_NORMAL");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_CONTACT_ERROR,L"CONTACT_ERROR");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_CONTACT_FORCE,L"CONTACT_FORCE");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_ACTOR_AXES,L"ACTOR_AXES");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_COLLISION_AABBS,L"COLLISION_AABBS");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_COLLISION_SHAPES,L"COLLISION_SHAPES");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_COLLISION_AXES,L"COLLISION_AXES");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_COLLISION_COMPOUNDS,L"COLLISION_COMPOUNDS");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_COLLISION_VNORMALS,L"COLLISION_VNORMALS");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_COLLISION_FNORMALS,L"COLLISION_FNORMALS");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_COLLISION_EDGES,L"COLLISION_EDGES");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_COLLISION_SPHERES,L"COLLISION_SPHERES");
#if NX_SDK_VERSION_NUMBER < 280
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_COLLISION_SAP,L"COLLISION_SAP");
#endif
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_COLLISION_STATIC,L"COLLISION_STATIC");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_COLLISION_DYNAMIC,L"COLLISION_DYNAMIC");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_COLLISION_FREE,L"COLLISION_FREE");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_COLLISION_CCD,L"COLLISION_CCD");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_COLLISION_SKELETONS,L"COLLISION_SKELETONS");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_FLUID_EMITTERS,L"FLUID_EMITTERS");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_FLUID_POSITION,L"FLUID_POSITION");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_FLUID_VELOCITY,L"FLUID_VELOCITY");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_FLUID_KERNEL_RADIUS,L"FLUID_KERNEL_RADIUS");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_FLUID_BOUNDS,L"FLUID_BOUNDS");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_FLUID_PACKETS,L"FLUID_PACKETS");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_FLUID_MOTION_LIMIT,L"FLUID_MOTION_LIMIT");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_FLUID_DYN_COLLISION,L"FLUID_DYN_COLLISION");
#if NX_SDK_VERSION_NUMBER >= 270
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_FLUID_STC_COLLISION,L"FLUID_STC_COLLISION");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_FLUID_MESH_PACKETS,L"FLUID_MESH_PACKETS");
#endif
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_FLUID_DRAINS,L"FLUID_DRAINS");
#if NX_SDK_VERSION_NUMBER >= 270
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_CLOTH_MESH,L"CLOTH_MESH");
#endif
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_CLOTH_COLLISIONS,L"CLOTH_COLLISIONS");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_CLOTH_SELFCOLLISIONS,L"CLOTH_SELFCOLLISIONS");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_CLOTH_WORKPACKETS,L"CLOTH_WORKPACKETS");
#if NX_SDK_VERSION_NUMBER >= 270
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_CLOTH_SLEEP,L"CLOTH_SLEEP");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_CLOTH_TEARABLE_VERTICES,L"CLOTH_TEARABLE_VERTICES");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_CLOTH_TEARING,L"CLOTH_TEARING");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_CLOTH_ATTACHMENT,L"CLOTH_ATTACHMENT");
#endif
#if NX_USE_SOFTBODY_API
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_SOFTBODY_MESH,L"SOFTBODY_MESH");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_SOFTBODY_COLLISIONS,L"SOFTBODY_COLLISIONS");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_SOFTBODY_WORKPACKETS,L"SOFTBODY_WORKPACKETS");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_SOFTBODY_SLEEP,L"SOFTBODY_SLEEP");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_SOFTBODY_TEARABLE_VERTICES,L"SOFTBODY_TEARABLE_VERTICES");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_SOFTBODY_TEARING,L"SOFTBODY_TEARING");
AppendMenu(m,MF_STRING | MF_UNCHECKED, MO_VISUALIZE_SOFTBODY_ATTACHMENT,L"SOFTBODY_ATTACHMENT");
#endif
memset(mVstate,0,sizeof(char)*MO_VISUALIZE_COUNT);
NxPhysicsSDK *sdk = getSDK();
if ( sdk )
{
for (unsigned int i=0; i<MO_VISUALIZE_COUNT; i++)
{
NxParameter p = (NxParameter) (i+NX_VISUALIZE_BODY_AXES);
sdk->setParameter(p,0);
}
}
// ok, now initialize the scripted menu interface.
gAllGlobals.gFileSystem.set(this);
Log* tmpLog = new Log("TetraMaker.txt");
gAllGlobals.gLog.set(tmpLog);
CommandParser* tmpCommandParser = new CommandParser;
TextUserInterface* tmpTui = new TextUserInterface("TetraMaker.tui");
//
AddToken("CreateDynamics", MC_CREATE_DYNAMICS );
AddToken("PsScript", MC_PSSCRIPT);
AddToken("PsLookAt", MC_PSLOOKAT);
AddToken("SbcImport", SBC_IMPORT);
#if NX_USE_SOFTBODY_API
AddToken("SbcSoftBody", SBC_SOFTBODY);
createButton("Simulate Soft Body", SBC_SIMULATE_SOFTBODY, "SbcSimulateSoftBody");
createButton("Stop Simulation", SBC_STOP_SIMULATION, "SbcStopSimuation");
createButton("New SoftBody", SBC_NEW_SOFTBODY, "SbcNewSoftBody");
createButton("SceneReset", SBC_RESET_SCENE, "SbcResetScene");
createSlider("Volume", SBC_VOLUME_STIFFNESS, "SbcVolumeStiffness",0,1,1);
createSlider("Stretching",SBC_STRETCHING_STIFFNESS,"SbcStretchingStiffness",0,1,1);
createSlider("Damping" ,SBC_DAMPING_COEFFICIENT, "SbcDampingCoefficient",0,1,0.5f);
createSlider("Friction", SBC_FRICTION, "SbcFriction", 0,1,0.5f);
createSlider("ParticleRadius", SBC_PARTICLE_RADIUS, "SbcParticleRadius", 0.001f,0.5f,0.01f);
createSlider("SolverIterations", SBC_SOLVER_ITERATIONS, "SbcSolverIterations",1,32,5);
createCheckbox("SHOW_TETRAHEDRA", SBC_SHOW_TETRAHEDRA, "SbcShowTetrahedra",false);
createCheckbox("SHOW_OVERLAY", SBC_SHOW_OVERLAY, "SbcShowOverlay",false);
createCheckbox("SHOW_GRAPHICS_MESH", SBC_SHOW_GRAPHICS_MESH, "SbcShowGraphicsMesh",true);
createCheckbox("SHOW_BACKFACES", SBC_SHOW_BACKFACES, "SbcShowBackfaces",false);
// createCheckbox("RAYCAST_OK", SBC_RAYCAST_OK, "SbcRaycastOk",true);
createSlider("SubdivisionLevel",SBC_SUBDIVISION_LEVEL, "SbcSubdivisionLevel", 1, 90, 20);
createSlider("Mesh Detail", SBC_MESH_DETAIL, "SbcMeshDetail", 10, 100, 50 );
createButton("Generate Volume", SBC_GENERATE_VOLUME, "SbcGenerateVolume");
createButton("Copy Surface", SBC_COPY_SURFACE, "SbcCopySurface");
createButton("Iso Surface", SBC_ISO_SURFACE, "SbcIsoSurface");
createCheckbox("IsoSingle", SBC_ISO_SINGLE, "SbcIsoSingle",true);
createCheckbox("Asynchronous", MC_ASYNC, "SbcAsync", true );
createSlider("Gravity", MC_GRAVITY, "SbcGravity", -40, 40, -9.8f );
createSlider("TimeScale", MC_TIME_SCALE, "SbcTimeScale", 0, 4, 1 );
CPARSER.Parse("TuiPageBegin SoftBodies");
CPARSER.Parse("TuiName \"SoftBody Meshes\"");
// CPARSER.Parse("TuiElement top");
CPARSER.Parse("TuiElement SbcSimulateSoftBody");
CPARSER.Parse("TuiElement SbcStopSimuation");
CPARSER.Parse("TuiElement SbcNewSoftBody");
CPARSER.Parse("TuiElement SbcResetScene");
CPARSER.Parse("TuiElement SbcVolumeStiffness");
CPARSER.Parse("TuiElement SbcStretchingStiffness");
CPARSER.Parse("TuiElement SbcDampingCoefficient");
CPARSER.Parse("TuiElement SbcFriction");
CPARSER.Parse("TuiElement SbcParticleRadius");
CPARSER.Parse("TuiElement SbcSolverIterations");
CPARSER.Parse("TuiElement SbcStatic");
CPARSER.Parse("TuiElement SbcDisableCollision");
CPARSER.Parse("TuiElement SbcSelfCollision");
CPARSER.Parse("TuiElement SbcVisualization");
CPARSER.Parse("TuiElement SbcGravity");
CPARSER.Parse("TuiElement SbcVolumeConservation");
CPARSER.Parse("TuiElement SbcDamping");
CPARSER.Parse("TuiElement SbcCollisionTwoWay");
CPARSER.Parse("TuiElement SbcTearable");
CPARSER.Parse("TuiElement SbcComDamping");
CPARSER.Parse("TuiElement SbcFluidCollision");
CPARSER.Parse("TuiElement SbcShowTetrahedra");
CPARSER.Parse("TuiElement SbcShowOverlay");
CPARSER.Parse("TuiElement SbcShowGraphicsMesh");
CPARSER.Parse("TuiElement SbcShowBackfaces");
CPARSER.Parse("TuiElement SbcRaycastOk");
CPARSER.Parse("TuiElement SbcSubdivisionLevel");
CPARSER.Parse("TuiElement SbcMeshDetail");
CPARSER.Parse("TuiElement SbcGenerateVolume");
CPARSER.Parse("TuiElement SbcCopySurface");
CPARSER.Parse("TuiElement SbcIsoSurface");
CPARSER.Parse("TuiElement SbcIsoSingle");
CPARSER.Parse("TuiElement SbcAsync");
CPARSER.Parse("TuiElement SbcGravity");
CPARSER.Parse("TuiElement SbcTimeScale");
CPARSER.Parse("TuiElement CreateDynamics");
CPARSER.Parse("TuiEnd");
#else
CPARSER.Parse("TuiPage CreateDynamics");
#endif
CPARSER.Parse("TuiLoad PhysXViewer.psc");
gAllGlobals.gLog.ref()->Display("Menu System Initialized\r\n");
}
