///////////////////////////////////////////////////////////////////////////////////////////
// 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();
assert(numIndices >= 2);
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)){
printf("GetNextIndex: Triangle doesn't have all of its vertices\n");
printf("GetNextIndex: Duplicate triangle probably got us derailed\n");
}
return fv0;
}
if (fv1 != v0 && fv1 != v1){
if ((fv0 != v0 && fv0 != v1) || (fv2 != v0 && fv2 != v1)){
printf("GetNextIndex: Triangle doesn't have all of its vertices\n");
printf("GetNextIndex: Duplicate triangle probably got us derailed\n");
}
return fv1;
}
if (fv2 != v0 && fv2 != v1){
if ((fv0 != v0 && fv0 != v1) || (fv1 != v0 && fv1 != v1)){
printf("GetNextIndex: Triangle doesn't have all of its vertices\n");
printf("GetNextIndex: Duplicate triangle probably got us derailed\n");
}
return fv2;
}
// shouldn't get here, but let's try and fail gracefully
if( (fv0 == fv1) || (fv0 == fv2) )
return fv0;
else if( (fv1 == fv0) || (fv1 == fv2) )
return fv1;
else if( (fv2 == fv0) || (fv2 == fv1) )
return fv2;
else
return -1;
}
///////////////////////////////////////////////////////////////////////////////////////////
// GetNextIndex()
//
// Returns vertex of the input face which is "next" in the input index list
//
IC int NvStripifier::GetNextIndex(const WordVec &indices, NvFaceInfo *face){
int numIndices = indices.size();
assert(numIndices >= 2);
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)){
Msg("! WARNING: GetNextIndex: Triangle doesn't have all of its vertices");
Msg("! WARNING: GetNextIndex: Duplicate triangle probably got us derailed");
}
return fv0;
}
if (fv1 != v0 && fv1 != v1){
if ((fv0 != v0 && fv0 != v1) || (fv2 != v0 && fv2 != v1)){
Msg("! WARNING: GetNextIndex: Triangle doesn't have all of its vertices");
Msg("! WARNING: GetNextIndex: Duplicate triangle probably got us derailed");
}
return fv1;
}
if (fv2 != v0 && fv2 != v1){
if ((fv0 != v0 && fv0 != v1) || (fv1 != v0 && fv1 != v1)){
Msg("! WARNING: GetNextIndex: Triangle doesn't have all of its vertices");
Msg("! WARNING: GetNextIndex: Duplicate triangle probably got us derailed");
}
return fv2;
}
// shouldn't get here
Msg("! WARNING: GetNextIndex: Duplicate triangle sent");
return -1;
}
////////////////////////////////////////////////////////////////////////////////////////
// GenerateStrips()
//
// in_indices: input index list, the indices you would use to render
// in_numIndices: number of entries in in_indices
// primGroups: array of optimized/stripified PrimitiveGroups
// numGroups: number of groups returned
//
// Be sure to call delete[] on the returned primGroups to avoid leaking mem
//
bool GenerateStrips(const unsigned short* in_indices, const unsigned int in_numIndices,
PrimitiveGroup** primGroups, unsigned short* numGroups, bool validateEnabled)
{
int i = 0;
//put data in format that the stripifier likes
WordVec tempIndices;
tempIndices.resize(in_numIndices);
unsigned short maxIndex = 0;
unsigned short minIndex = 0xFFFF;
for(i = 0; i < in_numIndices; i++)
{
tempIndices[i] = in_indices[i];
if (in_indices[i] > maxIndex)
maxIndex = in_indices[i];
if (in_indices[i] < minIndex)
minIndex = in_indices[i];
}
NvStripInfoVec tempStrips;
NvFaceInfoVec tempFaces;
NvStripifier stripifier;
//do actual stripification
stripifier.Stripify(tempIndices, cacheSize, minStripSize, maxIndex, tempStrips, tempFaces);
//stitch strips together
IntVec stripIndices;
unsigned int numSeparateStrips = 0;
if(bListsOnly)
{
//if we're outputting only lists, we're done
*numGroups = 1;
(*primGroups) = new PrimitiveGroup[*numGroups];
PrimitiveGroup* primGroupArray = *primGroups;
//count the total number of indices
unsigned int numIndices = 0;
for(i = 0; i < tempStrips.size(); i++)
{
numIndices += tempStrips[i]->m_faces.size() * 3;
}
//add in the list
numIndices += tempFaces.size() * 3;
primGroupArray[0].type = PT_LIST;
primGroupArray[0].numIndices = numIndices;
primGroupArray[0].indices = new unsigned short[numIndices];
//do strips
unsigned int indexCtr = 0;
for(i = 0; i < tempStrips.size(); i++)
{
for(int j = 0; j < tempStrips[i]->m_faces.size(); j++)
{
//degenerates are of no use with lists
if(!NvStripifier::IsDegenerate(tempStrips[i]->m_faces[j]))
{
primGroupArray[0].indices[indexCtr++] = tempStrips[i]->m_faces[j]->m_v0;
primGroupArray[0].indices[indexCtr++] = tempStrips[i]->m_faces[j]->m_v1;
primGroupArray[0].indices[indexCtr++] = tempStrips[i]->m_faces[j]->m_v2;
}
else
{
//we've removed a tri, reduce the number of indices
primGroupArray[0].numIndices -= 3;
}
}
}
//do lists
for(i = 0; i < tempFaces.size(); i++)
{
primGroupArray[0].indices[indexCtr++] = tempFaces[i]->m_v0;
primGroupArray[0].indices[indexCtr++] = tempFaces[i]->m_v1;
primGroupArray[0].indices[indexCtr++] = tempFaces[i]->m_v2;
}
}
else
{
stripifier.CreateStrips(tempStrips, stripIndices, bStitchStrips, numSeparateStrips, bRestart, restartVal);
//if we're stitching strips together, we better get back only one strip from CreateStrips()
assert( (bStitchStrips && (numSeparateStrips == 1)) || !bStitchStrips);
//convert to output format
*numGroups = numSeparateStrips; //for the strips
if(tempFaces.size() != 0)
(*numGroups)++; //we've got a list as well, increment
(*primGroups) = new PrimitiveGroup[*numGroups];
PrimitiveGroup* primGroupArray = *primGroups;
//first, the strips
int startingLoc = 0;
for(int stripCtr = 0; stripCtr < numSeparateStrips; stripCtr++)
{
int stripLength = 0;
if(!bStitchStrips)
{
int i;
//if we've got multiple strips, we need to figure out the correct length
for(i = startingLoc; i < stripIndices.size(); i++)
{
if(stripIndices[i] == -1)
break;
}
stripLength = i - startingLoc;
}
else
stripLength = stripIndices.size();
primGroupArray[stripCtr].type = PT_STRIP;
primGroupArray[stripCtr].indices = new unsigned short[stripLength];
primGroupArray[stripCtr].numIndices = stripLength;
int indexCtr = 0;
for(int i = startingLoc; i < stripLength + startingLoc; i++)
primGroupArray[stripCtr].indices[indexCtr++] = stripIndices[i];
//we add 1 to account for the -1 separating strips
//this doesn't break the stitched case since we'll exit the loop
startingLoc += stripLength + 1;
}
//next, the list
if(tempFaces.size() != 0)
{
int faceGroupLoc = (*numGroups) - 1; //the face group is the last one
primGroupArray[faceGroupLoc].type = PT_LIST;
primGroupArray[faceGroupLoc].indices = new unsigned short[tempFaces.size() * 3];
primGroupArray[faceGroupLoc].numIndices = tempFaces.size() * 3;
int indexCtr = 0;
for(int i = 0; i < tempFaces.size(); i++)
{
primGroupArray[faceGroupLoc].indices[indexCtr++] = tempFaces[i]->m_v0;
primGroupArray[faceGroupLoc].indices[indexCtr++] = tempFaces[i]->m_v1;
primGroupArray[faceGroupLoc].indices[indexCtr++] = tempFaces[i]->m_v2;
}
}
}
//validate generated data against input
if (validateEnabled)
{
const int NUMBINS = 100;
std::vector<NvFaceInfo> in_bins[NUMBINS];
//hash input indices on first index
for (i = 0; i < in_numIndices; i += 3)
{
NvFaceInfo faceInfo(in_indices[i], in_indices[i + 1], in_indices[i + 2]);
in_bins[in_indices[i] % NUMBINS].push_back(faceInfo);
}
for (i = 0; i < *numGroups; ++i)
{
switch ((*primGroups)[i].type)
{
case PT_LIST:
{
for (int j = 0; j < (*primGroups)[i].numIndices; j += 3)
{
unsigned short v0 = (*primGroups)[i].indices[j];
unsigned short v1 = (*primGroups)[i].indices[j + 1];
unsigned short v2 = (*primGroups)[i].indices[j + 2];
//ignore degenerates
if (NvStripifier::IsDegenerate(v0, v1, v2))
continue;
if (!TestTriangle(v0, v1, v2, in_bins, NUMBINS))
{
Cleanup(tempStrips, tempFaces);
return false;
}
}
break;
}
case PT_STRIP:
{
//int brokenCtr = 0;
bool flip = false;
for (int j = 2; j < (*primGroups)[i].numIndices; ++j)
{
unsigned short v0 = (*primGroups)[i].indices[j - 2];
unsigned short v1 = (*primGroups)[i].indices[j - 1];
unsigned short v2 = (*primGroups)[i].indices[j];
if (flip)
{
//swap v1 and v2
unsigned short swap = v1;
v1 = v2;
v2 = swap;
}
//ignore degenerates
if (NvStripifier::IsDegenerate(v0, v1, v2))
{
flip = !flip;
continue;
}
if (!TestTriangle(v0, v1, v2, in_bins, NUMBINS))
{
Cleanup(tempStrips, tempFaces);
return false;
}
flip = !flip;
}
break;
}
case PT_FAN:
default:
break;
}
}
}
//clean up everything
Cleanup(tempStrips, tempFaces);
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
WordVec scratchIndices;
// 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))
{
//check to see if this next face is going to cause us to die soon
int testnv0 = nv1;
int testnv1 = NvStripifier::GetNextIndex(scratchIndices, nextFace);
NvFaceInfo* nextNextFace = NvStripifier::FindOtherFace(edgeInfos, testnv0, testnv1, nextFace);
if( (nextNextFace == NULL) || (IsMarked(nextNextFace)) )
{
//uh, oh, we're following a dead end, try swapping
NvFaceInfo* testNextFace = NvStripifier::FindOtherFace(edgeInfos, nv0, testnv1, nextFace);
if( ((testNextFace != NULL) && !IsMarked(testNextFace)) )
{
//we only swap if it buys us something
//add a "fake" degenerate face
NvFaceInfo* tempFace = new NvFaceInfo(nv0, nv1, nv0, true);
forwardFaces.push_back(tempFace);
MarkTriangle(tempFace);
scratchIndices.push_back(nv0);
testnv0 = nv0;
++m_numDegenerates;
}
}
// add this to the strip
forwardFaces.push_back(nextFace);
MarkTriangle(nextFace);
// add the index
//nv0 = nv1;
//nv1 = NvStripifier::GetNextIndex(scratchIndices, nextFace);
scratchIndices.push_back(testnv1);
// and get the next face
nv0 = testnv0;
nv1 = testnv1;
nextFace = NvStripifier::FindOtherFace(edgeInfos, nv0, nv1, nextFace);
}
// tempAllFaces is going to be forwardFaces + backwardFaces
// it's used for Unique()
NvFaceInfoVec tempAllFaces;
for(size_t i = 0; i < forwardFaces.size(); i++)
tempAllFaces.push_back(forwardFaces[i]);
//
// reset the indices for building the strip backwards and do so
//
scratchIndices.resize(0);
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;
//check to see if this next face is going to cause us to die soon
int testnv0 = nv1;
int testnv1 = NvStripifier::GetNextIndex(scratchIndices, nextFace);
NvFaceInfo* nextNextFace = NvStripifier::FindOtherFace(edgeInfos, testnv0, testnv1, nextFace);
if( (nextNextFace == NULL) || (IsMarked(nextNextFace)) )
{
//uh, oh, we're following a dead end, try swapping
NvFaceInfo* testNextFace = NvStripifier::FindOtherFace(edgeInfos, nv0, testnv1, nextFace);
if( ((testNextFace != NULL) && !IsMarked(testNextFace)) )
{
//we only swap if it buys us something
//add a "fake" degenerate face
NvFaceInfo* tempFace = new NvFaceInfo(nv0, nv1, nv0, true);
backwardFaces.push_back(tempFace);
MarkTriangle(tempFace);
scratchIndices.push_back(nv0);
testnv0 = nv0;
++m_numDegenerates;
}
}
// 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(testnv1);
// and get the next face
nv0 = testnv0;
nv1 = testnv1;
nextFace = NvStripifier::FindOtherFace(edgeInfos, nv0, nv1, nextFace);
}
// Combine the forward and backwards stripification lists and put into our own face vector
Combine(forwardFaces, backwardFaces);
}
int main(int argc, char* argv[])
{
lbfgsfloatval_t start, end;
start = clock();
Parameter* para = new Parameter(argv[1]);
end = clock();
cout << "The time of reading parameter is " << (end-start)/CLOCKS_PER_SEC << endl << endl;
start = clock();
WordVec* srcWords = new WordVec();
srcWords->readFile(para, "MixedDomainSrc");
end = clock();
cout << "The time of reading srcWordVec is " << (end-start)/CLOCKS_PER_SEC << endl << endl;
start = clock();
RAE* srcRAE = new RAE(para, srcWords, SL);
end = clock();
cout << "The time of initial source language RAE is " << (end-start)/CLOCKS_PER_SEC << endl << endl;
bool isDev = atoi(para->getPara("IsDev").c_str());
bool isTrain = atoi(para->getPara("IsTrain").c_str());
bool isTest = atoi(para->getPara("IsTest").c_str());
cout << "Start training RAES......" << endl << endl;
start = clock();
if(isTrain || isDev)
{
srcRAE->training();
}
end = clock();
cout << "The time of training RAEs is " << (end-start)/CLOCKS_PER_SEC << endl << endl;
if(isTest)
{
start = clock();
srcRAE->loadWeights(para);
end = clock();
cout << "The time of RAEs' weights is " << (end-start)/CLOCKS_PER_SEC << endl << endl;
}
// thread_num = 1
int thread_num = atoi( para->getPara("THREAD_NUM").c_str() );
vector<string> v_domains;
string domainLine = para->getPara("DomainList");
string domainName;
stringstream ss(domainLine);
int count = 0;
while(ss >> domainName)
{
if(count == thread_num)
{
break;
}
count++;
v_domains.push_back(domainName);
}
vector<Domain*> domains;
//分发文件
for (int wid = 0; wid < thread_num; wid++)
{
Domain* domain = new Domain(para, v_domains[wid], srcRAE);
domains.push_back(domain);
}
MixedDomain mixedDomains(para, domains, srcRAE);
if(isTrain)
{
mixedDomains.training();
}
else if(isDev)
{
mixedDomains.training();
mixedDomains.testing();
}
else if(isTest)
{
mixedDomains.testing();
}
return 0;
}
///////////////////////////////////////////////////////////////////////////////////////////
// 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.resize(0);
// 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(u16(v0));
scratchIndices.push_back(u16(v1));
int v2 = NvStripifier::GetNextIndex(scratchIndices, m_startInfo.m_startFace);
scratchIndices.push_back(u16(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(u16(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.resize(0);
scratchIndices.push_back(u16(v2));
scratchIndices.push_back(u16(v1));
scratchIndices.push_back(u16(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(u16(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 vector3
Combine(forwardFaces, backwardFaces);
}
////////////////////////////////////////////////////////////////////////////////////////
// GenerateStrips()
//
// in_indices: input index list, the indices you would use to render
// in_numIndices: number of entries in in_indices
// primGroups: array of optimized/stripified PrimitiveGroups
// numGroups: number of groups returned
//
// Be sure to call delete[] on the returned primGroups to avoid leaking mem
//
void GenerateStrips(const U16* in_indices, const U32 in_numIndices,
PrimitiveGroup** primGroups, U16* numGroups)
{
//put data in format that the stripifier likes
WordVec tempIndices;
tempIndices.resize(in_numIndices);
U16 maxIndex = 0;
U32 i;
for(i = 0; i < in_numIndices; i++)
{
tempIndices[i] = in_indices[i];
if(in_indices[i] > maxIndex)
maxIndex = in_indices[i];
}
NvStripInfoVec tempStrips;
NvFaceInfoVec tempFaces;
NvStripifier stripifier;
//do actual stripification
stripifier.Stripify(tempIndices, cacheSize, minStripSize, maxIndex, tempStrips, tempFaces);
//stitch strips together
IntVec stripIndices;
U32 numSeparateStrips = 0;
if(bListsOnly)
{
//if we're outputting only lists, we're done
*numGroups = 1;
(*primGroups) = new PrimitiveGroup[*numGroups];
PrimitiveGroup* primGroupArray = *primGroups;
//count the total number of indices
U32 numIndices = 0;
U32 i;
for(i = 0; i < tempStrips.size(); i++)
{
numIndices += tempStrips[i]->m_faces.size() * 3;
}
//add in the list
numIndices += tempFaces.size() * 3;
primGroupArray[0].type = PT_LIST;
primGroupArray[0].numIndices = numIndices;
primGroupArray[0].indices = new U16[numIndices];
//do strips
U32 indexCtr = 0;
for(U32 k = 0; k < tempStrips.size(); k++)
{
for(U32 j = 0; j < tempStrips[i]->m_faces.size(); j++)
{
//degenerates are of no use with lists
if(!NvStripifier::IsDegenerate(tempStrips[i]->m_faces[j]))
{
primGroupArray[0].indices[indexCtr++] = tempStrips[k]->m_faces[j]->m_v0;
primGroupArray[0].indices[indexCtr++] = tempStrips[k]->m_faces[j]->m_v1;
primGroupArray[0].indices[indexCtr++] = tempStrips[k]->m_faces[j]->m_v2;
}
else
{
//we've removed a tri, reduce the number of indices
primGroupArray[0].numIndices -= 3;
}
}
}
//do lists
for(i = 0; i < tempFaces.size(); i++)
{
primGroupArray[0].indices[indexCtr++] = tempFaces[i]->m_v0;
primGroupArray[0].indices[indexCtr++] = tempFaces[i]->m_v1;
primGroupArray[0].indices[indexCtr++] = tempFaces[i]->m_v2;
}
}
else
{
stripifier.CreateStrips(tempStrips, stripIndices, bStitchStrips, numSeparateStrips);
//if we're stitching strips together, we better get back only one strip from CreateStrips()
assert( (bStitchStrips && (numSeparateStrips == 1)) || !bStitchStrips);
//convert to output format
*numGroups = numSeparateStrips; //for the strips
if(tempFaces.size() != 0)
(*numGroups)++; //we've got a list as well, increment
(*primGroups) = new PrimitiveGroup[*numGroups];
PrimitiveGroup* primGroupArray = *primGroups;
//first, the strips
S32 startingLoc = 0;
for(U32 stripCtr = 0; stripCtr < numSeparateStrips; stripCtr++)
{
S32 stripLength = 0;
if(!bStitchStrips)
{
//if we've got multiple strips, we need to figure out the correct length
U32 i;
for(i = startingLoc; i < stripIndices.size(); i++)
{
if(stripIndices[i] == -1)
break;
}
stripLength = i - startingLoc;
}
else
stripLength = stripIndices.size();
primGroupArray[stripCtr].type = PT_STRIP;
primGroupArray[stripCtr].indices = new U16[stripLength];
primGroupArray[stripCtr].numIndices = stripLength;
S32 indexCtr = 0;
for(S32 i = startingLoc; i < stripLength + startingLoc; i++)
primGroupArray[stripCtr].indices[indexCtr++] = stripIndices[i];
//we add 1 to account for the -1 separating strips
//this doesn't break the stitched case since we'll exit the loop
startingLoc += stripLength + 1;
}
//next, the list
if(tempFaces.size() != 0)
{
S32 faceGroupLoc = (*numGroups) - 1; //the face group is the last one
primGroupArray[faceGroupLoc].type = PT_LIST;
primGroupArray[faceGroupLoc].indices = new U16[tempFaces.size() * 3];
primGroupArray[faceGroupLoc].numIndices = tempFaces.size() * 3;
S32 indexCtr = 0;
for(U32 i = 0; i < tempFaces.size(); i++)
{
primGroupArray[faceGroupLoc].indices[indexCtr++] = tempFaces[i]->m_v0;
primGroupArray[faceGroupLoc].indices[indexCtr++] = tempFaces[i]->m_v1;
primGroupArray[faceGroupLoc].indices[indexCtr++] = tempFaces[i]->m_v2;
}
}
}
//clean up everything
//delete strips
for(i = 0; i < tempStrips.size(); i++)
{
for(U32 j = 0; j < tempStrips[i]->m_faces.size(); j++)
{
delete tempStrips[i]->m_faces[j];
tempStrips[i]->m_faces[j] = NULL;
}
delete tempStrips[i];
tempStrips[i] = NULL;
}
//delete faces
for(i = 0; i < tempFaces.size(); i++)
{
delete tempFaces[i];
tempFaces[i] = NULL;
}
}
