Removed hel mstl subfolders

ChangeLog

  OpenRaider (0.1.2) xythobuz <xythobuz@xythobuz.de>
 
 	[ 20140110 ]
+	* Converted many FIXME comments to be in the doxygen documentation
+	* Removed hel & mstl folders, moved into parent directory
+	* mtk_tga Unit Test uses greatest
 	* Moved remaining Unit Tests (Network & TombRaider)
 	* memory_test Unit Test no longer produces warnings
 	* Building a memory test build no longer produces warnings

Doxyfile

 # "Side Effects:". You can put \n's in the value part of an alias to insert
 # newlines.
 
-ALIASES                = "fixme=\xrefitem fixme \"FIXME\" \"Fix Me\""
+ALIASES                = "fixme=\xrefitem fixme \"FIXME\" \"Fix-Me Entries\""
 
 # This tag can be used to specify a number of word-keyword mappings (TCL only).
 # A mapping has the form "name=value". For example adding "class=itcl::class"

Makefile

 BASE_DEFS=$(shell sdl-config --cflags) -Iinclude -DSDL_INTERFACE \
 	-DUSING_OPENGL -DZLIB_SUPPORT -DUSING_EMITTER \
 	-DUSING_OPENAL -DUSING_MTK_TGA -DUSING_PTHREADS \
-	-DUSING_HEL -DHAVE_SDL_TTF
+	-DHAVE_SDL_TTF
 
 BASE_LIBS=$(shell sdl-config --libs) -lz -lstdc++ \
 	-lpthread -lSDL_ttf
 
 ################################################################
 
-# Later hel will become a seperate library once it matures
-HEL_OBJ = \
-	$(BUILDDIR)/math.o \
-	$(BUILDDIR)/Matrix.o \
-	$(BUILDDIR)/Quaternion.o \
-	$(BUILDDIR)/Vector3d.o \
-	$(BUILDDIR)/ViewVolume.o
-
 OBJS = \
 	$(DEBUG_OBJ) \
-	$(HEL_OBJ) \
 	$(BUILDDIR)/Camera.o \
 	$(BUILDDIR)/Emitter.o \
 	$(BUILDDIR)/GLString.o \
 	$(BUILDDIR)/Light.o \
+	$(BUILDDIR)/MatMath.o \
+	$(BUILDDIR)/Matrix.o \
 	$(BUILDDIR)/mtk_tga.o \
 	$(BUILDDIR)/Network.o \
 	$(BUILDDIR)/OpenGLMesh.o \
 	$(BUILDDIR)/OpenRaider.o \
 	$(BUILDDIR)/Particle.o \
+	$(BUILDDIR)/Quaternion.o \
 	$(BUILDDIR)/Render.o \
 	$(BUILDDIR)/SDLSystem.o \
 	$(BUILDDIR)/SkeletalModel.o \
 	$(BUILDDIR)/System.o \
 	$(BUILDDIR)/Texture.o \
 	$(BUILDDIR)/TombRaider.o \
+	$(BUILDDIR)/Vector3d.o \
+	$(BUILDDIR)/ViewVolume.o \
 	$(BUILDDIR)/World.o
 
 
 	@-echo "Building Matrix unit test"
 	mkdir -p $(BUILD_TEST_DIR)
 	$(CC) -Wall -g -lm -lstdc++ -Iinclude \
-	src/hel/Matrix.cpp src/hel/Quaternion.cpp src/hel/Vector3d.cpp \
-	test/hel/Matrix.cpp -o $(BUILD_TEST_DIR)/Matrix.test
+	src/Matrix.cpp src/Quaternion.cpp src/Vector3d.cpp \
+	test/Matrix.cpp -o $(BUILD_TEST_DIR)/Matrix.test
 	@-echo "================================================="
 	@-echo "Running Matrix unit test"
 	$(BUILD_TEST_DIR)/Matrix.test
 	@-echo "Building Quaternion unit test"
 	mkdir -p $(BUILD_TEST_DIR)
 	$(CC) -Wall -g -lm -lstdc++ -Iinclude \
-	src/hel/Quaternion.cpp test/hel/Quaternion.cpp -o $(BUILD_TEST_DIR)/Quaternion.test
+	src/Quaternion.cpp test/Quaternion.cpp -o $(BUILD_TEST_DIR)/Quaternion.test
 	@-echo "================================================="
 	@-echo "Running Quaternion unit test"
 	$(BUILD_TEST_DIR)/Quaternion.test
 	@-echo "Building Math unit test"
 	mkdir -p $(BUILD_TEST_DIR)
 	$(CC) -Wall -g -lm -lstdc++ -Iinclude \
-	src/hel/math.cpp src/hel/Vector3d.cpp test/hel/math.cpp -o $(BUILD_TEST_DIR)/Math.test
+	src/MatMath.cpp src/Vector3d.cpp test/MatMath.cpp -o $(BUILD_TEST_DIR)/Math.test
 	@-echo "================================================="
 	@-echo "Running hel unit test"
 	$(BUILD_TEST_DIR)/Math.test

include/hel/BoundingVolume.h → include/BoundingVolume.h

 #ifndef GUARD__LIBHEL_MONGOOSE_BOUNDINGVOLUME_H_
 #define GUARD__LIBHEL_MONGOOSE_BOUNDINGVOLUME_H_
 
-#include <hel/math.h>
+#include <MatMath.h>
 
 
 class BoundingSphere

include/Camera.h

 #ifndef __HEL_MONGOOSE_CAMERA_H_
 #define __HEL_MONGOOSE_CAMERA_H_
 
