added everything

lib/dtsSDKPlus/nvtristrip/NvTriStrip.cpp

@@ -0,0 +1,310 @@
+//-----------------------------------------------------------------------------
+// Torque Game Engine 
+// Copyright (C) GarageGames.com, Inc.
+//-----------------------------------------------------------------------------
+// Copied from NVidia Triangle Strip SDK, available from NVidia website
+//-----------------------------------------------------------------------------
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4786)
+#endif
+
+#include "NvTriStripObjects.h"
+#include "NvTriStrip.h"
+
+////////////////////////////////////////////////////////////////////////////////////////
+//private data
+static U32 cacheSize    = CACHESIZE_GEFORCE1_2;
+static bool bStitchStrips        = true;
+static U32 minStripSize = 0;
+static bool bListsOnly           = 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 U32 _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 U32 _minStripSize)
+{
+	minStripSize = _minStripSize;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 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;
+	}
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 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 U16 numGroups,
+				  const U16 numVerts, PrimitiveGroup** remappedGroups)
+{
+	(*remappedGroups) = new PrimitiveGroup[numGroups];
+
+	//caches oldIndex --> newIndex conversion
+	S32 *indexCache;
+	indexCache = new S32[numVerts];
+	memset(indexCache, -1, sizeof(S32)*numVerts);
+	
+	//loop over primitive groups
+	U32 indexCtr = 0;
+	for(S32 i = 0; i < numGroups; i++)
+	{
+		U32 numIndices = in_primGroups[i].numIndices;
+
+		//init remapped group
+		(*remappedGroups)[i].type       = in_primGroups[i].type;
+		(*remappedGroups)[i].numIndices = numIndices;
+		(*remappedGroups)[i].indices    = new U16[numIndices];
+
+		for(U32 j = 0; j < numIndices; j++)
+		{
+			S32 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;
+}

lib/dtsSDKPlus/nvtristrip/NvTriStrip.h

@@ -0,0 +1,135 @@
+//-----------------------------------------------------------------------------
+// Torque Game Engine 
+// Copyright (C) GarageGames.com, Inc.
+//-----------------------------------------------------------------------------
+// Copied from NVidia Triangle Strip SDK, available from NVidia website
+//-----------------------------------------------------------------------------
+
+#ifndef NVTRISTRIP_H
+#define NVTRISTRIP_H
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Mod for Torque, 1/3/04
+// Compile directly in Torque
+//#pragma comment(lib, "nvtristrip")
+////////////////////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 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;
+	U32 numIndices;
+	U16* indices;
+
+////////////////////////////////////////////////////////////////////////////////////////
+
+	PrimitiveGroup() : type(PT_STRIP), numIndices(0), indices(NULL) {}
+	~PrimitiveGroup()
+	{
+		if(indices)
+			delete[] indices;
+		indices = NULL;
+	}
+};
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 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 U32 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 U32 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
+//
+void GenerateStrips(const U16* in_indices, const U32 in_numIndices,
+					PrimitiveGroup** primGroups, U16* numGroups);
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 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 U16 numGroups, 
+				  const U16 numVerts, PrimitiveGroup** remappedGroups);
+
+#endif

lib/dtsSDKPlus/nvtristrip/NvTriStripObjects.h

