First pass at strippifier in niflib.

NvTriStrip/NvTriStrip.cpp

+
+#include "NvTriStripObjects.h"
+#include "NvTriStrip.h"
+
+////////////////////////////////////////////////////////////////////////////////////////
+//private data
+static unsigned int cacheSize    = CACHESIZE_GEFORCE1_2;
+static bool bStitchStrips         = true;
+static unsigned int minStripSize = 0;
+static bool bListsOnly            = false;
+static unsigned int restartVal   = 0;
+static bool bRestart              = false;
+
+void EnableRestart(const unsigned int _restartVal)
+{
+	bRestart = true;
+	restartVal = _restartVal;
+}
+
+void DisableRestart()
+{
+	bRestart = false;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// SetListsOnly()
+//
+// If set to true, will return an optimized list, with no strips at all.
+//
+// Default value: false
+//
+void SetListsOnly(const bool _bListsOnly)
+{
+	bListsOnly = _bListsOnly;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// SetCacheSize()
+//
+// Sets the cache size which the stripfier uses to optimize the data.
+// Controls the length of the generated individual strips.
+// This is the "actual" cache size, so 24 for GeForce3 and 16 for GeForce1/2
+// You may want to play around with this number to tweak performance.
+//
+// Default value: 16
+//
+void SetCacheSize(const unsigned int _cacheSize)
+{
+	cacheSize = _cacheSize;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// SetStitchStrips()
+//
+// bool to indicate whether to stitch together strips into one huge strip or not.
+// If set to true, you'll get back one huge strip stitched together using degenerate
+//  triangles.
+// If set to false, you'll get back a large number of separate strips.
+//
+// Default value: true
+//
+void SetStitchStrips(const bool _bStitchStrips)
+{
+	bStitchStrips = _bStitchStrips;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// SetMinStripSize()
+//
+// Sets the minimum acceptable size for a strip, in triangles.
+// All strips generated which are shorter than this will be thrown into one big, separate list.
+//
+// Default value: 0
+//
+void SetMinStripSize(const unsigned int _minStripSize)
+{
+	minStripSize = _minStripSize;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+//Cleanup strips / faces, used by generatestrips
+void Cleanup(NvStripInfoVec& tempStrips, NvFaceInfoVec& tempFaces)
+{
+	//delete strips
+	for(size_t i = 0; i < tempStrips.size(); i++)
+	{
+		for(size_t j = 0; j < tempStrips[i]->m_faces.size(); j++)
+		{
+			delete tempStrips[i]->m_faces[j];
+			tempStrips[i]->m_faces[j] = NULL;
+		}
+		tempStrips[i]->m_faces.resize(0);
+		delete tempStrips[i];
+		tempStrips[i] = NULL;
+	}
+
+	//delete faces
+	for(size_t i = 0; i < tempFaces.size(); i++)
+	{
+		delete tempFaces[i];
+		tempFaces[i] = NULL;
+	}
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+//SameTriangle()
+//
+//Returns true if the two triangles defined by firstTri and secondTri are the same
+// The "same" is defined in this case as having the same indices with the same winding order
+//
+bool SameTriangle(unsigned short firstTri0, unsigned short firstTri1, unsigned short firstTri2, 
+				  unsigned short secondTri0, unsigned short secondTri1, unsigned short secondTri2)
+{
+	bool isSame = false;
+
+	if (firstTri0 == secondTri0)
+	{
+		if (firstTri1 == secondTri1)
+		{
+			if (firstTri2 == secondTri2)
+				isSame = true;
+		}
+	}
+	else if (firstTri0 == secondTri1)
+	{
+		if (firstTri1 == secondTri2)
+		{
+			if (firstTri2 == secondTri0)
+				isSame = true;
+		}
+	}
+	else if (firstTri0 == secondTri2)
+	{
+		if (firstTri1 == secondTri0)
+		{
+			if (firstTri2 == secondTri1)
+				isSame = true;
+		}
+	}
+
+	return isSame;
+}
+
+
+bool TestTriangle(const unsigned short v0, const unsigned short v1, const unsigned short v2, const std::vector<NvFaceInfo>* in_bins, const int NUMBINS)
+{
+	//hash this triangle
+	bool isLegit = false;
+	int ctr = v0 % NUMBINS;
+	for (size_t k = 0; k < in_bins[ctr].size(); ++k)
+	{
+		//check triangles in this bin
+		if (SameTriangle(in_bins[ctr][k].m_v0, in_bins[ctr][k].m_v1, in_bins[ctr][k].m_v2, 
+			v0, v1, v2))
+		{
+			isLegit = true;
+			break;
+		}
+	}
+	if (!isLegit)
+	{
+		ctr = v1 % NUMBINS;
+		for (size_t k = 0; k < in_bins[ctr].size(); ++k)
+		{
+			//check triangles in this bin
+			if (SameTriangle(in_bins[ctr][k].m_v0, in_bins[ctr][k].m_v1, in_bins[ctr][k].m_v2, 
+				v0, v1, v2))
+			{
+				isLegit = true;
+				break;
+			}
+		}
+		
+		if (!isLegit)
+		{
+			ctr = v2 % NUMBINS;
+			for (size_t k = 0; k < in_bins[ctr].size(); ++k)
+			{
+				//check triangles in this bin
+				if (SameTriangle(in_bins[ctr][k].m_v0, in_bins[ctr][k].m_v1, in_bins[ctr][k].m_v2, 
+					v0, v1, v2))
+				{
+					isLegit = true;
+					break;
+				}
+			}
+			
+		}
+	}
+
+	return isLegit;
+}
+	
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 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)
+{
+	//put data in format that the stripifier likes
+	WordVec tempIndices;
+	tempIndices.resize(in_numIndices);
+	unsigned short maxIndex = 0;
+	unsigned short minIndex = 0xFFFF;
+	for(size_t 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(size_t 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(size_t i = 0; i < tempStrips.size(); i++)
+		{
+			for(size_t 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(size_t 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(size_t stripCtr = 0; stripCtr < numSeparateStrips; stripCtr++)
+		{
+			int stripLength = 0;
+
+			if(!bStitchStrips)
+			{
+				//if we've got multiple strips, we need to figure out the correct length
+				size_t 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 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(size_t 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 (size_t 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 (int i = 0; i < *numGroups; ++i)
+		{
+			switch ((*primGroups)[i].type)
+			{
+				case PT_LIST:
+				{
+					for (size_t 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 (size_t 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;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// RemapIndices()
+//
+// Function to remap your indices to improve spatial locality in your vertex buffer.
+//
+// in_primGroups: array of PrimitiveGroups you want remapped
+// numGroups: number of entries in in_primGroups
+// numVerts: number of vertices in your vertex buffer, also can be thought of as the range
+//  of acceptable values for indices in your primitive groups.
+// remappedGroups: array of remapped PrimitiveGroups
+//
+// Note that, according to the remapping handed back to you, you must reorder your 
+//  vertex buffer.
+//
+void RemapIndices(const PrimitiveGroup* in_primGroups, const unsigned short numGroups,
+				  const unsigned short numVerts, PrimitiveGroup** remappedGroups)
+{
+	(*remappedGroups) = new PrimitiveGroup[numGroups];
+
+	//caches oldIndex --> newIndex conversion
+	int *indexCache;
+	indexCache = new int[numVerts];
+	memset(indexCache, -1, sizeof(int)*numVerts);
+	
+	//loop over primitive groups
+	unsigned int indexCtr = 0;
+	for(int i = 0; i < numGroups; i++)
+	{
+		unsigned int numIndices = in_primGroups[i].numIndices;
+
+		//init remapped group
+		(*remappedGroups)[i].type       = in_primGroups[i].type;
+		(*remappedGroups)[i].numIndices = numIndices;
+		(*remappedGroups)[i].indices    = new unsigned short[numIndices];
+
+		for(size_t j = 0; j < numIndices; j++)
+		{
+			int cachedIndex = indexCache[in_primGroups[i].indices[j]];
+			if(cachedIndex == -1) //we haven't seen this index before
+			{
+				//point to "last" vertex in VB
+				(*remappedGroups)[i].indices[j] = indexCtr;
+
+				//add to index cache, increment
+				indexCache[in_primGroups[i].indices[j]] = indexCtr++;
+			}
+			else
+			{
+				//we've seen this index before
+				(*remappedGroups)[i].indices[j] = cachedIndex;
+			}
+		}
+	}
+
+	delete[] indexCache;
+}
\ No newline at end of file

NvTriStrip/NvTriStrip.h

+#ifndef NVTRISTRIP_H
+#define NVTRISTRIP_H
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Public interface for stripifier
+////////////////////////////////////////////////////////////////////////////////////////
+
+//GeForce1 and 2 cache size
+#define CACHESIZE_GEFORCE1_2 16
+
+//GeForce3 cache size
+#define CACHESIZE_GEFORCE3   24
+
+enum PrimType
+{
+	PT_LIST,
+	PT_STRIP,
+	PT_FAN
+};
+
+struct PrimitiveGroup
+{
+	PrimType type;
+	unsigned int numIndices;
+	unsigned short* indices;
+
+////////////////////////////////////////////////////////////////////////////////////////
+
+	PrimitiveGroup() : type(PT_STRIP), numIndices(0), indices(NULL) {}
+	~PrimitiveGroup()
+	{
+		if(indices)
+			delete[] indices;
+		indices = NULL;
+	}
+};
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// EnableRestart()
+//
+// For GPUs that support primitive restart, this sets a value as the restart index
+//
+// Restart is meaningless if strips are not being stitched together, so enabling restart
+//  makes NvTriStrip forcing stitching.  So, you'll get back one strip.
+//
+// Default value: disabled
+//
+void EnableRestart(const unsigned int restartVal);
+
+////////////////////////////////////////////////////////////////////////////////////////
+// DisableRestart()
+//
+// For GPUs that support primitive restart, this disables using primitive restart
+//
+void DisableRestart();
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// SetCacheSize()
+//
+// Sets the cache size which the stripfier uses to optimize the data.
+// Controls the length of the generated individual strips.
+// This is the "actual" cache size, so 24 for GeForce3 and 16 for GeForce1/2
+// You may want to play around with this number to tweak performance.
+//
+// Default value: 16
+//
+void SetCacheSize(const unsigned int cacheSize);
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// SetStitchStrips()
+//
+// bool to indicate whether to stitch together strips into one huge strip or not.
+// If set to true, you'll get back one huge strip stitched together using degenerate
+//  triangles.
+// If set to false, you'll get back a large number of separate strips.
+//
+// Default value: true
+//
+void SetStitchStrips(const bool bStitchStrips);
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// SetMinStripSize()
+//
+// Sets the minimum acceptable size for a strip, in triangles.
+// All strips generated which are shorter than this will be thrown into one big, separate list.
+//
+// Default value: 0
+//
+void SetMinStripSize(const unsigned int minSize);
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// SetListsOnly()
+//
+// If set to true, will return an optimized list, with no strips at all.
+//
+// Default value: false
+//
+void SetListsOnly(const bool bListsOnly);
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 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 = false);
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// RemapIndices()
+//
+// Function to remap your indices to improve spatial locality in your vertex buffer.
+//
+// in_primGroups: array of PrimitiveGroups you want remapped
+// numGroups: number of entries in in_primGroups
+// numVerts: number of vertices in your vertex buffer, also can be thought of as the range
+//  of acceptable values for indices in your primitive groups.
+// remappedGroups: array of remapped PrimitiveGroups
+//
+// Note that, according to the remapping handed back to you, you must reorder your 
+//  vertex buffer.
+//
+// Credit goes to the MS Xbox crew for the idea for this interface.
+//
+void RemapIndices(const PrimitiveGroup* in_primGroups, const unsigned short numGroups, 
+				  const unsigned short numVerts, PrimitiveGroup** remappedGroups);
+
+#endif
\ No newline at end of file

NvTriStrip/NvTriStripObjects.h

+
+#ifndef NV_TRISTRIP_OBJECTS_H
+#define NV_TRISTRIP_OBJECTS_H
+
+#include <assert.h>
+#include <vector>
+#include <list>
+#include "VertexCache.h"
+
+/////////////////////////////////////////////////////////////////////////////////
+//
+// Types defined for stripification
+//
+/////////////////////////////////////////////////////////////////////////////////
+
+struct MyVertex {
+	float x, y, z;
+	float nx, ny, nz;
+};
+
+typedef MyVertex MyVector;
+
+struct MyFace {
+	int v1, v2, v3;
+	float nx, ny, nz;
+};
+
+
+class NvFaceInfo {
+public:
+	
+	// vertex indices
+	NvFaceInfo(int v0, int v1, int v2, bool bIsFake = false){
+		m_v0 = v0; m_v1 = v1; m_v2 = v2;
+		m_stripId      = -1;
+		m_testStripId  = -1;
+		m_experimentId = -1;
+		m_bIsFake = bIsFake;
+	}
+	
+	// data members are left public
+	int   m_v0, m_v1, m_v2;
+	int   m_stripId;      // real strip Id
+	int   m_testStripId;  // strip Id in an experiment
+	int   m_experimentId; // in what experiment was it given an experiment Id?
+	bool  m_bIsFake;      //if true, will be deleted when the strip it's in is deleted
+};
+
+// nice and dumb edge class that points knows its
+// indices, the two faces, and the next edge using
+// the lesser of the indices
+class NvEdgeInfo {
+public:
+	
+	// constructor puts 1 ref on us
+	NvEdgeInfo (int v0, int v1){
+		m_v0       = v0;
+		m_v1       = v1;
+		m_face0    = NULL;
+		m_face1    = NULL;
+		m_nextV0   = NULL;
+		m_nextV1   = NULL;
+		
+		// we will appear in 2 lists.  this is a good
+		// way to make sure we delete it the second time
+		// we hit it in the edge infos
+		m_refCount = 2;    
+		
+	}
+	
+	// ref and unref
+	void Unref () { if (--m_refCount == 0) delete this; }
+	
+	// data members are left public
+	unsigned int m_refCount;
+	NvFaceInfo  *m_face0, *m_face1;
+	int          m_v0, m_v1;
+	NvEdgeInfo  *m_nextV0, *m_nextV1;
+};
+
+
+// This class is a quick summary of parameters used
+// to begin a triangle strip.  Some operations may
+// want to create lists of such items, so they were
+// pulled out into a class
+class NvStripStartInfo {
+public:
+	NvStripStartInfo(NvFaceInfo *startFace, NvEdgeInfo *startEdge, bool toV1){
+		m_startFace    = startFace;
+		m_startEdge    = startEdge;
+		m_toV1         = toV1;
+	}
+	NvFaceInfo    *m_startFace;
+	NvEdgeInfo    *m_startEdge;
+	bool           m_toV1;      
+};
+
+
+typedef std::vector<NvFaceInfo*>     NvFaceInfoVec;
+typedef std::list  <NvFaceInfo*>     NvFaceInfoList;
+typedef std::list  <NvFaceInfoVec*>  NvStripList;
+typedef std::vector<NvEdgeInfo*>     NvEdgeInfoVec;
+
+typedef std::vector<short> WordVec;
+typedef std::vector<int> IntVec;
+typedef std::vector<MyVertex> MyVertexVec;
+typedef std::vector<MyFace> MyFaceVec;
+
+template<class T> 
+inline void SWAP(T& first, T& second) 
+{
+	T temp = first;
+	first = second;
+	second = temp;
+}
+
+// This is a summary of a strip that has been built
+class NvStripInfo {
+public:
+	
+	// A little information about the creation of the triangle strips
+	NvStripInfo(const NvStripStartInfo &startInfo, int stripId, int experimentId = -1) :
+	  m_startInfo(startInfo)
+	{
+		m_stripId      = stripId;
+		m_experimentId = experimentId;
+		visited = false;
+		m_numDegenerates = 0;
+	}
+
+	// This is an experiment if the experiment id is >= 0
+	inline bool IsExperiment () const { return m_experimentId >= 0; }
+	  
+	inline bool IsInStrip (const NvFaceInfo *faceInfo) const 
+	{
+		if(faceInfo == NULL)
+			return false;
+		  
+		return (m_experimentId >= 0 ? faceInfo->m_testStripId == m_stripId : faceInfo->m_stripId == m_stripId);
+	}
+	  
+	bool SharesEdge(const NvFaceInfo* faceInfo, NvEdgeInfoVec &edgeInfos);
+	  
+	// take the given forward and backward strips and combine them together
+	void Combine(const NvFaceInfoVec &forward, const NvFaceInfoVec &backward);
+	  
+	//returns true if the face is "unique", i.e. has a vertex which doesn't exist in the faceVec
+	bool Unique(NvFaceInfoVec& faceVec, NvFaceInfo* face);
+	  
+	// mark the triangle as taken by this strip
+	bool IsMarked    (NvFaceInfo *faceInfo);
+	void MarkTriangle(NvFaceInfo *faceInfo);
+	  
+	// build the strip
+	void Build(NvEdgeInfoVec &edgeInfos, NvFaceInfoVec &faceInfos);
+	  
+	// public data members
+	NvStripStartInfo m_startInfo;
+	NvFaceInfoVec    m_faces;
+	int              m_stripId;
+	int              m_experimentId;
+	  
+	bool visited;
+
+	int m_numDegenerates;
+};
+
+typedef std::vector<NvStripInfo*>    NvStripInfoVec;
+
+
+//The actual stripifier
+class NvStripifier {
+public:
+	
+	// Constructor
+	NvStripifier();
+	~NvStripifier();
+	
+	//the target vertex cache size, the structure to place the strips in, and the input indices
+	void Stripify(const WordVec &in_indices, const int in_cacheSize, const int in_minStripLength, 
+				  const unsigned short maxIndex, NvStripInfoVec &allStrips, NvFaceInfoVec &allFaces);
+	void CreateStrips(const NvStripInfoVec& allStrips, IntVec& stripIndices, const bool bStitchStrips, unsigned int& numSeparateStrips, const bool bRestart, const unsigned int restartVal);
+	
+	static int GetUniqueVertexInB(NvFaceInfo *faceA, NvFaceInfo *faceB);
+	//static int GetSharedVertex(NvFaceInfo *faceA, NvFaceInfo *faceB);
+	static void GetSharedVertices(NvFaceInfo *faceA, NvFaceInfo *faceB, int* vertex0, int* vertex1);
+
+	static bool IsDegenerate(const NvFaceInfo* face);
+	static bool IsDegenerate(const unsigned short v0, const unsigned short v1, const unsigned short v2);
+	
+protected:
+	
+	WordVec indices;
+	int cacheSize;
+	int minStripLength;
+	float meshJump;
+	bool bFirstTimeResetPoint;
+	
+	/////////////////////////////////////////////////////////////////////////////////
+	//
+	// Big mess of functions called during stripification
+	//
+	/////////////////////////////////////////////////////////////////////////////////
+
+	//********************
+	bool IsMoneyFace(const NvFaceInfo& face);
+	bool FaceContainsIndex(const NvFaceInfo& face, const unsigned int index);
+
+	bool IsCW(NvFaceInfo *faceInfo, int v0, int v1);
+	bool NextIsCW(const int numIndices);
+	
+	static int  GetNextIndex(const WordVec &indices, NvFaceInfo *face);
+	static NvEdgeInfo *FindEdgeInfo(NvEdgeInfoVec &edgeInfos, int v0, int v1);
+	static NvFaceInfo *FindOtherFace(NvEdgeInfoVec &edgeInfos, int v0, int v1, NvFaceInfo *faceInfo);
+	NvFaceInfo *FindGoodResetPoint(NvFaceInfoVec &faceInfos, NvEdgeInfoVec &edgeInfos);
+	
+	void FindAllStrips(NvStripInfoVec &allStrips, NvFaceInfoVec &allFaceInfos, NvEdgeInfoVec &allEdgeInfos, int numSamples);
+	void SplitUpStripsAndOptimize(NvStripInfoVec &allStrips, NvStripInfoVec &outStrips, NvEdgeInfoVec& edgeInfos, NvFaceInfoVec& outFaceList);
+	void RemoveSmallStrips(NvStripInfoVec& allStrips, NvStripInfoVec& allBigStrips, NvFaceInfoVec& faceList);
+	
+	bool FindTraversal(NvFaceInfoVec &faceInfos, NvEdgeInfoVec &edgeInfos, NvStripInfo *strip, NvStripStartInfo &startInfo);
+	int  CountRemainingTris(std::list<NvStripInfo*>::iterator iter, std::list<NvStripInfo*>::iterator  end);
+	
+	void CommitStrips(NvStripInfoVec &allStrips, const NvStripInfoVec &strips);
+	
+	float AvgStripSize(const NvStripInfoVec &strips);
+	int FindStartPoint(NvFaceInfoVec &faceInfos, NvEdgeInfoVec &edgeInfos);
+	
+	void UpdateCacheStrip(VertexCache* vcache, NvStripInfo* strip);
+	void UpdateCacheFace(VertexCache* vcache, NvFaceInfo* face);
+	float CalcNumHitsStrip(VertexCache* vcache, NvStripInfo* strip);
+	int CalcNumHitsFace(VertexCache* vcache, NvFaceInfo* face);
+	int NumNeighbors(NvFaceInfo* face, NvEdgeInfoVec& edgeInfoVec);
+	
+	void BuildStripifyInfo(NvFaceInfoVec &faceInfos, NvEdgeInfoVec &edgeInfos, const unsigned short maxIndex);
+	bool AlreadyExists(NvFaceInfo* faceInfo, NvFaceInfoVec& faceInfos);
+	
+	// let our strip info classes and the other classes get
+	// to these protected stripificaton methods if they want
+	friend class NvStripInfo;
+};
+
+#endif

NvTriStrip/VertexCache.cpp

+
+
+#include "VertexCache.h"
+
+VertexCache::VertexCache()
+{
+  VertexCache(16);
+}
+
+
+VertexCache::VertexCache(int size)
+{
+  numEntries = size;
+
+  entries = new int[numEntries];
+
+  for(int i = 0; i < numEntries; i++)
+    entries[i] = -1;
+}
+
+
+VertexCache::~VertexCache()
+{
+  delete[] entries;
+}
+
+
+int VertexCache::At(int index)
+{
+  return entries[index];
+}
+
+
+void VertexCache::Set(int index, int value)
+{
+  entries[index] = value;
+}
+
+
+void VertexCache::Clear()
+{
+  for(int i = 0; i < numEntries; i++)
+    entries[i] = -1;
+}
+
+void VertexCache::Copy(VertexCache* inVcache)
+{
+  for(int i = 0; i < numEntries; i++)
+  {
+    inVcache->Set(i, entries[i]);
+  }
+}
+
+bool VertexCache::InCache(int entry)
+{
+  bool returnVal = false;
+
+  for(int i = 0; i < numEntries; i++)
+  {
+    if(entries[i] == entry)
+    {
+      returnVal = true;
+      break;
+    }
+  }
+
+  return returnVal;
+}
+
+
+int VertexCache::AddEntry(int entry)
+{
+  int removed;
+
+  removed = entries[numEntries - 1];
+
+  //push everything right one
+  for(int i = numEntries - 2; i >= 0; i--)
+  {
+    entries[i + 1] = entries[i];
+  }
+
+  entries[0] = entry;
+
+  return removed;
+}
+
+  
\ No newline at end of file

NvTriStrip/VertexCache.h

+  
+#ifndef VERTEX_CACHE_H
+
+#define VERTEX_CACHE_H
+
+class VertexCache
+{
+	
+public:
+	VertexCache(int size);
+	VertexCache();
+	~VertexCache();	
+	bool InCache(int entry);
+	int AddEntry(int entry);
+	void Clear();
+	void Copy(VertexCache* inVcache) ;
+	int At(int index);
+	void Set(int index, int value);
+
+private:
+
+  int *entries;
+  int numEntries;
+
+};
+
+#endif

TriStripper/connectivity_graph.cpp

+//
+// Copyright (C) 2004 Tanguy Fautr.
+// For conditions of distribution and use,
+// see copyright notice in tri_stripper.h
+//
+//////////////////////////////////////////////////////////////////////
+// SVN: $Id: connectivity_graph.cpp 86 2005-06-08 17:47:27Z gpsnoopy $
+//////////////////////////////////////////////////////////////////////
+
+#include "detail/connectivity_graph.h"
+
+#include <algorithm>
+
+
+
+
+namespace triangle_stripper {
+
+	namespace detail {
+
+
+
+
+namespace
+{
+
+	class tri_edge : public triangle_edge
+	{
+	public:
+		tri_edge(index A, index B, size_t TriPos)
+			: triangle_edge(A, B), m_TriPos(TriPos) { }
+
+		size_t TriPos() const { return m_TriPos; }
+
+	private:
+		size_t	m_TriPos;
+	};
+
+
+	class cmp_tri_edge_lt
+	{
+	public:
+		bool operator() (const tri_edge & a, const tri_edge & b) const;
+	};
+
+
+	typedef std::vector<tri_edge> edge_map;
+
+
+	void LinkNeighbours(graph_array<triangle> & Triangles, const edge_map & EdgeMap, const tri_edge Edge);
+
+}
+
+
+
+
+void make_connectivity_graph(graph_array<triangle> & Triangles, const indices & Indices)
+{
+	assert(Triangles.size() == (Indices.size() / 3));
+
+	// Fill the triangle data
+	for (size_t i = 0; i < Triangles.size(); ++i)
+		Triangles[i] = triangle(Indices[i * 3 + 0], Indices[i * 3 + 1], Indices[i * 3 + 2]);
+
+	// Build an edge lookup table
+	edge_map EdgeMap;
+	EdgeMap.reserve(Triangles.size() * 3);
+
+	for (size_t i = 0; i < Triangles.size(); ++i) {
+
+		const triangle & Tri = * Triangles[i];
+
+		EdgeMap.push_back(tri_edge(Tri.A(), Tri.B(), i)); 
+		EdgeMap.push_back(tri_edge(Tri.B(), Tri.C(), i)); 
+		EdgeMap.push_back(tri_edge(Tri.C(), Tri.A(), i)); 
+	}
+
+	std::sort(EdgeMap.begin(), EdgeMap.end(), cmp_tri_edge_lt());
+
+	// Link neighbour triangles together using the lookup table
+	for (size_t i = 0; i < Triangles.size(); ++i) {
+
+		const triangle & Tri = * Triangles[i];
+
+		LinkNeighbours(Triangles, EdgeMap, tri_edge(Tri.B(), Tri.A(), i)); 
+		LinkNeighbours(Triangles, EdgeMap, tri_edge(Tri.C(), Tri.B(), i)); 
+		LinkNeighbours(Triangles, EdgeMap, tri_edge(Tri.A(), Tri.C(), i)); 
+	}
+}
+
+
+
+namespace
+{
+	
+	inline bool cmp_tri_edge_lt::operator() (const tri_edge & a, const tri_edge & b) const
+	{
+		const index A1 = a.A();
+		const index B1 = a.B();
+		const index A2 = b.A();
+		const index B2 = b.B();
+
+		if ((A1 < A2) || ((A1 == A2) && (B1 < B2)))
+			return true;
+		else
+			return false;
+	}
+
+
+	void LinkNeighbours(graph_array<triangle> & Triangles, const edge_map & EdgeMap, const tri_edge Edge)
+	{
+		// Find the first edge equal to Edge
+		edge_map::const_iterator it = std::lower_bound(EdgeMap.begin(), EdgeMap.end(), Edge, cmp_tri_edge_lt());
+
+		// See if there are any other edges that are equal
+		// (if so, it means that more than 2 triangles are sharing the same edge,
+		//  which is unlikely but not impossible)
+		for (; (it != EdgeMap.end()) && (Edge == (* it)); ++it)
+			Triangles.insert_arc(Edge.TriPos(), it->TriPos());
+
+		// Note: degenerated triangles will also point themselves as neighbour triangles
+	}
+
+}
+
+
+
+
+	} // namespace detail
+
+} // namespace detail
+

TriStripper/detail/cache_simulator.h

+//
+// Copyright (C) 2004 Tanguy Fautr.
+// For conditions of distribution and use,
+// see copyright notice in tri_stripper.h
+//
+//////////////////////////////////////////////////////////////////////
+// SVN: $Id: cache_simulator.h 86 2005-06-08 17:47:27Z gpsnoopy $
+//////////////////////////////////////////////////////////////////////
+
+#ifndef TRI_STRIPPER_HEADER_GUARD_CACHE_SIMULATOR_H
+#define TRI_STRIPPER_HEADER_GUARD_CACHE_SIMULATOR_H
+
+#include <algorithm>
+#include <limits>
+#include <deque>
+
+
+
+
+namespace triangle_stripper {
+
+	namespace detail {
+
+
+
+
+class cache_simulator
+{
+public:
+	cache_simulator();
+
+	void clear();
+	void resize(size_t Size);
+	void reset();
+	void push_cache_hits(bool Enabled = true);
+	size_t size() const;
+
+	void push(index i, bool CountCacheHit = false);
+	void merge(const cache_simulator & Backward, size_t PossibleOverlap);
+
+	void reset_hitcount();
+	size_t hitcount() const;
+
+protected:
+	typedef std::deque<index> indices_deque;
+
+	indices_deque	m_Cache;
+	size_t			m_NbHits;
+	bool			m_PushHits;
+};
+
+
+
+
+
+//////////////////////////////////////////////////////////////////////////
+// cache_simulator inline functions
+//////////////////////////////////////////////////////////////////////////
+
+inline cache_simulator::cache_simulator()
+	: m_NbHits(0),
+	  m_PushHits(true)
+{
+
+}
+
+
+inline void cache_simulator::clear()
+{
+	reset_hitcount();
+	m_Cache.clear();
+}
+
+
+inline void cache_simulator::resize(const size_t Size)
+{
+	m_Cache.resize(Size, std::numeric_limits<index>::max());
+}
+
+
+inline void cache_simulator::reset()
+{
+	std::fill(m_Cache.begin(), m_Cache.end(), std::numeric_limits<index>::max());
+	reset_hitcount();
+}
+
+
+inline void cache_simulator::push_cache_hits(bool Enabled)
+{
+	m_PushHits = Enabled;
+}
+
+
+inline size_t cache_simulator::size() const
+{
+	return m_Cache.size();
+}
+
+
+inline void cache_simulator::push(const index i, const bool CountCacheHit)
+{
+	if (CountCacheHit || m_PushHits) {
+
+		if (std::find(m_Cache.begin(), m_Cache.end(), i) != m_Cache.end()) {
+
+			// Should we count the cache hits?
+			if (CountCacheHit)
+				++m_NbHits;
+			
+			// Should we not push the index into the cache if it's a cache hit?
+			if (! m_PushHits)
+				return;
+		}
+	}
+	    
+	// Manage the indices cache as a FIFO structure
+	m_Cache.push_front(i);
+	m_Cache.pop_back();
+}
+
+
+inline void cache_simulator::merge(const cache_simulator & Backward, const size_t PossibleOverlap)
+{
+	const size_t Overlap = std::min(PossibleOverlap, size());
+
+	for (size_t i = 0; i < Overlap; ++i)
+		push(Backward.m_Cache[i], true);
+
+	m_NbHits += Backward.m_NbHits;
+}
+
+
+inline void cache_simulator::reset_hitcount()
+{
+	m_NbHits = 0;
+}
+
+
+inline size_t cache_simulator::hitcount() const
+{
+	return m_NbHits;
+}
+
+
+
+
+	} // namespace detail
+
+} // namespace triangle_stripper
+
+
+
+
+#endif // TRI_STRIPPER_HEADER_GUARD_CACHE_SIMULATOR_H

TriStripper/detail/connectivity_graph.h

+//
+// Copyright (C) 2004 Tanguy Fautr.
+// For conditions of distribution and use,
+// see copyright notice in tri_stripper.h
+//
+//////////////////////////////////////////////////////////////////////
+// SVN: $Id: connectivity_graph.h 86 2005-06-08 17:47:27Z gpsnoopy $
+//////////////////////////////////////////////////////////////////////
+
+#ifndef TRI_STRIPPER_HEADER_GUARD_CONNECTIVITY_GRAPH_H
+#define TRI_STRIPPER_HEADER_GUARD_CONNECTIVITY_GRAPH_H
+
+#include "public_types.h"
+
+#include "graph_array.h"
+#include "types.h"
+
+
+
+
+namespace triangle_stripper
+{
+
+	namespace detail
+	{
+
+		void make_connectivity_graph(graph_array<triangle> & Triangles, const indices & Indices);
+
+	}
+
+}
+
+
+
+
+#endif // TRI_STRIPPER_HEADER_GUARD_CONNECTIVITY_GRAPH_H

TriStripper/detail/graph_array.h

+//
+// Copyright (C) 2004 Tanguy Fautr.
+// For conditions of distribution and use,
+// see copyright notice in tri_stripper.h
+//
+//////////////////////////////////////////////////////////////////////
+// SVN: $Id: graph_array.h 86 2005-06-08 17:47:27Z gpsnoopy $
+//////////////////////////////////////////////////////////////////////
+
+#ifndef TRI_STRIPPER_HEADER_GUARD_GRAPH_ARRAY_H
+#define TRI_STRIPPER_HEADER_GUARD_GRAPH_ARRAY_H
+
+#include <cassert>
+#include <algorithm>
+#include <functional>
+#include <limits>
+#include <vector>
+
+
+
+
+namespace triangle_stripper {
+
+	namespace detail {
+
+
+
+
+// graph_array main class
+template <class nodetype>
+class graph_array 
+{
+public:
+
+	class arc;
+	class node;
+
+	// New types
+	typedef size_t											nodeid;
+	typedef nodetype										value_type;
+	typedef std::vector<node>								node_vector;
+	typedef typename node_vector::iterator					node_iterator;
+	typedef typename node_vector::const_iterator			const_node_iterator;
+	typedef typename node_vector::reverse_iterator			node_reverse_iterator;
+	typedef typename node_vector::const_reverse_iterator	const_node_reverse_iterator;
+
+	typedef graph_array<nodetype> graph_type;
+	
+
+	// graph_array::arc class
+	class arc
+	{
+	public:
+		node_iterator terminal() const;
+
+	protected:
+		friend class graph_array<nodetype>;
+
+		arc(node_iterator Terminal);
+	
+		node_iterator	m_Terminal;
+	};
+
+
+	// New types
+	typedef std::vector<arc>					arc_list;
+	typedef typename arc_list::iterator			out_arc_iterator;
+	typedef typename arc_list::const_iterator	const_out_arc_iterator;
+
+
+	// graph_array::node class
+	class node
+	{
+	public:
+		void mark();
+		void unmark();
+		bool marked() const;
+
+		bool out_empty() const;
+		size_t out_size() const;
+
+		out_arc_iterator out_begin();
+		out_arc_iterator out_end();
+		const_out_arc_iterator out_begin() const;
+		const_out_arc_iterator out_end() const;
+
+		value_type & operator * ();
+		value_type * operator -> ();
+		const value_type & operator * () const;
+		const value_type * operator -> () const;
+
+		value_type & operator = (const value_type & Elem);
+
+	protected:
+		friend class graph_array<nodetype>;
+		friend class std::vector<node>;
+
+		node(arc_list & Arcs);
+
+		arc_list &		m_Arcs;
+		size_t			m_Begin;
+		size_t			m_End;
+
+		value_type		m_Elem;
+		bool			m_Marker;
+	};
+
+
+	graph_array();
+	explicit graph_array(size_t NbNodes);
+
+	// Node related member functions
+	bool empty() const;
+	size_t size() const;
+
+	node & operator [] (nodeid i);
+	const node & operator [] (nodeid i) const;
+
+	node_iterator begin();
+	node_iterator end();
+	const_node_iterator begin() const;
+	const_node_iterator end() const;
+
+	node_reverse_iterator rbegin();
+	node_reverse_iterator rend();
+	const_node_reverse_iterator rbegin() const;
+	const_node_reverse_iterator rend() const;
+
+	// Arc related member functions
+	out_arc_iterator insert_arc(nodeid Initial, nodeid Terminal);
+	out_arc_iterator insert_arc(node_iterator Initial, node_iterator Terminal);
+
+	// Optimized (overloaded) functions
+	void swap(graph_type & Right);
+	friend void swap(graph_type & Left, graph_type & Right)										{ Left.swap(Right); }
+
+protected:
+	graph_array(const graph_type &);
+	graph_type & operator = (const graph_type &);
+
+	node_vector		m_Nodes;
+	arc_list		m_Arcs;
+};
+
+
+
+// Additional "low level", graph related, functions
+template <class nodetype>
+void unmark_nodes(graph_array<nodetype> & G);
+
+
+
+
+
+//////////////////////////////////////////////////////////////////////////
+// graph_array::arc inline functions
+//////////////////////////////////////////////////////////////////////////
+
+template <class N>
+inline graph_array<N>::arc::arc(node_iterator Terminal)
+	: m_Terminal(Terminal) { }
+
+
+template <class N>
+inline typename graph_array<N>::node_iterator graph_array<N>::arc::terminal() const
+{
+	return m_Terminal;
+}
+
+
+
+//////////////////////////////////////////////////////////////////////////
+// graph_array::node inline functions
+//////////////////////////////////////////////////////////////////////////
+
+template <class N>
+inline graph_array<N>::node::node(arc_list & Arcs)
+	: m_Arcs(Arcs),
+	  m_Begin(std::numeric_limits<size_t>::max()),
+	  m_End(std::numeric_limits<size_t>::max()),
+	  m_Marker(false)
+{
+
+}
+
+
+template <class N>
+inline void graph_array<N>::node::mark()
+{
+	m_Marker = true;
+}
+
+
+template <class N>
+inline void graph_array<N>::node::unmark()
+{
+	m_Marker = false;
+}
+
+
+template <class N>
+inline bool graph_array<N>::node::marked() const
+{
+	return m_Marker;
+}
+
+
+template <class N>
+inline bool graph_array<N>::node::out_empty() const
+{
+	return (m_Begin == m_End);
+}
+
+
+template <class N>
+inline size_t graph_array<N>::node::out_size() const
+{
+	return (m_End - m_Begin);
+}
+
+
+template <class N>
+inline typename graph_array<N>::out_arc_iterator graph_array<N>::node::out_begin()
+{
+	return (m_Arcs.begin() + m_Begin);
+}
+
+
+template <class N>
+inline typename graph_array<N>::out_arc_iterator graph_array<N>::node::out_end()
+{
+	return (m_Arcs.begin() + m_End);
+}
+
+
+template <class N>
+inline typename graph_array<N>::const_out_arc_iterator graph_array<N>::node::out_begin() const
+{
+	return (m_Arcs.begin() + m_Begin);
+}
+
+
+template <class N>
+inline typename graph_array<N>::const_out_arc_iterator graph_array<N>::node::out_end() const
+{
+	return (m_Arcs.begin() + m_End);
+}
+
+
+template <class N>
+inline N & graph_array<N>::node::operator * ()
+{
+	return m_Elem;
+}
+
+
+template <class N>
+inline N * graph_array<N>::node::operator -> ()
+{
+	return &m_Elem;
+}
+
+
+template <class N>
+inline const N & graph_array<N>::node::operator * () const
+{
+	return m_Elem;
+}
+
+
+template <class N>
+inline const N * graph_array<N>::node::operator -> () const
+{
+	return &m_Elem;
+}
+
+
+template <class N>
+inline N & graph_array<N>::node::operator = (const N & Elem)
+{
+	return (m_Elem = Elem);
+}
+
+
+
+//////////////////////////////////////////////////////////////////////////
+// graph_array inline functions
+//////////////////////////////////////////////////////////////////////////
+
+template <class N>
+inline graph_array<N>::graph_array() { }
+
+
+template <class N>
+inline graph_array<N>::graph_array(const size_t NbNodes)
+	: m_Nodes(NbNodes, node(m_Arcs))
+{
+	// optimisation: we consider that, averagely, a triangle may have at least 2 neighbours
+	// otherwise we are just wasting a bit of memory, but not that much
+	m_Arcs.reserve(NbNodes * 2);
+}
+
+
+template <class N>
+inline bool graph_array<N>::empty() const
+{
+	return m_Nodes.empty();
+}
+
+
+template <class N>
+inline size_t graph_array<N>::size() const 
+{
+	return m_Nodes.size();
+}
+
+
+template <class N>
+inline typename graph_array<N>::node & graph_array<N>::operator [] (const nodeid i)
+{
+	assert(i < size());
+
+	return m_Nodes[i];
+}
+
+
+template <class N>
+inline const typename graph_array<N>::node & graph_array<N>::operator [] (const nodeid i) const
+{
+	assert(i < size());
+
+	return m_Nodes[i];
+}
+
+
+template <class N>
+inline typename graph_array<N>::node_iterator graph_array<N>::begin()
+{
+	return m_Nodes.begin();
+}
+
+
+template <class N>
+inline typename graph_array<N>::node_iterator graph_array<N>::end()
+{
+	return m_Nodes.end();
+}
+
+
+template <class N>
+inline typename graph_array<N>::const_node_iterator graph_array<N>::begin() const
+{
+	return m_Nodes.begin();
+}
+
+
+template <class N>
+inline typename graph_array<N>::const_node_iterator graph_array<N>::end() const
+{
+	return m_Nodes.end();
+}
+
+
+template <class N>
+inline typename graph_array<N>::node_reverse_iterator graph_array<N>::rbegin()
+{
+	return m_Nodes.rbegin();
+}
+
+
+template <class N>
+inline typename graph_array<N>::node_reverse_iterator graph_array<N>::rend()
+{
+	return m_Nodes.rend();
+}
+
+
+template <class N>
+inline typename graph_array<N>::const_node_reverse_iterator graph_array<N>::rbegin() const
+{
+	return m_Nodes.rbegin();
+}
+
+
+template <class N>
+inline typename graph_array<N>::const_node_reverse_iterator graph_array<N>::rend() const
+{
+	return m_Nodes.rend();
+}
+
+
+template <class N>
+inline typename graph_array<N>::out_arc_iterator graph_array<N>::insert_arc(const nodeid Initial, const nodeid Terminal)
+{
+	assert(Initial < size());
+	assert(Terminal < size());
+
+	return insert_arc(m_Nodes.begin() + Initial, m_Nodes.begin() + Terminal);
+}
+
+
+template <class N>
+inline typename graph_array<N>::out_arc_iterator graph_array<N>::insert_arc(const node_iterator Initial, const node_iterator Terminal)
+{
+	assert((Initial >= begin()) && (Initial < end()));
+	assert((Terminal >= begin()) && (Terminal < end()));
+
+	node & Node = * Initial;
+
+	if (Node.out_empty()) {
+
+		Node.m_Begin = m_Arcs.size();
+		Node.m_End = m_Arcs.size() + 1;
+
+	} else {
+
+		// we optimise here for make_connectivity_graph()
+		// we know all the arcs for a given node are successively and sequentially added
+		assert(Node.m_End == m_Arcs.size());
+		
+		++(Node.m_End);
+	}
+
+	m_Arcs.push_back(arc(Terminal));
+
+	out_arc_iterator it = m_Arcs.end();
+	return (--it);
+}
+
+
+template <class N>
+inline void graph_array<N>::swap(graph_type & Right)
+{
+	std::swap(m_Nodes, Right.m_Nodes);
+	std::swap(m_Arcs, Right.m_Arcs);
+}
+
+
+
+//////////////////////////////////////////////////////////////////////////
+// additional functions
+//////////////////////////////////////////////////////////////////////////
+
+template <class N>
+inline void unmark_nodes(graph_array<N> & G)
+{
+	std::for_each(G.begin(), G.end(), std::mem_fun_ref(&graph_array<N>::node::unmark));
+}
+
+
+
+
+	} // namespace detail
+
+} // namespace triangle_stripper
+
+
+
+
+#endif // TRI_STRIPPER_HEADER_GUARD_GRAPH_ARRAY_H

TriStripper/detail/heap_array.h

+//
+// Copyright (C) 2004 Tanguy Fautr.
+// For conditions of distribution and use,
+// see copyright notice in tri_stripper.h
+//
+//////////////////////////////////////////////////////////////////////
+// SVN: $Id: heap_array.h 86 2005-06-08 17:47:27Z gpsnoopy $
+//////////////////////////////////////////////////////////////////////
+
+#ifndef TRI_STRIPPER_HEADER_GUARD_HEAP_ARRAY_H
+#define TRI_STRIPPER_HEADER_GUARD_HEAP_ARRAY_H
+
+#include <vector>
+
+
+
+
+namespace triangle_stripper {
+
+	namespace detail {
+
+
+
+
+// mutable heap
+// can be interfaced pretty muck like an array
+template <class T, class CmpT = std::less<T> > 
+class heap_array
+{
+public:
+
+	// Pre = PreCondition, Post = PostCondition 
+
+	heap_array() : m_Locked(false) { }		// Post: ((size() == 0) && ! locked())
+
+	void clear();							// Post: ((size() == 0) && ! locked())
+
+	void reserve(size_t Size);
+	size_t size() const;
+
+	bool empty() const;
+	bool locked() const;
+	bool removed(size_t i) const;			// Pre: (valid(i))
+	bool valid(size_t i) const;
+
+	size_t position(size_t i) const;		// Pre: (valid(i))
+
+	const T & top() const;					// Pre: (! empty())
+	const T & peek(size_t i) const;			// Pre: (! removed(i))
+	const T & operator [] (size_t i) const;	// Pre: (! removed(i))
+
+	void lock();							// Pre: (! locked())   Post: (locked())
+	size_t push(const T & Elem);			// Pre: (! locked())
+
+	void pop();								// Pre: (locked() && ! empty())
+	void erase(size_t i);					// Pre: (locked() && ! removed(i))
+	void update(size_t i, const T & Elem);	// Pre: (locked() && ! removed(i))
+
+protected:
+
+	heap_array(const heap_array &);
+	heap_array & operator = (const heap_array &);
+
+	class linker
+	{
+	public:
+		linker(const T & Elem, size_t i)
+			: m_Elem(Elem), m_Index(i) { }
+
+		T		m_Elem;
+		size_t	m_Index;
+	};
+
+	typedef std::vector<linker> linked_heap;
+	typedef std::vector<size_t> finder;
+
+	void Adjust(size_t i);
+	void Swap(size_t a, size_t b);
+	bool Less(const linker & a, const linker & b) const;
+
+	linked_heap	m_Heap;
+	finder		m_Finder;
+	CmpT		m_Compare;
+	bool		m_Locked;
+};
+
+
+
+
+
+//////////////////////////////////////////////////////////////////////////
+// heap_indexed inline functions
+//////////////////////////////////////////////////////////////////////////
+
+template <class T, class CmpT> 
+inline void heap_array<T, CmpT>::clear()
+{
+	m_Heap.clear();
+	m_Finder.clear();
+	m_Locked = false;
+}
+
+
+template <class T, class CmpT> 
+inline bool heap_array<T, CmpT>::empty() const
+{
+	return m_Heap.empty();
+}
+
+
+template <class T, class CmpT>
+inline bool heap_array<T, CmpT>::locked() const
+{
+	return m_Locked;
+}
+
+
+template <class T, class CmpT>
+inline void heap_array<T, CmpT>::reserve(const size_t Size)
+{
+	m_Heap.reserve(Size);
+	m_Finder.reserve(Size);
+}
+
+
+template <class T, class CmpT> 
+inline size_t heap_array<T, CmpT>::size() const
+{
+	return m_Heap.size();
+}
+
+
+template <class T, class CmpT> 
+inline const T & heap_array<T, CmpT>::top() const
+{
+	assert(! empty());
+
+	return m_Heap.front().m_Elem;
+}
+
+
+template <class T, class CmpT> 
+inline const T & heap_array<T, CmpT>::peek(const size_t i) const
+{
+	assert(! removed(i));
+
+	return (m_Heap[m_Finder[i]].m_Elem);
+}
+
+
+template <class T, class CmpT> 
+inline const T & heap_array<T, CmpT>::operator [] (const size_t i) const
+{
+	return peek(i);
+}
+
+
+template <class T, class CmpT> 
+inline void heap_array<T, CmpT>::pop()
+{
+	assert(locked());
+	assert(! empty());
+
+	Swap(0, size() - 1);
+	m_Heap.pop_back();
+
+	if (! empty())
+		Adjust(0);
+}
+
+
+template <class T, class CmpT>
+inline void heap_array<T, CmpT>::lock()
+{
+	assert(! locked());
+
+	m_Locked =true;
+}
+
+
+template <class T, class CmpT> 
+inline size_t heap_array<T, CmpT>::push(const T & Elem)
+{
+	assert(! locked());
+
+	const size_t Id = size();
+	m_Finder.push_back(Id);
+	m_Heap.push_back(linker(Elem, Id));
+	Adjust(Id);
+
+	return Id;
+}
+
+
+template <class T, class CmpT>
+inline void heap_array<T, CmpT>::erase(const size_t i)
+{
+	assert(locked());
+	assert(! removed(i));
+
+	const size_t j = m_Finder[i];
+	Swap(j, size() - 1);
+	m_Heap.pop_back();
+
+	if (j != size())
+		Adjust(j);
+}
+
+
+template <class T, class CmpT>
+inline bool heap_array<T, CmpT>::removed(const size_t i) const
+{
+	assert(valid(i));
+
+	return (m_Finder[i] >= m_Heap.size());
+}
+
+
+template <class T, class CmpT>
+inline bool heap_array<T, CmpT>::valid(const size_t i) const
+{
+	return (i < m_Finder.size());
+}
+
+
+template <class T, class CmpT>
+inline size_t heap_array<T, CmpT>::position(const size_t i) const
+{
+	assert(valid(i));
+
+	return (m_Heap[i].m_Index);
+}
+
+
+template <class T, class CmpT> 
+inline void heap_array<T, CmpT>::update(const size_t i, const T & Elem)
+{
+	assert(locked());
+	assert(! removed(i));
+
+	const size_t j = m_Finder[i];
+	m_Heap[j].m_Elem = Elem;
+	Adjust(j);
+}
+
+
+template <class T, class CmpT> 
+inline void heap_array<T, CmpT>::Adjust(size_t i)
+{
+	assert(i < m_Heap.size());
+
+	size_t j;
+
+	// Check the upper part of the heap
+	for (j = i; (j > 0) && (Less(m_Heap[(j - 1) / 2], m_Heap[j])); j = ((j - 1) / 2))
+		Swap(j, (j - 1) / 2);
+
+	// Check the lower part of the heap
+	for (i = j; (j = 2 * i + 1) < size(); i = j) {
+ 		if ((j + 1 < size()) && (Less(m_Heap[j], m_Heap[j + 1])))
+			++j;
+
+		if (Less(m_Heap[j], m_Heap[i]))
+			return;
+
+		Swap(i, j);
+	}
+}
+
+
+template <class T, class CmpT> 
+inline void heap_array<T, CmpT>::Swap(const size_t a, const size_t b)
+{
+	std::swap(m_Heap[a], m_Heap[b]);
+
+	m_Finder[(m_Heap[a].m_Index)] = a;
+	m_Finder[(m_Heap[b].m_Index)] = b;
+}
+
+
+template <class T, class CmpT>
+inline bool heap_array<T, CmpT>::Less(const linker & a, const linker & b) const
+{
+	return m_Compare(a.m_Elem, b.m_Elem);
+}
+
+
+
+
+	} // namespace detail
+
+} // namespace triangle_stripper
+
+
+
+
+#endif // TRI_STRIPPER_HEADER_GUARD_HEAP_ARRAY_H

TriStripper/detail/policy.h

+//
+// Copyright (C) 2004 Tanguy Fautr.
+// For conditions of distribution and use,
+// see copyright notice in tri_stripper.h
+//
+//////////////////////////////////////////////////////////////////////
+// SVN: $Id: policy.h 86 2005-06-08 17:47:27Z gpsnoopy $
+//////////////////////////////////////////////////////////////////////
+
+#ifndef TRI_STRIPPER_HEADER_GUARD_POLICY_H
+#define TRI_STRIPPER_HEADER_GUARD_POLICY_H
+
+#include "public_types.h"
+#include "types.h"
+
+
+
+
+namespace triangle_stripper {
+
+	namespace detail {
+
+
+
+
+class policy
+{
+public:
+	policy(size_t MinStripSize, bool Cache);
+
+	strip BestStrip() const;
+	void Challenge(strip Strip, size_t Degree, size_t CacheHits);
+
+private:
+	strip	m_Strip;
+	size_t	m_Degree;
+	size_t	m_CacheHits;
+
+	const size_t	m_MinStripSize;
+	const bool		m_Cache;
+};
+
+
+
+
+
+inline policy::policy(size_t MinStripSize, bool Cache)
+: m_Degree(0), m_CacheHits(0), m_MinStripSize(MinStripSize), m_Cache(Cache) { }
+
+
+inline strip policy::BestStrip() const
+{
+	return m_Strip;
+}
+
+
+
+
+	} // namespace detail
+
+} // namespace triangle_stripper
+
+
+
+
+#endif // TRI_STRIPPER_HEADER_GUARD_POLICY_H

TriStripper/detail/types.h

+//
+// Copyright (C) 2004 Tanguy Fautr.
+// For conditions of distribution and use,
+// see copyright notice in tri_stripper.h
+//
+//////////////////////////////////////////////////////////////////////
+// SVN: $Id: types.h 86 2005-06-08 17:47:27Z gpsnoopy $
+//////////////////////////////////////////////////////////////////////
+
+#ifndef TRI_STRIPPER_HEADER_GUARD_TYPES_H
+#define TRI_STRIPPER_HEADER_GUARD_TYPES_H
+
+
+
+
+namespace triangle_stripper {
+
+	namespace detail {
+
+
+
+
+class triangle
+{
+public:
+	triangle() { }
+	triangle(index A, index B, index C)
+		: m_A(A), m_B(B), m_C(C), m_StripID(0) { }
+
+	void ResetStripID()							{ m_StripID = 0; }
+	void SetStripID(size_t StripID)				{ m_StripID = StripID; }	
+	size_t StripID() const						{ return m_StripID; }
+
+	index A() const								{ return m_A; }
+	index B() const								{ return m_B; }
+	index C() const								{ return m_C; }
+	
+private:
+	index	m_A;
+	index	m_B;
+	index	m_C;
+
+	size_t	m_StripID;
+};
+
+
+
+class triangle_edge
+{
+public:
+	triangle_edge(index A, index B)
+		: m_A(A), m_B(B) { }
+
+	index A() const								{ return m_A; }
+	index B() const								{ return m_B; }
+
+	bool operator == (const triangle_edge & Right) const {
+		return ((A() == Right.A()) && (B() == Right.B()));
+	}
+
+private:
+	index	m_A;
+	index	m_B;
+};
+
+
+
+enum triangle_order { ABC, BCA, CAB };
+
+
+
+class strip
+{
+public:
+	strip()
+		: m_Start(0), m_Order(ABC), m_Size(0) { }
+
+	strip(size_t Start, triangle_order Order, size_t Size)
+		: m_Start(Start), m_Order(Order), m_Size(Size) { }
+
+	size_t Start() const						{ return m_Start; }
+	triangle_order Order() const				{ return m_Order; }
+	size_t Size() const							{ return m_Size; }
+
+private:
+	size_t			m_Start;
+	triangle_order	m_Order;
+	size_t			m_Size;
+};
+
+
+
+
+	} // namespace detail
+
+} // namespace triangle_stripper
+
+
+
+
+#endif // TRI_STRIPPER_HEADER_GUARD_TYPES_H

TriStripper/policy.cpp

+//
+// Copyright (C) 2004 Tanguy Fautr.
+// For conditions of distribution and use,
+// see copyright notice in tri_stripper.h
+//
+//////////////////////////////////////////////////////////////////////
+// SVN: $Id: policy.cpp 86 2005-06-08 17:47:27Z gpsnoopy $
+//////////////////////////////////////////////////////////////////////
+
+#include "detail/policy.h"
+
+
+
+
+namespace triangle_stripper {
+
+	namespace detail {
+
+
+
+
+void policy::Challenge(strip Strip, size_t Degree, size_t CacheHits)
+{
+	if (Strip.Size() < m_MinStripSize)
+		return;
+
+	// Cache is disabled, take the longest strip
+	if (! m_Cache) {
+
+		if (Strip.Size() > m_Strip.Size())
+			m_Strip = Strip;
+
+	// Cache simulator enabled
+	} else {
+
+		// Priority 1: Keep the strip with the best cache hit count
+		if (CacheHits > m_CacheHits) {
+			m_Strip = Strip;
+			m_Degree = Degree;
+			m_CacheHits = CacheHits;
+
+		} else if (CacheHits == m_CacheHits) {
+
+			// Priority 2: Keep the strip with the loneliest start triangle
+			if ((m_Strip.Size() != 0) && (Degree < m_Degree)) {
+				m_Strip = Strip;
+				m_Degree = Degree;
+
+			// Priority 3: Keep the longest strip 
+			} else if (Strip.Size() > m_Strip.Size()) {
+				m_Strip = Strip;
+				m_Degree = Degree;
+			}
+		}
+	}
+}
+
+
+
+
+	} // namespace detail
+
+} // namespace triangle_stripper

TriStripper/public_types.h

+//
+// Copyright (C) 2004 Tanguy Fautr.
+// For conditions of distribution and use,
+// see copyright notice in tri_stripper.h
+//
+//////////////////////////////////////////////////////////////////////
+// SVN: $Id: public_types.h 86 2005-06-08 17:47:27Z gpsnoopy $
+//////////////////////////////////////////////////////////////////////
+
+#ifndef TRI_STRIPPER_HEADER_GUARD_PUBLIC_TYPES_H
+#define TRI_STRIPPER_HEADER_GUARD_PUBLIC_TYPES_H
+
+#include <vector>
+
+
+
+
+namespace triangle_stripper
+{
+
+	typedef size_t index;
+	typedef std::vector<index> indices;
+
+	enum primitive_type
+	{
+		TRIANGLES		= 0x0004,	// = GL_TRIANGLES
+		TRIANGLE_STRIP	= 0x0005	// = GL_TRIANGLE_STRIP
+	};
+
+	struct primitive_group
+	{
+		indices			Indices;
+		primitive_type	Type;
+	};
+
+	typedef std::vector<primitive_group> primitive_vector;
+
+}
+
+
+
+
+#endif // TRI_STRIPPER_HEADER_GUARD_PUBLIC_TYPES_H

TriStripper/tri_stripper.cpp

+//
+// Copyright (C) 2004 Tanguy Fautr.
+// For conditions of distribution and use,
+// see copyright notice in tri_stripper.h
+//
+//////////////////////////////////////////////////////////////////////
+// SVN: $Id: tri_stripper.cpp 86 2005-06-08 17:47:27Z gpsnoopy $
+//////////////////////////////////////////////////////////////////////
+
+#include "tri_stripper.h"
+
+#include "detail/connectivity_graph.h"
+#include "detail/policy.h"
+
+#include <cassert>
+
+
+
+
+namespace triangle_stripper {
+
+	using namespace detail;
+
+
+
+
+tri_stripper::tri_stripper(const indices & TriIndices)
+	: m_Triangles(TriIndices.size() / 3), // Silently ignore extra indices if (Indices.size() % 3 != 0)
+	  m_StripID(0),
+	  m_FirstRun(true)
+{
+	SetCacheSize();
+	SetMinStripSize();
+	SetBackwardSearch();
+	SetPushCacheHits();
+
+	make_connectivity_graph(m_Triangles, TriIndices);
+}
+
+
+
+void tri_stripper::Strip(primitive_vector * out_pPrimitivesVector)
+{
+	assert(out_pPrimitivesVector);
+
+	if (! m_FirstRun) {
+		unmark_nodes(m_Triangles);
+		ResetStripIDs();
+		m_Cache.reset();
+		m_TriHeap.clear();
+		m_Candidates.clear();
+		m_StripID = 0;
+
+		m_FirstRun = false;
+	}
+
+	out_pPrimitivesVector->clear();
+
+	InitTriHeap();
+
+	Stripify();
+	AddLeftTriangles();
+	
+	std::swap(m_PrimitivesVector, (* out_pPrimitivesVector));
+}
+
+
+
+void tri_stripper::InitTriHeap()
+{
+	m_TriHeap.reserve(m_Triangles.size());
+
+	// Set up the triangles priority queue
+	// The lower the number of available neighbour triangles, the higher the priority.
+	for (size_t i = 0; i < m_Triangles.size(); ++i)
+		m_TriHeap.push(m_Triangles[i].out_size());
+
+	// We're not going to add new elements anymore
+	m_TriHeap.lock();
+
+	// Remove useless triangles
+	// Note: we had to put all of them into the heap before to ensure coherency of the heap_array object
+	while ((! m_TriHeap.empty()) && (m_TriHeap.top() == 0))
+		m_TriHeap.pop();
+}
+
+
+
+void tri_stripper::ResetStripIDs()
+{
+	for (triangle_graph::node_iterator it = m_Triangles.begin(); it != m_Triangles.end(); ++it)
+		(**it).ResetStripID();
+}
+
+
+
+void tri_stripper::Stripify()
+{
+	while (! m_TriHeap.empty()) {
+
+		// There is no triangle in the candidates list, refill it with the loneliest triangle
+		const size_t HeapTop = m_TriHeap.position(0);
+		m_Candidates.push_back(HeapTop);
+
+		while (! m_Candidates.empty()) {
+
+			// Note: FindBestStrip empties the candidate list, while BuildStrip refills it
+			const strip TriStrip = FindBestStrip();
+
+			if (TriStrip.Size() >= m_MinStripSize)
+				BuildStrip(TriStrip);
+		}
+
+		if (! m_TriHeap.removed(HeapTop))
+			m_TriHeap.erase(HeapTop);
+
+		// Eliminate all the triangles that have now become useless
+		while ((! m_TriHeap.empty()) && (m_TriHeap.top() == 0))
+			m_TriHeap.pop();
+	}
+}
+
+
+
+inline strip tri_stripper::FindBestStrip()
+{
+	// Allow to restore the cache (modified by ExtendTriToStrip) and implicitly reset the cache hit count
+	const cache_simulator CacheBackup = m_Cache;
+
+	policy Policy(m_MinStripSize, Cache());
+
+	while (! m_Candidates.empty()) {
+
+		const size_t Candidate = m_Candidates.back();
+		m_Candidates.pop_back();
+
+		// Discard useless triangles from the candidate list
+		if ((m_Triangles[Candidate].marked()) || (m_TriHeap[Candidate] == 0))
+			continue;		
+
+		// Try to extend the triangle in the 3 possible forward directions
+		for (size_t i = 0; i < 3; ++i) {
+
+			const strip Strip = ExtendToStrip(Candidate, triangle_order(i));
+			Policy.Challenge(Strip, m_TriHeap[Strip.Start()], m_Cache.hitcount());
+			
+			m_Cache = CacheBackup;
+		}
+
+		// Try to extend the triangle in the 6 possible backward directions
+		if (m_BackwardSearch) {
+
+			for (size_t i = 0; i < 3; ++i) {
+
+				const strip Strip = BackExtendToStrip(Candidate, triangle_order(i), false);
+				Policy.Challenge(Strip, m_TriHeap[Strip.Start()], m_Cache.hitcount());
+			
+				m_Cache = CacheBackup;
+			}
+
+			for (size_t i = 0; i < 3; ++i) {
+
+				const strip Strip = BackExtendToStrip(Candidate, triangle_order(i), true);
+				Policy.Challenge(Strip, m_TriHeap[Strip.Start()], m_Cache.hitcount());
+			
+				m_Cache = CacheBackup;
+			}
+		}
+
+	}
+
+	return Policy.BestStrip();
+}
+
+
+
+strip tri_stripper::ExtendToStrip(const size_t Start, triangle_order Order)
+{
+	const triangle_order StartOrder = Order;
+	
+	// Begin a new strip
+	m_Triangles[Start]->SetStripID(++m_StripID);
+	AddTriangle(* m_Triangles[Start], Order, false);
+
+	size_t Size = 1;
+	bool ClockWise = false;
+
+	// Loop while we can further extend the strip
+	for (tri_iterator Node = (m_Triangles.begin() + Start); 
+		(Node != m_Triangles.end()) && (!Cache() || ((Size + 2) < CacheSize()));
+		++Size) {
+
+		const const_link_iterator Link = LinkToNeighbour(Node, ClockWise, Order, false);
+
+		// Is it the end of the strip?
+		if (Link == Node->out_end()) {
+
+			Node = m_Triangles.end();
+			--Size;
+
+		} else {
+
+			Node = Link->terminal();
+			(* Node)->SetStripID(m_StripID);
+			ClockWise = ! ClockWise;
+
+		}
+	}
+
+	return strip(Start, StartOrder, Size);
+}
+
+
+
+strip tri_stripper::BackExtendToStrip(size_t Start, triangle_order Order, bool ClockWise)
+{
+	// Begin a new strip
+	m_Triangles[Start]->SetStripID(++m_StripID);
+	BackAddIndex(LastEdge(* m_Triangles[Start], Order).B());
+	size_t Size = 1;
+
+	tri_iterator Node;
+
+	// Loop while we can further extend the strip
+	for (Node = (m_Triangles.begin() + Start); 
+		!Cache() || ((Size + 2) < CacheSize());
+		++Size) {
+
+		const const_link_iterator Link = BackLinkToNeighbour(Node, ClockWise, Order);
+
+		// Is it the end of the strip?
+		if (Link == Node->out_end())
+			break;
+
+		else {
+			Node = Link->terminal();
+			(* Node)->SetStripID(m_StripID);
+			ClockWise = ! ClockWise;
+		}
+	}
+
+	// We have to start from a counterclockwise triangle.
+	// Simply return an empty strip in the case where the first triangle is clockwise.
+	// Even though we could discard the first triangle and start from the next counterclockwise triangle,
+	// this often leads to more lonely triangles afterward.
+	if (ClockWise)
+		return strip();
+
+	if (Cache()) {
+		m_Cache.merge(m_BackCache, Size);
+		m_BackCache.reset();
+	}
+
+	return strip(Node - m_Triangles.begin(), Order, Size);
+}
+
+
+
+void tri_stripper::BuildStrip(const strip Strip)
+{
+	const size_t Start = Strip.Start();
+
+	bool ClockWise = false;
+	triangle_order Order = Strip.Order();
+
+	// Create a new strip
+	m_PrimitivesVector.push_back(primitive_group());
+	m_PrimitivesVector.back().Type = TRIANGLE_STRIP;
+	AddTriangle(* m_Triangles[Start], Order, true);
+	MarkTriAsTaken(Start);
+
+	// Loop while we can further extend the strip
+	tri_iterator Node = (m_Triangles.begin() + Start);
+
+	for (size_t Size = 1; Size < Strip.Size(); ++Size) {
+
+		const const_link_iterator Link = LinkToNeighbour(Node, ClockWise, Order, true);
+
+		assert(Link != Node->out_end());
+
+		// Go to the next triangle
+		Node = Link->terminal();
+		MarkTriAsTaken(Node - m_Triangles.begin());
+		ClockWise = ! ClockWise;
+	}
+}
+
+
+
+inline tri_stripper::const_link_iterator tri_stripper::LinkToNeighbour(const const_tri_iterator Node, const bool ClockWise, triangle_order & Order, const bool NotSimulation)
+{
+	const triangle_edge Edge = LastEdge(** Node, Order);
+
+	for (const_link_iterator Link = Node->out_begin(); Link != Node->out_end(); ++Link) {
+
+		// Get the reference to the possible next triangle
+		const triangle & Tri = ** Link->terminal();
+
+		// Check whether it's already been used
+		if (NotSimulation || (Tri.StripID() != m_StripID)) {
+
+			if (! Link->terminal()->marked()) {
+
+				// Does the current candidate triangle match the required position for the strip?
+
+				if ((Edge.B() == Tri.A()) && (Edge.A() == Tri.B())) {
+					Order = (ClockWise) ? ABC : BCA;
+					AddIndex(Tri.C(), NotSimulation);
+					return Link;
+				}
+
+				else if ((Edge.B() == Tri.B()) && (Edge.A() == Tri.C())) {
+					Order = (ClockWise) ? BCA : CAB;
+					AddIndex(Tri.A(), NotSimulation);
+					return Link;
+				}
+
+				else if ((Edge.B() == Tri.C()) && (Edge.A() == Tri.A())) {
+					Order = (ClockWise) ? CAB : ABC;
+					AddIndex(Tri.B(), NotSimulation);
+					return Link;
+				}
+			}
+		}
+
+	}
+
+	return Node->out_end();
+}
+
+
+
+inline tri_stripper::const_link_iterator tri_stripper::BackLinkToNeighbour(const_tri_iterator Node, bool ClockWise, triangle_order & Order)
+{
+	const triangle_edge Edge = FirstEdge(** Node, Order);
+
+	for (const_link_iterator Link = Node->out_begin(); Link != Node->out_end(); ++Link) {
+
+		// Get the reference to the possible previous triangle
+		const triangle & Tri = ** Link->terminal();
+
+		// Check whether it's already been used
+		if ((Tri.StripID() != m_StripID) && ! Link->terminal()->marked()) {
+
+			// Does the current candidate triangle match the required position for the strip?
+
+			if ((Edge.B() == Tri.A()) && (Edge.A() == Tri.B())) {
+				Order = (ClockWise) ? CAB : BCA;
+				BackAddIndex(Tri.C());
+				return Link;
+			}
+
+			else if ((Edge.B() == Tri.B()) && (Edge.A() == Tri.C())) {
+				Order = (ClockWise) ? ABC : CAB;
+				BackAddIndex(Tri.A());
+				return Link;
+			}
+
+			else if ((Edge.B() == Tri.C()) && (Edge.A() == Tri.A())) {
+				Order = (ClockWise) ? BCA : ABC;
+				BackAddIndex(Tri.B());
+				return Link;
+			}
+		}
+
+	}
+
+	return Node->out_end();
+}
+
+
+
+void tri_stripper::MarkTriAsTaken(const size_t i)
+{
+	typedef triangle_graph::node_iterator tri_node_iter;
+	typedef triangle_graph::out_arc_iterator tri_link_iter;
+
+	// Mark the triangle node
+	m_Triangles[i].mark();
+
+	// Remove triangle from priority queue if it isn't yet
+	if (! m_TriHeap.removed(i))
+		m_TriHeap.erase(i);
+
+	// Adjust the degree of available neighbour triangles
+	for (tri_link_iter Link = m_Triangles[i].out_begin(); Link != m_Triangles[i].out_end(); ++Link) {
+
+		const size_t j = Link->terminal() - m_Triangles.begin();
+
+		if ((! m_Triangles[j].marked()) && (! m_TriHeap.removed(j))) {
+			size_t NewDegree = m_TriHeap.peek(j);
+			NewDegree = NewDegree - 1;
+			m_TriHeap.update(j, NewDegree);
+
+			// Update the candidate list if cache is enabled
+			if (Cache() && (NewDegree > 0))
+				m_Candidates.push_back(j);
+		}
+	}
+}
+
+
+
+inline triangle_edge tri_stripper::FirstEdge(const triangle & Triangle, const triangle_order Order)
+{
+	switch (Order)
+	{
+	case ABC:
+		return triangle_edge(Triangle.A(), Triangle.B());
+
+	case BCA:
+		return triangle_edge(Triangle.B(), Triangle.C());
+
+	case CAB:
+		return triangle_edge(Triangle.C(), Triangle.A());
+
+	default:
+		assert(false);
+		return triangle_edge(0, 0);
+	}
+}
+
+
+
+inline triangle_edge tri_stripper::LastEdge(const triangle & Triangle, const triangle_order Order)
+{
+	switch (Order)
+	{
+	case ABC:
+		return triangle_edge(Triangle.B(), Triangle.C());
+
+	case BCA:
+		return triangle_edge(Triangle.C(), Triangle.A());
+
+	case CAB:
+		return triangle_edge(Triangle.A(), Triangle.B());
+
+	default:
+		assert(false);
+		return triangle_edge(0, 0);
+	}
+}
+
+
+
+inline void tri_stripper::AddIndex(const index i, const bool NotSimulation)
+{
+	if (Cache())
+		m_Cache.push(i, ! NotSimulation);
+
+	if (NotSimulation)
+		m_PrimitivesVector.back().Indices.push_back(i);
+}
+
+
+
+inline void tri_stripper::BackAddIndex(const index i)
+{
+	if (Cache())
+		m_BackCache.push(i, true);
+}
+
+
+
+inline void tri_stripper::AddTriangle(const triangle & Tri, const triangle_order Order, const bool NotSimulation)
+{
+	switch (Order)
+	{
+	case ABC:
+		AddIndex(Tri.A(), NotSimulation);
+		AddIndex(Tri.B(), NotSimulation);
+		AddIndex(Tri.C(), NotSimulation);
+		break;
+
+	case BCA:
+		AddIndex(Tri.B(), NotSimulation);
+		AddIndex(Tri.C(), NotSimulation);
+		AddIndex(Tri.A(), NotSimulation);
+		break;
+
+	case CAB:
+		AddIndex(Tri.C(), NotSimulation);
+		AddIndex(Tri.A(), NotSimulation);
+		AddIndex(Tri.B(), NotSimulation);
+		break;
+	}
+}
+
+
+
+inline void tri_stripper::BackAddTriangle(const triangle & Tri, const triangle_order Order)
+{
+	switch (Order)
+	{
+	case ABC:
+		BackAddIndex(Tri.C());
+		BackAddIndex(Tri.B());
+		BackAddIndex(Tri.A());
+		break;
+
+	case BCA:
+		BackAddIndex(Tri.A());
+		BackAddIndex(Tri.C());
+		BackAddIndex(Tri.B());
+		break;
+
+	case CAB:
+		BackAddIndex(Tri.B());
+		BackAddIndex(Tri.A());
+		BackAddIndex(Tri.C());
+		break;
+	}
+}
+
+
+
+void tri_stripper::AddLeftTriangles()
+{
+	// Create the last indices array and fill it with all the triangles that couldn't be stripped
+	primitive_group Primitives;
+	Primitives.Type = TRIANGLES;
+	m_PrimitivesVector.push_back(Primitives);
+	indices & Indices = m_PrimitivesVector.back().Indices;
+
+	for (size_t i = 0; i < m_Triangles.size(); ++i)
+		if (! m_Triangles[i].marked()) {
+			Indices.push_back(m_Triangles[i]->A());
+			Indices.push_back(m_Triangles[i]->B());
+			Indices.push_back(m_Triangles[i]->C());
+		}
+
+	// Undo if useless
+	if (Indices.size() == 0)
+		m_PrimitivesVector.pop_back();
+}
+
+
+
+inline bool tri_stripper::Cache() const
+{
+	return (m_Cache.size() != 0);
+}
+
+
+
+inline size_t tri_stripper::CacheSize() const
+{
+	return m_Cache.size();
+}
+
+
+
+
+} // namespace triangle_stripper

TriStripper/tri_stripper.h

+
+//////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2004 Tanguy Fautr.
+//
+//  This software is provided 'as-is', without any express or implied
+//  warranty.  In no event will the authors be held liable for any damages
+//  arising from the use of this software.
+//
+//  Permission is granted to anyone to use this software for any purpose,
+//  including commercial applications, and to alter it and redistribute it
+//  freely, subject to the following restrictions:
+//
+//  1. The origin of this software must not be misrepresented; you must not
+//     claim that you wrote the original software. If you use this software
+//     in a product, an acknowledgment in the product documentation would be
+//     appreciated but is not required.
+//  2. Altered source versions must be plainly marked as such, and must not be
+//     misrepresented as being the original software.
+//  3. This notice may not be removed or altered from any source distribution.
+//
+//  Tanguy Fautr
+//  softdev@telenet.be
+//
+//////////////////////////////////////////////////////////////////////
+//
+//							Tri Stripper
+//							************
+//
+// Post TnL cache aware triangle stripifier in O(n.log(n)).
+//          
+// History: see ChangeLog
+//
+//////////////////////////////////////////////////////////////////////
+// SVN: $Id: tri_stripper.h 86 2005-06-08 17:47:27Z gpsnoopy $
+//////////////////////////////////////////////////////////////////////
+
+// Protection against old C habits
+#if defined(max)
+#error "'max' macro defined! It's against the C++ standard. Please use 'std::max' instead (undefine 'max' macro if it was defined in another library)."
+#endif
+
+// Protection against old C habits
+#if defined(min)
+#error "'min' macro defined! It's against the C++ standard. Please use 'std::min' instead (undefine 'min' macro if it was defined in another library)."
+#endif
+
+
+
+#ifndef TRI_STRIPPER_HEADER_GUARD_TRI_STRIPPER_H
+#define TRI_STRIPPER_HEADER_GUARD_TRI_STRIPPER_H
+
+#include "public_types.h"
+
+#include "detail/cache_simulator.h"
+#include "detail/graph_array.h"
+#include "detail/heap_array.h"
+#include "detail/types.h"
+
+
+
+
+namespace triangle_stripper {
+
+
+
+
+class tri_stripper
+{
+public:
+
+	tri_stripper(const indices & TriIndices);
+
+	void Strip(primitive_vector * out_pPrimitivesVector);
+
+	/* Stripifier Algorithm Settings */
+	
+	// Set the post-T&L cache size (0 disables the cache optimizer).
+	void SetCacheSize(size_t CacheSize = 10);
+
+	// Set the minimum size of a triangle strip (should be at least 2 triangles).
+	// The stripifier discard any candidate strips that does not satisfy the minimum size condition.
+	void SetMinStripSize(size_t MinStripSize = 2);
+
+	// Set the backward search mode in addition to the forward search mode.
+	// In forward mode, the candidate strips are build with the current candidate triangle being the first
+	// triangle of the strip. When the backward mode is enabled, the stripifier also tests candidate strips
+	// where the current candidate triangle is the last triangle of the strip.
+	// Enable this if you want better results at the expense of being slightly slower.
+	// Note: Do *NOT* use this when the cache optimizer is enabled; it only gives worse results.
+	void SetBackwardSearch(bool Enabled = false);
+	
+	// Set the cache simulator FIFO behavior (does nothing if the cache optimizer is disabled).
+	// When enabled, the cache is simulated as a simple FIFO structure. However, when
+	// disabled, indices that trigger cache hits are not pushed into the FIFO structure.
+	// This allows simulating some GPUs that do not duplicate cache entries (e.g. NV25 or greater).
+	void SetPushCacheHits(bool Enabled = true);
+
+	/* End Settings */
+
+private:
+
+	typedef detail::graph_array<detail::triangle> triangle_graph;
+	typedef detail::heap_array<size_t, std::greater<size_t> > triangle_heap;
+	typedef std::vector<size_t> candidates;
+	typedef triangle_graph::node_iterator tri_iterator;
+	typedef triangle_graph::const_node_iterator const_tri_iterator;
+	typedef triangle_graph::out_arc_iterator link_iterator;
+	typedef triangle_graph::const_out_arc_iterator const_link_iterator;
+
+	void InitTriHeap();
+	void Stripify();
+	void AddLeftTriangles();
+	void ResetStripIDs();
+
+	detail::strip FindBestStrip();
+	detail::strip ExtendToStrip(size_t Start, detail::triangle_order Order);
+	detail::strip BackExtendToStrip(size_t Start, detail::triangle_order Order, bool ClockWise);
+	const_link_iterator LinkToNeighbour(const_tri_iterator Node, bool ClockWise, detail::triangle_order & Order, bool NotSimulation);
+	const_link_iterator BackLinkToNeighbour(const_tri_iterator Node, bool ClockWise, detail::triangle_order & Order);
+	void BuildStrip(const detail::strip Strip);
+	void MarkTriAsTaken(size_t i);
+	void AddIndex(index i, bool NotSimulation);
+	void BackAddIndex(index i);
+	void AddTriangle(const detail::triangle & Tri, detail::triangle_order Order, bool NotSimulation);
+	void BackAddTriangle(const detail::triangle & Tri, detail::triangle_order Order);
+
+	bool Cache() const;
+	size_t CacheSize() const;
+
+	static detail::triangle_edge FirstEdge(const detail::triangle & Triangle, detail::triangle_order Order);
+	static detail::triangle_edge LastEdge(const detail::triangle & Triangle, detail::triangle_order Order);
+
+	primitive_vector			m_PrimitivesVector;
+	triangle_graph				m_Triangles;
+	triangle_heap				m_TriHeap;
+	candidates					m_Candidates;
+	detail::cache_simulator		m_Cache;
+	detail::cache_simulator		m_BackCache;
+	size_t						m_StripID;
+	size_t						m_MinStripSize;
+	bool						m_BackwardSearch;
+	bool						m_FirstRun;
+};
+
+
+
+
+
+//////////////////////////////////////////////////////////////////////////
+// tri_stripper inline functions
+//////////////////////////////////////////////////////////////////////////
+
+inline void tri_stripper::SetCacheSize(const size_t CacheSize)
+{
+	m_Cache.resize(CacheSize);
+	m_BackCache.resize(CacheSize);
+}
+
+
+inline void tri_stripper::SetMinStripSize(const size_t MinStripSize)
+{
+	if (MinStripSize < 2)
+		m_MinStripSize = 2;
+	else
+		m_MinStripSize = MinStripSize;
+}
+
+
+inline void tri_stripper::SetBackwardSearch(const bool Enabled)
+{
+	m_BackwardSearch = Enabled;
+}
+
+
+
+inline void tri_stripper::SetPushCacheHits(bool Enabled)
+{
+	m_Cache.push_cache_hits(Enabled);
+}
+
+
+
+
+} // namespace triangle_stripper
+
+
+
+
+#endif // TRI_STRIPPER_HEADER_GUARD_TRI_STRIPPER_H

obj/NiObject.h

@@ -159,7 +159,7 @@ template <class T> Ref<const T> StaticCast (const NiObject * object) {
 #endif
 
 template <class T> Ref<T> DynamicCast( NiObject * object ) {
-	if ( object->IsDerivedType(T::TypeConst()) ) {
+	if ( object && object->IsDerivedType(T::TypeConst()) ) {
 		return (T*)object;
 	} else {
 		return NULL;
@@ -169,7 +169,7 @@ template <class T> Ref<T> DynamicCast( NiObject * object ) {
 //SWIG doesn't want two versions of the same thing
 #ifndef SWIG
 template <class T> Ref<const T> DynamicCast( const NiObject * object ) {
-	if ( object->IsDerivedType(T::TypeConst()) ) {
+	if ( object && object->IsDerivedType(T::TypeConst()) ) {
 		return (const T*)object;
 	} else {
 		return NULL;

obj/NiSkinData.cpp

@@ -120,3 +120,10 @@ NiSkinData::NiSkinData( const Ref<NiTriBasedGeom> & owner ) NI_SKIN_DATA_CONSTRU
 		res_mat.Decompose( boneList[i].translation, boneList[i].rotation, boneList[i].scale );
 	}
 }
+
+Ref<NiSkinPartition> NiSkinData::GetSkinPartition() const {
+   return skinPartition;
+}
+void NiSkinData::SetSkinPartition(Ref<NiSkinPartition> value) {
+   skinPartition = value;
+}