-#include "hel/math.h"
-#include "hel/Matrix.h"
-#include "hel/Quaternion.h"
+#include <MatMath.h>
+#include <Matrix.h>
+#include <Quaternion.h>
 
 enum camera_command                /* Interactive camera control */
 {

include/Emitter.h

 #ifndef __FREYJA_MONGOOSE_EMITTER_H_
 #define __FREYJA_MONGOOSE_EMITTER_H_
 
-#include "Particle.h"
+#include <Particle.h>
 
 
 class Emitter

include/hel/Entity.h → include/Entity.h

 #ifndef GUARD__HEL_MONGOOSE_ENTITY_H_
 #define GUARD__HEL_MONGOOSE_ENTITY_H_
 
-#include <hel/math.h>
-#include <hel/BoundingVolume.h>
-#include <hel/Quaternion.h>
-#include <hel/Vector3d.h>
-#include <hel/Mass.h>
+#include <MatMath.h>
+#include <BoundingVolume.h>
+#include <Quaternion.h>
+#include <Vector3d.h>
+#include <Mass.h>
 
 
 typedef enum

include/GLString.h

 /*!
- * \file GLString.h
+ * \file include/GLString.h
  * \brief Open GL rendering font/string class
  *
  * \author Mongoose

include/Light.h

 #ifndef __FREYJA_MONGOOSE_LIGHT_H_
 #define __FREYJA_MONGOOSE_LIGHT_H_
 
-#include "hel/math.h"
+#include <MatMath.h>
 
 
 class Light

include/mstl/Map.h → include/Map.h

 #include <stdlib.h>
 #include <stdio.h>
 
-#include <mstl/Tree.h>
+#include <Tree.h>
 
 #ifdef DEBUG_MEMORY
 #include <memory_test.h>

include/hel/Matrix.h → include/Matrix.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: 3d Matrix in class form
  *
  *
- *           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.06.17:
  * Mongoose - Now in column order to match OpenGL user needs,
 #define GUARD__FREYJA_MONGOOSE_MATRIX_H_
 
 
-#include <hel/math.h>
-#include <hel/Quaternion.h>
-#include <hel/Vector3d.h>
+#include <MatMath.h>
+#include <Quaternion.h>
+#include <Vector3d.h>
 
 	///////////////////////////////////////////////
 	// Multidim map for row order encoding       //
 
 	Matrix();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Constructs an object of Matrix
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.05.11: 
+	 * 2002.05.11:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	Matrix(matrix_t mat);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Constructs an object of Matrix
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.05.11: 
+	 * 2002.05.11:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	Matrix(Quaternion &q);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Converts and asigns Q to a Matrix
 	 *        returns quaternion as Matrix
 	 *
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.05.11: 
+	 * 2002.05.11:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 
 	void getMatrix(matrix_t mat);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Returns this matrix copy
 	 *
 	 *-- History ------------------------------------------
 
 	void getTransposeMatrix(matrix_t mat);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Returns this matrix transposed
 	 *
 	 *-- History ------------------------------------------
 
 	bool getInvert(matrix_t mat);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Returns this matrix inverted
 	 *
 	 *-- History ------------------------------------------
 	/*------------------------------------------------------
 	 * Pre  : Multiplies <V> vector (double[4]) and <This> matrix
 	 *
-	 * Post : Returns <Result> vector, 
+	 * Post : Returns <Result> vector,
 	 *        <V> and <Result> maybe be the same vector
 	 *
 	 *-- History ------------------------------------------
 	/*------------------------------------------------------
 	 * Pre  : Multiplies <V> vector and <This> matrix
 	 *
-	 * Post : Returns <Result> vector, 
+	 * Post : Returns <Result> vector,
 	 *        <V> and <Result> maybe be the same vector
 	 *
 	 *-- History ------------------------------------------
 	/*------------------------------------------------------
 	 * Pre  : Multiplies <V> vector and <This> matrix
 	 *
-	 * Post : Returns <Result> vector, 
+	 * Post : Returns <Result> vector,
 	 *        <V> and <Result> maybe be the same vector
 	 *
 	 *-- History ------------------------------------------
 
 	void print();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Prints matrix values to stdout
 	 *
 	 *-- History ------------------------------------------
 
 	bool isIdentity();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Is this matrix the identity matrix?
 	 *
 	 *-- History ------------------------------------------
 
 	void setIdentity();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Sets to identity matrix
 	 *
 	 *-- History ------------------------------------------
 
 	void setMatrix(matrix_t mat);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Set the matrix ( dangerous, scary boo )
 	 *
 	 *-- History ------------------------------------------
 
 	void scale(vec_t x, vec_t y, vec_t z);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Scales object in 3 space
 	 *
 	 *-- History ------------------------------------------
 
 	void scale(const vec_t *xyz);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Scales object in 3 space
 	 *
 	 *-- History ------------------------------------------
 
 	void translate(vec_t x, vec_t y, vec_t z);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Translates ( moves ) object in 3 space
 	 *
 	 *-- History ------------------------------------------
 
 	void translate(const vec_t *xyz);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Translates ( moves ) object in 3 space
 	 *
 	 *-- History ------------------------------------------
 
 	void transpose();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Transpose this matrix
 	 *
 	 *-- History ------------------------------------------
 
 	void copy(matrix_t source, matrix_t dest);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Copys value of source to dest
 	 *
 	 *-- History ------------------------------------------

include/OpenGLMesh.h

 /*!
- * \file OpenGLMesh.h
+ * \file include/OpenGLMesh.h
  * \brief OpenGL Mesh
  *
  * \author Mongoose
 #ifndef GUARD__OPENRAIDER_MONGOOSE_OPENGLMESH_H_
 #define GUARD__OPENRAIDER_MONGOOSE_OPENGLMESH_H_
 
-#include "hel/math.h"
+#include <MatMath.h>
 
 class OpenGLMesh {
 public:

include/OpenRaider.h

 #define GUARD__OPENRAIDER_MONGOOSE_OPENRAIDER_H_
 
 
-#include "mstl/List.h"
-#include "mstl/Map.h"
-#include "mstl/Vector.h"
-#include "TombRaider.h"
-#include "Camera.h"
-#include "Render.h"
-#include "Sound.h"
-#include "SDLSystem.h"
-#include "Network.h"
-#include "World.h"
+#include <List.h>
+#include <Map.h>
+#include <Vector.h>
+#include <TombRaider.h>
+#include <Camera.h>
+#include <Render.h>
+#include <Sound.h>
+#include <SDLSystem.h>
+#include <Network.h>
+#include <World.h>
 
 
 typedef enum

include/Particle.h

 /*!
- * \file Particle.h
+ * \file include/Particle.h
  * \brief Particle system base header
  *
  * \author Mongoose
 #ifndef __FREYJA_MONGOOSE_PARTICLE_H_
 #define __FREYJA_MONGOOSE_PARTICLE_H_
 
-#include "hel/math.h"
+#include <MatMath.h>
 
 /*!
  * \brief Partcle systems atomic base

include/hel/Quaternion.h → include/Quaternion.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: 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>
- * 
+ *
  *-- Test Defines -----------------------------------------------
- *           
- * UNIT_TEST_QUATERNION - Builds Quaternion class as a console unit test 
  *
- *-- History ------------------------------------------------ 
+ * UNIT_TEST_QUATERNION - Builds Quaternion class as a console unit test
+ *
+ *-- History ------------------------------------------------
  *
  * 2002.12.16:
  * Mongoose - Created, based on mtk3d ( freyja )
 #ifndef GUARD__HEL_MONGOOSE_QUATERNION_H_
 #define GUARD__HEL_MONGOOSE_QUATERNION_H_
 
-#include <hel/math.h>
-//#include <hel/Matrix.h>
+#include <MatMath.h>
 
 class Quaternion
 {
 
 	Quaternion();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Constructs an object of Quaternion
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.12.16: 
+	 * 2002.12.16:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	Quaternion(vec_t w, vec_t x, vec_t y, vec_t z);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Constructs an object of Quaternion
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.12.16: 
+	 * 2002.12.16:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.12.16: 
+	 * 2002.12.16:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.12.16: 
+	 * 2002.12.16:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 
 	Quaternion operator =(const Quaternion &q);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Asigns Q to this quaternion
 	 *        returns (this) resultant quaternion
 	 *
 
 	Quaternion operator *(const Quaternion &q);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Multiplies Q and this quaternion
 	 *        returns resultant quaternion
 	 *        ( Use normalize() call for unit quaternion )
 
 	Quaternion operator /(const Quaternion &q);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Dividess Q from this quaternion
 	 *        returns quotient quaternion
 	 *
 
 	Quaternion operator +(const Quaternion &q);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Adds Q and this quaternion
 	 *        returns resultant quaternion
 	 *
 
 	Quaternion operator -(const Quaternion &q);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Subtracts Q from this quaternion
 	 *        returns resultant quaternion
 	 *
 
 	bool operator ==(const Quaternion &q);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Compares Q to this quaternion
 	 *        returns boolean true if equal, otherwise false
 	 *
 
 	Quaternion conjugate();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Returns conjugate of this quaternion
 	 *
 	 *-- History ------------------------------------------
 
 	Quaternion scale(vec_t s);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Returns scaled result of this quaternion
 	 *
 	 *-- History ------------------------------------------
 
 	Quaternion inverse();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Returns inverse of this quaternion
 	 *
 	 *-- History ------------------------------------------
 
 	static vec_t dot(Quaternion a, Quaternion b);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Returns dot product of A and B quaternions
 	 *
 	 *-- History ------------------------------------------
 
 	vec_t magnitude();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Returns magnitude this quaternion
 	 *
 	 *-- History ------------------------------------------
 
 	static Quaternion slerp(Quaternion a, Quaternion b, vec_t time);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Interpolates between A and B rotations and
 	 *        returns resultant quaternion using
 	 *        spherical linear interpolation:
 
 	void setIdentity();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Sets this quaternion to identity
 	 *
 	 *-- History ------------------------------------------
 
 	void set(vec_t angle, vec_t x, vec_t y, vec_t z);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Sets this quaternion
 	 *
 	 *-- History ------------------------------------------
 
 	void normalize();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Normalize this quaternion
 	 *
 	 *-- History ------------------------------------------
 
 	void copy(Quaternion q);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Set this quaternion using q
 	 *
 	 *-- History ------------------------------------------
 
 	Quaternion multiply(Quaternion a, Quaternion b);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Multiplies A and B quaternions
 	 *        returns resultant quaternion
 	 *
 
 	Quaternion divide(Quaternion a, Quaternion b);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Divides B from A quaternion
 	 *        returns quotient quaternion
 	 *
 
 	Quaternion add(Quaternion a, Quaternion b);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Adds A and B quaternions
 	 *        returns resultant quaternion
 	 *
 
 	Quaternion subtract(Quaternion a, Quaternion b);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Subtracts B from A quaternion
 	 *        returns resultant quaternion
 	 *

include/Render.h

 #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 "Light.h"
-#include "World.h"
-#include "SkeletalModel.h"
-#include "OpenGLMesh.h"
-#include "Texture.h"
-#include "Camera.h"
-#include "GLString.h"
+#include <List.h>
+#include <Vector.h>
+#include <Matrix.h>
+#include <ViewVolume.h>
+#include <Light.h>
+#include <World.h>
+#include <SkeletalModel.h>
+#include <OpenGLMesh.h>
+#include <Texture.h>
+#include <Camera.h>
+#include <GLString.h>
 
 #ifdef USING_EMITTER
-#   include "Emitter.h"
+#include <Emitter.h>
 #endif
 
 
 
 	~RenderRoom()
 	{
-		// FIXME: hangs when erasing - might be shared pointers somewhere
+		//! \fixme Hangs when erasing - might be shared pointers somewhere
 		//lights.erase();
 	}
 
     * Mongoose - Created
     ------------------------------------------------------*/
 
-	// FIXME: Should be private
+	//! \fixme Should be private
    void drawLoadScreen();
    /*------------------------------------------------------
     * Pre  : Texture is init

include/SDLSystem.h

 #   error "SDLSystem requires -DSDL_INTERFACE"
 #endif
 
-#include "System.h"
+#include <System.h>
 
 class SDLSystem : public System
 {

include/SkeletalModel.h

 /*!
- * \file SkeletalModel.h
+ * \file include/SkeletalModel.h
  * \brief This is the factored out skeletal model class
  *
  * Defining UNIT_TEST_SKELETALMODEL builds SkeletalModel class as a console unit test
 #ifndef GUARD__OPENRAIDER_MONGOOSE_SKELETALMODEL_H_
 #define GUARD__OPENRAIDER_MONGOOSE_SKELETALMODEL_H_
 
-#include "mstl/Vector.h"
-#include "hel/math.h"
+#include <Vector.h>
+#include <MatMath.h>
 
 
 typedef struct bone_tag_s

include/Sound.h

 /*!
- * \file Sound.h
+ * \file include/Sound.h
  * \brief This is the audio manager Header
  *
  * \author Mongoose

include/System.h

 /*!
- * \file System.h
+ * \file include/System.h
  * \brief Mostly defines the interface of System implementations.
  *
  * Currently only SDL is used, but there was a GLUT implementation.
 #ifndef GUARD__UNRAIDER_MONGOOSE_SYSTEM_H_
 #define GUARD__UNRAIDER_MONGOOSE_SYSTEM_H_
 
-#include "mstl/Map.h"
-#include "mstl/Vector.h"
+#include <Map.h>
+#include <Vector.h>
 
 //! \todo Replace with unicode compatible key codes
 #define SYS_MOUSE_LEFT    6000

include/hel/Vector3d.h → include/Vector3d.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: Math vector
  *
  *
- *           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_VECTOR3D - Builds Vector3d class as a console unit test 
  *
- *-- History ------------------------------------------------ 
+ * UNIT_TEST_VECTOR3D - Builds Vector3d class as a console unit test
+ *
+ *-- History ------------------------------------------------
  *
  * 2002.12.24:
  * Mongoose - Created
 #define GUARD__HEL_MONGOOSE_VECTOR3D_H_
 
 
-#include <hel/math.h>
+#include <MatMath.h>
 
 class Vector3d
 {
 
 	Vector3d();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Constructs an object of Vector3d
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.12.24: 
+	 * 2002.12.24:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	Vector3d(vec3_t v);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Constructs an object of Vector3d
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.12.24: 
+	 * 2002.12.24:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	Vector3d(vec_t x, vec_t y, vec_t z);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Constructs an object of Vector3d
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.12.24: 
+	 * 2002.12.24:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.12.24: 
+	 * 2002.12.24:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 
 	static vec_t dot(const Vector3d &u, const Vector3d &v);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Returns dot product of U and V vectors
 	 *
 	 *-- History ------------------------------------------
 
 	static Vector3d cross(const Vector3d &u, const Vector3d &v);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Returns cross product of U and V vectors
 	 *
 	 *-- History ------------------------------------------
 
 	vec_t magnitude();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Returns magnitude this vector
 	 *
 	 *-- History ------------------------------------------
 
 	Vector3d unit();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Returns normalized copy of this vector
 	 *
 	 *-- History ------------------------------------------
 
 	static Vector3d zeroVector();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Returns the Zero vector <0, 0, 0>
 	 *
 	 *-- History ------------------------------------------
 
 	Vector3d operator +(const Vector3d &v);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Returns a vector = this vector + v
 	 *
 	 *-- History ------------------------------------------
 
 	Vector3d operator -(const Vector3d &v);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Returns a vector = this vector - v
 	 *
 	 *-- History ------------------------------------------
 
 	Vector3d operator -();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Returns a copy of this vector, negated
 	 *
 	 *-- History ------------------------------------------
 
 	void normalize();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Normalizes *this vector
 	 *
 	 *-- History ------------------------------------------
 
 	void zero();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post :This is set to the Zero vector <0, 0, 0>
 	 *
 	 *-- History ------------------------------------------
 
 	void operator =(const Vector3d &v);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : this = v, values are assigned   =)
 	 *
 	 *-- History ------------------------------------------
 
 	void operator +=(const Vector3d &v);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : this += v, values are sumed, assigned   =)
 	 *
 	 *-- History ------------------------------------------
 
 	void operator -=(const Vector3d &v);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : this -= v, values are diffed, assigned   =)
 	 *
 	 *-- History ------------------------------------------
 
 	void operator *=(vec_t s);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : this *= s, values are scaled, assigned   =)
 	 *
 	 *-- History ------------------------------------------

include/hel/ViewVolume.h → include/ViewVolume.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 is the viewing volume for culling use
  *
  *
- *           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_VIEWVOLUME - Builds ViewVolume class as a console unit test 
  *
- *-- History ------------------------------------------------ 
+ * UNIT_TEST_VIEWVOLUME - Builds ViewVolume class as a console unit test
+ *
+ *-- History ------------------------------------------------
  *
  * 2002.12.15:
  * Mongoose - Created
 #ifndef GUARD__HEL_MONGOOSE_VIEWVOLUME_H_
 #define GUARD__HEL_MONGOOSE_VIEWVOLUME_H_
 
-#include <hel/Matrix.h>
-#include <hel/BoundingVolume.h>
+#include <Matrix.h>
+#include <BoundingVolume.h>
 
 class ViewVolume
 {
 
 	ViewVolume();
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Constructs an object of ViewVolume
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.12.15: 
+	 * 2002.12.15:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.12.15: 
+	 * 2002.12.15:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 
 	bool isBoundingVolumeInFrustum(BoundingVolume bvol);
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : Returns true if frustum contains the given 
+	 * Pre  :
+	 * Post : Returns true if frustum contains the given
 	 *        bounding volume
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.12.15: 
+	 * 2002.12.15:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	bool isBoundingSphereInFrustum(BoundingSphere bvol);
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : Returns true if frustum contains the given 
+	 * Pre  :
+	 * Post : Returns true if frustum contains the given
 	 *        bounding volume
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.12.15: 
+	 * 2002.12.15:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	bool isBoundingBoxInFrustum(BoundingBox bvol);
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : Returns true if frustum contains the given 
+	 * Pre  :
+	 * Post : Returns true if frustum contains the given
 	 *        bounding volume
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.12.15: 
+	 * 2002.12.15:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	bool isPointInFrustum(vec_t x, vec_t y, vec_t z);
 	/*------------------------------------------------------
-	 * Pre  : 
-	 * Post : 
+	 * Pre  :
+	 * Post :
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.12.15: 
+	 * 2002.12.15:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.12.15: 
+	 * 2002.12.15:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.12.15: 
+	 * 2002.12.15:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	vec_t getDistToSphereFromNear(vec_t x, vec_t y, vec_t z, vec_t radius);
 	/*------------------------------------------------------
 	 * Pre  : Abstract sphere is valid
-	 * Post : Returns distance to abstract sphere 
+	 * Post : Returns distance to abstract sphere
 	 *        bounding volume
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.12.15: 
+	 * 2002.12.15:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 	 *
 	 *-- History ------------------------------------------
 	 *
-	 * 2002.12.15: 
+	 * 2002.12.15:
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
 
 	void getPlane(ViewVolumeSide p, vec4_t plane);
 	/*------------------------------------------------------
-	 * Pre  : 
+	 * Pre  :
 	 * Post : Get a copy of a given plane in view volume
 	 *
 	 *-- History ------------------------------------------
 	 * Mongoose - Created
 	 ------------------------------------------------------*/
 
-	
+
 	////////////////////////////////////////////////////////////
 	// Public Mutators
 	////////////////////////////////////////////////////////////

include/World.h

 #define BAD_BLOOD  // For temp rendering use
 
 #ifdef BAD_BLOOD
-#   include "SkeletalModel.h"
+#include <SkeletalModel.h>
 #endif
 
-#include "mstl/List.h"
-#include "mstl/Vector.h"
-#include "hel/math.h"
+#include <List.h>
+#include <Vector.h>
+#include <MatMath.h>
 
 
 // Mirrors TombRaider class' room flags really
 } sprite_seq_t;
 
 
