Most unit tests working

ChangeLog

 
  OpenRaider (0.1.2) xythobuz <xythobuz@xythobuz.de>
 
+	[ 20140104 ]
+	* Hel Unit Test build & passes
+	* Spring & Simulation Tests unbuildable, missing files?
+	* GLString Unit Test builds, works not every time?
+	* TombRaider Unit & Regression Test working
+
 	[ 20140103 ]
 	* Removed more (unused?) code, PSKModel & UTPackage
 	* Removed unused MD3, mtk3d, MtkImage stuff!

Makefile

 MAJOR_VERSION=0
 MINOR_VERSION=1
 MICRO_VERSION=2
-BUILD_ID=20140102
+BUILD_ID=$(shell date "+%Y%m%d")
 PRE=
 VERSION=$(MAJOR_VERSION).$(MINOR_VERSION).$(MICRO_VERSION)$(PRE)
 VERSION_DEB=$(MAJOR_VERSION).$(MINOR_VERSION).$(MICRO_VERSION).$(BUILD_ID)
 BUILD_HOST=$(shell uname -s -n -r -m)
 ARCH=$(shell uname -m)
-#ARCH=i386
 UNAME=$(shell uname -s)
 
 ###############################################################
 memory:
 	@-mkdir -p $(BUILD_MEM_DIR)
 	$(MAKE) targets BUILDDIR=$(BUILD_MEM_DIR) \
-	DEBUG_OBJ="$(BUILD_MEM_DIR)/memeory_test.o" \
+	DEBUG_OBJ="$(BUILD_MEM_DIR)/memory_test.o" \
 	CFLAGS="$(DEBUG_CFLAGS) -DDEBUG_MEMEORY" \
 	LD_FLAGS="$(LD_FLAGS)"
 
 	$(MAKE) targets NAME=TombRaider.test BUILDDIR=$(BUILD_TEST_DIR) \
 	OBJS="$(BUILD_TEST_DIR)/TombRaider.o $(BUILD_TEST_DIR)/mtk_tga.o $(BUILD_TEST_DIR)/memeory_test.o" \
 	CFLAGS="$(BASE_CFLAGS) -g -D__TOMBRAIDER_TEST__ -D__TEST_TR5_DUMP_TGA -D__TEST_32BIT_TEXTILES -DDEBUG_MEMEORY" \
-	LD_FLAGS="-lz"
+	LD_FLAGS="-lz -lstdc++"
 
 #################################################################
 
+ifeq ($(UNAME),Darwin)
+GLString.test:
+	mkdir -p $(BUILD_TEST_DIR)
+	$(CC) -Wall -Isrc -D__TEST__ -DHAVE_MTK -DHAVE_SDL -DUSING_MTK_TGA \
+	$(shell sdl-config --cflags) $(shell sdl-config --libs) \
+	-I/opt/local/include -I/usr/local/include \
+	-framework OpenGL \
+	-framework GLUT \
+	-lm -lstdc++ \
+	src/Texture.cpp src/mtk_tga.cpp \
+	src/GLString.cpp -o $(BUILD_TEST_DIR)/GLString.test
+else
 GLString.test:
 	mkdir -p $(BUILD_TEST_DIR)
 	$(CC) -Wall -Isrc -D__TEST__ -DHAVE_MTK -DHAVE_SDL -DUSING_MTK_TGA \
 	-lGL -lGLU -lm \
 	src/Texture.cpp src/mtk_tga.cpp \
 	src/GLString.cpp -o $(BUILD_TEST_DIR)/GLString.test
+endif
 
 #################################################################
+
+# CollisionObject and HeightCollisionObject seem to be missing?
+# -- xythobuz, 2014-01-04
+
 SIMULATION_CFLAGS=-Wall -O0 -g -Isrc $(shell sdl-config --cflags) \
+		-I/opt/local/include \
 		-DUSING_OPENGL -DUSING_HEL -DUSING_MTK_TGA \
 		-DUNIT_TEST_SIMULATION
 SIMULATION_OBJS=$(BUILD_TEST_DIR)/mtk_tga.o $(BUILD_TEST_DIR)/Texture.o \
 	$(MAKE) targets NAME=Simulation.test BUILDDIR=$(BUILD_TEST_DIR) \
 		OBJS="$(SIMULATION_OBJS)" \
 		CFLAGS="$(SIMULATION_CFLAGS)" \
