nvtristrip-ruby 0.5.0

data/ext/NvTriStripObjects.h

@@ -0,0 +1,248 @@
+
+#ifndef NV_TRISTRIP_OBJECTS_H
+#define NV_TRISTRIP_OBJECTS_H
+
+#include <assert.h>
+
+#include <stdint.h>
+#define UINT uint32_t
+#define WORD uint16_t
+
+#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
+	UINT         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<WORD> 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

data/ext/RbTriStrip.cpp

@@ -0,0 +1,324 @@
+/*
+  RbTriStrip.c -
+
+  Author: scoopr
+
+  */
+#include "NvTriStrip.h"
+#include <ruby.h>
+#include <string.h>	
+
+
+/* Document-module: NvTriStrip
+ *
+ * NvTriStrip module.
+ */
+
+
+/* Document-class: PrimitiveGroup
+ *
+ * Return value for strip generator
+ */
+
+typedef struct {
+	PrimitiveGroup *pg;
+} PrimitiveGroupWrap;
+
+VALUE primitiveGroupClass;
+
+void primitivegroup_free(PrimitiveGroupWrap *pgw) {
+	delete pgw->pg;
+}
+
+
+/* Creates an PrimitiveGroup of given number and type of indices, rarely used directly */
+VALUE primitivegroup_new(VALUE klass, VALUE type, VALUE numIndices) {
+
+	PrimitiveGroupWrap *pgw;
+	VALUE rpg=Data_Make_Struct(klass, PrimitiveGroupWrap, 0, primitivegroup_free, pgw);
+	pgw->pg=new PrimitiveGroup;
+	pgw->pg->type=(PrimType)NUM2INT(type);
+	pgw->pg->numIndices=NUM2INT(numIndices);
+	pgw->pg->indices=new unsigned short[pgw->pg->numIndices];
+	memset(pgw->pg->indices, 0, pgw->pg->numIndices * sizeof(unsigned short));
+	
+	return rpg;
+}
+
+
+/* call-seq: pg.set_at index,val
+ *           pg[index]=val 
+ *
+ * Set value at _index_ */
+VALUE primitivegroup_set_at(VALUE self, VALUE index, VALUE val) {
+	PrimitiveGroupWrap *pgw;
+	Data_Get_Struct(self, PrimitiveGroupWrap, pgw);
+	int v=NUM2INT(val);
+	int i=NUM2INT(index);
+	if(i<0 || i>pgw->pg->numIndices-1) rb_raise(rb_eIndexError,"Index out of bounds");
+	if(v<0 || v>65535) rb_raise(rb_eArgError, "Indices need to be between 0 and 65535");
+	pgw->pg->indices[i]=v;
+
+	return val;
+}
+
+/* call-seq: pg.get_at index -> val
+ *           pg[index]       -> val
+ *
+ * Value at _index_ */
+VALUE primitivegroup_get_at(VALUE self, VALUE index) {
+	PrimitiveGroupWrap *pgw;
+	Data_Get_Struct(self, PrimitiveGroupWrap, pgw);
+	int i=NUM2INT(index);
+	if(i<0 || i>pgw->pg->numIndices-1) rb_raise(rb_eIndexError,"Index out of bounds");
+
+	return INT2NUM(pgw->pg->indices[i]);
+	
+}
+
+/* call-seq: pg.num_indices -> how_many
+ *           pg.size -> how_many
+ *
+ * Number of indices */
+VALUE primitivegroup_num_indices(VALUE self) {
+	PrimitiveGroupWrap *pgw;
+	Data_Get_Struct(self, PrimitiveGroupWrap, pgw);
+
+	return INT2NUM(pgw->pg->numIndices);
+	
+}
+
+/* Iterate through all indices
+ */
+VALUE primitivegroup_each(VALUE self) {
+	PrimitiveGroupWrap *pgw;
+	Data_Get_Struct(self, PrimitiveGroupWrap, pgw);
+	
+	for(int i=0;i<pgw->pg->numIndices;i++) {
+		rb_yield(INT2NUM(pgw->pg->indices[i]));
+	}
+	
+}
+
+
+VALUE copy_pg(PrimitiveGroup *pg) {
+	VALUE npg=primitivegroup_new(primitiveGroupClass, INT2NUM((int)pg->type), INT2NUM(pg->numIndices));
+	PrimitiveGroupWrap *pgw;
+	Data_Get_Struct(npg, PrimitiveGroupWrap, pgw);
+	if(pg->indices!=NULL) {
+		memcpy(pgw->pg->indices, pg->indices, sizeof(unsigned short)*pg->numIndices);
+	}
+	return npg;
+}
+
+
+/*
+ * call-seq:
+ *   generate_strips indices, validate -> stripified_primitivegroup_ary
+ *
+ * This function generates stripified indices for given list of triangle indices.
+ * The index list should be an array (or anything that responds to #length and #[])
+ * of separate triangles, three indices per triangle.
+ */
+VALUE rbtristripper_generate_strips(VALUE self, VALUE indices, VALUE validateEnabled) {
+
+	ID sGet=rb_intern("[]");
+	ID sSize=rb_intern("length");
+
+	unsigned int size=NUM2INT(rb_funcall(indices,sSize,0));
+	unsigned short ind[size];
+		
+	for(int i=0;i<size;i++) {
+		int v=NUM2INT( rb_funcall(indices, sGet, 1, INT2NUM(i)) );
+		if(v<0 || v>65535) {
+			rb_raise(rb_eArgError, "Value of out range (0..65535)");
+		}
+		ind[i]=v;
+	}
+	unsigned short groups;
+	PrimitiveGroup *p;
+	GenerateStrips(ind, size, &p, &groups, validateEnabled==Qtrue);
+	
+	VALUE ary=rb_ary_new2(groups);
+	for(int i=0;i<groups;i++) {
+		VALUE v=copy_pg(&p[i]);
+		rb_ary_push(ary, v);
+	}
+	
+	delete[] p;
+
+	return ary;
+}
+
+
+/**
+  * call-seq:
+  * remap_indices primitivegroup_ary, max_verts -> remapped_primitivegroup_ary
+  * 
+  * Remaps indices to improve spatial locality in your vertex buffer
+  * With the indices handed back, you need to reorder your vertex buffer.
+  */
+VALUE rbtristripper_remap_indices(VALUE self, VALUE prims, VALUE maxVerts) {
+
+
+	ID sGet=rb_intern("[]");
+	ID sSize=rb_intern("length");
+
+	unsigned short size=NUM2INT(rb_funcall(prims,sSize,0));
+
+	PrimitiveGroup groups[size];
+	for(int i=0;i<size;i++) {
+		
+		PrimitiveGroupWrap *pgw;
+		Data_Get_Struct(rb_funcall(prims, sGet, 1, INT2NUM(i)), PrimitiveGroupWrap, pgw);
+		groups[i]=*(pgw->pg); // Copies the object for our own array
+	}
+
+
+	PrimitiveGroup *remappedGroups=new PrimitiveGroup[size];
+
+	RemapIndices(groups, size, NUM2INT(maxVerts), &remappedGroups);
+
+	VALUE remapped=rb_ary_new2(size);
+
+
+	for(int i=0;i<size;i++) {
+		// Copy resulting array to ruby array
+		VALUE v=copy_pg(&remappedGroups[i]);
+		rb_ary_push(remapped, v);
+
+		// Remove reference to index array, because we don't own it,
+		// and would be removed when leaving this function
+		groups[i].indices=NULL;
+	}
+
+	delete[] remappedGroups;
+	return remapped;
+}
+
+
+
+/* call-seq: set_lists_only boolean
+ *
+ * If set to true, will return an optimized list, with no strips at all.
+ * Default is false.
+ */
+VALUE rbtristripper_set_lists_only(VALUE self, VALUE val) {
+	SetListsOnly(val==Qtrue?true:false);
+	return Qnil;
+}
+
+/* call-seq: set_min_strip_size val
+ *
+ * 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.
+ */
+VALUE rbtristripper_set_min_strip_size(VALUE self, VALUE val) {
+	SetMinStripSize( NUM2INT(val) );
+	return Qnil;
+}
+
+/* call-seq: set_stitch_strips boolean
+ *
+ * Boolean 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 is true.
+ */
+VALUE rbtristripper_set_stitch_strips(VALUE self, VALUE val) {
+	SetStitchStrips(val==Qtrue?true:false);
+	return Qnil;
+}
+
+/* call-seq: set_cache_size val
+ *
+ * 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 is 16.
+ */
+VALUE rbtristripper_set_cache_size(VALUE self, VALUE val) {
+	SetCacheSize(NUM2INT(val));
+	return Qnil;
+}
+
+/* call-seq: disable_restart
+ *
+ * For GPUs that support primitive restart, this disables using primitive restart
+ *
+ */
+VALUE rbtristripper_disable_restart(VALUE self) {
+	DisableRestart();
+	return Qnil;
+}
+
+/* call-seq: enable_restart val
+ *
+ * For GPUs that support primitive restart, this sets a value as the restart index.
+ * (For OpenGL, the extension would be GL_NV_primitive_restart)
+ *
+ * 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 is disabled.
+ */
+VALUE rbtristripper_enable_restart(VALUE self, VALUE val) {
+	EnableRestart(NUM2INT(val));
+	return Qnil;
+}
+
+	
+extern "C" void Init_nvtristrip() {
+
+	VALUE stripperModule=rb_define_module("NvTriStrip");
+	
+	/* Constant for list type indices */
+	rb_define_const(stripperModule, "PT_LIST",  INT2NUM(PT_LIST)  );
+	/* Constant for strip type indices */
+	rb_define_const(stripperModule, "PT_STRIP", INT2NUM(PT_STRIP) );
+	/* Constant for fan type indices */
+	rb_define_const(stripperModule, "PT_FAN",   INT2NUM(PT_FAN)   );
+	
+	primitiveGroupClass=rb_define_class_under(stripperModule, "PrimitiveGroup", rb_cObject);
+	rb_define_singleton_method(primitiveGroupClass, "new", RUBY_METHOD_FUNC(primitivegroup_new), 2);
+
+
+	rb_define_method(primitiveGroupClass, "num_indices", RUBY_METHOD_FUNC(primitivegroup_num_indices),0);
+	rb_define_method(primitiveGroupClass, "get_at", RUBY_METHOD_FUNC(primitivegroup_get_at),1);
+	rb_define_method(primitiveGroupClass, "set_at", RUBY_METHOD_FUNC(primitivegroup_set_at),2);
+
+	// Ruby friendly aliases
+	rb_define_alias(primitiveGroupClass, "length", "num_indices");
+	rb_define_alias(primitiveGroupClass, "size", "num_indices");
+	rb_define_alias(primitiveGroupClass, "[]", "get_at");
+	rb_define_alias(primitiveGroupClass, "[]=", "set_at");
+	
+	// Make PrimitiveGroup act even more like a ruby array
+	rb_define_method(primitiveGroupClass, "each", RUBY_METHOD_FUNC(primitivegroup_each), 0);	
+	rb_include_module(primitiveGroupClass, rb_mEnumerable);
+
+  /* Size of Geforce 1 and 2 families cachesize, value is 16 */
+	rb_define_const(stripperModule, "CACHESIZE_GEFORCE1_2", INT2NUM(CACHESIZE_GEFORCE1_2) );
+  /* Size of Geforce 3 family cachesize, value is 24 */
+	rb_define_const(stripperModule, "CACHESIZE_GEFORCE3", INT2NUM(CACHESIZE_GEFORCE3) );
+
+
+	// Hard work
+	rb_define_singleton_method(stripperModule, "generate_strips", RUBY_METHOD_FUNC(rbtristripper_generate_strips), 2);
+	rb_define_singleton_method(stripperModule, "remap_indices", RUBY_METHOD_FUNC(rbtristripper_remap_indices), 2);
+
+
+	// Options
+	rb_define_singleton_method(stripperModule, "set_lists_only", RUBY_METHOD_FUNC(rbtristripper_set_lists_only),1);
+	rb_define_singleton_method(stripperModule, "set_min_strip_size", RUBY_METHOD_FUNC(rbtristripper_set_min_strip_size),1);
+	rb_define_singleton_method(stripperModule, "set_stitch_strips", RUBY_METHOD_FUNC(rbtristripper_set_stitch_strips),1);
+	rb_define_singleton_method(stripperModule, "set_cache_size", RUBY_METHOD_FUNC(rbtristripper_set_cache_size),1);
+	rb_define_singleton_method(stripperModule, "disable_restart", RUBY_METHOD_FUNC(rbtristripper_disable_restart),0);
+	rb_define_singleton_method(stripperModule, "enable_restart", RUBY_METHOD_FUNC(rbtristripper_enable_restart),1);
+
+
+	
+}