-// FIXME: For now shaders are textures on tex objects
-//        and materials on color objects.  If -1
-//        then it doesn't have that information yet.
+/*! \fixme For now shaders are textures on tex objects
+ * and materials on color objects. If -1
+ * then it doesn't have that information yet.
+ */
 
 typedef struct texture_tri_s
 {
 
 } sector_t;
 
-// FIXME: No room mesh list or sprites and etc
+//! \fixme No room mesh list or sprites and etc
 typedef struct room_mesh_s
 {
 	Vector<int> adjacentRooms;

src/Camera.cpp

 #include <stdio.h>
 #include <math.h>
 
-#include <hel/math.h>
+#include <MatMath.h>
 #include <Camera.h>
 
 #ifdef DEBUG_MEMORY

src/GLString.cpp

 /*!
- * \file GLString.cpp
+ * \file src/GLString.cpp
  * \brief Open GL rendering font/string class
  *
  * \author Mongoose

src/hel/math.cpp → src/MatMath.cpp

 #include <stdlib.h>
 #include <math.h>
 
-#include <hel/math.h>
-#include <hel/Vector3d.h>
-#include <hel/Matrix.h>
+#include <MatMath.h>
+#include <Vector3d.h>
+#include <Matrix.h>
 
 #define COMPUTE
 

src/hel/Matrix.cpp → src/Matrix.cpp

 #include <stdio.h>
 #include <math.h>
 
-#include <hel/Matrix.h>
+#include <Matrix.h>
 
 
 ////////////////////////////////////////////////////////////

src/Network.cpp

 			}
 		}
 
-		// FIXME: Combine with above, duh
+		//! \fixme Combine with above, duh
 		// 3. Send to network layer
 		if (gClients[i].frameExpected == f.header)
 		{

src/OpenGLMesh.cpp

 /*!
- * \file OpenGLMesh.cpp
+ * \file src/OpenGLMesh.cpp
  * \brief OpenGL Mesh
  *
  * \author Mongoose
 
 		glPointSize(1.0f);
 
-		return; // FIXME
+		return; //! \fixme
 
 		for (j = 0; j < mQuads[i].num_quads; ++j)
 		{
 	mTriangleFlags = flags;
 	mTriangleTexCoordArray = texCoords;
 
-	// FIXME: sortTrianglesByTexture();
+	//! \fixme sortTrianglesByTexture();
 }
 
 

src/OpenRaider.cpp

 
 OpenRaider::~OpenRaider()
 {
-	// Mongoose 2002.01.02, FIXME GL call to critical section,
-	//   needs mutex really
+	/*! \fixme GL call to critical section,
+	 * needs mutex really -- Mongoose 2002.01.02
+     */
 	m_render.setMode(Render::modeDisabled);
-	//sleep(1); // Why should we sleep here? -- xythobuz
+	sleep(1);
 
 	printf("Removing World...\n");
 	gWorld.destroy();
 	display_memory_usage();
 #endif
 
-	// Mongoose 2002.01.02, FIXME GL call to critical section,
-	//   needs mutex really
+	/*! \fixme GL call to critical section,
+	 * needs mutex really -- Mongoose 2002.01.02
+     */
 	m_render.setMode(Render::modeDisabled);
-	//sleep(2);
+	sleep(1);
 
 	// Draw game, level is loaded
 	m_render.setMode(Render::modeVertexLight);
 		}
 	}
 
