Added stub for missing hel/CollisionObject.

Now compiles on OS X, but segfaults at launch...

.gitignore

+.DS_Store

Makefile

 # -DMULTITEXTURE		Add OpenGL multitexturing
 # -DUNICODE_SUPPORT		Add unicode/internation keyboard support
 # -DUSING_EMITTER_IN_GAME	Run particle test in game
-BASE_DEFS=$(shell sdl-config --cflags) -DSDL_INTERFACE \
+BASE_DEFS=$(shell sdl-config --cflags) -Isrc -I/opt/local/include -DSDL_INTERFACE \
 	-DUSING_OPENGL -DZLIB_SUPPORT -DUSING_EMITTER \
 	-DUSING_OPENAL -DUSING_MTK_TGA -DUSING_PTHREADS \
 	-DUSING_HEL -DHAVE_SDL_TTF -DHAVE_OPENGL
 
 BASE_LIBS=$(shell sdl-config --libs) -lz -lstdc++ \
-	-lopenal -lpthread -lSDL_ttf
+	-lpthread -lSDL_ttf
 
 # -DDEBUG_GL
 DEBUG_DEFS=-DDEBUG -DEXPERIMENTAL
 
 ###############################################################
 # OpenAL, Sound support
-BASE_DEFS += -DHAVE_OPENAL
-BASE_LIBS += -lopenal
+#BASE_DEFS += -DHAVE_OPENAL
+#BASE_LIBS += -lopenal
 
 # libferit, File transfer via HTTP/FTP/etc support
 LIBFERIT_LIB=/usr/local/lib/libferit.so
 ###############################################################
 CC=gcc
 
-BASE_CFLAGS=-Wall -Isrc $(BASE_DEFS) \
+BASE_CFLAGS=-Wall $(BASE_DEFS) \
 	-DVERSION=\"\\\"$(NAME)-$(VERSION)-$(BUILD_ID)\\\"\" \
 	-DBUILD_HOST=\"\\\"$(BUILD_HOST)\\\"\"
 
-LD_FLAGS=-L/usr/X11R6/lib -lXmu -lXt -lSM -lICE -lXext -lX11 -lXi \
+LD_FLAGS=-L/opt/X11/lib -L/opt/local/lib -lXmu -lXt -lSM -lICE -lXext -lX11 -lXi \
 	-lGL -lGLU -lm $(BASE_LIBS)
 
 RELEASE_CFLAGS=$(BASE_CFLAGS) -ffast-math -funroll-loops \
 	$(BUILDDIR)/Vector3d.o \
 	$(BUILDDIR)/Matrix.o \
 	$(BUILDDIR)/ViewVolume.o \
-	$(BUILDDIR)/Spring.o \
 	$(BUILDDIR)/CollisionObject.o \
 	$(BUILDDIR)/BoundingVolume.o \
 	$(BUILDDIR)/Quaternion.o \
-	$(BUILDDIR)/math.o
-
+	$(BUILDDIR)/math.o \
+	$(BUILDDIR)/Entity.o
+	#$(BUILDDIR)/Spring.o
 
 OBJS = \
 	$(DEBUG_OBJ) \
 	CFLAGS="-Wall -O0 -g -Isrc -DUNIT_TEST_UTPACKAGE -DUSING_MTK_TGA" \
 	LD_FLAGS="-lm -lstdc++"
 
-#################################################################
+#################################################################

deps.sh

 # Call it passing CFLAGS and a source filename
 # to generate a dep line
 
-echo "# deps.sh was passed:"
-echo -n "# "
-echo $@
-
-echo "# Then made this line:"
-echo -n "\$(BUILDDIR)/"
-cc -MM $@
-printf "\t \$(DO_CC)\n\n"
+cc -MM $@ > /dev/null
+OUT=$?
+if [ $OUT -eq 0 ];then
+    printf "\$(BUILDDIR)/"
+    cc -MM $@
+    printf "\t \$(DO_CC)\n\n"
+fi

src/Camera.cpp

 /* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
 /*================================================================
- * 
+ *
  * Project : Freyja
  * Author  : Mongoose
  * Website : http://www.westga.edu/~stu7440/
  * License : No use w/o permission (C) 2001 Mongoose
  * Comments: OpenGL camera class for Freyja
  *
- *           This file was generated using Mongoose's C++ 
+ *           This file was generated using Mongoose's C++
  *           template generator script.  <stu7440@westga.edu>
- * 
- *-- History ------------------------------------------------- 
+ *
+ *-- History -------------------------------------------------
  *
  * 2002.12.16:
  * Mongoose - Removed perspective setting and OpenGL dependency
  *            API changes to reflect new direction of this object:
- *              Removing outdated algorithms and code 
+ *              Removing outdated algorithms and code
  *              And refactoring the class in general
  *
  * 2001.06.06:
  =================================================================*/
 
 #include <math.h>
-#include <hel/math.h>
+#include "hel/math.h"
 #include "Camera.h"
 
 #ifdef DEBUG_MEMEORY
 	double look[4] = { 0, 0, -1, 1 };
  	unsigned int i;
 	matrix_t m;
-   
+
 
 	t.set(angle, x, y, z);
 	n = mQ * t;
 		mTarget[i] += mPos[i];
 		mUp[i] += mPos[i];
 	}
-    
+
 	mQ = n;
 }
 
 
 	mPos[0] = x;
 	mPos[1] = y;
-	mPos[2] = z;	
+	mPos[2] = z;
 }
 
 
 		{
 			mPos[2] += (mTranslateDelta * cos(mTheta));
 		}
-		
+
 	  mPos[0] += (mTranslateDelta * sin(mTheta));
 	  mPos[1] += (mTranslateDelta * sin(mTheta2));
 	  break;
 	  rotate(mTheta, 0.0, 1.0, 0.0);
 	  break;
   case CAMERA_MOVE_UP:
-	  mPos[1] -= mTranslateDelta / 2.0;   
+	  mPos[1] -= mTranslateDelta / 2.0;
 	  mTarget[1] -= mTranslateDelta / 2.0;
 	  break;
   case CAMERA_MOVE_DOWN:

