Реализация статичного объекта в PhysX

[DarkMedveD]

Пытаюсь приготовить TriangleMesh в PhysX, но ничего не получается.
Реализацию данной функции нашел в одном задрипанном примере. В этом примере лежал файл уровня, который работает, а любой другой -нет.

Если у кого есть функция приготовления тримеша - дайте пожалуйста.

Вот моя:

//-----------------------------------------------------------------------------------------
// 1. Получить массив со всеми вершинами объекта 
//----------------------------------------------------------------------------------------
	NxVec3 vPosition( x, y, z);


	   vector<float> vertices;
	

    DWORD stride =  D3DXGetFVFVertexSize(Model->GetFVF());
    BYTE* vbptr = NULL;
    Model->LockVertexBuffer(0, (LPVOID*)&vbptr);
	
	vbptr=vbptr+32;
    int ii = -1;
    for(DWORD i = 0; i < Model->GetNumVertices(); i++)
    {
        ii++;
        D3DXVECTOR3* pos = (D3DXVECTOR3*)vbptr;
		D3DXVECTOR3 _tempPos=*pos;
		D3DXVec3TransformCoord(&_tempPos,&_tempPos,&scale);
        vertices.push_back(_tempPos.x);
        vertices.push_back(_tempPos.y);
        vertices.push_back(_tempPos.z);
		
		
        vbptr += stride;
    }
    Model->UnlockVertexBuffer();

//-----------------------------------------------------------------------------------------
// 2. Получить массив с индексами объекта
//---------------------------------------------------------------------------------------

	 
     stride = sizeof(short);
    BYTE* ibptr = NULL;
	
    short* indices = new short[Model->GetNumFaces()*3];

    vector<short> copy;

    Model->LockIndexBuffer(0, (LPVOID*)&indices);

    for(DWORD i = 0; i < Model->GetNumFaces(); i++)
    {
        copy.push_back(indices[i]);
    }

    Model->UnlockIndexBuffer();

//-----------------------------------------------------------------------------------------
// 3. Создать ограничивающие объемы
//---------------------------------------------------------------------------------------


	int NumVerticies = vertices.size() / 3;
    int NumTriangles = copy.size() / 3;
    //Create pointer for vertices
    NxVec3* verts = new NxVec3[NumVerticies];

	 ii = -1;
    for(int i = 0; i < NumVerticies; i++)
    {
        ++ii;
        verts[i].x = vertices[ii];
        verts[i].y = vertices[++ii];
        verts[i].z = vertices[++ii];
    }
    //Create pointer for indices
    NxU16 *tris = new NxU16[copy.size()];
    for(int i = copy.size() - 1; i >= 0; i--)
        tris[i] = i;

    // Build physical model
    NxTriangleMeshDesc TriMeshDesc;
    TriMeshDesc.numVertices = NumVerticies;
    TriMeshDesc.numTriangles = NumTriangles;
    TriMeshDesc.pointStrideBytes = sizeof(NxVec3);
    TriMeshDesc.triangleStrideBytes = 3*sizeof(NxU16);
    TriMeshDesc.points = verts;
    TriMeshDesc.triangles = tris;
    TriMeshDesc.flags = NX_MF_16_BIT_INDICES ;//| NX_MF_FLIPNORMALS  ;
    
    NxTriangleMeshShapeDesc ShapeDesc;
    NxInitCooking();

    // Cooking from memory
    MemoryWriteBuffer buf;
    bool status = NxCookTriangleMesh(TriMeshDesc, buf);
    ShapeDesc.meshData = g_pPhysicsSDK->createTriangleMesh(MemoryReadBuffer(buf.data));

    NxActorDesc actorDesc;
    actorDesc.shapes.pushBack(&ShapeDesc);
    actorDesc.globalPose.t = vPosition;

    Actor = g_pScene->createActor(actorDesc);

    delete[] verts;
    delete[] tris;

[DarkMedveD]

Держите:
Model - Сетка
Actor - физический объект

void Mesh::GenerateTriangleMeshFromDXMesh()
{

	typedef struct {
		D3DXVECTOR3 VertexPos;
		D3DXVECTOR3 Normal;
		D3DXVECTOR2 TexCoord;
	} Mesh_FVF;

	//Used to copy indices
	typedef struct {
		short IBNumber[3];
	} IndexBufferStruct;

	int NumVerticies = Model->GetNumVertices();
	int NumTriangles = Model->GetNumFaces();
	DWORD FVFSize = D3DXGetFVFVertexSize(Model->GetFVF());

	//Create pointer for vertices
	NxVec3* verts = new NxVec3[NumVerticies];

	char *DXMeshPtr;
	Model->LockVertexBuffer(D3DLOCK_READONLY, (void**)&DXMeshPtr);
	for(int i = 0; i < NumVerticies; i++)
	{
		Mesh_FVF *DXMeshFVF = (Mesh_FVF*)DXMeshPtr;
		verts[i] = NxVec3(DXMeshFVF->VertexPos.x, DXMeshFVF->VertexPos.y, DXMeshFVF->VertexPos.z);
		DXMeshPtr += FVFSize;
	}
	Model->UnlockVertexBuffer();

	//Create pointer for indices
	IndexBufferStruct *tris = new IndexBufferStruct[NumTriangles];

	IndexBufferStruct *DXMeshIBPtr;
	Model->LockIndexBuffer(D3DLOCK_READONLY, (void**)&DXMeshIBPtr);
	for(int NumInd = 0; NumInd < NumTriangles; NumInd++)
	{
		tris[NumInd].IBNumber[0] = DXMeshIBPtr[NumInd].IBNumber[0];
		tris[NumInd].IBNumber[1] = DXMeshIBPtr[NumInd].IBNumber[1];
		tris[NumInd].IBNumber[2] = DXMeshIBPtr[NumInd].IBNumber[2];
	}

	Model->UnlockIndexBuffer();




	// Build physical model
	NxTriangleMeshDesc TriMeshDesc;
	TriMeshDesc.numVertices = NumVerticies;
	TriMeshDesc.numTriangles = NumTriangles;
	TriMeshDesc.pointStrideBytes = sizeof(NxVec3);
	TriMeshDesc.triangleStrideBytes = 3*sizeof(NxU16);
	TriMeshDesc.points = verts;
	TriMeshDesc.triangles = tris;
	TriMeshDesc.flags = NX_MF_16_BIT_INDICES;




	NxTriangleMeshShapeDesc ShapeDesc;
	if(0)
	{
		// Cooking from file
		bool status = NxCookTriangleMesh(TriMeshDesc, UserStream("c:\\tmp.bin", false));
		ShapeDesc.meshData = g_pPhysicsSDK->createTriangleMesh(UserStream("c:\\tmp.bin", true));
	}
	else
	{
		// Cooking from memory
		MemoryWriteBuffer buf;
		bool status = NxCookTriangleMesh(TriMeshDesc, buf);
		ShapeDesc.meshData = g_pPhysicsSDK->createTriangleMesh(MemoryReadBuffer(buf.data));
	}



	NxActorDesc actorDesc;
	actorDesc.shapes.pushBack(&ShapeDesc);
	actorDesc.globalPose.t = NxVec3(0,0,0);
	Actor = g_pScene->createActor(actorDesc);
	Actor->userData = (void*)1;

	delete[] verts;
	delete[] tris;
}