codebase / stimlib

Browse Code »

Commit f1402849e5be2c2d9ce26a0d7f4c74b5748b8a74

Authored by dmayerich 2013-08-24 15:03:22 -0500

0 parents

renewed commit

Showing 101 changed files with 25830 additions and 0 deletions Show diff stats

Inline Side-by-side

Too many changes.
Reload with full diff Plain diff Email patch

To preserve performance only 100 of 101 files are displayed.

CHECK_OPENGL_ERROR.h 0 → 100755

Wrap text Show/Hide comments View file @f140284

	1	+++ a/CHECK_OPENGL_ERROR.h
	1	+#ifndef RTS_OPENGL_ERROR
	2	+#define RTS_OPENGL_ERROR
	3	+
	4	+#include <stdio.h>
	5	+#include <GL/gl.h>
	6	+#include <GL/glu.h>
	7	+
	8	+#define CHECK_OPENGL_ERROR \
	9	+{ GLenum error; \
	10	+ while ( (error = glGetError()) != GL_NO_ERROR) { \
	11	+ printf( "OpenGL ERROR: %s\nCHECK POINT: %s (line %d)\n", gluErrorString(error), __FILE__, __LINE__ ); \
	12	+ } \
	13	+}
	14	+
	15	+#endif
0	16	\ No newline at end of file
...	...

PerformanceDataTemplate.h 0 → 100755

Wrap text Show/Hide comments View file @f140284

	1	+++ a/PerformanceDataTemplate.h
	1	+// add the following to a cpp file:
	2	+// PerformanceData PD;
	3	+
	4	+
	5	+#pragma once
	6	+#include <ostream>
	7	+using namespace std;
	8	+
	9	+enum PerformanceDataType
	10	+{
	11	+ PD_DISPLAY=0,
	12	+ PD_SPS,
	13	+ PD_UNUSED0,
	14	+
	15	+ //my stuff
	16	+ SIMULATE_SPECTRUM,
	17	+ SIMULATE_GPU,
	18	+ KRAMERS_KRONIG,
	19	+
	20	+
	21	+
	22	+ //end my stuff
	23	+ PERFORMANCE_DATA_TYPE_COUNT
	24	+};
	25	+
	26	+static char PDTypeNames[][255] = {
	27	+ "Display ",
	28	+ "Simulation Total ",
	29	+ " ----------------- ",
	30	+ //my stuff
	31	+ "Simulate Spectrum ",
	32	+ " GPU Portion ",
	33	+ "Kramers-Kronig ",
	34	+
	35	+ //end my stuff
	36	+
	37	+};
	38	+#ifdef WIN32
	39	+#include <stdio.h>
	40	+#include <windows.h>
	41	+#include <float.h>
	42	+
	43	+#include <iostream>
	44	+#include <iomanip>
	45	+
	46	+//-------------------------------------------------------------------------------
	47	+
	48	+class PerformanceData
	49	+{
	50	+public:
	51	+ PerformanceData() { ClearAll(); QueryPerformanceFrequency(&cps); }
	52	+ ~PerformanceData(){}
	53	+
	54	+ void ClearAll()
	55	+ {
	56	+ for ( int i=0; i<PERFORMANCE_DATA_TYPE_COUNT; i++ ) {
	57	+ for ( int j=0; j<256; j++ ) times[i][j] = 0;
	58	+ pos[i] = 0;
	59	+ minTime[i] = 0xFFFFFFFF;
	60	+ maxTime[i] = 0;
	61	+ totalTime[i] = 0;
	62	+ dataReady[i] = false;
	63	+ }
	64	+ }
	65	+
	66	+ void StartTimer( int type ) { QueryPerformanceCounter( &startTime[type] );}
	67	+ void EndTimer( int type ) {
	68	+ LARGE_INTEGER endTime;
	69	+ QueryPerformanceCounter( &endTime );
	70	+ double t = (double)(endTime.QuadPart - startTime[type].QuadPart);
	71	+ //unsigned int t = GetTickCount() - startTime[type];
	72	+ if ( t < minTime[type] ) minTime[type] = t;
	73	+ if ( t > maxTime[type] ) maxTime[type] = t;
	74	+ totalTime[type] -= times[type][ pos[type] ];
	75	+ times[type][ pos[type] ] = t;
	76	+ totalTime[type] += t;
	77	+ pos[type]++;
	78	+ if ( pos[type] == 0 ) dataReady[type] = true;
	79	+ }
	80	+
	81	+ void PrintResult( ostream &os,int i=PERFORMANCE_DATA_TYPE_COUNT)
	82	+ {
	83	+ os.setf(ios::fixed);
	84	+ if ((i<PERFORMANCE_DATA_TYPE_COUNT)&&(i>=0)){
	85	+ double a = GetAvrgTime(i);
	86	+ if ( a )
	87	+ os<< PDTypeNames[i]<<" : avrg="<<setw(8)<<setprecision(3)<<a<<"\tmin="<<setw(8)<<setprecision(3)<< GetMinTime(i) <<"\tmax="<<setw(8)<<setprecision(3)<< GetMaxTime(i) <<endl ;
	88	+ else
	89	+ os<< PDTypeNames[i]<<" : avrg= -----\tmin= -----\tmax= -----"<<endl;
	90	+ }
	91	+ }
	92	+
	93	+ void PrintResults( ostream &os)
	94	+ {
	95	+ for ( int i=0; i<PERFORMANCE_DATA_TYPE_COUNT; i++ )
	96	+ PrintResult(os,i);
	97	+ }
	98	+
	99	+ double GetLastTime( int type ) { return times[type][pos[type]]; }
	100	+ double GetAvrgTime( int type ) { double a = 1000.0 * totalTime[type] / (float)cps.QuadPart / ( (dataReady[type]) ? 256.0 : (double)pos[type] ); return (_finite(a))? a:0; }
	101	+ double GetMinTime( int type ) { return 1000.0 * minTime[type] / (float)cps.LowPart; }
	102	+ double GetMaxTime( int type ) { return 1000.0 * maxTime[type] / (float)cps.LowPart; }
	103	+
	104	+private:
	105	+ double times[PERFORMANCE_DATA_TYPE_COUNT][256];
	106	+ unsigned char pos[PERFORMANCE_DATA_TYPE_COUNT];
	107	+ LARGE_INTEGER startTime[PERFORMANCE_DATA_TYPE_COUNT];
	108	+ double minTime[ PERFORMANCE_DATA_TYPE_COUNT ];
	109	+ double maxTime[ PERFORMANCE_DATA_TYPE_COUNT ];
	110	+ double totalTime[ PERFORMANCE_DATA_TYPE_COUNT ];
	111	+ bool dataReady[ PERFORMANCE_DATA_TYPE_COUNT ];
	112	+ LARGE_INTEGER cps;
	113	+};
	114	+
	115	+//-------------------------------------------------------------------------------
	116	+#else
	117	+
	118	+class PerformanceData{
	119	+public:
	120	+ PerformanceData() {;};
	121	+ ~PerformanceData(){;};
	122	+ void ClearAll(){;};
	123	+ void StartTimer( int type ) {;};
	124	+ void EndTimer( int type ) {;};
	125	+ void PrintResults( ostream &os){;};
	126	+ void PrintResult( ostream &os, int i=PERFORMANCE_DATA_TYPE_COUNT){;};
	127	+ double GetLastTime( int type ) { return 0.0; };
	128	+ double GetAvrgTime( int type ) { return 0.0; };
	129	+ double GetMinTime( int type ) { return 0.0; };
	130	+ double GetMaxTime( int type ) { return 0.0; };
	131	+};
	132	+
	133	+#endif
	134	+//-------------------------------------------------------------------------------
	135	+
	136	+extern PerformanceData PD;
	137	+
	138	+//-------------------------------------------------------------------------------
...	...

cudaHandleError.h 0 → 100755

Wrap text Show/Hide comments View file @f140284

	1	+++ a/cudaHandleError.h
	1	+#include <stdio.h>
	2	+#include "cuda_runtime.h"
	3	+#include "device_launch_parameters.h"
	4	+
	5	+#ifndef CUDA_HANDLE_ERROR_H
	6	+#define CUDA_HANDLE_ERROR_H
	7	+
	8	+//handle error macro
	9	+static void HandleError( cudaError_t err, const char *file, int line ) {
	10	+ if (err != cudaSuccess) {
	11	+ FILE* outfile = fopen("cudaErrorLog.txt", "w");
	12	+ fprintf(outfile, "%s in %s at line %d\n", cudaGetErrorString( err ), file, line );
	13	+ fclose(outfile);
	14	+ exit( EXIT_FAILURE );
	15	+ printf("%s in %s at line %d\n", cudaGetErrorString( err ), file, line );
	16	+ }
	17	+}
	18	+#define HANDLE_ERROR( err ) (HandleError( err, __FILE__, __LINE__ ))
	19	+
	20	+static cudaEvent_t tStartEvent;
	21	+static cudaEvent_t tStopEvent;
	22	+static void gpuStartTimer()
	23	+{
	24	+ //set up timing events
	25	+ cudaEventCreate(&tStartEvent);
	26	+ cudaEventCreate(&tStopEvent);
	27	+ cudaEventRecord(tStartEvent, 0);
	28	+}
	29	+
	30	+static float gpuStopTimer()
	31	+{
	32	+ cudaEventRecord(tStopEvent, 0);
	33	+ cudaEventSynchronize(tStopEvent);
	34	+ float elapsedTime;
	35	+ cudaEventElapsedTime(&elapsedTime, tStartEvent, tStopEvent);
	36	+ cudaEventDestroy(tStartEvent);
	37	+ cudaEventDestroy(tStopEvent);
	38	+ return elapsedTime;
	39	+}
	40	+
	41	+#endif