-	// FIXME: Check here and see if we already have one for object_id later
+	//! \fixme Check here and see if we already have one for object_id later
 	// if (gWorld.isCachedSkeletalModel(moveable[index].object_id))
 	// {
 	//   thing->modelId = m_render.add(sModel);
 		return;
 	}
 
-	// FIXME: Might be better UID for each model, but this seems
-	//        to work well
+	//! \fixme Might be better UID for each model, but this seems to work well
 	j = object_id;
 
 	// We only want one copy of the skeletal model in memory
 	// Assert common sense
 	if (index < 0 || !m_tombraider.isMeshValid(index))
 	{
-		// FIXME: allow sparse lists with matching ids instead?
+		//! \fixme allow sparse lists with matching ids instead?
 		gWorld.addMesh(NULL); // Filler, to make meshes array ids align
 		printf("x");
 		fflush(stdout);
 	// Mongoose 2002.08.30, Testing support for 'shootable' models ( traceable )
 	m_tombraider.getMeshCollisionInfo(index, mesh->center, &mesh->radius);
 
-	// FIXME: Arrays don't work either  =)
+	//! \fixme Arrays don't work either  =)
 	// Mesh geometery, colors, etc
 	m_tombraider.getMeshVertexArrays(index,
 												&mesh->vertexCount, &mesh->vertices,
 	float portalVertices[12];
 	count = m_tombraider.getRoomPortalCount(index);
 
-	// FIXME: OR wrongly uses a cached adj room list for rendering vis
+	//! \fixme OR wrongly uses a cached adj room list for rendering vis
 	r_mesh->adjacentRooms.reserve(count + 1);
 	r_mesh->adjacentRooms.setError(-1);
 
 
 	// Physics/gameplay use /////////////////////////////
 
-	// FIXME: Use more of sector structure, boxes, and floordata
+	//! \fixme Use more of sector structure, boxes, and floordata
 
 	// List of sectors in this room
 	unsigned int sectorFlags;
 	r_mesh->boxes.reserve(count);
 	r_mesh->boxes.setError(0x0);
 
-	// FIXME: Only to be done only on room[0]?  I don't think so...
+	//! fixme Only to be done only on room[0]?  I don't think so...
 	for (i = 0; !index && i < count; ++i)
 	{
 		box_t *box = new box_t;

src/Particle.cpp

 /*!
- * \file Particle.cpp
+ * \file src/Particle.cpp
  * \brief Particle system base implementation
  *
  * \author Mongoose

src/hel/Quaternion.cpp → src/Quaternion.cpp

 
 #include <math.h>
 
-#include <hel/Quaternion.h>
+#include <Quaternion.h>
 
 
 ////////////////////////////////////////////////////////////

src/Render.cpp

 		return;
 		break;
 	case Render::modeLoadScreen:
-		// Mongoose 2002.01.01, FIXME entry for seperate main drawing method
+		//! \fixme entry for seperate main drawing method -- Mongoose 2002.01.01
 		drawLoadScreen();
 		return;
 	default:
 	if (!rRoom || !rRoom->room)
 		return;
 
-	// Must be visible, FIXME: Add depth sorting here - remove multipass
+	// Must be visible
+    //! \fixme Add depth sorting here - remove multipass
 	if (!isVisible(rRoom->room->bbox_min, rRoom->room->bbox_max))
 		return;
 
 		return;
 
 	// Mongoose 2002.01.01, Rendered while game is loading...
-	//   FIXME seperate logo/particle coor later
+	//! \fixme seperate logo/particle coor later
 	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 	glLoadIdentity();
 
 	glPointSize(4.0);
 	//glLineWidth(1.25);
 
-	//FIXME: Need to make custom color key for this
+	//! \fixme Need to make custom color key for this
 	glColor3fv(RED);
 
 	glBegin(GL_POINTS);
 	glPointSize(4.0);
 	//glLineWidth(1.25);
 
-	//FIXME: Need to make custom color key for this
+	//! \fixme Need to make custom color key for this
 	glColor3fv(c1);
 
 	glBegin(GL_POINTS);
 
 	// If they pass NULL structs let it hang up - this is tmp
 
-	// FIXME: Duh, vis tests need to be put back
+	//! \fixme Duh, vis tests need to be put back
 	//if (!isVisible(r_mesh->center,	r_mesh->radius, r_mesh->bbox))
 	//{
 	//	 return;
 #endif
 
 
-	// Mongoose 2002.01.08, FIXME 'AMBIENT'
+	//! \fixme 'AMBIENT' -- Mongoose 2002.01.08
 	glColor3fv(WHITE);
 
 	if (mMode == modeWireframe)

src/SDLSystem.cpp

 {
 #ifdef HAVE_SDL_TTF
 #   ifdef FIXME
-	// FIXME: Filler
+	//! \fixme Filler
 	glBindTexture(GL_TEXTURE_2D, texture);
 	glBegin(GL_TRIANGLE_STRIP);
 	glTexCoord2f(texMinX, texMinY); glVertex2i(x,   y  );
 void SDLSystem::glPrintf3d(float x, float y, float z, char *string)
 {
 #ifdef HAVE_SDL_TTF_FIXME
-	// FIXME: Filler
-	// FIXME: Billboarding here requires a yaw jackass   =)
+	/*! \fixme Filler
+	 * Billboarding here requires a yaw jackass =)
+     */
 	glBindTexture(GL_TEXTURE_2D, texture);
 	glBegin(GL_TRIANGLE_STRIP);
 	glTexCoord2f(texMinX, texMinY); glVertex2i(x,   y  );
 
 				if (event.button.state == SDL_PRESSED)
 				{
-					handleKeyPressEvent(btn, 0); // FIXME: mod not used
+					handleKeyPressEvent(btn, 0); //! \fixme mod not used
 				}
 				else
 				{
-					handleKeyReleaseEvent(btn, 0); // FIXME: mod not used
+					handleKeyReleaseEvent(btn, 0); //! \fixme mod not used
 				}
 				break;
 			case SDL_KEYUP:
 					}
 				}
 #else
-				// 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
+				/*! \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;

src/Sound.cpp

 /*!
- * \file Sound.cpp
+ * \file src/Sound.cpp
  * \brief This is the audio manager Implementation
  *
  * \author Mongoose

src/System.cpp

 /*!
- * \file System.cpp
+ * \file src/System.cpp
  * \brief Mostly defines the interface of System implementations.
  *
  * Currently only SDL is used, but there was a GLUT implementation.

src/TombRaider.cpp

      return -1;
    }
 
-	/* FIXME: Endianess */
+	//! \fixme Endianess
    fread(&version, sizeof(version), 1, f);
 	fclose(f);
 
 	mReset = false;
 
    Fread(&mPakVersion, sizeof(mPakVersion), 1, f);
-   //FIXME: endian
+   //! \fixme endian
 
    printDebug("Load", "mPakVersion = %u", mPakVersion);
 
 
      if (mEngineVersion != TR_VERSION_1)
      {
-       //FIXME: need endian checking here
+       //! \fixme need endian checking here
        Fread(_textile16, sizeof(tr2_textile16_t), _num_textiles, f);
        printDebug("Load", "Read in 16bit texture tiles");
      }
    printDebug("Load", "_unknown_t = 0x%x", _unknown_t);
 
    /* Read raw room data */
-   //FIXME: needs endian checking
+   //! \fixme needs endian checking
    Fread(&_num_rooms, sizeof(_num_rooms), 1, f);
    printDebug("Load", "_num_rooms = %i", _num_rooms);
 
 		}
 
      /* Read RoomInfo */