@@ -0,0 +1,255 @@
+//-----------------------------------------------------------------------------
+// Torque Game Engine 
+// Copyright (C) GarageGames.com, Inc.
+//-----------------------------------------------------------------------------
+// Copied from NVidia Triangle Strip SDK, available from NVidia website
+//-----------------------------------------------------------------------------
+
+#ifndef NV_TRISTRIP_OBJECTS_H
+#define NV_TRISTRIP_OBJECTS_H
+
+#include <assert.h>
+#ifdef _WIN32
+#include <windows.h>
+#else
+   typedef U32 UINT;
+   typedef short WORD;
+#endif
+#include <vector>
+#include <list>
+#include "VertexCache.h"
+#include "../DTSPlusTypes.h"
+
+/////////////////////////////////////////////////////////////////////////////////
+//
+// Types defined for stripification
+//
+/////////////////////////////////////////////////////////////////////////////////
+
+struct MyVertex {
+	F32 x, y, z;
+	F32 nx, ny, nz;
+};
+
+typedef MyVertex MyVector;
+
+struct MyFace {
+	S32 v1, v2, v3;
+	F32 nx, ny, nz;
+};
+
+
+class NvFaceInfo {
+public:
+	
+	// vertex indices
+	NvFaceInfo(S32 v0, S32 v1, S32 v2){
+		m_v0 = v0; m_v1 = v1; m_v2 = v2;
+		m_stripId      = -1;
+		m_testStripId  = -1;
+		m_experimentId = -1;
+	}
+	
+	// data members are left public
+	S32   m_v0, m_v1, m_v2;
+	S32   m_stripId;      // real strip Id
+	S32   m_testStripId;  // strip Id in an experiment
+	S32   m_experimentId; // in what experiment was it given an experiment Id?
+};
+
+// 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 (S32 v0, S32 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
+	UINT         m_refCount;
+	NvFaceInfo  *m_face0, *m_face1;
+	S32          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<WORD> WordVec;
+typedef std::vector<S32> 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, S32 stripId, S32 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;
+	S32              m_stripId;
+	S32              m_experimentId;
+	  
+	bool visited;
+
+	S32 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 S32 in_cacheSize, const S32 in_minStripLength, 
+				  const U16 maxIndex, NvStripInfoVec &allStrips, NvFaceInfoVec &allFaces);
+	void CreateStrips(const NvStripInfoVec& allStrips, IntVec& stripIndices, const bool bStitchStrips, U32& numSeparateStrips);
+	
+	static S32 GetUniqueVertexInB(NvFaceInfo *faceA, NvFaceInfo *faceB);
+	//static S32 GetSharedVertex(NvFaceInfo *faceA, NvFaceInfo *faceB);
+	static void GetSharedVertices(NvFaceInfo *faceA, NvFaceInfo *faceB, S32* vertex0, S32* vertex1);
+
+	static bool IsDegenerate(const NvFaceInfo* face);
+	
+protected:
+	
+	WordVec indices;
+	S32 cacheSize;
+	S32 minStripLength;
+	F32 meshJump;
+	bool bFirstTimeResetPoint;
+	
+	/////////////////////////////////////////////////////////////////////////////////
+	//
+	// Big mess of functions called during stripification
+	//
+	/////////////////////////////////////////////////////////////////////////////////
+
+	//********************
+	bool IsMoneyFace(const NvFaceInfo& face);
+	bool FaceContainsIndex(const NvFaceInfo& face, const U32 index);
+
+	bool IsCW(NvFaceInfo *faceInfo, S32 v0, S32 v1);
+	bool NextIsCW(const S32 numIndices);
+	
+	bool IsDegenerate(const U16 v0, const U16 v1, const U16 v2);
+	
+	static S32  GetNextIndex(const WordVec &indices, NvFaceInfo *face);
+	static NvEdgeInfo *FindEdgeInfo(NvEdgeInfoVec &edgeInfos, S32 v0, S32 v1);
+	static NvFaceInfo *FindOtherFace(NvEdgeInfoVec &edgeInfos, S32 v0, S32 v1, NvFaceInfo *faceInfo);
+	NvFaceInfo *FindGoodResetPoint(NvFaceInfoVec &faceInfos, NvEdgeInfoVec &edgeInfos);
+	
+	void FindAllStrips(NvStripInfoVec &allStrips, NvFaceInfoVec &allFaceInfos, NvEdgeInfoVec &allEdgeInfos, S32 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);
+	S32  CountRemainingTris(std::list<NvStripInfo*>::iterator iter, std::list<NvStripInfo*>::iterator  end);
+	
+	void CommitStrips(NvStripInfoVec &allStrips, const NvStripInfoVec &strips);
+	
+	F32 AvgStripSize(const NvStripInfoVec &strips);
+	S32 FindStartPoint(NvFaceInfoVec &faceInfos, NvEdgeInfoVec &edgeInfos);
+	
+	void UpdateCacheStrip(VertexCache* vcache, NvStripInfo* strip);
+	void UpdateCacheFace(VertexCache* vcache, NvFaceInfo* face);
+	F32 CalcNumHitsStrip(VertexCache* vcache, NvStripInfo* strip);
+	S32 CalcNumHitsFace(VertexCache* vcache, NvFaceInfo* face);
+	S32 NumNeighbors(NvFaceInfo* face, NvEdgeInfoVec& edgeInfoVec);
+	
+	void BuildStripifyInfo(NvFaceInfoVec &faceInfos, NvEdgeInfoVec &edgeInfos, const U16 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

lib/dtsSDKPlus/nvtristrip/README.txt

@@ -0,0 +1,32 @@
+README for NvTriStrip, library version
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+To use: 
+-#include "NvTriStrip.h"
+-put nvtristrip.lib in your library path (the pragma in nvtristrip.h will automatically look for the library).
+
+Check out NvTriStrip.h for the interface.
+
+See the StripTest source code (in function LoadXFileStripped) for an example of using the library.
+
+Features:
+-generates strips from arbitrary geometry.
+-flexibly optimizes for post TnL vertex caches (16 on GeForce1/2, 24 on GeForce3).
+-can stitch together strips using degenerate triangles, or not.
+-can output lists instead of strips.
+-can optionally throw excessively small strips into a list instead.
+-can remap indices to improve spatial locality in your vertex buffers.
+
+On cache sizes:
+Note that it's better to UNDERESTIMATE the cache size instead of OVERESTIMATING.
+So, if you're targetting GeForce1, 2, and 3, be conservative and use the GeForce1_2 cache 
+size, NOT the GeForce3 cache size.
+This will make sure you don't "blow" the cache of the GeForce1 and 2.
+Also note that the cache size you specify is the "actual" cache size, not the "effective"
+cache size you may have heard about.  This is 16 for GeForce1 and 2, and 24 for GeForce3.
+
+Credit goes to Curtis Beeson and Joe Demers for the basis for this stripifier and to Jason Regier and 
+Jon Stone at Blizzard for providing a much cleaner version of CreateStrips().
+
+Questions/comments email cem@nvidia.com
+

lib/dtsSDKPlus/nvtristrip/VertexCache.h

@@ -0,0 +1,86 @@
+//-----------------------------------------------------------------------------
+// Torque Game Engine 
+// Copyright (C) GarageGames.com, Inc.
+//-----------------------------------------------------------------------------
+// Copied from NVidia Triangle Strip SDK, available from NVidia website
+//-----------------------------------------------------------------------------
+  
+#ifndef VERTEX_CACHE_H
+#define VERTEX_CACHE_H
+
+#include "../DTSPlusTypes.h"
+
+class VertexCache
+{
+	
+public:
+	
+	VertexCache(S32 size)
+	{
+		numEntries = size;
+		
+		entries = new S32[numEntries];
+		
+		for(S32 i = 0; i < numEntries; i++)
+			entries[i] = -1;
+	}
+		
+	VertexCache() { VertexCache(16); }
+	~VertexCache() { delete[] entries; entries = 0; }
+	
+	bool InCache(S32 entry)
+	{
+		bool returnVal = false;
+		for(S32 i = 0; i < numEntries; i++)
+		{
+			if(entries[i] == entry)
+			{
+				returnVal = true;
+				break;
+			}
+		}
+		
+		return returnVal;
+	}
+	
+	S32 AddEntry(S32 entry)
+	{
+		S32 removed;
+		
+		removed = entries[numEntries - 1];
+		
+		//push everything right one
+		for(S32 i = numEntries - 2; i >= 0; i--)
+		{
+			entries[i + 1] = entries[i];
+		}
+		
+		entries[0] = entry;
+		
+		return removed;
+	}
+
+	void Clear()
+	{
+		memset(entries, -1, sizeof(S32) * numEntries);
+	}
+	
+	void Copy(VertexCache* inVcache) 
+	{
+		for(S32 i = 0; i < numEntries; i++)
+		{
+			inVcache->Set(i, entries[i]);
+		}
+	}
+
+	S32 At(S32 index) { return entries[index]; }
+	void Set(S32 index, S32 value) { entries[index] = value; }
+
+private:
+
+  S32 *entries;
+  S32 numEntries;
+
+};
+
+#endif