Autor Wątek: PhysX NxNormalToTangents  (Przeczytany 531 razy)

Offline yoyuu

  • Użytkownik

# Maj 20, 2010, 19:19:38
Witam,

Czy możecie mi powiedzieć dlaczego nie mogę poprawnie ulokować i zorientować bryły geometrycznej w trójwymiarowej przestrzeni. Ciągle wychodzi coś nie tak, a siedzę nad tym już naprawdę długo. Robię to w następujący sposób:

pos - jest to początek wektora ov.
dim - to skalowanie bryły.
ov - to wektor (nieznormalizowany) zgodnie, z którym ma być zorientowana bryła.

NxActor *physics::CreateAndOrientObject(const NxVec3 &pos, const NxVec3 &dim, const NxReal density, const NxVec3 &ov)
{
        NxBodyDesc bodyDesc;

//w tym miejscu liczę macierz orientacji - orient
NxVec3 axis(ov);
axis.normalize();
NxVec3 binormal, normal;
NxNormalToTangents(axis,binormal,normal);
NxMat33 orient(normal,axis,binormal);


//w tym miejscu ustawiam sobie wierzchołki obiektu i skaluje je
int numVertices = geom.getNbVertices();
int numIndices = geom.getNbIndices();
int numTriangles = geom.getNbFaces();

std::vector<Vertex> hVert = geom.getVertices();
Vertex *vertices = new Vertex[numVertices];
for(int i = 0; i < numVertices; i++)
{
vertices[i] = hVert[i];
vertices[i].pos.y = hVert[i].pos.y * dim.y;
vertices[i].pos.x = hVert[i].pos.x * dim.x;
vertices[i].pos.z = hVert[i].pos.z * dim.z;
}


std::vector<DWORD> hInd = geom.getIndices();
DWORD *indices = new DWORD[numIndices];
for(int i = 0; i < numIndices; i++)
{
indices[i] = hInd[i];
}


//w tym miejscu tworze ConvexMesh
NxConvexMeshDesc *convexDesc = new NxConvexMeshDesc();
assert(convexDesc);
    convexDesc->numVertices = numVertices;
    convexDesc->pointStrideBytes = sizeof(Vertex);
    convexDesc->points = vertices;
convexDesc->flags = NX_CF_COMPUTE_CONVEX;
convexDesc->numTriangles = numTriangles;
convexDesc->triangles = indices;
convexDesc->triangleStrideBytes = 3 * sizeof(DWORD);

myData *md = new myData();
md->nbVertices = numVertices;
md->nbIndices = numIndices;
md->vertices = vertices;
md->indices = indices;

NxConvexShapeDesc convexShapeDesc;
convexShapeDesc.localPose.t = NxVec3(0,0,0);
convexShapeDesc.userData = md;
 
NxInitCooking();
MemoryWriteBuffer buf;
bool status = NxCookConvexMesh(*convexDesc,buf);
NxConvexMesh *pMesh = physicsSDK->createConvexMesh(MemoryReadBuffer(buf.data));
assert(pMesh);
convexShapeDesc.meshData = pMesh;
NxCloseCooking();

//tworzenie i ustawienie aktora
    if(pMesh)
    {
pMesh->saveToDesc(*convexDesc);
NxActorDesc actorDesc;
assert(convexShapeDesc.isValid());
        actorDesc.shapes.pushBack(&convexShapeDesc);
    actorDesc.body = &bodyDesc;
actorDesc.density = density;
   
assert(actorDesc.isValid());
NxActor* actor = scene->createActor(actorDesc);

actor->setGlobalOrientation(orient);
NxVec3 p;
p.x = pos.x + ov.x/2.0f;
p.y = pos.y + ov.y/2.0f;
p.z = pos.z + ov.z/2.0f;
actor->setGlobalPosition(p);

assert(actor);
return actor;
    }

return NULL;
}

Bryła ma być zorientowana zgodnie z wektorem ov, mieć jego długość oraz znajdować się dokładnie pomiędzy dwoma punktami, które tworzą wektor (czyli żeby tak jakby łączyła punkty). Dlatego na koniec mam takie oto linijki:

   poz.x = pos.x + ov.x/2.0f;
   poz.y = pos.y + ov.y/2.0f;
   poz.z = pos.z + ov.z/2.0f;

Będę bardzo wdzięczny za każdą pomoc.

Offline Mr. Spam

  • Miłośnik przetworów mięsnych