-     //FIXME: endian check needed
+     //! \fixme endian check needed
      Fread(&_rooms[i].info, sizeof(tr2_room_info_t), 1, f);
 
      printDebug("Load", "_rooms[%i].info =\n { x=%i, z=%i, yt=%i, yb=%i}",
 
      /* Identify vertices */
      data_offset = 0;
-     //FIXME: endian
+     //! \fixme endian
      _rooms[i].room_data.num_vertices = *(short *)(_rooms[i].data);
 
      data_offset += sizeof(_rooms[0].room_data.num_vertices);
 					  _rooms[i].data + data_offset, data_size);
        }
 
-       //FIXME: endian conversions for verts needed
+       //! \fixme endian conversions for verts needed
      }
 
      data_offset += data_size;
 
      /* identify rectangles */
-     //FIXME: endian conversion
+     //! \fixme endian conversion
      _rooms[i].room_data.num_rectangles =
        *(short *)(_rooms[i].data + data_offset);
 
 				 _rooms[i].room_data.rectangles[j].texture &= 0x7fff;
 			 }
        }
-       //FIXME: endian conversion
+       //! \fixme endian conversion
      }
 
      data_offset += data_size;
      /* Identify triangles */
      _rooms[i].room_data.num_triangles =
        *(short *)(_rooms[i].data + data_offset);
-     //FIXME: endian
+     //! \fixme endian
 
      data_offset += sizeof(_rooms[0].room_data.num_triangles);
      data_size = _rooms[i].room_data.num_triangles * sizeof(tr2_tri_t);
 			 {
 				 _rooms[i].room_data.triangles[j].texture &= 0x7fff;
 			 }
-			 //FIXME: endian
+			 //! \fixme endian
        }
      }
 
       /* Identify sprites */
       _rooms[i].room_data.num_sprites =
 			*(short *)(_rooms[i].data + data_offset);
-      //FIXME: endian
+      //! \fixme endian
 
       data_offset += sizeof(_rooms[0].room_data.num_sprites);
       data_size = _rooms[i].room_data.num_sprites * sizeof(tr2_room_sprite_t);
 				}
 			}
 
-			//FIXME: endian
+			//! \fixme endian
       }
 
       /* Free the raw room data */
       _rooms[i].data = NULL;
 
       /* Read door info */
-      //FIXME: endian
+      //! \fixme endian
       Fread(&_rooms[i].num_portals, sizeof(_rooms[0].num_portals), 1, f);
 
       printDebug("Load", "_rooms[%i].num_portals = %i",
 
       Fread(_rooms[i].portals, sizeof(tr2_room_portal_t),
 	    _rooms[i].num_portals, f);
-      //FIXME: endian
+      //! \fixme endian
 
       /* Read sector info */
-      //FIXME: endian
+      //! \fixme endian
       Fread(&_rooms[i].num_zsectors, sizeof(_rooms[0].num_zsectors), 1, f);
       Fread(&_rooms[i].num_xsectors, sizeof(_rooms[0].num_xsectors), 1, f);
 
 
       Fread(_rooms[i].sector_list, sizeof(tr2_room_sector_t),
 	    _rooms[i].num_zsectors * _rooms[i].num_xsectors, f);
-      //FIXME: endian
+      //! \fixme endian
 
       printDebug("Load", "Read %u room sectors",
 		 _rooms[i].num_zsectors * _rooms[i].num_xsectors);
       }
 
       /* Read room lighting info */
-       //FIXME: endian
+       //! \fixme endian
       Fread(&_rooms[i].num_lights, sizeof(_rooms[i].num_lights), 1, f);
 
       printDebug("Load", "_rooms[%i].num_lights = %u",
 						_rooms[i].num_lights, f);
 			}
       }
-      //FIXME: endian
+      //! \fixme endian
 
       /* Read Static Mesh Data */
       Fread(&_rooms[i].num_static_meshes, sizeof(unsigned short), 1, f);
-      //FIXME: endian
+      //! \fixme endian
 
       printDebug("Load", "_rooms[%i].num_static_meshes = %u",
 					  i, _rooms[i].num_static_meshes);
 						_rooms[i].num_static_meshes, f);
 			}
       }
-      //FIXME: endian
+      //! \fixme endian
 
       Fread(&_rooms[i].alternate_room, sizeof(short), 1, f);
-      //FIXME: endian
+      //! \fixme endian
 
       printDebug("Load", "_rooms[%i].alternate_room = %i",
 		 i, _rooms[i].alternate_room);
 
       Fread(&_rooms[i].flags, sizeof(short), 1, f);
-      //FIXME: endian
+      //! \fixme endian
 
       printDebug("Load", "_rooms[%i].flags = 0x%x",
 					  i, _rooms[i].flags);
    {
      _floor_data = new unsigned short[_num_floor_data];
      Fread(_floor_data, sizeof(short), _num_floor_data, f);
-     //FIXME: endian
+     //! \fixme endian
    }
 
    /* Read mesh data */
    Fread(&num_mesh_data_words, sizeof(num_mesh_data_words), 1, f);
-   //FIXME: endian
+   //! \fixme endian
 
    printDebug("Load", "num_mesh_data_words = %u", num_mesh_data_words);
 
 
    /* Read mesh pointers */
    Fread(&num_mesh_pointers, sizeof(num_mesh_pointers), 1, f);
-   //FIXME: endian
+   //! \fixme endian
 
    printDebug("Load", "num_mesh_pointers = %u", num_mesh_pointers);
 
    mesh_pointer_list = new unsigned int[num_mesh_pointers];
    Fread(mesh_pointer_list, sizeof(unsigned int), num_mesh_pointers, f);
-   //FIXME: endian
+   //! \fixme endian
 
    printDebug("Load", "Read mesh_pointer_list");
 
 
    /* Read animations */
    Fread(&_num_animations, sizeof(_num_animations), 1, f);
-   //FIXME: endian
+   //! \fixme endian
 
    printDebug("Load", "_num_animations = %u", _num_animations);
 
          Fread(_animations, sizeof(tr2_animation_t), _num_animations, f);
      }
    }
