//-----------------------------------------------------------------------------
// Torque Game Engine
// Copyright (C) GarageGames.com, Inc.
//-----------------------------------------------------------------------------
#pragma warning( disable : 4786 )
#include "max2dtsExporter/NvTriStripObjects.h"
#include "max2dtsExporter/NvVertexCache.h"
NvStripifier::NvStripifier()
{
}
NvStripifier::~NvStripifier()
{
}
///////////////////////////////////////////////////////////////////////////////////////////
// FindEdgeInfo()
//
// find the edge info for these two indices
//
NvEdgeInfo * NvStripifier::FindEdgeInfo(NvEdgeInfoVec &edgeInfos, int v0, int v1){
// we can get to it through either array
// because the edge infos have a v0 and v1
// and there is no order except how it was
// first created.
NvEdgeInfo *infoIter = edgeInfos[v0];
while (infoIter != NULL){
if (infoIter->m_v0 == v0){
if (infoIter->m_v1 == v1)
return infoIter;
else
infoIter = infoIter->m_nextV0;
}
else {
AssertFatal(infoIter->m_v1 == v0,"Strip error");
if (infoIter->m_v0 == v1)
return infoIter;
else
infoIter = infoIter->m_nextV1;
}
}
return NULL;
}
///////////////////////////////////////////////////////////////////////////////////////////
// FindOtherFace
//
// find the other face sharing these vertices
// exactly like the edge info above
//
NvFaceInfo * NvStripifier::FindOtherFace(NvEdgeInfoVec &edgeInfos, int v0, int v1, NvFaceInfo *faceInfo)
{
NvEdgeInfo *edgeInfo = FindEdgeInfo(edgeInfos, v0, v1);
AssertFatal(edgeInfo != NULL,"Strip error");
return (edgeInfo->m_face0 == faceInfo ? edgeInfo->m_face1 : edgeInfo->m_face0);
}
bool NvStripifier::AlreadyExists(NvFaceInfo* faceInfo, NvFaceInfoVec& faceInfos)
{
for(int i = 0; i < faceInfos.size(); i++)
{
if( (faceInfos[i]->m_v0 == faceInfo->m_v0) &&
(faceInfos[i]->m_v1 == faceInfo->m_v1) &&
(faceInfos[i]->m_v2 == faceInfo->m_v2) )
return true;
}
return false;
}
///////////////////////////////////////////////////////////////////////////////////////////
// BuildStripifyInfo()
//
// Builds the list of all face and edge infos
//
void NvStripifier::BuildStripifyInfo(NvFaceInfoVec &faceInfos, NvEdgeInfoVec &edgeInfos){
// reserve space for the face infos, but do not resize them.
int numIndices = indices.size();
faceInfos.reserve(numIndices);
// we actually resize the edge infos, so we must initialize to NULL
edgeInfos.setSize (numIndices);
for (int i = 0; i < numIndices; i++)
edgeInfos[i] = NULL;
// iterate through the triangles of the triangle list
int numTriangles = numIndices / 3;
int index = 0;
for (int i = 0; i < numTriangles; i++)
{
// grab the indices
int v0 = indices[index++];
int v1 = indices[index++];
int v2 = indices[index++];
// create the face info and add it to the list of faces, but only if this exact face doesn't already
// exist in the list
NvFaceInfo *faceInfo = new NvFaceInfo(v0, v1, v2);
if(!AlreadyExists(faceInfo, faceInfos))
{
faceInfos.push_back(faceInfo);
// grab the edge infos, creating them if they do not already exist
NvEdgeInfo *edgeInfo01 = FindEdgeInfo(edgeInfos, v0, v1);
if (edgeInfo01 == NULL){
// create the info
edgeInfo01 = new NvEdgeInfo(v0, v1);
// update the linked list on both
edgeInfo01->m_nextV0 = edgeInfos[v0];
edgeInfo01->m_nextV1 = edgeInfos[v1];
edgeInfos[v0] = edgeInfo01;
edgeInfos[v1] = edgeInfo01;
// set face 0
edgeInfo01->m_face0 = faceInfo;
}
else {
if (edgeInfo01->m_face1 != NULL)
{
// TODO: not an assert...dump in dump file or something...
AssertFatal(0,"BuildStripifyInfo: > 2 triangles on an edge... uncertain consequences");
}
else
edgeInfo01->m_face1 = faceInfo;
}
// grab the edge infos, creating them if they do not already exist
NvEdgeInfo *edgeInfo12 = FindEdgeInfo(edgeInfos, v1, v2);
if (edgeInfo12 == NULL){
// create the info
edgeInfo12 = new NvEdgeInfo(v1, v2);
// update the linked list on both
edgeInfo12->m_nextV0 = edgeInfos[v1];
edgeInfo12->m_nextV1 = edgeInfos[v2];
edgeInfos[v1] = edgeInfo12;
edgeInfos[v2] = edgeInfo12;
// set face 0
edgeInfo12->m_face0 = faceInfo;
}
else {
if (edgeInfo12->m_face1 != NULL)
{
// TODO: not an assert, put in dump file
AssertFatal(0,"BuildStripifyInfo: > 2 triangles on an edge... uncertain consequences\n");
}
else
edgeInfo12->m_face1 = faceInfo;
}
// grab the edge infos, creating them if they do not already exist
NvEdgeInfo *edgeInfo20 = FindEdgeInfo(edgeInfos, v2, v0);
if (edgeInfo20 == NULL){
// create the info
edgeInfo20 = new NvEdgeInfo(v2, v0);
// update the linked list on both
edgeInfo20->m_nextV0 = edgeInfos[v2];
edgeInfo20->m_nextV1 = edgeInfos[v0];
edgeInfos[v2] = edgeInfo20;
edgeInfos[v0] = edgeInfo20;
// set face 0
edgeInfo20->m_face0 = faceInfo;
}
else {
if (edgeInfo20->m_face1 != NULL)
{
// TODO: not an assert, put in dump file...
AssertFatal(0,"BuildStripifyInfo: > 2 triangles on an edge... uncertain consequences\n");
}
else
edgeInfo20->m_face1 = faceInfo;
}
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////
// FindStartPoint()
//
// Finds a good starting point, namely one which has only one neighbor
//
int NvStripifier::FindStartPoint(NvFaceInfoVec &faceInfos, NvEdgeInfoVec &edgeInfos)
{
for(int i = 0; i < faceInfos.size(); i++)
{
int ctr = 0;
if(FindOtherFace(edgeInfos, faceInfos[i]->m_v0, faceInfos[i]->m_v1, faceInfos[i]) == NULL)
ctr++;
if(FindOtherFace(edgeInfos, faceInfos[i]->m_v1, faceInfos[i]->m_v2, faceInfos[i]) == NULL)
ctr++;
if(FindOtherFace(edgeInfos, faceInfos[i]->m_v2, faceInfos[i]->m_v0, faceInfos[i]) == NULL)
ctr++;
if(ctr > 1)
return i;
}
return -1;
}
///////////////////////////////////////////////////////////////////////////////////////////
// FindGoodResetPoint()
//
// A good reset point is one near other commited areas so that
// we know that when we've made the longest strips its because
// we're stripifying in the same general orientation.
//
NvFaceInfo* NvStripifier::FindGoodResetPoint(NvFaceInfoVec &faceInfos, NvEdgeInfoVec &edgeInfos){
// we hop into different areas of the mesh to try to get
// other large open spans done. Areas of small strips can
// just be left to triangle lists added at the end.
NvFaceInfo *result = NULL;
if(result == NULL)
{
int numFaces = faceInfos.size();
int startPoint;
if(bFirstTimeResetPoint)
{
//first time, find a face with few neighbors (look for an edge of the mesh)
startPoint = FindStartPoint(faceInfos, edgeInfos);
bFirstTimeResetPoint = false;
}
else
startPoint = (int)(((float) numFaces - 1) * meshJump);
if(startPoint == -1)
startPoint = (int)(((float) numFaces - 1) * meshJump);
int i = startPoint;
do {
// if this guy isn't visited, try him
if (faceInfos[i]->m_stripId < 0){
result = faceInfos[i];
break;
}
// update the index and clamp to 0-(numFaces-1)
if (++i >= numFaces)
i = 0;
} while (i != startPoint);
// update the meshJump
meshJump += 0.1f;
if (meshJump > 1.0f)
meshJump = .05f;
}
// return the best face we found
return result;
}
///////////////////////////////////////////////////////////////////////////////////////////
// GetUniqueVertexInB()
//
// Returns the vertex unique to faceB
//
int NvStripifier::GetUniqueVertexInB(NvFaceInfo *faceA, NvFaceInfo *faceB){
int facev0 = faceB->m_v0;
if (facev0 != faceA->m_v0 &&
facev0 != faceA->m_v1 &&
facev0 != faceA->m_v2)
return facev0;
int facev1 = faceB->m_v1;
if (facev1 != faceA->m_v0 &&
facev1 != faceA->m_v1 &&
facev1 != faceA->m_v2)
return facev1;
int facev2 = faceB->m_v2;
if (facev2 != faceA->m_v0 &&
facev2 != faceA->m_v1 &&
facev2 != faceA->m_v2)
return facev2;
// nothing is different
return -1;
}
///////////////////////////////////////////////////////////////////////////////////////////
// GetSharedVertex()
//
// Returns the vertex shared between the two input faces
//
int NvStripifier::GetSharedVertex(NvFaceInfo *faceA, NvFaceInfo *faceB){
int facev0 = faceB->m_v0;
if (facev0 == faceA->m_v0 ||
facev0 == faceA->m_v1 ||
facev0 == faceA->m_v2)
return facev0;
int facev1 = faceB->m_v1;
if (facev1 == faceA->m_v0 ||
facev1 == faceA->m_v1 ||
facev1 == faceA->m_v2)
return facev1;
int facev2 = faceB->m_v2;
if (facev2 == faceA->m_v0 ||
facev2 == faceA->m_v1 ||
facev2 == faceA->m_v2)
return facev2;
// nothing is shared
return -1;
}
///////////////////////////////////////////////////////////////////////////////////////////
// GetNextIndex()
//
// Returns vertex of the input face which is "next" in the input index list
//
inline int NvStripifier::GetNextIndex(const WordVec &indices, NvFaceInfo *face){
int numIndices = indices.size();
AssertFatal(numIndices >= 2,"strip error");
int v0 = indices[numIndices-2];
int v1 = indices[numIndices-1];
int fv0 = face->m_v0;
int fv1 = face->m_v1;
int fv2 = face->m_v2;
if (fv0 != v0 && fv0 != v1){
if ((fv1 != v0 && fv1 != v1) || (fv2 != v0 && fv2 != v1))
{
// TODO: put into dump file
AssertFatal(0,"GetNextIndex: Triangle doesn't have all of its vertices\n");
AssertFatal(0,"GetNextIndex: Duplicate triangle probably got us derailed\n");
}
return fv0;
}
if (fv1 != v0 && fv1 != v1){
if ((fv0 != v0 && fv0 != v1) || (fv2 != v0 && fv2 != v1))
{
// TODO: put into dump file
AssertFatal(0,"GetNextIndex: Triangle doesn't have all of its vertices\n");
AssertFatal(0,"GetNextIndex: Duplicate triangle probably got us derailed\n");
}
return fv1;
}
if (fv2 != v0 && fv2 != v1){
if ((fv0 != v0 && fv0 != v1) || (fv1 != v0 && fv1 != v1))
{
// TODO: put into dump file
AssertFatal(0,"GetNextIndex: Triangle doesn't have all of its vertices\n");
AssertFatal(0,"GetNextIndex: Duplicate triangle probably got us derailed\n");
}
return fv2;
}
// shouldn't get here
// TODO: put into dump file
AssertFatal(0,"GetNextIndex: Duplicate triangle sent\n");
return -1;
}
///////////////////////////////////////////////////////////////////////////////////////////
// IsMarked()
//
// If either the faceInfo has a real strip index because it is
// already assign to a committed strip OR it is assigned in an
// experiment and the experiment index is the one we are building
// for, then it is marked and unavailable
inline bool NvStripInfo::IsMarked(NvFaceInfo *faceInfo){
return (faceInfo->m_stripId >= 0) || (IsExperiment() && faceInfo->m_experimentId == m_experimentId);
}
///////////////////////////////////////////////////////////////////////////////////////////
// MarkTriangle()
//
// Marks the face with the current strip ID
//
inline void NvStripInfo::MarkTriangle(NvFaceInfo *faceInfo){
AssertFatal(!IsMarked(faceInfo),"strip error");
if (IsExperiment()){
faceInfo->m_experimentId = m_experimentId;
faceInfo->m_testStripId = m_stripId;
}
else{
AssertFatal(faceInfo->m_stripId == -1,"strip error");
faceInfo->m_experimentId = -1;
faceInfo->m_stripId = m_stripId;
}
}
bool NvStripInfo::Unique(NvFaceInfoVec& faceVec, NvFaceInfo* face)
{
bool bv0, bv1, bv2; //bools to indicate whether a vertex is in the faceVec or not
bv0 = bv1 = bv2 = false;
for(int i = 0; i < faceVec.size(); i++)
{
if(!bv0)
{
if( (faceVec[i]->m_v0 == face->m_v0) ||
(faceVec[i]->m_v1 == face->m_v0) ||
(faceVec[i]->m_v2 == face->m_v0) )
bv0 = true;
}
if(!bv1)
{
if( (faceVec[i]->m_v0 == face->m_v1) ||
(faceVec[i]->m_v1 == face->m_v1) ||
(faceVec[i]->m_v2 == face->m_v1) )
bv1 = true;
}
if(!bv2)
{
if( (faceVec[i]->m_v0 == face->m_v2) ||
(faceVec[i]->m_v1 == face->m_v2) ||
(faceVec[i]->m_v2 == face->m_v2) )
bv2 = true;
}
//the face is not unique, all it's vertices exist in the face vector
if(bv0 && bv1 && bv2)
return false;
}
//if we get out here, it's unique
return true;
}
///////////////////////////////////////////////////////////////////////////////////////////
// Build()
//
// Builds a strip forward as far as we can go, then builds backwards, and joins the two lists
//
void NvStripInfo::Build(NvEdgeInfoVec &edgeInfos, NvFaceInfoVec &faceInfos){
// used in building the strips forward and backward
static WordVec scratchIndices;
scratchIndices.clear();
// build forward... start with the initial face
NvFaceInfoVec forwardFaces, backwardFaces;
forwardFaces.push_back(m_startInfo.m_startFace);
MarkTriangle(m_startInfo.m_startFace);
int v0 = (m_startInfo.m_toV1 ? m_startInfo.m_startEdge->m_v0 : m_startInfo.m_startEdge->m_v1);
int v1 = (m_startInfo.m_toV1 ? m_startInfo.m_startEdge->m_v1 : m_startInfo.m_startEdge->m_v0);
// easiest way to get v2 is to use this function which requires the
// other indices to already be in the list.
scratchIndices.push_back(v0);
scratchIndices.push_back(v1);
int v2 = NvStripifier::GetNextIndex(scratchIndices, m_startInfo.m_startFace);
scratchIndices.push_back(v2);
//
// build the forward list
//
int nv0 = v1;
int nv1 = v2;
NvFaceInfo *nextFace = NvStripifier::FindOtherFace(edgeInfos, nv0, nv1, m_startInfo.m_startFace);
while (nextFace != NULL && !IsMarked(nextFace))
{
//this tests to see if a face is "unique", meaning that its vertices aren't already in the list
// so, strips which "wrap-around" are not allowed
if(!Unique(forwardFaces, nextFace))
break;
// add this to the strip
forwardFaces.push_back(nextFace);
MarkTriangle(nextFace);
// add the index
nv0 = nv1;
nv1 = NvStripifier::GetNextIndex(scratchIndices, nextFace);
scratchIndices.push_back(nv1);
// and get the next face
nextFace = NvStripifier::FindOtherFace(edgeInfos, nv0, nv1, nextFace);
}
// tempAllFaces is going to be forwardFaces + backwardFaces
// it's used for Unique()
NvFaceInfoVec tempAllFaces;
for(int i = 0; i < forwardFaces.size(); i++)
tempAllFaces.push_back(forwardFaces[i]);
//
// reset the indices for building the strip backwards and do so
//
scratchIndices.clear();
scratchIndices.push_back(v2);
scratchIndices.push_back(v1);
scratchIndices.push_back(v0);
nv0 = v1;
nv1 = v0;
nextFace = NvStripifier::FindOtherFace(edgeInfos, nv0, nv1, m_startInfo.m_startFace);
while (nextFace != NULL && !IsMarked(nextFace))
{
//this tests to see if a face is "unique", meaning that its vertices aren't already in the list
// so, strips which "wrap-around" are not allowed
if(!Unique(tempAllFaces, nextFace))
break;
// add this to the strip
backwardFaces.push_back(nextFace);
//this is just so Unique() will work
tempAllFaces.push_back(nextFace);
MarkTriangle(nextFace);
// add the index
nv0 = nv1;
nv1 = NvStripifier::GetNextIndex(scratchIndices, nextFace);
scratchIndices.push_back(nv1);
// and get the next face
nextFace = NvStripifier::FindOtherFace(edgeInfos, nv0, nv1, nextFace);
}
// Combine the forward and backwards stripification lists and put into our own face vector
Combine(forwardFaces, backwardFaces);
}
///////////////////////////////////////////////////////////////////////////////////////////
// Combine()
//
// Combines the two input face vectors and puts the result into m_faces
//
void NvStripInfo::Combine(const NvFaceInfoVec &forward, const NvFaceInfoVec &backward){
// add backward faces
int numFaces = backward.size();
for (int i = numFaces - 1; i >= 0; i--)
m_faces.push_back(backward[i]);
// add forward faces
numFaces = forward.size();
for (int i = 0; i < numFaces; i++)
m_faces.push_back(forward[i]);
}
///////////////////////////////////////////////////////////////////////////////////////////
// SharesEdge()
//
// Returns true if the input face and the current strip share an edge
//
bool NvStripInfo::SharesEdge(const NvFaceInfo* faceInfo, NvEdgeInfoVec &edgeInfos)
{
//check v0->v1 edge
NvEdgeInfo* currEdge = NvStripifier::FindEdgeInfo(edgeInfos, faceInfo->m_v0, faceInfo->m_v1);
if(IsInStrip(currEdge->m_face0) || IsInStrip(currEdge->m_face1))
return true;
//check v1->v2 edge
currEdge = NvStripifier::FindEdgeInfo(edgeInfos, faceInfo->m_v1, faceInfo->m_v2);
if(IsInStrip(currEdge->m_face0) || IsInStrip(currEdge->m_face1))
return true;
//check v2->v0 edge
currEdge = NvStripifier::FindEdgeInfo(edgeInfos, faceInfo->m_v2, faceInfo->m_v0);
if(IsInStrip(currEdge->m_face0) || IsInStrip(currEdge->m_face1))
return true;
return false;
}
///////////////////////////////////////////////////////////////////////////////////////////
// CommitStrips()
//
// "Commits" the input strips by setting their m_experimentId to -1 and adding to the allStrips
// vector
//
void NvStripifier::CommitStrips(NvStripInfoVec &allStrips, const NvStripInfoVec &strips)
{
// Iterate through strips
int numStrips = strips.size();
for (int i = 0; i < numStrips; i++){
// Tell the strip that it is now real
NvStripInfo *strip = strips[i];
strip->m_experimentId = -1;
// add to the list of real strips
allStrips.push_back(strip);
// Iterate through the faces of the strip
// Tell the faces of the strip that they belong to a real strip now
const NvFaceInfoVec &faces = strips[i]->m_faces;
int numFaces = faces.size();
for (int j = 0; j < numFaces; j++)
strip->MarkTriangle(faces[j]);
}
}
///////////////////////////////////////////////////////////////////////////////////////////
// FindTraversal()
//
// Finds the next face to start the next strip on.
//
bool NvStripifier::FindTraversal(NvFaceInfoVec &faceInfos,
NvEdgeInfoVec &edgeInfos,
NvStripInfo *strip,
NvStripStartInfo &startInfo){
// if the strip was v0->v1 on the edge, then v1 will be a vertex in the next edge.
int v = (strip->m_startInfo.m_toV1 ? strip->m_startInfo.m_startEdge->m_v1 : strip->m_startInfo.m_startEdge->m_v0);
NvFaceInfo *untouchedFace = NULL;
NvEdgeInfo *edgeIter = edgeInfos[v];
while (edgeIter != NULL){
NvFaceInfo *face0 = edgeIter->m_face0;
NvFaceInfo *face1 = edgeIter->m_face1;
if ((face0 != NULL && !strip->IsInStrip(face0)) && face1 != NULL && !strip->IsMarked(face1))
{
untouchedFace = face1;
break;
}
if ((face1 != NULL && !strip->IsInStrip(face1)) && face0 != NULL && !strip->IsMarked(face0)){
untouchedFace = face0;
break;
}
// find the next edgeIter
edgeIter = (edgeIter->m_v0 == v ? edgeIter->m_nextV0 : edgeIter->m_nextV1);
}
startInfo.m_startFace = untouchedFace;
startInfo.m_startEdge = edgeIter;
if (edgeIter != NULL)
{
if(strip->SharesEdge(startInfo.m_startFace, edgeInfos))
startInfo.m_toV1 = (edgeIter->m_v0 == v); //note! used to be m_v1
else
startInfo.m_toV1 = (edgeIter->m_v1 == v);
}
return (startInfo.m_startFace != NULL);
}
////////////////////////////////////////////////////////////////////////////////////////
// RemoveSmallStrips()
//
// allStrips is the whole strip vector...all small strips will be deleted from this list, to avoid leaking mem
// allBigStrips is an out parameter which will contain all strips above minStripLength
// faceList is an out parameter which will contain all faces which were removed from the striplist
//
void NvStripifier::RemoveSmallStrips(NvStripInfoVec& allStrips, NvStripInfoVec& allBigStrips, NvFaceInfoVec& faceList)
{
faceList.clear();
allBigStrips.clear(); //make sure these are empty
NvFaceInfoVec tempFaceList;
for(int i = 0; i < allStrips.size(); i++)
{
if(allStrips[i]->m_faces.size() < minStripLength)
{
//strip is too small, add faces to faceList
for(int j = 0; j < allStrips[i]->m_faces.size(); j++)
tempFaceList.push_back(allStrips[i]->m_faces[j]);
//and free memory
delete allStrips[i];
}
else
{
allBigStrips.push_back(allStrips[i]);
}
}
bool *bVisitedList = new bool[tempFaceList.size()];
dMemset(bVisitedList, 0, tempFaceList.size()*sizeof(bool));
VertexCache* vcache = new VertexCache(cacheSize);
int bestNumHits = -1;
int numHits;
int bestIndex;
while(1)
{
bestNumHits = -1;
//find best face to add next, given the current cache
for(int i = 0; i < tempFaceList.size(); i++)
{
if(bVisitedList[i])
continue;
numHits = CalcNumHitsFace(vcache, tempFaceList[i]);
if(numHits > bestNumHits)
{
bestNumHits = numHits;
bestIndex = i;
}
}
if(bestNumHits == -1.0f)
break;
bVisitedList[bestIndex] = true;
UpdateCacheFace(vcache, tempFaceList[bestIndex]);
faceList.push_back(tempFaceList[bestIndex]);
}
delete vcache;
delete[] bVisitedList;
}
///////////////////////////////////////////////////////////////////////////////////////////
// Stripify()
//
//
// in_indices are the input indices of the mesh to stripify
// in_cacheSize is the target cache size
//
void NvStripifier::Stripify(const WordVec &in_indices, const int in_cacheSize,
const int in_minStripLength, NvStripInfoVec &outStrips, NvFaceInfoVec& outFaceList)
{
meshJump = 0.0f;
bFirstTimeResetPoint = true; //used in FindGoodResetPoint()
//the number of times to run the experiments
int numSamples = 10;
cacheSize = in_cacheSize;
minStripLength = in_minStripLength; //this is the strip size threshold below which we dump the strip into a list
indices = in_indices;
// build the stripification info
NvFaceInfoVec allFaceInfos;
NvEdgeInfoVec allEdgeInfos;
BuildStripifyInfo(allFaceInfos, allEdgeInfos);
NvStripInfoVec allStrips;
// stripify
FindAllStrips(allStrips, allFaceInfos, allEdgeInfos, numSamples);
//split up the strips into cache friendly pieces, optimize them, then dump these into outStrips
SplitUpStripsAndOptimize(allStrips, outStrips, allEdgeInfos, outFaceList);
//clean up
for(int i = 0; i < allStrips.size(); i++)
{
delete allStrips[i];
}
for (int i = 0; i < allEdgeInfos.size(); i++)
{
NvEdgeInfo *info = allEdgeInfos[i];
while (info != NULL){
NvEdgeInfo *next = (info->m_v0 == i ? info->m_nextV0 : info->m_nextV1);
info->Unref();
info = next;
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////
// SplitUpStripsAndOptimize()
//
// Splits the input vector of strips (allBigStrips) into smaller, cache friendly pieces, then
// reorders these pieces to maximize cache hits
// The final strips are output through outStrips
//
void NvStripifier::SplitUpStripsAndOptimize(NvStripInfoVec &allStrips, NvStripInfoVec &outStrips,
NvEdgeInfoVec& edgeInfos, NvFaceInfoVec& outFaceList)
{
int threshold = cacheSize - 4;
NvStripInfoVec tempStrips;
//split up strips into threshold-sized pieces
for(int i = 0; i < allStrips.size(); i++)
{
NvStripInfo* currentStrip;
NvStripStartInfo startInfo(NULL, NULL, false);
if(allStrips[i]->m_faces.size() > threshold)
{
int numTimes = allStrips[i]->m_faces.size() / threshold;
int numLeftover = allStrips[i]->m_faces.size() % threshold;
int j;
for(j = 0; j < numTimes; j++)
{
currentStrip = new NvStripInfo(startInfo, 0, -1);
for(int faceCtr = j*threshold; faceCtr < threshold+(j*threshold); faceCtr++)
{
currentStrip->m_faces.push_back(allStrips[i]->m_faces[faceCtr]);
}
tempStrips.push_back(currentStrip);
}
int leftOff = j * threshold;
if(numLeftover != 0)
{
currentStrip = new NvStripInfo(startInfo, 0, -1);
for(int k = 0; k < numLeftover; k++)
{
currentStrip->m_faces.push_back(allStrips[i]->m_faces[leftOff++]);
}
tempStrips.push_back(currentStrip);
}
}
else
{
//we're not just doing a tempStrips.push_back(allBigStrips[i]) because
// this way we can delete allBigStrips later to free the memory
currentStrip = new NvStripInfo(startInfo, 0, -1);
for(int j = 0; j < allStrips[i]->m_faces.size(); j++)
currentStrip->m_faces.push_back(allStrips[i]->m_faces[j]);
tempStrips.push_back(currentStrip);
}
}
//add small strips to face list
NvStripInfoVec tempStrips2;
RemoveSmallStrips(tempStrips, tempStrips2, outFaceList);
outStrips.clear();
if(tempStrips2.size() != 0)
{
//Optimize for the vertex cache
VertexCache* vcache = new VertexCache(cacheSize);
float bestNumHits = -1.0f;
float numHits;
int bestIndex;
bool done = false;
int firstIndex = 0;
float minCost = 10000.0f;
for(int i = 0; i < tempStrips2.size(); i++)
{
int numNeighbors = 0;
//find strip with least number of neighbors per face
for(int j = 0; j < tempStrips2[i]->m_faces.size(); j++)
{
numNeighbors += NumNeighbors(tempStrips2[i]->m_faces[j], edgeInfos);
}
float currCost = (float)numNeighbors / (float)tempStrips2[i]->m_faces.size();
if(currCost < minCost)
{
minCost = currCost;
firstIndex = i;
}
}
UpdateCacheStrip(vcache, tempStrips2[firstIndex]);
outStrips.push_back(tempStrips2[firstIndex]);
tempStrips2[firstIndex]->visited = true;
//this n^2 algo is what slows down stripification so much....
// needs to be improved
while(1)
{
bestNumHits = -1.0f;
//find best strip to add next, given the current cache
for(int i = 0; i < tempStrips2.size(); i++)
{
if(tempStrips2[i]->visited)
continue;
numHits = CalcNumHitsStrip(vcache, tempStrips2[i]);
if(numHits > bestNumHits)
{
bestNumHits = numHits;
bestIndex = i;
}
}
if(bestNumHits == -1.0f)
break;
tempStrips2[bestIndex]->visited = true;
UpdateCacheStrip(vcache, tempStrips2[bestIndex]);
outStrips.push_back(tempStrips2[bestIndex]);
}
delete vcache;
}
}
///////////////////////////////////////////////////////////////////////////////////////////
// UpdateCacheStrip()
//
// Updates the input vertex cache with this strip's vertices
//
void NvStripifier::UpdateCacheStrip(VertexCache* vcache, NvStripInfo* strip)
{
for(int i = 0; i < strip->m_faces.size(); i++)
{
if(!vcache->InCache(strip->m_faces[i]->m_v0))
vcache->AddEntry(strip->m_faces[i]->m_v0);
if(!vcache->InCache(strip->m_faces[i]->m_v1))
vcache->AddEntry(strip->m_faces[i]->m_v1);
if(!vcache->InCache(strip->m_faces[i]->m_v2))
vcache->AddEntry(strip->m_faces[i]->m_v2);
}
}
///////////////////////////////////////////////////////////////////////////////////////////
// UpdateCacheFace()
//
// Updates the input vertex cache with this face's vertices
//
void NvStripifier::UpdateCacheFace(VertexCache* vcache, NvFaceInfo* face)
{
if(!vcache->InCache(face->m_v0))
vcache->AddEntry(face->m_v0);
if(!vcache->InCache(face->m_v1))
vcache->AddEntry(face->m_v1);
if(!vcache->InCache(face->m_v2))
vcache->AddEntry(face->m_v2);
}
///////////////////////////////////////////////////////////////////////////////////////////
// CalcNumHitsStrip()
//
// returns the number of cache hits per face in the strip
//
float NvStripifier::CalcNumHitsStrip(VertexCache* vcache, NvStripInfo* strip)
{
int numHits = 0;
int numFaces = 0;
for(int i = 0; i < strip->m_faces.size(); i++)
{
if(vcache->InCache(strip->m_faces[i]->m_v0))
numHits++;
if(vcache->InCache(strip->m_faces[i]->m_v1))
numHits++;
if(vcache->InCache(strip->m_faces[i]->m_v2))
numHits++;
numFaces++;
}
return ((float)numHits / (float)numFaces);
}
///////////////////////////////////////////////////////////////////////////////////////////
// CalcNumHitsFace()
//
// returns the number of cache hits in the face
//
int NvStripifier::CalcNumHitsFace(VertexCache* vcache, NvFaceInfo* face)
{
int numHits = 0;
if(vcache->InCache(face->m_v0))
numHits++;
if(vcache->InCache(face->m_v1))
numHits++;
if(vcache->InCache(face->m_v2))
numHits++;
return numHits;
}
///////////////////////////////////////////////////////////////////////////////////////////
// NumNeighbors()
//
// Returns the number of neighbors that this face has
//
int NvStripifier::NumNeighbors(NvFaceInfo* face, NvEdgeInfoVec& edgeInfoVec)
{
int numNeighbors = 0;
if(FindOtherFace(edgeInfoVec, face->m_v0, face->m_v1, face) != NULL)
{
numNeighbors++;
}
if(FindOtherFace(edgeInfoVec, face->m_v1, face->m_v2, face) != NULL)
{
numNeighbors++;
}
if(FindOtherFace(edgeInfoVec, face->m_v2, face->m_v0, face) != NULL)
{
numNeighbors++;
}
return numNeighbors;
}
///////////////////////////////////////////////////////////////////////////////////////////
// AvgStripSize()
//
// Finds the average strip size of the input vector of strips
//
float NvStripifier::AvgStripSize(const NvStripInfoVec &strips){
int sizeAccum = 0;
int numStrips = strips.size();
for (int i = 0; i < numStrips; i++){
NvStripInfo *strip = strips[i];
sizeAccum += strip->m_faces.size();
}
return ((float)sizeAccum) / ((float)numStrips);
}
///////////////////////////////////////////////////////////////////////////////////////////
// FindAllStrips()
//
// Does the stripification, puts output strips into vector allStrips
//
// Works by setting runnning a number of experiments in different areas of the mesh, and
// accepting the one which results in the longest strips. It then accepts this, and moves
// on to a different area of the mesh. We try to jump around the mesh some, to ensure that
// large open spans of strips get generated.
//
void NvStripifier::FindAllStrips(NvStripInfoVec &allStrips,
NvFaceInfoVec &allFaceInfos,
NvEdgeInfoVec &allEdgeInfos,
int numSamples){
// the experiments
int experimentId = 0;
int stripId = 0;
bool done = false;
int loopCtr = 0;
while (!done)
{
loopCtr++;
//
// PHASE 1: Set up numSamples * numEdges experiments
//
NvStripInfoVec *experiments = new NvStripInfoVec [numSamples * 6];
int experimentIndex = 0;
Vector<NvFaceInfo*> resetPoints;
for (int i = 0; i < numSamples; i++)
{
// Try to find another good reset point.
// If there are none to be found, we are done
NvFaceInfo *nextFace = FindGoodResetPoint(allFaceInfos, allEdgeInfos);
if (nextFace == NULL){
done = true;
break;
}
// If we have already evaluated starting at this face in this slew
// of experiments, then skip going any further
else
{
S32 i;
for (i=0; i<resetPoints.size(); i++)
if (resetPoints[i]==nextFace)
break;
if (i!=resetPoints.size())
continue;
}
// trying it now...
resetPoints.push_back(nextFace);
// otherwise, we shall now try experiments for starting on the 01,12, and 20 edges
AssertFatal(nextFace->m_stripId < 0,"strip error");
// build the strip off of this face's 0-1 edge
NvEdgeInfo *edge01 = FindEdgeInfo(allEdgeInfos, nextFace->m_v0, nextFace->m_v1);
NvStripInfo *strip01 = new NvStripInfo(NvStripStartInfo(nextFace, edge01, true), stripId++, experimentId++);
experiments[experimentIndex++].push_back(strip01);
// build the strip off of this face's 1-0 edge
NvEdgeInfo *edge10 = FindEdgeInfo(allEdgeInfos, nextFace->m_v0, nextFace->m_v1);
NvStripInfo *strip10 = new NvStripInfo(NvStripStartInfo(nextFace, edge10, false), stripId++, experimentId++);
experiments[experimentIndex++].push_back(strip10);
// build the strip off of this face's 1-2 edge
NvEdgeInfo *edge12 = FindEdgeInfo(allEdgeInfos, nextFace->m_v1, nextFace->m_v2);
NvStripInfo *strip12 = new NvStripInfo(NvStripStartInfo(nextFace, edge12, true), stripId++, experimentId++);
experiments[experimentIndex++].push_back(strip12);
// build the strip off of this face's 2-1 edge
NvEdgeInfo *edge21 = FindEdgeInfo(allEdgeInfos, nextFace->m_v1, nextFace->m_v2);
NvStripInfo *strip21 = new NvStripInfo(NvStripStartInfo(nextFace, edge21, false), stripId++, experimentId++);
experiments[experimentIndex++].push_back(strip21);
// build the strip off of this face's 2-0 edge
NvEdgeInfo *edge20 = FindEdgeInfo(allEdgeInfos, nextFace->m_v2, nextFace->m_v0);
NvStripInfo *strip20 = new NvStripInfo(NvStripStartInfo(nextFace, edge20, true), stripId++, experimentId++);
experiments[experimentIndex++].push_back(strip20);
// build the strip off of this face's 0-2 edge
NvEdgeInfo *edge02 = FindEdgeInfo(allEdgeInfos, nextFace->m_v2, nextFace->m_v0);
NvStripInfo *strip02 = new NvStripInfo(NvStripStartInfo(nextFace, edge02, false), stripId++, experimentId++);
experiments[experimentIndex++].push_back(strip02);
}
//
// PHASE 2: Iterate through that we setup in the last phase
// and really build each of the strips and strips that follow to see how
// far we get
//
int numExperiments = experimentIndex;
for (int i = 0; i < numExperiments; i++){
// get the strip set
// build the first strip of the list
experiments[i][0]->Build(allEdgeInfos, allFaceInfos);
int experimentId = experiments[i][0]->m_experimentId;
NvStripInfo *stripIter = experiments[i][0];
NvStripStartInfo startInfo(NULL, NULL, false);
while (FindTraversal(allFaceInfos, allEdgeInfos, stripIter, startInfo)){
// create the new strip info
stripIter = new NvStripInfo(startInfo, stripId++, experimentId);
// build the next strip
stripIter->Build(allEdgeInfos, allFaceInfos);
// add it to the list
experiments[i].push_back(stripIter);
}
}
//
// Phase 3: Find the experiment that has the most promise
//
int bestIndex = 0;
double bestValue = 0;
for (int i = 0; i < numExperiments; i++)
{
const float avgStripSizeWeight = 1.0f;
const float numTrisWeight = 1.0f;
float avgStripSize = AvgStripSize(experiments[i]);
float numStrips = (float) experiments[i].size();
float value = avgStripSize * avgStripSizeWeight + (avgStripSize * numStrips * numTrisWeight);
if (value > bestValue)
{
bestValue = value;
bestIndex = i;
}
}
//
// Phase 4: commit the best experiment of the bunch
//
CommitStrips(allStrips, experiments[bestIndex]);
// and destroy all of the others
for (int i = 0; i < numExperiments; i++)
{
if (i != bestIndex)
{
int numStrips = experiments[i].size();
for (int j = 0; j < numStrips; j++)
{
delete experiments[i][j];
}
}
}
// delete the array that we used for all experiments
delete [] experiments;
}
}
///////////////////////////////////////////////////////////////////////////////////////////
// CountRemainingTris()
//
// This will count the number of triangles left in the
// strip list starting at iter and finishing up at end
//
int NvStripifier::CountRemainingTris(Vector<NvStripInfo*>::iterator iter,
Vector<NvStripInfo*>::iterator end)
{
int count = 0;
while (iter != end)
{
count += (*iter)->m_faces.size();
iter++;
}
return count;
}
///////////////////////////////////////////////////////////////////////////////////////////
//MyVertexVec vertices;
//MyVertexVec optimizedVerts;
//MyFaceVec faces;
//WordVec stripIndices;
NvStripInfoVec strips;
NvFaceInfoVec leftoverFaces;
inline void SWAP(S32 & a, S32 & b) { S32 tmp = a; a=b; b=tmp; }
bool NextIsCW(const int numIndices)
{
return ((numIndices % 2) == 0);
}
///////////////////////////////////////////////////////////////////////////////////////////
// IsCW()
//
// Returns true if the face is ordered in CW fashion
//
bool IsCW(NvFaceInfo *faceInfo, int v0, int v1)
{
if (faceInfo->m_v0 == v0)
return (faceInfo->m_v1 == v1);
else if (faceInfo->m_v1 == v0)
return (faceInfo->m_v2 == v1);
else
return (faceInfo->m_v0 == v1);
// shouldn't get here
AssertFatal(0,"strip error");
return false;
}
#include "ts/tsMesh.h"
void convertStripFormat(NvStripInfo * strip, TSDrawPrimitive & draw, U32 matIndex, Vector<U16> & indices)
{
NvFaceInfo tLastFace(0, 0, 0);
int nStripFaceCount = strip->m_faces.size();
Vector<U16> stripIndices;
// Handle the first face in the strip
{
NvFaceInfo tFirstFace(strip->m_faces[0]->m_v0, strip->m_faces[0]->m_v1, strip->m_faces[0]->m_v2);
// If there is a second face, reorder vertices such that the
// unique vertex is first
if (nStripFaceCount > 1)
{
int nUnique = NvStripifier::GetUniqueVertexInB(strip->m_faces[1], &tFirstFace);
if (nUnique == tFirstFace.m_v1)
{
SWAP(tFirstFace.m_v0, tFirstFace.m_v1);
}
else if (nUnique == tFirstFace.m_v2)
{
SWAP(tFirstFace.m_v0, tFirstFace.m_v2);
}
// If there is a third face, reorder vertices such that the
// shared vertex is last
if (nStripFaceCount > 2)
{
int nShared = NvStripifier::GetSharedVertex(strip->m_faces[2], &tFirstFace);
if (nShared == tFirstFace.m_v1)
{
SWAP(tFirstFace.m_v1, tFirstFace.m_v2);
}
}
}
if(!IsCW(strip->m_faces[0], tFirstFace.m_v0, tFirstFace.m_v1))
stripIndices.push_back(tFirstFace.m_v0);
stripIndices.push_back(tFirstFace.m_v0);
stripIndices.push_back(tFirstFace.m_v1);
stripIndices.push_back(tFirstFace.m_v2);
// Update last face info
tLastFace = tFirstFace;
}
for (int j = 1; j < nStripFaceCount; j++)
{
int nUnique = NvStripifier::GetUniqueVertexInB(&tLastFace, strip->m_faces[j]);
if (nUnique != -1)
{
stripIndices.push_back(nUnique);
// Update last face info
tLastFace.m_v0 = tLastFace.m_v1;
tLastFace.m_v1 = tLastFace.m_v2;
tLastFace.m_v2 = nUnique;
}
}
draw.start = indices.size();
draw.numElements = stripIndices.size();
draw.matIndex = matIndex;
indices.setSize(draw.start+draw.numElements);
dMemcpy(indices.address()+draw.start,stripIndices.address(),draw.numElements*sizeof(U16));
}
void nvMakeStrips(Vector<TSDrawPrimitive> & primitives, Vector<U16> & indices, U32 matIndex, S32 cacheSize, S32 minStripLength)
{
// incoming indices may have some "holes" in them...e.g., may have index 1,2,3,6,7 only
// map to 0..N-1
Vector<S16> map;
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]];
}
NvStripifier * stripper = new NvStripifier();
stripper->Stripify(indices,cacheSize,minStripLength,strips,leftoverFaces);
delete stripper;
// convert into ts format...
indices.clear();
S32 startPrim = primitives.size();
primitives.setSize(startPrim+strips.size());
for (i=0; i<strips.size(); i++)
convertStripFormat(strips[i],primitives[startPrim+i],matIndex,indices);
// remap indices...
for (i=0; i<indices.size(); i++)
indices[i] = remap[indices[i]];
}
void nvStripWrap(Vector<TSDrawPrimitive> & faces, Vector<U16> & indices, S32 cacheSize, S32 minStripLength)
{
// main strip loop...
U32 start, end, i, sz;
Vector<TSDrawPrimitive> someStrips;
Vector<TSDrawPrimitive> retStrips;
Vector<U16> someIndices;
Vector<U16> retIndices;
for (start = 0; start<faces.size(); start=end)
{
for (end=start; end<faces.size() && faces[start].matIndex==faces[end].matIndex; end++)
;
// copy start to end faces into new list -- this is so we end up doing less copying
// down the road (when we are doing the look ahead simulation)
someStrips.clear();
someIndices.clear();
for (i=start;i<end;i++)
{
someIndices.push_back(indices[faces[i].start + 0]);
someIndices.push_back(indices[faces[i].start + 1]);
someIndices.push_back(indices[faces[i].start + 2]);
}
U32 matIndex = faces[start].matIndex ^ (TSDrawPrimitive::Triangles|TSDrawPrimitive::Strip);
nvMakeStrips(someStrips,someIndices,matIndex,cacheSize,minStripLength);
// now move strips and indices into larger list
S32 startStrips = retStrips.size();
retStrips.setSize(startStrips+someStrips.size());
S32 startIndices = retIndices.size();
retIndices.setSize(startIndices+someIndices.size());
dMemcpy(retStrips.address()+startStrips,someStrips.address(),someStrips.size()*sizeof(TSDrawPrimitive));
dMemcpy(retIndices.address()+startIndices,someIndices.address(),someIndices.size()*sizeof(U16));
// now adjust start of new strips
for (i=startStrips; i<retStrips.size(); i++)
retStrips[i].start += startIndices;
}
indices = retIndices;
faces = retStrips;
}
/*
inline SWAP(S32 & a, S32 & b) { S32 tmp = a; a=b; b=tmp; }
bool NextIsCW(const int numIndices)
{
return ((numIndices % 2) == 0);
}
///////////////////////////////////////////////////////////////////////////////////////////
// IsCW()
//
// Returns true if the face is ordered in CW fashion
//
bool IsCW(NvFaceInfo *faceInfo, int v0, int v1)
{
if (faceInfo->m_v0 == v0)
return (faceInfo->m_v1 == v1);
else if (faceInfo->m_v1 == v0)
return (faceInfo->m_v2 == v1);
else
return (faceInfo->m_v0 == v1);
// shouldn't get here
AssertFatal(0,"strip error");
return false;
}
///////////////////////////////////////////////////////////////////////////////////////////
// CreateStrips()
//
// Up until now, the strips had been strips at heart, but tri lists in reality.
// Now, remove redundant indices, and stitch together strips to form one, huge uber-strip
// using degenerate tris.
//
void CreateStrips()
{
NvFaceInfo tLastFace(0, 0, 0);
int nStripCount = strips.size();
AssertFatal(nStripCount > 0,"strip error");
for (int i = 0; i < nStripCount; i++)
{
NvStripInfo *strip = strips[i];
int nStripFaceCount = strip->m_faces.size();
int stripIndicesSize = stripIndices.size();
AssertFatal(nStripFaceCount > 0,"strip error");
// Handle the first face in the strip
{
NvFaceInfo tFirstFace(strip->m_faces[0]->m_v0, strip->m_faces[0]->m_v1, strip->m_faces[0]->m_v2);
// If there is a second face, reorder vertices such that the
// unique vertex is first
if (nStripFaceCount > 1)
{
int nUnique = NvStripifier::GetUniqueVertexInB(strip->m_faces[1], &tFirstFace);
if (nUnique == tFirstFace.m_v1)
{
SWAP(tFirstFace.m_v0, tFirstFace.m_v1);
}
else if (nUnique == tFirstFace.m_v2)
{
SWAP(tFirstFace.m_v0, tFirstFace.m_v2);
}
// If there is a third face, reorder vertices such that the
// shared vertex is last
if (nStripFaceCount > 2)
{
int nShared = NvStripifier::GetSharedVertex(strip->m_faces[2], &tFirstFace);
if (nShared == tFirstFace.m_v1)
{
SWAP(tFirstFace.m_v1, tFirstFace.m_v2);
}
}
}
if (i != 0)
{
// Double tap the first in the new strip
stripIndices.push_back(tFirstFace.m_v0);
// Check CW/CCW ordering
if (NextIsCW(stripIndices.size()) != IsCW(strip->m_faces[0], tFirstFace.m_v0, tFirstFace.m_v1))
{
stripIndices.push_back(tFirstFace.m_v0);
}
}
else
{
if(!IsCW(strip->m_faces[0], tFirstFace.m_v0, tFirstFace.m_v1))
stripIndices.push_back(tFirstFace.m_v0);
}
stripIndices.push_back(tFirstFace.m_v0);
stripIndices.push_back(tFirstFace.m_v1);
stripIndices.push_back(tFirstFace.m_v2);
// Update last face info
tLastFace = tFirstFace;
}
for (int j = 1; j < nStripFaceCount; j++)
{
int nUnique = NvStripifier::GetUniqueVertexInB(&tLastFace, strip->m_faces[j]);
if (nUnique != -1)
{
stripIndices.push_back(nUnique);
// Update last face info
tLastFace.m_v0 = tLastFace.m_v1;
tLastFace.m_v1 = tLastFace.m_v2;
tLastFace.m_v2 = nUnique;
}
}
// Double tap between strips.
stripIndices.push_back(tLastFace.m_v2);
// Update last face info
tLastFace.m_v0 = tLastFace.m_v1;
tLastFace.m_v1 = tLastFace.m_v2;
tLastFace.m_v2 = tLastFace.m_v2;
}
}
///////////////////////////////////////////////////////////////////////////////////////////
// OptimizeVertices()
//
// Function which optimizes the vertices in the mesh to minimize page misses
//
// Puts output verts into optimizedVerts vector
//
//
void OptimizeVertices()
{
//caches oldIndex --> newIndex conversion
int *indexCache;
indexCache = new int[vertices.size()];
dMemset(indexCache, -1, sizeof(int)*vertices.size());
//first do the strips
for(int i = 0; i < strips.size(); i++)
{
for(int j = 0; j < strips[i]->m_faces.size(); j++)
{
int v0 = strips[i]->m_faces[j]->m_v0;
int v1 = strips[i]->m_faces[j]->m_v1;
int v2 = strips[i]->m_faces[j]->m_v2;
//v0
int index = indexCache[v0];
if(index == -1)
{
optimizedVerts.push_back(vertices[v0]);
strips[i]->m_faces[j]->m_v0 = optimizedVerts.size() - 1;
indexCache[v0] = strips[i]->m_faces[j]->m_v0;
}
else
{
strips[i]->m_faces[j]->m_v0 = index;
}
//v1
index = indexCache[v1];
if(index == -1)
{
optimizedVerts.push_back(vertices[v1]);
strips[i]->m_faces[j]->m_v1 = optimizedVerts.size() - 1;
indexCache[v1] = strips[i]->m_faces[j]->m_v1;
}
else
{
strips[i]->m_faces[j]->m_v1 = index;
}
//v2
index = indexCache[v2];
if(index == -1)
{
optimizedVerts.push_back(vertices[v2]);
strips[i]->m_faces[j]->m_v2 = optimizedVerts.size() - 1;
indexCache[v2] = strips[i]->m_faces[j]->m_v2;
}
else
{
strips[i]->m_faces[j]->m_v2 = index;
}
}
}
//now do the leftover list
for(i = 0; i < leftoverFaces.size(); i++)
{
int v0 = leftoverFaces[i]->m_v0;
int v1 = leftoverFaces[i]->m_v1;
int v2 = leftoverFaces[i]->m_v2;
//v0
int index = indexCache[v0];
if(index == -1)
{
optimizedVerts.push_back(vertices[v0]);
leftoverFaces[i]->m_v0 = optimizedVerts.size() - 1;
indexCache[v0] = leftoverFaces[i]->m_v0;
}
else
{
leftoverFaces[i]->m_v0 = index;
}
//v1
index = indexCache[v1];
if(index == -1)
{
optimizedVerts.push_back(vertices[v1]);
leftoverFaces[i]->m_v1 = optimizedVerts.size() - 1;
indexCache[v1] = leftoverFaces[i]->m_v1;
}
else
{
leftoverFaces[i]->m_v1 = index;
}
//v2
index = indexCache[v2];
if(index == -1)
{
optimizedVerts.push_back(vertices[v2]);
leftoverFaces[i]->m_v2 = optimizedVerts.size() - 1;
indexCache[v2] = leftoverFaces[i]->m_v2;
}
else
{
leftoverFaces[i]->m_v2 = index;
}
}
delete[] indexCache;
AssertFatal(optimizedVerts.size() == vertices.size(),"strip error");
}
*/