-		LD_FLAGS="-lm -lstdc++ -lGL -lGLU $(shell sdl-config --libs)"
+		LD_FLAGS="-lm -lstdc++ -lSDL_ttf -lSDL -lGL -lGLU $(shell sdl-config --libs)"
 
 #################################################################
+
+# Spring files seem to be missing?
+# -- xythobuz, 2014-01-04
+
 HEL_PARTICLE_CFLAGS=-Wall -O0 -g -Isrc $(shell sdl-config --cflags) \
+		-I/opt/local/include \
 		-DUSING_OPENGL -DUSING_HEL -DUSING_MTK_TGA \
-		-DUNIT_TEST_SPRING -DHAVE_SDL_TTF -lSDL_ttf
+		-DUNIT_TEST_SPRING -DHAVE_SDL_TTF
 HEL_PARTICLE_OBJS=$(BUILD_TEST_DIR)/mtk_tga.o $(BUILD_TEST_DIR)/Texture.o \
 		$(BUILD_TEST_DIR)/Mass.o \
 		$(BUILD_TEST_DIR)/Spring.o \
 	$(MAKE) targets NAME=Spring.test BUILDDIR=$(BUILD_TEST_DIR) \
 		OBJS="$(HEL_PARTICLE_OBJS)" \
 		CFLAGS="$(HEL_PARTICLE_CFLAGS)" \
-		LD_FLAGS="-lm -lstdc++ -lGL -lGLU $(shell sdl-config --libs)"
+		LD_FLAGS="-lm -lstdc++ -lSDL_ttf-lGL -lGLU $(shell sdl-config --libs)"
 
 #################################################################
 
 Quaternion.test:
 	@-echo "Building Quaternion unit test"
 	mkdir -p $(BUILD_TEST_DIR)
-	$(CC) -Wall -g -DQUATERNION_UNIT_TEST -lm -lstdc++ -Isrc \
+	$(CC) -Wall -g -DUNIT_TEST_QUATERNION -lm -lstdc++ -Isrc \
 	src/hel/Quaternion.cpp -o $(BUILD_TEST_DIR)/Quaternion.test
 	@-echo "================================================="
 	@-echo "Running Quaternion unit test"
 	@-echo "Building Math unit test"
 	mkdir -p $(BUILD_TEST_DIR)
 	$(CC) -Wall -g -DMATH_UNIT_TEST -lm -lstdc++ -Isrc \
-	src/hel/math.cpp -o $(BUILD_TEST_DIR)/Math.test
+	src/hel/math.cpp src/hel/Vector3d.cpp -o $(BUILD_TEST_DIR)/Math.test
 	@-echo "================================================="
 	@-echo "Running hel unit test"
 	$(BUILD_TEST_DIR)/Math.test
 
 #################################################################
 
-Memeory.test:
+Memory.test:
 	mkdir -p $(BUILD_TEST_DIR)
 	$(CC) -Wall -g -D__TEST__ -lstdc++ \
 	-DDEBUG_MEMEORY -DDEBUG_MEMEORY_ERROR \
-	src/memeory_test.cpp -o $(BUILD_TEST_DIR)/memeory_test.test
+	src/memeory_test.cpp -o $(BUILD_TEST_DIR)/memory_test.test
 
 #################################################################
 

src/GLString.cpp

 
 #ifdef __TEST__
 
+#include <math.h>
+
+#ifdef __APPLE__
+#include <OpenGL/glu.h>
+#else
 #include <GL/glu.h>
+#endif
 
 #ifdef HAVE_MTK
 #   include "Texture.h"
 	else
 	{
 		id[0] = gTexture.loadTGA("data/font-0.tga");
-		id[1] = gTexture.loadTGA("data/font-1.tga");
-		id[2] = gTexture.loadTGA("data/font-2.tga");
-		id[3] = gTexture.loadTGA("data/font-3.tga");
+		id[1] = gTexture.loadTGA("data/font-0.tga");
+		id[2] = gTexture.loadTGA("data/font-0.tga");
+		id[3] = gTexture.loadTGA("data/font-0.tga");
 	}
 
 	printf("%i %i %i %i\n", id[0], id[1], id[2], id[3]);
   // Create GL context
   SDL_Init(SDL_INIT_VIDEO);
 