-   //FIXME: endian
+   //! \fixme endian
 
    /* Read state changes */
    Fread(&_num_state_changes, sizeof(_num_state_changes), 1, f);
-   //FIXME: endian
+   //! \fixme endian
 
 
    if (percent)
 
      Fread(_state_changes, sizeof(tr2_state_change_t), _num_state_changes, f);
    }
-   //FIXME: endian
+   //! \fixme endian
 
    /* Read AnimDispatches */
    Fread(&_num_anim_dispatches, sizeof(_num_anim_dispatches), 1, f);
-   //FIXME: endian
+   //! \fixme endian
 
    printDebug("Load", "_num_anim_dispatches = %u", _num_anim_dispatches);
 
       Fread(_anim_dispatches, sizeof(tr2_anim_dispatch_t),
 	    _num_anim_dispatches, f);
    }
-   //FIXME: endian
+   //! \fixme endian
 
    /* Read anim commands */
    Fread(&_num_anim_commands, sizeof(_num_anim_commands), 1, f);
-   //FIXME: endian
+   //! \fixme endian
 
    printDebug("Load", "_num_anim_commands = %u", _num_anim_commands);
 
      _anim_commands = new tr2_anim_command_t[_num_anim_commands];
      Fread(_anim_commands, sizeof(tr2_anim_command_t), _num_anim_commands, f);
    }
-   //FIXME: endian
+   //! \fixme endian
 
    /* Read MeshTrees */
    Fread(&_num_mesh_trees, sizeof(_num_mesh_trees), 1, f);
-   //FIXME: endian
+   //! \fixme endian
 
    printDebug("Load", "_num_mesh_trees = %u", _num_mesh_trees);
 
      _mesh_trees = new tr2_meshtree_t[_num_mesh_trees];
      Fread(_mesh_trees, sizeof(int), _num_mesh_trees, f);
    }
-   //FIXME: endian
+   //! \fixme endian
 
    /* Read frames */
    Fread(&_num_frames, sizeof(_num_frames), 1, f);
-   //FIXME: endian
+   //! \fixme endian
 
    printDebug("Load", "_num_frames = %u", _num_frames);
 
    {
      _frames = new unsigned short[_num_frames];
      Fread(_frames, 2, _num_frames, f);
-     //FIXME: endian
+     //! \fixme endian
 
      if (mEngineVersion == TR_VERSION_1)
      {
 
    /* Read moveables */
    Fread(&_num_moveables, sizeof(_num_moveables), 1, f);
-   //FIXME: endian
+   //! \fixme endian
    printDebug("Load", "_num_moveables = %u", _num_moveables);
 
 	_moveables = 0x0;
      _moveables = new tr2_moveable_t[_num_moveables];
      Fread(_moveables, 18, _num_moveables, f);
    }
-   //FIXME: endian
+   //! \fixme endian
 
    Fread(&_num_static_meshes, sizeof(int), 1, f);
-   //FIXME: endian
+   //! \fixme endian
    printDebug("Load", "_num_static_meshes = %u", _num_static_meshes);
 
    // SAFE EXIT //////////////////////////
      _static_meshes = new tr2_staticmesh_t[_num_static_meshes];
      Fread(_static_meshes, sizeof(tr2_staticmesh_t),
 	   _num_static_meshes, f);
-     //FIXME: endian
+     //! \fixme endian
    }
 
 	_object_textures = 0x0;
      /* Read object textures */
      Fread(&_num_object_textures, sizeof(int), 1, f);
      printDebug("Load", "_num_object_textures = %u", _num_object_textures);
-     //FIXME: endian
+     //! \fixme endian
 
      if (_num_object_textures > 0)
      {
        Fread(_object_textures, sizeof(tr2_object_texture_t),
 	     _num_object_textures, f);
      }
-     //FIXME: endian
+     //! \fixme endian
    }
 
 
 
    /* Read sprite textures */
    Fread(&_num_sprite_textures, sizeof(int), 1, f);
-   //FIXME: endian
+   //! \fixme endian
    printDebug("Load", "_num_sprite_textures = %u", _num_sprite_textures);
 
 	_sprite_textures = 0x0;
      Fread(_sprite_textures, sizeof(tr2_sprite_texture_t),
 	   _num_sprite_textures, f);
    }
-   //FIXME: endian
+   //! \fixme endian
 
    /* Read sprite texture data (?) */
    Fread(&_num_sprite_sequences, sizeof(int), 1, f);
-   //FIXME: endian
+   //! \fixme endian
    printDebug("Load", "_num_sprite_sequences = %u", _num_sprite_sequences);
 
 	_sprite_sequences = 0x0;
      Fread(_sprite_sequences, sizeof(tr2_sprite_sequence_t),
 	   _num_sprite_sequences, f);
    }
-   //FIXME: endian
+   //! \fixme endian
 
    /* Read cameras */
    Fread(&_num_cameras, sizeof(_num_cameras), 1, f);
-   //FIXME: endian
+   //! \fixme endian
    printDebug("Load", "_num_cameras = %i", _num_cameras);
 
 	_cameras = 0x0;
    {
      _cameras = new tr2_camera_t[_num_cameras];
      Fread(_cameras, sizeof(tr2_camera_t), _num_cameras, f);
-     //FIXME: endian
+     //! \fixme endian
    }
 
 	if (mEngineVersion == TR_VERSION_4)
 
    /* Read sound effects (?) */
    Fread(&_num_sound_sources, sizeof(_num_sound_sources), 1, f);
-   //FIXME: endian
+   //! \fixme endian
    printDebug("Load", "_num_sound_sources = %i", _num_sound_sources);
 
 	_sound_sources = 0x0;
        Fread(_sound_sources, sizeof(tr2_sound_source_t),
 	     _num_sound_sources, f);
      }
-     //FIXME: endian
+     //! \fixme endian
    }
 
 #ifdef OBSOLETE
 
    /* Read boxes */
    Fread(&_num_boxes, sizeof(_num_boxes), 1, f);
-   //FIXME: endian
+   //! \fixme endian
    printDebug("Load", "_num_boxes = %i", _num_boxes);
 
 	_boxes = 0x0;
 		  tr1box = new tr1_box[_num_boxes];
 
 		  Fread(tr1box, sizeof(struct tr1_box), _num_boxes, f);
-		  //FIXME: endian
+		  //! \fixme endian
 
          for (j = 0; j < _num_boxes; ++j)
 			{
      {
        Fread(_boxes, sizeof(tr2_box_t), _num_boxes, f);
      }
-     //FIXME: endian
+     //! \fixme endian
    }
 
    /* Read overlaps (?) */
    Fread(&_num_overlaps, sizeof(_num_overlaps), 1, f);
-   //FIXME: endian
+   //! \fixme endian
    printDebug("Load", "_num_overlaps = %i", _num_overlaps);
 
 	_overlaps = 0x0;
    {
      _overlaps = new short[_num_overlaps];
      Fread(_overlaps, 2, _num_overlaps, f);
-     //FIXME: endian
+     //! \fixme endian
    }
 
 	_zones = 0x0;
      {
        Fread(_zones, 20, _num_boxes, f);
      }
-     //FIXME: endian
+     //! \fixme endian
    }
 
    /* Read animation textures (?) */
    Fread(&_num_animated_textures, sizeof(_num_animated_textures), 1, f);
-   //FIXME: endian
+   //! \fixme endian
    printDebug("Load", "_num_animated_textures = %i", _num_animated_textures);
 
 	_animated_textures = 0x0;
    {
      _animated_textures = new short[_num_animated_textures];
      Fread(_animated_textures, 2, _num_animated_textures, f);
-     //FIXME: endian
+     //! \fixme endian
    }
 
    if (mEngineVersion >= TR_VERSION_3)
       }
 
       Fread(&_num_object_textures, sizeof(_num_object_textures), 1, f);
-      //FIXME: endian
+      //! \fixme endian
 
       printDebug("Load", "_num_object_textures = %i", _num_object_textures);
 
 			// Used to be 2 * num, and I forgot why...
 			_object_textures = new tr2_object_texture_t[_num_object_textures];
 
-			//FIXME: This is fu fu fu fu fu fu
+			//! \fixme This is fu fu fu fu fu fu
 			if (mEngineVersion == TR_VERSION_4)
 	      {
 				int jjj, kkk;
 						_num_object_textures, f);
 			}
       }
-      //FIXME: endian
+      //! \fixme endian
    }
 
    /* Read items */
    Fread(&_num_items, sizeof(_num_items), 1, f);
