segmentation / netmets-old

  #ifndef OBJJEDI_H
  #define OBJJEDI_H
  
  /*OBJ reader and writer.
  
  One aspect of the writer is based on OpenGL output commands.  You can send OpenGL commands
  (replacing "gl" and "GL" with "obj" and "OBJ" respectively to render to an Wavefront OBJ file
  */
  
  //#include "rtsMath.h"
  #include "rtsLinearAlgebra.h"
  #include <vector>
  #include <fstream>
  #include <iostream>
  #include <string.h>
  #include <stdlib.h>
  using namespace std;
  
  //masks for valid vertex components
  #define OBJ_V_X		0x1
  #define OBJ_V_Y		0x2
  #define OBJ_V_Z		0x4
  #define OBJ_V_W		0x8
  
  #define OBJ_VT_U	0x1
  #define OBJ_VT_V	0x2
  #define OBJ_VT_W	0x4
  
  #define OBJ_VN_I	0x1
  #define OBJ_VN_J	0x2
  #define OBJ_VN_K	0x4
  
  #define OBJ_V		0x1
  #define OBJ_VT		0x2
  #define OBJ_VN		0x4
  
  //primitive types
  typedef unsigned char primitive_type;
  
  #define OBJ_END				0x0
  #define OBJ_POINTS			0x1
  #define OBJ_LINES			0x2
  #define OBJ_FACE			0x3
  
  
  #define OBJ_INVALID		ULONG_MAX
  //define the point structures
  struct vertex_position{float x,y,z,w; unsigned char mask;};
  struct vertex_texture{float u,v,w; unsigned char mask;};
  struct vertex_normal{float i,j,k; unsigned char mask;};
  //the point structure contains indices to the relative 3-vectors in the lists
  struct vertex
  {
  	unsigned int v;
  	unsigned int vt;
  	unsigned int vn;
  };
  
  struct primitive
  {
  	vector<vertex> p;		//indices to the point
  	unsigned char mask;		//mask describing which features (v, vt, vn) are used
  	primitive_type type;	//the type of primitive (points, lines, face)
  };
  
  //axis-aligned bounding box
  struct AABB
  {
  	vertex_position min;
  	vertex_position max;
  };
  
  //create variable types
  typedef unsigned int OBJint;
  
  //define the OBJ data class
  class rtsOBJ
  {
  private:
  
  	/*Current state variables.  These variables are committed to the OBJ object
  	when a vertex is added.  However, we are careful to only add them once (if they don't
  	change with every vertex.
  	*/
  	vertex_texture current_vt;
  	vertex_normal current_vn;
  	bool vt_changed;				//true if a new vt or vn was inserted since the last vertex
  	bool vn_changed;
  	unsigned char current_primitive_mask;	//defines what coordinates are being used by the current primitive
  	//global variable storing the current render mode
  	OBJint g_CurrentMode;
  	//output file stream
  	ofstream g_objFile;
  	//obj file object
  	//objData g_OBJ;
  	//number of vertices since the last BEGIN
  	unsigned int g_NumVertices;
  	/*Attribute mask.  This indicates what attributes are stored for each vertex.
  	Only a single mask applies to each vertex between objBegin() and objEnd().  The
  	attribute mask is flipped the first time an attribute is set but it is fixed after
  	the first vertex is passed.*/
  	unsigned char g_AttributeMask;
  	/*Attribute reset mask.  This indicates whether or not an attribute has been
  	reset since the last vertex was rendered.  This applies to OBJ_VT and OBJ_VN*/
  	unsigned char g_AttributeResetMask;
  	//latest texture coordinate sent
  	unsigned int g_LatestVT;
  	//latest vertex normal sent
  	unsigned int g_LatestVN;
  
  	//extents of the points in the OBJ file
  	AABB m_bounds;
  
  	OBJint f_InsertPointVertex();
  	OBJint f_InsertLineVertex();
  	OBJint f_InsertLineLoopVertex();
  	OBJint f_InsertLineStripVertex();
  	OBJint f_InsertTriangleVertex();
  	OBJint f_InsertTriangleStripVertex();
  	OBJint f_InsertTriangleFanVertex();
  	OBJint f_InsertQuadVertex();
  	OBJint f_InsertQuadStripVertex();
  	OBJint f_InsertPolygonVertex();
  	OBJint f_InsertPreviousFaceVertex(unsigned int v_index);
  	OBJint f_InsertFirstFaceVertex(unsigned int v_index);
  	OBJint f_InsertNewFaceVertex();
  	OBJint f_InsertNewLineVertex();
  	OBJint f_CreateNewFace();
  	OBJint f_CreateNewLine();
  	OBJint f_TerminateLineLoop();
  	OBJint f_LoadOBJ(const char* filename);
  	OBJint f_LoadSWC(const char* filename);
  
  	//insert coordinate commands
  	//these are used to handle coordinates of different dimensions (and are called by the associated public function)
  	OBJint f_InsertVertexf(float x, float y, float z, float w, unsigned char mask);
  	OBJint f_InsertTexCoordf(float u, float v, float w, unsigned char mask);
  	OBJint f_InsertNormalf(float i, float j, float k, unsigned char mask);
  	//output functions
  	void f_OutputVertices();
  	void f_OutputPoints();
  	void f_OutputLines();
  	void f_OutputFaces();
  	void f_OutputVertexNormals();
  	void f_OutputTextureCoordinates();
  	void f_ClearAll();
  
  	//methods for reading from a file
  	OBJint f_ReadPosition(ifstream &infile);
  	OBJint f_ReadNormal(ifstream &infile);
  	OBJint f_ReadTexCoord(ifstream &infile);
  	OBJint f_ReadVertex(ifstream &infile, vertex &new_point, unsigned char &mask);
  	OBJint f_ReadPrimitive(ifstream &infile, primitive_type type);
  	OBJint f_AdjustExtents(vertex_position v);
  
  public:
  	/*These vectors store the vertex and primitive data from the obj file.
  	All vertices, texture coordinates, and normals are stored in m_v, m_vt, m_vn
  	respectively.  The vectors for each primitive store an index into m_v, m_vt,
  	and m_vn identifying the associated coordinate.  Basically, the data is stored
  	in a structure very similar to the OBJ file itself.
  	*/
  	vector<vertex_position> v_list;
  	vector<vertex_texture> vt_list;
  	vector<vertex_normal> vn_list;
  	vector<primitive> primitives;
  
  	vector<unsigned int> points;
  	vector<unsigned int> lines;
  	vector<unsigned int> faces;
  
  public:
  
  	OBJint objOpen(const char* filename);
  	OBJint objBegin(OBJint obj_mode);
  	OBJint objEnd();
  	OBJint objClose();
  	OBJint objNormal3f(float i, float j, float k);
  	OBJint objNormal2f(float i, float j);
  	OBJint objNormal1f(float i);
  	OBJint objTexCoord3f(float u, float v, float w);
  	OBJint objTexCoord2f(float u, float v);
  	OBJint objTexCoord1f(float u);
  	OBJint objVertex1f(float x);
  	OBJint objVertex2f(float x, float y);
  	OBJint objVertex3f(float x, float y, float z);
  	OBJint objVertex4f(float x, float y, float z, float w);
  	OBJint LoadFile(const char* filename);
  	OBJint SaveFile(const char* filename);
  
  	//direct insertion methods
  	void insertVertexPosition(float x, float y, float z, unsigned char mask = OBJ_V_X | OBJ_V_Y | OBJ_V_Z);
  	void insertLine(unsigned int num_points, unsigned int* pointlist, unsigned int* normallist, unsigned int* texturelist);
  
  	//get methods
  	unsigned int getNumVertices();
  	unsigned int getNumLines();
  	unsigned int getNumFaces();
  	unsigned int getNumPointLists();
  	unsigned int getNumTexCoords();
  	unsigned int getNumNormals();
  
  	//these functions return the coordinate index as well as the value
  	unsigned int getNumFaceVertices(unsigned int face);
  	unsigned int getFaceVertex(unsigned int face, unsigned int vertex);
  	unsigned int getFaceNormal(unsigned int face, unsigned int normal);
  	unsigned int getFaceTexCoord(unsigned int face, unsigned int texcoord);
  	unsigned int getNumLineVertices(unsigned int line);
  	unsigned int getLineVertex(unsigned int line, unsigned int vertex);
  	unsigned int getLineTexCoord(unsigned int line, unsigned int texcoord);
  	point3D<float> getVertex3d(unsigned int index);
  	point3D<float> getTexCoord3d(unsigned int index);
  	point3D<float> getNormal3d(unsigned int index);
  	vertex_position getVertex(unsigned int index);
  	vertex_texture getTexCoord(unsigned int index);
  	vertex_normal getNormal(unsigned int index);
  	AABB getBoundingBox(){return m_bounds;}
  	void Scale(float scale_x, float scale_y, float scale_z);
  	void Translate(float trans_x, float trans_y, float trans_z);
  
  	float GetDistance(float x, float y, float z);
  
  	//return data about primitives
  	unsigned int getPrimitiveType(unsigned int primitive);
  
  	//constructors
  	rtsOBJ();
  	void CopyOBJ(const rtsOBJ& obj);
  	//assignment
  	rtsOBJ& operator=(const rtsOBJ& obj)
  	{
  		CopyOBJ(obj);
  		return *this;
  	}
  	//copy
  	rtsOBJ(const rtsOBJ& obj)
  	{
  		CopyOBJ(obj);
  		//return *this;
  	}
  
  
  
  	//Iterator stuff
  	class iterator
  	{
  		friend class rtsOBJ;
  	private:
  		rtsOBJ* obj;
  		bool end_primitive;
  		bool end_object;
  		unsigned int primitive_index;
  	public:
  		unsigned int operator*();
  		void operator++();
  		bool operator==(rtsOBJ::iterator operand);
  		bool operator!=(rtsOBJ::iterator operand);
  		unsigned int size(){return obj->primitives[primitive_index].p.size();};
  		void print();
  	};
  
  	iterator begin();
  	iterator end();
  };
  
  //define error codes
  #define OBJ_OK				0x0100
  #define OBJ_ERROR			0x0101
  
  //define the different modes
  #define OBJ_NONE			0x0
  #define OBJ_POINTS			0x1
  #define OBJ_LINES			0x2
  #define OBJ_LINE_STRIP		0x3
  #define OBJ_LINE_LOOP		0x4
  #define OBJ_TRIANGLES		0x5
  #define OBJ_TRIANGLE_STRIP	0x6
  #define OBJ_TRIANGLE_FAN	0x7
  #define OBJ_QUADS			0x8
  #define OBJ_QUAD_STRIP		0x9
  #define OBJ_POLYGON			0x10
  
  
  
  
  
  
  //initialize the OBJ file
  OBJint objOpen(char* filename);
  //close the obj file
  OBJint objClose();
  
  //start rendering in a certain mode
  OBJint objBegin(OBJint mode);
  //stop the current rendering sequence
  OBJint objEnd(void);
  //render a vertex to the file
  OBJint objVertex1f(float x);
  OBJint objVertex2f(float x, float y);
  OBJint objVertex3f(float x, float y, float z);
  OBJint objVertex4f(float x, float y, float z, float w);
  //set a normal vector for a vertex
  OBJint objNormal3f(float i, float j, float k);
  OBJint objNormal2f(float i, float j);
  OBJint objNormal1f(float i);
  //set a texture coordinate for a vertex
  OBJint objTexCoord3f(float u, float v, float w);
  OBJint objTexCoord2f(float u, float v);
  OBJint objTexCoord1f(float u);
  
  //global variable for global functions
  extern rtsOBJ g_OBJ;
  
  /*BUG NOTES
  The standard function calls for inserting vertices don't work anymore.  I've fixed points
  but everything beyond that has to be updated.
  */
  
  #include "objJedi.h"
  #include "rtsVector3d.h"
  #include "rtsPoint3d.h"
  #include <string>
  //variable for use in global functions
  rtsOBJ g_OBJ;
  
  /********UTILITY METHODS*******************************/
  void rtsOBJ::Scale(float scale_x, float scale_y, float scale_z)
  {
  	vector<vertex_position>::iterator i;
  	for(i = v_list.begin(); i!= v_list.end(); i++)
  	{
  		(*i).x *= scale_x;
  		(*i).y *= scale_y;
  		(*i).z *= scale_z;
  	}
  }
  
  void rtsOBJ::Translate(float trans_x, float trans_y, float trans_z)
  {
  	vector<vertex_position>::iterator i;
  	for(i = v_list.begin(); i!= v_list.end(); i++)
  	{
  		(*i).x += trans_x;
  		(*i).y += trans_y;
  		(*i).z += trans_z;
  	}
  
  }
  
  float rtsOBJ::GetDistance(float x, float y, float z)
  {
  	//gets the distance between the specified point and the nearest surface of the OBJ
  	//currently only works for lines
  
  	//cout<<"Primitives: "<<primitives.size()<<endl;
  	unsigned int num_primitives = primitives.size();
  	point3D<float> p0, p1, p2;
  	float min_dist = 255;
  	float dist;
  	unsigned int p, l;
  	vector3D<float> v, w;
  	float c1, c2, b;
  	point3D<float> Pb;
  
  	//for each line
  	for(l=0; l<num_primitives; l++)
  	{
  		if(primitives[l].type & OBJ_LINES)
  		{
  			//for each point
  			for(p = 1; p<primitives[l].p.size(); p++)
  			{
  
  				vertex_position v1 = v_list[primitives[l].p[p-1].v];
  				vertex_position v2 = v_list[primitives[l].p[p].v];
  				p1.x = v1.x;
  				p1.y = v1.y;
  				p1.z = v1.z;
  				p2.x = v2.x;
  				p2.y = v2.y;
  				p2.z = v2.z;
  
  				p0.x = x;
  				p0.y = y;
  				p0.z = z;
  
  				v = p2 - p1;
  				w = p0 - p1;
  				if((c1 = w*v) <= 0)
  					dist = (p1 - p0).Length();
  				else if((c2 = v*v) <= c1)
  					dist = (p2 - p0).Length();
  				else
  				{
  					b = c1/c2;
  					Pb = p1 + b*v;
  					dist = (Pb - p0).Length();
  				}
  				if(dist < min_dist)
  					min_dist = dist;
  
  
  
  			}
  		}
  	}
  	//cout<<"---------------------------------------------"<<endl;
  
  	return min_dist;
  
  
  }
  
  /********CLASS METHOD DEFINITIONS**********************/
  //constructors
  
  //constructor
  rtsOBJ::rtsOBJ()
  {
  	g_CurrentMode = OBJ_NONE;
  	g_NumVertices = 0;
  	g_AttributeMask = 0x0;
  	g_AttributeResetMask = 0x0;
  	g_LatestVT = 0;
  	g_LatestVN = 0;
  
  	m_bounds.min.x = m_bounds.min.y = m_bounds.min.z = 99999;
  	m_bounds.max.x = m_bounds.max.y = m_bounds.max.z = -99999;
  
  	current_primitive_mask = 0x0;
  }
  
  void rtsOBJ::CopyOBJ(const rtsOBJ& obj)
  {
  	current_vt = obj.current_vt;
  	current_vn = obj.current_vn;
  	vt_changed = obj.vt_changed;				//true if a new vt or vn was inserted since the last vertex
  	vn_changed = obj.vn_changed;
  	current_primitive_mask = obj.current_primitive_mask;	//defines what coordinates are being used by the current primitive
  	//global variable storing the current render mode
  	g_CurrentMode = obj.g_CurrentMode;
  	//output file stream
  	//g_objFile = obj.g_objFile;
  	//obj file object
  	//objData g_OBJ;
  	//number of vertices since the last BEGIN
  	g_NumVertices = obj.g_NumVertices;
  	/*Attribute mask.  This indicates what attributes are stored for each vertex.
  	Only a single mask applies to each vertex between objBegin() and objEnd().  The
  	attribute mask is flipped the first time an attribute is set but it is fixed after
  	the first vertex is passed.*/
  	g_AttributeMask = obj.g_AttributeMask;
  	/*Attribute reset mask.  This indicates whether or not an attribute has been
  	reset since the last vertex was rendered.  This applies to OBJ_VT and OBJ_VN*/
  	g_AttributeResetMask = obj.g_AttributeResetMask;
  	//latest texture coordinate sent
  	g_LatestVT = obj.g_LatestVT;
  	//latest vertex normal sent
  	g_LatestVN = obj.g_LatestVN;
  	m_bounds = obj.m_bounds;
  
  
  	v_list = obj.v_list;
  	vt_list = obj.vt_list;
  	vn_list = obj.vn_list;
  	primitives = obj.primitives;
  
  	points = obj.points;
  	lines = obj.lines;
  	faces = obj.faces;
  }
  
  //opens an obj file for rendering
  OBJint rtsOBJ::objOpen(const char* filename)
  {
  	g_objFile.open(filename);
  	return OBJ_OK;
  }
  
  //close the obj file
  OBJint rtsOBJ::objClose()
  {
  	//TODO: write obj data
  	f_OutputVertices();
  	f_OutputTextureCoordinates();
  	f_OutputVertexNormals();
  	f_OutputPoints();
  	f_OutputLines();
  	f_OutputFaces();
  
  	//close the file
  	g_objFile.close();
  
  	//delete all of the data from the global object
  	f_ClearAll();
  	return OBJ_OK;
  }
  
  OBJint rtsOBJ::objBegin(OBJint mode)
  {
  	//make sure that we aren't currently rendering
  	if(g_CurrentMode != OBJ_NONE)
  		return OBJ_ERROR;
  	//make sure that the given mode is valid
  	if(mode < OBJ_POINTS || mode > OBJ_POLYGON)
  		return OBJ_ERROR;
  
  	//otherwise, go ahead and set the mode
  	g_CurrentMode = mode;
  	//set the number of vertices to zero
  	g_NumVertices = 0;
  
  	//reset the current state primitive state
  	current_primitive_mask = 0x0;
  
  	return OBJ_OK;
  }
  
  OBJint rtsOBJ::objEnd()
  {
  	OBJint error = OBJ_OK;
  	//check to make sure the number of rendered vertices is valid for the current mode
  	switch(g_CurrentMode)
  	{
  	case OBJ_NONE:
  		//can't quit if we haven't started
  		error = OBJ_ERROR;
  		break;
  	case OBJ_LINES:
  		//if less than two vertices or an odd number of vertices
  		if(g_NumVertices < 2 || g_NumVertices%2 != 0)
  		{
  			//if there wasn't a vertex at all
  			if(g_NumVertices == 0)
  				error = OBJ_ERROR;
  			//if there was at least one vertex
  			else
  			{
  				//pop the last line off the list
  				primitives.pop_back();
  				lines.pop_back();
  				error = OBJ_ERROR;
  			}
  		}
  		break;
  	case OBJ_LINE_STRIP:
  		//if less than two vertices
  		if(g_NumVertices < 2)
  		{
  			//if there wasn't a vertex at all
  			if(g_NumVertices == 0)
  				error = OBJ_ERROR;
  			//if there was at least one vertex
  			else
  			{
  				//pop the last line off the list
  				primitives.pop_back();
  				lines.pop_back();
  				error = OBJ_ERROR;
  			}
  		}
  		break;
  	case OBJ_LINE_LOOP:
  		//if less than three vertices
  		if(g_NumVertices < 3)
  		{
  			//pop the last line off the list
  			primitives.pop_back();
  			lines.pop_back();
  			error = OBJ_ERROR;
  		}
  		//connect the first and last points
  		else
  		{
  			error = f_TerminateLineLoop();
  		}
  		break;
  	case OBJ_TRIANGLES:
  		//if less than three vertices or not a power of three
  		if(g_NumVertices < 3 || g_NumVertices%3 !=0)
  		{
  			primitives.pop_back();
  			faces.pop_back();
  			error = OBJ_ERROR;
  		}
  		break;
  	case OBJ_TRIANGLE_STRIP:
  		//if less than three vertices
  		if(g_NumVertices < 3)
  		{
  			primitives.pop_back();
  			faces.pop_back();
  			error = OBJ_ERROR;
  		}
  		break;
  	case OBJ_TRIANGLE_FAN:
  		//if less than three vertices
  		if(g_NumVertices < 3)
  		{
  			primitives.pop_back();
  			faces.pop_back();
  			error = OBJ_ERROR;
  		}
  		break;
  	case OBJ_QUADS:
  		if(g_NumVertices < 4 || g_NumVertices%4 != 0)
  		{
  			primitives.pop_back();
  			faces.pop_back();
  			error = OBJ_ERROR;
  		}
  		break;
  	case OBJ_QUAD_STRIP:
  		//has to be at least 4 vertices and an even number
  		if(g_NumVertices < 4 || g_NumVertices%2 != 0)
  		{
  			primitives.pop_back();
  			faces.pop_back();
  			error = OBJ_ERROR;
  		}
  		break;
  	case OBJ_POLYGON:
  		//has to be at least three vertices
  		if(g_NumVertices < 3)
  		{
  			primitives.pop_back();
  			faces.pop_back();
  			error = OBJ_ERROR;
  		}
  		break;
  	}
  
  	//reset the attribute mask
  	g_AttributeMask = 0x0;
  	//just for closure, reset the attribute reset mask
  	g_AttributeResetMask = 0x0;
  	//stop rendering
  	g_CurrentMode = OBJ_NONE;
  	return error;
  }
  
  OBJint rtsOBJ::f_InsertVertexf(float x, float y, float z, float w, unsigned char mask)
  {
  	//make sure we're rendering
  	if(g_CurrentMode == OBJ_NONE)
  		return OBJ_ERROR;
  
  	//insert the vertex into the vertex vector
  	vertex_position v;
  	v.x = x; v.y = y; v.z=z; v.w=w; v.mask = mask;
  	v_list.push_back(v);
  	f_AdjustExtents(v);			//set the bounding box
  	//insert texture coordinate and normal if specified for this primitive
  	if((current_primitive_mask & OBJ_VT)  && (vt_changed))
  		vt_list.push_back(current_vt);
  	if((current_primitive_mask & OBJ_VN) && (vn_changed))
  		vn_list.push_back(current_vn);
  
  
  	//increment the number of vertices inserted
  	g_NumVertices++;
  
  	//handle each case of the vertex creation individually
  	OBJint error = OBJ_OK;
  	switch(g_CurrentMode)
  	{
  	case OBJ_POINTS:
  		error = f_InsertPointVertex();
  		break;
  	case OBJ_LINES:
  		error = f_InsertLineVertex();
  		break;
  	case OBJ_LINE_LOOP:
  		error = f_InsertLineLoopVertex();
  		break;
  	case OBJ_LINE_STRIP:
  		error = f_InsertLineStripVertex();
  		break;
  	case OBJ_TRIANGLES:
  		error = f_InsertTriangleVertex();
  		break;
  	case OBJ_TRIANGLE_STRIP:
  		error = f_InsertTriangleStripVertex();
  		break;
  	case OBJ_TRIANGLE_FAN:
  		error = f_InsertTriangleFanVertex();
  		break;
  	case OBJ_QUADS:
  		error = f_InsertQuadVertex();
  		break;
  	case OBJ_QUAD_STRIP:
  		error = f_InsertQuadStripVertex();
  		break;
  	case OBJ_POLYGON:
  		error = f_InsertPolygonVertex();
  		break;
  	}
  	//set the reset mask to zero
  	g_AttributeResetMask = 0x0;
  
  	//set the attribute mask to include vertex position
  	g_AttributeMask = g_AttributeMask | OBJ_V;
  
  	//return the result of the insertion
  	return error;
  }
  
  OBJint rtsOBJ::objVertex1f(float x)
  {
  	return f_InsertVertexf(x, 0.0, 0.0, 0.0, OBJ_V_X);
  }
  
  OBJint rtsOBJ::objVertex2f(float x, float y)
  {
  	return f_InsertVertexf(x, y, 0.0, 0.0, OBJ_V_X | OBJ_V_Y);
  }
  
  OBJint rtsOBJ::objVertex3f(float x, float y, float z)
  {
  	return f_InsertVertexf(x, y, z, 0.0, OBJ_V_X | OBJ_V_Y | OBJ_V_Z);
  
  }
  
  OBJint rtsOBJ::objVertex4f(float x, float y, float z, float w)
  {
  	return f_InsertVertexf(x, y, z, w, OBJ_V_X | OBJ_V_Y | OBJ_V_Z | OBJ_V_W);
  }
  
  OBJint rtsOBJ::objNormal3f(float i, float j, float k)
  {
  	return f_InsertNormalf(i, j, k, OBJ_VN_I | OBJ_VN_J | OBJ_VN_K);
  }
  OBJint rtsOBJ::objNormal2f(float i, float j)
  {
  	return f_InsertNormalf(i, j, 0.0, OBJ_VN_I | OBJ_VN_J);
  }
  
  OBJint rtsOBJ::objNormal1f(float i)
  {
  	return f_InsertNormalf(i, 0.0, 0.0, OBJ_VN_I);
  }
  
  OBJint rtsOBJ::f_InsertNormalf(float i, float j, float k, unsigned char mask)
  {
  	/*DEPRECATED
  	//if the mode is not rendering faces, there is an error
  	if(g_CurrentMode < OBJ_TRIANGLES)
  		return OBJ_ERROR;
  	//if the normal attribute flag is not set, set it (as long as a vertex hasn't been written)
  	if(!(g_AttributeMask & OBJ_VN))
  	{
  		//if a vertex has been rendered, then we can't change the attribute, so exit
  		if(g_NumVertices > 0)
  			return OBJ_ERROR;
  		else
  			//otherwise, just set the attribute flag
  			g_AttributeMask = g_AttributeMask | OBJ_VN;
  	}
  
  
  	//insert the new normal into the normal list for the file
  	vertex_normal new_vn;
  	new_vn.i = i;  new_vn.j = j;  new_vn.k = k;
  	new_vn.mask = mask;
  	vn_list.push_back(new_vn);
  	*/
  	current_vn.i = i;											//set the current texture state to the given coordinates
  	current_vn.j = j;
  	current_vn.k = k;
  	current_vn.mask = mask;										//set the mask as appropriate
  	vn_changed = true;											//the texture coordinate state has changed
  	current_primitive_mask = current_primitive_mask | OBJ_VN;	//the current primitive now uses texture coordinates (if it didn't previously)
  
  	return OBJ_OK;
  }
  
  OBJint rtsOBJ::objTexCoord3f(float u, float v, float w)
  {
  	return f_InsertTexCoordf(u, v, w, OBJ_VT_U | OBJ_VT_V | OBJ_VT_W);
  }
  
  OBJint rtsOBJ::objTexCoord2f(float u, float v)
  {
  	return f_InsertTexCoordf(u, v, 0.0, OBJ_VT_U | OBJ_VT_V);
  }
  
  OBJint rtsOBJ::objTexCoord1f(float u)
  {
  	return f_InsertTexCoordf(u, 0.0, 0.0, OBJ_VT_U);
  }
  
  OBJint rtsOBJ::f_InsertTexCoordf(float u, float v, float w, unsigned char mask)
  {
  	/*
  	DEPRECATED
  	//if the normal attribute flag is not set, set it (as long as a vertex hasn't been written)
  	if(!(g_AttributeMask & OBJ_VT))
  	{
  		//if a vertex has been rendered, then we can't change the attribute, so exit
  		if(g_NumVertices > 0)
  			return OBJ_ERROR;
  		else
  			//otherwise, just set the attribute flag
  			g_AttributeMask = g_AttributeMask | OBJ_VT;
  	}
  
  	//insert the new texture coordinate into the list for the file
  	vertex_texture new_vt;
  	new_vt.u = u;  new_vt.v = v;  new_vt.w = w;
  	new_vt.mask = mask;
  	vt_list.push_back(new_vt);
  	*/
  	current_vt.u = u;											//set the current texture state to the given coordinates
  	current_vt.v = v;
  	current_vt.w = w;
  	current_vt.mask = mask;										//set the mask as appropriate
  	vt_changed = true;											//the texture coordinate state has changed
  	current_primitive_mask = current_primitive_mask | OBJ_VT;	//the current primitive now uses texture coordinates (if it didn't previously)
  
  	return OBJ_OK;
  }
  
  
  void rtsOBJ::insertVertexPosition(float x, float y, float z, unsigned char mask)
  {
  	vertex_position v;
  	v.x = x;
  	v.y = y;
  	v.z = z;
  	v.mask = mask;
  
  	v_list.push_back(v);
  }
  
  void rtsOBJ::insertLine(unsigned int num_points, unsigned int* pointlist, unsigned int* normallist, unsigned int* texturelist)
  {
  	//create the new primitive
  	primitive line;
  	line.type = OBJ_LINES;
  	line.mask = 0;
  
  	//set the mask based on the passed data
  	if(pointlist != NULL)
  		line.mask = line.mask | OBJ_V;
  	if(normallist != NULL)
  		line.mask = line.mask | OBJ_VN;
  	if(texturelist != NULL)
  		line.mask = line.mask | OBJ_VT;
  
  	//insert the line
  	unsigned int v;
  	vertex new_vert;
  	for(v=0; v<num_points; v++)
  	{
  		if(pointlist)
  			new_vert.v = pointlist[v];
  		if(normallist)
  			new_vert.vn = normallist[v];
  		if(texturelist)
  			new_vert.vt = texturelist[v];
  		line.p.push_back(new_vert);
  	}
  	//insert the new primitive into the list
  	primitives.push_back(line);
  }
  OBJint rtsOBJ::f_InsertPointVertex()
  {
  	//insert the most recent point into the most recent point list
  	//if this is the first vertex, create the point list
  	if(g_NumVertices == 1)
  	{
  		primitive new_p;						//create the new point
  		new_p.type = OBJ_POINTS;
  		new_p.mask = current_primitive_mask;
  		points.push_back(primitives.size());	//store the primitive id in the points list
  		primitives.push_back(new_p);
  	}
  
  	//find the id of the most recent primitive
  	unsigned int p_index = primitives.size() - 1;
  	//find the index of the recent point
  	vertex p;
  	p.v = v_list.size() - 1;
  	//insert the indices for texture coordinates and normal if necessary
  	if(primitives[p_index].mask & OBJ_VT)
  		p.vt = vt_list.size() - 1;
  	if(primitives[p_index].mask & OBJ_VN)
  		p.vn = vn_list.size() - 1;
  
  	//insert the vertex index into the primitive's point list
  	primitives[p_index].p.push_back(p);
  
  	//push the point into the points list if it is not the only point in the primitive
  	if(g_NumVertices > 1)
  		points.push_back(p_index);
  
  	return OBJ_OK;
  }
  
  OBJint rtsOBJ::f_InsertLineVertex()
  {
  	//if this is an odd vertex, create a new line
  	if(g_NumVertices%2 == 1)
  	{
  		f_CreateNewLine();
  	}
  
  	f_InsertNewLineVertex();
  
  	return OBJ_OK;
  }
  OBJint rtsOBJ::f_InsertLineLoopVertex()
  {
  	//technically, this is the same as inserting a line strip vertex
  	f_InsertLineStripVertex();
  	return OBJ_OK;
  }
  
  OBJint rtsOBJ::f_InsertLineStripVertex()
  {
  	if(g_NumVertices == 1)
  	{
  		f_CreateNewLine();
  	}
  
  	f_InsertNewLineVertex();
  
  	return OBJ_OK;
  }
  
  OBJint rtsOBJ::f_InsertTriangleVertex()
  {
  	//if this is the first vertex in a triangle, create a new triangle
  	if(g_NumVertices%3 == 1)
  	{
  		f_CreateNewFace();
  	}
  
  
  	f_InsertNewFaceVertex();
  
  	return OBJ_OK;
  }
  OBJint rtsOBJ::f_InsertTriangleStripVertex()
  {
  	//in the special case of the first three vertices, just create a triangle
  	if(g_NumVertices < 4)
  		f_InsertTriangleVertex();
  	else
  	{
  
  		//create a new face for the new triangle
  		f_CreateNewFace();
  
  		//make sure to get the ordering right:
  		//		Even vertices provide the previous two vertices "in order": (v2, v3, v4)
  		//		Odd vertices provide the previous two vertices in reverse order: (v1, v3, v2)
  		if(g_NumVertices % 2 == 1)
  		{
  			f_InsertPreviousFaceVertex(2);
  			f_InsertPreviousFaceVertex(1);
  			f_InsertNewFaceVertex();
  		}
  		else
  		{
  			f_InsertPreviousFaceVertex(1);
  			f_InsertNewFaceVertex();
  			f_InsertPreviousFaceVertex(2);
  		}
  	}
  
  	return OBJ_OK;
  }
  OBJint rtsOBJ::f_InsertTriangleFanVertex()
  {
  	//in the special case of the first three vertices, just create a triangle
  	if(g_NumVertices <4)
  		f_InsertTriangleVertex();
  	else
  	{
  		//create a new face for the new triangle
  		f_CreateNewFace();
  		//add the previous vertices to the face
  		f_InsertFirstFaceVertex(0);
  		f_InsertPreviousFaceVertex(2);
  		//insert the current vertex
  		f_InsertNewFaceVertex();
  	}
  
  	return OBJ_OK;
  }
  OBJint rtsOBJ::f_InsertQuadVertex()
  {
  	//if this is the first vertex in a quad, create a new quad
  	if(g_NumVertices%4 == 1)
  	{
  		f_CreateNewFace();
  	}
  
  	f_InsertNewFaceVertex();
  
  	return OBJ_OK;
  }
  OBJint rtsOBJ::f_InsertQuadStripVertex()
  {
  	//in the case of one of the first four vertices, just create a quad
  	if(g_NumVertices < 5)
  		f_InsertQuadVertex();
  	//if the vertex is odd (it will be the third vertex of a quad)
  	else if(g_NumVertices%2 == 1)
  	{
  		//create a new face for the new quad
  		f_CreateNewFace();
  		//add the previous two vertices
  		f_InsertPreviousFaceVertex(2);
  		f_InsertPreviousFaceVertex(3);
  		//add the current vertex
  		f_InsertNewFaceVertex();
  	}
  	else
  	{
  		//if this is the last vertex of the quad, just add it
  		f_InsertNewFaceVertex();
  
  	}
  	return OBJ_OK;
  }
  OBJint rtsOBJ::f_InsertPolygonVertex()
  {
  	//if this is the first vertex, create the quad
  	if(g_NumVertices == 1)
  	{
  		f_CreateNewFace();
  	}
  	f_InsertNewFaceVertex();
  
  	return OBJ_OK;
  }
  
  OBJint rtsOBJ::f_InsertPreviousFaceVertex(unsigned int v_index)
  {
  	/*Finds the vertex used in the previous face with the given index and
  	inserts it into the current face.  This limits the redundancy in the file
  	for re-used vertices (in strips and fans).  This also transfers texture
  	and normal information.*/
  
  	//find the index of the previous face
  	unsigned int prev_f_index = primitives.size() - 2;
  	//find the index of the current face
  	unsigned int f_index = prev_f_index +1;
  	//add the vertex information from the previous face to this face
  	primitives[f_index].p.push_back(primitives[prev_f_index].p[v_index]);
  
  	return OBJ_OK;
  }
  
  OBJint rtsOBJ::f_InsertFirstFaceVertex(unsigned int v_index)
  {
  	/*Finds the vertex used in the first face (since the last objBegin())
  	with the given index and inserts it at the end of the current face.
  	This includes texture and normal information.*/
  
  	//The result depends on the type of face being rendered
  	//So far, this function only applies to triangle fans
  	if(g_CurrentMode != OBJ_TRIANGLE_FAN)
  		return OBJ_ERROR;
  
  	//calculate the number of faces that have been rendered
  	unsigned int num_faces = g_NumVertices - 2;
  	//find the index of the first face
  	unsigned int first_f_index = primitives.size() - num_faces;
  	//find the index of the current face
  	unsigned int f_index = primitives.size() - 1;
  	//transfer the vertex information from the first face to this one
  	primitives[f_index].p.push_back(primitives[first_f_index].p[v_index]);
  
  
  	return OBJ_OK;
  }
  
  OBJint rtsOBJ::f_InsertNewFaceVertex()
  {
  	/*This inserts information about the current vertex into the current face*/
  	//find the new vertex index
  	vertex p;
  	p.v = v_list.size() -1;
  	p.vt = vt_list.size() - 1;
  	p.vn = vn_list.size() -1;
  	//find the face index
  	unsigned int f_index = primitives.size() -1;
  	//INSERT VERTEX AND ATTRIBUTE DATA
  	//just add the vertex to the face
  	primitives[f_index].p.push_back(p);
  
  	return OBJ_OK;
  }
  
  OBJint rtsOBJ::f_InsertNewLineVertex()
  {
  	/*This inserts information about the current vertex into the current line*/
  	//find the new vertex index
  	vertex p;
  	p.v = v_list.size() -1;
  	p.vt = vt_list.size() - 1;
  	//find the line index
  	unsigned int l_index = primitives.size() -1;
  
  	//ADD VERTEX AND ATTRIBUTE INFORMATION
  	//add the vertex to the line
  	primitives[l_index].p.push_back(p);
  
  	return OBJ_OK;
  }
  
  OBJint rtsOBJ::f_CreateNewFace()
  {
  	primitive new_f;
  	new_f.type = OBJ_FACE;
  	new_f.mask = g_AttributeMask;
  	faces.push_back(primitives.size());
  	primitives.push_back(new_f);
  
  
  	return OBJ_OK;
  }
  
  OBJint rtsOBJ::f_CreateNewLine()
  {
  	primitive new_l;
  	new_l.type = OBJ_LINES;
  	new_l.mask = g_AttributeMask;
  	lines.push_back(primitives.size());
  	primitives.push_back(new_l);
  
  	return OBJ_OK;
  }
  
  
  OBJint rtsOBJ::f_TerminateLineLoop()
  {
  	/*This function just terminates the line loop by setting the last vertex
  	to the first vertex.*/
  	if(g_CurrentMode != OBJ_LINE_LOOP)
  		return OBJ_ERROR;
  	//find the index for the current line
  	unsigned int l_index = lines.size() -1;
  	//insert the first vertex as the last vertex
  	primitives[l_index].p.push_back(primitives[l_index].p[0]);
  
  	return OBJ_OK;
  }
  
  void rtsOBJ::f_OutputVertices()
  {
  	//get the number of vertices in the object
  	unsigned int v_num = v_list.size();
  	for(unsigned int i=0; i<v_num; i++)
  	{
  		g_objFile<<"v";
  		if(v_list[i].mask & OBJ_V_X)
  			g_objFile<<" "<<v_list[i].x;
  		if(v_list[i].mask & OBJ_V_Y)
  			g_objFile<<" "<<v_list[i].y;
  		if(v_list[i].mask & OBJ_V_Z)
  			g_objFile<<" "<<v_list[i].z;
  		if(v_list[i].mask & OBJ_V_W)
  			g_objFile<<" "<<v_list[i].w;
  		g_objFile<<endl;
  	}
  
  }
  
  void rtsOBJ::f_OutputVertexNormals()
  {
  	//get the number of normals in the object
  	unsigned int vn_num = vn_list.size();
  	for(unsigned int i=0; i<vn_num; i++)
  	{
  		g_objFile<<"vn ";
  		if(vn_list[i].mask & OBJ_VN_I)
  		{
  			g_objFile<<vn_list[i].i;
  			if(vn_list[i].mask & OBJ_VN_J)
  			{
  				g_objFile<<" "<<vn_list[i].j;
  				if(vn_list[i].mask & OBJ_VN_K)
  					g_objFile<<" "<<vn_list[i].k;
  			}
  		}
  		g_objFile<<endl;
  	}
  }
  
  void rtsOBJ::f_OutputTextureCoordinates()
  {
  	//get the number of vertices in the object
  	unsigned int vt_num = vt_list.size();
  	for(unsigned int i=0; i<vt_num; i++)
  	{
  		g_objFile<<"vt ";
  		if(vt_list[i].mask & OBJ_VT_U)
  		{
  			g_objFile<<vt_list[i].u;
  			if(vt_list[i].mask & OBJ_VT_V)
  			{
  				g_objFile<<" "<<vt_list[i].v;
  				if(vt_list[i].mask & OBJ_VT_W)
  					g_objFile<<" "<<vt_list[i].w;
  			}
  		}
  		g_objFile<<endl;
  	}
  }
  
  void rtsOBJ::f_OutputPoints()
  {
  	/*
  	//get the number of point vectors
  	unsigned int p_num = points.size();
  
  	//for each point vector, output the points
  	for(unsigned int i=0; i<p_num; i++)
  	{
  		g_objFile<<"p";
  		unsigned int v_num = points[i].p.size();
  		for(unsigned int j=0; j<v_num; j++)
  		{
  			g_objFile<<" "<<points[i].p[j].v+1;
  		}
  		g_objFile<<endl;
  	}
  	*/
  }
  
  void rtsOBJ::f_OutputLines()
  {
  	/*
  	//get the number of line vectors
  	unsigned int l_num = lines.size();
  
  	//for each line vector, output the associated points
  	for(unsigned int i=0; i<l_num; i++)
  	{
  		g_objFile<<"l";
  		unsigned int v_num = lines[i].p.size();
  		for(unsigned int j=0; j<v_num; j++)
  		{
  			g_objFile<<" "<<lines[i].p[j].v+1;
  			//output texture coordinate if there are any
  			if(lines[i].mask & OBJ_VT)
  				g_objFile<<"/"<<lines[i].p[j].vt+1;
  		}
  		g_objFile<<endl;
  	}
  	*/
  }
  
  void rtsOBJ::f_OutputFaces()
  {
  	/*
  	//get the number of faces
  	unsigned int f_num = faces.size();
  
  	//for each face, output the associated points
  	for(unsigned int i=0; i<f_num; i++)
  	{
  		g_objFile<<"f";
  		//get the number of face vertices
  		unsigned int v_num = faces[i].p.size();
  		for(unsigned int j=0; j<v_num; j++)
  		{
  			g_objFile<<" "<<faces[i].p[j].v+1;
  			//if there are texture coordinates
  			if(faces[i].mask & OBJ_VT)
  				g_objFile<<"/"<<faces[i].p[j].vt+1;
  			//if there is a normal
  			if(faces[i].mask & OBJ_VN)
  			{
  				//but no texture coordinates, put an extra slash
  				if(!(faces[i].mask & OBJ_VT))
  					g_objFile<<"/";
  				g_objFile<<"/"<<faces[i].p[j].vn+1;
  			}
  
  		}
  		g_objFile<<endl;
  	}
  	*/
  }
  
  void rtsOBJ::f_ClearAll()
  {
  	rtsOBJ();
  	//clear all data from the global obj function
  	faces.clear();
  	lines.clear();
  	points.clear();
  	v_list.clear();
  	vn_list.clear();
  	vt_list.clear();
  	primitives.clear();
  }
  
  /*GLOBAL FUNCTION DEFINITIONS*/
  //initialize the OBJ file
  OBJint objOpen(char* filename)
  {
  	return g_OBJ.objOpen(filename);
  }
  //close the obj file
  OBJint objClose()
  {
  	return g_OBJ.objClose();
  }
  
  //start rendering in a certain mode
  OBJint objBegin(OBJint mode)
  {
  	return g_OBJ.objBegin(mode);
  }
  //stop the current rendering sequence
  OBJint objEnd(void)
  {
  	return g_OBJ.objEnd();
  }
  //render a vertex to the file
  OBJint objVertex1f(float x)
  {
  	return g_OBJ.objVertex1f(x);
  }
  
  OBJint objVertex2f(float x, float y)
  {
  	return g_OBJ.objVertex2f(x, y);
  }
  
  OBJint objVertex3f(float x, float y, float z)
  {
  	return g_OBJ.objVertex3f(x, y, z);
  }
  
  OBJint objVertex4f(float x, float y, float z, float w)
  {
  	return g_OBJ.objVertex4f(x, y, z, w);
  }
  //set a normal vector for a vertex
  OBJint objNormal3f(float i, float j, float k)
  {
  	return g_OBJ.objNormal3f(i, j, k);
  }
  OBJint objNormal2f(float i, float j)
  {
  	return g_OBJ.objNormal2f(i, j);
  }
  OBJint objNormal1f(float i)
  {
  	return g_OBJ.objNormal1f(i);
  }
  //set a texture coordinate for a vertex
  OBJint objTexCoord3f(float u, float v, float w)
  {
  	return g_OBJ.objTexCoord3f(u, v, w);
  }
  
  OBJint objTexCoord2f(float u, float v)
  {
  	return g_OBJ.objTexCoord2f(u,v);
  }
  
  OBJint objTexCoord1f(float u)
  {
  	return g_OBJ.objTexCoord1f(u);
  }
  
  OBJint rtsOBJ::f_ReadPosition(ifstream &infile)
  {
  	vertex_position new_vertex;
  	//get each coordinate
  	infile>>new_vertex.x;
  	new_vertex.mask = OBJ_V_X;
  
  	if(infile.peek() == ' ')
  	{
  		infile>>new_vertex.y;
  		new_vertex.mask = new_vertex.mask | OBJ_V_Y;
  	}
  	if(infile.peek() == ' ')
  	{
  		infile>>new_vertex.z;
  		new_vertex.mask = new_vertex.mask | OBJ_V_Z;
  	}
  	if(infile.peek() == ' ')
  	{
  		infile>>new_vertex.w;
  		new_vertex.mask = new_vertex.mask | OBJ_V_W;
  	}
  	int c = infile.peek();
  	//ignore the rest of the line
  	infile.ignore(1000, '\n');
  	c = infile.peek();
  
  	//cout<<"vertex read: "<<new_vertex.x<<","<<new_vertex.y<<","<<new_vertex.z<<","<<new_vertex.w<<endl;
  	//insert the vertex into the list
  	v_list.push_back(new_vertex);
  
  	//adjust the extents of the model
  	f_AdjustExtents(new_vertex);
  
  	return OBJ_OK;
  }
  
  OBJint rtsOBJ::f_ReadNormal(ifstream &infile)
  {
  	vertex_normal new_normal;
  	infile>>new_normal.i;
  	new_normal.mask = OBJ_VN_I;
  	//get every other component
  	if(infile.peek() == ' ')
  	{
  		infile>>new_normal.j;
  		new_normal.mask = new_normal.mask | OBJ_VN_J;
  	}
  	if(infile.peek() == ' ')
  	{
  		infile>>new_normal.k;
  		new_normal.mask = new_normal.mask | OBJ_VN_K;
  	}
  	//ignore the rest of the line
  	infile.ignore(1000, '\n');
  	//insert the normal
  	vn_list.push_back(new_normal);
  
  	return OBJ_OK;
  }
  
  OBJint rtsOBJ::f_ReadTexCoord(ifstream &infile)
  {
  	vertex_texture new_texcoord;
  	infile>>new_texcoord.u;
  	new_texcoord.mask = OBJ_VT_U;
  	//get every other component
  	if(infile.peek() == ' ')
  	{
  		infile>>new_texcoord.v;
  		new_texcoord.mask = new_texcoord.mask | OBJ_VT_V;
  	}
  	if(infile.peek() == ' ')
  	{
  		infile>>new_texcoord.w;
  		new_texcoord.mask = new_texcoord.mask | OBJ_VT_W;
  	}
  
  	//ignore the rest of the line
  	infile.ignore(1000, '\n');
  	//insert the texture coordinate
  	vt_list.push_back(new_texcoord);
  
  	return OBJ_OK;
  
  }
  
  OBJint rtsOBJ::f_ReadVertex(ifstream &infile, vertex &new_point, unsigned char &mask)
  {
  	//store the line vertex
  	infile>>new_point.v;
  	new_point.v--;
  	mask = OBJ_V;
  	//new_face.v.push_back(new_v - 1);
  	if(infile.peek() == '/')
  	{
  		infile.get();
  		//if there actually is a texcoord
  		if(infile.peek() != '/')
  		{
  			infile>>new_point.vt;						//get the index
  			new_point.vt--;
  			mask = mask | OBJ_VT;				//update the mask
  			//new_face.vt.push_back(new_vt - 1);
  		}
  	}
  	//check for a normal
  	if(infile.peek() == '/')
  	{
  		infile.get();
  		infile>>new_point.vn;							//get the index
  		new_point.vn--;
  		mask = mask | OBJ_VN;	//update the mask
  	}
  
  	return OBJ_OK;
  }
  
  OBJint rtsOBJ::f_ReadPrimitive(ifstream &infile, primitive_type type)
  {
  	//create a new point list
  	primitive new_primitive;
  	new_primitive.type = type;
  	//until the end of the line
  	while(infile.peek() != '\n')
  	{
  		//read each point
  		if(infile.peek() == ' ')
  			infile.get();
  		else
  		{
  			vertex new_point;
  			f_ReadVertex(infile, new_point, new_primitive.mask);
  			new_primitive.p.push_back(new_point);
  		}
  	}
  	//ignore the rest of the line
  	infile.ignore(1000, '\n');
  
  	//push the id of the primitive into the new list
  	//:DEBUG:
  	if(type == OBJ_POINTS)
  		points.push_back(primitives.size());
  	else if(type == OBJ_LINES)
  		lines.push_back(primitives.size());
  	else if(type == OBJ_FACE)
  		faces.push_back(primitives.size());
  
  	primitives.push_back(new_primitive);	//push the new primitive
  
  	return OBJ_OK;
  }
  
  
  OBJint rtsOBJ::f_AdjustExtents(vertex_position v)
  {
  	if(v.x < m_bounds.min.x)
  		m_bounds.min.x = v.x;
  	if(v.y < m_bounds.min.y)
  		m_bounds.min.y = v.y;
  	if(v.z < m_bounds.min.z)
  		m_bounds.min.z = v.z;
  
  	if(v.x > m_bounds.max.x) m_bounds.max.x = v.x;
  	if(v.y > m_bounds.max.y) m_bounds.max.y = v.y;
  	if(v.z > m_bounds.max.z) m_bounds.max.z = v.z;
  
  	return OBJ_OK;
  }
  
  OBJint rtsOBJ::f_LoadOBJ(const char* filename)
  {
  	f_ClearAll();
  	//open the file as a stream
  	ifstream infile;
  	infile.open(filename);
  	if(!infile)
  		exit(1);
  
  	unsigned int vertices = 0;
  
  	string token;
  	infile>>token;
  	while(!infile.eof())
  	{
  		//if the token is some vertex property
  		if(token == "v")
  			f_ReadPosition(infile);
  		else if(token == "vn")
  			f_ReadNormal(infile);
  		else if(token == "vt")
  			f_ReadTexCoord(infile);
  		else if(token == "p")
  			f_ReadPrimitive(infile, OBJ_POINTS);
  		else if(token == "l")
  			f_ReadPrimitive(infile, OBJ_LINES);
  		else if(token == "f")
  			f_ReadPrimitive(infile, OBJ_FACE);
  		else
  			infile.ignore(9999, '\n');
  		//vertices++;
  
  		infile>>token;
  	}
  
  }
  
  OBJint rtsOBJ::f_LoadSWC(const char* filename)
  {
  	f_ClearAll();
  	//open the file as a stream
  	ifstream infile;
  	infile.open(filename);
  	if(!infile.is_open())
  		return OBJ_ERROR;
  
  	vector<vertex_position> swcVertices;
  	float token;
  	objBegin(OBJ_LINES);
  	while(!infile.eof())
  	{
  		vertex_position v;
  		infile>>token;			//get the id
  		infile>>token;			//get the fiber type
  		infile>>v.x;			//get the node position
  		infile>>v.y;
  		infile>>v.z;
  		infile>>token;			//get the radius
  		infile>>token;			//get the parent
  
  		//insert the node into the swc vector
  		swcVertices.push_back(v);
  		//now draw the line from the parent to the current node
  		if(token != -1)
  		{
  			unsigned int i = (unsigned int)token - 1;
  			objVertex3f(swcVertices[i].x, swcVertices[i].y, swcVertices[i].z);
  			objVertex3f(v.x, v.y, v.z);
  		}
  	}
  	objEnd();
  
  
  	return OBJ_OK;
  
  }
  OBJint rtsOBJ::LoadFile(const char* filename)
  {
  	string strFilename = filename;
  	int length = strFilename.length();
  	string extension = strFilename.substr(strFilename.length() - 3, 3);
  	if(!extension.compare(string("obj")))
  		return f_LoadOBJ(filename);
  	else if(!extension.compare(string("swc")))
  		return f_LoadSWC(filename);
  	else return f_LoadOBJ(filename);
  
  }
  
  OBJint rtsOBJ::SaveFile(const char* filename)
  {
  	//open the file as a stream
  	ofstream outfile;
  	outfile.open(filename);
  	if(!outfile.is_open())
  		return OBJ_ERROR;
  
  	//output vertex positions
  	vector<vertex_position>::iterator v;
  	for(v=v_list.begin(); v!= v_list.end(); v++)
  	{
  		outfile<<"v";
  		if((*v).mask & OBJ_V_X)
  		{
  			outfile<<' '<<(*v).x;
  			if((*v).mask & OBJ_V_Y)
  			{
  				outfile<<' '<<(*v).y;
  				if((*v).mask & OBJ_V_Z)
  				{
  					outfile<<' '<<(*v).z;
  					if((*v).mask & OBJ_V_W)
  						outfile<<' '<<(*v).w;
  				}
  			}
  		}
  		outfile<<'\n';
  	}
  
  	//output vertex texture coordinates
  	vector<vertex_texture>::iterator vt;
  	for(vt=vt_list.begin(); vt!= vt_list.end(); vt++)
  	{
  		outfile<<"vt";
  		if((*vt).mask & OBJ_VT_U)
  		{
  			outfile<<' '<<(*vt).u;
  			if((*vt).mask & OBJ_VT_V)
  			{
  				outfile<<' '<<(*vt).v;
  				if((*vt).mask & OBJ_VT_W)
  					outfile<<' '<<(*vt).w;
  			}
  		}
  		outfile<<'\n';
  	}
  
  	//output vertex normal coordinates
  	vector<vertex_normal>::iterator vn;
  	for(vn=vn_list.begin(); vn!= vn_list.end(); vn++)
  	{
  		outfile<<"vn";
  		if((*vn).mask & OBJ_VN_I)
  		{
  			outfile<<' '<<(*vn).i;
  			if((*vn).mask & OBJ_VN_J)
  			{
  				outfile<<' '<<(*vn).j;
  				if((*vn).mask & OBJ_VN_K)
  					outfile<<' '<<(*vn).k;
  			}
  		}
  		outfile<<'\n';
  	}
  
  	//output each primitive
  	vector<primitive>::iterator p;
  	vector<vertex>::iterator vert;
  	for(p=primitives.begin(); p!= primitives.end(); p++)
  	{
  		switch((*p).type)
  		{
  		case OBJ_POINTS:
  			outfile<<"p";			//output the points token
  			break;
  		case OBJ_LINES:
  			outfile<<"l";			//output the lines token
  			break;
  		case OBJ_FACE:
  			outfile<<"f";			//output the face token
  			break;
  		}
  
  		//for each vertex in the list for the primitive
  		for(vert = (*p).p.begin(); vert != (*p).p.end(); vert++)
  		{
  			outfile<<' '<<(*vert).v + 1;
  			if((*p).mask & OBJ_VT)
  				outfile<<'/'<<(*vert).vt + 1;
  			if((*p).mask & OBJ_VN)
  			{
  				if(!((*p).mask & OBJ_VT))
  					outfile<<'/';
  				outfile<<'/'<<(*vert).vn + 1;
  			}
  		}
  		outfile<<'\n';
  
  	}
  
  
  
  }
  
  //get methods
  unsigned int rtsOBJ::getNumVertices(){return v_list.size();}
  unsigned int rtsOBJ::getNumLines(){return lines.size();}
  unsigned int rtsOBJ::getNumFaces(){return faces.size();}
  unsigned int rtsOBJ::getNumPointLists(){return points.size();}
  unsigned int rtsOBJ::getNumTexCoords(){return vt_list.size();}
  unsigned int rtsOBJ::getNumNormals(){return vn_list.size();}
  
  //these functions return the coordinate index as well as the value
  unsigned int rtsOBJ::getNumFaceVertices(unsigned int face){return primitives[face].p.size();}
  unsigned int rtsOBJ::getFaceVertex(unsigned int face, unsigned int vertex){return primitives[face].p[vertex].v;}
  unsigned int rtsOBJ::getFaceNormal(unsigned int face, unsigned int normal){return primitives[face].p[normal].vn;}
  unsigned int rtsOBJ::getFaceTexCoord(unsigned int face, unsigned int texcoord){return primitives[face].p[texcoord].vt;}
  unsigned int rtsOBJ::getNumLineVertices(unsigned int line){return primitives[line].p.size();}
  unsigned int rtsOBJ::getLineVertex(unsigned int line, unsigned int vertex){return primitives[line].p[vertex].v;}
  unsigned int rtsOBJ::getLineTexCoord(unsigned int line, unsigned int texcoord){return primitives[line].p[texcoord].vt;}
  point3D<float> rtsOBJ::getVertex3d(unsigned int index)
  {
  	return point3D<float>(v_list[index].x, v_list[index].y, v_list[index].z);
  }
  point3D<float> rtsOBJ::getTexCoord3d(unsigned int index)
  {
  	return point3D<float>(vt_list[index].u, vt_list[index].v, vt_list[index].w);
  }
  point3D<float> rtsOBJ::getNormal3d(unsigned int index)
  {
  	return point3D<float>(vn_list[index].i, vn_list[index].j, vn_list[index].k);
  }
  vertex_position rtsOBJ::getVertex(unsigned int index){return v_list[index];}
  vertex_texture rtsOBJ::getTexCoord(unsigned int index){return vt_list[index];}
  vertex_normal rtsOBJ::getNormal(unsigned int index){return vn_list[index];}
  
  
  unsigned int rtsOBJ::getPrimitiveType(unsigned int primitive)
  {
  	/*
  	switch(primitives[i].type)
  	{
  	case OBJ_POINTS:
  		return OBJ_POINTS;
  		break;
  	case OBJ_LINES:
  		return OBJ_LINES;
  		break;
  	case OBJ_FACE:
  		f_RenderFace(i);
  		break;
  	}*/
  	return 0;
  }
  /****************************************************/
  /*******Iterator Methods*****************************/
  /****************************************************/
  
  rtsOBJ::iterator rtsOBJ::begin()
  {
  	//create an iterator that will be returned and assign it to this OBJ
  	iterator result;
  	result.obj = this;
  	result.end_object = false;
  	result.end_primitive = false;
  
  	//if there are no primitives, return the end iterator
  	if(primitives.size() == 0)
  		return end();
  
  	//start at the beginning of the primitive array
  	result.primitive_index = 0;
  
  	return result;
  }
  
  rtsOBJ::iterator rtsOBJ::end()
  {
  	//create an end iterator to return
  	iterator result;
  	result.obj = this;
  	result.end_primitive = true;
  	result.primitive_index = result.obj->primitives.size();
  
  	return result;
  }
  
  void rtsOBJ::iterator::operator++()
  {
  	primitive_index++;
  	if(primitive_index >= obj->primitives.size())
  		(*this) = obj->end();
  
  }
  
  bool rtsOBJ::iterator::operator ==(rtsOBJ::iterator operand)
  {
  	if(operand.primitive_index == primitive_index)
  	   return true;
  	else return false;
  }
  
  bool rtsOBJ::iterator::operator !=(rtsOBJ::iterator operand)
  {
  	if(operand.primitive_index != primitive_index)
  	   return true;
  	else return false;
  }
  
  unsigned int rtsOBJ::iterator::operator*()
  {
  	return primitive_index;
  }
  
  void rtsOBJ::iterator::print()
  {
  	cout<<"This is a test"<<endl;
  }
  
  
  
  
  #endif