src/Camera.h

 /* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
 /*================================================================
- * 
+ *
  * Project : Hel
  * Author  : Mongoose
  * Website : http://www.westga.edu/~stu7440/
  * License : No use w/o permission (C) 2001 Mongoose
  * Comments: OpenGL camera class for Freyja
  *
- *           This file was generated using Mongoose's C++ 
+ *           This file was generated using Mongoose's C++
  *           template generator script.  <stu7440@westga.edu>
- * 
- *-- History ------------------------------------------------ 
+ *
+ *-- History ------------------------------------------------
  *
  * 2002.12.16:
  * Mongoose - Removed perspective setting and OpenGL dependency
  *            API changes to reflect new direction of this object:
- *              Removing outdated algorithms and code 
+ *              Removing outdated algorithms and code
  *              And refactoring the class in general
  *
  * 2001.06.06:
 #ifndef __HEL_MONGOOSE_CAMERA_H_
 #define __HEL_MONGOOSE_CAMERA_H_
 
-#include <hel/math.h>
-#include <hel/Matrix.h>
-#include <hel/Quaternion.h>
+#include "hel/math.h"
+#include "hel/Matrix.h"
+#include "hel/Quaternion.h"
 
 enum camera_command                /* Interactive camera control */
 {
 
 	Camera();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Constructs an object of Camera
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2001.05.18: 
+	 * 2001.05.18:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2001.05.18: 
+	 * 2001.05.18:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 
 	unsigned int getId();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Returns this camera's id
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2001.05.18: 
+	 * 2001.05.18:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	void getPosition(vec3_t pos);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Returns current position
 	 *
 	 *-- History ------------------------------------------
 
 	void getUp(vec3_t up);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Returns up vector
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2001.05.18: 
+	 * 2001.05.18:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	void getTarget(vec3_t target);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Returns target ( look at pos )
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2001.05.18: 
+	 * 2001.05.18:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
-	
+
 	float getYaw();
 	/*------------------------------------------------------
 	 * Pre  : Get current yaw in degrees
-	 * Post : 
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
 
 	double getRadianYaw();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Returns theta angle/yaw of camera
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2001.05.26: 
+	 * 2001.05.26:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
-	
+
 	float getPitch();
 	/*------------------------------------------------------
 	 * Pre  : Get current pitch in degrees
-	 * Post : 
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
 
 	double getRadianPitch();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Returns phi angle/pitch of camera
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2001.05.26: 
+	 * 2001.05.26:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
-	
+
 	bool isBehind(int x, int z);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Returns true if (x, z) is behind camera eye
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2001.05.26: 
+	 * 2001.05.26:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2001.06.04: 
+	 * 2001.06.04:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	void translate(float x, float y, float z);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Camera position is set to x,y,z
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2001.05.18: 
+	 * 2001.05.18:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	void reset();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Camera is set to inital state
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2001.05.18: 
+	 * 2001.05.18:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2001.06.04: 
+	 * 2001.06.04:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2001.06.04: 
+	 * 2001.06.04:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2001.05.18: 
+	 * 2001.05.18:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
     *
     *-- History ------------------------------------------
     *
-    * 2002.01.02: 
+    * 2002.01.02:
     * Mongoose - Created
     ------------------------------------------------------*/
 
 	void update();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Updates view target
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2001.05.18: 
+	 * 2001.05.18:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	void setPosition(vec3_t pos);
 	/*------------------------------------------------------
 	 * Pre  : Set current position
-	 * Post : 
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
 
 	void setUp(vec3_t up);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Sets up vector
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2001.05.18: 
+	 * 2001.05.18:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	void setTarget(vec3_t target);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Sets target ( look at pos )
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2001.05.18: 
+	 * 2001.05.18:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	Quaternion mQ;              /* Quaternion for rotation */
 
 	unsigned int mFlags;        /* For testing with flags  */
-		
+
 	double mPos[4];             /* Location in 3 space (aka eye) */
-	
+
 	double mTarget[4];          /* Postition we're looking at  */
-	
+
 	double mUp[4];              /* Up vector  */
-	
+
 	double mSide[4];            /* Side vector  */
-	
+
 	double mViewDistance;      /* Distance from target */
-	
+
 	double mTranslateDelta;    /* Step size to move */
-	
+
 	double mRotateDelta;       /* Radians to rotate  Y */
-	
+
 	double mTheta;              /* View angle  Y */
 
 	double mRotateDelta2;      /* Radians to rotate  Z */
-	
+
 	double mTheta2;             /* View angle  Z */
-	
+
 	bool mUpdate;               /* Check to see if view needs updating */
 
 	static unsigned int mCounter;   /* Id system use */

src/Emitter.cpp

 /* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
 /*================================================================
- * 
+ *
  * Project : Freyja
  * Author  : Terry 'Mongoose' Hendrix II
  * Website : http://www.westga.edu/~stu7440/
  * Comments: Particle emitter for freyja
  *
  *
- *           This file was generated using Mongoose's C++ 
+ *           This file was generated using Mongoose's C++
  *           template generator script.  <stu7440@westga.edu>
- * 
- *-- History ------------------------------------------------- 
+ *
+ *-- History -------------------------------------------------
  *
  * 2001.06.30:
  * Mongoose - Created
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
+#ifdef __APPLE__
+#include <OpenGL/gl.h>
+#include <OpenGL/glu.h>
+#else
 #include <GL/gl.h>
 #include <GL/glu.h>
+#endif
 #include "Emitter.h"
 
 #ifdef DEBUG_MEMEORY
 		return -1; // error really
 
 	a->Pos(&x, &y, &z);
-	distA = (Emitter::mFrustum[5][0] * x + 
-				Emitter::mFrustum[5][1] * y + 
-				Emitter::mFrustum[5][2] * z + 
+	distA = (Emitter::mFrustum[5][0] * x +
+				Emitter::mFrustum[5][1] * y +
+				Emitter::mFrustum[5][2] * z +
 				Emitter::mFrustum[5][3]);
 
 	b->Pos(&x, &y, &z);
-	distB = (Emitter::mFrustum[5][0] * x + 
-				Emitter::mFrustum[5][1] * y + 
-				Emitter::mFrustum[5][2] * z + 
+	distB = (Emitter::mFrustum[5][0] * x +
+				Emitter::mFrustum[5][1] * y +
+				Emitter::mFrustum[5][2] * z +
 				Emitter::mFrustum[5][3]);
 
 	// reverse less/greater than
 {
 	unsigned int i;
 
-	
+
 	for (i = 0; i < _count; i++)
-		_particle[i].TextureId(id);		
+		_particle[i].TextureId(id);
 }
 
 
-void Emitter::TextureId(unsigned int particle_start, 
+void Emitter::TextureId(unsigned int particle_start,
 								unsigned int particle_end, int id)
 {
 	unsigned int i;
 		 (particle_start < particle_end))
 	{
 		for (i = particle_start; i < particle_end; i++)
-			_particle[i].TextureId(id);		
+			_particle[i].TextureId(id);
 	}
 }
 
 
-void Emitter::Color(unsigned int particle_start, unsigned int particle_end, 
+void Emitter::Color(unsigned int particle_start, unsigned int particle_end,
 						  float r, float g, float b)
 {
 	unsigned int i;
 		 (particle_start < particle_end))
 	{
 		for (i = particle_start; i < particle_end; i++)
-			_particle[i].Color(r, g, b);		
+			_particle[i].Color(r, g, b);
 	}
 }
 
 
-void Emitter::Speed(unsigned int particle_start, unsigned int particle_end, 
+void Emitter::Speed(unsigned int particle_start, unsigned int particle_end,
 						  float x, float y, float z)
 {
 	unsigned int i;
 		 (particle_start < particle_end))
 	{
 		for (i = particle_start; i < particle_end; i++)
-			_particle[i].Speed(x, y, z);		
+			_particle[i].Speed(x, y, z);
 	}
 }
 
 
-void Emitter::Force(unsigned int particle_start, unsigned int particle_end, 
+void Emitter::Force(unsigned int particle_start, unsigned int particle_end,
 						  float x, float y, float z)
 {
 	unsigned int i;
 		 (particle_start < particle_end))
 	{
 		for (i = particle_start; i < particle_end; i++)
-			_particle[i].Force(x, y, z);		
+			_particle[i].Force(x, y, z);
 	}
 }
 
 			{
 				for (p = 0; p < 6; ++p)
 				{
-					if (mFrustum[p][0] * x + 
-						 mFrustum[p][1] * y + 
-						 mFrustum[p][2] * z + 
+					if (mFrustum[p][0] * x +
+						 mFrustum[p][1] * y +
+						 mFrustum[p][2] * z +
 						 mFrustum[p][3] < 0)
 					{
 						_particle[i].setActive(false);

src/GLString.cpp

 /* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
 /*================================================================
- * 
+ *
  * Project : Mtk
  * Author  : Terry 'Mongoose' Hendrix II
  * Website : http://www.westga.edu/~stu7440/
  * Comments: Open GL rendering font/string class
  *
  *
- *           This file was generated using Mongoose's C++ 
+ *           This file was generated using Mongoose's C++
  *           template generator script.  <stu7440@westga.edu>
- * 
- *-- History ------------------------------------------------- 
+ *
+ *-- History -------------------------------------------------
  *
  * 2002.01.01:
  * Mongoose - Created
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>
+#ifdef __APPLE__
+#include <OpenGL/gl.h>
+#else
 #include <GL/gl.h>
+#endif
 
 #include "Texture.h"
 
 	{
 		delete [] _font_texture;
 	}
-	
+
 	if (_font_base)
 	{
 		delete [] _font_base;
 }
 
 
-void GLString::Init(unsigned int max_strings, unsigned int max_fonts, 
+void GLString::Init(unsigned int max_strings, unsigned int max_fonts,
 						  int *tex_map)
 {
 	unsigned int i;
 	for (i = 0; i < max_fonts; ++i)
 	{
 		_font_texture[i] = tex_map[i];
-		
+
 		if (BuildFontList(i) < 0)
 		{
 			printf("GLString::Init> BuildFontList failed for %i\n", i);
 {
 	gl_string_t *str = GetString(string);
 
-	
+
 	if (str && pos < str->len)
 	{
 		str->text[pos] = c;
 {
 	gl_string_t *str = GetString(string);
 
-	
+
 	if (str)
 	{
 		return str->len;
 {
 	gl_string_t *str = GetString(string);
 
-	
+
 	if (str)
 	{
 		return str->text;
 		}
 
 		va_start(args, s);
-		vsnprintf(str->text, str->len-2, s, args);	
+		vsnprintf(str->text, str->len-2, s, args);
 		str->text[str->len-1] = 0;
 		va_end(args);
 	}
 	int i;
 	float cx;
 	float cy;
-	
+
 
 	if (_num_font >= _num_font_max || index < 0 || index >= (int)_num_font_max)
 	{
 
 	_font_base[index] = glGenLists(256);
 	glBindTexture(GL_TEXTURE_2D, _font_texture[index]);
-	
+
 	// Mongoose 2002.01.01, Generate 256 lists per font
 	//   one per symbol
 	for (i = 0; i < 256; i++)
 		cx = 1 - (float)(i % 16) / 16.0f;
 		/* Y Position Of Current Character */
 		cy = 1 - (float)(i / 16) / 16.0f;
-		
+
 		/* Start Building A List */
 		glNewList(_font_base[index] + (255 - i), GL_COMPILE);
 		/* Use A Quad For Each Character */
 		glTexCoord2f(cx - 0.0625, cy);
 		/* Vertex Coord (Bottom Left) */
 		glVertex2i(0, 0);
-		
+
 		/* Texture Coord (Bottom Right) */
 		glTexCoord2f(cx, cy);
 		/* Vertex Coord (Bottom Right) */
 		glVertex2i(16, 0);
-		
+
 		/* Texture Coord (Top Right) */
 		glTexCoord2f(cx, cy - 0.0625f);
 		 /* Vertex Coord (Top Right) */
 		glVertex2i(16, 16);
-		
+
 		/* Texture Coord (Top Left) */
 		glTexCoord2f(cx - 0.0625f, cy - 0.0625f);
 		/* Vertex Coord (Top Left) */
 		glVertex2i(0, 16);
 		glEnd();
-		
+
 		/* Move To The Left Of The Character */
 		glTranslated(10, 0, 0);
 		glEndList();
 	int n;
 	va_list args;
 
-	
+
 	// Mongoose 2002.01.01, Only allow valid strings
 	//   we must assume it's NULL terminated also if it passes...
 	if (!string || !string[0])
 	// Mongoose 2002.01.04, Remeber string size, for future rebuffering use
 	_string[_num_string].len = sz;
 
-	// Mongoose 2002.01.01, Incement string counter, since we just 
+	// Mongoose 2002.01.01, Incement string counter, since we just
 	//   allocated a string
 	++_num_string;
 
 	// Mongoose 2001.12.31, Restore scene projection
 	glMatrixMode(GL_PROJECTION);
 	glPopMatrix();
-	
+
 	// Mongoose 2001.12.31, Restore scene matrix
 	glMatrixMode(GL_MODELVIEW);
 	glPopMatrix();
 	{
 		if (_string[i].active)
 		{
-			glPrint2d(_string[i].x, _string[i].y, 
-						 _string[i].scale, 
+			glPrint2d(_string[i].x, _string[i].y,
+						 _string[i].scale,
 						 _string[i].text);
 		}
 	}
 
 	glMatrixMode(GL_PROJECTION);
 	aspect = (GLfloat)width/(GLfloat)height;
-	
+
 	// Mongoose 2002.01.01, Setup view volume, with a nice FOV
 	gluPerspective(40.0, aspect, 1, 2000);
 
 }
 
 
-void init_gl(unsigned int width, unsigned int height, 
+void init_gl(unsigned int width, unsigned int height,
 				 int argc, char *argv[])
 {
 	int i, j;
 	glDepthFunc(GL_LESS);
 	glEnable(GL_BLEND);
 	glBlendFunc(GL_SRC_ALPHA, GL_ONE);
-	
+
 	event_resize(width, height);
 
 	// Mongoose 2002.01.01, Texture setup
 	gTexture.reset();
 	gTexture.setFlag(Texture::fUseMipmaps);
 	gTexture.setMaxTextureCount(32);
-	
+
 	if (argc > 1)
 	{
 		for (i = 1, j = 0; i < argc; ++i, ++j)
 	printf("%i %i %i %i\n", id[0], id[1], id[2], id[3]);
 
 	TEXT->Init(4, 4, id);
-	i = TEXT->glPrintf((width/2)-12*5, height/2, 0, 
+	i = TEXT->glPrintf((width/2)-12*5, height/2, 0,
 							 "[font %i] GLString Test", id[0]);
 	if (i)
 	{
 		printf("TEXT->glPrintf> ERROR code %i ( 0 means no error )\n", i);
 	}
 
-	i = TEXT->glPrintf((width/2)-10*7, height/2+32, 1, 
+	i = TEXT->glPrintf((width/2)-10*7, height/2+32, 1,
 							 "[font %i] GLString Test", id[1]);
 
 	if (i)
 	s = 1.1;
 	TEXT->Scale(s);
 
-	i = TEXT->glPrintf((width/2)-10*7, height/2+64, 1, 
+	i = TEXT->glPrintf((width/2)-10*7, height/2+64, 1,
 							 "[font %i] Scaled by %.3f", id[1], s);
 
 	if (i)
 	{
 		printf("TEXT->glPrintf> ERROR code %i ( 0 means no error )\n", i);
 	}
-	i = TEXT->glPrintf((width/2)-10*7, height/2-32, 0, 
+	i = TEXT->glPrintf((width/2)-10*7, height/2-32, 0,
 							 "[font %i] Scaled by %.3f", id[0], s);
 
 	if (i)
 	  if (SDL_GL_LoadLibrary("libGL.so") < 0)
 	  {
 		  SDL_ClearError();
-    
+
 		  // Fallback 2
 		  if (SDL_GL_LoadLibrary("libGL.so.1") < 0)
 		  {
   SDL_WINDOW = SDL_SetVideoMode(width, height, 16, flags);
   SDL_WM_SetCaption("GLString Test", "GLString Test");
   SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
-  
+
   // Init rendering
   init_gl(width, height, argc, argv);
 
 			  break;
 		  case SDL_MOUSEBUTTONDOWN:
 		  case SDL_MOUSEBUTTONUP:
-			  break;	
+			  break;
 		  case SDL_KEYDOWN:
 			  mkeys = (unsigned int)SDL_GetModState();
 			  mod = 0;
 			  break;
 		  case SDL_KEYUP:
 			  break;
-		  case SDL_VIDEORESIZE:			  
+		  case SDL_VIDEORESIZE:
 			  event_resize(event.resize.w, event.resize.h);
 
 			  width = event.resize.w;
 		  }
 	  }
   }
-  
+
   return 0;
 }
 #else

src/GLUTSystem.cpp

 /* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
 /*================================================================
- * 
+ *
  * Project : UnRaider
  * Author  : Terry 'Mongoose' Hendrix II
  * Website : http://www.westga.edu/~stu7440/
  * Email   : stu7440@westga.edu
  * Object  : GLUTSystem
  * License : No use w/o permission (C) 2002 Mongoose
- * Comments: 
+ * Comments:
  *
  *
- *           This file was generated using Mongoose's C++ 
+ *           This file was generated using Mongoose's C++
  *           template generator script.  <stu7440@westga.edu>
- * 
- *-- History ------------------------------------------------- 
+ *
+ *-- History -------------------------------------------------
  *
  * 2002.08.09:
  * Mongoose - Created
 #include <stdio.h>
 #include <string.h>
 
+#ifdef __APPLE__
+#include <OpenGL/gl.h>
+#include <OpenGL/glu.h>
+#include <GLUT/glut.h>
+#else
 #include <GL/gl.h>
 #include <GL/glu.h>
 #include <GL/glut.h>
+#endif
 
 #ifdef PS2_LINUX
 #   include "ps2.h"
 	//printf("[Mongoose MEMEORY_DEBUG]\nUnfreed memory table:\n");
 	//dump_memory_report();
 	//#endif
-	
+
 	printf("\n\n\tThanks for testing %s\n", VERSION);
 	printf("\tPlease file bug reports and submit video card performance\n\n");
 	printf("\tBuild date : %s @ %s\n", __DATE__, __TIME__);
 }
 
 
-void GLUTSystem::initVideo(unsigned int width, unsigned int height, 
+void GLUTSystem::initVideo(unsigned int width, unsigned int height,
 								  bool fullscreen)
 {
 	glutInit(NULL, 0);
 	printf("@Created OpenGL Context...\n");
-	
+
 	m_width = width;
 	m_height = height;
 

src/Light.h

 /* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
 /*================================================================
- * 
+ *
  * Project : Freyja
  * Author  : Terry 'Mongoose' Hendrix II
  * Website : http://www.westga.edu/~stu7440/
  * Comments: This is the GL light class
  *
  *
- *           This file was generated using Mongoose's C++ 
+ *           This file was generated using Mongoose's C++
  *           template generator script.  <stu7440@westga.edu>
- * 
- *-- History ------------------------------------------------ 
+ *
+ *-- History ------------------------------------------------
  *
  * 2002.01.27:
  * Mongoose - Created
 #ifndef __FREYJA_MONGOOSE_LIGHT_H_
 #define __FREYJA_MONGOOSE_LIGHT_H_
 
-#include <hel/math.h>
+#include "hel/math.h"
 
 
 class Light
 
 	typedef enum
    {
-		typePoint = 1, 
-		typeSpot = 2, 
+		typePoint = 1,
+		typeSpot = 2,
 		typeDirectional = 3
 	} FreyjaLightType;
 
 
 	Light();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Constructs an object of Light
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.01.27: 
+	 * 2002.01.27:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.01.27: 
+	 * 2002.01.27:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 

src/Md3.cpp

 /* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
 /*==========================================================================
- * 
+ *
  * Project : GooseEgg
  * Author  : Terry 'Mongoose' Hendrix II
  * Website : http://www.westga.edu/~stu7440
  *           so - since this class is desgined using their specs...
  *
  *
- *-- History ---------------------------------------------------------- 
+ *-- History ----------------------------------------------------------
  *
  * 2000-10-06:
  * Mongoose - The new code for the new interface
 #include <math.h>
 
 #ifdef USING_OPENGL
-#   include <GL/gl.h>
+#ifdef __APPLE__
+#include <OpenGL/gl.h>
+#else
+#include <GL/gl.h>
+#endif
 #endif
 
 #include "endian.h"
 {
 	mFlags = fDecodeNormals;
 
-	memset(m_filename, 0, 68);     
- 
+	memset(m_filename, 0, 68);
+
 	m_id = 0;
-	m_version = 0;           
-	m_num_bones = 0;   
-	m_num_tags = 0;          
-	m_num_meshes = 0;        
+	m_version = 0;
+	m_num_bones = 0;
+	m_num_tags = 0;
+	m_num_meshes = 0;
 	m_max_skins = 0;
 
-	m_header_length = 0;     
-	m_tag_start = 0;         
-	m_surfaces_start = 0;          
-	m_file_size = 0;        
+	m_header_length = 0;
+	m_tag_start = 0;
+	m_surfaces_start = 0;
+	m_file_size = 0;
 
 	m_debug = 1;
 
-	m_tags = NULL;     
+	m_tags = NULL;
 	m_bones = NULL;
 	m_meshes = NULL;
 	slaveTest = NULL;
 
 
 Md3::Md3(unsigned int num_meshes, unsigned int num_bones, unsigned int num_tags)
-{	
-	memset(m_filename, 0, 68);     
- 
+{
+	memset(m_filename, 0, 68);
+
 	m_id = 0;
 	m_version = 0;
 	m_max_skins = 0;
 
-	m_header_length = 0;     
-	m_tag_start = 0;         
-	m_surfaces_start = 0;          
-	m_file_size = 0;        
+	m_header_length = 0;
+	m_tag_start = 0;
+	m_surfaces_start = 0;
+	m_file_size = 0;
 
 	m_debug = 1;
 
-	m_tags = NULL;     
+	m_tags = NULL;
 	m_bones = NULL;
 	m_meshes = NULL;
 	slaveTest = NULL;
 	texTest = NULL;
 
-	m_num_bones = num_bones;   
-	m_num_tags = num_tags;          
+	m_num_bones = num_bones;
+	m_num_tags = num_tags;
 	m_num_meshes = num_meshes;
 	createMeshes(num_meshes);
 	createTags(num_tags*num_bones);
 {
 	int i;
 
-	memset(m_filename, 0, 68);     
+	memset(m_filename, 0, 68);
 
 	m_id = 0;
-	m_version = 0;           
-	m_num_bones = 0;   
-	m_num_tags = 0;          
-	m_num_meshes = 0;        
+	m_version = 0;
+	m_num_bones = 0;
+	m_num_tags = 0;
+	m_num_meshes = 0;
 	m_max_skins = 0;
-	m_header_length = 0;     
-	m_tag_start = 0;         
-	m_surfaces_start = 0;          
-	m_file_size = 0;  
+	m_header_length = 0;
+	m_tag_start = 0;
+	m_surfaces_start = 0;
+	m_file_size = 0;
 
 	if (m_meshes)
 	{
 	{
 		delete [] texTest;
 	}
-} 
+}
 
 
 void Md3::setDebug(unsigned char level)
 	int16_t ss;
 	int8_t sb;
 
-  
+
 	npherno_warn = 0;
 
 	f = fopen(filename, "rb");
 
 	fread_int_small(&m_id, f);
 	printDebug("load", "id = 0x%x\n", m_id);
-  
+
 	if (m_id != MD3_IDALIASHEADER)
 	{
 		printError("load", "header not 0x%x\n", MD3_IDALIASHEADER);
 		return -2;
 	}
-  
+
 	fread_int_small(&m_version, f);
 	printDebug("load", "version = %i\n", m_version);
 
 		printError("load", "version not %i\n", MD3_ALIAS_VERSION);
 		return -3;
 	}
-  
+
 	fread(&m_filename, 68, 1, f);
 	printDebug("load", "filename = '%s'\n", m_filename);
 
 
 	fread_int_small(&m_file_size, f);
 	printDebug("load", "file_size = %i\n", m_file_size);
- 
+
 	// End Header //////////////////
 	printDebug("load", "Loading %i bones\n", m_num_bones);
 	createBones(m_num_bones);
 			npherno_warn = 1;
 		}
 
-		printDebug("load", "bone[%i].mins = %f %f %f\n", i, 
+		printDebug("load", "bone[%i].mins = %f %f %f\n", i,
 				 m_bones[i].mins[0], m_bones[i].mins[1], m_bones[i].mins[2]);
-		printDebug("load", "bone[%i].maxs = %f %f %f\n", i, 
+		printDebug("load", "bone[%i].maxs = %f %f %f\n", i,
 				 m_bones[i].maxs[0], m_bones[i].maxs[1], m_bones[i].maxs[2]);
-		printDebug("load", "bone[%i].center = %f %f %f\n", i, 
+		printDebug("load", "bone[%i].center = %f %f %f\n", i,
 				 m_bones[i].center[0], m_bones[i].center[1], m_bones[i].center[2]);
 		printDebug("load", "bone[%i].scale = %f\n", i, m_bones[i].scale);
 		printDebug("load", "bone[%i].creator = '%s'\n", i, m_bones[i].creator);
 
 	if (m_tag_start != ftell(f))
 	{
-		printWarning("load", "tag_start %i != file pos %lu\n", 
+		printWarning("load", "tag_start %i != file pos %lu\n",
 						 m_tag_start,ftell(f));
 
 		fseek(f, m_tag_start, SEEK_SET);
 
 	if (m_surfaces_start != ftell(f))
 	{
-		printWarning("load", "surfaces_start %i != file pos %lu\n", 
+		printWarning("load", "surfaces_start %i != file pos %lu\n",
 						 m_surfaces_start, ftell(f));
 
 		fseek(f, m_surfaces_start, SEEK_SET);
 		printWarning("load", "File position set to %lu\n", ftell(f));
 	}
- 
+
 	printDebug("load", "Loading %i meshes\n", m_num_meshes);
 	createMeshes(m_num_meshes);
 
 		fread(&m_meshes[i].name, 64, 1, f);
 		fread(&m_meshes[i].flags, 4, 1, f);
 		fread(&m_meshes[i].num_frames, 4, 1, f);
-    
+
 		fread(&m_meshes[i].num_shaders, 4, 1, f);
 		m_meshes[i].num_skins = m_meshes[i].num_shaders;
-    
+
 		fread(&m_meshes[i].num_vertices, 4, 1, f);
 		fread(&m_meshes[i].num_triangles, 4, 1, f);
 		fread(&m_meshes[i].tris_offset, 4, 1, f);
 		// num_verts * num_frames
 		fread(&m_meshes[i].mesh_size, 4, 1, f);     // next surface
 
-		printDebug("load", "mesh[%i].id = '%c%c%c%c'\n", i, 
+		printDebug("load", "mesh[%i].id = '%c%c%c%c'\n", i,
 				 m_meshes[i].id[0], m_meshes[i].id[1], m_meshes[i].id[2], m_meshes[i].id[3]);
-		printDebug("load", "mesh[%i].name = '%s'\n", i, 
+		printDebug("load", "mesh[%i].name = '%s'\n", i,
 				 m_meshes[i].name);
-		printDebug("load", "mesh[%i].flags = %i\n", i, 
+		printDebug("load", "mesh[%i].flags = %i\n", i,
 				 m_meshes[i].flags);
-		printDebug("load", "mesh[%i].num_frames = %i\n", i, 
+		printDebug("load", "mesh[%i].num_frames = %i\n", i,
 				 m_meshes[i].num_frames);
-		printDebug("load", "mesh[%i].num_shaders = %i\n", i, 
+		printDebug("load", "mesh[%i].num_shaders = %i\n", i,
 				 m_meshes[i].num_shaders);
-		printDebug("load", "mesh[%i].num_vertices = %i\n", i, 
+		printDebug("load", "mesh[%i].num_vertices = %i\n", i,
 				 m_meshes[i].num_vertices);
-		printDebug("load", "mesh[%i].num_triangles = %i\n", i, 
+		printDebug("load", "mesh[%i].num_triangles = %i\n", i,
 				 m_meshes[i].num_triangles);
-		printDebug("load", "mesh[%i].tris_offset = %i\n", i, 
+		printDebug("load", "mesh[%i].tris_offset = %i\n", i,
 				 m_meshes[i].tris_offset+m_surfaces_start);
-		printDebug("load", "mesh[%i].shader_offset = %i\n", i, 
+		printDebug("load", "mesh[%i].shader_offset = %i\n", i,
 				 m_meshes[i].header_size+m_surfaces_start);
-		printDebug("load", "mesh[%i].texel_offset = %i\n", i, 
+		printDebug("load", "mesh[%i].texel_offset = %i\n", i,
 				 m_meshes[i].texel_offset+m_surfaces_start);
-		printDebug("load", "mesh[%i].vertex_offset = %i\n", i, 
+		printDebug("load", "mesh[%i].vertex_offset = %i\n", i,
 				 m_meshes[i].vertex_offset+m_surfaces_start);
-		printDebug("load", "mesh[%i].mesh_end = %i\n", i, 
+		printDebug("load", "mesh[%i].mesh_end = %i\n", i,
 				 m_meshes[i].mesh_size+m_surfaces_start);
 
 		// This will kind of handle bad mesh reads here
 		{
 			printWarning("load", "_mesh[%i] shader offset %i != file pos %lu\n",
 							 i, m_surfaces_start+m_meshes[i].header_size, ftell(f));
-      
+
 			fseek(f, m_surfaces_start+m_meshes[i].header_size, SEEK_SET);
 			printWarning("load", "HANDLE: File position set to %lu\n", ftell(f));
 		}
 
 				for (k = 0; k < 68; ++k)
 				{
-					if (m_meshes[i].skin[j].name[k] > 32 && 
+					if (m_meshes[i].skin[j].name[k] > 32 &&
 						 m_meshes[i].skin[j].name[k] < 127)
 					{
 						printf("%c", m_meshes[i].skin[j].name[k]);
 				printf("'\n");
 			}
 
-			printDebug("load", "mesh[%i].skin[%i].name = '%s'\n", 
+			printDebug("load", "mesh[%i].skin[%i].name = '%s'\n",
 					 i, j, m_meshes[i].skin[j].name);
 		}
 
 		// Start triangles ////////////////////////
 		if (m_surfaces_start+m_meshes[i].tris_offset != ftell(f))
 		{
-			printWarning("load", "mesh[%i] tris offset %i != file pos %lu\n", i, 
+			printWarning("load", "mesh[%i] tris offset %i != file pos %lu\n", i,
 							 m_surfaces_start+m_meshes[i].tris_offset, ftell(f));
-      
+
 			fseek(f, m_surfaces_start+m_meshes[i].tris_offset, SEEK_SET);
 			printWarning("load", "HANDLE: File position set to %lu\n", ftell(f));
 		}
 		// Start texels /////////////////////
 		if (m_surfaces_start+m_meshes[i].texel_offset != ftell(f))
 		{
-			printWarning("load", "mesh[%i] texel offset %i != file pos %lu\n", i, 
+			printWarning("load", "mesh[%i] texel offset %i != file pos %lu\n", i,
 							 m_surfaces_start+m_meshes[i].texel_offset, ftell(f));
-      
+
 			fseek(f, m_surfaces_start+m_meshes[i].texel_offset, SEEK_SET);
 			printWarning("load", "HANDLE: File position set to %lu\n", ftell(f));
 		}
 		// Start vertices /////////////////////
 		if (m_surfaces_start+m_meshes[i].vertex_offset != ftell(f))
 		{
-			printWarning("load", "mesh[%i] vertex offset %i != file pos %lu\n", 
+			printWarning("load", "mesh[%i] vertex offset %i != file pos %lu\n",
 							 i, m_surfaces_start+m_meshes[i].vertex_offset, ftell(f));
-      
+
 			fseek(f, m_surfaces_start+m_meshes[i].vertex_offset, SEEK_SET);
 			printWarning("load", "HANDLE: File position set to %lu\n", ftell(f));
 		}
 
 		// Should be num_vertices * num_frames??
-		m_meshes[i].vertex = 
+		m_meshes[i].vertex =
       new md3_vertex_t[m_meshes[i].num_vertices * m_meshes[i].num_frames];
 
 		for (j = 0; j < m_meshes[i].num_vertices * m_meshes[i].num_frames; ++j)
 				normal = (unsigned short)m_meshes[i].vertex[j].st;
 				lat = (unsigned char)((normal & 255) * (2 * M_PI) / 255.0);
 				lng = (unsigned char)(((normal >> 8) & 255) * (2 * M_PI) / 255.0);
-				
+
 				m_meshes[i].vertex[j].norm[0] = cos(lat) * sin(lng);
 				m_meshes[i].vertex[j].norm[1] = sin(lat) * sin(lng);
 				m_meshes[i].vertex[j].norm[2] = cos(lng);
 
-				printDebug("load", "%f %f %f\n", 
+				printDebug("load", "%f %f %f\n",
 							  m_meshes[i].vertex[j].norm[0],
 							  m_meshes[i].vertex[j].norm[1],
 							  m_meshes[i].vertex[j].norm[2]);
 		// Start next surface/mesh /////////////////////
 		if (m_surfaces_start+m_meshes[i].mesh_size != ftell(f))
 		{
-			printWarning("load", "_mesh[%i] next mesh offset %i != file pos %lu\n", 
+			printWarning("load", "_mesh[%i] next mesh offset %i != file pos %lu\n",
 						  i, m_surfaces_start+m_meshes[i].mesh_size, ftell(f));
-      
+
 			fseek(f, m_surfaces_start+m_meshes[i].mesh_size, SEEK_SET);
 			printWarning("load", "HANDLE: File position set to %lu\n", ftell(f));
 		}
   FILE *f;
   int i, ii, tmp, hms;
   int32_t si;
-  
 
-  if ((!m_tags && m_num_tags) || (!m_bones && m_num_bones) || 
+
+  if ((!m_tags && m_num_tags) || (!m_bones && m_num_bones) ||
 		(!m_meshes && m_num_meshes))
   {
     printError("save", "invalid md3\n");
   si = m_id;
   fwrite(&si, 4, 1, f);
   printDebug("save", "id = 0x%x\n", m_id);
-  
+
   m_version = MD3_ALIAS_VERSION;
 
   fwrite(&m_version, 4, 1, f);
   // store file postiion for now
   m_file_size = ftell(f);
   fwrite(&m_file_size, 4, 1, f);
- 
+
   // End Header //////////////////
   tmp = m_header_length;
   m_header_length = ftell(f);
 
 #ifdef TEST_MD3
       printf("Viewing full skin buffer:\n'");
-		
+
       for (int foo = 0; foo < 68; ++foo)
 	printf("%c", m_meshes[i].skin[ii].name[foo]);
 
       printf("'\n");
 #endif
 
-      printDebug("save", "_mesh[%i].skin[%i].name = '%s'\n", 
+      printDebug("save", "_mesh[%i].skin[%i].name = '%s'\n",
 	     i, ii, m_meshes[i].skin[ii].name);
     }
 
     m_meshes[i].tris_offset = tmp - hms;
     fwrite(&m_meshes[i].tris_offset, 4, 1, f);
     printDebug("save", "_mesh[%i].tris_offset = %i\n",i,m_meshes[i].tris_offset);
-    fseek(f, tmp, SEEK_SET);   
+    fseek(f, tmp, SEEK_SET);
 
     for(ii = 0; ii < m_meshes[i].num_triangles; ++ii)
     {
     fwrite(&m_meshes[i].texel_offset, 4, 1, f);
     printDebug("save", "_mesh[%i].texel_offset = %i\n",
 	   i,m_meshes[i].texel_offset);
-    fseek(f, tmp, SEEK_SET);   
+    fseek(f, tmp, SEEK_SET);
 
     for(ii = 0; ii < m_meshes[i].num_vertices; ++ii)
     {
     fwrite(&m_meshes[i].vertex_offset, 4, 1, f);
     printDebug("save", "_mesh[%i]._vertexoffset = %i\n",
 	   i,m_meshes[i].vertex_offset);
-    fseek(f, tmp, SEEK_SET);  
+    fseek(f, tmp, SEEK_SET);
 
     // Should be num_vertices * num_frames??
     for(ii = 0; ii < m_meshes[i].num_vertices * m_meshes[i].num_frames; ++ii)
 	m_meshes = new md3_mesh_t[num];
 
 	texTest = new int[num];
-	memset(texTest, 0, num*4);	
+	memset(texTest, 0, num*4);
 }
 
 
 
 
 	printf("[MD3 class test]\n");
-	
+
 	md3.setDebug(2);
 
 	if (argc > 2)
 		}
 		else
 		{
-			printf("\n\n%s [save | load | test] filename.md3 [testout.md3]\n", 
+			printf("\n\n%s [save | load | test] filename.md3 [testout.md3]\n",
 					 argv[0]);
 		}
 	}
 	else
 	{
-		printf("\n\n%s [save | load | test] filename.md3 [testout.md3]\n", 
+		printf("\n\n%s [save | load | test] filename.md3 [testout.md3]\n",
 				 argv[0]);
 	}
 }

src/Md3AnimModel.cpp

 /* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
 /*================================================================
- * 
+ *
  * Project : Freyja
  * Author  : Terry 'Mongoose' Hendrix II
  * Website : http://www.westga.edu/~stu7440/
  * Comments: Md3 animation model class
  *
  *
- *           This file was generated using Mongoose's C++ 
+ *           This file was generated using Mongoose's C++
  *           template generator script.  <stu7440@westga.edu>
- * 
- *-- History ------------------------------------------------- 
+ *
+ *-- History -------------------------------------------------
  *
  * 2002.06.19:
  * Mongoose - Created
 #include <ctype.h>
 
 #ifdef USING_OPENGL
-#   include <GL/gl.h>
+#ifdef __APPLE__
+#include <OpenGL/gl.h>
+#else
+#include <GL/gl.h>
+#endif
 #endif
 
-#include <hel/math.h>
-#include <hel/Quaternion.h>
+#include "hel/math.h"
+#include "hel/Quaternion.h"
 #include "Md3AnimModel.h"
 
 
 }
 
 
-// Mongoose 2002.06.29, FIXME: Add handler here to avoid 
+// Mongoose 2002.06.29, FIXME: Add handler here to avoid
 //   using animations not loaded
 void Md3AnimModel::setAnimUpper(md3_animation_id_t anim)
 {
 }
 
 
-// Mongoose 2002.06.29, FIXME: Add handler here to avoid 
+// Mongoose 2002.06.29, FIXME: Add handler here to avoid
 //   using animations not loaded
 void Md3AnimModel::setAnimLower(md3_animation_id_t anim)
 {
 					firstFrame = atoi(buffer);
 					++state;
 					i = 0;
-					break; 
+					break;
 				case 1:
 					numFrames = atoi(buffer);
 					++state;
 					i = 0;
-					break; 
+					break;
 				case 2:
 					loopingFrames = atoi(buffer);
 					++state;
 					i = 0;
-					break; 
+					break;
 				case 3:
 					framesPerSecond = atoi(buffer);
 					state = 4; // override comment buffer block
 					i = 0;
-					break; 
+					break;
 				}
 			}
 			break;
 			{
 				for (j = 0; j < i; ++j)
 				{
-					if (!isdigit(buffer[j]) && !isupper(buffer[j]) && 
+					if (!isdigit(buffer[j]) && !isupper(buffer[j]) &&
 						 buffer[j] != '_')
 					{
 						printf("WARNING: Stripping '%s'.\n", buffer);
 						j = i;
 					}
 				}
-				
+
 				i = 0;
 			}
 			else
 
 				if (m_debug > 0)
 				{
-					printf("<%s> %3i %3i %3i %3i \t'%s' \t(%i)\n", 
+					printf("<%s> %3i %3i %3i %3i \t'%s' \t(%i)\n",
 							 (id == UNSUPPORTED) ? "Unsupported" : "",
-							 firstFrame, numFrames, 
+							 firstFrame, numFrames,
 							 loopingFrames, framesPerSecond, buffer, id);
 				}
 
-				addAnim(buffer, id, firstFrame, numFrames, 
+				addAnim(buffer, id, firstFrame, numFrames,
 								loopingFrames, framesPerSecond);
 
 				i = 0;
 			}
 			else if (strncmp("TORSO_", buffer, 6) == 0)
-			{				
+			{
 				if (strncmp("TORSO_GESTURE\0", buffer, 14) == 0)
 				{
 					id = TORSO_GESTURE;
 				{
 					id = UNSUPPORTED;
 				}
-			
+
 				if (m_debug > 0)
 				{
-					printf("<%s> %3i %3i %3i %3i \t'%s' (%i)\n", 
+					printf("<%s> %3i %3i %3i %3i \t'%s' (%i)\n",
 							 (id == UNSUPPORTED) ? "Unsupported" : "",
-							 firstFrame, numFrames, 
+							 firstFrame, numFrames,
 							 loopingFrames, framesPerSecond, buffer, id);
 				}
 
 				if (id != UNSUPPORTED)
 				{
-					addAnim(buffer, id, firstFrame, numFrames, 
+					addAnim(buffer, id, firstFrame, numFrames,
 							  loopingFrames, framesPerSecond);
 				}
 
 				i = 0;
 			}
 			else if (strncmp("LEGS_", buffer, 5) == 0)
-			{				
+			{
 				if (strncmp("LEGS_WALKCR\0", buffer, 12) == 0)
 				{
 					id = LEGS_WALKCR;
 				else if (strncmp("LEGS_WALK\0", buffer, 10) == 0)
 				{
 					id = LEGS_WALK;
-				}	
+				}
 				else if (strncmp("LEGS_RUN\0", buffer, 9) == 0)
 				{
 					id = LEGS_RUN;
-				}	
+				}
 				else if (strncmp("LEGS_BACK\0", buffer, 10) == 0)
 				{
 					id = LEGS_BACK;
-				}	
+				}
 				else if (strncmp("LEGS_SWIM\0", buffer, 10) == 0)
 				{
 					id = LEGS_SWIM;
-				}	
+				}
 				else if (strncmp("LEGS_JUMPB\0", buffer, 11) == 0)
 				{
 					id = LEGS_JUMPB;
-				}	
+				}
 				else if (strncmp("LEGS_LANDB\0", buffer, 11) == 0)
 				{
 					id = LEGS_LANDB;
-				}	
+				}
 				else if (strncmp("LEGS_IDLECR\0", buffer, 12) == 0)
 				{
 					id = LEGS_IDLECR;
-				}	
+				}
 				else if (strncmp("LEGS_JUMP\0", buffer, 10) == 0)
 				{
 					id = LEGS_JUMP;
-				}	
+				}
 				else if (strncmp("LEGS_LAND\0", buffer, 10) == 0)
 				{
 					id = LEGS_LAND;
-				}	
+				}
 				else if (strncmp("LEGS_IDLE\0", buffer, 10) == 0)
 				{
 					id = LEGS_IDLE;
-				}	
+				}
 				else if (strncmp("LEGS_TURN\0", buffer, 10) == 0)
 				{
 					id = LEGS_TURN;
 				else
 				{
 					id = UNSUPPORTED;
-				}	
+				}
 
 				if (m_debug > 0)
 				{
-					printf("<%s> %3i %3i %3i %3i \t'%s' (%i)\n", 
+					printf("<%s> %3i %3i %3i %3i \t'%s' (%i)\n",
 							 (id == UNSUPPORTED) ? "Unsupported" : "",
-							 firstFrame, numFrames, 
+							 firstFrame, numFrames,
 							 loopingFrames, framesPerSecond, buffer, id);
 				}
 
 				if (id != UNSUPPORTED)
 				{
-					addAnim(buffer, id, firstFrame, numFrames, 
+					addAnim(buffer, id, firstFrame, numFrames,
 							  loopingFrames, framesPerSecond);
 				}
 
 			else if (strncmp("sexf", buffer, 4) == 0)
 			{
 				m_sex = MD3_SEX_FEMALE;
-				
+
 				if (m_debug > 0)
 				{
 					printf("<> sex = female\n");
 ////////////////////////////////////////////////////////////
 
 void Md3AnimModel::setCurrentTime(Md3 &model)
-{ 
+{
 	int animationSpeed;
 	float elapsedTime = 0.0f;
 	float time, t;
 
-	
+
 	// No animations in this model
 	if (model.numAnimations == 0)
 	{
 	// Tells out far from the current key frame to the next key frame.
 	t = (elapsedTime / (1000.0f / animationSpeed));
 
-	//printf("t = %f, et = %f, lt = %f, fps = %i\n", 
+	//printf("t = %f, et = %f, lt = %f, fps = %i\n",
 	//		 t, elapsedTime, model.lastTime, animationSpeed);
 
-	// If our elapsed time goes over the desired time segment, start over 
+	// If our elapsed time goes over the desired time segment, start over
 	// and go to the next key frame.
 	if (elapsedTime >= (1000.0f / animationSpeed))
 	{
 	model.nextFrame = (model.currentFrame + 1) % endFrame;
 
 	// Wrap to first frame if past last
-	if (model.nextFrame == 0) 
+	if (model.nextFrame == 0)
 	{
 		model.nextFrame = startFrame;
 	}
-	
+
 	// Set interpolating time 0.0 - 1.0 ( start to end of animation)
 	setCurrentTime(model);
 }
 
 
 int Md3AnimModel::addAnim(char *modelPath, md3_animation_id_t id,
-								  unsigned int firstFrame, 
-								  unsigned int numFrames, 
-								  unsigned int loopingFrames, 
+								  unsigned int firstFrame,
+								  unsigned int numFrames,
+								  unsigned int loopingFrames,
 								  unsigned int framesPerSecond)
 {
 	if (m_animCount == 30)
 }
 
 
-int Md3AnimModel::loadMd3(Md3 &model, char *base, char *modelPath, char *skin, 
+int Md3AnimModel::loadMd3(Md3 &model, char *base, char *modelPath, char *skin,
 								  md3_lod_t modelLoD)
 {
 	char filename[256];
 	len = strlen(modelPath);
 
 	// Load model with requested LoD
-	snprintf(filename, l, "%s%s%s%s", modelPath, 
-				(modelPath[len-1] == '/') ? "" : "/", 
+	snprintf(filename, l, "%s%s%s%s", modelPath,
+				(modelPath[len-1] == '/') ? "" : "/",
 				base,
-				(modelLoD == MD3_LOD_HIGH) ? ".md3" : 
+				(modelLoD == MD3_LOD_HIGH) ? ".md3" :
 				(modelLoD == MD3_LOD_MED) ? "_1.md3" : "_2.md3");
 
 	model.reset();
 	// Load skin if requested
 	if (skin && skin[0])
 	{
-		snprintf(filename, l, "%s%s%s_%s.skin", modelPath, 
+		snprintf(filename, l, "%s%s%s_%s.skin", modelPath,
 					(modelPath[len-1] == '/') ? "" : "/", base, skin);
 
 		if (loadSkin(model, filename))
 					filename[j] = '/';
 				}
 
-				// Lowercase alphabet MSDOS is case insensitive 
+				// Lowercase alphabet MSDOS is case insensitive
 				// data created with it's skin names are bad
 				if (filename[j] > 64 && filename[j] < 91)
 				{
 		texTest[texNumTest].name_len = len+1;
 		strncpy(texTest[texNumTest].name, texture, len+1);
 		texTest[texNumTest].name[len] = 0;
-				
+
 		id = texNumTest;
-				
+
 		texNumTest++;
 	}
 
 				for (j = 0; j < m; ++j)
 				{
 					if (strncmp(mesh, meshes[j].name, 68) == 0)
-					{				
+					{
 						switch (i)
 						{
 						case 1:
 	if (model.idTest == 4)
 	{
 		m_weapon.texTest[0] = cacheTexture("models/weapons/machinegun/skin2.tga");
-		
+
 		for (i = m_weapon.getNumMeshes() - 1; i > 0; --i)
 		{
 			m_weapon.texTest[i] = m_weapon.texTest[0];
 
 		if (errors < 8)
 		{
-			printf("ERROR: %i. Not all animations loaded %i/24\n", 
+			printf("ERROR: %i. Not all animations loaded %i/24\n",
 					 errors+1, m_animCount);
 			++errors;
 		}
 #ifdef USING_OPENGL
 	unsigned int i, j, k, numBones, numMeshes;
 	unsigned int index, currentIndex, nextIndex, maxIndex;
-	md3_mesh_t *meshes, *mesh;	
+	md3_mesh_t *meshes, *mesh;
 	md3_bone_t *bones, *bone;
 
 
 	numMeshes = model.getNumMeshes();
 	meshes = model.getMeshes();
-	
+
 	if (mFlags & fRenderBones)
 	{
 		numBones = model.getNumBones();
 
 		// Try to avoid bad models/loading taking down the subsystem
 		// and also handle bad data as well as we can
-		if ((int)model.currentFrame >= mesh->num_frames || 
+		if ((int)model.currentFrame >= mesh->num_frames ||
 			 (int)model.nextFrame >= mesh->num_frames)
-		{			
+		{
 			if (mFlags & fRenderingWarnings)
 			{
 				fprintf(stderr, "renderModel> WARNING: Frame index would be out of bounds\n model[%i].mesh[%i], %i out of %i frames\n",
 			{
 				index = mesh->tris[j].triangle[k];
 
-				if (index + nextIndex > maxIndex || 
+				if (index + nextIndex > maxIndex ||
 					 index + currentIndex > maxIndex)
 				{
 					currentIndex = 0;
 				{
 					glTexCoord2fv(mesh->texel[index].st);
 				}
-				
+
 				if (mFlags & fDisableMeshInterpolate)
 				{
 					glVertex3f(mesh->vertex[index + currentIndex].pos[0],
 void renderBone(vec3_t min, vec3_t max, vec3_t center, vec_t scale)
 {
 	glDisable(GL_TEXTURE_2D);
-	
+
 	//scale *= 0.2f;
 
 	glPushMatrix();
 	// min, bottom quad
 	glVertex3f(min[0], min[1], min[2]);
 	glVertex3f(min[0], max[1], min[2]);
-    
+
 	glVertex3f(min[0], min[1], min[2]);
 	glVertex3f(max[0], min[1], min[2]);
 
 
 	glDisable(GL_TEXTURE_2D);
 
-	glPushMatrix();			
+	glPushMatrix();
 	glScalef(100, 100, 100);
 
 	// Draw two long quads that skrink and fade the they go further out
 	glColor4f(0.3-d, 0.1, 0.1, 0.5);
 	glVertex3f(lenght, 0.1, 0.0);
 	glVertex3f(lenght,  0.0, 0.0);
-	
+
 	glColor4f(0.9-d, 0.1, 0.1, 0.5);
 	glVertex3f(start, 0.0, 0.0);
 	glVertex3f(start, 0.0, 0.2);
-	glColor4f(0.3-d, 0.1, 0.1, 0.5);		
+	glColor4f(0.3-d, 0.1, 0.1, 0.5);
 	glVertex3f(lenght, 0.0, 0.1);
 	glVertex3f(lenght, 0.0, 0.0);
-	glEnd();		
+	glEnd();
 
 	glPopMatrix();
 
 	for (i = 0; i < t; ++i)
 	{
 		if (slaves[i] > 0)
-		{	
+		{
 			// Using digiben's tag anim notes
-			// To find the current translation position for 
+			// To find the current translation position for
 			// this frame of animation, we multiply
-			// the currentFrame by the number of tags, 
+			// the currentFrame by the number of tags,
 			// then add i.  This is similar to how
 			// the vertex key frames are interpolated.
 			pos[0] = tags[f*t+i].center[0];
 			pos[1] = tags[f*t+i].center[1];
 			pos[2] = tags[f*t+i].center[2];
-			
+
 			// Grab the next key frame translation position
 			nextPos[0] = tags[nf*t+i].center[0];
 			nextPos[1] = tags[nf*t+i].center[1];
 			nextPos[2] = tags[nf*t+i].center[2];
 
 			// By using the equation: p(t) = p0 + t(p1 - p0), with a time t,
-			// we create a new translation position that 
-			// is closer to the next key frame.			
+			// we create a new translation position that
+			// is closer to the next key frame.
 			pos[0] = pos[0] + time * (nextPos[0] - pos[0]);
 			pos[1] = pos[1] + time * (nextPos[1] - pos[1]);
 			pos[2] = pos[2] + time * (nextPos[2] - pos[2]);
 
-			// Now comes the more complex interpolation.  Just like 
-			// the translation, we want to store the current and 
+			// Now comes the more complex interpolation.  Just like
+			// the translation, we want to store the current and
 			// next key frame rotation matrix, then interpolate
 			// between the 2.
 
-			// Get a pointer to the start of the 3x3 rotation matrix 
+			// Get a pointer to the start of the 3x3 rotation matrix
 			// for the current frame
 			//matrix = &tags[f*t+i].rotation[0][0];
 			convertQuake3ToHelMatrix(tags[f*t+i].rotation, matrix);
 
-			// Get a pointer to the start of the 3x3 rotation matrix 
+			// Get a pointer to the start of the 3x3 rotation matrix
 			// for the next frame
 			//nextMatrix = &tags[nf*t+i].rotation[0][0];
 			convertQuake3ToHelMatrix(tags[nf*t+i].rotation, nextMatrix);
 			q.setByMatrix(matrix);
 			qNext.setByMatrix(nextMatrix);
 
-			// Using spherical linear interpolation, find the 
+			// Using spherical linear interpolation, find the
 			// interpolated quaternion
 			qInterpolate = Quaternion::slerp(q, qNext, time);
 
 			// Here we convert the interpolated quaternion into a matrix
 			qInterpolate.getMatrix(finalMatrix);
-			
+
 			glPushMatrix();
 
 			if (mFlags & fDisableTagInterpolate)
 				//glTranslatef(pos[0]*64, pos[1]*64, pos[2]*64);
 				matrix[12] = pos[0]*scaleHack;
 				matrix[13] = pos[1]*scaleHack;
-				matrix[14] = pos[2]*scaleHack;	
+				matrix[14] = pos[2]*scaleHack;
 				glMultMatrixf(matrix);
 			}
 			else
 				//glTranslatef(pos[0]*64, pos[1]*64, pos[2]*64);
 				finalMatrix[12] = pos[0]*scaleHack;
 				finalMatrix[13] = pos[1]*scaleHack;
-				finalMatrix[14] = pos[2]*scaleHack;	
+				finalMatrix[14] = pos[2]*scaleHack;
 				glMultMatrixf(finalMatrix);
 			}
 
 	snprintf(pathname, 255, "data/models/players/%s", model);
 	pathname[255] = 0;
 
-	if (gMd3.load(pathname, skin, MD3_LOD_HIGH) < 0) 
-	{ 
+	if (gMd3.load(pathname, skin, MD3_LOD_HIGH) < 0)
+	{
 		printf("ERROR: MD3 '%s' not loaded\n", pathname);
-	} 
+	}
 	else
 	{
 		snprintf(pathname, 255, "data/models/weapons2/%s", weapon);
 			printf("Couldn't load weapon model '%s'.\n", pathname);
 		}
 
-		gMd3.setAnimUpper(TORSO_STAND); 
+		gMd3.setAnimUpper(TORSO_STAND);
 		gMd3.setAnimLower(LEGS_IDLE);
 
 		// Setup textures
 		printf("\nLoading textures: ");
-		for (i = 0; i < gMd3.texNumTest; ++i) 
-		{ 
-			snprintf(pathname, 255, "data/%s", gMd3.texTest[i].name); 
+		for (i = 0; i < gMd3.texNumTest; ++i)
+		{
+			snprintf(pathname, 255, "data/%s", gMd3.texTest[i].name);
 			pathname[255] = 0;
 
-			gMd3.texTest[i].gl_texture_id = gTexture.loadTGA(pathname); 
-			
-			if (gMd3.texTest[i].gl_texture_id < 0) 
-			{ 
-				printf("ERROR: Md3 texture '%s' not loaded\n", pathname); 
+			gMd3.texTest[i].gl_texture_id = gTexture.loadTGA(pathname);
+
+			if (gMd3.texTest[i].gl_texture_id < 0)
+			{
+				printf("ERROR: Md3 texture '%s' not loaded\n", pathname);
 			}
-		} 
+		}
 	}
 }
 
 	float x, y, time;
 
 
-	gluLookAt(0.0, 0.0, -256.0, 
-				 0.0, 8.0, 0.0, 
+	gluLookAt(0.0, 0.0, -256.0,
+				 0.0, 8.0, 0.0,
 				 0.0, 1.0, 0.0);
 
 
 		glBegin(GL_LINE_LOOP);
 		for (y = -size; y < size; y += step)
 		{
-			glVertex3f(x + step, 0.0f, y);	
-			glVertex3f(x, 0.0f, y);	
+			glVertex3f(x + step, 0.0f, y);
+			glVertex3f(x, 0.0f, y);
 			glVertex3f(x, 0.0f, y + step);
 			glVertex3f(x + step, 0.0f, y + step);
 		}
 		glEnd();
 	}
 	glPopMatrix();
-	
+
 	// Draw model
 	glEnable(GL_TEXTURE_2D);
 	glColor3f(1.0f, 1.0f, 1.0f);
 	printf("UP/DOWN    - Adjust scene pitch\n");
 	printf("RIGHT/LEFT - Adjust scene yaw\n");
 	printf("----------------------------------\n");
-	printf("1 - Toggle tag interpolating\n");   
+	printf("1 - Toggle tag interpolating\n");
 	printf("2 - Toggle animation\n");
 	printf("3 - Toggle bone rendering\n");
 	printf("4 - Toggle weapon rendering\n");
 	printf("5 - Toggle mesh interpolating\n");
 	printf("6 - Toggle scene rotation\n");
-	printf("7 - Toggle rendering warning reporting\n");      
-	printf("8 - Toggle alpha blending\n");      
+	printf("7 - Toggle rendering warning reporting\n");
+	printf("8 - Toggle alpha blending\n");
 	printf("w - Toggle wireframe rendering\n");
 	printf("[ - Loop through lower animations\n");
 	printf("] - Loop through upper animations\n");
 
 		if (wireframe)
 		{
-			glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); 
+			glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
 		}
 		else
 		{
 	gWidth = width;
 	gHeight = height;
 
-	glViewport(0, 0, width, height); 
+	glViewport(0, 0, width, height);
 
 	glMatrixMode(GL_PROJECTION);
 	glLoadIdentity();
 	gTexture.reset();
 	gTexture.setFlag(Texture::fUseMipmaps);
 	gTexture.setMaxTextureCount(64);
-	
+
 }
 
 
 	  if (SDL_GL_LoadLibrary("libGL.so") < 0)
 	  {
 		  SDL_ClearError();
-    
+
 		  // Fallback 2
 		  if (SDL_GL_LoadLibrary("libGL.so.1") < 0)
 		  {
   gSDLWindow = SDL_SetVideoMode(width, height, 16, flags);
   SDL_WM_SetCaption("Md3AnimModel Test", "Md3AnimModel Test");
   SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
-  
+
   // Init rendering
   init_gl(width, height);
   initScene(argc, argv);
 			  break;
 		  case SDL_MOUSEBUTTONDOWN:
 		  case SDL_MOUSEBUTTONUP:
-			  break;	
+			  break;
 		  case SDL_KEYDOWN:
 			  mkeys = (unsigned int)SDL_GetModState();
 			  mod = 0;
 					  SDL_WM_ToggleFullScreen(gSDLWindow);
 				  }
 			  }
-			  
+
 			  handleKey(key);
 			  break;
 		  case SDL_KEYUP:
 			  break;
-		  case SDL_VIDEORESIZE:			  
+		  case SDL_VIDEORESIZE:
 			  event_resize(event.resize.w, event.resize.h);
 
 			  width = event.resize.w;
 
 	  event_display(width, height);
   }
-  
+
   return 0;
 }
 
 	}
 	else
 	{
-		printf("\n\n%s LoD path skin_name\neg %s 0 /usr/local/games/quake3/qbase3/players/slash/ default [weapon_path weapon_name]\n", 
+		printf("\n\n%s LoD path skin_name\neg %s 0 /usr/local/games/quake3/qbase3/players/slash/ default [weapon_path weapon_name]\n",
 				 argv[0], argv[0]);
 	}
 }

src/OpenGLMesh.cpp

 /* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
 /*================================================================
- * 
+ *
  * Project : OpenRaider
  * Author  : Terry 'Mongoose' Hendrix II
  * Website : http://www.westga.edu/~stu7440/
  * Email   : stu7440@westga.edu
  * Object  : OpenGLMesh
  * License : No use w/o permission (C) 2002 Mongoose
- * Comments: 
+ * Comments:
  *
  *
- *           This file was generated using Mongoose's C++ 
+ *           This file was generated using Mongoose's C++
  *           template generator script.  <stu7440@westga.edu>
- * 
- *-- History ------------------------------------------------- 
+ *
+ *-- History -------------------------------------------------
  *
  * 2002.08.23:
  * Mongoose - Created
  =================================================================*/
 
+#ifdef __APPLE__
+#include <OpenGL/gl.h>
+#else
 #include <GL/gl.h>
+#endif
 #include "OpenGLMesh.h"
 
 
 	{
 		delete [] mVertices;
 	}
-	
+
 	if (mNormals)
 	{
 		delete [] mNormals;
 	}
-	
+
 	if (mColors)
 	{
 		delete [] mColors;
 
 		delete [] mTris;
 	}
-	
+
 	if (mQuads)
-	{	
+	{
 		for (i = 0; i < mNumQuads; ++i)
 		{
 			if (mQuads[i].quads)
 
 		glBegin(GL_QUADS);
 
-		for (j = 0; j < mQuads[i].num_alpha_quads; ++j) 
+		for (j = 0; j < mQuads[i].num_alpha_quads; ++j)
 		{
 			for (k = 0; k < 4; ++k)
-			{							
+			{
 				index = mQuads[i].alpha_quads[j*4+k];
-				
+
 				glTexCoord2fv(mQuads[i].texcoors2[j*4+k]);
 				glColor4fv(mColors[index]);
 				glVertex3fv(mVertices[index]);
 
 		glBegin(GL_TRIANGLES);
 
-		for (j = 0; j < mTris[i].num_alpha_triangles; ++j) 
+		for (j = 0; j < mTris[i].num_alpha_triangles; ++j)
 		{
 			for (k = 0; k < 3; ++k)
 			{
 				index = mTris[i].alpha_triangles[j*3+k];
-				
+
 				glTexCoord2fv(mTris[i].texcoors2[j*3+k]);
 				glColor4fv(mColors[index]);
 				glVertex3fv(mVertices[index]);
 
 		return; // FIXME
 
-		for (j = 0; j < mQuads[i].num_quads; ++j) 
+		for (j = 0; j < mQuads[i].num_quads; ++j)
 		{
 			for (k = 0; k < 4; ++k)
-			{							
+			{
 				index = mQuads[i].quads[j*4+k];
-				
+
 				glTexCoord2fv(mQuads[i].texcoors[j*4+k]);
 				glArrayElement(mQuads[i].quads[j*4+k]);
 			}
 
 		glBegin(GL_QUADS);
 
-		for (j = 0; j < mQuads[i].num_quads; ++j) 
+		for (j = 0; j < mQuads[i].num_quads; ++j)
 		{
 			for (k = 0; k < 4; ++k)
-			{							
+			{
 				index = mQuads[i].quads[j*4+k];
-					
+
 				glColor4fv(mColors[index]);
 
 #ifdef MULTITEXTURE
 				if (mMode == OpenGLMeshModeMultiTexture)
 				{
-					glMultiTexCoord2fvARB(GL_TEXTURE0_ARB, 
+					glMultiTexCoord2fvARB(GL_TEXTURE0_ARB,
 												 mQuads[i].texcoors[j*4+k]);
-					glMultiTexCoord2fvARB(GL_TEXTURE1_ARB, 
+					glMultiTexCoord2fvARB(GL_TEXTURE1_ARB,
 												 mQuads[i].texcoors[j*4+k]);
 				}
 				else
 
 		glBegin(GL_TRIANGLES);
 
-		for (j = 0; j < mTris[i].num_triangles; ++j) 
+		for (j = 0; j < mTris[i].num_triangles; ++j)
 		{
 			for (k = 0; k < 3; ++k)
 			{
 #ifdef MULTITEXTURE
 				if (mMode == OpenGLMeshModeMultiTexture)
 				{
-					glMultiTexCoord2fvARB(GL_TEXTURE0_ARB, 
+					glMultiTexCoord2fvARB(GL_TEXTURE0_ARB,
 												 mTris[i].texcoors[j*3+k]);
-					glMultiTexCoord2fvARB(GL_TEXTURE1_ARB, 
+					glMultiTexCoord2fvARB(GL_TEXTURE1_ARB,
 												 mTris[i].texcoors[j*3+k]);
 				}
 				else
 		mNumColors = 0;
 		delete [] mColors;
 	}
-	
+
 	if (!colorCount)
 	{
 		return;
 	}
-	
+
 		//mColorWidth = colorWidth;  // for now assume 4 always
 	mNumColors = colorCount;
-	mColorArray = colors; 
+	mColorArray = colors;
 }
 
 
 		mNumNormals = 0;
 		delete [] mNormals;
 	}
-	
+
 	if (!normalCount)
 	{
 		return;
 	}
-	
+
 	mNumNormals = normalCount;
 	mNormalArray = normals;
 }
 
 
-void OpenGLMesh::bufferTriangles(unsigned int count, 
-											unsigned int *indices, vec_t *texCoords, 
+void OpenGLMesh::bufferTriangles(unsigned int count,
+											unsigned int *indices, vec_t *texCoords,
 											int *textures, unsigned int *flags)
 {
-	
+
 	mTriangleCount = count;
 	mTriangleTextures = textures;
 	mTriangleIndices = indices;
 		mNumVertices = 0;
 		delete [] mVertices;
 	}
-	
+
 	if (!vertexCount)
 	{
 		return;
 	}
-	
+
 	mNumVertices = vertexCount;
-	mVertexArray = vertices; 
+	mVertexArray = vertices;
 	mFlags |= fOpenGLMesh_UseVertexArray;
 }
 
 
-void OpenGLMesh::setColor(unsigned int index, 
+void OpenGLMesh::setColor(unsigned int index,
 								  float r, float g, float b, float a)
 {
 	if (index > mNumColors)
 	{
 		return;
 	}
-	
+
 	mColors[index][0] = r;
 	mColors[index][1] = g;
 	mColors[index][2] = b;
 	{
 		return;
 	}
-	
+
 	mColors[index][0] = rgba[0];
 	mColors[index][1] = rgba[1];
 	mColors[index][2] = rgba[2];
 	{
 		return;
 	}
-	
+
 	mNormals[index][0] = i;
 	mNormals[index][1] = j;
 	mNormals[index][2] = k;
 	{
 		return;
 	}
-	
+
 	mVertices[index][0] = x;
 	mVertices[index][1] = y;
 	mVertices[index][2] = z;

src/OpenGLMesh.h

 /* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
 /*================================================================
- * 
+ *
  * Project : OpenRaider
  * Author  : Terry 'Mongoose' Hendrix II
  * Website : http://www.westga.edu/~stu7440/
  * Email   : stu7440@westga.edu
  * Object  : OpenGLMesh
  * License : No use w/o permission (C) 2002 Mongoose
- * Comments: 
+ * Comments:
  *
  *
- *           This file was generated using Mongoose's C++ 
+ *           This file was generated using Mongoose's C++
  *           template generator script.  <stu7440@westga.edu>
- * 
+ *
  *-- Test Defines -----------------------------------------------
- *           
- * UNIT_TEST_OPENGLMESH - Builds OpenGLMesh class as a console unit test 
  *
- *-- History ------------------------------------------------ 
+ * UNIT_TEST_OPENGLMESH - Builds OpenGLMesh class as a console unit test
+ *
+ *-- History ------------------------------------------------
  *
  * 2002.08.23:
  * Mongoose - Created
 #ifndef GUARD__OPENRAIDER_MONGOOSE_OPENGLMESH_H_
 #define GUARD__OPENRAIDER_MONGOOSE_OPENGLMESH_H_
 
-#include <hel/math.h>
+#include "hel/math.h"
 
 // TODO: Unify the parallel systems here, arrays and the allocate/set
 
 {
 	OpenGLMeshModeSolid          = 0,
 	OpenGLMeshModeWireframe      = 1,
-	OpenGLMeshModeTexture        = 2,	
+	OpenGLMeshModeTexture        = 2,
 	OpenGLMeshModeMultiTexture   = 3
 
 } OpenGLMeshMode;
 	unsigned int cnum_alpha_triangles;
 
 	unsigned int num_texcoors;
-	vec2_t *texcoors; 
+	vec2_t *texcoors;
 
 	unsigned int num_texcoors2;
-	vec2_t *texcoors2; 
+	vec2_t *texcoors2;
 
 	// Arrays of triangle indices sorted by texture
 	unsigned int num_triangles;
 
 	// Arrays of alpha triangle indices sorted by texture
 	unsigned int num_alpha_triangles;
-	unsigned int *alpha_triangles; // ABCABCABC... 
+	unsigned int *alpha_triangles; // ABCABCABC...
 
 } tris_t;
 
 	unsigned int cnum_alpha_quads;
 
 	unsigned int num_texcoors;
-	vec2_t *texcoors; 
+	vec2_t *texcoors;
 
 	unsigned int num_texcoors2;
-	vec2_t *texcoors2; 
+	vec2_t *texcoors2;
 
 	// Arrays of rectangle indices sorted by texture
 	unsigned int num_quads;
 
 	OpenGLMesh();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Constructs an object of OpenGLMesh
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.08.23: 
+	 * 2002.08.23:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.08.23: 
+	 * 2002.08.23:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 
 	void drawAlpha();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Render alpha polygons
 	 *
 	 *-- History ------------------------------------------
 
 	void drawSolid();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Render solid polygons
 	 *
 	 *-- History ------------------------------------------
 
 	void allocateColors(unsigned int n);
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
 
 	void allocateNormals(unsigned int n);
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
 
 	void allocateRectangles(unsigned int n);
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
 
 	void allocateTriangles(unsigned int n);
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
 
 	void allocateVertices(unsigned int n);
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
 	void bufferColorArray(unsigned int colorCount, vec_t *colors,
 								 unsigned int colorWidth);
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
 
 	void bufferNormalArray(unsigned int normalCount, vec_t *normals);
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
-	void bufferTriangles(unsigned int count, 
-								unsigned int *indices, vec_t *texCoords, 
+	void bufferTriangles(unsigned int count,
+								unsigned int *indices, vec_t *texCoords,
 								int *textures, unsigned int *flags);
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
 
 	void bufferVertexArray(unsigned int vertexCount, vec_t *vertices);
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
 
 	void setColor(unsigned int index, float r, float g, float b, float a);
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
 
 	void setColor(unsigned int index, float rgba[4]);
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
 
 	void setNormal(unsigned int index, float i, float j, float k);
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
 
 	void setVertex(unsigned int index, float x, float y, float z);
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
 #ifdef NOT_IMPLEMENTED
 	void sortFacesByTexture();
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
 	void addFace(int textureIndex, int textureIndexB, unsigned int flags,
 					 unsigned int vertexIndexCount, vec_t *vertexIndices);
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
-	void addTexTiledFace(int textureIndex, int textureIndexB, 
-								unsigned int flags, unsigned int indexCount, 
+	void addTexTiledFace(int textureIndex, int textureIndexB,
+								unsigned int flags, unsigned int indexCount,
 								vec_t *vertexIndices, vec_t *texcoords);
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
 
 	void bufferTexcoords(unsigned int texcoordCount, vec_t *texcoords);
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
 
 	void duplicateArraysForTexTiledTexcoords();
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
 	unsigned int mNumQuads;
 	rect_t *mQuads;
 
-	
+
 	unsigned int mTriangleCount;
 	int *mTriangleTextures;
 	unsigned int *mTriangleIndices;

src/OpenRaider.h

 /* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
 /*================================================================
- * 
+ *
  * Project : OpenRaider
  * Author  : Mongoose
  * Website : http://www.westga.edu/~stu7440/
  * Comments: This is the main class for OpenRaider
  *
  *
- *           This file was generated using Mongoose's C++ 
+ *           This file was generated using Mongoose's C++
  *           template generator script.  <stu7440@westga.edu>
- * 
- *-- History ------------------------------------------------ 
+ *
+ *-- History ------------------------------------------------
  *
  * 2002.08.24:
  * Mongoose - Finally made into Singleton
 #define GUARD__OPENRAIDER_MONGOOSE_OPENRAIDER_H_
 
 
-#include <mstl/List.h>
-#include <mstl/Map.h>
-#include <mstl/Vector.h>
+#include "mstl/List.h"
+#include "mstl/Map.h"
+#include "mstl/Vector.h"
 #include "TombRaider.h"
 #include "Camera.h"
 #include "Render.h"
 
 	static OpenRaider *Instance();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Constructs the object of OpenRaider or
 	 *        returns pointer to it if previously allocated
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2001.08.24: 
+	 * 2001.08.24:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2001.05.21: 
+	 * 2001.05.21:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 
 	void start();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Init the Game
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2001.05.21: 
+	 * 2001.05.21:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	void handleMouseMotionEvent(float x, float y);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Mouse motion input used
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2001.06.04: 
+	 * 2001.06.04:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	/*------------------------------------------------------
 	 * Pre  : <Key> is a valid keyboard code
 	 *
-	 * Post : Recieves <Event> bound to <Cmd> from <Key> press 
+	 * Post : Recieves <Event> bound to <Cmd> from <Key> press
 	 *
 	 *-- History ------------------------------------------
 	 *
 
 	 void handleCommand(char *command, unsigned int mode);
 	/*------------------------------------------------------
-	 * Pre  : <Command> is valid keyword optionally followed 
+	 * Pre  : <Command> is valid keyword optionally followed
 	 *        by ' ' (space) seperated and argument(s)
 	 *
 	 *        <Mode> is the current type or resource mode
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2001.05.27: 
+	 * 2001.05.27:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	void initGL();
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
 
 	void gameFrame();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : One game physics/time frame passes
 	 *        Also renders one frame per call
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2001.05.21: 
+	 * 2001.05.21:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 
 	OpenRaider();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Constructs an object of OpenRaider
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2001.05.21: 
+	 * 2001.05.21:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 
 	void consoleCommand(char *cmd);
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * ????.??.??: 
+	 * ????.??.??:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	void soundEvent(int type, int id, vec3_t pos, vec3_t angles);
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.06.16: 
+	 * 2002.06.16:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 //	void entityEvent(entity_t &e, RaiderEvent event);
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.06.16: 
+	 * 2002.06.16:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	void processPakSounds();
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2001.06.04: 
+	 * 2001.06.04:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2001.06.04: 
+	 * 2001.06.04:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	void initTextures();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Generates all textures or mipmaps
 	 *        needed for fonts, splash, ext particles
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2001.05.28: 
+	 * 2001.05.28:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	void processTextures();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Generates tombraider textures or mipmaps
 	 *        needed for sprites, rooms, and models
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2001.05.28: 
+	 * 2001.05.28:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	void processSprites();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Generates render sprite sequences
 	 *
 	 *-- History ------------------------------------------
 	 * 2001.06.06:
 	 * Mongoose - All new functionality
 	 *
-	 * 2001.05.28: 
+	 * 2001.05.28:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
-	
+
 	void processMoveables();
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2001.06.08: 
+	 * 2001.06.08:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
-	
+
 	void processMoveable(int index, int i, int *ent, List <skeletal_model_t *> &cache2, List <unsigned int> &cache, int object_id);
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.04.06: 
+	 * 2002.04.06:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2001.05.26: 
+	 * 2001.05.26:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2001.05.21: 
+	 * 2001.05.21:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
-	
+
 	void loadLevel(char *filename);
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : Loads validated level pak from diskfile 
+	 * Pre  :
+	 * Post : Loads validated level pak from diskfile
 	 *        using maplist
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2001.05.21: 
+	 * 2001.05.21:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 
 	// Game vars //////////////
 
-	Vector <char *> mMusicList;  /* List of game level music */ 
+	Vector <char *> mMusicList;  /* List of game level music */
+
+	Vector <char *> mMapList;    /* List of game maps */
 
-	Vector <char *> mMapList;    /* List of game maps */ 
-	
 	char m_mapName[32];          /* Current map filename */
 
 	char *m_pakDir;              /* Current pak directory */

src/PSKModel.cpp

 /* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
 /*================================================================
- * 
+ *
  * Project : Freyja
  * Author  : Terry 'Mongoose' Hendrix II
  * Website : http://www.westga.edu/~stu7440/
  * Comments: Unreal Tournament skeletal model
  *
  *
- *           This file was generated using Mongoose's C++ 
+ *           This file was generated using Mongoose's C++
  *           template generator script.  <stu7440@westga.edu>
- * 
- *-- History ------------------------------------------------- 
+ *
+ *-- History -------------------------------------------------
  *
  * 2003.07.12:
  * Mongoose - UT Package prototype code moved into 'UTPackage'
  *
  * 2003.01.20:
  * Mongoose - Fixed triangle rendering thanks to debugging by
- *            Steven Fuller, who found the tris -> UV -> vert 
+ *            Steven Fuller, who found the tris -> UV -> vert
  *            connection
  *
- *            Finished up basic rendering, lots of 
+ *            Finished up basic rendering, lots of
  *            small fixes/features
  *
  * 2003.01.06:
 #include <math.h>
 
 #ifdef USING_OPENGL
-#   include <GL/gl.h>
-#   include <GL/glu.h>
+#ifdef __APPLE__
+#include <OpenGL/gl.h>
+#include <OpenGL/glu.h>
+#else
+#include <GL/gl.h>
+#include <GL/glu.h>
+#endif
 #endif
 
 #include "UTPackage.h"
 	result[ 1] = a[ 0] * b[ 4] + a[ 4] * b[ 5] + a[ 8] * b[ 6] + a[12] * b[ 7];
 	result[ 2] = a[ 0] * b[ 8] + a[ 4] * b[ 9] + a[ 8] * b[10] + a[12] * b[11];
 	result[ 3] = a[ 0] * b[12] + a[ 4] * b[13] + a[ 8] * b[14] + a[12] * b[15];
-	
+
 	result[ 4] = a[ 1] * b[ 0] + a[ 5] * b[ 1] + a[ 9] * b[ 2] + a[13] * b[ 3];
 	result[ 5] = a[ 1] * b[ 4] + a[ 5] * b[ 5] + a[ 9] * b[ 6] + a[13] * b[ 7];
 	result[ 6] = a[ 1] * b[ 8] + a[ 5] * b[ 9] + a[ 9] * b[10] + a[13] * b[11];
 	result[ 7] = a[ 1] * b[12] + a[ 5] * b[13] + a[ 9] * b[14] + a[13] * b[15];
-	
+
 	result[ 8] = a[ 2] * b[ 0] + a[ 6] * b[ 1] + a[10] * b[ 2] + a[14] * b[ 3];
 	result[ 9] = a[ 2] * b[ 4] + a[ 6] * b[ 5] + a[10] * b[ 6] + a[14] * b[ 7];
 	result[10] = a[ 2] * b[ 8] + a[ 6] * b[ 9] + a[10] * b[10] + a[14] * b[11];
 	result[11] = a[ 2] * b[12] + a[ 6] * b[13] + a[10] * b[14] + a[14] * b[15];
-	
+
 	result[12] = a[ 3] * b[ 0] + a[ 7] * b[ 1] + a[11] * b[ 2] + a[15] * b[ 3];
 	result[13] = a[ 3] * b[ 4] + a[ 7] * b[ 5] + a[11] * b[ 6] + a[15] * b[ 7];
 	result[14] = a[ 3] * b[ 8] + a[ 7] * b[ 9] + a[11] * b[10] + a[15] * b[11];
    tmat[12]=tx; tmat[13]=ty; tmat[14]=tz; tmat[15]=1;
 
 	//copy_matrix(m, tmp);
-	
+
 	for (i = 0; i < 16; ++i)
 		tmp[i] = m[i];
 
 	/* NB. OpenGL Matrices are COLUMN major. */
 #define SWAP_ROWS(a, b) { float *_tmp = a; (a)=(b); (b)=_tmp; }
 #define MAT(m,r,c) (m)[(c)*4+(r)]
-	
+
 	float wtmp[4][8];
 	float m0, m1, m2, m3, s;
 	float *r0, *r1, *r2, *r3;
-	
+
 	r0 = wtmp[0], r1 = wtmp[1], r2 = wtmp[2], r3 = wtmp[3];
-	
+
 	r0[0] = MAT(m,0,0), r0[1] = MAT(m,0,1),
 	r0[2] = MAT(m,0,2), r0[3] = MAT(m,0,3),
 	r0[4] = 1.0, r0[5] = r0[6] = r0[7] = 0.0,
-	
+
 	r1[0] = MAT(m,1,0), r1[1] = MAT(m,1,1),
 	r1[2] = MAT(m,1,2), r1[3] = MAT(m,1,3),
 	r1[5] = 1.0, r1[4] = r1[6] = r1[7] = 0.0,
-	
+
 	r2[0] = MAT(m,2,0), r2[1] = MAT(m,2,1),
 	r2[2] = MAT(m,2,2), r2[3] = MAT(m,2,3),
 	r2[6] = 1.0, r2[4] = r2[5] = r2[7] = 0.0,
-	
+
 	r3[0] = MAT(m,3,0), r3[1] = MAT(m,3,1),
 	r3[2] = MAT(m,3,2), r3[3] = MAT(m,3,3),
 	r3[7] = 1.0, r3[4] = r3[5] = r3[6] = 0.0;
 	if (fabs(r2[0])>fabs(r1[0])) SWAP_ROWS(r2, r1);
 	if (fabs(r1[0])>fabs(r0[0])) SWAP_ROWS(r1, r0);
 	if (0.0 == r0[0])  return false;
-	
+
 	/* eliminate first variable     */
 	m1 = r1[0]/r0[0]; m2 = r2[0]/r0[0]; m3 = r3[0]/r0[0];
 	s = r0[1]; r1[1] -= m1 * s; r2[1] -= m2 * s; r3[1] -= m3 * s;
 	if (s != 0.0) { r1[6] -= m1 * s; r2[6] -= m2 * s; r3[6] -= m3 * s; }
 	s = r0[7];
 	if (s != 0.0) { r1[7] -= m1 * s; r2[7] -= m2 * s; r3[7] -= m3 * s; }
-	
+
 	/* choose pivot - or die */
 	if (fabs(r3[1])>fabs(r2[1])) SWAP_ROWS(r3, r2);
 	if (fabs(r2[1])>fabs(r1[1])) SWAP_ROWS(r2, r1);
 	if (0.0 == r1[1])  return false;
-	
+
 	/* eliminate second variable */
 	m2 = r2[1]/r1[1]; m3 = r3[1]/r1[1];
 	r2[2] -= m2 * r1[2]; r3[2] -= m3 * r1[2];
 	s = r1[5]; if (0.0 != s) { r2[5] -= m2 * s; r3[5] -= m3 * s; }
 	s = r1[6]; if (0.0 != s) { r2[6] -= m2 * s; r3[6] -= m3 * s; }
 	s = r1[7]; if (0.0 != s) { r2[7] -= m2 * s; r3[7] -= m3 * s; }
-	
+
 	/* choose pivot - or die */
 	if (fabs(r3[2])>fabs(r2[2])) SWAP_ROWS(r3, r2);
 	if (0.0 == r2[2])  return false;
-	
+
 	/* eliminate third variable */
 	m3 = r3[2]/r2[2];
 	r3[3] -= m3 * r2[3], r3[4] -= m3 * r2[4],
 	r3[5] -= m3 * r2[5], r3[6] -= m3 * r2[6],
 	r3[7] -= m3 * r2[7];
-	
+
 	/* last check */
 	if (0.0 == r3[3]) return false;
-	
+
 	s = 1.0/r3[3];              /* now back substitute row 3 */
 	r3[4] *= s; r3[5] *= s; r3[6] *= s; r3[7] *= s;
-	
+
 	m2 = r2[3];                 /* now back substitute row 2 */
 	s  = 1.0/r2[2];
 	r2[4] = s * (r2[4] - r3[4] * m2), r2[5] = s * (r2[5] - r3[5] * m2),
 	m0 = r0[3];
 	r0[4] -= r3[4] * m0, r0[5] -= r3[5] * m0,
 	r0[6] -= r3[6] * m0, r0[7] -= r3[7] * m0;
-	
+
 	m1 = r1[2];                 /* now back substitute row 1 */
 	s  = 1.0/r1[1];
 	r1[4] = s * (r1[4] - r2[4] * m1), r1[5] = s * (r1[5] - r2[5] * m1),
 	m0 = r0[2];
 	r0[4] -= r2[4] * m0, r0[5] -= r2[5] * m0,
 	r0[6] -= r2[6] * m0, r0[7] -= r2[7] * m0;
-	
+
 	m0 = r0[1];                 /* now back substitute row 0 */
 	s  = 1.0/r0[0];
 	r0[4] = s * (r0[4] - r1[4] * m0), r0[5] = s * (r0[5] - r1[5] * m0),
 	r0[6] = s * (r0[6] - r1[6] * m0), r0[7] = s * (r0[7] - r1[7] * m0);
-	
-	MAT(out,0,0) = r0[4]; 
-	MAT(out,0,1) = r0[5], MAT(out,0,2) = r0[6]; 
+
+	MAT(out,0,0) = r0[4];
+	MAT(out,0,1) = r0[5], MAT(out,0,2) = r0[6];
 	MAT(out,0,3) = r0[7], MAT(out,1,0) = r1[4];
 	MAT(out,1,1) = r1[5], MAT(out,1,2) = r1[6];
 	MAT(out,1,3) = r1[7], MAT(out,2,0) = r2[4];
 	MAT(out,2,1) = r2[5], MAT(out,2,2) = r2[6];
 	MAT(out,2,3) = r2[7], MAT(out,3,0) = r3[4];
 	MAT(out,3,1) = r3[5], MAT(out,3,2) = r3[6];
-	MAT(out,3,3) = r3[7]; 
-	
+	MAT(out,3,3) = r3[7];
+
 	return true;
 #undef MAT
 #undef SWAP_ROWS
 	m[ 1] = 2.0f * (mX*mY - mW*mZ);
 	m[ 2] = 2.0f * (mX*mZ + mW*mY);
 	m[ 3] = 0.0f;
-	
+
 	m[ 4] = 2.0f * (mX*mY + mW*mZ);
 	m[ 5] = 1.0f - 2.0f * (mX*mX + mZ*mZ);
 	m[ 6] = 2.0f * (mY*mZ - mW*mX);
 	m[ 7] = 0.0f;
-	
+
 	m[ 8] = 2.0f * (mX*mZ - mW*mY);
 	m[ 9] = 2.0f * (mY*mZ + mW*mX);
 	m[10] = 1.0 - 2.0f * (mX*mX + mY*mY);
 	m[11] = 0.0f;
-	
+
 	m[12] = 0.0f;
 	m[13] = 0.0f;
 	m[14] = 0.0f;
 }
 
 
-void quaternion_to_axis_angles(float qw, float qx, float qy, float qz, 
+void quaternion_to_axis_angles(float qw, float qx, float qy, float qz,
 										 float *theta, float *x, float *y, float *z)
 {
 	*theta = (float)acos(qw) * 2.0;
 }
 
 
-void quaternion_to_euler_angles(float qw, float qx, float qy, float qz, 
+void quaternion_to_euler_angles(float qw, float qx, float qy, float qz,
 										  float *x, float *y, float *z)
 {
 	double qw2 = qw*qw;
 
 PSKModel::~PSKModel()
 {
-	if (mVertices) 
+	if (mVertices)
 		delete [] mVertices;
 
-	if (mWeights) 
+	if (mWeights)
 		delete [] mWeights;
 
-	if (mVTXWs) 
+	if (mVTXWs)
 		delete [] mVTXWs;
 
-	if (mFaces) 
+	if (mFaces)
 		delete [] mFaces;
 
-	if (mMaterials) 
+	if (mMaterials)
 		delete [] mMaterials;
 
-	if (mBones) 
+	if (mBones)
 		delete [] mBones;
 }
 
 	{
 		printf("%3i. ", i);
 		j = i;
-			
+
 		while (j > 0)
 		{
 			if (printNames)
 
 			j = mBones[j].parentIndex;
 		}
-			
+
 		printf("\n");
 	}
 
 	{
 		printf(" ===========================\n");
 		printf(" Reading Frame[%03u]\n", frame);
-		printf(" ===========================\n");		
+		printf(" ===========================\n");
 
 		/* PNTS0000... */
 		fread(buffer, 1, 28, f);
 		buffer[8] = 0;
-	
+
 		if (frame == 0 && strncmp("PNTS0000", buffer, 8) != 0)
 		{
 			printf("Expected PNTS0000, found '%s'\n", buffer);
 			mVertices[i+1] = r;
 			fread(&r, 1, 4, f);
 			mVertices[i+2] = r;
-			
+
 			if (mFlags & fDebugPointLoad)
 			{
-				printf("\t%5u (%.3f, %.3f, %.3f)\n", 
+				printf("\t%5u (%.3f, %.3f, %.3f)\n",
 						 i/3, mVertices[i], mVertices[i+1], mVertices[i+2]);
 			}
 		}
 		/* VTXW0000... */
 		fread(buffer, 1, 28, f);
 		buffer[8] = 0;
-		
+
 		if (frame == 0 && strncmp("VTXW0000", buffer, 8) != 0)
 		{
 			printf("Expected VTXW0000, found '%s'\n", buffer);
 			printf("This isn't a known VTXW0000\n");
 			return -2;
 		}
-		
+
 		fread(&mNumVTXWs, 1, 4, f);
 		printf(" NumVTXWs =\t %u\n", mNumVTXWs);
 
 
 			if (mFlags & fDebugUVLoad)
 			{
-				printf("\t%5u vertex = %u, unknown1 = 0x%x, UV = (%.3f, %.3f), unknown2 = 0x%x\n", 
-						 i, 
-						 mVTXWs[i].vertex, mVTXWs[i].unknown1, 
+				printf("\t%5u vertex = %u, unknown1 = 0x%x, UV = (%.3f, %.3f), unknown2 = 0x%x\n",
+						 i,
+						 mVTXWs[i].vertex, mVTXWs[i].unknown1,
 						 mVTXWs[i].uv[0], mVTXWs[i].uv[1],
 						 mVTXWs[i].unknown2);
 			}
 		/* FACE0000... */
 		fread(buffer, 1, 28, f);
 		buffer[8] = 0;
-		
+
 		if (frame == 0 && strncmp("FACE0000", buffer, 8) != 0)
 		{
 			printf("Expected FACE0000, found '%s'\n", buffer);
 
 		fread(&mNumFaces, 1, 4, f);
 		printf(" NumFaces =\t %u\n", mNumFaces);
-		
+
 		mFaces = new psk_face_t[mNumFaces];
-		
+
 		for (i = 0; i < mNumFaces; ++i)
 		{
 			// Vertex indices
 
 			if (mFlags & fDebugFaceLoad)
 			{
-				printf("%5u (%u, %u, %u), material = %u, flags = %u, unknown = 0x%x\n", 
-						 i, 
+				printf("%5u (%u, %u, %u), material = %u, flags = %u, unknown = 0x%x\n",
+						 i,
 						 mFaces[i].x, mFaces[i].y, mFaces[i].z,
 						 mFaces[i].material, mFaces[i].flags, mFaces[i].unknown);
-						 
+
 			}
 		}
 
 		/* MATT0000... */
 		fread(buffer, 1, 28, f);
 		buffer[8] = 0;
-		
+
 		if (frame == 0 && strncmp("MATT0000", buffer, 8) != 0)
 		{
 			printf("Expected MATT0000, found '%s'\n", buffer);
 		fread(&mNumMaterials, 1, 4, f);
 		printf(" NumMaterials =\t %u\n", mNumMaterials);
 		mMaterials = new psk_material_t[mNumMaterials];
-		
+
 		for (i = 0; i < mNumMaterials; ++i)
 		{
 			fread(&mMaterials[i].name, 1, 64, f);
 
 	fread(&mNumBones, 1, 4, f);
 	printf(" NumBones =\t %u\n", mNumBones);
-	
+
 	mBones = new psk_bone_t[mNumBones];
 
 	for (i = 0; i < mNumBones; ++i)
 		strncpy(mBones[i].name, buffer, 64);
 		fread(&mBones[i].flags, 1, 4, f);
 		fread(&mBones[i].numChildren, 1, 4, f);
-		fread(&mBones[i].parentIndex, 1, 4, f); 
+		fread(&mBones[i].parentIndex, 1, 4, f);
 
 		fread(&r, 1, 4, f);
 		mBones[i].restDir[0] = r;
 		fread(mBones[i].unknown+1, 1, 4, f);
 		fread(mBones[i].unknown+2, 1, 4, f);
 		fread(mBones[i].unknown+3, 1, 4, f);
-		
+
 		if (mFlags & fDebugBoneLoad)
 		{
 			unsigned int offset = ftell(f) - 110;
 			printf("\n# File offset 0x%x + 110bytes\n", offset);
 
 			printf("Bone[%03u] = { '%s'\n", i, buffer);
-			printf("\tParent: %u, Children: %u, flags: 0x%80x\n", 
-					 mBones[i].parentIndex, mBones[i].numChildren, 
+			printf("\tParent: %u, Children: %u, flags: 0x%80x\n",
+					 mBones[i].parentIndex, mBones[i].numChildren,
 					 mBones[i].flags);
-			printf("\tRest Loc: (%.3f, %.3f, %.3f)\n", 
-					 mBones[i].restLoc[0], mBones[i].restLoc[1], 
+			printf("\tRest Loc: (%.3f, %.3f, %.3f)\n",
+					 mBones[i].restLoc[0], mBones[i].restLoc[1],
 					 mBones[i].restLoc[2]);
-			printf("\tRest Dir XYZ: (%.3f, %.3f, %.3f), W: %.3f?\n", 
-					 mBones[i].restDir[0], mBones[i].restDir[1], 
+			printf("\tRest Dir XYZ: (%.3f, %.3f, %.3f), W: %.3f?\n",
+					 mBones[i].restDir[0], mBones[i].restDir[1],
 					 mBones[i].restDir[2], mBones[i].restDir[3]);
-			
-			printf("\tUnknown: 0x%x, 0x%x, 0x%x, Flags? 0x%x\n", 
-					 mBones[i].unknown[0], mBones[i].unknown[1], 
+
+			printf("\tUnknown: 0x%x, 0x%x, 0x%x, Flags? 0x%x\n",
+					 mBones[i].unknown[0], mBones[i].unknown[1],
 					 mBones[i].unknown[2], mBones[i].unknown[3]);
 			printf("}\n");
 		}
 
 	fread(&mNumWeights, 1, 4, f);
 	printf(" NumWeights =\t %u\n", mNumWeights);
-	
+
 	mWeights = new psk_weight_t[mNumWeights];
 
 	for (i = 0; i < mNumWeights; ++i)
 
 		if (mFlags & fDebugWeightLoad)
 		{
-			printf("\tWeight[%u] { w = %f, vertexIndex = %u,  boneIndex = %u }\n", i, 
-					 mWeights[i].weight, 
+			printf("\tWeight[%u] { w = %f, vertexIndex = %u,  boneIndex = %u }\n", i,
+					 mWeights[i].weight,
 					 mWeights[i].vertexIndex, mWeights[i].boneIndex);
 		}
 	}
 		fread(mBones[i].name, 1, 64, f);
 		fread(&mBones[i].flags, 1, 4, f);
 		fread(&mBones[i].numChildren, 1, 4, f);
-		fread(&mBones[i].parentIndex, 1, 4, f); 
+		fread(&mBones[i].parentIndex, 1, 4, f);
 
 		fread(&mBones[i].restDir[0], 1, 4, f);
 		fread(&mBones[i].restDir[1], 1, 4, f);
 		if (mFlags &fDebugBones)
 		{
 			printf("Bone[%03u] = { '%s'\n", i, mBones[i].name);
-			printf("\tParent: %u, Children: %u, Flags: 0x%04x\n", 
+			printf("\tParent: %u, Children: %u, Flags: 0x%04x\n",
 					 mBones[i].parentIndex, mBones[i].numChildren,
 					 mBones[i].flags);
-			printf("\tRest Loc: (%.3f, %.3f, %.3f)\n", 
-					 mBones[i].restLoc[0], mBones[i].restLoc[1], 
+			printf("\tRest Loc: (%.3f, %.3f, %.3f)\n",
+					 mBones[i].restLoc[0], mBones[i].restLoc[1],
 					 mBones[i].restLoc[2]);
-			printf("\tRest Dir XYZ: (%.3f, %.3f, %.3f), W: %.3f\n", 
-					 mBones[i].restDir[0], mBones[i].restDir[1], 
+			printf("\tRest Dir XYZ: (%.3f, %.3f, %.3f), W: %.3f\n",
+					 mBones[i].restDir[0], mBones[i].restDir[1],
 					 mBones[i].restDir[2], mBones[i].restDir[3]);
-			printf("\?: 0x%x, 0x%x, 0x%x, Flags? 0x%08x\n", 
-					 mBones[i].unknown[0], mBones[i].unknown[1], 
+			printf("\?: 0x%x, 0x%x, 0x%x, Flags? 0x%08x\n",
+					 mBones[i].unknown[0], mBones[i].unknown[1],
 					 mBones[i].unknown[2], mBones[i].unknown[3]);
 			printf("? %f\n", *((float *)&mBones[i].unknown[3]));
 			printf("}\n");
 		if (mFlags &fDebugAnimInfos)
 		{
 			printf("\n");
-			printf("AnimInfo[%u] = { name: '%s', name2: '%s'\n", i, 
+			printf("AnimInfo[%u] = { name: '%s', name2: '%s'\n", i,
 					 mAnimInfos[i].name, mAnimInfos[i].name2);
 			printf(" numBones = %u, rootId = %u\n",
 					 mAnimInfos[i].numBones, mAnimInfos[i].rootId);
-			printf(" key: %u %u %f\n", 
-					 mAnimInfos[i].key[0], mAnimInfos[i].key[1], 
+			printf(" key: %u %u %f\n",
+					 mAnimInfos[i].key[0], mAnimInfos[i].key[1],
 					 mAnimInfos[i].keyf);
-			printf(" time: %f %f\n", 
+			printf(" time: %f %f\n",
 					 mAnimInfos[i].time[0], mAnimInfos[i].time[1]);
-			printf(" unknowns: %f %f %f\n", 
-					 mAnimInfos[i].unknown[0], mAnimInfos[i].unknown[1], 
+			printf(" unknowns: %f %f %f\n",
+					 mAnimInfos[i].unknown[0], mAnimInfos[i].unknown[1],
 					 mAnimInfos[i].unknown[2]);
 			printf("}\n");
 		}
 	}
-	
+
 	printf("COMPUTE: psa.numKeyframes / info.numBones = frames per bone\n");
 	printf("\n");
 
 	mKeyFrames = new psa_key_frame_t[mNumKeyFrames];
 
 	for (i = 0; i < mNumKeyFrames; ++i)
-	{	
+	{
 		// tx ty tz qx qy qz qw s
 		fread(&mKeyFrames[i].trans[0], 4, 1, f);
 		fread(&mKeyFrames[i].trans[1], 4, 1, f);
 		if (mFlags &fDebugKeyFrames)
 		{
 			printf("keyFrame[%u] = {\n", i);
-			printf("Trans XYZ: ( %f %f %f )\n", 
+			printf("Trans XYZ: ( %f %f %f )\n",
 					 mKeyFrames[i].trans[0], mKeyFrames[i].trans[1],
 					 mKeyFrames[i].trans[2]);
-			printf("Dir XYZ: ( %f %f %f ) %f\n", 
-					 mKeyFrames[i].dir[0], mKeyFrames[i].dir[1], 
+			printf("Dir XYZ: ( %f %f %f ) %f\n",
+					 mKeyFrames[i].dir[0], mKeyFrames[i].dir[1],
 					 mKeyFrames[i].dir[2], mKeyFrames[i].dir[3]);
 			printf("scale = %f\n", mKeyFrames[i].scale);
 			printf("}\n\n");
 	}
 
 	if (mFlags & fRenderPoints)
-	{	
+	{
 		glBegin(GL_POINTS);
-		
+
 		for (i = 0; i < mNumVertices*3; i+= 3)
 		{
 			glVertex3fv(mVertexTransformCache+i);
 		}
-		
+
 		glEnd();
 	}
 
 	}
 
 	if (mFlags & fRenderFaces)
-	{		
+	{
 		unsigned int index[3];
 		int lastTexture = 999999;
 
 				glTexCoord2fv(mVTXWs[mFaces[i].y].uv);
 				glVertex3fv(mVertexTransformCache+index[1]);
 				glTexCoord2fv(mVTXWs[mFaces[i].z].uv);
-				glVertex3fv(mVertexTransformCache+index[2]); 
+				glVertex3fv(mVertexTransformCache+index[2]);
 			}
 			else
 			{
-				((i % 2) ? 
+				((i % 2) ?
 				 glColor3f(0.0f, 0.0f, (((float)i)/(float)mNumFaces)*.5+.25) :
 				 glColor3f(0.0f, (((float)i)/(float)mNumFaces)*.5+.25, 0.0f));
 
-				glVertex3fv(mVertexTransformCache+index[0]); 
-				glVertex3fv(mVertexTransformCache+index[1]); 
-				glVertex3fv(mVertexTransformCache+index[2]); 
+				glVertex3fv(mVertexTransformCache+index[0]);
+				glVertex3fv(mVertexTransformCache+index[1]);
+				glVertex3fv(mVertexTransformCache+index[2]);
 			}
 
 			glEnd();
 	if (mAnimationFrame > 0 &&
 		 mAnimation && mAnimation->mBones == mBones)
 	{
-		f = id + (mAnimationFrame*mAnimation->mNumBones); 
+		f = id + (mAnimationFrame*mAnimation->mNumBones);
 
 		posB[0] = -mAnimation->mKeyFrames[f].trans[0];
 		posB[1] = -mAnimation->mKeyFrames[f].trans[1];
 		posB[2] = -mAnimation->mKeyFrames[f].trans[2];
-		
+
 		glTranslatef(mAnimation->mKeyFrames[f].trans[0],
 						 mAnimation->mKeyFrames[f].trans[1],
 						 mAnimation->mKeyFrames[f].trans[2]);
 		posB[0] = -mBones[id].restLoc[0];
 		posB[1] = -mBones[id].restLoc[1];
 		posB[2] = -mBones[id].restLoc[2];
-		
+
 		glTranslatef(mBones[id].restLoc[0],
 						 mBones[id].restLoc[1],
 						 mBones[id].restLoc[2]);
 		{
 			if (i == mBones[i].parentIndex)
 				continue;
-			
+
 			if (mBones[i].parentIndex == id)
 			{
 				renderBone(i);
 												&mBoneRotationCache[i*4],    // x
 												&mBoneRotationCache[i*4+1],  // y
 												&mBoneRotationCache[i*4+2]); // z
-			
+
 			// Convert radians to degrees
 			mBoneRotationCache[i*4] *= 57.295779513082323;
 			mBoneRotationCache[i*4+1] *= 57.295779513082323;
 											  mBones[i].restDir[2], // qz
 											  &mBoneRotationCache[i*4],  // theta
 											  &mBoneRotationCache[i*4+1],  // x
-											  &mBoneRotationCache[i*4+2],  // y  
+											  &mBoneRotationCache[i*4+2],  // y
 											  &mBoneRotationCache[i*4+3]); // z
 
 			// Convert radians to degrees, negated to account for UT coords
-			mBoneRotationCache[i*4] *= -57.295779513082323; 
+			mBoneRotationCache[i*4] *= -57.295779513082323;
 		}
 	}
 }
 												&mBoneRotationCache[b*4],    // x
 												&mBoneRotationCache[b*4+1],  // y
 												&mBoneRotationCache[b*4+2]); // z
-			
+
 			// Convert radians to degrees
 			mBoneRotationCache[b*4] *= 57.295779513082323;
 			mBoneRotationCache[b*4+1] *= 57.295779513082323;
 			quaternion_to_axis_angles(qw, qx, qy, qz,
 											  &mBoneRotationCache[b*4],    // theta
 											  &mBoneRotationCache[b*4+1],  // x
-											  &mBoneRotationCache[b*4+2],  // y  
+											  &mBoneRotationCache[b*4+2],  // y
 											  &mBoneRotationCache[b*4+3]); // z
 
 			// Convert radians to degrees, negated to account for UT coords
 	if (!anim || !mModel || anim->mNumBones != mModel->mNumBones)
 	{
 		printf("Error: Unable to load PSA Animation, [%s]\n",
-				 (!mModel) ? "No PSK model loaded" : 
+				 (!mModel) ? "No PSK model loaded" :
 				 (!anim) ? "Null PSA given" :
 				 "PSA animation doesn't match loaded PSK model");
 		return;
 	mFaces = model->mFaces;
 	mMaterials = model->mMaterials;
 	mBones = model->mBones;
-	mWeights = model->mWeights;		
+	mWeights = model->mWeights;
 
 	/* Setup vertices */
 	if (mVertexTransformCache)
 	/* Setup bones */
 	if (mBoneRotationCache)
 		delete [] mBoneRotationCache;
-	
+
 	mBoneRotationCache = new float[model->mNumBones*4];
 	convertBoneAngles();
 
 	/* OpenGL axis angles rotation */
 	glRotatef(theta, x, y, z);
 
-	/* Store this bones tranform matrix inverted to 
+	/* Store this bones tranform matrix inverted to
 		get bone rest position of model vertices */
 	glGetFloatv(GL_MODELVIEW_MATRIX, m);
 	invert_matrix(m, mInvertedMatrices[id]);
 		{
 			if (i == mBones[i].parentIndex)
 				continue;
-			
+
 			if (mBones[i].parentIndex == id)
 			{
 				setupRestMatrices(i);
 	if (mAnimationFrame > 0 &&
 		 mAnimation && mAnimation->mBones == mBones)
 	{
-		f = id + (mAnimationFrame*mAnimation->mNumBones); 
-		
+		f = id + (mAnimationFrame*mAnimation->mNumBones);
+
 		glTranslatef(mAnimation->mKeyFrames[f].trans[0],
 						 mAnimation->mKeyFrames[f].trans[1],
 						 mAnimation->mKeyFrames[f].trans[2]);
 		{
 			if (i == mBones[i].parentIndex)
 				continue;
-			
+
 			if (mBones[i].parentIndex == id)
 			{
 				setupWorldMatrices(i);
 	float m[16], m2[16], m3[16];
 
 
-	/* Currently inline transforms all vertices to produce 
+	/* Currently inline transforms all vertices to produce
 		one deformed mesh keyframe */
 	if (id == 0)
 		copyVertices();
 								mModel->mBones[id].restDir[1], // qy
 								mModel->mBones[id].restDir[2], // qz
 								m2);
-	
+
 	multiply_matrix(m, m2, m3);
 
 	if (id == 0)
 	else
 	{
 		invert_matrix(m3, m2);
-		multiply_matrix(mInvertedMatrices[mModel->mBones[id].parent], 
-							 m2, mInvertedMatrices[id]);	
+		multiply_matrix(mInvertedMatrices[mModel->mBones[id].parent],
+							 m2, mInvertedMatrices[id]);
 	}
 
 	/* Transformed skeleton matrices */
 	else
 	{
 		multiply_matrix(mInvertedMatrices[id], m3, m2);
-		multiply_matrix(mInvertedMatrices[mModel->mBones[id].parent], 
+		multiply_matrix(mInvertedMatrices[mModel->mBones[id].parent],
 							 m2, m);
-	}	
+	}
 	//copy_matrix(m, mInvertedMatrices[id]);
 
 	for (i = 0; i < mModel->mNumWeights; ++i)
 			if (mModel->mWeights[i].boneIndex == id)
 			{
 				j = mModel->mWeights[i].vertexIndex;
-				
+
 				x = mVertexTransformCache[j*3+0] * mModel->mWeights[i].weight;
 				y = mVertexTransformCache[j*3+1] * mModel->mWeights[i].weight;
 				z = mVertexTransformCache[j*3+2] * mModel->mWeights[i].weight;
-				
+
 				mVertexTransformCache[j*3+0] = m[0]*x + m[4]*y + m[ 8]*z + m[12];
 				mVertexTransformCache[j*3+1] = m[1]*x + m[5]*y + m[ 9]*z + m[13];
 				mVertexTransformCache[j*3+2] = m[2]*x + m[6]*y + m[10]*z + m[14];
 	float x, y, time;
 
 
-	gluLookAt(0.0, 0.0, -256.0, 
-				 0.0, 8.0, 0.0, 
+	gluLookAt(0.0, 0.0, -256.0,
+				 0.0, 8.0, 0.0,
 				 0.0, 1.0, 0.0);
 
 	glDisable(GL_TEXTURE_2D);
 	// Draw light symbol
 	glPushMatrix();
 	glTranslatef(gLightPos[0], gLightPos[1], gLightPos[2]);
-	
+
 	glBegin(GL_LINES);
 	glColor3f(1.0f, 1.0f, 1.0f);
 	glVertex3f(0.0f, 0.0f, 0.0f);
 		glBegin(GL_LINE_LOOP);
 		for (y = -size; y < size; y += step)
 		{
-			glVertex3f(x + step, 0.0f, y);	
-			glVertex3f(x, 0.0f, y);	
+			glVertex3f(x + step, 0.0f, y);
+			glVertex3f(x, 0.0f, y);
 			glVertex3f(x, 0.0f, y + step);
 			glVertex3f(x + step, 0.0f, y + step);
 		}
 		glEnd();
 	}
 	glPopMatrix();
-	
+
 	// Draw model
 	glEnable(GL_TEXTURE_2D);
 	glColor3f(1.0f, 1.0f, 1.0f);
 	printf(";/'        - Switch PSA frame (EXPERIMENTAL)\n");
 	printf("/          - Show PSK frame\n");
 	printf("----------------------------------\n");
-	printf("1 - Toggle polygon rendering\n");   
-	printf("2 - Toggle polygon render debugging\n"); 
-	printf("3 - Toggle textured polygons\n");  
-	printf("4 - Toggle points\n");  
+	printf("1 - Toggle polygon rendering\n");
+	printf("2 - Toggle polygon render debugging\n");
+	printf("3 - Toggle textured polygons\n");
+	printf("4 - Toggle points\n");
 	printf("7 - Toggle scene rotation\n");
-	printf("8 - Toggle alpha blending\n");      
-	printf("8 - Toggle OpenGL Lighting\n"); 
-	printf("r - Reset mesh to default\n");  
+	printf("8 - Toggle alpha blending\n");
+	printf("8 - Toggle OpenGL Lighting\n");
+	printf("r - Reset mesh to default\n");
 	printf("w - Toggle wireframe rendering\n");
 #ifdef INTERACTIVE_BONE_RENDER
 	printf("g,h - Select bone Id\n");
 
 		if (gWireframe)
 		{
-			glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); 
+			glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
 		}
 		else
 		{
 {
 	GLfloat aspect;
 
-	
+
 	gWidth = width;
 	gHeight = height;
 
 	aspect = (GLfloat)width/(GLfloat)height;
 
-	glViewport(0, 0, width, height); 
+	glViewport(0, 0, width, height);
 
 	glMatrixMode(GL_PROJECTION);
 	glLoadIdentity();
 	  if (SDL_GL_LoadLibrary("libGL.so") < 0)
 	  {
 		  SDL_ClearError();
-    
+
 		  // Fallback 2
 		  if (SDL_GL_LoadLibrary("libGL.so.1") < 0)
 		  {
   SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
   gSDLWindow = SDL_SetVideoMode(width, height, 16, flags);
   SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
-  
+
   // Init rendering
   init_gl(width, height);
   initScene(argc, argv);
 			  break;
 		  case SDL_MOUSEBUTTONDOWN:
 		  case SDL_MOUSEBUTTONUP:
-			  break;	
+			  break;
 		  case SDL_KEYDOWN:
 			  mkeys = (unsigned int)SDL_GetModState();
 			  mod = 0;
 					  SDL_WM_ToggleFullScreen(gSDLWindow);
 				  }
 			  }
-			  
+
 			  handleKey(key);
 			  break;
 		  case SDL_KEYUP:
 			  break;
-		  case SDL_VIDEORESIZE:			  
+		  case SDL_VIDEORESIZE:
 			  event_resize(event.resize.w, event.resize.h);
 
 			  width = event.resize.w;
 
 	  event_display(width, height);
   }
-  
+
   return 0;
 }
 #endif
 			{
 			case '.':
 				gAnim.mFlags = (PSAAnimation::fDebugBones |
-									 PSAAnimation::fDebugAnimInfos | 
+									 PSAAnimation::fDebugAnimInfos |
 									 PSAAnimation::fDebugKeyFrames);
 				gAnim.load(argv[2]);
 				break;
 			case 'p':
-				gAnim.mFlags = (PSAAnimation::fDebugBones |	
-									 PSAAnimation::fDebugAnimInfos | 
+				gAnim.mFlags = (PSAAnimation::fDebugBones |
+									 PSAAnimation::fDebugAnimInfos |
 									 PSAAnimation::fDebugKeyFrames);
 				break;
 			case 'g':
 				break;
 			}
 		}
-		
+
 		if (argc > 3)
 		{
 			/* Load PSK model */

src/Particle.h

 /* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
 /*================================================================
- * 
+ *
  * Project : Freyja
  * Author  : Terry 'Mongoose' Hendrix II
  * Website : http://www.westga.edu/~stu7440/
  * Comments: Partcle system's atomic base
  *
  *
- *           This file was generated using Mongoose's C++ 
+ *           This file was generated using Mongoose's C++
  *           template generator script.  <stu7440@westga.edu>
- * 
- *-- History ------------------------------------------------ 
+ *
+ *-- History ------------------------------------------------
  *
  * 2001.08.13:
  * Mongoose - Created
 #ifndef __FREYJA_MONGOOSE_PARTICLE_H_
 #define __FREYJA_MONGOOSE_PARTICLE_H_
 
-#include <hel/math.h>
+#include "hel/math.h"
 
 class Particle
 {
 
   Particle();
   /*------------------------------------------------------
-   * Pre  : 
+   * Pre  :
    * Post : Constructs an object of Particle
    *
    *-- History ------------------------------------------
    *
-   * 2001.08.13: 
+   * 2001.08.13:
    * Mongoose - Created
    ------------------------------------------------------*/
 
    *
    *-- History ------------------------------------------
    *
-   * 2001.08.13: 
+   * 2001.08.13:
    * Mongoose - Created
    ------------------------------------------------------*/
 
 	void setActive(bool active);
   /*------------------------------------------------------
-   * Pre  : 
+   * Pre  :
    * Post : Toggles active state of particle
    *
    *-- History ------------------------------------------
    *
-   * 2001.08.13: 
+   * 2001.08.13:
    * Mongoose - Created
    ------------------------------------------------------*/
 
   void Force(float x, float y, float z);
   /*------------------------------------------------------
-   * Pre  : 
+   * Pre  :
    * Post : Sets gravity/force acting on particle
    *
    *-- History ------------------------------------------
    *
-   * 2001.08.13: 
+   * 2001.08.13:
    * Mongoose - Created
    ------------------------------------------------------*/
 
   void Reset();
   /*------------------------------------------------------
-   * Pre  : 
+   * Pre  :
    * Post : Resets particle to defaults
    *
    *-- History ------------------------------------------
    *
-   * 2001.08.13: 
+   * 2001.08.13:
    * Mongoose - Created
    ------------------------------------------------------*/
 
    *
    *-- History ------------------------------------------
    *
-   * 2001.08.14: 
+   * 2001.08.14:
    * Mongoose - Created
    ------------------------------------------------------*/
 
    *
    *-- History ------------------------------------------
    *
-   * 2001.08.14: 
+   * 2001.08.14:
    * Mongoose - Created
    ------------------------------------------------------*/
 
    *
    *-- History ------------------------------------------
    *
-   * 2001.08.13: 
+   * 2001.08.13:
    * Mongoose - Created
    ------------------------------------------------------*/
 
    *
    *-- History ------------------------------------------
    *
-   * 2001.08.13: 
+   * 2001.08.13:
    * Mongoose - Created
    ------------------------------------------------------*/
 
   float Life();
   /*------------------------------------------------------
-   * Pre  : 
+   * Pre  :
    * Post : Returns current life ( blend ) of particle
    *
    *-- History ------------------------------------------
    *
-   * 2001.08.13: 
+   * 2001.08.13:
    * Mongoose - Created
    ------------------------------------------------------*/
 
   void Update();
   /*------------------------------------------------------
-   * Pre  : 
+   * Pre  :
    * Post : Ajusts for particle life cycle
    *
    *-- History ------------------------------------------
    *
-   * 2001.08.13: 
+   * 2001.08.13:
    * Mongoose - Created
    ------------------------------------------------------*/
 
   int Texture();
   /*------------------------------------------------------
-   * Pre  : 
+   * Pre  :
    * Post : Returens texture binding for this particle
    *
    *-- History ------------------------------------------
    *
-   * 2001.08.13: 
+   * 2001.08.13:
    * Mongoose - Created
    ------------------------------------------------------*/
 
   bool isActive();
   /*------------------------------------------------------
-   * Pre  : 
+   * Pre  :
    * Post : Returns active value
    *
    *-- History ------------------------------------------
    *
-   * 2001.08.13: 
+   * 2001.08.13:
    * Mongoose - Created
    ------------------------------------------------------*/
 
   void TextureId(int t);
   /*------------------------------------------------------
-   * Pre  : 
-   * Post : 
+   * Pre  :
+   * Post :
    *
    *-- History ------------------------------------------
    *
-   * 2001.08.13: 
+   * 2001.08.13:
    * Mongoose - Created
    ------------------------------------------------------*/
 
  private:
 
 	bool _active;           /* Is this particle in use? */
-	
+
 	float _life;            /* Life of particle  */
-	
+
 	float _blend;           /* Blend amount or fade */
 
 	int _texture;           /* Texture polygon to use */

src/Render.h

 /* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
 /*================================================================
- * 
+ *
  * Project : Render
  * Author  : Mongoose
  * Website : http://www.westga.edu/~stu7440/
  * Comments: This is the renderer class for OpenRaider
  *
  *
- *           This file was generated using Mongoose's C++ 
+ *           This file was generated using Mongoose's C++
  *           template generator script.  <stu7440@westga.edu>
- * 
- *-- History ------------------------------------------------ 
+ *
+ *-- History ------------------------------------------------
  *
  * 2001.05.21:
  * Mongoose - Created
 #ifndef GUARD__RENDER_MONGOOSE_RENDER_H_
 #define GUARD__RENDER_MONGOOSE_RENDER_H_
 
-#include <mstl/List.h>
-#include <mstl/Vector.h>
-#include <hel/Matrix.h>
-#include <hel/ViewVolume.h>
+#include "mstl/List.h"
+#include "mstl/Vector.h"
+#include "hel/Matrix.h"
+#include "hel/ViewVolume.h"
 #include "Light.h"
 #include "World.h"
 #include "SkeletalModel.h"
 	////////////////////////////////////////////////////////////
 	// Constructors
 	////////////////////////////////////////////////////////////
-	
+
 	Render();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Constructs an object of Render
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2001.05.21: 
+	 * 2001.05.21:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
-	
+
 	~Render();
 	/*------------------------------------------------------
 	 * Pre  : Render object is allocated
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2001.05.21: 
+	 * 2001.05.21:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
-	
+
 
 	////////////////////////////////////////////////////////////
 	// Public Accessors
 
 	void screenShot(char *filenameBase);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Makes a screenshot, writes to disk as file
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.12.20: 
+	 * 2002.12.20:
 	 * Mongoose - Created, factored out of OpenRaider class
 	 ------------------------------------------------------*/
 
 	int getMode();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Gets current rendering mode
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2001.05.21: 
+	 * 2001.05.21:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 
 	void addRoom(RenderRoom *rRoom);
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
 
 	void Init(int width, int height, bool fastCard);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Starts and sets up OpenGL target
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2001.05.21: 
+	 * 2001.05.21:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
-	void loadTexture(unsigned char *image, 
+	void loadTexture(unsigned char *image,
 						  unsigned int width, unsigned int height,
 						  unsigned int id);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Loads textures in a certian id slot
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.12.20: 
+	 * 2002.12.20:
 	 * Mongoose - Created, factored out of OpenRaider class
 	 ------------------------------------------------------*/
 
-	void initTextures(char *textureDir, unsigned int *numLoaded, 
+	void initTextures(char *textureDir, unsigned int *numLoaded,
 							unsigned int *nextId);
 	/*------------------------------------------------------
 	 * Pre  : textureDir is valid and exists with textures
 	 * Post : Sets up textures for OpenRaider
-	 *        Returns number of loaded textures and 
+	 *        Returns number of loaded textures and
 	 *
 	 *        numLoaded will update number of
 	 *        external textures loaded
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.12.20: 
+	 * 2002.12.20:
 	 * Mongoose - Created, factored out of OpenRaider class
 	 ------------------------------------------------------*/
 
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.12.25: 
+	 * 2002.12.25:
 	 * Mongoose - Created, factored out of UnRaider class
 	 ------------------------------------------------------*/
 
-	void initEmitter(char *name, unsigned int size, 
+	void initEmitter(char *name, unsigned int size,
 						  unsigned int snowTex1, unsigned int snowTex2);
 	/*------------------------------------------------------
 	 * Pre  : Textures are init and these args are valid
 
 	void ClearWorld();
   /*------------------------------------------------------
-   * Pre  : 
+   * Pre  :
    * Post : Removes current world/entity/etc geometery
    *
    *-- History ------------------------------------------
    *
-   * 2001.05.21: 
+   * 2001.05.21:
    * Mongoose - Created
    ------------------------------------------------------*/
 
    *
    *-- History ------------------------------------------
    *
-   * 2002.03.21: 
+   * 2002.03.21:
    * Mongoose - Created
    ------------------------------------------------------*/
 
 	void setMode(int n);
   /*------------------------------------------------------
-   * Pre  : 
-   * Post : 
+   * Pre  :
+   * Post :
    *
    *-- History ------------------------------------------
    *
-   * 2001.05.21: 
+   * 2001.05.21:
    * Mongoose - Created
    ------------------------------------------------------*/
 
 	void Update(int width, int height);
   /*------------------------------------------------------
-   * Pre  : 
-   * Post : 
+   * Pre  :
+   * Post :
    *
    *-- History ------------------------------------------
    *
-   * 2001.05.21: 
+   * 2001.05.21:
    * Mongoose - Created
    ------------------------------------------------------*/
 
 	void Display();
   /*------------------------------------------------------
-   * Pre  : 
+   * Pre  :
    * Post : Renders a single game frame
    *
    *-- History ------------------------------------------
    *
-   * 2001.05.21: 
+   * 2001.05.21:
    * Mongoose - Created
    ------------------------------------------------------*/
-	
+
 	void setSkyMesh(int index, bool rot);
   /*------------------------------------------------------
-   * Pre  : 
-   * Post : 
+   * Pre  :
+   * Post :
    *
    *-- History ------------------------------------------
    *
-   * 2001.05.21: 
+   * 2001.05.21:
    * Mongoose - Created
    ------------------------------------------------------*/
-	
+
 	void ViewModel(entity_t *ent, int index);
   /*------------------------------------------------------
-   * Pre  : 
-   * Post : 
+   * Pre  :
+   * Post :
    *
    *-- History ------------------------------------------
    *
-   * 2001.05.21: 
+   * 2001.05.21:
    * Mongoose - Created
    ------------------------------------------------------*/
-	
+
 	void RegisterCamera(Camera *camera);
   /*------------------------------------------------------
-   * Pre  : 
-   * Post : 
+   * Pre  :
+   * Post :
    *
    *-- History ------------------------------------------
    *
-   * 2001.05.21: 
+   * 2001.05.21:
    * Mongoose - Created
    ------------------------------------------------------*/
 
    GLString *GetString();
    /*------------------------------------------------------
-    * Pre  : 
+    * Pre  :
     * Post : Returns GL text output agent
     *
     *-- History ------------------------------------------
     *
-    * 2002.01.04: 
+    * 2002.01.04:
     * Mongoose - Created
     ------------------------------------------------------*/
 
     *
     *-- History ------------------------------------------
     *
-    * 2002.01.01: 
+    * 2002.01.01:
     * Mongoose - Created
     ------------------------------------------------------*/
 
     *
     *-- History ------------------------------------------
     *
-    * 2002.01.01: 
+    * 2002.01.01:
     * Mongoose - Created
     ------------------------------------------------------*/
 
 	 * 2002.12.16:
 	 * Mongoose - Moved to Render class
 	 *
-	 * 2001.06.06: 
+	 * 2001.06.06:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	bool isVisible(float x, float y, float z);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Is point in view volume?
 	 *
 	 *-- History ------------------------------------------
 
 	bool isVisible(float x, float y, float z, float radius);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Is sphere in view volume?
 	 *
 	 *-- History ------------------------------------------
     *
     *-- History ------------------------------------------
     *
-    * 2002.01.01: 
+    * 2002.01.01:
     * Mongoose - Created
     ------------------------------------------------------*/
 
     *
     *-- History ------------------------------------------
     *
-    * 2002.01.01: 
+    * 2002.01.01:
     * Mongoose - Created
     ------------------------------------------------------*/
 
     *
     *-- History ------------------------------------------
     *
-    * 2002.01.01: 
+    * 2002.01.01:
     * Mongoose - Created
     ------------------------------------------------------*/
 
     *
     *-- History ------------------------------------------
     *
-    * 2002.01.01: 
+    * 2002.01.01:
     * Mongoose - Created
     ------------------------------------------------------*/
 
     *
     *-- History ------------------------------------------
     *
-    * 2002.01.01: 
+    * 2002.01.01:
     * Mongoose - Created
     ------------------------------------------------------*/
 
     *
     *-- History ------------------------------------------
     *
-    * 2002.01.01: 
+    * 2002.01.01:
     * Mongoose - Created
     ------------------------------------------------------*/
-	
+
 	void drawRoomModel(static_model_t *mesh);
    /*------------------------------------------------------
     * Pre  : Texture is init
     *
     *-- History ------------------------------------------
     *
-    * 2002.01.01: 
+    * 2002.01.01:
     * Mongoose - Created
     ------------------------------------------------------*/
-	
+
 	void drawModelMesh(model_mesh_t *r_mesh, RenderMeshType type);
    /*------------------------------------------------------
     * Pre  : Texture is init, type is object containing mesh
     *
     *-- History ------------------------------------------
     *
-    * 2002.01.01: 
+    * 2002.01.01:
     * Mongoose - Created
     ------------------------------------------------------*/
-	
+
 	void drawSprite(sprite_t *sprite);
    /*------------------------------------------------------
     * Pre  : Texture is init
     *
     *-- History ------------------------------------------
     *
-    * 2002.01.01: 
+    * 2002.01.01:
     * Mongoose - Created
     ------------------------------------------------------*/
 
 
 	void tmpRenderModelMesh(model_mesh_t *r_mesh, texture_tri_t *ttri);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Let them eat cake...
 	 *
 	 *-- History ------------------------------------------

src/SDLSystem.cpp

 /* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
 /*================================================================
- * 
+ *
  * Project : OpenRaider
  * Author  : Terry 'Mongoose' Hendrix II
  * Website : http://www.westga.edu/~stu7440/
  * Email   : stu7440@westga.edu
  * Object  : SDL
  * License : No use w/o permission (C) 2002 Mongoose
- * Comments: 
+ * Comments:
  *
  *
- *           This file was generated using Mongoose's C++ 
+ *           This file was generated using Mongoose's C++
  *           template generator script.  <stu7440@westga.edu>
- * 
- *-- History ------------------------------------------------- 
  *
- * 2003.06.30, 
+ *-- History -------------------------------------------------
+ *
+ * 2003.06.30,
  * Mongoose - SDL_TTF support moved to Texture class
  *
  * 2003.06.03:
  * Mongoose - SDL_TTF support based on Sam Lantinga's public domain
- *            SDL_TTF demo functions and algorithms 
+ *            SDL_TTF demo functions and algorithms
  *
  * 2002.06.06:
  * Mongoose - Created
 #endif
 
 #ifdef HAVE_OPENGL
-#   include <GL/gl.h>
-#   include <GL/glu.h>
+#ifdef __APPLE__
+#include <OpenGL/gl.h>
+#include <OpenGL/glu.h>
+#else
+#include <GL/gl.h>
+#include <GL/glu.h>
+#endif
 #else
 #   error "SDLSystem requires -DHAVE_OPENGL"
 #endif
 		glBegin(GL_LINE_LOOP);
 		for (y = -size; y < size; y += step)
 		{
-			glVertex3f(x + step, 0.0f, y);	
-			glVertex3f(x, 0.0f, y);	
+			glVertex3f(x + step, 0.0f, y);
+			glVertex3f(x, 0.0f, y);
 			glVertex3f(x, 0.0f, y + step);
 			glVertex3f(x + step, 0.0f, y + step);
 		}
 	}
 
 	printf("Bound command '%s' -> event %i (0x%x key)\n", cmd, event, key);
-	
+
 	keyEvents[key] = event;
 }
 #endif
 }
 
 
-void SDLSystem::initVideo(unsigned int width, unsigned int height, 
+void SDLSystem::initVideo(unsigned int width, unsigned int height,
 								  bool fullscreen)
 {
 	int flags; //, x, y;
 	if (!m_driver || !m_driver[0] || SDL_GL_LoadLibrary(m_driver) < 0)
 	{
 		SDL_ClearError();
-		
+
 		// Fallback 1
 		if (SDL_GL_LoadLibrary("libGL.so") < 0)
 		{
 			SDL_ClearError();
-    
+
 			// Fallback 2
 			if (SDL_GL_LoadLibrary("libGL.so.1") < 0)
 			{
 
 	// Start game renderer
 	initGL();
-	
+
 	// Resize context
 	resizeGL(width, height);
 }
 {
 	GLfloat aspect;
 
-	
+
 	m_width = width;
 	m_height = height;
 
 	aspect = (GLfloat)width/(GLfloat)height;
 
-	glViewport(0, 0, width, height); 
+	glViewport(0, 0, width, height);
 
 	glMatrixMode(GL_PROJECTION);
 	glLoadIdentity();
 				{
 				case SDL_BUTTON_LEFT:
 					btn = SYS_MOUSE_LEFT;
-					break; 
+					break;
 				case SDL_BUTTON_RIGHT:
 					btn = SYS_MOUSE_RIGHT;
-					break; 
+					break;
 				case SDL_BUTTON_MIDDLE:
 					btn = SYS_MOUSE_MIDDLE;
 					break;
 					handleKeyReleaseEvent(btn, 0); // FIXME: mod not used
 				}
 				break;
-			case SDL_KEYUP:	
+			case SDL_KEYUP:
 			case SDL_KEYDOWN:
 				//SDL_GetMouseState(&x, &y); // Get cursor pos
 
 					{
 						key= (unsigned int)(event.key.keysym.unicode & 0x7F);
 					}
-					else 
+					else
 					{
 						key = 0;
 					}
 				}
 #else
-				// FIXME: Avoid passing modifers as a key, since the 
+				// FIXME: Avoid passing modifers as a key, since the
 				// consoles using this expect text characters, add unicode
 				// support later when they're able to handle it
 				if (key > 255 && key < 1000)
 					key = 0;
 				}
 #endif
-				
+
 				if (key == mConsoleKey)
 				{
 					if (event.type == SDL_KEYDOWN)
 					}
 				}
 				break;
-			case SDL_VIDEORESIZE:			  
+			case SDL_VIDEORESIZE:
 				resizeGL(event.resize.w, event.resize.h);
 				gameFrame();
 				break;
 void SDLSystem::toggleFullscreen()
 {
 	if (mWindow)
-	{		
+	{
 		SDL_ShowCursor(SDL_DISABLE);
 		SDL_WM_ToggleFullScreen(mWindow);
 	}

src/SDLUnitTest.cpp

 
 #ifdef USING_OPENGL
 
-#   include <GL/gl.h>
-#   include <GL/glu.h>
+#ifdef __APPLE__
+#include <OpenGL/gl.h>
+#include <OpenGL/glu.h>
+#else
+#include <GL/gl.h>
+#include <GL/glu.h>
+#endif
 #   include <SDL/SDL.h>
 #   include <Texture.h>
 
 
 		if (wireframe)
 		{
-			glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); 
+			glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
 		}
 		else
 		{
 {
 	GLfloat aspect;
 
-	
+
 	gWidth = width;
 	gHeight = height;
 
 	aspect = (GLfloat)width/(GLfloat)height;
 
-	glViewport(0, 0, width, height); 
+	glViewport(0, 0, width, height);
 
 	glMatrixMode(GL_PROJECTION);
 	glLoadIdentity();
 #endif
 
 
-void renderUnitTestScene() 
+void renderUnitTestScene()
 {
 
 	static float lastTime = 0.0f;
 	float x, y, time;
 
 
-	gluLookAt(0.0, 0.0, -256.0, 
-				 0.0, 8.0, 0.0, 
+	gluLookAt(0.0, 0.0, -256.0,
+				 0.0, 8.0, 0.0,
 				 0.0, 1.0, 0.0);
 
 	glDisable(GL_TEXTURE_2D);
 	// Draw light symbol
 	glPushMatrix();
 	glTranslatef(gLightPos[0], gLightPos[1], gLightPos[2]);
-	
+
 	glBegin(GL_LINES);
 	glColor3f(1.0f, 1.0f, 1.0f);
 	glVertex3f(0.0f, 0.0f, 0.0f);
 		glBegin(GL_LINE_LOOP);
 		for (y = -size; y < size; y += step)
 		{
-			glVertex3f(x + step, 0.0f, y);	
-			glVertex3f(x, 0.0f, y);	
+			glVertex3f(x + step, 0.0f, y);
+			glVertex3f(x, 0.0f, y);
 			glVertex3f(x, 0.0f, y + step);
 			glVertex3f(x + step, 0.0f, y + step);
 		}
 
 	glPopMatrix();
 
-	
+
 	glEnable(GL_TEXTURE_2D);
 	glColor3f(1.0f, 1.0f, 1.0f);
 	glPushMatrix();
 	  if (SDL_GL_LoadLibrary("libGL.so") < 0)
 	  {
 		  SDL_ClearError();
-    
+
 		  // Fallback 2
 		  if (SDL_GL_LoadLibrary("libGL.so.1") < 0)
 		  {
   SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
   gSDLWindow = SDL_SetVideoMode(width, height, 16, flags);
   SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
-  
+
   // Init rendering
   init_gl(width, height);
   initScene(argc, argv);
 			  break;
 		  case SDL_MOUSEBUTTONDOWN:
 		  case SDL_MOUSEBUTTONUP:
-			  break;	
+			  break;
 		  case SDL_KEYDOWN:
 			  mkeys = (unsigned int)SDL_GetModState();
 			  mod = 0;
 					  SDL_WM_ToggleFullScreen(gSDLWindow);
 				  }
 			  }
-			  
+
 			  handle_key(key);
 			  break;
 		  case SDL_KEYUP:
 			  break;
-		  case SDL_VIDEORESIZE:			  
+		  case SDL_VIDEORESIZE:
 			  event_resize(event.resize.w, event.resize.h);
 
 			  width = event.resize.w;
 
 	  event_display(width, height);
   }
-  
+
   return 0;
 }
 #endif
 		printf("'%s h' for help\n", argv[0]);
 	}
 
-	
+
 #ifdef USING_OPENGL
 	main_gl(argc, argv);
 #else

src/SkeletalModel.h

 /* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
 /*================================================================
- * 
+ *
  * Project : OpenRaider
  * Author  : Terry 'Mongoose' Hendrix II
  * Website : http://www.westga.edu/~stu7440/
  * Comments: This is the factored out skeletal model class
  *
  *
- *           This file was generated using Mongoose's C++ 
+ *           This file was generated using Mongoose's C++
  *           template generator script.  <stu7440@westga.edu>
- * 
+ *
  *-- Test Defines -----------------------------------------------
- *           
- * UNIT_TEST_SKELETALMODEL - Builds SkeletalModel class as a console unit test 
  *
- *-- History ------------------------------------------------ 
+ * UNIT_TEST_SKELETALMODEL - Builds SkeletalModel class as a console unit test
+ *
+ *-- History ------------------------------------------------
  *
  * 2003.05.19:
  * Mongoose - Created
  ================================================================*/
 
-// TODO 
+// TODO
 // Start cutting off old hacks by simple force use of method interface
 // Also move the publicly exposed attributes out  =)
 // Better animation system in general - this is memory wasteful
 #ifndef GUARD__OPENRAIDER_MONGOOSE_SKELETALMODEL_H_
 #define GUARD__OPENRAIDER_MONGOOSE_SKELETALMODEL_H_
 
-#include <mstl/Vector.h>
-#include <hel/math.h>
+#include "mstl/Vector.h"
+#include "hel/math.h"
 
 
 typedef struct bone_tag_s
 
 	SkeletalModel();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Constructs an object of SkeletalModel
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2003.05.19: 
+	 * 2003.05.19:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2003.05.19: 
+	 * 2003.05.19:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 

src/Sound.cpp

 /* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
 /*================================================================
- * 
+ *
  * Project : OpenRaider
  * Author  : Mongoose
  * Website : http://www.westga.edu/~stu7440/
  * Comments: This is the audio manager for OpenRaider
  *
  *
- *           This file was generated using Mongoose's C++ 
+ *           This file was generated using Mongoose's C++
  *           template generator script.  <stu7440@westga.edu>
- * 
- *-- History ------------------------------------------------- 
+ *
+ *-- History -------------------------------------------------
  *
  * 2001.05.23:
  * Mongoose - Created
  =================================================================*/
 
 #ifdef HAVE_OPENAL
+#ifdef __APPLE__
+#include <OpenAL/al.h>
+#include <OpenAL/alc.h>
+#else
 #   include <AL/al.h>
 #   include <AL/alc.h>
 #   include <AL/alut.h>
 #   include <AL/alext.h>
 #endif
+#endif
 
 #include <time.h>
 #include <stdio.h>
 
 int Sound::init()
 {
-	int fd;	
+	int fd;
 
 	fd = open("/dev/dsp", O_RDWR);
 
 
 #ifdef HAVE_OPENAL
 	alListenerfv(AL_POSITION, pos);
-	alListenerfv(AL_ORIENTATION, angle);	
+	alListenerfv(AL_ORIENTATION, angle);
 #endif
 }
 
 
 	alGenBuffers(1, &mBuffer[mNextBuffer]);
 
-	if (alGetError() != AL_NO_ERROR)	
+	if (alGetError() != AL_NO_ERROR)
    {
 		fprintf(stderr, "Sound::Init> alGenBuffers call failed\n");
 		return -1;
 		fprintf(stderr, "Sound::Init> alGenSources call failed\n");
 		return -2;
 	}
-   
+
    err = alutLoadWAV(filename, &data, &format, &size, &bits, &freq);
 
-   if (err == AL_FALSE) 
+   if (err == AL_FALSE)
 	{
 	   fprintf(stderr, "Could not load %s\n", filename);
 	   return -3;
 
 	alGenBuffers(1, &mBuffer[mNextBuffer]);
 
-	if (alGetError() != AL_NO_ERROR)	
+	if (alGetError() != AL_NO_ERROR)
    {
 		fprintf(stderr, "Sound::Init> alGenBuffers call failed\n");
 		return -1;
 		fprintf(stderr, "Sound::Init> alGenSources call failed\n");
 		return -2;
 	}
-   
+
 	// AL_FORMAT_WAVE_EXT
    alBufferData(mBuffer[mNextBuffer], AL_FORMAT_WAVE_EXT, data, size, freq);
 
 
 
 #ifdef UNIT_TEST_SOUND
-int main(int argc, char* argv[]) 
+int main(int argc, char* argv[])
 {
 	Sound snd;
 	FILE *f;
 			fread(buf, l, 1, f);
 
 			fclose(f);
-			
+
 			printf("Loading buffer of %s\n", argv[1]);
 			ret = snd.add(buf, &id, SoundFlagsNone);
 			printf("Load returned %i\n", ret);

src/System.cpp

 /* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
 /*================================================================
- * 
+ *
  * Project : UnRaider
  * Author  : Terry 'Mongoose' Hendrix II
  * Website : http://www.westga.edu/~stu7440/
  * Email   : stu7440@westga.edu
  * Object  : System
  * License : No use w/o permission (C) 2002 Mongoose
- * Comments: 
+ * Comments:
  *
  *
- *           This file was generated using Mongoose's C++ 
+ *           This file was generated using Mongoose's C++
  *           template generator script.  <stu7440@westga.edu>
- * 
- *-- History ------------------------------------------------- 
+ *
+ *-- History -------------------------------------------------
  *
  * 2002.08.09:
  * Mongoose - Created
 #include <stdarg.h>
 
 #ifdef USING_OPENGL
-#   include <GL/gl.h>
-#   include <GL/glu.h>
+#ifdef __APPLE__
+#include <OpenGL/gl.h>
+#include <OpenGL/glu.h>
+#else
+#include <GL/gl.h>
+#include <GL/glu.h>
+#endif
 #endif
 
 #ifdef HAVE_LIBFERIT
 #   include <ferit/Ftp.h>
 #endif
 
-#ifdef linux
+#if defined(linux) || defined(__APPLE__)
 #   include <time.h>
 #   include <sys/time.h>
 #endif
 	printf("[System.Core]\n");
 
 	// Hack for bad Map class, as well as reserved commands
-	addCommandMode("[System.Console]"); 
+	addCommandMode("[System.Console]");
 	mConsoleKey = '`';
 	bindKeyCommand("+console", mConsoleKey, 0);
 
 	char *text;
 	va_list args;
 
-	
+
 	// Mongoose 2002.01.01, Only allow valid strings
 	//   we must assume it's NULL terminated also if it passes...
 	if (!string || !string[0])
 
 		i = lenPath;
 	}
-	
+
 	// Make sure ends in "end" char
 	if (end && dir[i-1] != end)
 	{
 		dir[i++] = end;
 	}
-		
+
 	dir[i] = 0;
 
 	return dir;
 
 
 	len = strlen(filename);
-	
+
 	for (i = len, j = 0; i > 0; --i, ++j)
 	{
 		if (filename[i] == '/' || filename[i] == '\\')
 			break;
 	}
-	
+
 	j--;
-	
+
 	str = new char[len - j + 1];
-	
+
 	for (i = 0; i < len - j; ++i)
 	{
 		str[i] = filename[i + len - j];
 }
 
 
-int System::downloadToBuffer(char *urlString, 
+int System::downloadToBuffer(char *urlString,
 									  unsigned char **buffer, unsigned int *size)
 {
 #ifdef HAVE_LIBFERIT
 		break;
 	default:
 		printf("Sorry the protocol used in the URL isn't unsupported.\n");
-	
+
 		if (client)
 		{
 			delete client;
 		}
-		
+
 		return -2;
 	}
 
 
 	if (url)
 		delete url;
-	
+
 	return err;
 #else
 	printf("ERROR: This build not libferit enabled, unable to download\n");
 // FIXME: Modifer support later
 void System::bindKeyCommand(char *cmd, unsigned int key, int event)
 {
-	printf("Bound command '%s' -> event %i (0x%x key)\n", cmd, event, key);	
+	printf("Bound command '%s' -> event %i (0x%x key)\n", cmd, event, key);
 	mKeyEvents.Add(key, event);
 }
 
 
 	i = 0;
 	buffer[0] = 0;
-	
+
 	// Strip out whitespace and comments
 	while (fscanf(f, "%c", &c) != EOF)
 	{
 		if (line_comment && c != '\n')
 			continue;
-		
+
 		if (i > 254)
 		{
 			printf("loadResourceFile> Overflow handled\n");
 			i = 254;
 		}
-		
+
 		switch (c)
 		{
 		case '\v':
 			{
 				line_comment = false;
 			}
-			
+
 			if (buffer[0] == 0)
 			{
 				i = 0;
 				continue;
 			}
-			
+
 			buffer[i] = 0;
 			//printf("'%s'\n", buffer);
 
 						buffer[j-9] = buffer[j];
 						buffer[j-8] = 0;
 					}
-					
+
 					printf("Importing '%s'\n", buffer);
-					
+
 					loadResourceFile(fullPath(buffer, '/'));
 				}
 			}
 			buffer[i++] = c;
 		}
 	}
-	
+
 	fclose(f);
 
 	return 0;
 	// Set background to black
 	glClearColor(0.0, 0.0, 0.0, 1.0);
 
-	// Disable lighting 
+	// Disable lighting
 	glDisable(GL_LIGHTING);
 
 	// Set up alpha blending
-	if (m_fastCard) 
+	if (m_fastCard)
 	{
 		glEnable(GL_BLEND);
 		glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 	// Setup shading
 	glShadeModel(GL_SMOOTH);
 
-	if (m_fastCard) 
+	if (m_fastCard)
 	{
 		glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
 		glHint(GL_FOG_HINT, GL_NICEST);
 		glDisable(GL_COLOR_MATERIAL);
 		glEnable(GL_DITHER);
-		
+
 		// AA polygon edges
 		//glEnable(GL_POLYGON_SMOOTH);
 		//glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST);
 	}
 
 	glViewport(0, 0, w, h);
-	glMatrixMode(GL_PROJECTION); 
-	glLoadIdentity(); 
+	glMatrixMode(GL_PROJECTION);
+	glLoadIdentity();
 
 	// Adjust clipping
 	gluPerspective(m_fovY, ((GLdouble)w)/((GLdouble)h), m_clipNear, m_clipFar);
 // Gobal helper functions
 ////////////////////////////////////////////////////////////
 
-// Mongoose 2002.03.23, Checks command to see if it's same 
+// Mongoose 2002.03.23, Checks command to see if it's same
 //   as symbol, then returns the arg list in command buffer
 bool rc_command(char *symbol, char *command)
 {
 
 		return true;
 	}
-		
+
 	return false;
 }
 
 	{
 		return -1;
 	}
-	
+
 	if (strncmp(buffer, "true", 4) == 0)
 		*val = true;
 	else if (strncmp(buffer, "false", 5) == 0)
 		break;
 	case 1:
 		gettimeofday(&stop, &tz);
-		
-		if (start.tv_usec > stop.tv_usec) 
-		{ 
+
+		if (start.tv_usec > stop.tv_usec)
+		{
 #ifdef OBSOLETE
-			stop.tv_usec = (1000000 + stop.tv_usec); 
+			stop.tv_usec = (1000000 + stop.tv_usec);
 #else
-			stop.tv_usec = (1000 + stop.tv_usec); 
+			stop.tv_usec = (1000 + stop.tv_usec);
 #endif
-			stop.tv_sec--; 
-		} 
+			stop.tv_sec--;
+		}
 
-		stop.tv_usec -= start.tv_usec; 
+		stop.tv_usec -= start.tv_usec;
 		stop.tv_sec -= start.tv_sec;
 
 #ifdef OBSOLETE
 		total.tv_sec += stop.tv_sec;
 		total.tv_usec += stop.tv_usec;
 
-		while (total.tv_usec > 1000000) 
+		while (total.tv_usec > 1000000)
 		{
 			total.tv_usec -= 1000000;
-			total.tv_sec++; 
-		} 
+			total.tv_sec++;
+		}
 
 		return total.tv_sec * 1000000 + total.tv_usec;
 #else

src/System.h

 /* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
 /*================================================================
- * 
+ *
  * Project : UnRaider, OpenRaider, RaiderUnification 2003
  * Author  : Terry 'Mongoose' Hendrix II
  * Website : http://www.westga.edu/~stu7440/
  * Email   : stu7440@westga.edu
  * Object  : System
  * License : No use w/o permission (C) 2002 Mongoose
- * Comments: 
+ * Comments:
  *
  *
- *           This file was generated using Mongoose's C++ 
+ *           This file was generated using Mongoose's C++
  *           template generator script.  <stu7440@westga.edu>
- * 
+ *
  *-- Test Defines -----------------------------------------------
  *
- * UNIT_TEST_SYSTEM - Builds System class as a console unit test 
+ * UNIT_TEST_SYSTEM - Builds System class as a console unit test
  *
- *-- History ------------------------------------------------ 
+ *-- History ------------------------------------------------
  *
  * 2002.08.09:
  * Mongoose - Created
 #ifndef GUARD__UNRAIDER_MONGOOSE_SYSTEM_H_
 #define GUARD__UNRAIDER_MONGOOSE_SYSTEM_H_
 
-#include <mstl/Map.h>
-#include <mstl/Vector.h>
+#include "mstl/Map.h"
+#include "mstl/Vector.h"
 
 // TODO: Replace with unicode compatible key codes
 #define SYS_MOUSE_LEFT    6000
 #define SYS_KEY_F11       1010
 #define SYS_KEY_F12       1011
 
-typedef enum 
+typedef enum
 {
   SYS_MOD_KEY_LSHIFT = 1,
   SYS_MOD_KEY_RSHIFT = 2,
-  SYS_MOD_KEY_LCTRL  = 4, 
-  SYS_MOD_KEY_RCTRL  = 8, 
+  SYS_MOD_KEY_LCTRL  = 4,
+  SYS_MOD_KEY_RCTRL  = 8,
   SYS_MOD_KEY_LALT   = 16,
   SYS_MOD_KEY_RALT   = 32
 
 
 	System();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Constructs an object of System
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.08.09: 
+	 * 2002.08.09:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.08.09: 
+	 * 2002.08.09:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	 * 2003.06.03:
 	 * Mongoose - Made into a printf string caching system
 	 *
-    * 2001.12.31: 
+    * 2001.12.31:
     * Mongoose - Created, was GLString::glPrintf
     ------------------------------------------------------*/
 
 	static char *fullPath(char *path, char end);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Returns allocated string of path, with
 	 *        expansion of unix home enviroment char and
 	 *        makes sure string ends in "end" char
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.08.17: 
+	 * 2002.08.17:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	static char *getFileFromFullPath(char *filename);
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
 
 	virtual unsigned int getTicks();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Returns number of milliseconds since start of
 	 *        program
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.06.06: 
+	 * 2002.06.06:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
-	static int downloadToBuffer(char *urlString, 
+	static int downloadToBuffer(char *urlString,
 										 unsigned char **buffer, unsigned int *size);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Downloads something into passed buffer,
 	 *        Returns < 0 on error, 0 on sucess
 	 *
 
 	static int downloadToFile(char *urlString, char *filename);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Downloads something into a disk file,
 	 *        Returns < 0 on error, 0 on sucess
 	 *
 	 *        <Key> is a valid keyboard code
 	 *        <Event> is a valid game event Id
 	 *
-	 * Post : Sets <Event> binding <Cmd> to <Key> press 
+	 * Post : Sets <Event> binding <Cmd> to <Key> press
 	 *
 	 *-- History ------------------------------------------
 	 *
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2001.05.27: 
+	 * 2001.05.27:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	virtual void gameFrame() = 0;
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.08.09?: 
+	 * 2002.08.09?:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	virtual void handleMouseMotionEvent(float x, float y) = 0;
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.08.09?: 
+	 * 2002.08.09?:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	/*------------------------------------------------------
 	 * Pre  : <Key> is a valid keyboard code
 	 *
-	 * Post : Recieves <Event> bound to <Cmd> from <Key> press 
+	 * Post : Recieves <Event> bound to <Cmd> from <Key> press
 	 *
 	 *-- History ------------------------------------------
 	 *
 
 	virtual void handleCommand(char *command, unsigned int mode) = 0;
 	/*------------------------------------------------------
-	 * Pre  : <Command> is valid keyword optionally followed 
+	 * Pre  : <Command> is valid keyword optionally followed
 	 *        by ' ' (space) seperated and argument(s)
 	 *
 	 *        <Mode> is the current type or resource mode
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
-	virtual void handleConsoleKeyPressEvent(unsigned int key, 
+	virtual void handleConsoleKeyPressEvent(unsigned int key,
 														 unsigned int mod) = 0;
 	/*------------------------------------------------------
 	 * Pre  : <Key> is a valid keyboard code
 
 	virtual void handleKeyPressEvent(unsigned int key, unsigned int mod) = 0;
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.08.09?: 
+	 * 2002.08.09?:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	virtual void handleKeyReleaseEvent(unsigned int key, unsigned int mod) = 0;
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.08.09?: 
+	 * 2002.08.09?:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	virtual void initGL();
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.08.09?: 
+	 * 2002.08.09?:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
-	virtual void initVideo(unsigned int width, unsigned int height, 
+	virtual void initVideo(unsigned int width, unsigned int height,
 								  bool fullscreen) = 0;
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.08.09?: 
+	 * 2002.08.09?:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	virtual int loadResourceFile(char *filename);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Init the resource vars
 	 *
 	 *        Returns less than zero value on error
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2001.05.27: 
+	 * 2001.05.27:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	static void resetTicks();
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.08.09?: 
+	 * 2002.08.09?:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	virtual void resizeGL(unsigned int width, unsigned int height);
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.08.09?: 
+	 * 2002.08.09?:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	virtual void runGame() = 0;
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.08.09?: 
+	 * 2002.08.09?:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	void setConsoleMode(bool on);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Turns console key events on/off,
-	 *        mostly for allowing text entry vs key 
+	 *        mostly for allowing text entry vs key
 	 *        impluse commands
 	 *
 	 *-- History ------------------------------------------
 
 	void setDriverGL(const char *driver);
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.08.09?: 
+	 * 2002.08.09?:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	void setFastCardPerformance(bool isFast);
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.08.09?: 
+	 * 2002.08.09?:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	virtual void shutdown(int code) = 0;
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.08.09?: 
+	 * 2002.08.09?:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	virtual void swapBuffersGL() = 0;
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.08.09?: 
+	 * 2002.08.09?:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	virtual void toggleFullscreen() = 0;
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.08.09?: 
+	 * 2002.08.09?:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 
 	bool rc_command(char *symbol, char *command);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Returns true if <Command> matches <Symbol>
 	 *        command string
 	 *
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.03.23: 
+	 * 2002.03.23:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	/*------------------------------------------------------
 	 * Pre  : Buffer is "true" or "false"
 	 *
-	 * Post : Returns 0 if <Buffer> is "true" or "false" 
+	 * Post : Returns 0 if <Buffer> is "true" or "false"
 	 *        and sets <Val> accordingly
 	 *
 	 *        Returns -1 for null string
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.03.23: 
+	 * 2002.03.23:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.06.06: 
+	 * 2002.06.06:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 #endif

src/Texture.cpp

 /* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
 /*==========================================================================
- * 
+ *
  * Project : MTK, Freyja, OpenRaider
  * Author  : Terry 'Mongoose' Hendrix II
  * Website : http://www.westga.edu/~stu7440
  *
  *           See file COPYING for license details.
  *
- * 
- *-- History ---------------------------------------------------------- 
  *
- * 2003.06.30, 
+ *-- History ----------------------------------------------------------
+ *
+ * 2003.06.30,
  * Mongoose - API update, SDL_TTF support moved here, misc features
  *            SDL_TTF support based on Sam Lantinga's public domain
- *            SDL_TTF demo functions and algorithms 
+ *            SDL_TTF demo functions and algorithms
  *
  * 2001.05.29:
  * Mongoose - Removed legacy code and done clean up
 #   include <SDL/SDL_ttf.h>
 #endif
 
+#ifdef __APPLE__
+#include <OpenGL/gl.h>
+#include <OpenGL/glu.h>
+#else
 #include <GL/gl.h>
 #include <GL/glu.h>
+#endif
 
 #include "Texture.h"
 
 ////////////////////////////////////////////////////////////
 
 unsigned char *Texture::generateColorTexture(unsigned char rgba[4],
-															unsigned int width, 
+															unsigned int width,
 															unsigned int height)
 {
 	unsigned char *image;
 	if (s && s[0])
 	{
 		va_start(args, s);
-		vsnprintf(string, len-1, s, args);	
+		vsnprintf(string, len-1, s, args);
 		string[len-1] = 0;
 		va_end(args);
 	}
 	glBindTexture(GL_TEXTURE_2D, font->textureId);
 	glTranslatef(x, y, 0);
 	glScalef(scale, scale, 1);
-	
-	/* FIXME: 
+
+	/* FIXME:
 	 * Add utf-8 dencoding of char* string
 	 *
 	 *	Also this string must be preprocessed to have glyph offsets
 }
 
 
-void glPrint3d(float x, float y, float z, 
-					float pitch, float yaw, float roll, 
+void glPrint3d(float x, float y, float z,
+					float pitch, float yaw, float roll,
 					float scale,
 					char *string)
 {
 	glRotatef(yaw,   0, 1, 0);
 	glRotatef(pitch, 0, 0, 1);
 	glScalef(scale, scale, scale);
-	
-	/* FIXME: 
+
+	/* FIXME:
 	 * Add utf-8 dencoding of char* string
 	 *
 	 *	Also this string must be preprocessed to have glyph offsets
 }
 
 
-int Texture::loadFontTTF(char *filename, 
+int Texture::loadFontTTF(char *filename,
 								 unsigned int utf8Offset, unsigned int count)
 {
 	ttf_texture_t *texture;
 
 		gFontTest = generateFont(texture);
 
-		/* FIXME: Until UTF8 decoder is working, we map from 
+		/* FIXME: Until UTF8 decoder is working, we map from
 			ASCII when rendering */
 		gFontTest->utf8Offset = 32; // hack to use ASCII strings to test unicode
 
 #ifdef DEBUG_TTF_OFFSET
 		if (i+texture->utf8Offset == 'y' || i+texture->utf8Offset == 'x')
 		{
-			printf("%c: %i %i %i\n", 
+			printf("%c: %i %i %i\n",
 					 i+texture->utf8Offset,
 					 texture->fontDescent,
 					 texture->glyphs[i].miny, texture->glyphs[i].maxy);
 		glBegin(GL_QUADS);
 		 glTexCoord2f(u2, v);	/* Top, right */
 		 glVertex3i(texture->glyphs[i].w, h, 0);
-		
+
 		 glTexCoord2f(u, v);	/* Top, left */
 		 glVertex3i(0, h, 0);
 
 		 glTexCoord2f(u, v2);	/* Bottom, left */
 		 glVertex3i(0, h+texture->glyphs[i].h, 0);
-		
+
 		 glTexCoord2f(u2, v2);	/* Bottom, right */
 		 glVertex3i(texture->glyphs[i].w, h+texture->glyphs[i].h, 0);
 		glEnd();
-		
+
 		/* Move To The Left Of The Character */
 		glTranslated(texture->glyphs[i].w + spacing, 0, 0);
 		glEndList();
 }
 
 
-ttf_texture_t *Texture::generateFontTexture(char *filename, int pointSize, 
+ttf_texture_t *Texture::generateFontTexture(char *filename, int pointSize,
 														  unsigned int textureWidth,
 														  unsigned char color[3],
 														  unsigned int utf8Offset,
 	texture->glyphs = new ttf_glyph_t[count];
 	texture->texture = new unsigned char[textureWidth*textureWidth*4];
 	memset(texture->texture, 0, textureWidth*textureWidth*4);
-		
+
 	texture->fontHeight = TTF_FontHeight(font);
 	texture->fontAscent = TTF_FontAscent(font);
 	texture->fontDescent = TTF_FontDescent(font);
 	texture->fontSpacing = TTF_FontLineSkip(font);
 
-	for (i = 0; i < count; ++i) 
+	for (i = 0; i < count; ++i)
 	{
 		glyph = TTF_RenderGlyph_Blended(font, i + utf8Offset, sdlColor);
 
 	      image = (unsigned char*)glyph->pixels;
 
 			TTF_GlyphMetrics(font, i + utf8Offset,
-								  &texture->glyphs[i].minx, &texture->glyphs[i].maxx, 
+								  &texture->glyphs[i].minx, &texture->glyphs[i].maxx,
 								  &texture->glyphs[i].miny, &texture->glyphs[i].maxy,
 								  &texture->glyphs[i].advance);
 
 	      texture->glyphs[i].w = glyph->w;
 	      texture->glyphs[i].h = glyph->h;
-			
+
 	      if (xx + texture->glyphs[i].w > ((int)textureWidth - 1))
 	      {
 				yy += hh;
 				texture->glyphs[i].x = xx;
 				texture->glyphs[i].y = yy;
 	      }
-			
+
 	      xx += glyph->w;
-			
+
 			if (verbose)
 			{
 				printf("0x%x : %ix%i @ %i, %i\n", i + utf8Offset,
-						 texture->glyphs[i].w, texture->glyphs[i].h, 
+						 texture->glyphs[i].w, texture->glyphs[i].h,
 						 texture->glyphs[i].x, texture->glyphs[i].y);
 			}
 
 				w = texture->glyphs[i].x + k%glyph->w;
 				h = texture->glyphs[i].y + k/glyph->w;
 				offset = (w + h*textureWidth);
-				
+
 				if (verbose)
 				{
-					printf("Offset: %i; Pixel: %i,%i; Data: 0x%08x\n", 
+					printf("Offset: %i; Pixel: %i,%i; Data: 0x%08x\n",
 							 offset, w, h, *((unsigned int *)&image[k*4]));
 				}
-				
+
 				/* 32-bit ARGB to RGBA */
 				b = image[k*4+3];
 				texture->texture[offset*4]   = image[k*4]   = image[k*4+1];
 		fprintf(stderr, "initSDL_TTF> Error is [%s].\n", SDL_GetError());
 	}
 	else
-	{	
+	{
 		mFlags |= fUseSDL_TTF;
 
 		printf("@ Started SDL_TTF subsystem...\n");
 void Texture::bindMultiTexture(int texture0, int texture1)
 {
 	if (//(int)a == mTextureId && (int)b == mTextureId2 ||
-		 !mTextureIds || 
+		 !mTextureIds ||
 		 texture0 < 0 || texture0 > (int)mTextureCount ||
 		 texture1 < 0 || texture1 > (int)mTextureCount)
    {
 
 
 
-int Texture::loadBuffer(unsigned char *image, 
+int Texture::loadBuffer(unsigned char *image,
 								unsigned int width, unsigned int height,
 								ColorMode mode, unsigned int bpp)
 {
 }
 
 
-void convertARGB32bppToRGBA32bpp(unsigned char *image, 
+void convertARGB32bppToRGBA32bpp(unsigned char *image,
 											unsigned int w, unsigned int h)
 {
 	unsigned int i, size = w*h;
 }
 
 
-int Texture::loadBufferSlot(unsigned char *image, 
+int Texture::loadBufferSlot(unsigned char *image,
 									 unsigned int width, unsigned int height,
 									 ColorMode mode, unsigned int bpp,
 									 unsigned int slot)
 			printf("Texture::Load> ERROR Unsupported GREYSCALE, %i bpp\n", bpp);
 			return -2;
 		}
-		
+
 		bytes = 1;
 		glcMode = GL_LUMINANCE;
 		break;
 			printf("Texture::Load> ERROR Unsupported RGBA, %i bpp\n", bpp);
 			return -2;
 		}
-		
+
 		bytes = 3;
 		glcMode = GL_RGB;
 		break;
 			printf("Texture::Load> ERROR Unsupported RGBA/ARGB, %i bpp\n", bpp);
 			return -2;
 		}
-		
+
 		bytes = 4;
 		glcMode = GL_RGBA;
 		break;
 	glClearColor(0.0, 0.0, 0.0, 0.0);
 	glEnable(GL_DEPTH_TEST);
 	glShadeModel(GL_SMOOTH);
-  
+
 	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 
 	glBindTexture(GL_TEXTURE_2D, mTextureIds[slot]);
 
 	if (mFlags & fUseMipmaps)
 	{
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, 
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
 							 GL_NEAREST_MIPMAP_LINEAR);
 		//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, 
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
 							 GL_LINEAR_MIPMAP_LINEAR);
-		
+
 		gluBuild2DMipmaps(GL_TEXTURE_2D, bytes, width, height,
 								glcMode, GL_UNSIGNED_BYTE, image);
 	}
 	else
 	{
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-		
+
 		glTexImage2D(GL_TEXTURE_2D, 0, glcMode, width, height, 0,
 						 glcMode, GL_UNSIGNED_BYTE, image);
 	}
   while (!done)
   {
     snprintf(filename, 1024, "%s-%03i.png", base, count++);
-    
+
     f = fopen(filename, "rb");
 
     if (f)
 
   mtk_image__png_save(f, image, width, height, 3);
   fclose(f);
-	
+
   delete [] image;
 
   printf("glScreenShot> Took screenshot '%s'.\n", filename);
   bool done = false;
   int i, j, size;
   unsigned char comment_lenght;
-  unsigned char colormap_type; 
-  unsigned char image_type;    
-  unsigned short colormap_index;      
-  unsigned short colormap_lenght;     
-  unsigned char colormap_bbp;         
+  unsigned char colormap_type;
+  unsigned char image_type;
+  unsigned short colormap_index;
+  unsigned short colormap_lenght;
+  unsigned char colormap_bbp;
   unsigned short origin_x;
   unsigned short origin_y;
-  unsigned short swidth;   
-  unsigned short sheight;  
+  unsigned short swidth;
+  unsigned short sheight;
   char comment[32] = "Mongoose TGA 0.0.1\0";
   unsigned char tmp, bpp, desc_flags;
 
   while (!done)
   {
     snprintf(filename, 1024, "%s-%04i.tga", base, count++);
-    
+
     f = fopen(filename, "rb");
 
     if (f)
 
   // Write TGA header
   fwrite(&comment_lenght, 1, 1, f);
-  fwrite(&colormap_type, 1, 1, f); 
+  fwrite(&colormap_type, 1, 1, f);
   fwrite(&image_type, 1, 1, f);
   fwrite(&colormap_index, 2, 1, f);
   fwrite(&colormap_lenght, 2, 1, f);
   fwrite(&comment, 1, comment_lenght, f);
 
   size = width * height * 3;
- 
+
   for (i = 0; i < size; i += 3)
   {
     tmp = image[i];
 
 
 	f = fopen(filename, "rb");
-  
+
 	if (!f)
 	{
 		perror("Couldn't load file");
 			image = image2;
 			w = h = 256;
 		}
-		
+
 		if (image)
 		{
 			id = loadBuffer(image, w, h,
 
 
 	f = fopen(filename, "rb");
-  
+
 	if (!f)
 	{
 		perror("Couldn't load file");
 
 		if (image)
 		{
-			id = loadBuffer(image, w, h, 
+			id = loadBuffer(image, w, h,
 								 (type == 4) ? RGBA : RGB,
 								 (type == 4) ? 32 : 24);
-			
+
 			printf("%c", (id == -1) ? 'x' : 'o');
 			fflush(stdout);
 
 {
   int i;
 
-  for(i = 1; i < seed; i *= 2) 
+  for(i = 1; i < seed; i *= 2)
     ;
 
   return i;
 
 
 /* This code based off on gluScaleImage()  */
-unsigned char *Texture::scaleBuffer(unsigned char *image, 
-												int width,  int height,	
+unsigned char *Texture::scaleBuffer(unsigned char *image,
+												int width,  int height,
 												int components)
 {
    int i, j, k;
    height = nextPower(height);
    width = nextPower(width);
 
-   if (height > 256) 
+   if (height > 256)
      height = 256;
-    
-   if (width > 256) 
+
+   if (width > 256)
      width = 256;
 
    // Check to see if scaling is needed
-   if (height == original_height && width == original_width) 
+   if (height == original_height && width == original_width)
 		return NULL;
 
 	//printf("%i\n", components);
    }
 
    // Copy user data to float format.
-   for (i = 0; i < original_height * original_width * components; ++i) 
+   for (i = 0; i < original_height * original_width * components; ++i)
    {
      tempin[i] = (float)image[i];
    }
 
    // Determine which filter to use by checking ratios.
-   if (width > 1) 
+   if (width > 1)
    {
      sx = (float)(original_width - 1) / (float)(width - 1);
-   } 
-   else 
+   }
+   else
    {
      sx = (float)(original_width - 1);
    }
    if (height > 1)
    {
      sy = (float)(original_height - 1) / (float) (height - 1);
-   } 
-   else 
+   }
+   else
    {
      sy = (float)(original_height - 1);
    }
 
-   if (sx < 1.0 && sy < 1.0) 
+   if (sx < 1.0 && sy < 1.0)
    {
      /* Magnify both width and height:  use weighted sample of 4 pixels */
      int i0, i1, j0, j1;
      float s1, s2;
      float* dst;
 
-     for(i = 0; i < height; ++i) 
+     for(i = 0; i < height; ++i)
      {
        i0 = (int)(i * sy);
        i1 = i0 + 1;
 
-       if (i1 >= original_height) 
+       if (i1 >= original_height)
        {
 			 i1 = original_height - 1;
        }
 
        alpha = i * sy - i0;
 
-       for (j = 0; j < width; ++j) 
+       for (j = 0; j < width; ++j)
        {
 			 j0 = (int) (j * sx);
 			 j1 = j0 + 1;
 
-			 if (j1 >= original_width) 
+			 if (j1 >= original_width)
 			 {
 				 j1 = original_width - 1;
 			 }
 
 			 dst = tempout + (i * width + j) * components;
 
-			 for (k = 0; k < components; ++k) 
+			 for (k = 0; k < components; ++k)
 			 {
 				 s1 = *src00++ * (1.0 - beta) + *src01++ * beta;
 				 s2 = *src10++ * (1.0 - beta) + *src11++ * beta;
 				 *dst++ = s1 * (1.0 - alpha) + s2 * alpha;
-			 } 
+			 }
        }
-     }     
+     }
    }
-   else 
+   else
    {
      /* Shrink width and/or height:  use an unweighted box filter */
      int i0, i1;
      float sum;
      float* dst;
 
-     for (i = 0; i < height; ++i) 
+     for (i = 0; i < height; ++i)
      {
        i0 = (int) (i * sy);
        i1 = i0 + 1;
 
-       if (i1 >= original_height) 
+       if (i1 >= original_height)
        {
 			 i1 = original_height - 1;
        }
 
-       for (j = 0; j < width; ++j) 
+       for (j = 0; j < width; ++j)
        {
 			 j0 = (int) (j * sx);
 			 j1 = j0 + 1;
 
-			 if (j1 >= original_width) 
+			 if (j1 >= original_width)
 			 {
 				 j1 = original_width - 1;
 			 }
 			 dst = tempout + (i * width + j) * components;
 
 			 /* Compute average of pixels in the rectangle (i0,j0)-(i1,j1) */
-			 for (k = 0; k < components; ++k) 
+			 for (k = 0; k < components; ++k)
 			 {
 				 sum = 0.0;
 
-				 for (ii = i0; ii <= i1; ++ii) 
+				 for (ii = i0; ii <= i1; ++ii)
 				 {
-					 for (jj = j0; jj <= j1; ++jj) 
+					 for (jj = j0; jj <= j1; ++jj)
 					 {
-						 sum += *(tempin + (ii * original_width + jj) 
+						 sum += *(tempin + (ii * original_width + jj)
 									 * components + k);
 					 }
 				 }
 				 sum /= ( j1 - j0 + 1 ) * ( i1 - i0 + 1 );
 				 *dst++ = sum;
 			 }
-       } 
+       }
      }
    }
 
    // Copy to our results.
-   for( i = 0; i < height * width * components; ++i) 
+   for( i = 0; i < height * width * components; ++i)
    {
      timage[i] = (unsigned char)tempout[i];
    }

src/World.h

 /* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
 /*================================================================
- * 
+ *
  * Project : OpenRaider
  * Author  : Terry 'Mongoose' Hendrix II
  * Website : http://www.westga.edu/~stu7440/
  * Comments: The game world ( model )
  *
  *
- *           This file was generated using Mongoose's C++ 
+ *           This file was generated using Mongoose's C++
  *           template generator script.  <stu7440@westga.edu>
- * 
+ *
  *-- Test Defines -----------------------------------------------
- *           
- * UNIT_TEST_WORLD - Builds World class as a console unit test 
  *
- *-- History ------------------------------------------------ 
+ * UNIT_TEST_WORLD - Builds World class as a console unit test
+ *
+ *-- History ------------------------------------------------
  *
  * 2002.12.16:
  * Mongoose - Created
 #   include "SkeletalModel.h"
 #endif
 
-#include <mstl/List.h>
-#include <mstl/Vector.h>
-#include <hel/math.h>
-#include <hel/Mass.h>
+#include "mstl/List.h"
+#include "mstl/Vector.h"
+#include "hel/math.h"
+#include "hel/Mass.h"
 
 
 // Mirrors TombRaider class' room flags really
 
 typedef struct sprite_s
 {
-	int num_verts; // 4 == Quad, 3 == Triangle, renderered as triangles 
+	int num_verts; // 4 == Quad, 3 == Triangle, renderered as triangles
 	vertex_t vertex[4];
 	texel_t texel[4];
 	float pos[3];
 	float radius; // yeah, I know
-	int texture;	
+	int texture;
 
 } sprite_t;
 
 	int index;     // model_mesh index
 	float yaw;     // angle of rotation on Y
 	float pos[3];  // position
-	
+
 	//vec3_t bboxMax;
 	//vec3_t bboxMin;
 
 
 
 // Workout generic entity and a client class from these entities
-typedef struct world_entity_s 
+typedef struct world_entity_s
 {
 	vec3_t pos;
 	vec3_t lastPos;
 } world_entity_t;
 
 
-typedef struct actor_entity_s 
+typedef struct actor_entity_s
 {
 	vec3_t pos;
 	vec3_t lastPos;
 
 	World();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Constructs an object of World
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.12.16: 
+	 * 2002.12.16:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.12.16: 
+	 * 2002.12.16:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	 *-- History ------------------------------------------
 	 *
 	 * 2002.12.20:
-	 * Mongoose - Created, factored out of Render class 
+	 * Mongoose - Created, factored out of Render class
 	 ------------------------------------------------------*/
 
 	int getRoomByLocation(float x, float y, float z);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Returns correct room index or -1 for unknown
 	 *
-	 *        NOTE: If it fails to be in a room it gives 
+	 *        NOTE: If it fails to be in a room it gives
 	 *        closest overlapping room
 	 *
 	 *-- History ------------------------------------------
 	 *
 	 * 2002.12.20:
-	 * Mongoose - Created, factored out of Render class 
+	 * Mongoose - Created, factored out of Render class
 	 ------------------------------------------------------*/
 
-	int getAdjoiningRoom(int index, 
+	int getAdjoiningRoom(int index,
 								float x, float y, float z,
 								float x2, float y2, float z2);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Looks for portal crossings from xyz to xyz2 segment
 	 *        from room[index] returns index of adjoined room or -1
 	 *
 	 *-- History ------------------------------------------
 	 *
 	 * 2002.12.20:
-	 * Mongoose - Created, factored out of Render class 
+	 * Mongoose - Created, factored out of Render class
 	 ------------------------------------------------------*/
 
 	unsigned int getRoomInfo(int room);
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
 	 *-- History ------------------------------------------
 	 *
 	 * 2002.12.20:
-	 * Mongoose - Created, factored out of Render class 
+	 * Mongoose - Created, factored out of Render class
 	 ------------------------------------------------------*/
 
 	bool getHeightAtPosition(int index, float x, float *y, float z);
 	 *-- History ------------------------------------------
 	 *
 	 * 2002.12.20:
-	 * Mongoose - Created, factored out of Render class 
+	 * Mongoose - Created, factored out of Render class
 	 ------------------------------------------------------*/
 
 	// Temp methods for rendering use until more refactoring is done
 	////////////////////////////////////////////////////////////
 	// Public Mutators
 	////////////////////////////////////////////////////////////
-	
+
 	void setFlag(WorldFlag flag);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Sets option flag
 	 *
 	 *-- History ------------------------------------------
 	 *
 	 * 2002.12.20:
-	 * Mongoose - Created, factored out of Render class 
+	 * Mongoose - Created, factored out of Render class
 	 ------------------------------------------------------*/
 
 	void clearFlag(WorldFlag flag);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Clears option flag
 	 *
 	 *-- History ------------------------------------------
 	 *
 	 * 2002.12.20:
-	 * Mongoose - Created, factored out of Render class 
+	 * Mongoose - Created, factored out of Render class
 	 ------------------------------------------------------*/
 
 	void destroy();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Clears all data in world, in future will check
 	 *        if data is in use before clearing
 	 *
 
 	void addRoom(room_mesh_t *room);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Adds object to world
 	 *
 	 *-- History ------------------------------------------
 	 *
 	 * 2002.12.20:
-	 * Mongoose - Created, factored out of Render class 
+	 * Mongoose - Created, factored out of Render class
 	 ------------------------------------------------------*/
-	
+
 	void addMesh(model_mesh_t *model);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Adds object to world
 	 *
 	 *-- History ------------------------------------------
 	 *
 	 * 2002.12.20:
-	 * Mongoose - Created, factored out of Render class 
+	 * Mongoose - Created, factored out of Render class
 	 ------------------------------------------------------*/
 
 	void addEntity(entity_t *e);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Adds object to world
 	 *
 	 *-- History ------------------------------------------
 	 *
 	 * 2002.12.20:
-	 * Mongoose - Created, factored out of Render class 
+	 * Mongoose - Created, factored out of Render class
 	 ------------------------------------------------------*/
 
 	int addModel(skeletal_model_t *model);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Adds object to world, returns next model Id
 	 *        or -1 if failed to add model to world
 	 *
 	 *-- History ------------------------------------------
 	 *
 	 * 2002.12.20:
-	 * Mongoose - Created, factored out of Render class 
+	 * Mongoose - Created, factored out of Render class
 	 ------------------------------------------------------*/
 
 	void addSprite(sprite_seq_t *sprite);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Adds object to world
 	 *
 	 *-- History ------------------------------------------
 	 *
 	 * 2002.12.20:
-	 * Mongoose - Created, factored out of Render class 
+	 * Mongoose - Created, factored out of Render class
 	 ------------------------------------------------------*/
 
 	void moveEntity(entity_t *e, char movement);
 
 	void clear();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Clears all data in world
 	 *
 	 *-- History ------------------------------------------

src/hel/CollisionObject.cpp

+/* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
+/*================================================================
+ *
+ * Project : libHel
+ * Author  : Terry 'Mongoose' Hendrix II
+ * Website : http://www.westga.edu/~stu7440/
+ * Email   : stu7440@westga.edu
+ * Object  : CollisionObject
+ * License : No use w/o permission (C) 2002 Mongoose
+ * Comments: Bounding volume class for world/vis
+ *           culling/clipping/collision stuff
+ *
+ *
+ *           This file was generated using Mongoose's C++
+ *           template generator script.  <stu7440@westga.edu>
+ *
+ *-- History -------------------------------------------------
+ *
+ * 2002.11.27:
+ * Mongoose - Created
+ =================================================================*/
+
+#include "CollisionObject.h"
+
+
+////////////////////////////////////////////////////////////
+// Constructors
+////////////////////////////////////////////////////////////
+
+CollisionObject::CollisionObject()
+{
+}
+
+
+CollisionObject::~CollisionObject()
+{
+}
+
+
+////////////////////////////////////////////////////////////
+// Public Accessors
+////////////////////////////////////////////////////////////
+
+bool CollisionObject::intersectPoint(Vector3d p) {
+    return 0;
+}
+
+////////////////////////////////////////////////////////////
+// Public Mutators
+////////////////////////////////////////////////////////////
+
+
+////////////////////////////////////////////////////////////
+// Private Accessors
+////////////////////////////////////////////////////////////
+
+
+////////////////////////////////////////////////////////////
+// Private Mutators
+////////////////////////////////////////////////////////////
+
+
+////////////////////////////////////////////////////////////
+// Unit Test code
+////////////////////////////////////////////////////////////
+
+#ifdef UNIT_TEST_CollisionObject
+int runCollisionObjectUnitTest()
+{
+	CollisionObject col;
+
+	return 0;
+}
+
+
+int main(int argc, char *argv[])
+{
+	printf("[CollisionObject class test]\n");
+
+	runCollisionObjectUnitTest();
+
+	return 0;
+}
+#endif

src/hel/CollisionObject.h

+/* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
+/*================================================================
+ *
+ * Project : libHel
+ * Author  : Terry 'Mongoose' Hendrix II
+ * Website : http://www.westga.edu/~stu7440/
+ * Email   : stu7440@westga.edu
+ * Object  : CollisionObject
+ * License : No use w/o permission (C) 2002 Mongoose
+ * Comments: Bounding volume class for world/vis
+ *           culling/clipping/collision stuff
+ *
+ *
+ *           This file was generated using Mongoose's C++
+ *           template generator script.  <stu7440@westga.edu>
+ *
+ *-- Test Defines -----------------------------------------------
+ *
+ * UNIT_TEST_BOUNDINGVOLUME - Builds BoundingVolume class unit test
+ *
+ *-- History ------------------------------------------------
+ *
+ * 2002.11.27:
+ * Mongoose - Created
+ ================================================================*/
+
+
+#ifndef GUARD__LIBHEL_MONGOOSE_COLLISIONOBJECT_H_
+#define GUARD__LIBHEL_MONGOOSE_COLLISIONOBJECT_H_
+
+#include <hel/Vector3d.h>
+
+class CollisionObject
+{
+ public:
+
+	////////////////////////////////////////////////////////////
+	// Constructors
+	////////////////////////////////////////////////////////////
+
+	CollisionObject();
+	/*------------------------------------------------------
+	 * Pre  :
+	 * Post : Constructs an object of CollisionObject
+	 *
+	 *-- History ------------------------------------------
+	 *
+	 * 2002.11.27:
+	 * Mongoose - Created
+	 ------------------------------------------------------*/
+
+	~CollisionObject();
+	/*------------------------------------------------------
+	 * Pre  : CollisionObject object is allocated
+	 * Post : Deconstructs an object of CollisionObject
+	 *
+	 *-- History ------------------------------------------
+	 *
+	 * 2002.11.27:
+	 * Mongoose - Created
+	 ------------------------------------------------------*/
+
+
+	////////////////////////////////////////////////////////////
+	// Public Accessors
+	////////////////////////////////////////////////////////////
+
+    bool intersectPoint(Vector3d p);
+
+	////////////////////////////////////////////////////////////
+	// Public Mutators
+	////////////////////////////////////////////////////////////
+
+    Vector3d mIntersection;
+
+
+ private:
+
+	////////////////////////////////////////////////////////////
+	// Private Accessors
+	////////////////////////////////////////////////////////////
+
+
+	////////////////////////////////////////////////////////////
+	// Private Mutators
+	////////////////////////////////////////////////////////////
+
+
+	/* */
+};
+
+#endif

src/hel/Simulation.h

 /* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
 /*================================================================
- * 
+ *
  * Project : Hel
  * Author  : Terry 'Mongoose' Hendrix II
  * Website : http://www.westga.edu/~stu7440/
  * Comments: This class simulates mass physics
  *
  *
- *           This file was generated using Mongoose's C++ 
+ *           This file was generated using Mongoose's C++
  *           template generator script.  <stu7440@westga.edu>
- * 
+ *
  *-- Test Defines -----------------------------------------------
- *           
- * UNIT_TEST_SIMULATION - Builds Simulation class as a console unit test 
  *
- *-- History ------------------------------------------------ 
+ * UNIT_TEST_SIMULATION - Builds Simulation class as a console unit test
+ *
+ *-- History ------------------------------------------------
  *
  * 2003.06.08:
  * Mongoose - Generic collision and basic resolution w/o generic
 
 	Simulation();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Constructs an object of Simulation
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2003.06.02: 
+	 * 2003.06.02:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2003.06.02: 
+	 * 2003.06.02:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 
 	Mass *getMass(unsigned int i);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Get <i>th Mass element of this simulation
 	 *
 	 *-- History ------------------------------------------
 
 	virtual void attachCollisionObject(CollisionObject *obj);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Adds <Obj> to the collision list for this simulation
 	 *
 	 * TODO : Allow multiple types of collision to be excluded?
 
 	virtual void clear();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Removes all masses from this simulation
 	 *
 	 *-- History ------------------------------------------
 
 	virtual bool collisionDetected(Mass *mass);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Returns true if <Mass> collided with object
 	 *
 	 *-- History ------------------------------------------
 
 	virtual void generateMasses(unsigned int count, vec_t mass);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : <Count> number of masses with <mass> value are added
 	 *
 	 *-- History ------------------------------------------
 	 ------------------------------------------------------*/
 
 	virtual void generateMasses(unsigned int count, vec_t mass,
-										 const Vector3d &position, 
+										 const Vector3d &position,
 										 const Vector3d &velocity);
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : <Count> number of masses with 
+	 * Pre  :
+	 * Post : <Count> number of masses with
 	 *        <mass>, <position>, and <velocity> are added
 	 *
 	 *-- History ------------------------------------------
 
 	virtual void init();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Reset forces acting on masses
 	 *
 	 *-- History ------------------------------------------
 
 	virtual void resolveCollision(Mass *mass, CollisionObject *obj);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Resolves a collision of <Obj> and <Mass>
 	 *
 	 *        The default resolution here is to set mass pos
 
 	virtual void run(vec_t timeDelta);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Does full init, solve, simulate cycle
 	 *
 	 *-- History ------------------------------------------
 
 	virtual void simulate(vec_t timeDelta);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Update change in time for each mass
 	 *
 	 *-- History ------------------------------------------
 	virtual void solve ();
 	/*------------------------------------------------------
 	 * Pre  :
-	 * Post : Have forces act on masses  
+	 * Post : Have forces act on masses
 	 *
 	 *-- History ------------------------------------------
 	 *
 {
 public:
 
-	GravitySimulation() : Simulation()      
+	GravitySimulation() : Simulation()
 	{
 		gravitation = Vector3d(0.0f, -9.81f, 0.0f);
 	}
 
 
-	virtual void solve()                                                    
+	virtual void solve()
 	{
 		Mass *m;
 
 
 			// Gravitational force, Force = (Mass)(Gravity)
 			m->applyForce(gravitation * m->mMass);
-			
+
 			if (collisionDetected(m))
 			{
 				m->mVelocity = Vector3d(0, 0, 0);
 	{
 	}
 
-	
+
 	virtual void generateMasses(unsigned int count, vec_t mass,
-										 const Vector3d &position, 
+										 const Vector3d &position,
 										 const Vector3d &velocity)
 	{
-		Simulation::generateMasses(count, mass, 
+		Simulation::generateMasses(count, mass,
 											connectionPos + position, velocity);
 	}
 
 
 			// Vector from mass to spring connection
 			Vector3d springVector = m->mPos - connectionPos;
-			
+
 			// Apply spring force, spring force formulation
 			m->applyForce(-springVector * springConstant);
 

src/mstl/Tree.h

 /* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
 /*================================================================
- * 
+ *
  * Project : Freyja
  * Author  : Mongoose
  * Website : http://gooseegg.sourceforge.net/
  *           2. The root node must be black.
  *           3. Every leaf node is black. (null pointers)
  *           4. If a node is red, then both its children are black.
- *           5. Every simple path from a node to a descendant 
+ *           5. Every simple path from a node to a descendant
  *              leaf contains the same number of black nodes.
  *           6. Any path from the root to a leaf must not have
  *              adjacent red nodes.
  *
  *
- *           This file was generated using Mongoose's C++ 
+ *           This file was generated using Mongoose's C++
  *           template generator script.  <stu7440@westga.edu>
- * 
- *-- History ------------------------------------------------ 
+ *
+ *-- History ------------------------------------------------
  *
  * 2002.02.17:
  * Mongoose - Rewritten as a Red-Black tree
  *
  * 2002.02.16:
- * Mongoose - Dug out of cobwebs and fixed up 
+ * Mongoose - Dug out of cobwebs and fixed up
  *            Yes, I believe in code reuse!  =)
  *
  * 2000.10.26:
 {
 	_tree_h_black,
 	_tree_h_red
-	
+
 }  _tree_h_color_t;
 
 
 
 
 	~TreeNode()
-	{		
+	{
 		TreeNode<Key, Data> *left;
 		TreeNode<Key, Data> *right;
 
 			left->SetParent(NULL);
 			delete left;
 		}
-			
+
 		if (right)
 		{
 			right->SetParent(NULL);
 
 	/// Left, child ///////////////////////////////
 
-	TreeNode<Key, Data> *GetChild() 
+	TreeNode<Key, Data> *GetChild()
 	{
-		return Left();
+		return GetLeft();
 	}
 
-	
-	void SetChild(TreeNode<Key, Data> *tree) 
+
+	void SetChild(TreeNode<Key, Data> *tree)
 	{
 		Left(tree);
 	}
 
 
-	TreeNode<Key, Data> *GetLeft() 
+	TreeNode<Key, Data> *GetLeft()
 	{
 		return _left;
 	}
 
 
 	void SetLeft(TreeNode<Key, Data> *tree)
-	{	
+	{
 		if (tree == this)
 		{
 			return;
 		{
 			tree->SetParent(this);
 		}
-	} 
+	}
 
 	/// Right, sibling ///////////////////////////
 
-	TreeNode<Key, Data> *GetSibling() 
+	TreeNode<Key, Data> *GetSibling()
 	{
-		return Right();
+		return GetRight();
 	}
 
 
-	void SetSibling(TreeNode<Key, Data> *tree) 
+	void SetSibling(TreeNode<Key, Data> *tree)
 	{
-		Right(tree);
+		SetRight(tree);
 	}
 
 
-	TreeNode<Key, Data> *GetRight() 
+	TreeNode<Key, Data> *GetRight()
 	{
 		return _right;
 	}
 
 
 	void SetRight(TreeNode<Key, Data> *tree)
-	{		
+	{
 		if (tree == this)
 		{
 			return;
 	}
 
 
-	void PrintInorder() 
+	void PrintInorder()
 	{
 		if (_left)
 		{
 		}
 
 		PrintNode();
-    
+
 		if (_right)
 		{
 			//cout << ", ";
 			}
 			else
 			{
-				_right->Insert(tree);     
+				_right->Insert(tree);
 			}
 		}
 	}
 template <class Key, class Data> class Tree
 {
 public:
-	
+
 	Tree()
 	{
 		_error = false;
 	{
 		Clear();
 	}
-  
+
 
 	unsigned int NumElements()
 	{
 		}
 
 		seeking = _root->SearchByKey(key, error);
-		
+
 		if (seeking)
 		{
 			return seeking->GetData();
 		}
 
 		seeking = _root->SearchByData(data, error);
-		
+
 		if (seeking)
 		{
 			return seeking->GetKey();
 		if (_root)
 		{
 #ifdef OBSOLETE
-			// Mongoose 2002.02.18, To remove duplicates 
+			// Mongoose 2002.02.18, To remove duplicates
 			erorr = false;
 
 			while (!error)
 		}
 
 		return error;
-	}  
+	}
 
 
 	void Erase()
 				}
 			}
 
-			cout << "(" << tree->GetKey() << ", " 
+			cout << "(" << tree->GetKey() << ", "
 				  << ((tree->GetColor() == _tree_h_red) ? "red" : "blk")
 				  << ")";
 
 			return;
 		}
 		else if (seek < height)
-		{			
+		{
 			return;
 		}
 
 		{
 			cout << "(-, blk) ";
 		}
-		
+
 		if (right)
 		{
 			PrintTree(right, height, seek, rightmost);
 		PrintTree(_root, 0, 0, true);
 		cout << endl << "Nodes marked with * are in error" << endl;
 	}
-  
+
 
 	void Print()
 	{
-		cout << "Tree: " << _num_elements <<" elements {" << endl;    
+		cout << "Tree: " << _num_elements <<" elements {" << endl;
 
 		if (_root)
 		{
 			}
 
 			return predecessor;
-		}		
+		}
 	}
 
 
 			}
 			else
 			{
-				parent->SetRight(right);				
+				parent->SetRight(right);
 			}
 		}
 		else // TreeNode 'tree' was root, so now right is root
 
 		if (left)
 		{
-        left->SetParent(tree->GetParent());  
+        left->SetParent(tree->GetParent());
 		}
 
 		parent = tree->GetParent();
 	}
 
 
-	void TreeNodeShallowCopy(TreeNode<Key, Data> *src, 
+	void TreeNodeShallowCopy(TreeNode<Key, Data> *src,
 									 TreeNode<Key, Data> *dest, bool no_links)
 	{
 		if (!src || !dest)
 		}
 		else
 		{
-			cur = prev->GetRight();  
+			cur = prev->GetRight();
 		}
 
 		if (cur)
 		if (prev != tree)
 		{
 			TreeNodeShallowCopy(prev, tree, true);
-			
+
 			if (prev->GetParent())
 			{
 				if (prev == (prev->GetParent())->GetLeft())
 			prev->SetParent(NULL);
 			prev->SetLeft(NULL);
 
-			delete prev;     
+			delete prev;
 		}
 
 		if (tree->GetColor() == _tree_h_black)
 
 		parent = tree->GetParent();
 
-		while ((tree != _root) && (parent->GetColor() == _tree_h_black)) 
+		while ((tree != _root) && (parent->GetColor() == _tree_h_black))
 		{
-			if (tree == parent->GetLeft()) 
+			if (tree == parent->GetLeft())
 			{
 				sibling = parent->GetRight();
 
-				if (sibling && sibling->GetColor() == _tree_h_red) 
+				if (sibling && sibling->GetColor() == _tree_h_red)
 				{
 					sibling->SetColor(_tree_h_black);
 					parent->SetColor(_tree_h_red);
 		}
 
 		tree->SetColor(_tree_h_red);
-		
+
 		parent = tree->GetParent();
 
-		while ((tree != _root) && (parent->GetColor() == _tree_h_red)) 
+		while ((tree != _root) && (parent->GetColor() == _tree_h_red))
 		{
 			grandparent = parent->GetParent();
-			
-			if (parent == grandparent->GetLeft()) 
+
+			if (parent == grandparent->GetLeft())
 			{
 				uncle = grandparent->GetRight();
 
-				if (uncle && uncle->GetColor() == _tree_h_red) 
+				if (uncle && uncle->GetColor() == _tree_h_red)
 				{
                // Case 1 - Change the colors
                parent->SetColor(_tree_h_black);
 			else // TreeNode 'tree' is in right subtree
 			{
 				uncle = grandparent->GetLeft();
-								
-				if (uncle && uncle->GetColor() == _tree_h_red) 
+
+				if (uncle && uncle->GetColor() == _tree_h_red)
 				{
                // Case 1 - Change the colors
                parent->SetColor(_tree_h_black);

src/mstl/Vector.h

 /* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
 /*================================================================
- * 
+ *
  * Project : Freyja
  * Author  : Mongoose
  * Website : http://www.westga.edu/~stu7440/
  * Comments: mtk template vector
  *
  *           UINT_MAX is an error condition, used in place of -1
- * 
- *           This file was generated using Mongoose's C++ 
+ *
+ *           This file was generated using Mongoose's C++
  *           template generator script.  <stu7440@westga.edu>
- * 
- *-- History ------------------------------------------------ 
+ *
+ *-- History ------------------------------------------------
  *
  * 2002.08.31:
  * Mongoose - Created
 			delete [] mData;
 		}
 
-		clear();		
+		clear();
 		mReserve = 0;
 	}
 
 	{
 		unsigned int i;
 		Object *swap = 0x0;
-		
+
 
 		if (count > mReserve)
 		{
 			{
 				mData[i] = swap[i];
 			}
-			
+
 			delete [] swap;
 		}
 	}
 				mData[i] = object;
 			}
 		}
-		
+
 		mEnd = count;
 	}
 
 	{
 		pushBack(0x0);
 	}
-	
+
 
 	void pushBack(Object object)
 	{
 	{
 		return mReserve;
 	}
-	
+
 
 	unsigned int begin()
 	{
 		return mStart;
 	}
-	
+
 
 	unsigned int end()
 	{
 	{
 		return mEnd;
 	}
-	
+
 
 	void copy(Vector<Object> &vector)
 	{
 		for (i = vector.begin(); i < vector.end(); ++i)
 		{
 			mData[i] = vector[i];
-			Add(list->Current());
+			//Add(list->Current()); // WTFBBQ?
 		}
 	}
 
 	{
 		qsort(mData, end(), sizeof(Object), compareFunc);
 	}
-	
+
 
 	void swap(unsigned int index, unsigned int index2)
 	{
 		if (index < begin() || index > end())
 			return;
-		
+
 		if (index2 < begin() || index2 > end())
 			return;
 
 		mData[index2] = swap;
 	}
 
-	
+
 	void assign(unsigned int index, Object object)
 	{
 		mData[index] = object;
 
 	Object operator [] (unsigned int index)
 	{
-		if (mData == 0x0 || index < begin() || index > end() || 
+		if (mData == 0x0 || index < begin() || index > end() ||
 			 index >= size() || empty())
 			return mError;
 
 
 			fflush(stdout);
 		}
-		
-		printf("\n");    
+
+		printf("\n");
 	}
 
 
 
 	void start(unsigned int index)
 	{
-		if (mData == 0x0 || index < begin() || index > end() || 
+		if (mData == 0x0 || index < begin() || index > end() ||
 			 index >= size() || empty())
 			return;
 
 		return mData[mIndex];
 	}
 
-	
+
 	/* Requires objects to support '=='  */
 	bool find(Object object)
 	{

src/mtk_tga.cpp

 /*================================================================
- * 
+ *
  * Project : Freyja
  * Author  : Mongoose
  * Website : http://www.westga.edu/~stu7440/
  * Email   : stu7440@westga.edu
- * Object  : 
+ * Object  :
  * License : GPL See file COPYING, also (C) 2000 Mongoose
  * Comments: TGA plug-in
  *
  *                 2 bits for RGBA | RGB | GREY
  *                 val for depth
  *
- *           This file was generated using Mongoose's C++ 
+ *           This file was generated using Mongoose's C++
  *           template generator script.  <stu7440@westga.edu>
- * 
- *-- History ------------------------------------------------ 
+ *
+ *-- History ------------------------------------------------
  *
  * 2001-10-25:
  * Mongoose - support for screen origin bit
 }
 
 
-int mtk_image__tga_load(FILE *f, unsigned char **image, 
+int mtk_image__tga_load(FILE *f, unsigned char **image,
 			unsigned int *width, unsigned int *height, char *type)
 {
   mtk_image_tga_t header;
 
   // Read TGA header
   fread(&header.comment_lenght, 1, 1, f);
-  fread(&header.colormap_type, 1, 1, f); 
+  fread(&header.colormap_type, 1, 1, f);
   fread(&header.image_type, 1, 1, f);
   fread(&header.colormap_index, 2, 1, f);
   fread(&header.colormap_lenght, 2, 1, f);
   }
 
 #ifdef DEBUG_TGA
-  printf("TGA [%ix%i@%ibpp, %it, %ix, %iy, %uf]\n", 
-	 header.width, header.height, header.bpp, header.image_type,  
+  printf("TGA [%ix%i@%ibpp, %it, %ix, %iy, %uf]\n",
+	 header.width, header.height, header.bpp, header.image_type,
 	 header.origin_x, header.origin_y,
 	 header.desc_flags);
 #endif
 
   // Comments can be 0 - 255
-  if (header.comment_lenght) 
+  if (header.comment_lenght)
   {
     fread(&comment, 1, header.comment_lenght, f);
-    
+
     for (i = 0; i < 255; ++i)
     {
       if (comment[i] > 32 && comment[i] < 127)
 
   size = header.width * header.height;
 
-  if (!size || (!(header.colormap_type == 0 && 
+  if (!size || (!(header.colormap_type == 0 &&
 		  (header.image_type == 2 || header.image_type == 10))))
   {
     fprintf(stderr, "mtk_image__tga_load> Unknown image format.\n");
       for (i = 0; i < size;)
       {
 	fread(&packet, 1, 1, f);
-	
+
 	if (packet & 0x80)  // Run Lenght
 	{
 	  packet = (packet &0x7F) + 1;
 	else // RAW
 	{
 	  packet = (packet &0x7F) + 1;
-	  
+
 	  for (j = 0; j < packet; j++)
 	  {
 	    fread(&pixel, 4, 1, f);
       }
 
       for (i = 0; i < size; i += 4)
-      { 
+      {
 	tmp = (*image)[i];
 	(*image)[i] = (*image)[i + 2];
 	(*image)[i + 2] = tmp;
     if (must_flip)
     {
       swap_row = new unsigned char [header.width * 4];
-      
-      for (i = 0, (int)j = header.height-1; (int)i < header.height/2; i++, j--)
+
+      for (i = 0, j = header.height-1; (int)i < header.height/2; i++, j--)
       {
 	memcpy(swap_row, &(*image)[i*header.width*4], header.width*4);
-	memcpy(&(*image)[i*header.width*4], &(*image)[j*header.width*4], 
+	memcpy(&(*image)[i*header.width*4], &(*image)[j*header.width*4],
 	       header.width*4);
 	memcpy(&(*image)[j*header.width*4], swap_row, header.width*4);
       }
-			
+
       delete [] swap_row;
     }
     break;
     if (must_flip)
     {
       swap_row = new unsigned char [header.width * 3];
-      
+
       for (i = 0, j = header.height - 1; (int)i < header.height / 2; i++, j--)
       {
 	memcpy(swap_row, &(*image)[i*header.width*3], header.width*3);
-	memcpy(&(*image)[i*header.width*3], &(*image)[j*header.width*3], 
+	memcpy(&(*image)[i*header.width*3], &(*image)[j*header.width*3],
 	       header.width*3);
 	memcpy(&(*image)[j*header.width*3], swap_row, header.width*3);
       }
     }
 
     break;
-  case 8: 
+  case 8:
     printf("tga_load> 8bpp Not implemented\n");
     break;
   default:
     ;
   }
-    
+
 #ifdef DEBUG_TGA
   char c;
 
   printf("\n");
 #endif
 
-  return 0; 
+  return 0;
 }
 
 
 			unsigned int width, unsigned int height, char type)
 {
   mtk_image_tga_t header;
-  unsigned int size; 
+  unsigned int size;
   //  unsigned int i;
   //  unsigned char tmp;
   char comment[64];
 
   header.comment_lenght = strlen(comment);
   header.colormap_type = 0;
-  
+
   // No colormaps
   header.colormap_index = 0;
   header.colormap_lenght = 0;
 
   // Write TGA header
   fwrite(&header.comment_lenght, 1, 1, f);
-  fwrite(&header.colormap_type, 1, 1, f); 
+  fwrite(&header.colormap_type, 1, 1, f);
   fwrite(&header.image_type, 1, 1, f);
   fwrite(&header.colormap_index, 2, 1, f);
   fwrite(&header.colormap_lenght, 2, 1, f);
   {
   case 32:
     size = header.width * header.height * 4;
- 
+
     //for (i = 0; i < size; i += 4)
     //{
     //  tmp = image[i];
     break;
   case 24:
     size = header.width * header.height * 3;
- 
+
     //for (i = 0; i < size; i += 3)
     //{
     //  tmp = image[i];
   va_start(args, s);
   vsnprintf(buffer, 1023, s, args);
   va_end(args);
-  
+
   f = fopen(buffer, "wb");
 
   if (!f)
   FILE *f;
   unsigned char *image;
   unsigned int width;
-  unsigned int height; 
+  unsigned int height;
   char type;
 
   if (argc > 1)