+#ifndef __APPLE__
   if (!driver || !driver[0] || SDL_GL_LoadLibrary(driver) < 0)
   {
 	  SDL_ClearError();
 		  }
 	  }
   }
+#endif
 
   flags = SDL_OPENGL | SDL_GL_DOUBLEBUFFER;
 

src/hel/Matrix.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: 3d Matrix 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.05.11:
  * Mongoose - Created
 	/* 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
 {
 	vec_t x = v[0], y = v[1], z = v[2], w = v[3];
 
-	
+
    result[0] = mMatrix[ 0]*x + mMatrix[ 1]*y + mMatrix[ 2]*z + mMatrix[ 3]*w;
 	result[1] = mMatrix[ 4]*x + mMatrix[ 5]*y + mMatrix[ 6]*z + mMatrix[ 7]*w;
 	result[2] = mMatrix[ 8]*x + mMatrix[ 9]*y + mMatrix[10]*z + mMatrix[11]*w;
 bool Matrix::isIdentity()
 {
 	// Hhhmm... floating point using direct comparisions
-	if (mMatrix[ 0] == 1 && mMatrix[ 1] == 0 && mMatrix[ 2] == 0 && 
-		 mMatrix[ 3] == 0 &&	mMatrix[ 4] == 0 && mMatrix[ 5] == 1 && 
-		 mMatrix[ 6] == 0 && mMatrix[ 7] == 0 && mMatrix[ 8] == 0 && 
+	if (mMatrix[ 0] == 1 && mMatrix[ 1] == 0 && mMatrix[ 2] == 0 &&
+		 mMatrix[ 3] == 0 &&	mMatrix[ 4] == 0 && mMatrix[ 5] == 1 &&
+		 mMatrix[ 6] == 0 && mMatrix[ 7] == 0 && mMatrix[ 8] == 0 &&
 		 mMatrix[ 9] == 0 && mMatrix[10] == 1 && mMatrix[11] == 0 &&
-		 mMatrix[12] == 0 && mMatrix[13] == 0 && mMatrix[14] == 0 && 
+		 mMatrix[12] == 0 && mMatrix[13] == 0 && mMatrix[14] == 0 &&
 		 mMatrix[15] == 1)
 		return true;
 
 	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];
 	result[ 1] = a[ 0] * b[ 1] + a[ 1] * b[ 5] + a[ 2] * b[ 9] + a[ 3] * b[13];
 	result[ 2] = a[ 0] * b[ 2] + a[ 1] * b[ 6] + a[ 2] * b[10] + a[ 3] * b[14];
 	result[ 3] = a[ 0] * b[ 3] + a[ 1] * b[ 7] + a[ 2] * b[11] + a[ 3] * b[15];
-	
+
 	result[ 4] = a[ 4] * b[ 0] + a[ 5] * b[ 4] + a[ 6] * b[ 8] + a[ 7] * b[12];
 	result[ 5] = a[ 4] * b[ 1] + a[ 5] * b[ 5] + a[ 6] * b[ 9] + a[ 7] * b[13];
 	result[ 6] = a[ 4] * b[ 2] + a[ 5] * b[ 6] + a[ 6] * b[10] + a[ 7] * b[14];
 	result[ 7] = a[ 4] * b[ 3] + a[ 5] * b[ 7] + a[ 6] * b[11] + a[ 7] * b[15];
-	
+
 	result[ 8] = a[ 8] * b[ 0] + a[ 9] * b[ 4] + a[10] * b[ 8] + a[11] * b[12];
 	result[ 9] = a[ 8] * b[ 1] + a[ 9] * b[ 5] + a[10] * b[ 9] + a[11] * b[13];
 	result[10] = a[ 8] * b[ 2] + a[ 9] * b[ 6] + a[10] * b[10] + a[11] * b[14];
 	result[11] = a[ 8] * b[ 3] + a[ 9] * b[ 7] + a[10] * b[11] + a[11] * b[15];
-	
+
 	result[12] = a[12] * b[ 0] + a[13] * b[ 4] + a[14] * b[ 8] + a[15] * b[12];
 	result[13] = a[12] * b[ 1] + a[13] * b[ 5] + a[14] * b[ 9] + a[15] * b[13];
 	result[14] = a[12] * b[ 2] + a[13] * b[ 6] + a[14] * b[10] + a[15] * b[14];
 
 
 ////////////////////////////////////////////////////////////
-// Unit Test 
+// Unit Test
 ////////////////////////////////////////////////////////////
 
 #ifdef MATRIX_UNIT_TEST
+#include <strings.h>
 /* <Order> is (r)ow or (c)ol */
 void generateMatrixSourceTest(char order)
 {
 	int i, j, k;
 
-	
+
 	if (order == 'r')
 	{
 		printf("/* Row order */\n");
 	{
 		printf("/* Column order */\n");
 	}
-	
+
 	for (i = 0; i < 4; ++i)
 	{
 		for (j = 0; j < 4; ++j)
 			{
 				printf("result[%2i] = ", j+i*4);
 			}
-			
+
 			for (k = 0; k < 4; ++k)
 			{
 				if (order == 'r')
 				{
 					printf("a[%2i] * b[%2i]%s",
-							  k+i*4, j+k*4, (k == 3) ? ";\n" : " + "); 
+							  k+i*4, j+k*4, (k == 3) ? ";\n" : " + ");
 				}
 				else
 				{
-					printf("a[%2i] * b[%2i]%s", 
+					printf("a[%2i] * b[%2i]%s",
 							 i+k*4, k+j*4, (k == 3) ? ";\n" : " + ");
 				}
 
 			printf("Identity * Identity");
 			c.setIdentity();
 			b.setIdentity();
-			a = c * b; 
+			a = c * b;
 			break;
 		case 2:
 			printf("Identity *= Identity");
 		printf("\n");
 	}
 
-	/* 2003.06.18, Mongoose - These tests are weak and 
+	/* 2003.06.18, Mongoose - These tests are weak and
 		only spot check some of the matrix */
 
 
 
 #ifdef COLUMN_ORDER
 	unsigned char i0  = 0, i1  = 4, i2  =  8, i3  = 12;
-	unsigned char i4  = 1, i5  = 5, i6  =  9, i7  = 13; 
+	unsigned char i4  = 1, i5  = 5, i6  =  9, i7  = 13;
 	unsigned char i8  = 2, i9  = 6, i10 = 10, i11 = 14;
 	unsigned char i12 = 3, i13 = 7, i14 = 11, i15 = 15;
 #else
-	unsigned char i0  =  0, i1  =  1, i2  =  2, i3  =  3;
-	unsigned char i4  =  4, i5  =  5, i6  =  6, i7  =  7;
-	unsigned char i8  =  8, i9  =  9, i10 = 10, i11 = 11;
+	unsigned char i0  =  0, i1  =  1, i2  =  2; // i3  =  3
+	unsigned char i4  =  4, i6  =  6; // i5  =  5, i7  =  7
+	unsigned char i8  =  8, i9  =  9, i10 = 10; // i11 = 11
 	unsigned char i12 = 12, i13 = 13, i14 = 14, i15 = 15;
 #endif
 
-	if (a.mMatrix[i12] != 10 || 
-		 a.mMatrix[i13] != 20 || 
+	if (a.mMatrix[i12] != 10 ||
+		 a.mMatrix[i13] != 20 ||
 		 a.mMatrix[i14] != 30)
 	{
 			++errs;
 			printf(" \t[ Failed ]\a\n"); // beep
-			a.print();		
+			a.print();
 	}
 
 	/* Cheap X rotation test */
 	printf("I -> Rotate (90 degrees, 0, 0)\n");
 	a.rotate(90*0.01745329251994329f, 0, 0);
 
-	if (a.mMatrix[i0] != 1 || a.mMatrix[i15] != 1 || 
+	if (a.mMatrix[i0] != 1 || a.mMatrix[i15] != 1 ||
 		 a.mMatrix[i9] != -1 || a.mMatrix[i6] != 1)
 	{
 			++errs;
 			printf(" \t[ Failed ]\a\n"); // beep
-			a.print();		
+			a.print();
 	}
 
 	/* Cheap Y rotation test */
 	{
 			++errs;
 			printf(" \t[ Failed ]\a\n"); // beep
-			a.print();		
+			a.print();
 	}
 
 	/* Cheap Z rotation test */
 	printf("I -> Rotate (0, 0, 90 degrees)\n");
 	a.rotate(0, 0, 90*0.01745329251994329f);
 
-	if (a.mMatrix[i4] != -1 || a.mMatrix[i15] != 1 || 
+	if (a.mMatrix[i4] != -1 || a.mMatrix[i15] != 1 ||
 		 a.mMatrix[i1] != 1 || a.mMatrix[i10] != 1)
 	{
 			++errs;
 			printf(" \t[ Failed ]\a\n"); // beep
-			a.print();		
+			a.print();
 	}
 
 	printf("\n%i errors\n", errs);
 	a.translate(-10, -20, -30);
 	printf(" -> Rotate (0, 0, -90 degrees)\n");
 	a.rotate(0, 0, -90*0.01745329251994329f);
-	a.print();	
+	a.print();
 
 	printf("\n%i errors\n", errs);
 

src/hel/Quaternion.cpp

 /* -*- 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: Quaternion now in C++ class form fresh from the grove
  *
  *
- *           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 - Created, based on mtk3d ( freyja )
 	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;
 	mX = q.mX;
 	mY = q.mY;
 	mZ = q.mZ;
-  
+
   return (*this);
 }
 
 {
 	vec_t temp, dist;
 
-	
+
 	// Normalize
 	temp = x*x + y*y + z*z;
-	
+
 	dist = (float)(1.0 / sqrt(temp));
-	
+
 	x *= dist;
 	y *= dist;
 	z *= dist;
-	
+
 	mX = x;
 	mY = y;
 	mZ = z;
-	
-	mW = (float)cos(angle / 2.0f);	
+
+	mW = (float)cos(angle / 2.0f);
 }
 
 
 
 
 	square = mX * mX + mY * mY + mZ * mZ + mW * mW;
-	
+
 	if (square > 0.0)
 	{
 		dist = (float)(1.0 / sqrt(square));
 	}
-	else 
+	else
 	{
 		dist = 1;
 	}
 	mX *= dist;
 	mY *= dist;
 	mZ *= dist;
-	mW *= dist; 
+	mW *= dist;
 }
 
 
 	 *
 	 * http://www.magic-software.com/Documentation/quat.pdf
 	 *
-	 * Thanks to digiben for algorithms and basis of the notes in 
+	 * Thanks to digiben for algorithms and basis of the notes in
 	 * this func
 	 *
 	 *******************************************************************/
 
 
 	// Don't bother if it's the same rotation, it's the same as the result
-	if (a == b) 
+	if (a == b)
 	{
 		return a;
 	}
 
-	// A . B 
+	// A . B
 	result = dot(a, b);
-  
+
 	// If the dot product is less than 0, the angle is greater than 90 degrees
 	if (result < 0.0f)
 	{
 	// angle is fairly small, we can actually just do a simpler linear interpolation
 	// of the 2 quaternions, and skip all the complex math.  We create a "delta" value
 	// of 0.1 to say that if the cosine of the angle (result of the dot product) between
-	// the 2 quaternions is smaller than 0.1, then we do NOT want to perform the full on 
+	// the 2 quaternions is smaller than 0.1, then we do NOT want to perform the full on
 	// interpolation using.  This is because you won't really notice the difference.
-	
-	// Check if the angle between the 2 quaternions was big enough 
+
+	// Check if the angle between the 2 quaternions was big enough
 	// to warrant such calculations
 	if (1 - result > 0.1f)
 	{
 		// the angle and it's sine value
 		scaleA = (float)sin((1 - time) * theta) / sinTheta;
 		scaleB = (float)sin((time * theta)) / sinTheta;
-	}	
+	}
 
 	// Calculate the x, y, z and w values for the quaternion by using a special
 	// form of linear interpolation for quaternions.
 
 
 void Quaternion::setByMatrix(matrix_t matrix)
-{   
+{
 	float diagonal = matrix[0] + matrix[5] + matrix[10] + 1.0f;
 	float scale = 0.0f;
 	float w = 0.0f, x = 0.0f, y = 0.0f, z = 0.0f;
-	
-	
+
+
 	if (diagonal > 0.00000001)
 	{
 		// Calculate the scale of the diagonal
 		scale = (float)(sqrt(diagonal) * 2);
-		
+
 		w = 0.25f * scale;
 		x = (matrix[9] - matrix[6]) / scale;
 		y = (matrix[2] - matrix[8]) / scale;
 		z = (matrix[4] - matrix[1]) / scale;
 	}
-	else 
+	else
 	{
 		 // If the first element of the diagonal is the greatest value
 		if (matrix[0] > matrix[5] && matrix[0] > matrix[10])
-		{   
+		{
 			 // Find the scale according to the first element, and double it
 			scale = (float)sqrt(1.0f + matrix[0] - matrix[5] - matrix[10])*2.0f;
-			
+
 			// Calculate the quaternion
-			w = (matrix[9] - matrix[6]) / scale; 
+			w = (matrix[9] - matrix[6]) / scale;
 			x = 0.25f * scale;
 			y = (matrix[4] + matrix[1]) / scale;
 			z = (matrix[2] + matrix[8]) / scale;
-		} 
+		}
 		// The second element of the diagonal is the greatest value
-		else if (matrix[5] > matrix[10]) 
+		else if (matrix[5] > matrix[10])
 		{
 			// Find the scale according to the second element, and double it
 			scale = (float)sqrt(1.0f + matrix[5] - matrix[0] - matrix[10])*2.0f;
-			
-			// Calculate the quaternion 
+
+			// Calculate the quaternion
 			w = (matrix[2] - matrix[8]) / scale;
 			x = (matrix[4] + matrix[1]) / scale;
 			y = 0.25f * scale;
 			z = (matrix[9] + matrix[6]) / scale;
-		} 
+		}
 		// The third element of the diagonal is the greatest value
-		else 
-		{   
+		else
+		{
 			// Find the scale according to the third element, and double it
 			scale = (float)sqrt(1.0f + matrix[10] - matrix[0] - matrix[5])*2.0f;
-			
+
 			// Calculate the quaternion
 			w = (matrix[4] - matrix[1]) / scale;
 			x = (matrix[2] + matrix[8]) / scale;
 ////////////////////////////////////////////////////////////
 
 #ifdef UNIT_TEST_QUATERNION
+
+#include <stdio.h>
+
 int runQuaternionUnitTest(int argc, char *argv[])
 {
+    //! \todo Implement Quaternion Unit Tests!
+    printf("Not implemented!\n");
 	return 0;
 }
 

src/hel/math.cpp

 }
 
 
-bool tmpHelSphereIntersectLine(Vector3d pos, Vector3d lastPos, 
+bool tmpHelSphereIntersectLine(Vector3d pos, Vector3d lastPos,
 										 Vector3d center, vec_t radius)
 {
 	Vector3d seg, segToCenter, delta;
 
 	dist = Vector3d::dot(d, d);
 	minDist = radiusA + radiusB;
-	
+
 	return (dist <= minDist * minDist);
 }
 
 
-inline vec_t square(vec_t a) 
+inline vec_t square(vec_t a)
 {
 	return a * a;
 }
 {
 	// float x , y , z;
 	vec_t a, b, c, mu, i ;
-	
 
-	a = (square(posB[0] - posA[0]) + 
-		  square(posB[1] - posA[1]) + 
+
+	a = (square(posB[0] - posA[0]) +
+		  square(posB[1] - posA[1]) +
 		  square(posB[2] - posA[2]));
 	b = (2 * ((posB[0] - posA[0]) * (posA[0] - center[0]) +
 				 (posB[1] - posA[1]) * (posA[1] - center[1]) +
 	c = (square(center[0]) + square(center[1]) +
 		  square(center[2]) + square(posA[0]) +
 		  square(posA[1]) + square(posA[2]) -
-		  2 * (center[0]*posA[0] + center[1]*posA[1] + center[2]*posA[2]) - 
+		  2 * (center[0]*posA[0] + center[1]*posA[1] + center[2]*posA[2]) -
 		  square(radius));
 
 	i = b * b - 4 * a * c;
 
-	
+
 	if (i < 0.0)
 	{
 		// No intersection
 	else
 	{
 		// Two intersections
-		
+
 		// First intersection
 		mu = (-b + sqrt( square(b) - 4*a*c)) / (2*a);
 		intersectionA[1] = posA[0] + mu*(posB[0]-posA[0]);
 		intersectionA[2] = posA[1] + mu*(posB[1]-posA[1]);
 		intersectionA[3] = posA[2] + mu*(posB[2]-posA[2]);
-		
+
 		// Second intersection
 		mu = (-b - sqrt(square(b) - 4*a*c)) / (2*a);
 		intersectionB[0] = posA[0] + mu*(posB[0]-posA[0]);
 
 	// find D
 	//d = (normal[0] * ploygon[0][0] -
-	//	  normal[1] * ploygon[0][1] - 
+	//	  normal[1] * ploygon[0][1] -
 	//	  normal[2] * ploygon[0][2]);
 	d = (normal.mVec[0] * ploygon[0][0] -
-		  normal.mVec[1] * ploygon[0][1] - 
+		  normal.mVec[1] * ploygon[0][1] -
 		  normal.mVec[2] * ploygon[0][2]);
 
 	// line segment parallel to plane?
 	intersect[0] = b.mVec[0];
 	intersect[1] = b.mVec[1];
 	intersect[2] = b.mVec[2];
-	
+
 
 	// See if the intercept is bound by polygon by winding number
 #ifdef WINDING_NUMBERS_TRIANGLE
 	vec_t d;
 
 
-	d = (plane[0] * center[0] + 
+	d = (plane[0] * center[0] +
 		  plane[1] * center[1] +
-		  plane[2] * center[2] + 
+		  plane[2] * center[2] +
 		  plane[3]);
 
 	if (d <= -radius)
 
 	helMidpoint3v(min, max, center);
 
-	d = (plane[0] * center[0] + 
-		  plane[1] * center[1] + 
-		  plane[2] * center[2] + 
+	d = (plane[0] * center[0] +
+		  plane[1] * center[1] +
+		  plane[2] * center[2] +
 		  plane[3]);
 
 	radius = helDist3v(max, center);
 vec_t helDist3v(vec3_t a, vec3_t b)
 {
 	return (sqrt( ((b[0] - a[0]) * (b[0] - a[0])) +
-					  ((b[1] - a[1]) * (b[1] - a[1])) + 
+					  ((b[1] - a[1]) * (b[1] - a[1])) +
 					  ((b[2] - a[2]) * (b[2] - a[2]))));
 }
 
 
 
 vec_t helNorm4v(vec4_t v)
-{ 
+{
 	return (sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2] + v[3]*v[3]));
 }
 
 
 vec_t helNorm3v(vec3_t v)
-{ 
+{
 	return (sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]));
-} 
+}
 
 
 vec_t helNorm2v(vec2_t v)
-{ 
+{
 	return (sqrt(v[0]*v[0] + v[1]*v[1]));
 }
 
 vec_t helRadToDeg(vec_t rad)
 {
 #ifdef COMPUTE
-	return ((rad / HEL_PI) * 180.0); 
+	return ((rad / HEL_PI) * 180.0);
 #else
 	// rad * (PI / 180.0);
 	return (rad * HEL_PI_OVER_180);
 
 void helMathTest()
 {
-	printf("180/PI: %f, %f, %f\n", 
-			 HEL_180_OVER_PI, 
+	printf("180/PI: %f, %f, %f\n",
+			 HEL_180_OVER_PI,
 			 180.0f / HEL_PI,
 			 180.0 / M_PI);
 }
 
 
-int main(int argc, char *argv)
+int main(int argc, char *argv[])
 {
 	helMathTest();