-   //FIXME: endian
+   //! \fixme endian
    printDebug("Load", "_num_items = %i", _num_items);
 
 	_items = 0x0;
        Fread(_items, sizeof(tr2_item_t), _num_items, f);
      }
    }
-   //FIXME: endian
+   //! \fixme endian
 
    /* Read LightMaps */
    _light_map = new unsigned char[32 * 256];
 		unsigned short num_cinematic_frames;
 
      Fread(&num_cinematic_frames, sizeof(num_cinematic_frames), 1, f);
-     //FIXME: endian
+     //! \fixme endian
 
 	  _num_cinematic_frames = num_cinematic_frames;
 
 
    /* Read demodata (?) */
    Fread(&_num_demo_data, sizeof(_num_demo_data), 1, f);
-   //FIXME: endian
+   //! \fixme endian
    printDebug("Load", "_num_demo_data = %i", _num_demo_data);
 
 	_demo_data = 0x0;
    if (mEngineVersion == TR_VERSION_1)
    {
      Fread(mSoundMap, sizeof(short), 256, f);
-     //memset(_sound_map, 0, 370 * sizeof(short));   //FIXME: KLUDGE!!!
+     //memset(_sound_map, 0, 370 * sizeof(short));   //! \fixme KLUDGE!!!
    }
    else
    {
        Fread(mSoundMap, sizeof(short), 370, f);
      }
    }
-   //FIXME: endian
+   //! \fixme endian
 
    /* Read SoundDetails */
    Fread(&mNumSoundDetails, sizeof(mNumSoundDetails), 1, f);
    printDebug("Load", "mNumSoundDetails = %i", mNumSoundDetails);
-   //FIXME: endian
+   //! \fixme endian
 
 	mSoundDetails = 0x0;
 
      mSoundDetails = new tr2_sound_details_t[mNumSoundDetails];
      Fread(mSoundDetails, sizeof(tr2_sound_details_t), mNumSoundDetails, f);
    }
-   //FIXME: endian
+   //! \fixme endian
 
 	// Read sound sample indices
 	mSampleIndices = 0x0;
 		if (mNumSampleIndices > 0)
 		{
 			mSampleIndices = new int[mNumSampleIndices];
-			// FIXME: (Endian)
+			//! \fixme (Endian)
 			Fread(mSampleIndices, 4, mNumSampleIndices, f);
 		}
 		break;
 		mFreadMode = TR_FREAD_NORMAL;
 		// 0x46464952
 
-		// FIXME: (Endian) Read bitu32 / u_int32_t
+		//! \fixme (Endian) Read bitu32 / u_int32_t
 		Fread(&mNumTR4Samples, 4, 1, f);
 		printDebug("Load", "mNumTR4Samples = %i", mNumTR4Samples);
 
 		}
 		break;
 	default:
-		// FIXME: (Endian) Read bit32 / int32_t
+		//! \fixme (Endian) Read bit32 / int32_t
 		Fread(&mNumSampleIndices, 4, 1, f);
 		printDebug("Load", "mNumSampleIndices = %i", mNumSampleIndices);
 
 		if (mNumSampleIndices > 0)
 		{
 			mSampleIndices = new int[mNumSampleIndices];
-			// FIXME: (Endian)
+			//! \fixme (Endian)
 			Fread(mSampleIndices, 4, mNumSampleIndices, f);
 		}
    }
      delete [] mCompressedLevelData;
    }
 
-	// FIXME: memory damage?
+	//! \fixme memory damage?
 	mCompressedLevelData = NULL;
 #endif
 
 }
 
 
