//-------------------------------------------------------------------------------------------------
void sdPhysXCookUtility::CloseCooking()
{
#ifdef COOKING_INTERFACE
if (ms_pkCooking)
ms_pkCooking->NxCloseCooking();
#else
return NxCloseCooking();
#endif
}
void CloseCooking()
{
#ifdef COOKING_INTERFACE
if ( !gCooking ) return;
gCooking->NxCloseCooking();
#else
return NxCloseCooking();
#endif
}
plSimulationMgr::~plSimulationMgr()
{
fLOSDispatch->UnRef();
fLOSDispatch = nil;
delete fSoundMgr;
fSoundMgr = nil;
hsAssert(fScenes.empty(), "Unreleased scenes at shutdown");
if (fSDK) {
NxCloseCooking();
fSDK->release();
}
delete fLog;
fLog = nil;
}
// -----------------------------------------------------------------------
void MyCloth::init(NxScene *scene, NxClothDesc &desc, NxClothMeshDesc &meshDesc)
{
mScene = scene;
// 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 (desc.flags & NX_CLF_TEARABLE)
meshDesc.flags |= NX_CLOTH_MESH_TEARABLE;
NxInitCooking();
cookMesh(meshDesc);
NxCloseCooking();
releaseMeshDescBuffers(meshDesc);
allocateReceiveBuffers(meshDesc.numVertices, meshDesc.numTriangles);
desc.clothMesh = mClothMesh;
desc.meshData = mReceiveBuffers;
mCloth = scene->createCloth(desc);
mInitDone = true;
}
void plPhysXCooking::Shutdown()
{
NxCloseCooking();
fUtilLib=nil;
fSkipErrors = false;
}
NxActor* CreateConvex(const NxVec3 &pos, int flag)
{
NxActorDesc actorDesc;
NxBodyDesc bodyDesc;
NxVec3 boxDim(1,0.8,1.5);
// Pyramid
NxVec3 verts[8] = { NxVec3(boxDim.x, -boxDim.y, -boxDim.z),
NxVec3(-boxDim.x, -boxDim.y, -boxDim.z),
NxVec3(-boxDim.x, -boxDim.y, boxDim.z),
NxVec3(boxDim.x, -boxDim.y, boxDim.z),
NxVec3(boxDim.x*0.5, boxDim.y, -boxDim.z*0.5),
NxVec3(-boxDim.x*0.5, boxDim.y, -boxDim.z*0.5),
NxVec3(-boxDim.x*0.5, boxDim.y, boxDim.z*0.5),
NxVec3(boxDim.x*0.5, boxDim.y, boxDim.z*0.5)
};
// Create descriptor for convex mesh
if (!convexDesc)
{
convexDesc = new NxConvexMeshDesc();
assert(convexDesc);
}
convexDesc->numVertices = 8;
convexDesc->pointStrideBytes = sizeof(NxVec3);
convexDesc->points = verts;
convexDesc->flags = NX_CF_COMPUTE_CONVEX;
NxConvexShapeDesc convexShapeDesc;
convexShapeDesc.localPose.t = NxVec3(0, 2.0f, boxDim.z * 0.4);
convexShapeDesc.userData = convexDesc;
NxInitCooking();
// Cooking from memory
MemoryWriteBuffer buf;
bool status = NxCookConvexMesh(*convexDesc, buf);
//
// Please note about the created Convex Mesh, user needs to release it when no one uses it to save memory. It can be detected
// by API "meshData->getReferenceCount() == 0". And, the release API is "gPhysicsSDK->releaseConvexMesh(*convexShapeDesc.meshData);"
//
NxConvexMesh *pMesh = gPhysicsSDK->createConvexMesh(MemoryReadBuffer(buf.data));
assert(pMesh);
convexShapeDesc.meshData = pMesh;
NxCloseCooking();
if (pMesh)
{
// Save mesh in userData for drawing.
pMesh->saveToDesc(*convexDesc);
//
NxActorDesc actorDesc;
assert(convexShapeDesc.isValid());
actorDesc.shapes.pushBack(&convexShapeDesc);
if (0 == flag)
{ //Dynamic actor
bodyDesc.flags |= NX_BF_DISABLE_GRAVITY;
actorDesc.body = &bodyDesc;
actorDesc.density = 1.0f;
}
else if (1 == flag)
{ //Static actor
actorDesc.body = NULL;
actorDesc.density = 1.0f;
}
else if (2 == flag)
{ // Kinematic actor
bodyDesc.flags |= NX_BF_KINEMATIC;
actorDesc.body = &bodyDesc;
actorDesc.density = 1.0f;
}
actorDesc.globalPose.t = pos; //NxVec3(6.5f, 0.0f, 0.0f);
assert(actorDesc.isValid());
NxActor* actor = gScene->createActor(actorDesc);
assert(actor);
return actor;
}
return NULL;
}
void FPxScene::CreateLevel( ULevel* level )
{
pxguard(FPxScene::CreateLevel);
PX_LOG( PX_NAME, TEXT("%s >> %s ::"), PX_LOGP );
if( !level )
{
PX_ERR( PX_NAME, TEXT("%s !! %s :: No level provided"), PX_LOGP );
return;
}
if( mLevel )
{
PX_ERR( PX_NAME, TEXT("%s !! %s :: Level already loaded"), PX_LOGP );
return;
}
mLevel = level;
// Triangulate level mesh
PX_LOG( PX_NAME, TEXT("%s .. %s :: Triangulating Level"), PX_LOGP );
FPxTriangulator tor;
tor.Triangulate(mLevel->Model);
TArray<INT>& tris = tor.Triangles;
TArray<NxVec3> verts;
for( TArray<FVector>::TIterator it_point(tor.Points); it_point; ++it_point )
{
verts.AddItem( ToNVS(*it_point) );
}
// Build physical model
NxTriangleMeshDesc levelDesc;
levelDesc.numVertices = verts.Num();
levelDesc.numTriangles = tris.Num() / 3;
levelDesc.pointStrideBytes = sizeof(NxVec3);
levelDesc.triangleStrideBytes = 3*sizeof(INT);
levelDesc.points = verts.GetData();
levelDesc.triangles = tris.GetData();
levelDesc.flags = NX_MF_FLIPNORMALS;
// Cooking
PX_LOG( PX_NAME, TEXT("%s .. %s :: Cooking Level"), PX_LOGP );
NxInitCooking();
FPxMemWriteBuffer buf;
bool status = NxCookTriangleMesh(levelDesc, buf);
NxTriangleMeshShapeDesc levelShapeDesc;
levelShapeDesc.meshData = GPxPhysics.GetSDK().createTriangleMesh(FPxMemReadBuffer(buf.data));
NxCloseCooking();
// Calc level bounding box
NxVec3 bmin, bmax;
NxComputeBounds( bmin, bmax, verts.Num(), static_cast<NxVec3*>(verts.GetData()) );
mBounds.set(bmin,bmax);
// Update scene limits
mSceneLimits.maxNbActors = 1;
mSceneLimits.maxNbBodies = 1;
mSceneLimits.maxNbStaticShapes = 1;
mSceneLimits.maxNbDynamicShapes = 0;
mSceneLimits.maxNbJoints = 0;
// Update scene descriptor
mSceneDesc.limits = &mSceneLimits;
mSceneDesc.maxBounds = &mBounds;
mSceneDesc.upAxis = 1; // Y
mSceneDesc.staticStructure = NX_PRUNING_STATIC_AABB_TREE;
mSceneDesc.dynamicStructure = NX_PRUNING_NONE; //NX_PRUNING_DYNAMIC_AABB_TREE;
// create scene
if( !mScene )
{
CreateScene();
}
if( !mScene )
{
PX_ERR( PX_NAME, TEXT("%s !! %s :: Scene could not be created"), PX_LOGP );
return;
}
// default material
NxMaterial* defaultMaterial = mScene->getMaterialFromIndex(0);
defaultMaterial->setRestitution(0.1f);
defaultMaterial->setStaticFriction(0.9f);
defaultMaterial->setDynamicFriction(0.85f);
// Create static level actor
PX_LOG( PX_NAME, TEXT("%s .. %s :: Creating level mesh"), PX_LOGP );
NxActorDesc actorDesc;
actorDesc.shapes.pushBack(&levelShapeDesc);
// Add level actor to the scene
PX_LOG( PX_NAME, TEXT("%s .. %s :: Creating level actor"), PX_LOGP );
NxActor* actor = mScene->createActor(actorDesc);
actor->userData = (void*)level->GetLevelInfo();
PX_LOG( PX_NAME, TEXT("%s << %s ::"), PX_LOGP );
unguard;
}
