void AtlasOldMesher::optimize() { AssertISV(false, "This is probably broken right now - BJG"); #if 0 // Shove everything through nvTriStrip SetCacheSize(24); // first, stripify our geometry... PrimitiveGroup *pg; U16 pgCount; GenerateStrips(mIndices.address(), mIndices.size(), &pg, &pgCount, AtlasOldActivationHeightfield::smDoChecks); // We're lazy. AssertISV(pgCount == 1, "AtlasOldMesher::optimize - Got unexpectedly complex geometry from NVTriStrip! (a)"); AssertISV(pg->type == PT_STRIP, "AtlasOldMesher::optimize - Got unexpectedly complex geometry from NVTriStrip! (b)"); // Remap indices! BJGTODO - how am I supposed to interpet the results? /* PrimitiveGroup *pgRemapped; RemapIndices(pg, pgCount, mVerts.size(), &pgRemapped); */ // Ok, let's suck this stuff back in. mIndices.clear(); mIndices.reserve(pg->numIndices); for(S32 i=0; i<pg->numIndices; i++) mIndices[i] = pg->indices[i]; // And clean up the memory from the stripper. delete[] pg; #endif }
void TriangleBatch::Stripify( TriangleBatch& pNewBatch ) { #if GD_PLATFORM == GD_PLATFORM_WIN32 GD_ASSERT( mIndices ); PrimitiveGroup* strip; UInt16 numGroups; SetCacheSize(CACHESIZE_GEFORCE1_2); SetStitchStrips(true); SetMinStripSize(0); SetListsOnly(false); // Stripify! GenerateStrips( mIndices, mIndicesCount, &strip, &numGroups ); GD_ASSERT( numGroups == 1 ); // Copy the result in our triangle batch. pNewBatch.Allocate( TriangleStrip, strip->numIndices ); memcpy( pNewBatch.GetIndices(), strip->indices, strip->numIndices*sizeof(UInt16) ); //GD_DELETE_ARRAY(strip); #else debugBreak(); #endif }
bool Stripify(model_t *model) { int n; for (n=0; n<model->num_meshes; n++) { int count = 0; mesh_t *mesh = &model->meshes[n]; PrimitiveGroup *outPrims; unsigned short outNum; unsigned short *indices = new unsigned short[mesh->num_faces * 3]; if (!mesh->num_faces) continue; //copy the face list into an unsigned short array for (int face=0; face<mesh->num_faces; face++) { for (int v=0; v<3; v++) { indices[count++] = (unsigned short)mesh->facelist[face][v]; } } //make sure we output a triangle list SetListsOnly(true); GenerateStrips(indices, count, &outPrims, &outNum); //should only ouput 1 list if (outNum != 1) { delete [] indices; return false; } //map the faces back into the mesh count = 0; for (int face=0; face<mesh->num_faces; face++) { for (int v=0; v<3; v++) { mesh->facelist[face][v] = indices[count++]; } } delete [] indices; } return true; }
void nvMakeStrips(std::vector<Primitive> & primitives, std::vector<U16> & indices, S32 cacheSize, U32 matIndex) { // incoming indices may have some "holes" in them...e.g., may have index 1,2,3,6,7 only // map to 0..N-1 std::vector<S16> map; std::vector<S16> remap; U16 next=0; S32 i; for (i=0; i<indices.size(); i++) { while (indices[i]>=map.size()) map.push_back(-1); if (map[indices[i]]<0) { map[indices[i]]=next++; remap.push_back(indices[i]); } indices[i] = map[indices[i]]; } PrimitiveGroup * primGroups; U16 numGroups; GenerateStrips(&indices[0],indices.size(),&primGroups,&numGroups); for (i=0; i<numGroups; i++) { assert(primGroups[i].type == PT_STRIP); Primitive strip; strip.type = matIndex; strip.firstElement = indices.size(); strip.numElements = primGroups[i].numIndices; primitives.push_back(strip); for (S32 j=0; j<primGroups[i].numIndices; j++) indices.push_back(primGroups[i].indices[j]); } delete [] primGroups; // remap indices... for (i=0; i<indices.size(); i++) indices[i] = remap[indices[i]]; }
void optimizeFaces(int index) { assert(index >= 0 && index < LOD_AMOUNT); int faceAmount = faces[index].size(); unsigned short *oldIndices = new unsigned short[faceAmount * 3]; for(int i = 0; i < faceAmount; ++i) for(int j = 0; j < 3; ++j) { int oldIndex = faces[index][i].getVertexIndex(j); assert(oldIndex >= 0 && oldIndex < int(vertices.size())); oldIndices[i * 3 + j] = oldIndex; } PrimitiveGroup *primitiveGroup = 0; unsigned short groupAmount = 0; SetCacheSize(CACHESIZE_GEFORCE3); SetListsOnly(true); GenerateStrips(oldIndices, faceAmount * 3, &primitiveGroup, &groupAmount); faces[index].resize(primitiveGroup->numIndices / 3); { for(unsigned int i = 0; i < primitiveGroup->numIndices / 3; ++i) for(int j = 0; j < 3; ++j) { int newIndex = primitiveGroup->indices[i * 3 + j]; assert(newIndex >= 0 && newIndex < int(vertices.size())); faces[index][i].setVertexIndex(j, newIndex); } } delete[] oldIndices; delete[] primitiveGroup; }
void xrStripify (xr_vector<u16> &indices, xr_vector<u16> &perturb, int iCacheSize, int iMinStripLength) { SetCacheSize (iCacheSize); SetMinStripSize (iMinStripLength); SetListsOnly (true); // Generate strips xr_vector<PrimitiveGroup> PGROUP; GenerateStrips (&*indices.begin(),(u32)indices.size(),PGROUP); R_ASSERT (PGROUP.size()==1); R_ASSERT (PGROUP[0].type==PT_LIST); if (indices.size()!=PGROUP[0].numIndices) throw "Stripify failed."; // Remap indices xr_vector<PrimitiveGroup> xPGROUP; RemapIndices (PGROUP,u16(perturb.size()),xPGROUP); R_ASSERT (xPGROUP.size()==1); R_ASSERT (xPGROUP[0].type==PT_LIST); // Build perturberation table for(u32 index = 0; index < PGROUP[0].numIndices; index++) { u16 oldIndex = PGROUP[0].indices [index]; int newIndex = xPGROUP[0].indices [index]; R_ASSERT(oldIndex<(int)perturb.size()); R_ASSERT(newIndex<(int)perturb.size()); perturb[newIndex] = oldIndex; } // Copy indices Memory.mem_copy (&*indices.begin(),xPGROUP[0].indices,(u32)indices.size()*sizeof(u16)); // Release memory xPGROUP.clear (); PGROUP.clear (); }