-// FIXME: Needs refinement once the ideal format it's feeding is refined
+//! \fixme Needs refinement once the ideal format it's feeding is refined
 // I should stick a HACK postfix on the method name - it's temporary
 // until an array format can be crafted from a pinned down design and
 // RE notes review session ( eg what about TR5? )
 	{
 		givenWarning = true;
 
-		// FIXME: Use Material class to handle greyscale alpha intensity
+		//! \fixme Use Material class to handle greyscale alpha intensity
 		//        (partial alpha)
 		print("getMeshTexturedRectangle",
 				"TR3+ greyscale alpha intensity not implmented, %s:%i",
 	{
 		givenWarning = true;
 
-		// FIXME: Use Material class to handle greyscale alpha intensity
+		//! \fixme Use Material class to handle greyscale alpha intensity
 		//        (partial alpha)
 		print("getMeshTexturedTriangle",
 				"TR3+ greyscale alpha intensity not implmented, %s:%i",
 }
 
 
-// FIXME: Perhaps making color an 8bit intensity would be a better idea
+//! \fixme Perhaps making color an 8bit intensity would be a better idea
 void TombRaider::getMeshVertexArrays(unsigned int meshIndex,
 												 unsigned int *vertexCount, float **verts,
 												 unsigned int *normalCount, float **norms,
 		// Bounding Box setup
 		for (i = 0; i < mRoomsTR5[index].numLayers; ++i)
 		{
-			// FIXME: check the boxes are in min, max order in TRC
+			//! \fixme check the boxes are in min, max order in TRC
 
 			if (i == 0)
 			{
 }
 
 
-// FIXME: No TRC support
+//! \fixme No TRC support
 void TombRaider::getRoomRectangle(unsigned int roomIndex,
 											 unsigned int rectangleIndex,
 											 unsigned int *indices, float *texCoords,
 }
 
 
-// FIXME: No TR5 support
+//! \fixme No TR5 support
 void TombRaider::getRoomVertex(unsigned int roomIndex,unsigned int vertexIndex,
 										 float *xyz, float *rgba)
 {
 				(*normals)[k*3+1] = mRoomsTR5[roomIndex].faces[i].verts[j].ny;
 				(*normals)[k*3+2] = mRoomsTR5[roomIndex].faces[i].verts[j].nz;
 
-				// FIXME: Ah, yeah this may be wrong
+				//! \fixme Ah, yeah this may be wrong
 				c = ((unsigned char *)&mRoomsTR5[roomIndex].faces[i].verts[j].vColor)[1];
 				(*colors)[k*4] = (float)c / 255.0f;
 				c = ((unsigned char *)&mRoomsTR5[roomIndex].faces[i].verts[j].vColor)[2];
 	default:
 		*vertexCount = count;
 		*vertices = new float[count*3];
-		*normalCount = 0;  // FIXME: Do some TR1-TR4 levels support normals here?
+		*normalCount = 0;  //! \fixme Do some TR1-TR4 levels support normals here?
 		*normals = 0x0;
 		*colorCount = count;
 		*colors = new float[count*4];
 	switch (Engine())
 	{
 	case TR_VERSION_1:
-		// FIXME: This implies higher tmp memory cost ( copy safety )
+		//! \fixme This implies higher tmp memory cost ( copy safety )
 		getRiffData(bytes, &riff);
 
 		if (riff && (int)index < mNumSampleIndices)
 		return;
 	}
 
-  // FIXME: Palettes aren't the same size anymore
+  //! \fixme Palettes aren't the same size anymore
   //memset(_palette8, 0, 256);
   //memset(_palette16, 0, 256);
 
   if (_textile32)
     delete [] _textile32;
 
-  // FIXME: Damaged memory causes delete to not set pointer to NULL?
+  //! \fixme Damaged memory causes delete to not set pointer to NULL?
   _tex_special = NULL;
   _textile8 = NULL;
   _textile16 = NULL;
 
 		/* Get Centre + Unknowns */
 		memcpy(&mMeshes[i].centre.x, mesh_pointer, 10);
-		//FIXME: endian
+		//! \fixme endian
 
 		// depending on the interpretation of the unknowns that follow the Centre
 		// element, more endian conversion may be necessary
 
 		/* Get number of vertices */
 		memcpy(&mMeshes[i].num_vertices, mesh_pointer, 2);
-		//FIXME: endian
+		//! \fixme endian
 
 		printDebug("ExtractMeshes", "mMeshes[%i].num_vertices = %u",
 					  i, mMeshes[i].num_vertices);
 			mMeshes[i].vertices = new tr2_vertex_t[mMeshes[i].num_vertices];
 
 		memcpy(mMeshes[i].vertices, mesh_pointer, size);
-		//FIXME: endian
+		//! \fixme endian
 
 		mesh_pointer += size;
 
 		/* Get number of normals */
 		memcpy(&mMeshes[i].num_normals, mesh_pointer, sizeof(unsigned short));
-		//FIXME: endian
+		//! \fixme endian
 
 		mesh_pointer += sizeof(unsigned short);
 		negative_size = (mMeshes[i].num_normals < 0);
 
 			memcpy(mMeshes[i].normals, mesh_pointer, size);
 		}
-		//FIXME: endian
+		//! \fixme endian
 
 		mesh_pointer += size;
 
 		/* Get number of textured rectangles */
 		memcpy(&mMeshes[i].num_textured_rectangles,
 				 mesh_pointer, sizeof(unsigned short));
-		//FIXME: endian
+		//! \fixme endian
 
 		mesh_pointer += sizeof(unsigned short);
 		mMeshes[i].num_textured_rectangles =
 			{
 				memcpy(mMeshes[i].textured_rectangles, mesh_pointer, size);
 			}
-			//FIXME: endian
+			//! \fixme endian
 
 			if (mEngineVersion != TR_VERSION_4)
 				mesh_pointer += size;
 		/* Get number of textured triangles */
 		memcpy(&mMeshes[i].num_textured_triangles,
 				 mesh_pointer, sizeof(unsigned short));
-		//FIXME: endian
+		//! \fixme endian
 
 		mesh_pointer += sizeof(unsigned short);
 		mMeshes[i].num_textured_triangles =
 			{
 				memcpy(mMeshes[i].textured_triangles, mesh_pointer, size);
 			}
-			//FIXME: endian
+			//! \fixme endian
 
 			if (mEngineVersion != TR_VERSION_4)
 				mesh_pointer += size;
 		/* Get number of coloured rectangles */
 		memcpy(&mMeshes[i].num_coloured_rectangles, mesh_pointer,
 				 sizeof(unsigned short));
-		//FIXME: endian
+		//! \fixme endian
 		mesh_pointer += sizeof(unsigned short);
 		mMeshes[i].num_coloured_rectangles =
       (short)abs(mMeshes[i].num_coloured_rectangles);
 		if (mMeshes[i].num_coloured_rectangles > 0)
 		{
 			memcpy(mMeshes[i].coloured_rectangles, mesh_pointer, size);
-			//FIXME: endian
+			//! \fixme endian
 			mesh_pointer += size;
 		}
 
 		/* Get number of coloured triangles */
 		memcpy(&mMeshes[i].num_coloured_triangles, mesh_pointer,
 				 sizeof(unsigned short));
-		//FIXME: endian
+		//! \fixme endian
 
 		mesh_pointer += sizeof(unsigned short);
 		mMeshes[i].num_coloured_triangles =
 		if (mMeshes[i].num_coloured_triangles > 0)
 		{
 			memcpy(mMeshes[i].coloured_triangles, mesh_pointer, size);
-			//FIXME: endian
+			//! \fixme endian
 
 			mesh_pointer += size;
 		}
 		case TR_VERSION_3: // Account for alpha flags
 			for (j = 0; j < (int)_num_object_textures; j++)
 			{
-				// FIXME: This kind of works for lighting - but messes up lara
+				//! \fixme This kind of works for lighting - but messes up lara
 #ifdef FIXME
 				if (_object_textures[j].tile == texture &&
 					 _object_textures[j].transparency_flags == 1)
 }
 
 
-// FIXME: Move these data about to make full use in the class  ;)
+//! \fixme Move these data about to make full use in the class  ;)
 int TombRaider::loadTR5(FILE *f, void (*percent)(int))
 {
 	unsigned int level_data_sz, riffOffset, seperator0;
 		fseek(f, u, SEEK_SET);
 	}
 
-	// FIXME: (Endian) Read bitu32 / u_int32_t
+	//! \fixme (Endian) Read bitu32 / u_int32_t
 	Fread(&mNumTR4Samples, 4, 1, f);
 	printDebug("Load", "mNumTR4Samples = %i", mNumTR4Samples);
 

src/hel/Vector3d.cpp → src/Vector3d.cpp

 
 #include <math.h>
 
-#include <hel/Vector3d.h>
+#include <Vector3d.h>
 
 
 ////////////////////////////////////////////////////////////

src/hel/ViewVolume.cpp → src/ViewVolume.cpp

 
 #include <math.h>
 
-#include <hel/ViewVolume.h>
+#include <ViewVolume.h>
 
 
 ////////////////////////////////////////////////////////////

src/World.cpp

 			break;
 		}
 
-		// FIXME: Test for vector (move vector) / plane (portal) collision here
-		//        to see if we need to switch rooms... man...
+		/*! \fixme Test for vector (move vector) / plane (portal) collision here
+		 * to see if we need to switch rooms... man...
+         */
 
 		h = y;
 		getHeightAtPosition(room, x, &h, z);

test/GLString.cpp

 /*!
- * \file GLString.cpp
+ * \file test/GLString.cpp
  * \brief Open GL rendering font/string Unit Test
  *
  * \author Mongoose

test/hel/math.cpp → test/MatMath.cpp

 #include <stdio.h>
 #include <math.h>
 
-#include <hel/math.h>
+#include <MatMath.h>
 
 void helMathTest()
 {

test/hel/Matrix.cpp → test/Matrix.cpp

 #include <math.h>
 #include <strings.h>
 
-#include <hel/Matrix.h>
+#include <Matrix.h>
 
 
 /* <Order> is (r)ow or (c)ol */

test/hel/Quaternion.cpp → test/Quaternion.cpp

 #include <stdio.h>
 #include <math.h>
 
-#include <hel/Quaternion.h>
+#include <Quaternion.h>
 
 int runQuaternionUnitTest(int argc, char *argv[])
 {

test/Sound.cpp

 /*!
- * \file Sound.cpp
+ * \file test/Sound.cpp
  * \brief This is the audio manager Unit Test
  *
  * \author Mongoose

test/mtk_tga.cpp

-/*================================================================
+/*!
+ * \file test/mtk_tga.cpp
+ * \brief The TGA reader Unit Test
  *
- * Project : Freyja
- * Author  : Mongoose
- * Website : http://www.westga.edu/~stu7440/
- * Email   : stu7440@westga.edu
- * Object  :
- * License : GPL See file COPYING, also (C) 2000 Mongoose
- * Comments: TGA plug-in
- *
- *           TODO: type should pass more info
- *                 2 bits for RGBA | RGB | GREY
- *                 val for depth
- *
- *           This file was generated using Mongoose's C++
- *           template generator script.  <stu7440@westga.edu>
- *
- *-- History ------------------------------------------------
- *
- * 2001-10-25:
- * Mongoose - support for screen origin bit
- *
- * 2000-10-15:
- * Mongoose - Created
- ================================================================*/
-
-#include <string.h>
-#include <stdarg.h>
-
+ * \author xythobuz
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <greatest.h>
 #include <mtk_tga.h>
 
-int main(int argc, char *argv[])
-{
-  FILE *f;
-  unsigned char *image;
-  unsigned int width;
-  unsigned int height;
-  char type;
-
-  if (argc > 1)
-  {
-    f = fopen(argv[1], "r");
+#define TESTFILE "data/font-0.tga"
+FILE *f = NULL;
 
-    if (!f)
-    {
-      perror("Failed to open file> ");
-      return -1;
-    }
+TEST checkFile() {
+    ASSERTm("File wasn't opened. Please run the suite!", f != NULL);
+    ASSERT_FALSEm("File is invalid?!", mtk_image__tga_check(f));
+    PASS();
+}
 
-    if (!mtk_image__tga_check(f))
-    {
-      if (!mtk_image__tga_load(f, &image, &width, &height, &type))
-      {
-        printf("Loaded %s successfully!\n", argv[1]);
-        delete [] image;
-      }
-    }
+TEST loadFile() {
+    unsigned char *image;
+    unsigned int width, height;
+    char type;
+    ASSERTm("File wasn't opened. Please run the suite!", f != NULL);
+    ASSERT_FALSEm("File couldn't be loaded!", mtk_image__tga_load(f, &image, &width, &height, &type));
+    printf("\nWidth: %u\nHeight: %u\nType: %d\n", width, height, type);
+    PASS();
+}
 
+SUITE(tgaSuite) {
+    f = fopen(TESTFILE, "r");
+    RUN_TEST(checkFile);
+    RUN_TEST(loadFile);
     fclose(f);
-  } else {
-      printf("Usage: %s testfile.tga\n", argv[0]);
-  }
+}
+
+GREATEST_MAIN_DEFS();
 
-  return 0;
+int main(int argc, char *argv[]) {
+    GREATEST_MAIN_BEGIN();
+    RUN_SUITE(tgaSuite);
+    GREATEST_MAIN_END();
 }