PhysX and Polysoup Work

Add this to the bottom of PhysXTSStatic.cpp
void PhysXTSStatic::SetupTriangleCollision(bool server, TSStatic &tsstatic)
{
	mServer = server;

	PhysXWorld *PxWorld = PhysXWorld::getWorld(server);

	// If we don't have a PhysXWorld, just return.
	if ( !PxWorld ) 
		return; 

	Box3F box = tsstatic.getObjBox();
	VectorF scale = tsstatic.getScale();//*10.0;
	box.min.convolve(scale);
	box.max.convolve(scale);
	MatrixF wmat = tsstatic.getWorldTransform();
	Point3F placePos = tsstatic.getPosition();
	// make our matrices into Quats... for the physx engine
	QuatF q(wmat);
	Point3F wpos;
	wmat.getColumn(3,&wpos);
	NxQuat quat;
	quat. setXYZW(q.x, q.y, q.z, q.w);
	NxActorDesc actorDesc;
	
	Vector<U32> indicesList;

	TSShapeInstance *shapeInst = tsstatic.mShapeInstance; 

	if ( !shapeInst )
		return;

	NxInitCooking();

	// Loop through each *MeshObjectInstance* in the TSShapeInstance.
	for( U32 i = 0; i < shapeInst->mMeshObjects.size(); i++ )
   	{
		// Grab out the MeshObjectInstance.
		TSShapeInstance::MeshObjectInstance *meshInst = &shapeInst->mMeshObjects[i];

		// Grab out the TSMesh for that MeshObjectInstance.
		TSMesh *mesh = meshInst->getMesh( 0 );

		if ( !mesh )
		{
			continue; // Nothing left to do if no mesh.
		}
		
		// Figure out how many triangles we have...
		nbFaces = 0;
		const U32 base = 0;

		// Loop through the TSDrawPrimitives.	
		for ( U32 j = 0; j < mesh->primitives.size(); j++ )
		{
			// Pull out the TSDrawPrimitive.
			TSDrawPrimitive &draw = mesh->primitives[j];
			U32 start = draw.start;
         
			if ( (draw.matIndex & TSDrawPrimitive::TypeMask) == TSDrawPrimitive::Triangles)
			{
				nbFaces += draw.numElements / 3;
			}
			else
			{
				U32 idx0 = base + mesh->indices[start + 0];
				U32 idx1;
				U32 idx2 = base + mesh->indices[start + 1];
				U32 * nextIdx = &idx1;
				for ( S32 k = 2; k < draw.numElements; k++ )
				{
					*nextIdx = idx2;
					nextIdx = (U32*) ( (dsize_t)nextIdx ^ (dsize_t)&idx0 ^ (dsize_t)&idx1);
					idx2 = base + mesh->indices[start + k];
					if (idx0 == idx1 || idx0 == idx2 || idx1 == idx2)
						continue; 
					nbFaces++;  
				}
			}
		}


		for ( U32 j = 0; j < mesh->primitives.size(); j++ )
		{
			TSDrawPrimitive &draw = mesh->primitives[j];
			
			U32 start = draw.start;
			
			if ( (draw.matIndex & TSDrawPrimitive::TypeMask) == TSDrawPrimitive::Triangles)
			{
				for ( S32 j = 0; j < draw.numElements; )
				{
					U32 idx0 = base + mesh->indices[start + j + 0];
					U32 idx1 = base + mesh->indices[start + j + 1];
					U32 idx2 = base + mesh->indices[start + j + 2];
					indicesList.push_back( idx0 );
					indicesList.push_back( idx1 );
					indicesList.push_back( idx2 );
					
					j += 3;
				}
			}
			else
			{
				U32 idx0 = base + mesh->indices[start + 0];
				U32 idx1;
				U32 idx2 = base + mesh->indices[start + 1];
				U32 * nextIdx = &idx1;
				for (S32 j=2; j<draw.numElements; j++)
				{
					*nextIdx = idx2;
					
					nextIdx = (U32*) ( (dsize_t)nextIdx ^ (dsize_t)&idx0 ^ (dsize_t)&idx1);
					idx2 = base + mesh->indices[start + j];
					if (idx0 == idx1 || idx0 == idx2 || idx1 == idx2)
						continue;

					indicesList.push_back( idx0 );
					indicesList.push_back( idx1 );
					indicesList.push_back( idx2 );
				}
			}
		}
	
		// Here you can loop through your
		// indicesList and index mesh->verts
		// to collect them all.
		nbVerts = mesh->verts.size();
		verts = new NxVec3[nbVerts];
	
		// Load vertices
		for(U32 i=0; i < nbVerts; i++)
		{
			verts[i].x = mesh->verts[i].x;
			verts[i].y = mesh->verts[i].y;
			verts[i].z = mesh->verts[i].z;
		}
		faces = indicesList.address();
		NxTriangleMeshDesc triangleDesc;
		triangleDesc.numVertices            = nbVerts;
		triangleDesc.numTriangles           = nbFaces;
		triangleDesc.pointStrideBytes       = sizeof(NxVec3);
		triangleDesc.triangleStrideBytes	= 3*sizeof(NxU32);
		triangleDesc.points			        = verts;
		triangleDesc.triangles              = faces;
		triangleDesc.flags		     	    = NX_MF_FLIPNORMALS;
		
		// cook it
		MemoryWriteBuffer buf;
		NxCookingParams params;
		params.targetPlatform = PLATFORM_PC;
		params.skinWidth=0.0f;
		params.hintCollisionSpeed = false;
		NxSetCookingParams(params);
		bool status = NxCookTriangleMesh(triangleDesc, buf);
		
		if (status)
		{
			MemoryReadBuffer readBuffer(buf.data);
			mTriangleMesh = PxWorld->createTriangleMesh(readBuffer);
			
			// Push this actor back into our actor list.
			NxTriangleMeshShapeDesc staticMeshDesc;
			staticMeshDesc.meshData = mTriangleMesh;
			actorDesc.shapes.push_back(&staticMeshDesc);
		}
		else
		{
			return;
		}
	}
	NxCloseCooking();

	actorDesc.body = NULL;
	gTSStatic = PxWorld->AddActor(actorDesc);

	if(gTSStatic->active)
	{
		gTSStatic->actor->setGlobalOrientationQuat(quat);
		gTSStatic->actor->setGlobalPosition( NxVec3(placePos) );
		gTSStatic->actor->userData = (void*) static_cast<SimObject*>( this );
	}
}

void SetupTriangleCollision(bool server,TSStatic &);

void SetupCollision(bool server,TSStatic &);

void PhysXWorld::SetupTSStatic(TSStatic &tsstatic)
{
	if (mRemoteClient || isServerObject())
	{
		PhysXTSStatic *pxTSStatic = new PhysXTSStatic();
		pxTSStatic->registerObject();
		mTSStaticList.push_front(pxTSStatic);
		if(tsstatic.usesPolysoup())
		{
			pxTSStatic->SetupTriangleCollision(isServerObject(),tsstatic);
		}
		else
		{
			pxTSStatic->SetupCollision(isServerObject(),tsstatic);
		}
	}
}