...	...

cuda_callable.h 0 → 100644

Wrap text Show/Hide comments View file @f140284

	1	+++ a/cuda_callable.h
	1	+#ifndef CUDA_CALLABLE
	2	+
	3	+//define the CUDA_CALLABLE macro (will prefix all members)
	4	+#ifdef __CUDACC__
	5	+#define CUDA_CALLABLE __host__ __device__
	6	+#else
	7	+#define CUDA_CALLABLE
	8	+#endif
	9	+
	10	+#endif
...	...

objJedi.cpp 0 → 100755

Wrap text Show/Hide comments View file @f140284

	1	+++ a/objJedi.cpp
	1	+/*BUG NOTES
	2	+The standard function calls for inserting vertices don't work anymore. I've fixed points
	3	+but everything beyond that has to be updated.
	4	+*/
	5	+
	6	+#include "objJedi.h"
	7	+#include "rtsvector3D.h"
	8	+#include "rtspoint3D.h"
	9	+#include <string>
	10	+//variable for use in global functions
	11	+rtsOBJ g_OBJ;
	12	+
	13	+/******UTILITY METHODS*****************************/
	14	+void rtsOBJ::Scale(float scale_x, float scale_y, float scale_z)
	15	+{
	16	+ vector<vertex_position>::iterator i;
	17	+ for(i = v_list.begin(); i!= v_list.end(); i++)
	18	+ {
	19	+ (i).x = scale_x;
	20	+ (i).y = scale_y;
	21	+ (i).z = scale_z;
	22	+ }
	23	+}
	24	+
	25	+void rtsOBJ::Translate(float trans_x, float trans_y, float trans_z)
	26	+{
	27	+ vector<vertex_position>::iterator i;
	28	+ for(i = v_list.begin(); i!= v_list.end(); i++)
	29	+ {
	30	+ (*i).x += trans_x;
	31	+ (*i).y += trans_y;
	32	+ (*i).z += trans_z;
	33	+ }
	34	+
	35	+}
	36	+
	37	+float rtsOBJ::GetDistance(float x, float y, float z)
	38	+{
	39	+ //gets the distance between the specified point and the nearest surface of the OBJ
	40	+ //currently only works for lines
	41	+
	42	+ //cout<<"Primitives: "<<primitives.size()<<endl;
	43	+ int num_primitives = primitives.size();
	44	+ point3D<double> p0, p1, p2;
	45	+ double min_dist = 255;
	46	+ double dist, numerator, denominator;
	47	+ int p, l;
	48	+ vector3D<double> v, w;
	49	+ double c1, c2, b;
	50	+ point3D<double> Pb;
	51	+
	52	+ //for each line
	53	+ for(l=0; l<num_primitives; l++)
	54	+ {
	55	+ if(primitives[l].type & OBJ_LINES)
	56	+ {
	57	+ //for each point
	58	+ for(p = 1; p<primitives[l].p.size(); p++)
	59	+ {
	60	+
	61	+ vertex_position v1 = v_list[primitives[l].p[p-1].v];
	62	+ vertex_position v2 = v_list[primitives[l].p[p].v];
	63	+ p1.x = v1.x;
	64	+ p1.y = v1.y;
	65	+ p1.z = v1.z;
	66	+ p2.x = v2.x;
	67	+ p2.y = v2.y;
	68	+ p2.z = v2.z;
	69	+
	70	+ p0.x = x;
	71	+ p0.y = y;
	72	+ p0.z = z;
	73	+
	74	+ v = p2 - p1;
	75	+ w = p0 - p1;
	76	+ if((c1 = w*v) <= 0)
	77	+ dist = (p1 - p0).Length();
	78	+ else if((c2 = v*v) <= c1)
	79	+ dist = (p2 - p0).Length();
	80	+ else
	81	+ {
	82	+ b = c1/c2;
	83	+ Pb = p1 + b*v;
	84	+ dist = (Pb - p0).Length();
	85	+ }
	86	+ if(dist < min_dist)
	87	+ min_dist = dist;
	88	+
	89	+
	90	+
	91	+ }
	92	+ }
	93	+ }
	94	+ //cout<<"---------------------------------------------"<<endl;
	95	+
	96	+ return min_dist;
	97	+
	98	+
	99	+}
	100	+
	101	+/******CLASS METHOD DEFINITIONS********************/
	102	+//constructors
	103	+
	104	+//constructor
	105	+rtsOBJ::rtsOBJ()
	106	+{
	107	+ g_CurrentMode = OBJ_NONE;
	108	+ g_NumVertices = 0;
	109	+ g_AttributeMask = 0x0;
	110	+ g_AttributeResetMask = 0x0;
	111	+ g_LatestVT = 0;
	112	+ g_LatestVN = 0;
	113	+
	114	+ m_bounds.min.x = m_bounds.min.y = m_bounds.min.z = 99999;
	115	+ m_bounds.max.x = m_bounds.max.y = m_bounds.max.z = -99999;
	116	+
	117	+ current_primitive_mask = 0x0;
	118	+}
	119	+
	120	+void rtsOBJ::CopyOBJ(const rtsOBJ& obj)
	121	+{
	122	+ current_vt = obj.current_vt;
	123	+ current_vn = obj.current_vn;
	124	+ vt_changed = obj.vt_changed; //true if a new vt or vn was inserted since the last vertex
	125	+ vn_changed = obj.vn_changed;
	126	+ current_primitive_mask = obj.current_primitive_mask; //defines what coordinates are being used by the current primitive
	127	+ //global variable storing the current render mode
	128	+ g_CurrentMode = obj.g_CurrentMode;
	129	+ //output file stream
	130	+ //g_objFile = obj.g_objFile;
	131	+ //obj file object
	132	+ //objData g_OBJ;
	133	+ //number of vertices since the last BEGIN
	134	+ g_NumVertices = obj.g_NumVertices;
	135	+ /*Attribute mask. This indicates what attributes are stored for each vertex.
	136	+ Only a single mask applies to each vertex between objBegin() and objEnd(). The
	137	+ attribute mask is flipped the first time an attribute is set but it is fixed after
	138	+ the first vertex is passed.*/
	139	+ g_AttributeMask = obj.g_AttributeMask;
	140	+ /*Attribute reset mask. This indicates whether or not an attribute has been
	141	+ reset since the last vertex was rendered. This applies to OBJ_VT and OBJ_VN*/
	142	+ g_AttributeResetMask = obj.g_AttributeResetMask;
	143	+ //latest texture coordinate sent
	144	+ g_LatestVT = obj.g_LatestVT;
	145	+ //latest vertex normal sent
	146	+ g_LatestVN = obj.g_LatestVN;
	147	+ m_bounds = obj.m_bounds;
	148	+
	149	+
	150	+ v_list = obj.v_list;
	151	+ vt_list = obj.vt_list;
	152	+ vn_list = obj.vn_list;
	153	+ primitives = obj.primitives;
	154	+
	155	+ points = obj.points;
	156	+ lines = obj.lines;
	157	+ faces = obj.faces;
	158	+}
	159	+
	160	+//opens an obj file for rendering
	161	+OBJint rtsOBJ::objOpen(const char* filename)
	162	+{
	163	+ g_objFile.open(filename);
	164	+ return OBJ_OK;
	165	+}
	166	+
	167	+//close the obj file
	168	+OBJint rtsOBJ::objClose()
	169	+{
	170	+ //TODO: write obj data
	171	+ f_OutputVertices();
	172	+ f_OutputTextureCoordinates();
	173	+ f_OutputVertexNormals();
	174	+ f_OutputPoints();
	175	+ f_OutputLines();
	176	+ f_OutputFaces();
	177	+
	178	+ //close the file
	179	+ g_objFile.close();
	180	+
	181	+ //delete all of the data from the global object
	182	+ f_ClearAll();
	183	+ return OBJ_OK;
	184	+}
	185	+
	186	+OBJint rtsOBJ::objBegin(OBJint mode)
	187	+{
	188	+ //make sure that we aren't currently rendering
	189	+ if(g_CurrentMode != OBJ_NONE)
	190	+ return OBJ_ERROR;
	191	+ //make sure that the given mode is valid
	192	+ if(mode < OBJ_POINTS \|\| mode > OBJ_POLYGON)
	193	+ return OBJ_ERROR;
	194	+
	195	+ //otherwise, go ahead and set the mode
	196	+ g_CurrentMode = mode;
	197	+ //set the number of vertices to zero
	198	+ g_NumVertices = 0;
	199	+
	200	+ //reset the current state primitive state
	201	+ current_primitive_mask = 0x0;
	202	+
	203	+ return OBJ_OK;
	204	+}
	205	+
	206	+OBJint rtsOBJ::objEnd()
	207	+{
	208	+ OBJint error = OBJ_OK;
	209	+ //check to make sure the number of rendered vertices is valid for the current mode
	210	+ switch(g_CurrentMode)
	211	+ {
	212	+ case OBJ_NONE:
	213	+ //can't quit if we haven't started
	214	+ error = OBJ_ERROR;
	215	+ break;
	216	+ case OBJ_LINES:
	217	+ //if less than two vertices or an odd number of vertices
	218	+ if(g_NumVertices < 2 \|\| g_NumVertices%2 != 0)
	219	+ {
	220	+ //if there wasn't a vertex at all
	221	+ if(g_NumVertices == 0)
	222	+ error = OBJ_ERROR;
	223	+ //if there was at least one vertex
	224	+ else
	225	+ {
	226	+ //pop the last line off the list
	227	+ primitives.pop_back();
	228	+ lines.pop_back();
	229	+ error = OBJ_ERROR;
	230	+ }
	231	+ }
	232	+ break;
	233	+ case OBJ_LINE_STRIP:
	234	+ //if less than two vertices
	235	+ if(g_NumVertices < 2)
	236	+ {
	237	+ //if there wasn't a vertex at all
	238	+ if(g_NumVertices == 0)
	239	+ error = OBJ_ERROR;
	240	+ //if there was at least one vertex
	241	+ else
	242	+ {
	243	+ //pop the last line off the list
	244	+ primitives.pop_back();
	245	+ lines.pop_back();
	246	+ error = OBJ_ERROR;
	247	+ }
	248	+ }
	249	+ break;
	250	+ case OBJ_LINE_LOOP:
	251	+ //if less than three vertices
	252	+ if(g_NumVertices < 3)
	253	+ {
	254	+ //pop the last line off the list
	255	+ primitives.pop_back();
	256	+ lines.pop_back();
	257	+ error = OBJ_ERROR;
	258	+ }
	259	+ //connect the first and last points
	260	+ else
	261	+ {
	262	+ error = f_TerminateLineLoop();
	263	+ }
	264	+ break;
	265	+ case OBJ_TRIANGLES:
	266	+ //if less than three vertices or not a power of three
	267	+ if(g_NumVertices < 3 \|\| g_NumVertices%3 !=0)
	268	+ {
	269	+ primitives.pop_back();
	270	+ faces.pop_back();
	271	+ error = OBJ_ERROR;
	272	+ }
	273	+ break;
	274	+ case OBJ_TRIANGLE_STRIP:
	275	+ //if less than three vertices
	276	+ if(g_NumVertices < 3)
	277	+ {
	278	+ primitives.pop_back();
	279	+ faces.pop_back();
	280	+ error = OBJ_ERROR;
	281	+ }
	282	+ break;
	283	+ case OBJ_TRIANGLE_FAN:
	284	+ //if less than three vertices
	285	+ if(g_NumVertices < 3)
	286	+ {
	287	+ primitives.pop_back();
	288	+ faces.pop_back();
	289	+ error = OBJ_ERROR;
	290	+ }
	291	+ break;
	292	+ case OBJ_QUADS:
	293	+ if(g_NumVertices < 4 \|\| g_NumVertices%4 != 0)
	294	+ {
	295	+ primitives.pop_back();
	296	+ faces.pop_back();
	297	+ error = OBJ_ERROR;
	298	+ }
	299	+ break;
	300	+ case OBJ_QUAD_STRIP:
	301	+ //has to be at least 4 vertices and an even number
	302	+ if(g_NumVertices < 4 \|\| g_NumVertices%2 != 0)
	303	+ {
	304	+ primitives.pop_back();
	305	+ faces.pop_back();
	306	+ error = OBJ_ERROR;
	307	+ }
	308	+ break;
	309	+ case OBJ_POLYGON:
	310	+ //has to be at least three vertices
	311	+ if(g_NumVertices < 3)
	312	+ {
	313	+ primitives.pop_back();
	314	+ faces.pop_back();
	315	+ error = OBJ_ERROR;
	316	+ }
	317	+ break;
	318	+ }
	319	+
	320	+ //reset the attribute mask
	321	+ g_AttributeMask = 0x0;
	322	+ //just for closure, reset the attribute reset mask
	323	+ g_AttributeResetMask = 0x0;
	324	+ //stop rendering
	325	+ g_CurrentMode = OBJ_NONE;
	326	+ return error;
	327	+}
	328	+
	329	+OBJint rtsOBJ::f_InsertVertexf(float x, float y, float z, float w, unsigned char mask)
	330	+{
	331	+ //make sure we're rendering
	332	+ if(g_CurrentMode == OBJ_NONE)
	333	+ return OBJ_ERROR;
	334	+
	335	+ //insert the vertex into the vertex vector
	336	+ vertex_position v;
	337	+ v.x = x; v.y = y; v.z=z; v.w=w; v.mask = mask;
	338	+ v_list.push_back(v);
	339	+ f_AdjustExtents(v); //set the bounding box
	340	+ //insert texture coordinate and normal if specified for this primitive
	341	+ if((current_primitive_mask & OBJ_VT) && (vt_changed))
	342	+ vt_list.push_back(current_vt);
	343	+ if((current_primitive_mask & OBJ_VN) && (vn_changed))
	344	+ vn_list.push_back(current_vn);
	345	+
	346	+
	347	+ //increment the number of vertices inserted
	348	+ g_NumVertices++;
	349	+
	350	+ //handle each case of the vertex creation individually
	351	+ OBJint error = OBJ_OK;
	352	+ switch(g_CurrentMode)
	353	+ {
	354	+ case OBJ_POINTS:
	355	+ error = f_InsertPointVertex();
	356	+ break;
	357	+ case OBJ_LINES:
	358	+ error = f_InsertLineVertex();
	359	+ break;
	360	+ case OBJ_LINE_LOOP:
	361	+ error = f_InsertLineLoopVertex();
	362	+ break;
	363	+ case OBJ_LINE_STRIP:
	364	+ error = f_InsertLineStripVertex();
	365	+ break;
	366	+ case OBJ_TRIANGLES:
	367	+ error = f_InsertTriangleVertex();
	368	+ break;
	369	+ case OBJ_TRIANGLE_STRIP:
	370	+ error = f_InsertTriangleStripVertex();
	371	+ break;
	372	+ case OBJ_TRIANGLE_FAN:
	373	+ error = f_InsertTriangleFanVertex();
	374	+ break;
	375	+ case OBJ_QUADS:
	376	+ error = f_InsertQuadVertex();
	377	+ break;
	378	+ case OBJ_QUAD_STRIP:
	379	+ error = f_InsertQuadStripVertex();
	380	+ break;
	381	+ case OBJ_POLYGON:
	382	+ error = f_InsertPolygonVertex();
	383	+ break;
	384	+ }
	385	+ //set the reset mask to zero
	386	+ g_AttributeResetMask = 0x0;
	387	+
	388	+ //set the attribute mask to include vertex position
	389	+ g_AttributeMask = g_AttributeMask \| OBJ_V;
	390	+
	391	+ //return the result of the insertion
	392	+ return error;
	393	+}
	394	+
	395	+OBJint rtsOBJ::objVertex1f(float x)
	396	+{
	397	+ return f_InsertVertexf(x, 0.0, 0.0, 0.0, OBJ_V_X);
	398	+}
	399	+
	400	+OBJint rtsOBJ::objVertex2f(float x, float y)
	401	+{
	402	+ return f_InsertVertexf(x, y, 0.0, 0.0, OBJ_V_X \| OBJ_V_Y);
	403	+}
	404	+
	405	+OBJint rtsOBJ::objVertex3f(float x, float y, float z)
	406	+{
	407	+ return f_InsertVertexf(x, y, z, 0.0, OBJ_V_X \| OBJ_V_Y \| OBJ_V_Z);
	408	+
	409	+}
	410	+
	411	+OBJint rtsOBJ::objVertex4f(float x, float y, float z, float w)
	412	+{
	413	+ return f_InsertVertexf(x, y, z, w, OBJ_V_X \| OBJ_V_Y \| OBJ_V_Z \| OBJ_V_W);
	414	+}
	415	+
	416	+OBJint rtsOBJ::objNormal3f(float i, float j, float k)
	417	+{
	418	+ return f_InsertNormalf(i, j, k, OBJ_VN_I \| OBJ_VN_J \| OBJ_VN_K);
	419	+}
	420	+OBJint rtsOBJ::objNormal2f(float i, float j)
	421	+{
	422	+ return f_InsertNormalf(i, j, 0.0, OBJ_VN_I \| OBJ_VN_J);
	423	+}
	424	+
	425	+OBJint rtsOBJ::objNormal1f(float i)
	426	+{
	427	+ return f_InsertNormalf(i, 0.0, 0.0, OBJ_VN_I);
	428	+}
	429	+
	430	+OBJint rtsOBJ::f_InsertNormalf(float i, float j, float k, unsigned char mask)
	431	+{
	432	+ /*DEPRECATED
	433	+ //if the mode is not rendering faces, there is an error
	434	+ if(g_CurrentMode < OBJ_TRIANGLES)
	435	+ return OBJ_ERROR;
	436	+ //if the normal attribute flag is not set, set it (as long as a vertex hasn't been written)
	437	+ if(!(g_AttributeMask & OBJ_VN))
	438	+ {
	439	+ //if a vertex has been rendered, then we can't change the attribute, so exit
	440	+ if(g_NumVertices > 0)
	441	+ return OBJ_ERROR;
	442	+ else
	443	+ //otherwise, just set the attribute flag
	444	+ g_AttributeMask = g_AttributeMask \| OBJ_VN;
	445	+ }
	446	+
	447	+
	448	+ //insert the new normal into the normal list for the file
	449	+ vertex_normal new_vn;
	450	+ new_vn.i = i; new_vn.j = j; new_vn.k = k;
	451	+ new_vn.mask = mask;
	452	+ vn_list.push_back(new_vn);
	453	+ */
	454	+ current_vn.i = i; //set the current texture state to the given coordinates
	455	+ current_vn.j = j;
	456	+ current_vn.k = k;
	457	+ current_vn.mask = mask; //set the mask as appropriate
	458	+ vn_changed = true; //the texture coordinate state has changed
	459	+ current_primitive_mask = current_primitive_mask \| OBJ_VN; //the current primitive now uses texture coordinates (if it didn't previously)
	460	+
	461	+ return OBJ_OK;
	462	+}
	463	+
	464	+OBJint rtsOBJ::objTexCoord3f(float u, float v, float w)
	465	+{
	466	+ return f_InsertTexCoordf(u, v, w, OBJ_VT_U \| OBJ_VT_V \| OBJ_VT_W);
	467	+}
	468	+
	469	+OBJint rtsOBJ::objTexCoord2f(float u, float v)
	470	+{
	471	+ return f_InsertTexCoordf(u, v, 0.0, OBJ_VT_U \| OBJ_VT_V);
	472	+}
	473	+
	474	+OBJint rtsOBJ::objTexCoord1f(float u)
	475	+{
	476	+ return f_InsertTexCoordf(u, 0.0, 0.0, OBJ_VT_U);
	477	+}
	478	+
	479	+OBJint rtsOBJ::f_InsertTexCoordf(float u, float v, float w, unsigned char mask)
	480	+{
	481	+ /*
	482	+ DEPRECATED
	483	+ //if the normal attribute flag is not set, set it (as long as a vertex hasn't been written)
	484	+ if(!(g_AttributeMask & OBJ_VT))
	485	+ {
	486	+ //if a vertex has been rendered, then we can't change the attribute, so exit
	487	+ if(g_NumVertices > 0)
	488	+ return OBJ_ERROR;
	489	+ else
	490	+ //otherwise, just set the attribute flag
	491	+ g_AttributeMask = g_AttributeMask \| OBJ_VT;
	492	+ }
	493	+
	494	+ //insert the new texture coordinate into the list for the file
	495	+ vertex_texture new_vt;
	496	+ new_vt.u = u; new_vt.v = v; new_vt.w = w;
	497	+ new_vt.mask = mask;
	498	+ vt_list.push_back(new_vt);
	499	+ */
	500	+ current_vt.u = u; //set the current texture state to the given coordinates
	501	+ current_vt.v = v;
	502	+ current_vt.w = w;
	503	+ current_vt.mask = mask; //set the mask as appropriate
	504	+ vt_changed = true; //the texture coordinate state has changed
	505	+ current_primitive_mask = current_primitive_mask \| OBJ_VT; //the current primitive now uses texture coordinates (if it didn't previously)
	506	+
	507	+ return OBJ_OK;
	508	+}
	509	+
	510	+
	511	+void rtsOBJ::insertVertexPosition(float x, float y, float z, unsigned char mask)
	512	+{
	513	+ vertex_position v;
	514	+ v.x = x;
	515	+ v.y = y;
	516	+ v.z = z;
	517	+ v.mask = mask;
	518	+
	519	+ v_list.push_back(v);
	520	+}
	521	+
	522	+void rtsOBJ::insertLine(unsigned int num_points, unsigned int* pointlist, unsigned int* normallist, unsigned int* texturelist)
	523	+{
	524	+ //create the new primitive
	525	+ primitive line;
	526	+ line.type = OBJ_LINES;
	527	+ line.mask = 0;
	528	+
	529	+ //set the mask based on the passed data
	530	+ if(pointlist != NULL)
	531	+ line.mask = line.mask \| OBJ_V;
	532	+ if(normallist != NULL)
	533	+ line.mask = line.mask \| OBJ_VN;
	534	+ if(texturelist != NULL)
	535	+ line.mask = line.mask \| OBJ_VT;
	536	+
	537	+ //insert the line
	538	+ int v;
	539	+ vertex new_vert;
	540	+ for(v=0; v<num_points; v++)
	541	+ {
	542	+ if(pointlist)
	543	+ new_vert.v = pointlist[v];
	544	+ if(normallist)
	545	+ new_vert.vn = normallist[v];
	546	+ if(texturelist)
	547	+ new_vert.vt = texturelist[v];
	548	+ line.p.push_back(new_vert);
	549	+ }
	550	+ //insert the new primitive into the list
	551	+ primitives.push_back(line);
	552	+}
	553	+OBJint rtsOBJ::f_InsertPointVertex()
	554	+{
	555	+ //insert the most recent point into the most recent point list
	556	+ //if this is the first vertex, create the point list
	557	+ if(g_NumVertices == 1)
	558	+ {
	559	+ primitive new_p; //create the new point
	560	+ new_p.type = OBJ_POINTS;
	561	+ new_p.mask = current_primitive_mask;
	562	+ points.push_back(primitives.size()); //store the primitive id in the points list
	563	+ primitives.push_back(new_p);
	564	+ }
	565	+
	566	+ //find the id of the most recent primitive
	567	+ unsigned int p_index = primitives.size() - 1;
	568	+ //find the index of the recent point
	569	+ vertex p;
	570	+ p.v = v_list.size() - 1;
	571	+ //insert the indices for texture coordinates and normal if necessary
	572	+ if(primitives[p_index].mask & OBJ_VT)
	573	+ p.vt = vt_list.size() - 1;
	574	+ if(primitives[p_index].mask & OBJ_VN)
	575	+ p.vn = vn_list.size() - 1;
	576	+
	577	+ //insert the vertex index into the primitive's point list
	578	+ primitives[p_index].p.push_back(p);
	579	+
	580	+ //push the point into the points list if it is not the only point in the primitive
	581	+ if(g_NumVertices > 1)
	582	+ points.push_back(p_index);
	583	+
	584	+ return OBJ_OK;
	585	+}
	586	+
	587	+OBJint rtsOBJ::f_InsertLineVertex()
	588	+{
	589	+ //if this is an odd vertex, create a new line
	590	+ if(g_NumVertices%2 == 1)
	591	+ {
	592	+ f_CreateNewLine();
	593	+ }
	594	+
	595	+ f_InsertNewLineVertex();
	596	+
	597	+ return OBJ_OK;
	598	+}
	599	+OBJint rtsOBJ::f_InsertLineLoopVertex()
	600	+{
	601	+ //technically, this is the same as inserting a line strip vertex
	602	+ f_InsertLineStripVertex();
	603	+ return OBJ_OK;
	604	+}
	605	+
	606	+OBJint rtsOBJ::f_InsertLineStripVertex()
	607	+{
	608	+ if(g_NumVertices == 1)
	609	+ {
	610	+ f_CreateNewLine();
	611	+ }
	612	+
	613	+ f_InsertNewLineVertex();
	614	+
	615	+ return OBJ_OK;
	616	+}
	617	+
	618	+OBJint rtsOBJ::f_InsertTriangleVertex()
	619	+{
	620	+ //if this is the first vertex in a triangle, create a new triangle
	621	+ if(g_NumVertices%3 == 1)
	622	+ {
	623	+ f_CreateNewFace();
	624	+ }
	625	+
	626	+
	627	+ f_InsertNewFaceVertex();
	628	+
	629	+ return OBJ_OK;
	630	+}
	631	+OBJint rtsOBJ::f_InsertTriangleStripVertex()
	632	+{
	633	+ //in the special case of the first three vertices, just create a triangle
	634	+ if(g_NumVertices <4)
	635	+ f_InsertTriangleVertex();
	636	+ else
	637	+ {
	638	+
	639	+ //create a new face for the new triangle
	640	+ f_CreateNewFace();
	641	+
	642	+ //insert the last two vertices from the previous triangle
	643	+ f_InsertPreviousFaceVertex(1);
	644	+ f_InsertPreviousFaceVertex(2);
	645	+ //insert the new vertex
	646	+ f_InsertNewFaceVertex();
	647	+ }
	648	+
	649	+ return OBJ_OK;
	650	+}
	651	+OBJint rtsOBJ::f_InsertTriangleFanVertex()
	652	+{
	653	+ //in the special case of the first three vertices, just create a triangle
	654	+ if(g_NumVertices <4)
	655	+ f_InsertTriangleVertex();
	656	+ else
	657	+ {
	658	+ //create a new face for the new triangle
	659	+ f_CreateNewFace();
	660	+ //add the previous vertices to the face
	661	+ f_InsertFirstFaceVertex(0);
	662	+ f_InsertPreviousFaceVertex(2);
	663	+ //insert the current vertex
	664	+ f_InsertNewFaceVertex();
	665	+ }
	666	+
	667	+ return OBJ_OK;
	668	+}
	669	+OBJint rtsOBJ::f_InsertQuadVertex()
	670	+{
	671	+ //if this is the first vertex in a quad, create a new quad
	672	+ if(g_NumVertices%4 == 1)
	673	+ {
	674	+ f_CreateNewFace();
	675	+ }
	676	+
	677	+ f_InsertNewFaceVertex();
	678	+
	679	+ return OBJ_OK;
	680	+}
	681	+OBJint rtsOBJ::f_InsertQuadStripVertex()
	682	+{
	683	+ //in the case of one of the first four vertices, just create a quad
	684	+ if(g_NumVertices < 5)
	685	+ f_InsertQuadVertex();
	686	+ //if the vertex is odd (it will be the third vertex of a quad)
	687	+ else if(g_NumVertices%2 == 1)
	688	+ {
	689	+ //create a new face for the new quad
	690	+ f_CreateNewFace();
	691	+ //add the previous two vertices
	692	+ f_InsertPreviousFaceVertex(2);
	693	+ f_InsertPreviousFaceVertex(3);
	694	+ //add the current vertex
	695	+ f_InsertNewFaceVertex();
	696	+ }
	697	+ else
	698	+ {
	699	+ //if this is the last vertex of the quad, just add it
	700	+ f_InsertNewFaceVertex();
	701	+
	702	+ }
	703	+ return OBJ_OK;
	704	+}
	705	+OBJint rtsOBJ::f_InsertPolygonVertex()
	706	+{
	707	+ //if this is the first vertex, create the quad
	708	+ if(g_NumVertices == 1)
	709	+ {
	710	+ f_CreateNewFace();
	711	+ }
	712	+ f_InsertNewFaceVertex();
	713	+
	714	+ return OBJ_OK;
	715	+}
	716	+
	717	+OBJint rtsOBJ::f_InsertPreviousFaceVertex(unsigned int v_index)
	718	+{
	719	+ /*Finds the vertex used in the previous face with the given index and
	720	+ inserts it into the current face. This limits the redundancy in the file
	721	+ for re-used vertices (in strips and fans). This also transfers texture
	722	+ and normal information.*/
	723	+
	724	+ //find the index of the previous face
	725	+ unsigned int prev_f_index = primitives.size() - 2;
	726	+ //find the index of the current face
	727	+ unsigned int f_index = prev_f_index +1;
	728	+ //add the vertex information from the previous face to this face
	729	+ primitives[f_index].p.push_back(primitives[prev_f_index].p[v_index]);
	730	+
	731	+ return OBJ_OK;
	732	+}
	733	+
	734	+OBJint rtsOBJ::f_InsertFirstFaceVertex(unsigned int v_index)
	735	+{
	736	+ /*Finds the vertex used in the first face (since the last objBegin())
	737	+ with the given index and inserts it at the end of the current face.
	738	+ This includes texture and normal information.*/
	739	+
	740	+ //The result depends on the type of face being rendered
	741	+ //So far, this function only applies to triangle fans
	742	+ if(g_CurrentMode != OBJ_TRIANGLE_FAN)
	743	+ return OBJ_ERROR;
	744	+
	745	+ //calculate the number of faces that have been rendered
	746	+ unsigned int num_faces = g_NumVertices - 2;
	747	+ //find the index of the first face
	748	+ unsigned int first_f_index = primitives.size() - num_faces;
	749	+ //find the index of the current face
	750	+ unsigned int f_index = primitives.size() - 1;
	751	+ //transfer the vertex information from the first face to this one
	752	+ primitives[f_index].p.push_back(primitives[first_f_index].p[v_index]);
	753	+
	754	+
	755	+ return OBJ_OK;
	756	+}
	757	+
	758	+OBJint rtsOBJ::f_InsertNewFaceVertex()
	759	+{
	760	+ /This inserts information about the current vertex into the current face/
	761	+ //find the new vertex index
	762	+ vertex p;
	763	+ p.v = v_list.size() -1;
	764	+ p.vt = vt_list.size() - 1;
	765	+ p.vn = vn_list.size() -1;
	766	+ //find the face index
	767	+ unsigned int f_index = primitives.size() -1;
	768	+ //INSERT VERTEX AND ATTRIBUTE DATA
	769	+ //just add the vertex to the face
	770	+ primitives[f_index].p.push_back(p);
	771	+
	772	+ return OBJ_OK;
	773	+}
	774	+
	775	+OBJint rtsOBJ::f_InsertNewLineVertex()
	776	+{
	777	+ /This inserts information about the current vertex into the current line/
	778	+ //find the new vertex index
	779	+ vertex p;
	780	+ p.v = v_list.size() -1;
	781	+ p.vt = vt_list.size() - 1;
	782	+ //find the line index
	783	+ unsigned int l_index = primitives.size() -1;
	784	+
	785	+ //ADD VERTEX AND ATTRIBUTE INFORMATION
	786	+ //add the vertex to the line
	787	+ primitives[l_index].p.push_back(p);
	788	+
	789	+ return OBJ_OK;
	790	+}
	791	+
	792	+OBJint rtsOBJ::f_CreateNewFace()
	793	+{
	794	+ primitive new_f;
	795	+ new_f.type = OBJ_FACE;
	796	+ new_f.mask = g_AttributeMask;
	797	+ faces.push_back(primitives.size());
	798	+ primitives.push_back(new_f);
	799	+
	800	+
	801	+ return OBJ_OK;
	802	+}
	803	+
	804	+OBJint rtsOBJ::f_CreateNewLine()
	805	+{
	806	+ primitive new_l;
	807	+ new_l.type = OBJ_LINES;
	808	+ new_l.mask = g_AttributeMask;
	809	+ lines.push_back(primitives.size());
	810	+ primitives.push_back(new_l);
	811	+
	812	+ return OBJ_OK;
	813	+}
	814	+
	815	+
	816	+OBJint rtsOBJ::f_TerminateLineLoop()
	817	+{
	818	+ /*This function just terminates the line loop by setting the last vertex
	819	+ to the first vertex.*/
	820	+ if(g_CurrentMode != OBJ_LINE_LOOP)
	821	+ return OBJ_ERROR;
	822	+ //find the index for the current line
	823	+ unsigned int l_index = lines.size() -1;
	824	+ //insert the first vertex as the last vertex
	825	+ primitives[l_index].p.push_back(primitives[l_index].p[0]);
	826	+
	827	+ return OBJ_OK;
	828	+}
	829	+
	830	+void rtsOBJ::f_OutputVertices()
	831	+{
	832	+ //get the number of vertices in the object
	833	+ unsigned int v_num = v_list.size();
	834	+ for(unsigned int i=0; i<v_num; i++)
	835	+ {
	836	+ g_objFile<<"v";
	837	+ if(v_list[i].mask & OBJ_V_X)
	838	+ g_objFile<<" "<<v_list[i].x;
	839	+ if(v_list[i].mask & OBJ_V_Y)
	840	+ g_objFile<<" "<<v_list[i].y;
	841	+ if(v_list[i].mask & OBJ_V_Z)
	842	+ g_objFile<<" "<<v_list[i].z;
	843	+ if(v_list[i].mask & OBJ_V_W)
	844	+ g_objFile<<" "<<v_list[i].w;
	845	+ g_objFile<<endl;
	846	+ }
	847	+
	848	+}
	849	+
	850	+void rtsOBJ::f_OutputVertexNormals()
	851	+{
	852	+ //get the number of normals in the object
	853	+ unsigned int vn_num = vn_list.size();
	854	+ for(unsigned int i=0; i<vn_num; i++)
	855	+ {
	856	+ g_objFile<<"vn ";
	857	+ if(vn_list[i].mask & OBJ_VN_I)
	858	+ {
	859	+ g_objFile<<vn_list[i].i;
	860	+ if(vn_list[i].mask & OBJ_VN_J)
	861	+ {
	862	+ g_objFile<<" "<<vn_list[i].j;
	863	+ if(vn_list[i].mask & OBJ_VN_K)
	864	+ g_objFile<<" "<<vn_list[i].k;
	865	+ }
	866	+ }
	867	+ g_objFile<<endl;
	868	+ }
	869	+}
	870	+
	871	+void rtsOBJ::f_OutputTextureCoordinates()
	872	+{
	873	+ //get the number of vertices in the object
	874	+ unsigned int vt_num = vt_list.size();
	875	+ for(unsigned int i=0; i<vt_num; i++)
	876	+ {
	877	+ g_objFile<<"vt ";
	878	+ if(vt_list[i].mask & OBJ_VT_U)
	879	+ {
	880	+ g_objFile<<vt_list[i].u;
	881	+ if(vt_list[i].mask & OBJ_VT_V)
	882	+ {
	883	+ g_objFile<<" "<<vt_list[i].v;
	884	+ if(vt_list[i].mask & OBJ_VT_W)
	885	+ g_objFile<<" "<<vt_list[i].w;
	886	+ }
	887	+ }
	888	+ g_objFile<<endl;
	889	+ }
	890	+}
	891	+
	892	+void rtsOBJ::f_OutputPoints()
	893	+{
	894	+ /*
	895	+ //get the number of point vectors
	896	+ unsigned int p_num = points.size();
	897	+
	898	+ //for each point vector, output the points
	899	+ for(unsigned int i=0; i<p_num; i++)
	900	+ {
	901	+ g_objFile<<"p";
	902	+ unsigned int v_num = points[i].p.size();
	903	+ for(unsigned int j=0; j<v_num; j++)
	904	+ {
	905	+ g_objFile<<" "<<points[i].p[j].v+1;
	906	+ }
	907	+ g_objFile<<endl;
	908	+ }
	909	+ */
	910	+}
	911	+
	912	+void rtsOBJ::f_OutputLines()
	913	+{
	914	+ /*
	915	+ //get the number of line vectors
	916	+ unsigned int l_num = lines.size();
	917	+
	918	+ //for each line vector, output the associated points
	919	+ for(unsigned int i=0; i<l_num; i++)
	920	+ {
	921	+ g_objFile<<"l";
	922	+ unsigned int v_num = lines[i].p.size();
	923	+ for(unsigned int j=0; j<v_num; j++)
	924	+ {
	925	+ g_objFile<<" "<<lines[i].p[j].v+1;
	926	+ //output texture coordinate if there are any
	927	+ if(lines[i].mask & OBJ_VT)
	928	+ g_objFile<<"/"<<lines[i].p[j].vt+1;
	929	+ }
	930	+ g_objFile<<endl;
	931	+ }
	932	+ */
	933	+}
	934	+
	935	+void rtsOBJ::f_OutputFaces()
	936	+{
	937	+ /*
	938	+ //get the number of faces
	939	+ unsigned int f_num = faces.size();
	940	+
	941	+ //for each face, output the associated points
	942	+ for(unsigned int i=0; i<f_num; i++)
	943	+ {
	944	+ g_objFile<<"f";
	945	+ //get the number of face vertices
	946	+ unsigned int v_num = faces[i].p.size();
	947	+ for(unsigned int j=0; j<v_num; j++)
	948	+ {
	949	+ g_objFile<<" "<<faces[i].p[j].v+1;
	950	+ //if there are texture coordinates
	951	+ if(faces[i].mask & OBJ_VT)
	952	+ g_objFile<<"/"<<faces[i].p[j].vt+1;
	953	+ //if there is a normal
	954	+ if(faces[i].mask & OBJ_VN)
	955	+ {
	956	+ //but no texture coordinates, put an extra slash
	957	+ if(!(faces[i].mask & OBJ_VT))
	958	+ g_objFile<<"/";
	959	+ g_objFile<<"/"<<faces[i].p[j].vn+1;
	960	+ }
	961	+
	962	+ }
	963	+ g_objFile<<endl;
	964	+ }
	965	+ */
	966	+}
	967	+
	968	+void rtsOBJ::f_ClearAll()
	969	+{
	970	+ rtsOBJ();
	971	+ //clear all data from the global obj function
	972	+ faces.clear();
	973	+ lines.clear();
	974	+ points.clear();
	975	+ v_list.clear();
	976	+ vn_list.clear();
	977	+ vt_list.clear();
	978	+ primitives.clear();
	979	+}
	980	+
	981	+/GLOBAL FUNCTION DEFINITIONS/
	982	+//initialize the OBJ file
	983	+OBJint objOpen(char* filename)
	984	+{
	985	+ return g_OBJ.objOpen(filename);
	986	+}
	987	+//close the obj file
	988	+OBJint objClose()
	989	+{
	990	+ return g_OBJ.objClose();
	991	+}
	992	+
	993	+//start rendering in a certain mode
	994	+OBJint objBegin(OBJint mode)
	995	+{
	996	+ return g_OBJ.objBegin(mode);
	997	+}
	998	+//stop the current rendering sequence
	999	+OBJint objEnd(void)
	1000	+{
	1001	+ return g_OBJ.objEnd();
	1002	+}
	1003	+//render a vertex to the file
	1004	+OBJint objVertex1f(float x)
	1005	+{
	1006	+ return g_OBJ.objVertex1f(x);
	1007	+}
	1008	+
	1009	+OBJint objVertex2f(float x, float y)
	1010	+{
	1011	+ return g_OBJ.objVertex2f(x, y);
	1012	+}
	1013	+
	1014	+OBJint objVertex3f(float x, float y, float z)
	1015	+{
	1016	+ return g_OBJ.objVertex3f(x, y, z);
	1017	+}
	1018	+
	1019	+OBJint objVertex4f(float x, float y, float z, float w)
	1020	+{
	1021	+ return g_OBJ.objVertex4f(x, y, z, w);
	1022	+}
	1023	+//set a normal vector for a vertex
	1024	+OBJint objNormal3f(float i, float j, float k)
	1025	+{
	1026	+ return g_OBJ.objNormal3f(i, j, k);
	1027	+}
	1028	+OBJint objNormal2f(float i, float j)
	1029	+{
	1030	+ return g_OBJ.objNormal2f(i, j);
	1031	+}
	1032	+OBJint objNormal1f(float i)
	1033	+{
	1034	+ return g_OBJ.objNormal1f(i);
	1035	+}
	1036	+//set a texture coordinate for a vertex
	1037	+OBJint objTexCoord3f(float u, float v, float w)
	1038	+{
	1039	+ return g_OBJ.objTexCoord3f(u, v, w);
	1040	+}
	1041	+
	1042	+OBJint objTexCoord2f(float u, float v)
	1043	+{
	1044	+ return g_OBJ.objTexCoord2f(u,v);
	1045	+}
	1046	+
	1047	+OBJint objTexCoord1f(float u)
	1048	+{
	1049	+ return g_OBJ.objTexCoord1f(u);
	1050	+}
	1051	+
	1052	+OBJint rtsOBJ::f_ReadPosition(ifstream &infile)
	1053	+{
	1054	+ vertex_position new_vertex;
	1055	+ //get each coordinate
	1056	+ infile>>new_vertex.x;
	1057	+ new_vertex.mask = OBJ_V_X;
	1058	+
	1059	+ if(infile.peek() == ' ')
	1060	+ {
	1061	+ infile>>new_vertex.y;
	1062	+ new_vertex.mask = new_vertex.mask \| OBJ_V_Y;
	1063	+ }
	1064	+ if(infile.peek() == ' ')
	1065	+ {
	1066	+ infile>>new_vertex.z;
	1067	+ new_vertex.mask = new_vertex.mask \| OBJ_V_Z;
	1068	+ }
	1069	+ if(infile.peek() == ' ')
	1070	+ {
	1071	+ infile>>new_vertex.w;
	1072	+ new_vertex.mask = new_vertex.mask \| OBJ_V_W;
	1073	+ }
	1074	+ int c = infile.peek();
	1075	+ //ignore the rest of the line
	1076	+ infile.ignore(1000, '\n');
	1077	+ c = infile.peek();
	1078	+
	1079	+ //cout<<"vertex read: "<<new_vertex.x<<","<<new_vertex.y<<","<<new_vertex.z<<","<<new_vertex.w<<endl;
	1080	+ //insert the vertex into the list
	1081	+ v_list.push_back(new_vertex);
	1082	+
	1083	+ //adjust the extents of the model
	1084	+ f_AdjustExtents(new_vertex);
	1085	+
	1086	+ return OBJ_OK;
	1087	+}
	1088	+
	1089	+OBJint rtsOBJ::f_ReadNormal(ifstream &infile)
	1090	+{
	1091	+ vertex_normal new_normal;
	1092	+ infile>>new_normal.i;
	1093	+ new_normal.mask = OBJ_VN_I;
	1094	+ //get every other component
	1095	+ if(infile.peek() == ' ')
	1096	+ {
	1097	+ infile>>new_normal.j;
	1098	+ new_normal.mask = new_normal.mask \| OBJ_VN_J;
	1099	+ }
	1100	+ if(infile.peek() == ' ')
	1101	+ {
	1102	+ infile>>new_normal.k;
	1103	+ new_normal.mask = new_normal.mask \| OBJ_VN_K;
	1104	+ }
	1105	+ //ignore the rest of the line
	1106	+ infile.ignore(1000, '\n');
	1107	+ //insert the normal
	1108	+ vn_list.push_back(new_normal);
	1109	+
	1110	+ return OBJ_OK;
	1111	+}
	1112	+
	1113	+OBJint rtsOBJ::f_ReadTexCoord(ifstream &infile)
	1114	+{
	1115	+ vertex_texture new_texcoord;
	1116	+ infile>>new_texcoord.u;
	1117	+ new_texcoord.mask = OBJ_VT_U;
	1118	+ //get every other component
	1119	+ if(infile.peek() == ' ')
	1120	+ {
	1121	+ infile>>new_texcoord.v;
	1122	+ new_texcoord.mask = new_texcoord.mask \| OBJ_VT_V;
	1123	+ }
	1124	+ if(infile.peek() == ' ')
	1125	+ {
	1126	+ infile>>new_texcoord.w;
	1127	+ new_texcoord.mask = new_texcoord.mask \| OBJ_VT_W;
	1128	+ }
	1129	+
	1130	+ //ignore the rest of the line
	1131	+ infile.ignore(1000, '\n');
	1132	+ //insert the texture coordinate
	1133	+ vt_list.push_back(new_texcoord);
	1134	+
	1135	+ return OBJ_OK;
	1136	+
	1137	+}
	1138	+
	1139	+OBJint rtsOBJ::f_ReadVertex(ifstream &infile, vertex &new_point, unsigned char &mask)
	1140	+{
	1141	+ //store the line vertex
	1142	+ infile>>new_point.v;
	1143	+ new_point.v--;
	1144	+ mask = OBJ_V;
	1145	+ //new_face.v.push_back(new_v - 1);
	1146	+ if(infile.peek() == '/')
	1147	+ {
	1148	+ infile.get();
	1149	+ //if there actually is a texcoord
	1150	+ if(infile.peek() != '/')
	1151	+ {
	1152	+ infile>>new_point.vt; //get the index
	1153	+ new_point.vt--;
	1154	+ mask = mask \| OBJ_VT; //update the mask
	1155	+ //new_face.vt.push_back(new_vt - 1);
	1156	+ }
	1157	+ }
	1158	+ //check for a normal
	1159	+ if(infile.peek() == '/')
	1160	+ {
	1161	+ infile.get();
	1162	+ infile>>new_point.vn; //get the index
	1163	+ new_point.vn--;
	1164	+ mask = mask \| OBJ_VN; //update the mask
	1165	+ }
	1166	+
	1167	+ return OBJ_OK;
	1168	+}
	1169	+
	1170	+OBJint rtsOBJ::f_ReadPrimitive(ifstream &infile, primitive_type type)
	1171	+{
	1172	+ //create a new point list
	1173	+ primitive new_primitive;
	1174	+ new_primitive.type = type;
	1175	+ //until the end of the line
	1176	+ while(infile.peek() != '\n')
	1177	+ {
	1178	+ //read each point
	1179	+ if(infile.peek() == ' ')
	1180	+ infile.get();
	1181	+ else
	1182	+ {
	1183	+ vertex new_point;
	1184	+ f_ReadVertex(infile, new_point, new_primitive.mask);
	1185	+ new_primitive.p.push_back(new_point);
	1186	+ }
	1187	+ }
	1188	+ //ignore the rest of the line
	1189	+ infile.ignore(1000, '\n');
	1190	+
	1191	+ //push the id of the primitive into the new list
	1192	+ //:DEBUG:
	1193	+ if(type == OBJ_POINTS)
	1194	+ points.push_back(primitives.size());
	1195	+ else if(type == OBJ_LINES)
	1196	+ lines.push_back(primitives.size());
	1197	+ else if(type == OBJ_FACE)
	1198	+ faces.push_back(primitives.size());
	1199	+
	1200	+ primitives.push_back(new_primitive); //push the new primitive
	1201	+
	1202	+ return OBJ_OK;
	1203	+}
	1204	+
	1205	+
	1206	+OBJint rtsOBJ::f_AdjustExtents(vertex_position v)
	1207	+{
	1208	+ if(v.x < m_bounds.min.x)
	1209	+ m_bounds.min.x = v.x;
	1210	+ if(v.y < m_bounds.min.y)
	1211	+ m_bounds.min.y = v.y;
	1212	+ if(v.z < m_bounds.min.z)
	1213	+ m_bounds.min.z = v.z;
	1214	+
	1215	+ if(v.x > m_bounds.max.x) m_bounds.max.x = v.x;
	1216	+ if(v.y > m_bounds.max.y) m_bounds.max.y = v.y;
	1217	+ if(v.z > m_bounds.max.z) m_bounds.max.z = v.z;
	1218	+
	1219	+ return OBJ_OK;
	1220	+}
	1221	+
	1222	+OBJint rtsOBJ::f_LoadOBJ(const char* filename)
	1223	+{
	1224	+ f_ClearAll();
	1225	+ //open the file as a stream
	1226	+ ifstream infile;
	1227	+ infile.open(filename);
	1228	+ if(!infile.is_open())
	1229	+ return OBJ_ERROR;
	1230	+
	1231	+ unsigned int vertices = 0;
	1232	+
	1233	+ string token;
	1234	+ infile>>token;
	1235	+ while(!infile.eof())
	1236	+ {
	1237	+ //if the token is some vertex property
	1238	+ if(token == "v")
	1239	+ f_ReadPosition(infile);
	1240	+ else if(token == "vn")
	1241	+ f_ReadNormal(infile);
	1242	+ else if(token == "vt")
	1243	+ f_ReadTexCoord(infile);
	1244	+ else if(token == "p")
	1245	+ f_ReadPrimitive(infile, OBJ_POINTS);
	1246	+ else if(token == "l")
	1247	+ f_ReadPrimitive(infile, OBJ_LINES);
	1248	+ else if(token == "f")
	1249	+ f_ReadPrimitive(infile, OBJ_FACE);
	1250	+ else
	1251	+ infile.ignore(9999, '\n');
	1252	+ //vertices++;
	1253	+
	1254	+ infile>>token;
	1255	+ }
	1256	+
	1257	+}
	1258	+
	1259	+OBJint rtsOBJ::f_LoadSWC(const char* filename)
	1260	+{
	1261	+ f_ClearAll();
	1262	+ //open the file as a stream
	1263	+ ifstream infile;
	1264	+ infile.open(filename);
	1265	+ if(!infile.is_open())
	1266	+ return OBJ_ERROR;
	1267	+
	1268	+ vector<vertex_position> swcVertices;
	1269	+ float token;
	1270	+ objBegin(OBJ_LINES);
	1271	+ while(!infile.eof())
	1272	+ {
	1273	+ vertex_position v;
	1274	+ infile>>token; //get the id
	1275	+ infile>>token; //get the fiber type
	1276	+ infile>>v.x; //get the node position
	1277	+ infile>>v.y;
	1278	+ infile>>v.z;
	1279	+ infile>>token; //get the radius
	1280	+ infile>>token; //get the parent
	1281	+
	1282	+ //insert the node into the swc vector
	1283	+ swcVertices.push_back(v);
	1284	+ //now draw the line from the parent to the current node
	1285	+ if(token != -1)
	1286	+ {
	1287	+ objVertex3f(swcVertices[token-1].x, swcVertices[token-1].y, swcVertices[token-1].z);
	1288	+ objVertex3f(v.x, v.y, v.z);
	1289	+ }
	1290	+ }
	1291	+ objEnd();
	1292	+
	1293	+
	1294	+ return OBJ_OK;
	1295	+
	1296	+}
	1297	+OBJint rtsOBJ::LoadFile(const char* filename)
	1298	+{
	1299	+ string strFilename = filename;
	1300	+ int length = strFilename.length();
	1301	+ string extension = strFilename.substr(strFilename.length() - 3, 3);
	1302	+ if(!extension.compare(string("obj")))
	1303	+ return f_LoadOBJ(filename);
	1304	+ else if(!extension.compare(string("swc")))
	1305	+ return f_LoadSWC(filename);
	1306	+ else return f_LoadOBJ(filename);
	1307	+
	1308	+}
	1309	+
	1310	+OBJint rtsOBJ::SaveFile(const char* filename)
	1311	+{
	1312	+ //open the file as a stream
	1313	+ ofstream outfile;
	1314	+ outfile.open(filename);
	1315	+ if(!outfile.is_open())
	1316	+ return OBJ_ERROR;
	1317	+
	1318	+ //output vertex positions
	1319	+ vector<vertex_position>::iterator v;
	1320	+ for(v=v_list.begin(); v!= v_list.end(); v++)
	1321	+ {
	1322	+ outfile<<"v";
	1323	+ if((*v).mask & OBJ_V_X)
	1324	+ {
	1325	+ outfile<<' '<<(*v).x;
	1326	+ if((*v).mask & OBJ_V_Y)
	1327	+ {
	1328	+ outfile<<' '<<(*v).y;
	1329	+ if((*v).mask & OBJ_V_Z)
	1330	+ {
	1331	+ outfile<<' '<<(*v).z;
	1332	+ if((*v).mask & OBJ_V_W)
	1333	+ outfile<<' '<<(*v).w;
	1334	+ }
	1335	+ }
	1336	+ }
	1337	+ outfile<<'\n';
	1338	+ }
	1339	+
	1340	+ //output vertex texture coordinates
	1341	+ vector<vertex_texture>::iterator vt;
	1342	+ for(vt=vt_list.begin(); vt!= vt_list.end(); vt++)
	1343	+ {
	1344	+ outfile<<"vt";
	1345	+ if((*vt).mask & OBJ_VT_U)
	1346	+ {
	1347	+ outfile<<' '<<(*vt).u;
	1348	+ if((*vt).mask & OBJ_VT_V)
	1349	+ {
	1350	+ outfile<<' '<<(*vt).v;
	1351	+ if((*vt).mask & OBJ_VT_W)
	1352	+ outfile<<' '<<(*vt).w;
	1353	+ }
	1354	+ }
	1355	+ outfile<<'\n';
	1356	+ }
	1357	+
	1358	+ //output vertex normal coordinates
	1359	+ vector<vertex_normal>::iterator vn;
	1360	+ for(vn=vn_list.begin(); vn!= vn_list.end(); vn++)
	1361	+ {
	1362	+ outfile<<"vn";
	1363	+ if((*vn).mask & OBJ_VN_I)
	1364	+ {
	1365	+ outfile<<' '<<(*vn).i;
	1366	+ if((*vn).mask & OBJ_VN_J)
	1367	+ {
	1368	+ outfile<<' '<<(*vn).j;
	1369	+ if((*vn).mask & OBJ_VN_K)
	1370	+ outfile<<' '<<(*vn).k;
	1371	+ }
	1372	+ }
	1373	+ outfile<<'\n';
	1374	+ }
	1375	+
	1376	+ //output each primitive
	1377	+ vector<primitive>::iterator p;
	1378	+ vector<vertex>::iterator vert;
	1379	+ for(p=primitives.begin(); p!= primitives.end(); p++)
	1380	+ {
	1381	+ switch((*p).type)
	1382	+ {
	1383	+ case OBJ_POINTS:
	1384	+ outfile<<"p"; //output the points token
	1385	+ break;
	1386	+ case OBJ_LINES:
	1387	+ outfile<<"l"; //output the lines token
	1388	+ break;
	1389	+ case OBJ_FACE:
	1390	+ outfile<<"f"; //output the face token
	1391	+ break;
	1392	+ }
	1393	+
	1394	+ //for each vertex in the list for the primitive
	1395	+ for(vert = (p).p.begin(); vert != (p).p.end(); vert++)
	1396	+ {
	1397	+ outfile<<' '<<(*vert).v + 1;
	1398	+ if((*p).mask & OBJ_VT)
	1399	+ outfile<<'/'<<(*vert).vt + 1;
	1400	+ if((*p).mask & OBJ_VN)
	1401	+ {
	1402	+ if(!((*p).mask & OBJ_VT))
	1403	+ outfile<<'/';
	1404	+ outfile<<'/'<<(*vert).vn + 1;
	1405	+ }
	1406	+ }
	1407	+ outfile<<'\n';
	1408	+
	1409	+ }
	1410	+
	1411	+
	1412	+
	1413	+}
	1414	+
	1415	+//get methods
	1416	+unsigned int rtsOBJ::getNumVertices(){return v_list.size();}
	1417	+unsigned int rtsOBJ::getNumLines(){return lines.size();}
	1418	+unsigned int rtsOBJ::getNumFaces(){return faces.size();}
	1419	+unsigned int rtsOBJ::getNumPointLists(){return points.size();}
	1420	+unsigned int rtsOBJ::getNumTexCoords(){return vt_list.size();}
	1421	+unsigned int rtsOBJ::getNumNormals(){return vn_list.size();}
	1422	+
	1423	+//these functions return the coordinate index as well as the value
	1424	+unsigned int rtsOBJ::getNumFaceVertices(unsigned int face){return primitives[face].p.size();}
	1425	+unsigned int rtsOBJ::getFaceVertex(unsigned int face, unsigned int vertex){return primitives[face].p[vertex].v;}
	1426	+unsigned int rtsOBJ::getFaceNormal(unsigned int face, unsigned int normal){return primitives[face].p[normal].vn;}
	1427	+unsigned int rtsOBJ::getFaceTexCoord(unsigned int face, unsigned int texcoord){return primitives[face].p[texcoord].vt;}
	1428	+unsigned int rtsOBJ::getNumLineVertices(unsigned int line){return primitives[line].p.size();}
	1429	+unsigned int rtsOBJ::getLineVertex(unsigned int line, unsigned int vertex){return primitives[line].p[vertex].v;}
	1430	+unsigned int rtsOBJ::getLineTexCoord(unsigned int line, unsigned int texcoord){return primitives[line].p[texcoord].vt;}
	1431	+point3D<float> rtsOBJ::getVertex3d(unsigned int index)
	1432	+{
	1433	+ return point3D<float>(v_list[index].x, v_list[index].y, v_list[index].z);
	1434	+}
	1435	+point3D<float> rtsOBJ::getTexCoord3d(unsigned int index)
	1436	+{
	1437	+ return point3D<float>(vt_list[index].u, vt_list[index].v, vt_list[index].w);
	1438	+}
	1439	+point3D<float> rtsOBJ::getNormal3d(unsigned int index)
	1440	+{
	1441	+ return point3D<float>(vn_list[index].i, vn_list[index].j, vn_list[index].k);
	1442	+}
	1443	+vertex_position rtsOBJ::getVertex(unsigned int index){return v_list[index];}
	1444	+vertex_texture rtsOBJ::getTexCoord(unsigned int index){return vt_list[index];}
	1445	+vertex_normal rtsOBJ::getNormal(unsigned int index){return vn_list[index];}
	1446	+
	1447	+
	1448	+unsigned int rtsOBJ::getPrimitiveType(unsigned int primitive)
	1449	+{
	1450	+ /*
	1451	+ switch(primitives[i].type)
	1452	+ {
	1453	+ case OBJ_POINTS:
	1454	+ return OBJ_POINTS;
	1455	+ break;
	1456	+ case OBJ_LINES:
	1457	+ return OBJ_LINES;
	1458	+ break;
	1459	+ case OBJ_FACE:
	1460	+ f_RenderFace(i);
	1461	+ break;
	1462	+ }*/
	1463	+ return 0;
	1464	+}
	1465	+/****************************************************/
	1466	+/*****Iterator Methods***************************/
	1467	+/****************************************************/
	1468	+
	1469	+rtsOBJ::iterator rtsOBJ::begin()
	1470	+{
	1471	+ //create an iterator that will be returned and assign it to this OBJ
	1472	+ iterator result;
	1473	+ result.obj = this;
	1474	+ result.end_object = false;
	1475	+ result.end_primitive = false;
	1476	+
	1477	+ //if there are no primitives, return the end iterator
	1478	+ if(primitives.size() == 0)
	1479	+ return end();
	1480	+
	1481	+ //start at the beginning of the primitive array
	1482	+ result.primitive_index = 0;
	1483	+
	1484	+ return result;
	1485	+}
	1486	+
	1487	+rtsOBJ::iterator rtsOBJ::end()
	1488	+{
	1489	+ //create an end iterator to return
	1490	+ iterator result;
	1491	+ result.obj = this;
	1492	+ result.end_primitive = true;
	1493	+ result.primitive_index = result.obj->primitives.size();
	1494	+
	1495	+ return result;
	1496	+}
	1497	+
	1498	+void rtsOBJ::iterator::operator++()
	1499	+{
	1500	+ primitive_index++;
	1501	+ if(primitive_index >= obj->primitives.size())
	1502	+ (*this) = obj->end();
	1503	+
	1504	+}
	1505	+
	1506	+bool rtsOBJ::iterator::operator ==(rtsOBJ::iterator operand)
	1507	+{
	1508	+ if(operand.primitive_index == primitive_index)
	1509	+ return true;
	1510	+ else return false;
	1511	+}
	1512	+
	1513	+bool rtsOBJ::iterator::operator !=(rtsOBJ::iterator operand)
	1514	+{
	1515	+ if(operand.primitive_index != primitive_index)
	1516	+ return true;
	1517	+ else return false;
	1518	+}
	1519	+
	1520	+unsigned int rtsOBJ::iterator::operator*()
	1521	+{
	1522	+ return primitive_index;
	1523	+}
	1524	+
	1525	+void rtsOBJ::iterator::print()
	1526	+{
	1527	+ cout<<"This is a test"<<endl;
	1528	+}
	1529	+
	1530	+
	1531	+
0	1532	\ No newline at end of file
...	...

objJedi.h 0 → 100755

Wrap text Show/Hide comments View file @f140284

	1	+++ a/objJedi.h
	1	+#ifndef OBJJEDI_H
	2	+#define OBJJEDI_H
	3	+
	4

renewed commit

Too many changes. Reload with full diff Plain diff Email patch

Too many changes.
Reload with full diff Plain diff Email patch