hsVectorStream* plPhysXCooking::CookTrimesh(int nVerts, hsPoint3* verts, int nFaces, uint16_t* faces)
{
NxTriangleMeshDesc triDesc;
triDesc.numVertices = nVerts;
triDesc.pointStrideBytes = sizeof(hsPoint3);
triDesc.points = verts;
triDesc.numTriangles = nFaces;
triDesc.triangleStrideBytes = sizeof(uint16_t) * 3;
triDesc.triangles = faces;
triDesc.flags = NX_MF_16_BIT_INDICES;
hsVectorStream* ram = new hsVectorStream;
plPXStream buf(ram);
bool status = NxCookTriangleMesh(triDesc, buf);
hsAssert(status, "Trimesh failed to cook");
if (status)
{
ram->Rewind();
return ram;
}
else
{
delete ram;
return nil;
}
}
Menge::GeometryInterface * NovodexPhysicSystem::cookConcave( const float * _verts, int _vertexSize, const int * _indecies, int _indexSize )
{
NxTriangleMeshDesc triMeshDesc;
triMeshDesc.numVertices = _vertexSize;
triMeshDesc.pointStrideBytes = 3 * sizeof(float);
triMeshDesc.points = _verts;
triMeshDesc.numTriangles = _indexSize;
triMeshDesc.triangles = _indecies;
triMeshDesc.triangleStrideBytes = 3 * sizeof(int);
triMeshDesc.flags = 0;
NxTriangleMeshShapeDesc * nxTriShape = new NxTriangleMeshShapeDesc();
NxInitCooking();
MemoryWriteBuffer buf;
//bool status = NxCookTriangleMesh(triMeshDesc, UserStream("c:\\cooked.bin", false));
bool status = NxCookTriangleMesh(triMeshDesc, buf);
assert(status);
nxTriShape->meshData = m_physicsSDK->createTriangleMesh(MemoryReadBuffer(buf.data));
nxTriShape->group = GROUP_COLLIDABLE_NON_PUSHABLE;
NovodexGeometry * novodexGeometry = new NovodexGeometry(nxTriShape);
return novodexGeometry;
}
//-------------------------------------------------------------------------------------------------
bool sdPhysXCookUtility::CookTriangleMesh(const NxTriangleMeshDesc& kDesc, NxStream& kStream)
{
#ifdef COOKING_INTERFACE
return ms_pkCooking->NxCookTriangleMesh(kDesc, kStream);
#else
return NxCookTriangleMesh(kDesc, kStream);
#endif
}
bool CookTriangleMesh(const NxTriangleMeshDesc& desc, NxStream& stream)
{
#ifdef COOKING_INTERFACE
hasCookingLibrary();
if ( !gCooking ) return false;
return gCooking->NxCookTriangleMesh(desc,stream);
#else
return NxCookTriangleMesh(desc,stream);
#endif
}
void PhysCreateStaticRigidBodyMesh ( int iObject )
{
sObject* pObject = dbGetObject ( iObject );
if ( !pObject )
return;
int iCount = 0;
for ( int iMesh = 0; iMesh < pObject->iMeshCount; iMesh++ )
{
NxVec3* pVertices = new NxVec3 [ pObject->ppMeshList [ iMesh ]->dwVertexCount ];
int iVertexCount = pObject->ppMeshList [ iMesh ]->dwVertexCount;
int* iTriangles = new int [ pObject->ppMeshList [ iMesh ]->dwIndexCount ];
int iTriangleCount = pObject->ppMeshList [ iMesh ]->dwIndexCount;
sOffsetMap offsetMap;
GetFVFOffsetMap ( pObject->ppMeshList [ iMesh ], &offsetMap );
for ( int i = 0; i < iVertexCount; i++ )
{
pVertices [ i ].x = *( ( float* ) pObject->ppMeshList [ iMesh ]->pVertexData + offsetMap.dwX + ( offsetMap.dwSize * i ) );
pVertices [ i ].y = *( ( float* ) pObject->ppMeshList [ iMesh ]->pVertexData + offsetMap.dwY + ( offsetMap.dwSize * i ) );
pVertices [ i ].z = *( ( float* ) pObject->ppMeshList [ iMesh ]->pVertexData + offsetMap.dwZ + ( offsetMap.dwSize * i ) );
}
for ( i = 0; i < iTriangleCount; i++ )
iTriangles [ i ] = pObject->ppMeshList [ iMesh ]->pIndices [ i ];
NxTriangleMeshDesc levelDesc;
levelDesc.numVertices = iVertexCount;
levelDesc.numTriangles = iTriangleCount / 3;
levelDesc.pointStrideBytes = sizeof ( NxVec3 );
levelDesc.triangleStrideBytes = 3 * sizeof ( int );
levelDesc.points = pVertices;
levelDesc.triangles = iTriangles;
levelDesc.flags = NX_CF_COMPUTE_CONVEX;
NxTriangleMeshShapeDesc levelShapeDesc;
NxInitCooking ( );
MemoryWriteBuffer buf;
bool status = NxCookTriangleMesh ( levelDesc, buf );
if ( status )
{
levelShapeDesc.meshData = gPhysicsSDK->createTriangleMesh ( MemoryReadBuffer ( buf.data ) );
NxActor* actor = NULL;
NxActorDesc actorDesc;
actorDesc.shapes.pushBack ( &levelShapeDesc );
actor = gScene->createActor ( actorDesc );
sPhysObject* pPhys = new sPhysObject;
pPhys->iID = iObject;
actor->userData = ( void* )pPhys;
SetActorCollisionGroup ( actor, GROUP_COLLIDABLE_NON_PUSHABLE );
}
}
}
void plGenericPhysical::IWritePXPhysical(hsStream* S, plResManager* mgr) {
S->writeFloat(fMass);
S->writeFloat(fFriction);
S->writeFloat(fRestitution);
S->writeByte(fBounds);
S->writeByte(plPXSimDefs::toGroup(fMemberGroup, fCollideGroup));
S->writeInt(plPXSimDefs::setReportsOn(fReportGroup));
S->writeShort(fLOSDBs);
mgr->writeKey(S, fObjectKey);
mgr->writeKey(S, fSceneNode);
mgr->writeKey(S, fSubWorld);
mgr->writeKey(S, fSoundGroup);
fPos.write(S);
fRot.write(S);
fProps.write(S);
if (fBounds == plSimDefs::kSphereBounds) {
S->writeFloat(fRadius);
fOffset.write(S);
} else if (fBounds == plSimDefs::kBoxBounds) {
fDimensions.write(S);
fOffset.write(S);
} else if (fBounds == plSimDefs::kHullBounds) {
#ifdef HAVE_PX_SDK
if (!sPhysxWasInit) {
NxInitCooking();
sPhysxWasInit = true;
}
NxConvexMeshDesc convexDesc;
convexDesc.numVertices = fVerts.size();
convexDesc.pointStrideBytes = sizeof(hsVector3);
convexDesc.points = &fVerts[0];
convexDesc.flags = NX_CF_COMPUTE_CONVEX;
plPXStream buf(S);
if (!NxCookConvexMesh(convexDesc, buf))
throw hsBadParamException(__FILE__, __LINE__, "Incorrect data for PhysX Hull Bake");
#else
throw hsNotImplementedException(__FILE__, __LINE__, "PhysX HullBounds");
#endif
} else { // Proxy or Explicit
#ifdef HAVE_PX_SDK
if (!sPhysxWasInit) {
NxInitCooking();
sPhysxWasInit = true;
}
NxTriangleMeshDesc triDesc;
triDesc.numVertices = fVerts.size();
triDesc.pointStrideBytes = sizeof(hsVector3);
triDesc.points = &fVerts[0];
triDesc.numTriangles = fIndices.size() / 3;
triDesc.triangleStrideBytes = sizeof(unsigned int) * 3;
triDesc.triangles = &fIndices[0];
triDesc.flags = 0; // 32-bit appears to be the default for index size
plPXStream buf(S);
if (!NxCookTriangleMesh(triDesc, buf))
throw hsBadParamException(__FILE__, __LINE__, "Incorrect data for a PhysX Trimesh Bake");
#else
throw hsNotImplementedException(__FILE__, __LINE__, "PhysX TriangleMesh");
#endif
}
}
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;
}
