Autoindent & retab

ChangeLog

@@ -7,6 +7,8 @@
 
 	[ 20140120 ]
 	* Removed HAVE_SDL & HAVE_SDL_TTF flags. SDL & TTF always required!
+	* Converted all tabs to spaces (4 spaces per tab)
+	* Auto indented all cpp files
 
 	[ 20140119 ]
 	* Enabled linear texture filtering for fonts, resulting in nicer
@@ -169,7 +171,7 @@
 	[ 20030701 ]
 	* Removing OpenRaider Map use for level/music string storage
 	  ( This means if you set a map to a certain number in rc, then
-	    you can no longer call it by 'load #' )
+		you can no longer call it by 'load #' )
 	* Fixed PSKModel unit test build
 	* Fixed Hel Simulation, Spring unit test builds
 	
@@ -428,7 +430,7 @@
 
 	* TR4 pak sound reading and dumping 
 	  ( I couldn't find any paks using compression - however
-	    my algorithm can handle those that may )
+		my algorithm can handle those that may )
 	* Sound read from TR1 paks agian ( TombRaider.test can dump them )
 	* TR4 ponytail type guessing algorithm works with TR4 paks
 	  ( May not apply to all custom lara models )
@@ -1063,7 +1065,7 @@
 	* Worked on portal code (testing)
 	* Since adding quaternion camera, segfault on exit... hhmmm...
 	* Finished quaternion based camera and rendering
- 	* Planning to break mtk3d into base type classes and expand it as
+	* Planning to break mtk3d into base type classes and expand it as
 	  a library with learping functions for use in animation also  =)
 	* Started on quaternion camera and quaternion support in mtk3d
 	* TR4 sound fx postioning loader starts
@@ -1082,14 +1084,14 @@
  OpenRaider (0.0.3-20010602) Mongoose <mongoose@users.sourceforge.net>
 
 	* SDL is very slow atm ( drag ass )
-   	  You can edit Makefile to set it to use it if you want
+	  You can edit Makefile to set it to use it if you want
 	* Finished basic test SDL interface
 	* Started on item sprite loading (likes a little more, but not priority)
 	* Aren't you all gald I ditched render engine #1 now?  ;)
 	* New sprite rendering code
 	* Fixed bug that drew static room meshes twice
 	* Fixed bug that drew alpha sorted tris 3 times
-   	  (Fixes all known alpha rendering bugs)
+	  (Fixes all known alpha rendering bugs)
 	* Room sprite loading code
 	* Cleaned code, fixed some documentation
 	* Started work on Resource agent, not ready to replace old code yet
@@ -1108,7 +1110,7 @@
 	* SDL support starts back
 	* Added my old linux joystick code
 	* Basic sorted alpha poly render second pass with very small penalty
-   	  ( An all new rendering feature never in engine before )
+	  ( An all new rendering feature never in engine before )
 	* Figured out best way to sort alpha polys exp with rooms only for now
 	* SkyMesh support ( rendering/identifing ) for TR2 and TR3
 	* Static mesh rendering back ( doesn't use room lighting 
@@ -1124,7 +1126,7 @@
 	* Code clean up
 	* Item sprite and room sprite loader code about finished
 	* Finished adding my screenshot code from Freyja, and
-   	  made it produce TGAs instead of PPMs ( cmd 'S' )
+	  made it produce TGAs instead of PPMs ( cmd 'S' )
 
 
  OpenRaider (0.0.3-20010528) Mongoose <mongoose@users.sourceforge.net>
@@ -1132,14 +1134,14 @@
 	* POublic CVS Release 
 	* Vertex lighting now functional and stable in new engine
 	* Fix for TR4 water alpha via textile generator, but
-   	  some light shards are still black - might be other
-   	  alpha flags that are unknown
+	  some light shards are still black - might be other
+	  alpha flags that are unknown
 	* New level loader using _map_list
 	* New Map list RC rule
 	* Start of item sprite code in new engine
- 	* Leaving old Texture calls for compaiblity with obsolete
+	* Leaving old Texture calls for compaiblity with obsolete
 	* New textile loading by moving new code into Freyja's
-   	  TombRaider module to handle *all pixmap generation
+	  TombRaider module to handle *all pixmap generation
 	* User documentation
 
 
@@ -1149,7 +1151,7 @@
 	* Resource system back in
 	* AL init threaded off
 	* Switched order of AL and GL inits 
-   	  ( so you can have in game progess loader for loading )
+	  ( so you can have in game progess loader for loading )
 
 
  OpenRaider (0.0.3-20010526) Mongoose <mongoose@users.sourceforge.net>
@@ -1188,7 +1190,7 @@
 	* TR4 texture fixes ported from gegg
 	* Fixed segfault on texture handling
 	* Removed splash screen code completely
-   	  ( Will later use loader screens just like TR )
+	  ( Will later use loader screens just like TR )
 
 
  OpenRaider (0.0.2-20010522) Mongoose <mongoose@users.sourceforge.net>

include/Camera.h

@@ -60,7 +60,7 @@ enum camera_command                /* Interactive camera control */
 
 enum CameraFlags
 {
-	Camera_FlyMode = 1
+    Camera_FlyMode = 1
 };
 
 
@@ -68,206 +68,206 @@ class Camera
 {
  public:
 
-	////////////////////////////////////////////////////////////
-	// Constructors
-	////////////////////////////////////////////////////////////
-
-	Camera();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Constructs an object of Camera
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.05.18:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	~Camera();
-	/*------------------------------------------------------
-	 * Pre  : Camera object is allocated
-	 * Post : Deconstructs an object of Camera
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.05.18:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-
-	////////////////////////////////////////////////////////////
-	// Public Accessors
-	////////////////////////////////////////////////////////////
-
-	unsigned int getId();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Returns this camera's id
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.05.18:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void getPosition(vec3_t pos);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Returns current position
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.06.16:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void getUp(vec3_t up);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Returns up vector
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.05.18:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void getTarget(vec3_t target);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Returns target ( look at pos )
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.05.18:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	float getYaw();
-	/*------------------------------------------------------
-	 * Pre  : Get current yaw in degrees
-	 * Post :
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.06.22:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	double getRadianYaw();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Returns theta angle/yaw of camera
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.05.26:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	float getPitch();
-	/*------------------------------------------------------
-	 * Pre  : Get current pitch in degrees
-	 * Post :
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.06.22:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	double getRadianPitch();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Returns phi angle/pitch of camera
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.05.26:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	bool isBehind(int x, int z);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Returns true if (x, z) is behind camera eye
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.05.26:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-
-	////////////////////////////////////////////////////////////
-	// Public Mutators
-	////////////////////////////////////////////////////////////
-
-	void rotate(float angle, float x, float y, float z);
-	/*------------------------------------------------------
-	 * Pre  : x,y,z axis; angle in radians
-	 * Post : Rotates camera
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.06.04:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void translate(float x, float y, float z);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Camera position is set to x,y,z
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.05.18:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void reset();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Camera is set to inital state
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.05.18:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void setSensitivityX(float angle);
-	/*------------------------------------------------------
-	 * Pre  : angle is theta's rotation delta in degrees
-	 * Post : Sets rotation delta
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.06.04:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void setSensitivityY(float angle);
-	/*------------------------------------------------------
-	 * Pre  : angle is theta's rotation delta in degrees
-	 * Post : Sets rotation delta
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.06.04:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void command(enum camera_command cmd);
-	/*------------------------------------------------------
-	 * Pre  : Command is valid camera command
-	 * Post : Sends interactive command to camera
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.05.18:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
+    ////////////////////////////////////////////////////////////
+    // Constructors
+    ////////////////////////////////////////////////////////////
+
+    Camera();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Constructs an object of Camera
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.05.18:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    ~Camera();
+    /*------------------------------------------------------
+     * Pre  : Camera object is allocated
+     * Post : Deconstructs an object of Camera
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.05.18:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+
+    ////////////////////////////////////////////////////////////
+    // Public Accessors
+    ////////////////////////////////////////////////////////////
+
+    unsigned int getId();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Returns this camera's id
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.05.18:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void getPosition(vec3_t pos);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Returns current position
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.06.16:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void getUp(vec3_t up);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Returns up vector
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.05.18:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void getTarget(vec3_t target);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Returns target ( look at pos )
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.05.18:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    float getYaw();
+    /*------------------------------------------------------
+     * Pre  : Get current yaw in degrees
+     * Post :
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.06.22:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    double getRadianYaw();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Returns theta angle/yaw of camera
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.05.26:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    float getPitch();
+    /*------------------------------------------------------
+     * Pre  : Get current pitch in degrees
+     * Post :
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.06.22:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    double getRadianPitch();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Returns phi angle/pitch of camera
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.05.26:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    bool isBehind(int x, int z);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Returns true if (x, z) is behind camera eye
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.05.26:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+
+    ////////////////////////////////////////////////////////////
+    // Public Mutators
+    ////////////////////////////////////////////////////////////
+
+    void rotate(float angle, float x, float y, float z);
+    /*------------------------------------------------------
+     * Pre  : x,y,z axis; angle in radians
+     * Post : Rotates camera
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.06.04:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void translate(float x, float y, float z);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Camera position is set to x,y,z
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.05.18:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void reset();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Camera is set to inital state
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.05.18:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void setSensitivityX(float angle);
+    /*------------------------------------------------------
+     * Pre  : angle is theta's rotation delta in degrees
+     * Post : Sets rotation delta
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.06.04:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void setSensitivityY(float angle);
+    /*------------------------------------------------------
+     * Pre  : angle is theta's rotation delta in degrees
+     * Post : Sets rotation delta
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.06.04:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void command(enum camera_command cmd);
+    /*------------------------------------------------------
+     * Pre  : Command is valid camera command
+     * Post : Sends interactive command to camera
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.05.18:
+     * Mongoose - Created
+     ------------------------------------------------------*/
 
    void setSpeed(float s);
    /*------------------------------------------------------
@@ -280,91 +280,91 @@ class Camera
     * Mongoose - Created
     ------------------------------------------------------*/
 
-	void update();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Updates view target
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.05.18:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void setPosition(vec3_t pos);
-	/*------------------------------------------------------
-	 * Pre  : Set current position
-	 * Post :
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.06.16:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void setUp(vec3_t up);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Sets up vector
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.05.18:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void setTarget(vec3_t target);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Sets target ( look at pos )
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.05.18:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
+    void update();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Updates view target
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.05.18:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void setPosition(vec3_t pos);
+    /*------------------------------------------------------
+     * Pre  : Set current position
+     * Post :
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.06.16:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void setUp(vec3_t up);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Sets up vector
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.05.18:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void setTarget(vec3_t target);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Sets target ( look at pos )
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.05.18:
+     * Mongoose - Created
+     ------------------------------------------------------*/
 
 
  private:
 
-	////////////////////////////////////////////////////////////
-	// Private Accessors
-	////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////
+    // Private Accessors
+    ////////////////////////////////////////////////////////////
 
 
-	////////////////////////////////////////////////////////////
-	// Private Mutators
-	////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////
+    // Private Mutators
+    ////////////////////////////////////////////////////////////
 
-	unsigned int mId;           /* Unquie id */
+    unsigned int mId;           /* Unquie id */
 
-	Quaternion mQ;              /* Quaternion for rotation */
+    Quaternion mQ;              /* Quaternion for rotation */
 
-	unsigned int mFlags;        /* For testing with flags  */
+    unsigned int mFlags;        /* For testing with flags  */
 
-	double mPos[4];             /* Location in 3 space (aka eye) */
+    double mPos[4];             /* Location in 3 space (aka eye) */
 
-	double mTarget[4];          /* Postition we're looking at  */
+    double mTarget[4];          /* Postition we're looking at  */
 
-	double mUp[4];              /* Up vector  */
+    double mUp[4];              /* Up vector  */
 
-	double mSide[4];            /* Side vector  */
+    double mSide[4];            /* Side vector  */
 
-	double mViewDistance;      /* Distance from target */
+    double mViewDistance;      /* Distance from target */
 
-	double mTranslateDelta;    /* Step size to move */
+    double mTranslateDelta;    /* Step size to move */
 
-	double mRotateDelta;       /* Radians to rotate  Y */
+    double mRotateDelta;       /* Radians to rotate  Y */
 
-	double mTheta;              /* View angle  Y */
+    double mTheta;              /* View angle  Y */
 
-	double mRotateDelta2;      /* Radians to rotate  Z */
+    double mRotateDelta2;      /* Radians to rotate  Z */
 
-	double mTheta2;             /* View angle  Z */
+    double mTheta2;             /* View angle  Z */
 
-	bool mUpdate;               /* Check to see if view needs updating */
+    bool mUpdate;               /* Check to see if view needs updating */
 
-	static unsigned int mCounter;   /* Id system use */
+    static unsigned int mCounter;   /* Id system use */
 };
 
 #endif

include/Emitter.h

@@ -33,18 +33,18 @@ class Emitter
 {
  public:
 
-	typedef enum
-	{
-		fUseFrustumCulling = 1,
-		fUseDepthSorting = 2
-	} EmitterFlags;
+    typedef enum
+    {
+        fUseFrustumCulling = 1,
+        fUseDepthSorting = 2
+    } EmitterFlags;
 
 
   Emitter(const char *name, int n);
   /*------------------------------------------------------
    * Pre  : name is a valid C string
-	*        n is a number greater than 0
-	*
+    *        n is a number greater than 0
+    *
    * Post : Constructs an object of Emitter
    *
    *-- History ------------------------------------------
@@ -108,7 +108,7 @@ class Emitter
    * Mongoose - Created
    ------------------------------------------------------*/
 
-	void Orientation(float x, float y, float z);
+    void Orientation(float x, float y, float z);
   /*------------------------------------------------------
    * Pre  : x,y,z exist
    * Post : Sets orientation of emitter in 3 space
@@ -119,7 +119,7 @@ class Emitter
    * Mongoose - Created
    ------------------------------------------------------*/
 
-	void Orientation(float *x, float *y, float *z);
+    void Orientation(float *x, float *y, float *z);
   /*------------------------------------------------------
    * Pre  : x,y,z exist
    * Post : Returns orientation of emitter in 3 space
@@ -146,9 +146,9 @@ class Emitter
   /*------------------------------------------------------
    * Pre  :
    * Post : Set and Unset flag with op
-	*
-	*          true - set
-	*          flase - unset
+    *
+    *          true - set
+    *          flase - unset
    *
    *-- History ------------------------------------------
    *
@@ -160,9 +160,9 @@ class Emitter
   /*------------------------------------------------------
    * Pre  : n is a number greater than 0
    * Post : Allocates the particle array and sets the count.
-	*        If the array has been allocated previously, then
-	*        the array is deallocated and a new one made.
-	*
+    *        If the array has been allocated previously, then
+    *        the array is deallocated and a new one made.
+    *
    *
    *-- History ------------------------------------------
    *
@@ -204,13 +204,13 @@ class Emitter
    ------------------------------------------------------*/
 
   void TextureId(unsigned int particle_start, unsigned int particle_end,
-					  int id);
+                      int id);
   /*------------------------------------------------------
    * Pre  : particle_start and particle_end are a valid
-	*        range of particles in the array
-	*
-	*        id is a valid texture id
-	*
+    *        range of particles in the array
+    *
+    *        id is a valid texture id
+    *
    * Post :
    *
    *-- History ------------------------------------------
@@ -220,13 +220,13 @@ class Emitter
    ------------------------------------------------------*/
 
   void Color(unsigned int particle_start, unsigned int particle_end,
-				 float r, float g, float b);
+                 float r, float g, float b);
   /*------------------------------------------------------
    * Pre  : particle_start and particle_end are a valid
-	*        range of particles in the array
-	*
-	*        r,g,b are colors 0.0 to 1.0
-	*
+    *        range of particles in the array
+    *
+    *        r,g,b are colors 0.0 to 1.0
+    *
    * Post :
    *
    *-- History ------------------------------------------
@@ -236,13 +236,13 @@ class Emitter
    ------------------------------------------------------*/
 
   void Speed(unsigned int particle_start, unsigned int particle_end,
-				 float x, float y, float z);
+                 float x, float y, float z);
   /*------------------------------------------------------
    * Pre  : particle_start and particle_end are a valid
-	*        range of particles in the array
-	*
-	*        take note speed inits at 2000, lower is faster
-	*
+    *        range of particles in the array
+    *
+    *        take note speed inits at 2000, lower is faster
+    *
    * Post :
    *
    *-- History ------------------------------------------
@@ -252,13 +252,13 @@ class Emitter
    ------------------------------------------------------*/
 
   void Force(unsigned int particle_start, unsigned int particle_end,
-				 float x, float y, float z);
+                 float x, float y, float z);
   /*------------------------------------------------------
    * Pre  : particle_start and particle_end are a valid
-	*        range of particles in the array
-	*
-	*        Force/Gravity acting on particles
-	*
+    *        range of particles in the array
+    *
+    *        Force/Gravity acting on particles
+    *
    * Post :
    *
    *-- History ------------------------------------------
@@ -268,7 +268,7 @@ class Emitter
    ------------------------------------------------------*/
 
 
-	static vec_t mFrustum[6][4]; /* View Volume copy */
+    static vec_t mFrustum[6][4]; /* View Volume copy */
 
 
  private:
@@ -276,17 +276,17 @@ class Emitter
     static int compareParticleDist(const void *voidA, const void *voidB);
 
 
-	char *_name;              /* Emitter name */
+    char *_name;              /* Emitter name */
 
-	unsigned int _flags;      /* Emitter flags */
+    unsigned int _flags;      /* Emitter flags */
 
-	vec3_t _pos;              /* Position in 3 space */
+    vec3_t _pos;              /* Position in 3 space */
 
-	vec3_t _mangle;           /* Oreintation in 3 space */
+    vec3_t _mangle;           /* Oreintation in 3 space */
 
-	Particle *_particle;      /* Array of particles */
+    Particle *_particle;      /* Array of particles */
 
-	unsigned int _count;      /* Particle count */
+    unsigned int _count;      /* Particle count */
 };
 
 #endif

include/List.h

@@ -149,8 +149,8 @@ template <class T> class List
       // Found
       if (current->Id() == id)
       {
-	_cache = current;
-	return current->Data();
+    _cache = current;
+    return current->Data();
       }
 
       last = current;
@@ -178,8 +178,8 @@ template <class T> class List
       // Found
       if (current->Data() == data)
       {
-	_cache = current;
-	return current->Id();
+    _cache = current;
+    return current->Id();
       }
 
       last = current;
@@ -219,20 +219,20 @@ template <class T> class List
       // Remove
       if (current->Id() == id)
       {
-	if (current == _head)
-	  _head = current->Next();
-	else
-	{
-	  last->Next(current->Next());
-	}
+    if (current == _head)
+      _head = current->Next();
+    else
+    {
+      last->Next(current->Next());
+    }
 
-	if (_current == current)
-	  _current = NULL;
+    if (_current == current)
+      _current = NULL;
 
-	delete current;
-	_num_items--;
+    delete current;
+    _num_items--;
 
-	return;
+    return;
       }
 
       last = current;
@@ -253,20 +253,20 @@ template <class T> class List
       // Remove
       if (current->Data() == data)
       {
-	if (current == _head)
-	  _head = current->Next();
-	else
-	{
-	  last->Next(current->Next());
-	}
+    if (current == _head)
+      _head = current->Next();
+    else
+    {
+      last->Next(current->Next());
+    }
 
-	if (_current == current)
-	  _current = NULL;
+    if (_current == current)
+      _current = NULL;
 
-	delete current;
-	_num_items--;
+    delete current;
+    _num_items--;
 
-	return;
+    return;
       }
 
       last = current;
@@ -323,7 +323,7 @@ template <class T> class List
       current = current->Next();
 
       if (current)
-	printf(", ");
+    printf(", ");
 
       fflush(stdout);
     }
@@ -401,29 +401,29 @@ template <class T> class List
       //EXP
       if (_last)
       {
-	i = _last->Id();
-	current = _last;
+    i = _last->Id();
+    current = _last;
       }
 
       while (current)
       {
-	// Prepend
-	if (current->Id() > i)
-	{
-	  node->Id(i);
-	  node->Next(current);
-
-	  if (current == _head)
-	    _head = node;
-	  else if (last)
-	    last->Next(node);
-
-	  return node->Id();
-	}
-
-	i++;
-	last = current;
-	current = current->Next();
+    // Prepend
+    if (current->Id() > i)
+    {
+      node->Id(i);
+      node->Next(current);
+
+      if (current == _head)
+        _head = node;
+      else if (last)
+        last->Next(node);
+
+      return node->Id();
+    }
+
+    i++;
+    last = current;
+    current = current->Next();
       }
 
       // Append

include/Map.h

@@ -51,61 +51,61 @@ template <class K, class D> class MapNode
 {
 public:
 
-	MapNode(K key, D data)
-	{
-		_data  = data;
-		_key = key;
-		_next = NULL;
-	}
+    MapNode(K key, D data)
+    {
+        _data  = data;
+        _key = key;
+        _next = NULL;
+    }
 
 
-	~MapNode()
-	{
-	}
+    ~MapNode()
+    {
+    }
 
 
-	void Key(K key)
-	{
-		_key = key;
-	}
+    void Key(K key)
+    {
+        _key = key;
+    }
 
 
-	K Key()
-	{
-		return _key;
-	}
+    K Key()
+    {
+        return _key;
+    }
 
 
-	void Data(D data)
-	{
+    void Data(D data)
+    {
     _data = data;
-	}
+    }
 
 
-	D Data()
-	{
-		return _data;
-	}
+    D Data()
+    {
+        return _data;
+    }
 
 
-	MapNode<K, D> *Next()
-	{
-		return _next;
-	}
+    MapNode<K, D> *Next()
+    {
+        return _next;
+    }
 
 
-	void Next(MapNode<K, D> *next)
-	{
-		_next = next;
-	}
+    void Next(MapNode<K, D> *next)
+    {
+        _next = next;
+    }
 
 private:
 
-	MapNode<K, D> *_next;
+    MapNode<K, D> *_next;
 
-	K _key;
+    K _key;
 
-	D _data;
+    D _data;
 };
 
 
@@ -113,458 +113,458 @@ template <class K, class D> class Map
 {
 public:
 
-	Map()
-	{
-		UnSetError();
-		_num_items = 0;
-		_head = NULL;
-		_current = NULL;
-		_cache = NULL;
-	}
+    Map()
+    {
+        UnSetError();
+        _num_items = 0;
+        _head = NULL;
+        _current = NULL;
+        _cache = NULL;
+    }
 
 
-	~Map()
-	{
-		Clear();
-	}
+    ~Map()
+    {
+        Clear();
+    }
 
 
-	void Clear()
-	{
-		UnSetError();
-		_num_items = 0;
-		_cache = NULL;
+    void Clear()
+    {
+        UnSetError();
+        _num_items = 0;
+        _cache = NULL;
 
-		while (_head)
-		{
-			_current = _head;
-			_head = _head->Next();
-			delete _current;
-		}
+        while (_head)
+        {
+            _current = _head;
+            _head = _head->Next();
+            delete _current;
+        }
 
-		_tree.Clear();
-	}
+        _tree.Clear();
+    }
 
 
-	void SetError()
-	{
-		_error = true;
-	}
+    void SetError()
+    {
+        _error = true;
+    }
 
 
-	void UnSetError()
-	{
-		_error = false;
-	}
+    void UnSetError()
+    {
+        _error = false;
+    }
 
 
-	bool GetError()
-	{
-		return _error;
-	}
+    bool GetError()
+    {
+        return _error;
+    }
 
 
-	D FindDataByKey(K key)
-	{
-		MapNode<K, D> *current = NULL;
-		MapNode<K, D> *next = NULL;
+    D FindDataByKey(K key)
+    {
+        MapNode<K, D> *current = NULL;
+        MapNode<K, D> *next = NULL;
 
 
-		if (_head)
-		{
-			UnSetError();
+        if (_head)
+        {
+            UnSetError();
 
-			if (_cache)
-			{
-				next = _cache->Next();
-			}
+            if (_cache)
+            {
+                next = _cache->Next();
+            }
 
-			// Mongoose 2002.02.19, Optimize for sequential searches
-			if (next && key == next->Key())
-			{
-				current = next;
-			}
-			else // Mongoose 2002.02.19, Use search algorithm otherwise
-			{
-				current = _tree.SearchByKey(key, &_error);
-
-				if (_error)
-					return false;
-			}
+            // Mongoose 2002.02.19, Optimize for sequential searches
+            if (next && key == next->Key())
+            {
+                current = next;
+            }
+            else // Mongoose 2002.02.19, Use search algorithm otherwise
+            {
+                current = _tree.SearchByKey(key, &_error);
+
+                if (_error)
+                    return false;
+            }
 
-			if (current)
-			{
-				_cache = _current = current;
-				return current->Data();
-			}
-		}
+            if (current)
+            {
+                _cache = _current = current;
+                return current->Data();
+            }
+        }
 
-		SetError();
-		return 0;
-	}
+        SetError();
+        return 0;
+    }
 
 
-	D operator [] (K key)
-	{
-		return FindDataByKey(key);
-	}
+    D operator [] (K key)
+    {
+        return FindDataByKey(key);
+    }
 
 
-	K FindKeyByData(D data)
-	{
-		MapNode<K, D> *current = _head;
-		MapNode<K, D> *last = NULL;
+    K FindKeyByData(D data)
+    {
+        MapNode<K, D> *current = _head;
+        MapNode<K, D> *last = NULL;
 
 
-		UnSetError();
+        UnSetError();
 
-		while (current)
-		{
-			// Found
-			if (current->Data() == data)
-			{
-				_cache = current;
-				return current->Key();
-			}
+        while (current)
+        {
+            // Found
+            if (current->Data() == data)
+            {
+                _cache = current;
+                return current->Key();
+            }
 
-			last = current;
-			current = current->Next();
-		}
+            last = current;
+            current = current->Next();
+        }
 
-		SetError();
+        SetError();
 
-		return 0;
-	}
+        return 0;
+    }
 
 
-	D getCache()
-	{
-		if (_cache == 0x0)
-		{
-			printf("Map::getCache> Bad request - should segfault\n");
-		}
+    D getCache()
+    {
+        if (_cache == 0x0)
+        {
+            printf("Map::getCache> Bad request - should segfault\n");
+        }
 
-		return _cache->Data();
-	}
-
-
-	bool findKey(K key)
-	{
-		MapNode<K, D> *current = NULL;
-		MapNode<K, D> *next = NULL;
-
-		if (_head)
-		{
-			UnSetError();
+        return _cache->Data();
+    }
+
+
+    bool findKey(K key)
+    {
+        MapNode<K, D> *current = NULL;
+        MapNode<K, D> *next = NULL;
+
+        if (_head)
+        {
+            UnSetError();
 
-			if (_cache)
-			{
-				if (_cache->Key() == key)
-				{
-					return true;
-				}
+            if (_cache)
+            {
+                if (_cache->Key() == key)
+                {
+                    return true;
+                }
 
-				next = _cache->Next();
-			}
+                next = _cache->Next();
+            }
 
-			// Mongoose 2002.02.19, Optimize for sequential searches
-			if (next && key == next->Key())
-			{
-				current = next;
-			}
-			else // Mongoose 2002.02.19, Use search algorithm otherwise
-			{
-				current = _tree.SearchByKey(key, &_error);
-			}
-
-			if (current)
-			{
-				_cache = _current = current;
-				//curData = current->Data();
-				return true;
-			}
-		}
-
-		SetError();
-		return false;
-	}
-
-
-	bool Add(K key, D data)
-	{
-		MapNode<K, D> *node;
-
-
-		UnSetError();
-		node = new MapNode<K, D>(key, data);
-		_num_items++;
-		return Add(node);
-	}
+            // Mongoose 2002.02.19, Optimize for sequential searches
+            if (next && key == next->Key())
+            {
+                current = next;
+            }
+            else // Mongoose 2002.02.19, Use search algorithm otherwise
+            {
+                current = _tree.SearchByKey(key, &_error);
+            }
+
+            if (current)
+            {
+                _cache = _current = current;
+                //curData = current->Data();
+                return true;
+            }
+        }
+
+        SetError();
+        return false;
+    }
+
+
+    bool Add(K key, D data)
+    {
+        MapNode<K, D> *node;
+
+
+        UnSetError();
+        node = new MapNode<K, D>(key, data);
+        _num_items++;
+        return Add(node);
+    }
 
 
-	bool Add(MapNode<K, D> *node)
-	{
-		MapNode<K, D> *current = _head;
-		MapNode<K, D> *last = NULL;
+    bool Add(MapNode<K, D> *node)
+    {
+        MapNode<K, D> *current = _head;
+        MapNode<K, D> *last = NULL;
 
 
-		if (!node)
-			return false;
+        if (!node)
+            return false;
 
-		UnSetError();
+        UnSetError();
 
-		if (_head)
-		{
-			current = _head;
-			last = NULL;
-
-			while (current)
-			{
-				// Prepend
-				if (current->Key() > node->Key())
-				{
-					node->Next(current);
-
-					if (current == _head)
-					{
-						_head = node;
-					}
-					else if (last)
-					{
-						last->Next(node);
-					}
-
-					_tree.Insert(node->Key(), node);
-					return true;
-				}
-
-				last = current;
-				current = current->Next();
-			}
-
-			// Append
-			last->Next(node);
-		}
-		else
-		{
-			_head = node;
-		}
-
-		_tree.Insert(node->Key(), node);
-		return true;
-	}
-
-
-	void RemoveByKey(K key)
-	{
-		MapNode<K, D> *current = _head;
-		MapNode<K, D> *last = NULL;
-
-
-		UnSetError();
-
-		_cache = NULL;
+        if (_head)
+        {
+            current = _head;
+            last = NULL;
+
+            while (current)
+            {
+                // Prepend
+                if (current->Key() > node->Key())
+                {
+                    node->Next(current);
+
+                    if (current == _head)
+                    {
+                        _head = node;
+                    }
+                    else if (last)
+                    {
+                        last->Next(node);
+                    }
+
+                    _tree.Insert(node->Key(), node);
+                    return true;
+                }
+
+                last = current;
+                current = current->Next();
+            }
+
+            // Append
+            last->Next(node);
+        }
+        else
+        {
+            _head = node;
+        }
+
+        _tree.Insert(node->Key(), node);
+        return true;
+    }
+
+
+    void RemoveByKey(K key)
+    {
+        MapNode<K, D> *current = _head;
+        MapNode<K, D> *last = NULL;
+
+
+        UnSetError();
+
+        _cache = NULL;
 
-		while (current)
-		{
-			// Remove
-			if (current->Key() == key)
-			{
-				if (current == _head)
-				{
-					_head = current->Next();
-				}
-				else
-				{
-					last->Next(current->Next());
-				}
+        while (current)
+        {
+            // Remove
+            if (current->Key() == key)
+            {
+                if (current == _head)
+                {
+                    _head = current->Next();
+                }
+                else
+                {
+                    last->Next(current->Next());
+                }
 
-				if (_current == current)
-				{
-					_current = NULL;
-				}
+                if (_current == current)
+                {
+                    _current = NULL;
+                }
 
-				_tree.RemoveByKey(current->Key());
-				delete current;
-				_num_items--;
+                _tree.RemoveByKey(current->Key());
+                delete current;
+                _num_items--;
 
-				return;
-			}
+                return;
+            }
 
-			last = current;
-			current = current->Next();
-		}
+            last = current;
+            current = current->Next();
+        }
 
-		SetError();
-	}
+        SetError();
+    }
 
 
-	void RemoveByData(D data)
-	{
-		MapNode<K, D> *current = _head;
-		MapNode<K, D> *last = NULL;
+    void RemoveByData(D data)
+    {
+        MapNode<K, D> *current = _head;
+        MapNode<K, D> *last = NULL;
 
 
-		UnSetError();
+        UnSetError();
 
-		_cache = NULL;
+        _cache = NULL;
 
-		while (current)
-		{
-			// Remove
-			if (current->Data() == data)
-			{
-				if (current == _head)
-				{
-					_head = current->Next();
-				}
-				else
-				{
-					last->Next(current->Next());
-				}
+        while (current)
+        {
+            // Remove
+            if (current->Data() == data)
+            {
+                if (current == _head)
+                {
+                    _head = current->Next();
+                }
+                else
+                {
+                    last->Next(current->Next());
+                }
 
-				if (_current == current)
-				{
-					_current = NULL;
-				}
+                if (_current == current)
+                {
+                    _current = NULL;
+                }
 
-				_tree.RemoveByKey(current->Key());
-				delete current;
-				_num_items--;
+                _tree.RemoveByKey(current->Key());
+                delete current;
+                _num_items--;
 
-				return;
-			}
+                return;
+            }
 
-			last = current;
-			current = current->Next();
-		}
+            last = current;
+            current = current->Next();
+        }
 
-		SetError();
-	}
+        SetError();
+    }
 
 
-	bool Empty()
-	{
-		return (_head == NULL);
-	}
+    bool Empty()
+    {
+        return (_head == NULL);
+    }
 
 
-	unsigned int count()
-	{
-		return _num_items;
-	}
+    unsigned int count()
+    {
+        return _num_items;
+    }
 
-	unsigned int NumItems()
-	{
-		return _num_items;
-	}
+    unsigned int NumItems()
+    {
+        return _num_items;
+    }
 
 
-	void Print(void (*print_key_func)(K), void (*print_data_func)(D))
-	{
-		MapNode<K, D> *current = _head;
+    void Print(void (*print_key_func)(K), void (*print_data_func)(D))
+    {
+        MapNode<K, D> *current = _head;
 
 
-		UnSetError();
+        UnSetError();
 
-		if (!print_key_func || !print_data_func)
-		{
-			SetError();
-			return;
-		}
+        if (!print_key_func || !print_data_func)
+        {
+            SetError();
+            return;
+        }
 
-		printf(" [%i] {\n", _num_items);
+        printf(" [%i] {\n", _num_items);
 
-		while (current)
-		{
-			printf("(");
-			(*print_key_func)(current->Key());
-			printf(", ");
-			(*print_data_func)(current->Data());
-			printf("), ");
+        while (current)
+        {
+            printf("(");
+            (*print_key_func)(current->Key());
+            printf(", ");
+            (*print_data_func)(current->Data());
+            printf("), ");
 
-			current = current->Next();
-			fflush(stdout);
-		}
+            current = current->Next();
+            fflush(stdout);
+        }
 
-		printf(" }\n");
-	}
+        printf(" }\n");
+    }
 
 
-	void Reset()
-	{
-		_current = _head;
-		_cache = _head;
-	}
+    void Reset()
+    {
+        _current = _head;
+        _cache = _head;
+    }
 
 
-	bool operator ++ (int)
-	{
-		return Next();
-	}
+    bool operator ++ (int)
+    {
+        return Next();
+    }
 
     bool operator ++ ()
-	{
-		return Next();
-	}
+    {
+        return Next();
+    }
 
 
-	bool Next()
-	{
-		if (_current)
-		{
-			_current = _current->Next();
-		}
+    bool Next()
+    {
+        if (_current)
+        {
+            _current = _current->Next();
+        }
 
-		return (_current != NULL);
-	}
+        return (_current != NULL);
+    }
 
 
-	bool CurrentExists()
-	{
-		return (_current != 0);
-	}
+    bool CurrentExists()
+    {
+        return (_current != 0);
+    }
 
 
-	K CurrentKey()
-	{
-		UnSetError();
+    K CurrentKey()
+    {
+        UnSetError();
 
-		if (!_current)
-		{
-			SetError();
-			return 0;
-		}
+        if (!_current)
+        {
+            SetError();
+            return 0;
+        }
 
-		return _current->Key();
-	}
+        return _current->Key();
+    }
 
 
-	D Current()
-	{
-		UnSetError();
+    D Current()
+    {
+        UnSetError();
 
-		if (!_current)
-		{
-			SetError();
-			return 0;
-		}
+        if (!_current)
+        {
+            SetError();
+            return 0;
+        }
 
-		return _current->Data();
-	}
+        return _current->Data();
+    }
 
 private:
 
-	unsigned int _num_items;
+    unsigned int _num_items;
 
-	bool _error;
+    bool _error;
 
-	Tree<K, MapNode<K, D> *> _tree;
+    Tree<K, MapNode<K, D> *> _tree;
 
-	MapNode<K, D> *_head;
+    MapNode<K, D> *_head;
 
-	MapNode<K, D> *_current;
+    MapNode<K, D> *_current;
 
-	MapNode<K, D> *_cache;
+    MapNode<K, D> *_cache;
 };
 #endif

include/MatMath.h

@@ -53,7 +53,7 @@ int helIntersectionLineAndPolygon(vec3_t intersect, vec3_t p1, vec3_t p2, vec3_t
  * \param plane Plane
  * \returns distance
  */
-vec_t helDistToSphereFromPlane3v(vec3_t center,	vec_t radius, vec4_t plane);
+vec_t helDistToSphereFromPlane3v(vec3_t center, vec_t radius, vec4_t plane);
 
 /*!
  * \brief Calculate the distance from a box to a plane

include/Matrix.h

@@ -32,350 +32,350 @@
 #include <Quaternion.h>
 #include <Vector3d.h>
 
-	///////////////////////////////////////////////
-	// Multidim map for row order encoding       //
-	///////////////////////////////////////////////
-	// 0,0 - 0;   0,1 - 1;   0,2 - 2;   0,3 - 3  //
-	// 1,0 - 4;   1,1 - 5;   1,2 - 6;   1,3 - 7  //
-	// 2,0 - 8;   2,1 - 9;   2,2 - 10;  2,3 - 11 //
-	// 3,0 - 12;  3,1 - 13;  3,2 - 14;  3,3 - 15 //
-	///////////////////////////////////////////////
-
-	///////////////////////////////////////////////
-	// Multidim map for column order encoding    //
-	///////////////////////////////////////////////
-	// 0,0 - 0;   0,1 - 4;   0,2 - 8;   0,3 - 12 //
-	// 1,0 - 1;   1,1 - 5;   1,2 - 9;   1,3 - 13 //
-	// 2,0 - 2;   2,1 - 6;   2,2 - 10;  2,3 - 14 //
-	// 3,0 - 3;   3,1 - 7;   3,2 - 11;  3,3 - 15 //
-	///////////////////////////////////////////////
+    ///////////////////////////////////////////////
+    // Multidim map for row order encoding       //
+    ///////////////////////////////////////////////
+    // 0,0 - 0;   0,1 - 1;   0,2 - 2;   0,3 - 3  //
+    // 1,0 - 4;   1,1 - 5;   1,2 - 6;   1,3 - 7  //
+    // 2,0 - 8;   2,1 - 9;   2,2 - 10;  2,3 - 11 //
+    // 3,0 - 12;  3,1 - 13;  3,2 - 14;  3,3 - 15 //
+    ///////////////////////////////////////////////
+
+    ///////////////////////////////////////////////
+    // Multidim map for column order encoding    //
+    ///////////////////////////////////////////////
+    // 0,0 - 0;   0,1 - 4;   0,2 - 8;   0,3 - 12 //
+    // 1,0 - 1;   1,1 - 5;   1,2 - 9;   1,3 - 13 //
+    // 2,0 - 2;   2,1 - 6;   2,2 - 10;  2,3 - 14 //
+    // 3,0 - 3;   3,1 - 7;   3,2 - 11;  3,3 - 15 //
+    ///////////////////////////////////////////////
 
 
 class Matrix
 {
  public:
 
-	////////////////////////////////////////////////////////////
-	// Constructors
-	////////////////////////////////////////////////////////////
-
-	Matrix();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Constructs an object of Matrix
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.11:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	Matrix(matrix_t mat);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Constructs an object of Matrix
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.11:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	Matrix(Quaternion &q);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Converts and asigns Q to a Matrix
-	 *        returns quaternion as Matrix
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	~Matrix();
-	/*------------------------------------------------------
-	 * Pre  : Matrix object is allocated
-	 * Post : Deconstructs an object of Matrix
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.11:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	////////////////////////////////////////////////////////////
-	// Public Accessors
-	////////////////////////////////////////////////////////////
-
-	void getMatrix(matrix_t mat);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Returns this matrix copy
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void getTransposeMatrix(matrix_t mat);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Returns this matrix transposed
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	bool getInvert(matrix_t mat);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Returns this matrix inverted
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	Matrix multiply(const Matrix &a, const Matrix &b);
-	/*------------------------------------------------------
-	 * Pre  : Multiplies 2 matrices
-	 * Post : Returns resultant matrix
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void multiply4d(double *v, double *result);
-	/*------------------------------------------------------
-	 * Pre  : Multiplies <V> vector (double[4]) and <This> matrix
-	 *
-	 * Post : Returns <Result> vector,
-	 *        <V> and <Result> maybe be the same vector
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void multiply4v(vec4_t v, vec4_t result);
-	/*------------------------------------------------------
-	 * Pre  : Multiplies <V> vector and <This> matrix
-	 *
-	 * Post : Returns <Result> vector,
-	 *        <V> and <Result> maybe be the same vector
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void multiply3v(vec3_t v, vec3_t result);
-	/*------------------------------------------------------
-	 * Pre  : Multiplies <V> vector and <This> matrix
-	 *
-	 * Post : Returns <Result> vector,
-	 *        <V> and <Result> maybe be the same vector
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void print();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Prints matrix values to stdout
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	bool isIdentity();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Is this matrix the identity matrix?
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	Matrix operator *(const Matrix &a);
-	/*------------------------------------------------------
-	 * Pre  : Multiplies A and this matrices
-	 * Post : Returns resultant matrix
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	Vector3d operator *(Vector3d v);
-	/*------------------------------------------------------
-	 * Pre  : <V> is vector to multiply by this matrix
-	 * Post : Returns resultant vector ( mult )
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-
-	////////////////////////////////////////////////////////////
-	// Public Mutators
-	////////////////////////////////////////////////////////////
-
-	void setIdentity();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Sets to identity matrix
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void setMatrix(matrix_t mat);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Set the matrix ( dangerous, scary boo )
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void rotate(vec_t x, vec_t y, vec_t z);
-	/*------------------------------------------------------
-	 * Pre  : Radian input
-	 * Post : Rotates object in 3 space
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void rotate(const vec_t *xyz);
-	/*------------------------------------------------------
-	 * Pre  : Rotates object in 3 space, Radian input
-	 * Post : Returns true on sucess
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void scale(vec_t x, vec_t y, vec_t z);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Scales object in 3 space
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void scale(const vec_t *xyz);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Scales object in 3 space
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void translate(vec_t x, vec_t y, vec_t z);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Translates ( moves ) object in 3 space
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void translate(const vec_t *xyz);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Translates ( moves ) object in 3 space
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void transpose();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Transpose this matrix
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	matrix_t mMatrix;      /* Data model, moved public for faster
-									  external renderer feedback use */
+    ////////////////////////////////////////////////////////////
+    // Constructors
+    ////////////////////////////////////////////////////////////
+
+    Matrix();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Constructs an object of Matrix
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.11:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    Matrix(matrix_t mat);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Constructs an object of Matrix
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.11:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    Matrix(Quaternion &q);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Converts and asigns Q to a Matrix
+     *        returns quaternion as Matrix
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    ~Matrix();
+    /*------------------------------------------------------
+     * Pre  : Matrix object is allocated
+     * Post : Deconstructs an object of Matrix
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.11:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    ////////////////////////////////////////////////////////////
+    // Public Accessors
+    ////////////////////////////////////////////////////////////
+
+    void getMatrix(matrix_t mat);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Returns this matrix copy
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void getTransposeMatrix(matrix_t mat);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Returns this matrix transposed
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    bool getInvert(matrix_t mat);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Returns this matrix inverted
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    Matrix multiply(const Matrix &a, const Matrix &b);
+    /*------------------------------------------------------
+     * Pre  : Multiplies 2 matrices
+     * Post : Returns resultant matrix
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void multiply4d(double *v, double *result);
+    /*------------------------------------------------------
+     * Pre  : Multiplies <V> vector (double[4]) and <This> matrix
+     *
+     * Post : Returns <Result> vector,
+     *        <V> and <Result> maybe be the same vector
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void multiply4v(vec4_t v, vec4_t result);
+    /*------------------------------------------------------
+     * Pre  : Multiplies <V> vector and <This> matrix
+     *
+     * Post : Returns <Result> vector,
+     *        <V> and <Result> maybe be the same vector
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void multiply3v(vec3_t v, vec3_t result);
+    /*------------------------------------------------------
+     * Pre  : Multiplies <V> vector and <This> matrix
+     *
+     * Post : Returns <Result> vector,
+     *        <V> and <Result> maybe be the same vector
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void print();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Prints matrix values to stdout
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    bool isIdentity();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Is this matrix the identity matrix?
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    Matrix operator *(const Matrix &a);
+    /*------------------------------------------------------
+     * Pre  : Multiplies A and this matrices
+     * Post : Returns resultant matrix
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    Vector3d operator *(Vector3d v);
+    /*------------------------------------------------------
+     * Pre  : <V> is vector to multiply by this matrix
+     * Post : Returns resultant vector ( mult )
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+
+    ////////////////////////////////////////////////////////////
+    // Public Mutators
+    ////////////////////////////////////////////////////////////
+
+    void setIdentity();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Sets to identity matrix
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void setMatrix(matrix_t mat);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Set the matrix ( dangerous, scary boo )
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void rotate(vec_t x, vec_t y, vec_t z);
+    /*------------------------------------------------------
+     * Pre  : Radian input
+     * Post : Rotates object in 3 space
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void rotate(const vec_t *xyz);
+    /*------------------------------------------------------
+     * Pre  : Rotates object in 3 space, Radian input
+     * Post : Returns true on sucess
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void scale(vec_t x, vec_t y, vec_t z);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Scales object in 3 space
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void scale(const vec_t *xyz);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Scales object in 3 space
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void translate(vec_t x, vec_t y, vec_t z);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Translates ( moves ) object in 3 space
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void translate(const vec_t *xyz);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Translates ( moves ) object in 3 space
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void transpose();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Transpose this matrix
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    matrix_t mMatrix;      /* Data model, moved public for faster
+                                      external renderer feedback use */
 
  private:
 
-	////////////////////////////////////////////////////////////
-	// Private Accessors
-	////////////////////////////////////////////////////////////
-
-
-	////////////////////////////////////////////////////////////
-	// Private Mutators
-	////////////////////////////////////////////////////////////
-
-	void copy(matrix_t source, matrix_t dest);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Copys value of source to dest
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void multiply(const matrix_t a, const matrix_t b, matrix_t result);
-	/*------------------------------------------------------
-	 * Pre  : Multiplies matrices a and b
-	 *        Neither a or b is also the result
-	 *
-	 * Post : Sets resultant matrix value ( result )
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
+    ////////////////////////////////////////////////////////////
+    // Private Accessors
+    ////////////////////////////////////////////////////////////
+
+
+    ////////////////////////////////////////////////////////////
+    // Private Mutators
+    ////////////////////////////////////////////////////////////
+
+    void copy(matrix_t source, matrix_t dest);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Copys value of source to dest
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void multiply(const matrix_t a, const matrix_t b, matrix_t result);
+    /*------------------------------------------------------
+     * Pre  : Multiplies matrices a and b
+     *        Neither a or b is also the result
+     *
+     * Post : Sets resultant matrix value ( result )
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
 };
 
 #endif

include/Network.h

@@ -31,18 +31,18 @@
  ---------------------------------------------*/
 typedef struct network_packet_s
 {
-	char send;
-	unsigned int port;
-	unsigned int cid;
-	char  data[32];
-	float pos[3];
-	float pitch;
-	float yaw;
-	int aframe;
-	int bframe;
-	int view_model;
-
-	char gurantee; // TCP like
+    char send;
+    unsigned int port;
+    unsigned int cid;
+    char  data[32];
+    float pos[3];
+    float pitch;
+    float yaw;
+    int aframe;
+    int bframe;
+    int view_model;
+
+    char gurantee; // TCP like
 
 } network_packet_t;
 
@@ -57,11 +57,11 @@ typedef struct network_packet_s
  ---------------------------------------------*/
 typedef struct network_frame_s
 {
-	unsigned int header;
-	unsigned int seq;
-	unsigned int uid;
+    unsigned int header;
+    unsigned int seq;
+    unsigned int uid;
 
-	network_packet_t data;
+    network_packet_t data;
 
 } network_frame_t;
 
@@ -80,250 +80,250 @@ class Network
 {
  public:
 
-	////////////////////////////////////////////////////////////
-	// Constructors ( Singleton )
-	////////////////////////////////////////////////////////////
-
-	static Network *Instance();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Constructs the object of Network or
-	 *        returns pointer to it if previously allocated
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.08.24:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	~Network();
-	/*------------------------------------------------------
-	 * Pre  : Network object is allocated
-	 * Post : Deconstructs an object of Network
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.06.21:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	////////////////////////////////////////////////////////////
-	// Public Accessors
-	////////////////////////////////////////////////////////////
-
-	network_frame_t &getPiggyBack();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post :
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.09.03:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	unsigned int getUID();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post :
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.09.03:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	float getRandom(float from, float to);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post :
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.09.03:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	int getPort();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post :
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.09.03:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	////////////////////////////////////////////////////////////
-	// Public Mutators
-	////////////////////////////////////////////////////////////
-
-	void setDebug(bool toggle);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post :
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.15:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void setPort(unsigned int port);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post :
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.09.03:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void setBindHost(char *s);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post :
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.09.10:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void setRemoteHost(char *s);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post :
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.09.03:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void killServerThread();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post :
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.09.03:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void killClientThread();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post :
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.09.03:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void spawnServerThread();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post :
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.09.03:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void spawnClientThread();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post :
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.09.03:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	int runServer();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post :
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.09.03:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void runClient();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post :
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.09.03:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
+    ////////////////////////////////////////////////////////////
+    // Constructors ( Singleton )
+    ////////////////////////////////////////////////////////////
+
+    static Network *Instance();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Constructs the object of Network or
+     *        returns pointer to it if previously allocated
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.08.24:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    ~Network();
+    /*------------------------------------------------------
+     * Pre  : Network object is allocated
+     * Post : Deconstructs an object of Network
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.06.21:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    ////////////////////////////////////////////////////////////
+    // Public Accessors
+    ////////////////////////////////////////////////////////////
+
+    network_frame_t &getPiggyBack();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post :
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.09.03:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    unsigned int getUID();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post :
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.09.03:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    float getRandom(float from, float to);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post :
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.09.03:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    int getPort();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post :
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.09.03:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    ////////////////////////////////////////////////////////////
+    // Public Mutators
+    ////////////////////////////////////////////////////////////
+
+    void setDebug(bool toggle);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post :
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.15:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void setPort(unsigned int port);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post :
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.09.03:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void setBindHost(char *s);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post :
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.09.10:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void setRemoteHost(char *s);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post :
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.09.03:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void killServerThread();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post :
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.09.03:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void killClientThread();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post :
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.09.03:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void spawnServerThread();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post :
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.09.03:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void spawnClientThread();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post :
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.09.03:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    int runServer();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post :
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.09.03:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void runClient();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post :
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.09.03:
+     * Mongoose - Created
+     ------------------------------------------------------*/
 
  protected:
 
-	////////////////////////////////////////////////////////////
-	// Constructors ( Singleton )
-	////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////
+    // Constructors ( Singleton )
+    ////////////////////////////////////////////////////////////
 
-	Network();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Constructs an object of Network
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.06.21:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
+    Network();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Constructs an object of Network
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.06.21:
+     * Mongoose - Created
+     ------------------------------------------------------*/
 
 
-	////////////////////////////////////////////////////////////
-	// Protected Mutators
-	////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////
+    // Protected Mutators
+    ////////////////////////////////////////////////////////////
 
  private:
 
-	////////////////////////////////////////////////////////////
-	// Private Accessors
-	////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////
+    // Private Accessors
+    ////////////////////////////////////////////////////////////
 
 
-	////////////////////////////////////////////////////////////
-	// Private Mutators
-	////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////
+    // Private Mutators
+    ////////////////////////////////////////////////////////////
 
 
-	static Network *mInstance;      /* Singleton use */
+    static Network *mInstance;      /* Singleton use */
 
-	bool mSpawnedClient;
+    bool mSpawnedClient;
 
-	bool mSpawnedServer;
+    bool mSpawnedServer;
 
-	int mPort;
+    int mPort;
 
-	char mRemoteHost[REMOTE_HOST_STR_SZ];
+    char mRemoteHost[REMOTE_HOST_STR_SZ];
 
-	char mBindHost[BIND_HOST_STR_SZ];
+    char mBindHost[BIND_HOST_STR_SZ];
 
-	bool mPiggyBack;
+    bool mPiggyBack;
 
-	bool mNetworkReliable;
+    bool mNetworkReliable;
 
-	bool mKillClient;
+    bool mKillClient;
 
-	bool mKillServer;
+    bool mKillServer;
 
-	bool mDebug;
+    bool mDebug;
 };
 
 #endif

include/OpenRaider.h

@@ -41,38 +41,38 @@
 
 typedef enum
 {
-	OpenRaiderKey_console = 1, // Reserved 0 event for console in System
-	OpenRaiderKey_attack,
-	OpenRaiderKey_forward,
-	OpenRaiderKey_left,
-	OpenRaiderKey_right,
-	OpenRaiderKey_backward,
-	OpenRaiderKey_jump,
-	OpenRaiderKey_tiltUp,
-	OpenRaiderKey_tiltDown,
-	OpenRaiderKey_panLeft,
-	OpenRaiderKey_panRight,
-	OpenRaiderKey_crouch
+    OpenRaiderKey_console = 1, // Reserved 0 event for console in System
+    OpenRaiderKey_attack,
+    OpenRaiderKey_forward,
+    OpenRaiderKey_left,
+    OpenRaiderKey_right,
+    OpenRaiderKey_backward,
+    OpenRaiderKey_jump,
+    OpenRaiderKey_tiltUp,
+    OpenRaiderKey_tiltDown,
+    OpenRaiderKey_panLeft,
+    OpenRaiderKey_panRight,
+    OpenRaiderKey_crouch
 
 } OpenRaider_KeyEvent;
 
 
 typedef enum
 {
-	OpenRaider_ShowFPS      =   1,
-	OpenRaider_DebugMap     =   2,
-	OpenRaider_DebugModel   =   4,
-	OpenRaider_EnableSound  =   8,
-	OpenRaider_DumpTexture  =  16,
-	OpenRaider_FullScreen   =  32,
-	OpenRaider_Loading      =  64,
-	OpenRaider_GameRunning  = 128
+    OpenRaider_ShowFPS      =   1,
+    OpenRaider_DebugMap     =   2,
+    OpenRaider_DebugModel   =   4,
+    OpenRaider_EnableSound  =   8,
+    OpenRaider_DumpTexture  =  16,
+    OpenRaider_FullScreen   =  32,
+    OpenRaider_Loading      =  64,
+    OpenRaider_GameRunning  = 128
 
 } OpenRaiderFlags;
 
 typedef enum
 {
-	OpenRaiderSound_Ambient = 1
+    OpenRaiderSound_Ambient = 1
 
 } OpenRaider_SoundEventType;
 
@@ -81,393 +81,393 @@ class OpenRaider : public SDLSystem
 {
  public:
 
-	////////////////////////////////////////////////////////////
-	// Constructors ( Singleton )
-	////////////////////////////////////////////////////////////
-
-	static OpenRaider *Instance();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Constructs the object of OpenRaider or
-	 *        returns pointer to it if previously allocated
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.08.24:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	~OpenRaider();
-	/*------------------------------------------------------
-	 * Pre  : OpenRaider object is allocated
-	 * Post : Deconstructs an object of OpenRaider
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.05.21:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-
-	////////////////////////////////////////////////////////////
-	// Public Accessors
-	////////////////////////////////////////////////////////////
-
-
-	////////////////////////////////////////////////////////////
-	// Public Mutators
-	////////////////////////////////////////////////////////////
-
-	void start();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Init the Game
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.05.21:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void handleMouseMotionEvent(float x, float y);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Mouse motion input used
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.06.04:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void handleBoundKeyPressEvent(unsigned int key);
-	/*------------------------------------------------------
-	 * Pre  : <Key> is a valid keyboard code
-	 *
-	 * Post : Recieves <Event> bound to <Cmd> from <Key> press
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2003.06.03:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void handleBoundKeyReleaseEvent(unsigned int key);
-	/*------------------------------------------------------
-	 * Pre  : <Key> is a valid keyboard code
-	 *
-	 * Post : Recieves <Event> bound to <Cmd> from <Key> release
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2003.06.03:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	 void handleCommand(char *command, unsigned int mode);
-	/*------------------------------------------------------
-	 * Pre  : <Command> is valid keyword optionally followed
-	 *        by ' ' (space) seperated and argument(s)
-	 *
-	 *        <Mode> is the current type or resource mode
-	 *
-	 * Post : Executes valid command based on keyword
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.03.23:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	 void handleConsoleKeyPressEvent(unsigned int key, unsigned int mod);
-	/*------------------------------------------------------
-	 * Pre  : <Key> is a valid keyboard code
-	 *
-	 * Post : Recieves <Key> code from text input in console mode
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2003.06.03:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void handleKeyPressEvent(unsigned int key, unsigned int mod);
-	void handleKeyReleaseEvent(unsigned int key, unsigned int mod);
-	/*------------------------------------------------------
-	 * Pre  : key and mod are valid key command
-	 * Post : executes command acc with key, if any
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.05.27:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void initGL();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post :
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.08.13:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void gameFrame();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : One game physics/time frame passes
-	 *        Also renders one frame per call
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.05.21:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void print(bool dump_stdout, const char *format, ...);
-	/*------------------------------------------------------
-	 * Pre  : Use like printf
-	 *
-	 * Post : Outputs message in game console
-	 *
-	 *        If dump_stdout is true, print to stdout also
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.08.13:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
+    ////////////////////////////////////////////////////////////
+    // Constructors ( Singleton )
+    ////////////////////////////////////////////////////////////
+
+    static OpenRaider *Instance();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Constructs the object of OpenRaider or
+     *        returns pointer to it if previously allocated
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.08.24:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    ~OpenRaider();
+    /*------------------------------------------------------
+     * Pre  : OpenRaider object is allocated
+     * Post : Deconstructs an object of OpenRaider
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.05.21:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+
+    ////////////////////////////////////////////////////////////
+    // Public Accessors
+    ////////////////////////////////////////////////////////////
+
+
+    ////////////////////////////////////////////////////////////
+    // Public Mutators
+    ////////////////////////////////////////////////////////////
+
+    void start();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Init the Game
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.05.21:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void handleMouseMotionEvent(float x, float y);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Mouse motion input used
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.06.04:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void handleBoundKeyPressEvent(unsigned int key);
+    /*------------------------------------------------------
+     * Pre  : <Key> is a valid keyboard code
+     *
+     * Post : Recieves <Event> bound to <Cmd> from <Key> press
+     *
+     *-- History ------------------------------------------
+     *
+     * 2003.06.03:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void handleBoundKeyReleaseEvent(unsigned int key);
+    /*------------------------------------------------------
+     * Pre  : <Key> is a valid keyboard code
+     *
+     * Post : Recieves <Event> bound to <Cmd> from <Key> release
+     *
+     *-- History ------------------------------------------
+     *
+     * 2003.06.03:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+     void handleCommand(char *command, unsigned int mode);
+    /*------------------------------------------------------
+     * Pre  : <Command> is valid keyword optionally followed
+     *        by ' ' (space) seperated and argument(s)
+     *
+     *        <Mode> is the current type or resource mode
+     *
+     * Post : Executes valid command based on keyword
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.03.23:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+     void handleConsoleKeyPressEvent(unsigned int key, unsigned int mod);
+    /*------------------------------------------------------
+     * Pre  : <Key> is a valid keyboard code
+     *
+     * Post : Recieves <Key> code from text input in console mode
+     *
+     *-- History ------------------------------------------
+     *
+     * 2003.06.03:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void handleKeyPressEvent(unsigned int key, unsigned int mod);
+    void handleKeyReleaseEvent(unsigned int key, unsigned int mod);
+    /*------------------------------------------------------
+     * Pre  : key and mod are valid key command
+     * Post : executes command acc with key, if any
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.05.27:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void initGL();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post :
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.08.13:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void gameFrame();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : One game physics/time frame passes
+     *        Also renders one frame per call
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.05.21:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void print(bool dump_stdout, const char *format, ...);
+    /*------------------------------------------------------
+     * Pre  : Use like printf
+     *
+     * Post : Outputs message in game console
+     *
+     *        If dump_stdout is true, print to stdout also
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.08.13:
+     * Mongoose - Created
+     ------------------------------------------------------*/
 
 
  protected:
 
-	////////////////////////////////////////////////////////////
-	// Constructors ( Singleton )
-	////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////
+    // Constructors ( Singleton )
+    ////////////////////////////////////////////////////////////
 
-	OpenRaider();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Constructs an object of OpenRaider
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.05.21:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
+    OpenRaider();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Constructs an object of OpenRaider
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.05.21:
+     * Mongoose - Created
+     ------------------------------------------------------*/
 
 
  private:
 
-	////////////////////////////////////////////////////////////
-	// Private Accessors
-	////////////////////////////////////////////////////////////
-
-
-	////////////////////////////////////////////////////////////
-	// Private Mutators
-	////////////////////////////////////////////////////////////
-
-	void consoleCommand(char *cmd);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post :
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * ????.??.??:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void soundEvent(int type, int id, vec3_t pos, vec3_t angles);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post :
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.06.16:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-//	void entityEvent(entity_t &e, RaiderEvent event);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post :
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.06.16:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void processPakSounds();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post :
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.06.04:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void initSound();
-	/*------------------------------------------------------
-	 * Pre  : Sound system has been init
-	 * Post : Loads and positions level sounds and music
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.06.04:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void initTextures();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Generates all textures or mipmaps
-	 *        needed for fonts, splash, ext particles
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.05.28:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void processTextures();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Generates tombraider textures or mipmaps
-	 *        needed for sprites, rooms, and models
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.05.28:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void processSprites();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Generates render sprite sequences
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.06.06:
-	 * Mongoose - All new functionality
-	 *
-	 * 2001.05.28:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void processMoveables();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post :
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 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 :
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.04.06:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void processModel(int index);
-	/*------------------------------------------------------
-	 * Pre  : valid model index
-	 * Post : Generates render mesh and any textures
-	 *        needed for model[index]
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.05.26:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void processRoom(int index);
-	/*------------------------------------------------------
-	 * Pre  : valid room index
-	 * Post : Generates render mesh and any textures
-	 *        needed for room[index]
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.05.21:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void loadLevel(char *filename);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Loads validated level pak from diskfile
-	 *        using maplist
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.05.21:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-
-	static OpenRaider *mInstance; /* Singleton use */
-
-	TombRaider m_tombraider;      /* Tombraider data support */
-
-	Sound mSound;                 /* 3d Audio support */
-
-	Render m_render;              /* Rendering support */
-
-	Camera m_camera;              /* Client camera support */
-
-	GLString *mText;              /* Hook to textbox like output */
-
-	int mNoClipping;              /* 0 - Clipping, 1 - No Clipping,
-											   2 - No Clipping w/o gravity */
-
-	// RC vars //////////////////
-
-	unsigned int mMode[8];			/* Translate System's mode ids to OR's */
-
-	unsigned int m_flags;			/* Set options by flags */
-
-	int m_testSFX;						/* Used for mixed channel sound tests */
-
-	float m_mouseX, m_mouseY;		/* XY axis rotation deltas */
+    ////////////////////////////////////////////////////////////
+    // Private Accessors
+    ////////////////////////////////////////////////////////////
+
+
+    ////////////////////////////////////////////////////////////
+    // Private Mutators
+    ////////////////////////////////////////////////////////////
+
+    void consoleCommand(char *cmd);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post :
+     *
+     *-- History ------------------------------------------
+     *
+     * ????.??.??:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void soundEvent(int type, int id, vec3_t pos, vec3_t angles);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post :
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.06.16:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+//  void entityEvent(entity_t &e, RaiderEvent event);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post :
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.06.16:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void processPakSounds();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post :
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.06.04:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void initSound();
+    /*------------------------------------------------------
+     * Pre  : Sound system has been init
+     * Post : Loads and positions level sounds and music
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.06.04:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void initTextures();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Generates all textures or mipmaps
+     *        needed for fonts, splash, ext particles
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.05.28:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void processTextures();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Generates tombraider textures or mipmaps
+     *        needed for sprites, rooms, and models
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.05.28:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void processSprites();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Generates render sprite sequences
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.06.06:
+     * Mongoose - All new functionality
+     *
+     * 2001.05.28:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void processMoveables();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post :
+     *
+     *-- History ------------------------------------------
+     *
+     * 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 :
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.04.06:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void processModel(int index);
+    /*------------------------------------------------------
+     * Pre  : valid model index
+     * Post : Generates render mesh and any textures
+     *        needed for model[index]
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.05.26:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void processRoom(int index);
+    /*------------------------------------------------------
+     * Pre  : valid room index
+     * Post : Generates render mesh and any textures
+     *        needed for room[index]
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.05.21:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void loadLevel(char *filename);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Loads validated level pak from diskfile
+     *        using maplist
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.05.21:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+
+    static OpenRaider *mInstance; /* Singleton use */
+
+    TombRaider m_tombraider;      /* Tombraider data support */
+
+    Sound mSound;                 /* 3d Audio support */
+
+    Render m_render;              /* Rendering support */
+
+    Camera m_camera;              /* Client camera support */
+
+    GLString *mText;              /* Hook to textbox like output */
+
+    int mNoClipping;              /* 0 - Clipping, 1 - No Clipping,
+                                               2 - No Clipping w/o gravity */
+
+    // RC vars //////////////////
+
+    unsigned int mMode[8];          /* Translate System's mode ids to OR's */
+
+    unsigned int m_flags;           /* Set options by flags */
+
+    int m_testSFX;                      /* Used for mixed channel sound tests */
+
+    float m_mouseX, m_mouseY;       /* XY axis rotation deltas */
 
-	unsigned int m_texOffset;		/* Offset of TombRaider textures in list */
+    unsigned int m_texOffset;       /* Offset of TombRaider textures in list */
 
-	unsigned int mLevelTextureOffset;
+    unsigned int mLevelTextureOffset;
 
-	// Game vars //////////////
+    // 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_mapName[32];          /* Current map filename */
 
-	char *m_pakDir;              /* Current pak directory */
+    char *m_pakDir;              /* Current pak directory */
 
-	char *m_audioDir;            /* Current audio directory */
+    char *m_audioDir;            /* Current audio directory */
 
-	char *m_homeDir;             /* Current home directory */
+    char *m_homeDir;             /* Current home directory */
 
-	Vector<entity_t *> mClients; /* Player entity/clients */
+    Vector<entity_t *> mClients; /* Player entity/clients */
 
-	unsigned int mMaxClients;    /* Max number of clients */
+    unsigned int mMaxClients;    /* Max number of clients */
 };
 
 #endif

include/Quaternion.h

@@ -33,333 +33,333 @@ class Quaternion
 {
  public:
 
-	////////////////////////////////////////////////////////////
-	// Constructors
-	////////////////////////////////////////////////////////////
-
-	Quaternion();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Constructs an object of Quaternion
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.16:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	Quaternion(vec_t w, vec_t x, vec_t y, vec_t z);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Constructs an object of Quaternion
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.16:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	Quaternion(vec4_t v);
-	/*------------------------------------------------------
-	 * Pre  : v { w, x, y, z }
-	 * Post : Constructs an object of Quaternion
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.16:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	~Quaternion();
-	/*------------------------------------------------------
-	 * Pre  : Quaternion object is allocated
-	 * Post : Deconstructs an object of Quaternion
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.16:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-
-	////////////////////////////////////////////////////////////
-	// Public Accessors
-	////////////////////////////////////////////////////////////
-
-	void getMatrix(matrix_t m);
-	/*------------------------------------------------------
-	 * Pre  : Matrix is valid
-	 * Post : Returns col order matrix equiv of this quaternion
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	Quaternion operator =(const Quaternion &q);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Asigns Q to this quaternion
-	 *        returns (this) resultant quaternion
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	Quaternion operator *(const Quaternion &q);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Multiplies Q and this quaternion
-	 *        returns resultant quaternion
-	 *        ( Use normalize() call for unit quaternion )
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	Quaternion operator /(const Quaternion &q);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Dividess Q from this quaternion
-	 *        returns quotient quaternion
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	Quaternion operator +(const Quaternion &q);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Adds Q and this quaternion
-	 *        returns resultant quaternion
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	Quaternion operator -(const Quaternion &q);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Subtracts Q from this quaternion
-	 *        returns resultant quaternion
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	bool operator ==(const Quaternion &q);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Compares Q to this quaternion
-	 *        returns boolean true if equal, otherwise false
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	Quaternion conjugate();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Returns conjugate of this quaternion
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	Quaternion scale(vec_t s);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Returns scaled result of this quaternion
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	Quaternion inverse();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Returns inverse of this quaternion
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	static vec_t dot(Quaternion a, Quaternion b);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Returns dot product of A and B quaternions
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	vec_t magnitude();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Returns magnitude this quaternion
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	static Quaternion slerp(Quaternion a, Quaternion b, vec_t time);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Interpolates between A and B rotations and
-	 *        returns resultant quaternion using
-	 *        spherical linear interpolation:
-	 *
-	 *        I = (((B . A)^ -1)^ Time) A
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-
-	////////////////////////////////////////////////////////////
-	// Public Mutators
-	////////////////////////////////////////////////////////////
-
-	void setIdentity();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Sets this quaternion to identity
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void set(vec_t angle, vec_t x, vec_t y, vec_t z);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Sets this quaternion
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void normalize();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Normalize this quaternion
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void copy(Quaternion q);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Set this quaternion using q
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void setByMatrix(matrix_t m);
-	/*------------------------------------------------------
-	 * Pre  : Matrix is valid column order
-	 * Post : Sets matrix equiv of this quaternion
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
+    ////////////////////////////////////////////////////////////
+    // Constructors
+    ////////////////////////////////////////////////////////////
+
+    Quaternion();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Constructs an object of Quaternion
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.16:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    Quaternion(vec_t w, vec_t x, vec_t y, vec_t z);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Constructs an object of Quaternion
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.16:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    Quaternion(vec4_t v);
+    /*------------------------------------------------------
+     * Pre  : v { w, x, y, z }
+     * Post : Constructs an object of Quaternion
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.16:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    ~Quaternion();
+    /*------------------------------------------------------
+     * Pre  : Quaternion object is allocated
+     * Post : Deconstructs an object of Quaternion
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.16:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+
+    ////////////////////////////////////////////////////////////
+    // Public Accessors
+    ////////////////////////////////////////////////////////////
+
+    void getMatrix(matrix_t m);
+    /*------------------------------------------------------
+     * Pre  : Matrix is valid
+     * Post : Returns col order matrix equiv of this quaternion
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    Quaternion operator =(const Quaternion &q);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Asigns Q to this quaternion
+     *        returns (this) resultant quaternion
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    Quaternion operator *(const Quaternion &q);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Multiplies Q and this quaternion
+     *        returns resultant quaternion
+     *        ( Use normalize() call for unit quaternion )
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    Quaternion operator /(const Quaternion &q);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Dividess Q from this quaternion
+     *        returns quotient quaternion
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    Quaternion operator +(const Quaternion &q);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Adds Q and this quaternion
+     *        returns resultant quaternion
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    Quaternion operator -(const Quaternion &q);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Subtracts Q from this quaternion
+     *        returns resultant quaternion
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    bool operator ==(const Quaternion &q);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Compares Q to this quaternion
+     *        returns boolean true if equal, otherwise false
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    Quaternion conjugate();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Returns conjugate of this quaternion
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    Quaternion scale(vec_t s);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Returns scaled result of this quaternion
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    Quaternion inverse();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Returns inverse of this quaternion
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    static vec_t dot(Quaternion a, Quaternion b);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Returns dot product of A and B quaternions
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    vec_t magnitude();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Returns magnitude this quaternion
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    static Quaternion slerp(Quaternion a, Quaternion b, vec_t time);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Interpolates between A and B rotations and
+     *        returns resultant quaternion using
+     *        spherical linear interpolation:
+     *
+     *        I = (((B . A)^ -1)^ Time) A
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+
+    ////////////////////////////////////////////////////////////
+    // Public Mutators
+    ////////////////////////////////////////////////////////////
+
+    void setIdentity();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Sets this quaternion to identity
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void set(vec_t angle, vec_t x, vec_t y, vec_t z);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Sets this quaternion
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void normalize();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Normalize this quaternion
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void copy(Quaternion q);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Set this quaternion using q
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void setByMatrix(matrix_t m);
+    /*------------------------------------------------------
+     * Pre  : Matrix is valid column order
+     * Post : Sets matrix equiv of this quaternion
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
 
 
  private:
 
-	////////////////////////////////////////////////////////////
-	// Private Accessors
-	////////////////////////////////////////////////////////////
-
-	Quaternion multiply(Quaternion a, Quaternion b);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Multiplies A and B quaternions
-	 *        returns resultant quaternion
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	Quaternion divide(Quaternion a, Quaternion b);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Divides B from A quaternion
-	 *        returns quotient quaternion
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	Quaternion add(Quaternion a, Quaternion b);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Adds A and B quaternions
-	 *        returns resultant quaternion
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	Quaternion subtract(Quaternion a, Quaternion b);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Subtracts B from A quaternion
-	 *        returns resultant quaternion
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	////////////////////////////////////////////////////////////
-	// Private Mutators
-	////////////////////////////////////////////////////////////
-
-	vec_t mW, mX, mY, mZ;          /* Quaternion */
+    ////////////////////////////////////////////////////////////
+    // Private Accessors
+    ////////////////////////////////////////////////////////////
+
+    Quaternion multiply(Quaternion a, Quaternion b);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Multiplies A and B quaternions
+     *        returns resultant quaternion
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    Quaternion divide(Quaternion a, Quaternion b);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Divides B from A quaternion
+     *        returns quotient quaternion
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    Quaternion add(Quaternion a, Quaternion b);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Adds A and B quaternions
+     *        returns resultant quaternion
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    Quaternion subtract(Quaternion a, Quaternion b);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Subtracts B from A quaternion
+     *        returns resultant quaternion
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    ////////////////////////////////////////////////////////////
+    // Private Mutators
+    ////////////////////////////////////////////////////////////
+
+    vec_t mW, mX, mY, mZ;          /* Quaternion */
 };
 
 #endif

include/Render.h

@@ -43,35 +43,35 @@
 class RenderRoom
 {
 public:
-	RenderRoom()
-	{
-		room = 0x0;
-	}
+    RenderRoom()
+    {
+        room = 0x0;
+    }
 
-	~RenderRoom()
-	{
-		//! \fixme Hangs when erasing - might be shared pointers somewhere
-		//lights.erase();
-	}
+    ~RenderRoom()
+    {
+        //! \fixme Hangs when erasing - might be shared pointers somewhere
+        //lights.erase();
+    }
 
-	void computeCenter()
-	{
-		if (room)
-		{
-			helMidpoint3v(room->bbox_min, room->bbox_max, center);
-		}
-	}
+    void computeCenter()
+    {
+        if (room)
+        {
+            helMidpoint3v(room->bbox_min, room->bbox_max, center);
+        }
+    }
 
-	vec_t dist;              /* Distance to near plane, move to room?  */
+    vec_t dist;              /* Distance to near plane, move to room?  */
 
-	vec3_t center;           /* Center of bbox, move to room? */
+    vec3_t center;           /* Center of bbox, move to room? */
 
-	room_mesh_t *room;       /* Physical room stored in World,
-										 Very dangerous as allocated and used */
+    room_mesh_t *room;       /* Physical room stored in World,
+                                         Very dangerous as allocated and used */
 
-	Vector<Light *> lights;  /* List of lights in this room */
+    Vector<Light *> lights;  /* List of lights in this room */
 
-	OpenGLMesh mesh;         /* OpenGL mesh that represents this room */
+    OpenGLMesh mesh;         /* OpenGL mesh that represents this room */
 };
 
 
@@ -79,169 +79,169 @@ class Render
 {
  public:
 
-	typedef enum
+    typedef enum
    {
-		modeDisabled    = 0,
-		modeLoadScreen  = 1,
-		modeVertexLight = 2,
-		modeSolid       = 3,
-		modeWireframe   = 4,
-		modeTexture     = 5
-	} RenderMode;
-
-	typedef enum
+        modeDisabled    = 0,
+        modeLoadScreen  = 1,
+        modeVertexLight = 2,
+        modeSolid       = 3,
+        modeWireframe   = 4,
+        modeTexture     = 5
+    } RenderMode;
+
+    typedef enum
    {
-		fParticles		= 1,
-		fPortals			= 2,
-		fRoomAlpha		= 4,
-		fViewModel    = 8,
-		fSprites      = 16,
-		fRoomModels   = 32,
-		fEntityModels = 64,
-		fFog          = 128,
-		fUsePortals   = 256,
-		fFastCard     = 1024,
-		fGL_Lights    = 2048,
-		fOneRoom      = 4096,
-		fRenderPonytail = 8192,
-		fMultiTexture = 16384,
-		fUpdateRoomListPerFrame = 32768,
-		fAnimateAllModels = 65536,
-		fAllRooms      =  131072
-	} RenderFlags;
-
-	typedef enum
-	{
-		roomMesh = 1,
-		skeletalMesh = 2
-
-	} RenderMeshType;
-
-	////////////////////////////////////////////////////////////
-	// Constructors
-	////////////////////////////////////////////////////////////
-
-	Render();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Constructs an object of Render
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.05.21:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	~Render();
-	/*------------------------------------------------------
-	 * Pre  : Render object is allocated
-	 * Post : Deconstructs an object of Render
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.05.21:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-
-	////////////////////////////////////////////////////////////
-	// Public Accessors
-	////////////////////////////////////////////////////////////
-
-	void screenShot(char *filenameBase);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Makes a screenshot, writes to disk as file
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.20:
-	 * Mongoose - Created, factored out of OpenRaider class
-	 ------------------------------------------------------*/
-
-	int getMode();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Gets current rendering mode
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.05.21:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-
-	////////////////////////////////////////////////////////////
-	// Public Mutators
-	////////////////////////////////////////////////////////////
-
-	void addRoom(RenderRoom *rRoom);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post :
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.21:
-	 * Mongoose - Created, factored out of World
-	 ------------------------------------------------------*/
-
-	void Init(int width, int height, bool fastCard);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Starts and sets up OpenGL target
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.05.21:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void loadTexture(unsigned char *image,
-						  unsigned int width, unsigned int height,
-						  unsigned int id);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Loads textures in a certian id slot
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.20:
-	 * Mongoose - Created, factored out of OpenRaider class
-	 ------------------------------------------------------*/
-
-	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
-	 *
-	 *        numLoaded will update number of
-	 *        external textures loaded
-	 *
-	 *        nextId will update next level texture id
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.20:
-	 * Mongoose - Created, factored out of OpenRaider class
-	 ------------------------------------------------------*/
-
-	void initEmitter(const char *name, unsigned int size,
-						  unsigned int snowTex1, unsigned int snowTex2);
-	/*------------------------------------------------------
-	 * Pre  : Textures are init and these args are valid
-	 * Post : Emitter is set up for rendering with 2 textures
-	 *        in a overhead rain or snow like pattern
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.20:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void ClearWorld();
+        fParticles      = 1,
+        fPortals            = 2,
+        fRoomAlpha      = 4,
+        fViewModel    = 8,
+        fSprites      = 16,
+        fRoomModels   = 32,
+        fEntityModels = 64,
+        fFog          = 128,
+        fUsePortals   = 256,
+        fFastCard     = 1024,
+        fGL_Lights    = 2048,
+        fOneRoom      = 4096,
+        fRenderPonytail = 8192,
+        fMultiTexture = 16384,
+        fUpdateRoomListPerFrame = 32768,
+        fAnimateAllModels = 65536,
+        fAllRooms      =  131072
+    } RenderFlags;
+
+    typedef enum
+    {
+        roomMesh = 1,
+        skeletalMesh = 2
+
+    } RenderMeshType;
+
+    ////////////////////////////////////////////////////////////
+    // Constructors
+    ////////////////////////////////////////////////////////////
+
+    Render();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Constructs an object of Render
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.05.21:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    ~Render();
+    /*------------------------------------------------------
+     * Pre  : Render object is allocated
+     * Post : Deconstructs an object of Render
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.05.21:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+
+    ////////////////////////////////////////////////////////////
+    // Public Accessors
+    ////////////////////////////////////////////////////////////
+
+    void screenShot(char *filenameBase);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Makes a screenshot, writes to disk as file
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.20:
+     * Mongoose - Created, factored out of OpenRaider class
+     ------------------------------------------------------*/
+
+    int getMode();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Gets current rendering mode
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.05.21:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+
+    ////////////////////////////////////////////////////////////
+    // Public Mutators
+    ////////////////////////////////////////////////////////////
+
+    void addRoom(RenderRoom *rRoom);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post :
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.21:
+     * Mongoose - Created, factored out of World
+     ------------------------------------------------------*/
+
+    void Init(int width, int height, bool fastCard);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Starts and sets up OpenGL target
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.05.21:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void loadTexture(unsigned char *image,
+                          unsigned int width, unsigned int height,
+                          unsigned int id);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Loads textures in a certian id slot
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.20:
+     * Mongoose - Created, factored out of OpenRaider class
+     ------------------------------------------------------*/
+
+    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
+     *
+     *        numLoaded will update number of
+     *        external textures loaded
+     *
+     *        nextId will update next level texture id
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.20:
+     * Mongoose - Created, factored out of OpenRaider class
+     ------------------------------------------------------*/
+
+    void initEmitter(const char *name, unsigned int size,
+                          unsigned int snowTex1, unsigned int snowTex2);
+    /*------------------------------------------------------
+     * Pre  : Textures are init and these args are valid
+     * Post : Emitter is set up for rendering with 2 textures
+     *        in a overhead rain or snow like pattern
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.20:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void ClearWorld();
   /*------------------------------------------------------
    * Pre  :
    * Post : Removes current world/entity/etc geometery
@@ -252,9 +252,9 @@ class Render
    * Mongoose - Created
    ------------------------------------------------------*/
 
-	void toggleFlag(unsigned int flag);
-	void clearFlags(unsigned int flags);
-	void setFlags(unsigned int flags);
+    void toggleFlag(unsigned int flag);
+    void clearFlags(unsigned int flags);
+    void setFlags(unsigned int flags);
   /*------------------------------------------------------
    * Pre  : (Un)Sets bitflags for various control use
    * Post : Changes state of renderer in some way
@@ -265,7 +265,7 @@ class Render
    * Mongoose - Created
    ------------------------------------------------------*/
 
-	void setMode(int n);
+    void setMode(int n);
   /*------------------------------------------------------
    * Pre  :
    * Post :
@@ -276,7 +276,7 @@ class Render
    * Mongoose - Created
    ------------------------------------------------------*/
 
-	void Update(int width, int height);
+    void Update(int width, int height);
   /*------------------------------------------------------
    * Pre  :
    * Post :
@@ -287,7 +287,7 @@ class Render
    * Mongoose - Created
    ------------------------------------------------------*/
 
-	void Display();
+    void Display();
   /*------------------------------------------------------
    * Pre  :
    * Post : Renders a single game frame
@@ -298,7 +298,7 @@ class Render
    * Mongoose - Created
    ------------------------------------------------------*/
 
-	void setSkyMesh(int index, bool rot);
+    void setSkyMesh(int index, bool rot);
   /*------------------------------------------------------
    * Pre  :
    * Post :
@@ -309,7 +309,7 @@ class Render
    * Mongoose - Created
    ------------------------------------------------------*/
 
-	void ViewModel(entity_t *ent, int index);
+    void ViewModel(entity_t *ent, int index);
   /*------------------------------------------------------
    * Pre  :
    * Post :
@@ -320,7 +320,7 @@ class Render
    * Mongoose - Created
    ------------------------------------------------------*/
 
-	void RegisterCamera(Camera *camera);
+    void RegisterCamera(Camera *camera);
   /*------------------------------------------------------
    * Pre  :
    * Post :
@@ -342,7 +342,7 @@ class Render
     * Mongoose - Created
     ------------------------------------------------------*/
 
-	//! \fixme Should be private
+    //! \fixme Should be private
    void drawLoadScreen();
    /*------------------------------------------------------
     * Pre  : Texture is init
@@ -354,7 +354,7 @@ class Render
     * Mongoose - Created
     ------------------------------------------------------*/
 
-	void addSkeletalModel(SkeletalModel *mdl);
+    void addSkeletalModel(SkeletalModel *mdl);
    /*------------------------------------------------------
     * Pre  :
     * Post :
@@ -368,53 +368,53 @@ class Render
 
 private:
 
-	////////////////////////////////////////////////////////////
-	// Private Accessors
-	////////////////////////////////////////////////////////////
-
-	bool isVisible(float bboxMin[3], float bboxMax[3]);
-	/*------------------------------------------------------
-	 * Pre  : Abstract bounding box must be valid
-	 * Post : If object's bounding box is in viewing volume
-	 *        return true, else false
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.16:
-	 * Mongoose - Moved to Render class
-	 *
-	 * 2001.06.06:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	bool isVisible(float x, float y, float z);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Is point in view volume?
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.16:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	bool isVisible(float x, float y, float z, float radius);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Is sphere in view volume?
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.16:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-
-	////////////////////////////////////////////////////////////
-	// Private Mutators
-	////////////////////////////////////////////////////////////
-
-	void newRoomRenderList(int index);
+    ////////////////////////////////////////////////////////////
+    // Private Accessors
+    ////////////////////////////////////////////////////////////
+
+    bool isVisible(float bboxMin[3], float bboxMax[3]);
+    /*------------------------------------------------------
+     * Pre  : Abstract bounding box must be valid
+     * Post : If object's bounding box is in viewing volume
+     *        return true, else false
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.16:
+     * Mongoose - Moved to Render class
+     *
+     * 2001.06.06:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    bool isVisible(float x, float y, float z);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Is point in view volume?
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.16:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    bool isVisible(float x, float y, float z, float radius);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Is sphere in view volume?
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.16:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+
+    ////////////////////////////////////////////////////////////
+    // Private Mutators
+    ////////////////////////////////////////////////////////////
+
+    void newRoomRenderList(int index);
    /*------------------------------------------------------
     * Pre  : room index is valid
     * Post : Build a visible room list starting at index
@@ -425,12 +425,12 @@ private:
     * Mongoose - Created
     ------------------------------------------------------*/
 
-	void buildRoomRenderList(RenderRoom *room);
+    void buildRoomRenderList(RenderRoom *room);
    /*------------------------------------------------------
     * Pre  : room is valid
     * Post : Build a visible room list starting from room
-	 *        and only consider it's linked rooms and their
-	 *        linked rooms
+     *        and only consider it's linked rooms and their
+     *        linked rooms
     *
     *-- History ------------------------------------------
     *
@@ -438,7 +438,7 @@ private:
     * Mongoose - Created
     ------------------------------------------------------*/
 
-	void drawObjects();
+    void drawObjects();
    /*------------------------------------------------------
     * Pre  : Texture is init
     * Post : Renders visible world objects
@@ -449,10 +449,10 @@ private:
     * Mongoose - Created
     ------------------------------------------------------*/
 
-	void drawSkyMesh(float scale);
+    void drawSkyMesh(float scale);
    /*------------------------------------------------------
     * Pre  : Texture is init
-	 *        scale is correct for map size
+     *        scale is correct for map size
     * Post : Renders Sky domes/boxes/etc by scaling factor
     *
     *-- History ------------------------------------------
@@ -461,7 +461,7 @@ private:
     * Mongoose - Created
     ------------------------------------------------------*/
 
-	void drawModel(SkeletalModel *model);
+    void drawModel(SkeletalModel *model);
    /*------------------------------------------------------
     * Pre  : Texture is init
     * Post : Renders a skeletal model
@@ -472,15 +472,15 @@ private:
     * Mongoose - Created
     ------------------------------------------------------*/
 
-	void drawRoom(RenderRoom *rRoom, bool draw_alpha);
+    void drawRoom(RenderRoom *rRoom, bool draw_alpha);
    /*------------------------------------------------------
     * Pre  : Texture is init
-	 *        Draw all rooms with alpha false, then
-	 *        draw with alpha true
-	 *
+     *        Draw all rooms with alpha false, then
+     *        draw with alpha true
+     *
     * Post : Renders a room in 2 seperate passes to
-	 *        handle alpha, currently doesn't sort alpha
-	 *        but looks pretty good
+     *        handle alpha, currently doesn't sort alpha
+     *        but looks pretty good
     *
     *-- History ------------------------------------------
     *
@@ -488,7 +488,7 @@ private:
     * Mongoose - Created
     ------------------------------------------------------*/
 
-	void drawRoomModel(static_model_t *mesh);
+    void drawRoomModel(static_model_t *mesh);
    /*------------------------------------------------------
     * Pre  : Texture is init
     * Post : Renders static room model
@@ -499,7 +499,7 @@ private:
     * Mongoose - Created
     ------------------------------------------------------*/
 
-	void drawModelMesh(model_mesh_t *r_mesh, RenderMeshType type);
+    void drawModelMesh(model_mesh_t *r_mesh, RenderMeshType type);
    /*------------------------------------------------------
     * Pre  : Texture is init, type is object containing mesh
     * Post : Renders a mesh
@@ -510,7 +510,7 @@ private:
     * Mongoose - Created
     ------------------------------------------------------*/
 
-	void drawSprite(sprite_t *sprite);
+    void drawSprite(sprite_t *sprite);
    /*------------------------------------------------------
     * Pre  : Texture is init
     * Post : Renders a sprite
@@ -521,65 +521,65 @@ private:
     * Mongoose - Created
     ------------------------------------------------------*/
 
-	void updateViewVolume();
-	/*------------------------------------------------------
-	 * Pre  : Call once per render frame
-	 * Post : Updated view volume
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.16:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void tmpRenderModelMesh(model_mesh_t *r_mesh, texture_tri_t *ttri);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Let them eat cake...
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2003.05.19:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
+    void updateViewVolume();
+    /*------------------------------------------------------
+     * Pre  : Call once per render frame
+     * Post : Updated view volume
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.16:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void tmpRenderModelMesh(model_mesh_t *r_mesh, texture_tri_t *ttri);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Let them eat cake...
+     *
+     *-- History ------------------------------------------
+     *
+     * 2003.05.19:
+     * Mongoose - Created
+     ------------------------------------------------------*/
 
 
 
 #ifdef USING_EMITTER
-	Emitter *mEmitter;      /* Particle emitter test */
+    Emitter *mEmitter;      /* Particle emitter test */
 #endif
 
-	Texture mTexture;       /* Texture subsystem */
+    Texture mTexture;       /* Texture subsystem */
 
-	Camera *mCamera;        /* Camera subsystem */
+    Camera *mCamera;        /* Camera subsystem */
 
-	GLString mString;       /* GL Text subsystem */
+    GLString mString;       /* GL Text subsystem */
 
-	Vector<RenderRoom *> mRoomRenderList;
+    Vector<RenderRoom *> mRoomRenderList;
 
-	Vector<RenderRoom *> mRooms;
+    Vector<RenderRoom *> mRooms;
 
-	Vector<SkeletalModel *> mModels;
+    Vector<SkeletalModel *> mModels;
 
-	unsigned int mFlags;    /* Rendering flags */
+    unsigned int mFlags;    /* Rendering flags */
 
-	unsigned int mWidth;    /* Viewport width */
+    unsigned int mWidth;    /* Viewport width */
 
-	unsigned int mHeight;   /* Viewport height */
+    unsigned int mHeight;   /* Viewport height */
 
-	unsigned int mMode;     /* Rendering mode */
+    unsigned int mMode;     /* Rendering mode */
 
-	unsigned int *mNumTexturesLoaded;
+    unsigned int *mNumTexturesLoaded;
 
-	unsigned int *mNextTextureId;
+    unsigned int *mNextTextureId;
 
-	// float mSplash;
+    // float mSplash;
 
-	int mLock;
+    int mLock;
 
-	int mSkyMesh;           /* Skymesh model id */
+    int mSkyMesh;           /* Skymesh model id */
 
-	bool mSkyMeshRotation;  /* Should Skymesh be rotated? */
+    bool mSkyMeshRotation;  /* Should Skymesh be rotated? */
 };
 
 #endif

include/SDLSystem.h

@@ -35,88 +35,88 @@ class SDLSystem : public System
 {
  public:
 
-	////////////////////////////////////////////////////////////
-	// Constructors
-	////////////////////////////////////////////////////////////
-
-	SDLSystem();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Constructs an object of SDLSystem
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.06.06:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	virtual ~SDLSystem();
-	/*------------------------------------------------------
-	 * Pre  : SDL object is allocated
-	 * Post : Deconstructs an object of SDLSystem
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.06.06:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-
-	////////////////////////////////////////////////////////////
-	// Public Accessors
-	////////////////////////////////////////////////////////////
-
-	virtual unsigned int getTicks();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Returns number of milliseconds since start of
-	 *        program
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.06.06:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-
-	////////////////////////////////////////////////////////////
-	// Public Mutators
-	////////////////////////////////////////////////////////////
-
-	//FIXME: void bindKeyCommand(const char *cmd, int key, int event);
-	/*------------------------------------------------------
-	 * Pre  : <Cmd> is a valid command string
-	 *        <Key> is a valid keyboard code
-	 *        <Event> is a valid game event Id
-	 *
-	 * Post : Sets <Event> binding <Cmd> to <Key> press
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2003.06.03:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
+    ////////////////////////////////////////////////////////////
+    // Constructors
+    ////////////////////////////////////////////////////////////
+
+    SDLSystem();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Constructs an object of SDLSystem
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.06.06:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    virtual ~SDLSystem();
+    /*------------------------------------------------------
+     * Pre  : SDL object is allocated
+     * Post : Deconstructs an object of SDLSystem
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.06.06:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+
+    ////////////////////////////////////////////////////////////
+    // Public Accessors
+    ////////////////////////////////////////////////////////////
+
+    virtual unsigned int getTicks();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Returns number of milliseconds since start of
+     *        program
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.06.06:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+
+    ////////////////////////////////////////////////////////////
+    // Public Mutators
+    ////////////////////////////////////////////////////////////
+
+    //FIXME: void bindKeyCommand(const char *cmd, int key, int event);
+    /*------------------------------------------------------
+     * Pre  : <Cmd> is a valid command string
+     *        <Key> is a valid keyboard code
+     *        <Event> is a valid game event Id
+     *
+     * Post : Sets <Event> binding <Cmd> to <Key> press
+     *
+     *-- History ------------------------------------------
+     *
+     * 2003.06.03:
+     * Mongoose - Created
+     ------------------------------------------------------*/
 
    void glPrintf2d(float x, float y, char *string);
    /*------------------------------------------------------
     * Pre  : <X>, and <Y> are valid world coordinates
-	 *        <String> is a valid string
-	 *
-	 *        Requires glEnterMode2d() call before entry
-	 *
-	 *        System::bufferString(..) can cache printf()
-	 *        style calls for use with this method
-	 *
+     *        <String> is a valid string
+     *
+     *        Requires glEnterMode2d() call before entry
+     *
+     *        System::bufferString(..) can cache printf()
+     *        style calls for use with this method
+     *
     * Post : Renders string in OpenGL ( 2d projection )
-	 *
-	 *        Call glExitMode2d() after finishing calls
-	 *        to this method and other 2d rendering
+     *
+     *        Call glExitMode2d() after finishing calls
+     *        to this method and other 2d rendering
     *
     *-- History ------------------------------------------
     *
-	 * 2003.06.03:
-	 * Mongoose - Ported to SDL_TTF
-	 *
+     * 2003.06.03:
+     * Mongoose - Ported to SDL_TTF
+     *
     * 2001.12.31:
     * Mongoose - Created
     ------------------------------------------------------*/
@@ -124,101 +124,101 @@ class SDLSystem : public System
    void glPrintf3d(float x, float y, float z, char *string);
    /*------------------------------------------------------
     * Pre  : <X>, <Y>, and <Z> are valid world coordinates
-	 *        <String> is a valid string
-	 *
-	 *        System::bufferString(..) can cache printf()
-	 *        style calls for use with this method
-	 *
+     *        <String> is a valid string
+     *
+     *        System::bufferString(..) can cache printf()
+     *        style calls for use with this method
+     *
     * Post : Renders string in OpenGL ( 3d projection )
     *
     *-- History ------------------------------------------
     *
-	 * 2003.06.03:
-	 * Mongoose - Ported to SDL_TTF
-	 *
+     * 2003.06.03:
+     * Mongoose - Ported to SDL_TTF
+     *
     * 2001.12.31:
     * Mongoose - Created
     ------------------------------------------------------*/
 
-	void initVideo(unsigned int width, unsigned int height,
-						bool fullscreen);
-	/*------------------------------------------------------
-	 * Pre  : Video mode request <Width> x <Height>
-	 *        <Fullscreen> enables fullscreen rendering
-	 *
-	 * Post : Start up video subsystem
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.06.06:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void resize(unsigned int width, unsigned int height);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Resizes game window
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.06.06:
-	 * Mongoose - Created, from old SDLUnitTest code
-	 ------------------------------------------------------*/
-
-	void runGame();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Start game loop
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.06.06:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void setGrabMouse(bool on);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post :
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2003.01.05:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void shutdown(int i);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Shutsdown the game subsystems, exits game loop
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.06.06:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void swapBuffersGL();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Swaps OpenGL buufers ( call at end of frame )
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.06.06:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void toggleFullscreen();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Toggle fullscreen windowing mode
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.06.06:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
+    void initVideo(unsigned int width, unsigned int height,
+                        bool fullscreen);
+    /*------------------------------------------------------
+     * Pre  : Video mode request <Width> x <Height>
+     *        <Fullscreen> enables fullscreen rendering
+     *
+     * Post : Start up video subsystem
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.06.06:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void resize(unsigned int width, unsigned int height);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Resizes game window
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.06.06:
+     * Mongoose - Created, from old SDLUnitTest code
+     ------------------------------------------------------*/
+
+    void runGame();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Start game loop
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.06.06:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void setGrabMouse(bool on);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post :
+     *
+     *-- History ------------------------------------------
+     *
+     * 2003.01.05:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void shutdown(int i);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Shutsdown the game subsystems, exits game loop
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.06.06:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void swapBuffersGL();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Swaps OpenGL buufers ( call at end of frame )
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.06.06:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void toggleFullscreen();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Toggle fullscreen windowing mode
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.06.06:
+     * Mongoose - Created
+     ------------------------------------------------------*/
 
  protected:
     int m_old_width;
@@ -228,15 +228,15 @@ class SDLSystem : public System
 
  private:
 
-	////////////////////////////////////////////////////////////
-	// Private Accessors
-	////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////
+    // Private Accessors
+    ////////////////////////////////////////////////////////////
 
 
-	////////////////////////////////////////////////////////////
-	// Private Mutators
-	////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////
+    // Private Mutators
+    ////////////////////////////////////////////////////////////
 
-	SDL_Surface *mWindow;	/* This is the pointer to the SDL surface */
+    SDL_Surface *mWindow;   /* This is the pointer to the SDL surface */
 };
 #endif

include/SkeletalModel.h

@@ -20,45 +20,45 @@
 
 typedef struct bone_tag_s
 {
-	int mesh;
-	vec3_t off;
-	vec3_t rot;
-	char flag;
+    int mesh;
+    vec3_t off;
+    vec3_t rot;
+    char flag;
 
 } bone_tag_t;
 
 
 typedef struct bone_frame_s
 {
-	Vector<bone_tag_t *> tag;
-	vec3_t pos;
-	float yaw;
+    Vector<bone_tag_t *> tag;
+    vec3_t pos;
+    float yaw;
 
 } bone_frame_t;
 
 
 typedef struct animation_frame_s
 {
-	int id;
-	char rate;
-	Vector<bone_frame_t *> frame;
+    int id;
+    char rate;
+    Vector<bone_frame_t *> frame;
 
 } animation_frame_t;
 
 
 typedef struct skeletal_model_s
 {
-	int id;
-	bool tr4Overlay;
-	bool pigtails;
-	int ponytailId;
-	vec3_t ponytail;
-	int ponytailMeshId;
-	unsigned int ponytailNumMeshes;
-	float ponytailAngle;
-	float ponyOff;
-	float ponyOff2;
-	Vector<animation_frame_t *> animation;
+    int id;
+    bool tr4Overlay;
+    bool pigtails;
+    int ponytailId;
+    vec3_t ponytail;
+    int ponytailMeshId;
+    unsigned int ponytailNumMeshes;
+    float ponytailAngle;
+    float ponyOff;
+    float ponyOff2;
+    Vector<animation_frame_t *> animation;
 
 } skeletal_model_t;
 
@@ -67,83 +67,83 @@ class SkeletalModel
 {
  public:
 
-	////////////////////////////////////////////////////////////
-	// Constructors
-	////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////
+    // Constructors
+    ////////////////////////////////////////////////////////////
 
-	SkeletalModel();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Constructs an object of SkeletalModel
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2003.05.19:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
+    SkeletalModel();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Constructs an object of SkeletalModel
+     *
+     *-- History ------------------------------------------
+     *
+     * 2003.05.19:
+     * Mongoose - Created
+     ------------------------------------------------------*/
 
-	~SkeletalModel();
-	/*------------------------------------------------------
-	 * Pre  : SkeletalModel object is allocated
-	 * Post : Deconstructs an object of SkeletalModel
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2003.05.19:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
+    ~SkeletalModel();
+    /*------------------------------------------------------
+     * Pre  : SkeletalModel object is allocated
+     * Post : Deconstructs an object of SkeletalModel
+     *
+     *-- History ------------------------------------------
+     *
+     * 2003.05.19:
+     * Mongoose - Created
+     ------------------------------------------------------*/
 
 
-	////////////////////////////////////////////////////////////
-	// Public Accessors
-	////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////
+    // Public Accessors
+    ////////////////////////////////////////////////////////////
 
-	int getAnimation();
+    int getAnimation();
 
-	int getFrame() ;
+    int getFrame() ;
 
-	int getIdleAnimation();
+    int getIdleAnimation();
 
 
-	////////////////////////////////////////////////////////////
-	// Public Mutators
-	////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////
+    // Public Mutators
+    ////////////////////////////////////////////////////////////
 
-	void setModel(skeletal_model_t *mdl);
+    void setModel(skeletal_model_t *mdl);
 
-	void setAnimation(int index);
+    void setAnimation(int index);
 
-	void setFrame(int index);
+    void setFrame(int index);
 
-	void setIdleAnimation(int index);
+    void setIdleAnimation(int index);
 
 
-	enum SkeletalModelFlag { fReserved = 1 };
+    enum SkeletalModelFlag { fReserved = 1 };
 
-	unsigned int flags;
+    unsigned int flags;
 
-	skeletal_model_t *model;   /* World render model */
+    skeletal_model_t *model;   /* World render model */
 
-	float time;                /* Interpolation use */
-	float lastTime;
+    float time;                /* Interpolation use */
+    float lastTime;
 
-	float rate; // temp cache this here for old animation system use
+    float rate; // temp cache this here for old animation system use
 
 private:
 
-	////////////////////////////////////////////////////////////
-	// Private Accessors
-	////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////
+    // Private Accessors
+    ////////////////////////////////////////////////////////////
 
 
-	////////////////////////////////////////////////////////////
-	// Private Mutators
-	////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////
+    // Private Mutators
+    ////////////////////////////////////////////////////////////
 
 
-	int mBoneFrame;             /* Bone frame */
-	int mAnimationFrame;        /* Animation frame */
-	int mIdleAnimation;         /* Idle animation */
+    int mBoneFrame;             /* Bone frame */
+    int mAnimationFrame;        /* Animation frame */
+    int mIdleAnimation;         /* Idle animation */
 };
 
 #endif

include/Texture.h

@@ -36,41 +36,41 @@
 
 typedef struct
 {
-	int x, y, w, h;
-	int minx; int maxx; int miny; int maxy; int advance;
+    int x, y, w, h;
+    int minx; int maxx; int miny; int maxy; int advance;
 
 } ttf_glyph_t;
 
 typedef struct
 {
-	unsigned int utf8Offset;
-	unsigned int count;
+    unsigned int utf8Offset;
+    unsigned int count;
 
 /* [utf8Offset -> utf8Offset+count],
-	 matches indexing into glyphs[0 -> count] for texcoords, etc
-	----------------------------------------
-	41     -> 126     ASCII English w/ special chars,
-	0x303f -> 0x3093  Japanese hiragana kana,
-	0x301a -> 0x30f6  Japanese katakana kana */
+     matches indexing into glyphs[0 -> count] for texcoords, etc
+    ----------------------------------------
+    41     -> 126     ASCII English w/ special chars,
+    0x303f -> 0x3093  Japanese hiragana kana,
+    0x301a -> 0x30f6  Japanese katakana kana */
 
-	unsigned int width;     /* Width and height of RGBA texture */
-	unsigned char *texture; /* RGBA texture data */
+    unsigned int width;     /* Width and height of RGBA texture */
+    unsigned char *texture; /* RGBA texture data */
 
-	ttf_glyph_t *glyphs;    /* For typesetting and rendering use */
-	int fontHeight;
-	int fontAscent;
-	int fontDescent;
-	int fontSpacing;
+    ttf_glyph_t *glyphs;    /* For typesetting and rendering use */
+    int fontHeight;
+    int fontAscent;
+    int fontDescent;
+    int fontSpacing;
 
 } ttf_texture_t;
 
 
 typedef struct
 {
-	unsigned int utf8Offset;
-	unsigned int count;
-	int textureId;
-	int drawListBase;
+    unsigned int utf8Offset;
+    unsigned int count;
+    int textureId;
+    int drawListBase;
 
 } gl_font_t;
 
@@ -80,399 +80,399 @@ class Texture
 {
  public:
 
-	enum ColorMode
-	{
-		GREYSCALE = 1,
-		RGB,
-		RGBA,
-		ARGB
-	};
-
-	enum TextureFlag
-	{
-		fUseMipmaps			= (1 << 0),
-		fUseMultiTexture	= (1 << 1),
+    enum ColorMode
+    {
+        GREYSCALE = 1,
+        RGB,
+        RGBA,
+        ARGB
+    };
+
+    enum TextureFlag
+    {
+        fUseMipmaps         = (1 << 0),
+        fUseMultiTexture    = (1 << 1),
         fUseSDL_TTF         = (1 << 2)
-	};
+    };
 
 
-	////////////////////////////////////////////////////////////
-	// Constructors
-	////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////
+    // Constructors
+    ////////////////////////////////////////////////////////////
 
    Texture();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Constructs an object of Texture
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.05.29:
-	 * Mongoose - Big code clean up, documentation
-	 *
-	 * 2000.10.05:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Constructs an object of Texture
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.05.29:
+     * Mongoose - Big code clean up, documentation
+     *
+     * 2000.10.05:
+     * Mongoose - Created
+     ------------------------------------------------------*/
 
    ~Texture();
-	/*------------------------------------------------------
-	 * Pre  : This object exists
-	 * Post : Deconstructs an object of Texture
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.05.29:
-	 * Mongoose - Big code clean up, documentation
-	 *
-	 * 2000.10.05:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-
-	////////////////////////////////////////////////////////////
-	// Public Accessors
-	////////////////////////////////////////////////////////////
-
-	static unsigned char *generateColorTexture(unsigned char rgba[4],
-															 unsigned int width,
-															 unsigned int height);
-	/*------------------------------------------------------
-	 * Pre  : <Rgba> is 32bpp RGBA color
-	 *        <Width> and <Height> are powers of two, pref
-	 *        the same number
-	 * Post :
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2003.06.30:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	gl_font_t *generateFont(ttf_texture_t *texture);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post :
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2003.06.30:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	ttf_texture_t *generateFontTexture(const char *filename, int pointSize,
-												  unsigned int textureWidth,
-												  unsigned char color[3],
-												  unsigned int utf8Offset,
-												  unsigned int count,
-												  char verbose);
-	/*------------------------------------------------------
-	 * Pre  : <Filename> of TTF font
-	 *        <PointSize> to generate
-	 *        <TextureWidth> is width of texture, height will match it
-	 *        <Color> is RGB 24bit color
-	 *        <Utf8Offset> is offset into font's encoding chart
-	 *        <Count> is number of glyphs to read from offset start
-	 *        <Verbose> dumps debug info to stdout
-	 *
-	 * Post : Generates a font texture with typeset info from TTF
-	 *
-	 *        DOES NOT load the texture itself, call loadFont()
-	 *        on returned ttf_texture_t
-	 *
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2003.06.03:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
+    /*------------------------------------------------------
+     * Pre  : This object exists
+     * Post : Deconstructs an object of Texture
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.05.29:
+     * Mongoose - Big code clean up, documentation
+     *
+     * 2000.10.05:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+
+    ////////////////////////////////////////////////////////////
+    // Public Accessors
+    ////////////////////////////////////////////////////////////
+
+    static unsigned char *generateColorTexture(unsigned char rgba[4],
+                                                             unsigned int width,
+                                                             unsigned int height);
+    /*------------------------------------------------------
+     * Pre  : <Rgba> is 32bpp RGBA color
+     *        <Width> and <Height> are powers of two, pref
+     *        the same number
+     * Post :
+     *
+     *-- History ------------------------------------------
+     *
+     * 2003.06.30:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    gl_font_t *generateFont(ttf_texture_t *texture);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post :
+     *
+     *-- History ------------------------------------------
+     *
+     * 2003.06.30:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    ttf_texture_t *generateFontTexture(const char *filename, int pointSize,
+                                                  unsigned int textureWidth,
+                                                  unsigned char color[3],
+                                                  unsigned int utf8Offset,
+                                                  unsigned int count,
+                                                  char verbose);
+    /*------------------------------------------------------
+     * Pre  : <Filename> of TTF font
+     *        <PointSize> to generate
+     *        <TextureWidth> is width of texture, height will match it
+     *        <Color> is RGB 24bit color
+     *        <Utf8Offset> is offset into font's encoding chart
+     *        <Count> is number of glyphs to read from offset start
+     *        <Verbose> dumps debug info to stdout
+     *
+     * Post : Generates a font texture with typeset info from TTF
+     *
+     *        DOES NOT load the texture itself, call loadFont()
+     *        on returned ttf_texture_t
+     *
+     *
+     *-- History ------------------------------------------
+     *
+     * 2003.06.03:
+     * Mongoose - Created
+     ------------------------------------------------------*/
 
    int getTextureCount();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Returns number of textures in use, or -1 for
-	 *        error ( Not initalized )
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.05.29:
-	 * Mongoose - Big code clean up, documentation
-	 *
-	 * 2000.10.05:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void glScreenShot(char *base, unsigned int width, unsigned int height);
-	/*------------------------------------------------------
-	 * Pre  : <Base> is base filename,
-	 *        <Width> and <Height> are viewport dim
-	 *
-	 * Post : Dumps a screenshot to disk,
-	 *        avoids overwriting files with same base name
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.06.16:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-
-	////////////////////////////////////////////////////////////
-	// Public Mutators
-	////////////////////////////////////////////////////////////
-
-	void bindMultiTexture(int texture0, int texture1);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Sets up multitexture rendering with passed texture ids
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.24:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Returns number of textures in use, or -1 for
+     *        error ( Not initalized )
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.05.29:
+     * Mongoose - Big code clean up, documentation
+     *
+     * 2000.10.05:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void glScreenShot(char *base, unsigned int width, unsigned int height);
+    /*------------------------------------------------------
+     * Pre  : <Base> is base filename,
+     *        <Width> and <Height> are viewport dim
+     *
+     * Post : Dumps a screenshot to disk,
+     *        avoids overwriting files with same base name
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.06.16:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+
+    ////////////////////////////////////////////////////////////
+    // Public Mutators
+    ////////////////////////////////////////////////////////////
+
+    void bindMultiTexture(int texture0, int texture1);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Sets up multitexture rendering with passed texture ids
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.24:
+     * Mongoose - Created
+     ------------------------------------------------------*/
 
    void bindTextureId(unsigned int n);
-	/*------------------------------------------------------
-	 * Pre  : n is valid texture index
-	 * Post : Binds the texture for use in GL
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.05.29:
-	 * Mongoose - Big code clean up, documentation
-	 *
-	 * 2000.10.05:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void clearFlag(TextureFlag flag);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : CLears a option flag
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2003.01.05:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void disableMultiTexture();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post :
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.24:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void initSDL_TTF();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Loads SDL_TTF if avalible
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2003.06.03:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
+    /*------------------------------------------------------
+     * Pre  : n is valid texture index
+     * Post : Binds the texture for use in GL
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.05.29:
+     * Mongoose - Big code clean up, documentation
+     *
+     * 2000.10.05:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void clearFlag(TextureFlag flag);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : CLears a option flag
+     *
+     *-- History ------------------------------------------
+     *
+     * 2003.01.05:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void disableMultiTexture();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post :
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.24:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void initSDL_TTF();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Loads SDL_TTF if avalible
+     *
+     *-- History ------------------------------------------
+     *
+     * 2003.06.03:
+     * Mongoose - Created
+     ------------------------------------------------------*/
 
    int loadBuffer(unsigned char *image,
-						unsigned int width, unsigned int height,
-						ColorMode mode, unsigned int bpp);
-	/*------------------------------------------------------
-	 * Pre  : image must be a valid pixmap that agrees
-	 *        with mode, width, and height
-	 *
-	 * Post : Returns texture id or < 0 error flag
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.05.29:
-	 * Mongoose - Big code clean up, documentation
-	 *
-	 * 2000.10.05:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
+                        unsigned int width, unsigned int height,
+                        ColorMode mode, unsigned int bpp);
+    /*------------------------------------------------------
+     * Pre  : image must be a valid pixmap that agrees
+     *        with mode, width, and height
+     *
+     * Post : Returns texture id or < 0 error flag
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.05.29:
+     * Mongoose - Big code clean up, documentation
+     *
+     * 2000.10.05:
+     * Mongoose - Created
+     ------------------------------------------------------*/
 
    int loadBufferSlot(unsigned char *image,
-							 unsigned int width, unsigned int height,
-							 ColorMode mode, unsigned int bpp,
-							 unsigned int slot);
-	/*------------------------------------------------------
-	 * Pre  : image must be a valid pixmap that agrees
-	 *        with mode, width, and height, slot ( ID )
-	 *
-	 * Post : Returns texture id or < 0 error flag
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.09.05:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	int loadColorTexture(unsigned char rgba[4],
-								unsigned int width, unsigned int height);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Generates and loads a solid color texture,
-	 *        returns texture Id or -1 if failed
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2003.06.30:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	int loadFontTTF(const char *filename,
-						 unsigned int utf8Offset, unsigned int count);
-	/*------------------------------------------------------
-	 * Pre  : <Filename> of TTF font
-	 *        <Utf8Offset> is offset into UNICODE table
-	 *        <Count> is number of glyphs to load
-	 *
-	 * Post : Loads a TTF,
-	 *        Generates: texture image, glyph list, and drawlist
-	 *
-	 *        Returns font id if sucessful, or < 0 if error
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2003.07.05:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	int loadPNG(const char *filename);
-	/*------------------------------------------------------
-	 * Pre  : Texture is init and filename/file is valid
-	 * Post : Loads PNG as texture and returns ID or -1 error
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.06.16:
-	 * Mongoose - Created, from Freyja
-	 ------------------------------------------------------*/
-
-	int loadTGA(const char *filename);
-	/*------------------------------------------------------
-	 * Pre  : Texture is init and filename/file is valid
-	 * Post : Loads TGA as texture and returns ID or -1 error
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.06.16:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
+                             unsigned int width, unsigned int height,
+                             ColorMode mode, unsigned int bpp,
+                             unsigned int slot);
+    /*------------------------------------------------------
+     * Pre  : image must be a valid pixmap that agrees
+     *        with mode, width, and height, slot ( ID )
+     *
+     * Post : Returns texture id or < 0 error flag
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.09.05:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    int loadColorTexture(unsigned char rgba[4],
+                                unsigned int width, unsigned int height);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Generates and loads a solid color texture,
+     *        returns texture Id or -1 if failed
+     *
+     *-- History ------------------------------------------
+     *
+     * 2003.06.30:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    int loadFontTTF(const char *filename,
+                         unsigned int utf8Offset, unsigned int count);
+    /*------------------------------------------------------
+     * Pre  : <Filename> of TTF font
+     *        <Utf8Offset> is offset into UNICODE table
+     *        <Count> is number of glyphs to load
+     *
+     * Post : Loads a TTF,
+     *        Generates: texture image, glyph list, and drawlist
+     *
+     *        Returns font id if sucessful, or < 0 if error
+     *
+     *-- History ------------------------------------------
+     *
+     * 2003.07.05:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    int loadPNG(const char *filename);
+    /*------------------------------------------------------
+     * Pre  : Texture is init and filename/file is valid
+     * Post : Loads PNG as texture and returns ID or -1 error
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.06.16:
+     * Mongoose - Created, from Freyja
+     ------------------------------------------------------*/
+
+    int loadTGA(const char *filename);
+    /*------------------------------------------------------
+     * Pre  : Texture is init and filename/file is valid
+     * Post : Loads TGA as texture and returns ID or -1 error
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.06.16:
+     * Mongoose - Created
+     ------------------------------------------------------*/
 
    void reset();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Resets all texture data
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.05.29:
-	 * Mongoose - Big code clean up, documentation
-	 *
-	 * 2000.10.05:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void setFlag(TextureFlag flag);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Sets a option flag
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2003.01.05:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void setMaxTextureCount(unsigned int n);
-	/*------------------------------------------------------
-	 * Pre  : n is max number of textures you wish to allow
-	 * Post : Sets up GL texturing, and must be called
-	 *        as the first setup step
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2001.05.29:
-	 * Mongoose - Big code clean up, documentation
-	 *
-	 * 2000.10.05:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void useMultiTexture(float u, float v);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post :
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.24:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void useMultiTexture(float aU, float aV, float bU, float bV);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post :
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.24:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Resets all texture data
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.05.29:
+     * Mongoose - Big code clean up, documentation
+     *
+     * 2000.10.05:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void setFlag(TextureFlag flag);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Sets a option flag
+     *
+     *-- History ------------------------------------------
+     *
+     * 2003.01.05:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void setMaxTextureCount(unsigned int n);
+    /*------------------------------------------------------
+     * Pre  : n is max number of textures you wish to allow
+     * Post : Sets up GL texturing, and must be called
+     *        as the first setup step
+     *
+     *-- History ------------------------------------------
+     *
+     * 2001.05.29:
+     * Mongoose - Big code clean up, documentation
+     *
+     * 2000.10.05:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void useMultiTexture(float u, float v);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post :
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.24:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void useMultiTexture(float aU, float aV, float bU, float bV);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post :
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.24:
+     * Mongoose - Created
+     ------------------------------------------------------*/
 
 
  private:
 
-	////////////////////////////////////////////////////////////
-	// Private Accessors
-	////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////
+    // Private Accessors
+    ////////////////////////////////////////////////////////////
 
-	int nextPower(int seed);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post :
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.06.16:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
+    int nextPower(int seed);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post :
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.06.16:
+     * Mongoose - Created
+     ------------------------------------------------------*/
 
-	unsigned char *scaleBuffer(unsigned char *image, int width, int height,
-										int components);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post :
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.06.16:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
+    unsigned char *scaleBuffer(unsigned char *image, int width, int height,
+                                        int components);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post :
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.06.16:
+     * Mongoose - Created
+     ------------------------------------------------------*/
 
 
-	////////////////////////////////////////////////////////////
-	// Private Mutators
-	////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////
+    // Private Mutators
+    ////////////////////////////////////////////////////////////
 
-   unsigned int *mTextureIds;		/* GL texture list */
+   unsigned int *mTextureIds;       /* GL texture list */
 
-   unsigned int mTextureCount;	/* Texture counter */
+   unsigned int mTextureCount;  /* Texture counter */
 
-   unsigned int mTextureLimit;	/* The texture limit */
+   unsigned int mTextureLimit;  /* The texture limit */
 
-	unsigned int mFlags;				/* Class options */
+    unsigned int mFlags;                /* Class options */
 
-   int mTextureId;					/* Currently bound texture id */
+   int mTextureId;                  /* Currently bound texture id */
 
-	int mTextureId2;					/* Multitexture Texture Id */
+    int mTextureId2;                    /* Multitexture Texture Id */
 };
 
 
@@ -480,31 +480,31 @@ class Texture
 void bufferedPrintf(char *string, unsigned int len, char *s, ...);
 
 void glPrint3d(float x, float y, float z,
-					float pitch, float yaw, float roll,
-					float scale,
-					char *string);
+                    float pitch, float yaw, float roll,
+                    float scale,
+                    char *string);
 
 void glPrint2d(float x, float y, float scale, char *string);
 
-	void glEnterMode2d(unsigned int width, unsigned int height);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : OpenGL ortho projection
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2003.06.03:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void glExitMode2d();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : OpenGL model matrix projection
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2003.06.03:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
+    void glEnterMode2d(unsigned int width, unsigned int height);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : OpenGL ortho projection
+     *
+     *-- History ------------------------------------------
+     *
+     * 2003.06.03:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void glExitMode2d();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : OpenGL model matrix projection
+     *
+     *-- History ------------------------------------------
+     *
+     * 2003.06.03:
+     * Mongoose - Created
+     ------------------------------------------------------*/
 #endif

include/TombRaider1.h

@@ -26,38 +26,38 @@ class TombRaider1
 {
 public:
 
-	TombRaider1();
+    TombRaider1();
 
-	~TombRaider1();
+    ~TombRaider1();
 
-	enum Items
+    enum Items
    {
-		Lara = 0,
-		PistolAnimation  = 1,
-		ShotgunAnimation = 2,
-		MagnumAnimation = 3,
-		LaraAlternate = 4, // Lara's home appearance, wounded, or turned to gold
-		UziAnimation = 5,
-		LaraMutant = 6,
-		Wolf = 7,
-		Bear = 8,
-		Bat = 9
-	};
+        Lara = 0,
+        PistolAnimation  = 1,
+        ShotgunAnimation = 2,
+        MagnumAnimation = 3,
+        LaraAlternate = 4, // Lara's home appearance, wounded, or turned to gold
+        UziAnimation = 5,
+        LaraMutant = 6,
+        Wolf = 7,
+        Bear = 8,
+        Bat = 9
+    };
 
-	enum WolfStates
-	{
-		WolfState_Walking   = 1,
-		WolfState_Running   = 2,
-		WolfState_Jumping   = 3,
-		WolfState_Stalking  = 5,
-		WolfState_JumpingAttack   = 6,
-		WolfState_Attacking = 7,
-		WolfState_Lying     = 8,  // down
-		WolfState_Getting   = 9,  // ready to strike
-		WolfState_RunningJump   = 10,
-		WolfState_Dying     = 11,
-		WolfState_Biting    = 12
-	};
+    enum WolfStates
+    {
+        WolfState_Walking   = 1,
+        WolfState_Running   = 2,
+        WolfState_Jumping   = 3,
+        WolfState_Stalking  = 5,
+        WolfState_JumpingAttack   = 6,
+        WolfState_Attacking = 7,
+        WolfState_Lying     = 8,  // down
+        WolfState_Getting   = 9,  // ready to strike
+        WolfState_RunningJump   = 10,
+        WolfState_Dying     = 11,
+        WolfState_Biting    = 12
+    };
 };
 
 #ifdef FIXME_DONT_COMPILE

include/TombRaider5.h

@@ -20,471 +20,471 @@
 
 typedef enum
 {
-		TR4_OBJ_LARA = 0,
-		TR4_OBJ_PISTOLS_ANIM = 1,
-		TR4_OBJ_UZI_ANIM = 2,
-		TR4_OBJ_SHOTGUN_ANIM = 3,
-		TR4_OBJ_CROSSBOW_ANIM = 4,
-		TR4_OBJ_GRENADE_GUN_ANIM = 5,
-		TR4_OBJ_SIXSHOOTER_ANIM = 6,
-		TR4_OBJ_FLARE_ANIM = 7,
-		TR4_OBJ_LARA_SKIN = 8,
-		TR4_OBJ_LARA_SKIN_JOINTS = 9,
-		TR4_OBJ_LARA_SCREAM = 10,
-		TR4_OBJ_LARA_CROSSBOW_LASER = 11,
-		TR4_OBJ_LARA_REVOLVER_LASER = 12,
-		TR4_OBJ_LARA_HOLSTERS = 13,
-		TR4_OBJ_LARA_HOLSTERS_PISTOLS = 14,
-		TR4_OBJ_LARA_HOLSTERS_UZIS = 15,
-		TR4_OBJ_LARA_HOLSTERS_SIXSHOOTER = 16,
-		TR4_OBJ_LARA_SPEECH_HEAD1 = 17,
-		TR4_OBJ_LARA_SPEECH_HEAD2 = 18,
-		TR4_OBJ_LARA_SPEECH_HEAD3 = 19,
-		TR4_OBJ_LARA_SPEECH_HEAD4 = 20,
-		TR4_OBJ_ACTOR1_SPEECH_HEAD1 = 21,
-		TR4_OBJ_ACTOR1_SPEECH_HEAD2 = 22,
-		TR4_OBJ_ACTOR2_SPEECH_HEAD1 = 23,
-		TR4_OBJ_ACTOR2_SPEECH_HEAD2 = 24,
-		TR4_OBJ_LARA_WATER_MESH = 25,
-		TR4_OBJ_LARA_PETROL_MESH = 26,
-		TR4_OBJ_LARA_DIRT_MESH = 27,
-		TR4_OBJ_CROWBAR_ANIM = 28,
-		TR4_OBJ_TORCH_ANIM = 29,
-		TR4_OBJ_HAIR = 30,
-		TR4_OBJ_MOTORBIKE = 31,
-		TR4_OBJ_JEEP = 32,
-		TR4_OBJ_VEHICLE_EXTRA = 33,
-		TR4_OBJ_ENEMY_JEEP = 34,
-		TR4_OBJ_SKELETON = 35,
-		TR4_OBJ_SKELETON_MIP = 36,
-		TR4_OBJ_GUIDE = 37,
-		TR4_OBJ_GUIDE_MIP = 38,
-		TR4_OBJ_VON_CROY = 39,
-		TR4_OBJ_VON_CROY_MIP = 40,
-		TR4_OBJ_BADDY_1 = 41,
-		TR4_OBJ_BADDY_1_MIP = 42,
-		TR4_OBJ_BADDY_2 = 43,
-		TR4_OBJ_BADDY_2_MIP = 44,
-		TR4_OBJ_SETHA = 45,
-		TR4_OBJ_SETHA_MIP = 46,
-		TR4_OBJ_MUMMY = 47,
-		TR4_OBJ_MUMMY_MIP = 48,
-		TR4_OBJ_SPHINX = 49,
-		TR4_OBJ_SPHINX_MIP = 50,
-		TR4_OBJ_CROCODILE = 51,
-		TR4_OBJ_CROCODILE_MIP = 52,
-		TR4_OBJ_HORSEMAN = 53,
-		TR4_OBJ_HORSEMAN_MIP = 54,
-		TR4_OBJ_SCORPION = 55,
-		TR4_OBJ_SCORPION_MIP = 56,
-		TR4_OBJ_JEAN_YVES = 57,
-		TR4_OBJ_JEAN_YVES_MIP = 58,
-		TR4_OBJ_TROOPS = 59,
-		TR4_OBJ_TROOPS_MIP = 60,
-		TR4_OBJ_KNIGHTS_TEMPLAR = 61,
-		TR4_OBJ_KNIGHTS_TEMPLAR_MIP = 62,
-		TR4_OBJ_MUTANT = 63,
-		TR4_OBJ_MUTANT_MIP = 64,
-		TR4_OBJ_HORSE = 65,
-		TR4_OBJ_HORSE_MIP = 66,
-		TR4_OBJ_BABOON_NORMAL = 67,
-		TR4_OBJ_BABOON_NORMAL_MIP = 68,
-		TR4_OBJ_BABOON_INV = 69,
-		TR4_OBJ_BABOON_INV_MIP = 70,
-		TR4_OBJ_BABOON_SILENT = 71,
-		TR4_OBJ_BABOON_SILENT_MIP = 72,
-		TR4_OBJ_WILD_BOAR = 73,
-		TR4_OBJ_WILD_BOAR_MIP = 74,
-		TR4_OBJ_HARPY = 75,
-		TR4_OBJ_HARPY_MIP = 76,
-		TR4_OBJ_DEMIGOD1 = 77,
-		TR4_OBJ_DEMIGOD1_MIP = 78,
-		TR4_OBJ_DEMIGOD2 = 79,
-		TR4_OBJ_DEMIGOD2_MIP = 80,
-		TR4_OBJ_DEMIGOD3 = 81,
-		TR4_OBJ_DEMIGOD3_MIP = 82,
-		TR4_OBJ_LITTLE_BEETLE = 83,
-		TR4_OBJ_BIG_BEETLE = 84,
-		TR4_OBJ_BIG_BEETLE_MIP = 85,
-		TR4_OBJ_WRAITH1 = 86,
-		TR4_OBJ_WRAITH2 = 87,
-		TR4_OBJ_WRAITH3 = 88,
-		TR4_OBJ_WRAITH4 = 89,
-		TR4_OBJ_BAT = 90,
-		TR4_OBJ_DOG = 91,
-		TR4_OBJ_DOG_MIP = 92,
-		TR4_OBJ_HAMMERHEAD = 93,
-		TR4_OBJ_HAMMERHEAD_MIP = 94,
-		TR4_OBJ_SAS = 95,
-		TR4_OBJ_SAS_MIP = 96,
-		TR4_OBJ_SAS_DYING = 97,
-		TR4_OBJ_SAS_DYING_MIP = 98,
-		TR4_OBJ_SAS_CAPTAIN = 99,
-		TR4_OBJ_SAS_CAPTAIN_MIP = 100,
-		TR4_OBJ_SAS_DRAG_BLOKE = 101,
-		TR4_OBJ_AHMET = 102,
-		TR4_OBJ_AHMET_MIP = 103,
-		TR4_OBJ_LARA_DOUBLE = 104,
-		TR4_OBJ_LARA_DOUBLE_MIP = 105,
-		TR4_OBJ_SMALL_SCORPION = 106,
-		TR4_OBJ_FISH = 107,
-		TR4_OBJ_GAME_PIECE1 = 108,
-		TR4_OBJ_GAME_PIECE2 = 109,
-		TR4_OBJ_GAME_PIECE3 = 110,
-		TR4_OBJ_ENEMY_PIECE = 111,
-		TR4_OBJ_WHEEL_OF_FORTUNE = 112,
-		TR4_OBJ_SCALES = 113,
-		TR4_OBJ_DARTS = 114,
-		TR4_OBJ_DART_EMITTER = 115,
-		TR4_OBJ_HOMING_DART_EMITTER = 116,
-		TR4_OBJ_FALLING_CEILING = 117,
-		TR4_OBJ_FALLING_BLOCK = 118,
-		TR4_OBJ_FALLING_BLOCK2 = 119,
-		TR4_OBJ_SMASHABLE_BIKE_WALL = 120,
-		TR4_OBJ_SMASHABLE_BIKE_FLOOR = 121,
-		TR4_OBJ_TRAPDOOR1 = 122,
-		TR4_OBJ_TRAPDOOR2 = 123,
-		TR4_OBJ_TRAPDOOR3 = 124,
-		TR4_OBJ_FLOOR_TRAPDOOR1 = 125,
-		TR4_OBJ_FLOOR_TRAPDOOR2 = 126,
-		TR4_OBJ_CEILING_TRAPDOOR1 = 127,
-		TR4_OBJ_CEILING_TRAPDOOR2 = 128,
-		TR4_OBJ_SCALING_TRAPDOOR = 129,
-		TR4_OBJ_ROLLINGBALL = 130,
-		TR4_OBJ_SPIKEY_FLOOR = 131,
-		TR4_OBJ_TEETH_SPIKES = 132,
-		TR4_OBJ_JOBY_SPIKES = 133,
-		TR4_OBJ_SLICER_DICER = 134,
-		TR4_OBJ_CHAIN = 135,
-		TR4_OBJ_PLOUGH = 136,
-		TR4_OBJ_STARGATE = 137,
-		TR4_OBJ_HAMMER = 138,
-		TR4_OBJ_BURNING_FLOOR = 139,
-		TR4_OBJ_COG = 140,
-		TR4_OBJ_SPIKEBALL = 141,
-		TR4_OBJ_FLAME = 142,
-		TR4_OBJ_FLAME_EMITTER = 143,
-		TR4_OBJ_FLAME_EMITTER2 = 144,
-		TR4_OBJ_FLAME_EMITTER3 = 145,
-		TR4_OBJ_ROPE = 146,
-		TR4_OBJ_FIREROPE = 147,
-		TR4_OBJ_POLEROPE = 148,
-		TR4_OBJ_ONEBLOCK_PLATFORM = 149,
-		TR4_OBJ_TWOBLOCK_PLATFORM = 150,
-		TR4_OBJ_RAISING_BLOCK1 = 151,
-		TR4_OBJ_RAISING_BLOCK2 = 152,
-		TR4_OBJ_EXPANDING_PLATFORM = 153,
-		TR4_OBJ_SQUISHY_BLOCK1 = 154,
-		TR4_OBJ_SQUISHY_BLOCK2 = 155,
-		TR4_OBJ_PUSHABLE_OBJECT1 = 156,
-		TR4_OBJ_PUSHABLE_OBJECT2 = 157,
-		TR4_OBJ_PUSHABLE_OBJECT3 = 158,
-		TR4_OBJ_PUSHABLE_OBJECT4 = 159,
-		TR4_OBJ_PUSHABLE_OBJECT5 = 160,
-		TR4_OBJ_TRIPWIRE = 161,
-		TR4_OBJ_SENTRY_GUN = 162,
-		TR4_OBJ_MINE = 163,
-		TR4_OBJ_MAPPER = 164,
-		TR4_OBJ_OBELISK = 165,
-		TR4_OBJ_FLOOR_4BLADE = 166,
-		TR4_OBJ_ROOF_4BLADE = 167,
-		TR4_OBJ_BIRD_BLADE = 168,
-		TR4_OBJ_CATWALK_BLADE = 169,
-		TR4_OBJ_MOVING_BLADE = 170,
-		TR4_OBJ_PLINTH_BLADE = 171,
-		TR4_OBJ_SETH_BLADE = 172,
-		TR4_OBJ_LIGHTNING_CONDUCTOR = 173,
-		TR4_OBJ_ELEMENT_PUZZLE = 174,
-		TR4_OBJ_PUZZLE_ITEM1 = 175,
-		TR4_OBJ_PUZZLE_ITEM2 = 176,
-		TR4_OBJ_PUZZLE_ITEM3 = 177,
-		TR4_OBJ_PUZZLE_ITEM4 = 178,
-		TR4_OBJ_PUZZLE_ITEM5 = 179,
-		TR4_OBJ_PUZZLE_ITEM6 = 180,
-		TR4_OBJ_PUZZLE_ITEM7 = 181,
-		TR4_OBJ_PUZZLE_ITEM8 = 182,
-		TR4_OBJ_PUZZLE_ITEM9 = 183,
-		TR4_OBJ_PUZZLE_ITEM10 = 184,
-		TR4_OBJ_PUZZLE_ITEM11 = 185,
-		TR4_OBJ_PUZZLE_ITEM12 = 186,
-		TR4_OBJ_PUZZLE_ITEM1_COMBO1 = 187,
-		TR4_OBJ_PUZZLE_ITEM1_COMBO2 = 188,
-		TR4_OBJ_PUZZLE_ITEM2_COMBO1 = 189,
-		TR4_OBJ_PUZZLE_ITEM2_COMBO2 = 190,
-		TR4_OBJ_PUZZLE_ITEM3_COMBO1 = 191,
-		TR4_OBJ_PUZZLE_ITEM3_COMBO2 = 192,
-		TR4_OBJ_PUZZLE_ITEM4_COMBO1 = 193,
-		TR4_OBJ_PUZZLE_ITEM4_COMBO2 = 194,
-		TR4_OBJ_PUZZLE_ITEM5_COMBO1 = 195,
-		TR4_OBJ_PUZZLE_ITEM5_COMBO2 = 196,
-		TR4_OBJ_PUZZLE_ITEM6_COMBO1 = 197,
-		TR4_OBJ_PUZZLE_ITEM6_COMBO2 = 198,
-		TR4_OBJ_PUZZLE_ITEM7_COMBO1 = 199,
-		TR4_OBJ_PUZZLE_ITEM7_COMBO2 = 200,
-		TR4_OBJ_PUZZLE_ITEM8_COMBO1 = 201,
-		TR4_OBJ_PUZZLE_ITEM8_COMBO2 = 202,
-		TR4_OBJ_KEY_ITEM1 = 203,
-		TR4_OBJ_KEY_ITEM2 = 204,
-		TR4_OBJ_KEY_ITEM3 = 205,
-		TR4_OBJ_KEY_ITEM4 = 206,
-		TR4_OBJ_KEY_ITEM5 = 207,
-		TR4_OBJ_KEY_ITEM6 = 208,
-		TR4_OBJ_KEY_ITEM7 = 209,
-		TR4_OBJ_KEY_ITEM8 = 210,
-		TR4_OBJ_KEY_ITEM9 = 211,
-		TR4_OBJ_KEY_ITEM10 = 212,
-		TR4_OBJ_KEY_ITEM11 = 213,
-		TR4_OBJ_KEY_ITEM12 = 214,
-		TR4_OBJ_KEY_ITEM1_COMBO1 = 215,
-		TR4_OBJ_KEY_ITEM1_COMBO2 = 216,
-		TR4_OBJ_KEY_ITEM2_COMBO1 = 217,
-		TR4_OBJ_KEY_ITEM2_COMBO2 = 218,
-		TR4_OBJ_KEY_ITEM3_COMBO1 = 219,
-		TR4_OBJ_KEY_ITEM3_COMBO2 = 220,
-		TR4_OBJ_KEY_ITEM4_COMBO1 = 221,
-		TR4_OBJ_KEY_ITEM4_COMBO2 = 222,
-		TR4_OBJ_KEY_ITEM5_COMBO1 = 223,
-		TR4_OBJ_KEY_ITEM5_COMBO2 = 224,
-		TR4_OBJ_KEY_ITEM6_COMBO1 = 225,
-		TR4_OBJ_KEY_ITEM6_COMBO2 = 226,
-		TR4_OBJ_KEY_ITEM7_COMBO1 = 227,
-		TR4_OBJ_KEY_ITEM7_COMBO2 = 228,
-		TR4_OBJ_KEY_ITEM8_COMBO1 = 229,
-		TR4_OBJ_KEY_ITEM8_COMBO2 = 230,
-		TR4_OBJ_PICKUP_ITEM1 = 231,
-		TR4_OBJ_PICKUP_ITEM2 = 232,
-		TR4_OBJ_PICKUP_ITEM3 = 233,
-		TR4_OBJ_PICKUP_ITEM4 = 234,
-		TR4_OBJ_PICKUP_ITEM1_COMBO1 = 235,
-		TR4_OBJ_PICKUP_ITEM1_COMBO2 = 236,
-		TR4_OBJ_PICKUP_ITEM2_COMBO1 = 237,
-		TR4_OBJ_PICKUP_ITEM2_COMBO2 = 238,
-		TR4_OBJ_PICKUP_ITEM3_COMBO1 = 239,
-		TR4_OBJ_PICKUP_ITEM3_COMBO2 = 240,
-		TR4_OBJ_PICKUP_ITEM4_COMBO1 = 241,
-		TR4_OBJ_PICKUP_ITEM4_COMBO2 = 242,
-		TR4_OBJ_EXAMINE1 = 243,
-		TR4_OBJ_EXAMINE2 = 244,
-		TR4_OBJ_EXAMINE3 = 245,
-		TR4_OBJ_CROWBAR_ITEM = 246,
-		TR4_OBJ_BURNING_TORCH_ITEM = 247,
-		TR4_OBJ_CLOCKWORK_BEETLE = 248,
-		TR4_OBJ_CLOCKWORK_BEETLE_COMBO1 = 249,
-		TR4_OBJ_CLOCKWORK_BEETLE_COMBO2 = 250,
-		TR4_OBJ_MINE_DETECTOR = 251,
-		TR4_OBJ_QUEST_ITEM1 = 252,
-		TR4_OBJ_QUEST_ITEM2 = 253,
-		TR4_OBJ_QUEST_ITEM3 = 254,
-		TR4_OBJ_QUEST_ITEM4 = 255,
-		TR4_OBJ_QUEST_ITEM5 = 256,
-		TR4_OBJ_QUEST_ITEM6 = 257,
-		TR4_OBJ_MAP = 258,
-		TR4_OBJ_SECRET_MAP = 259,
-		TR4_OBJ_PUZZLE_HOLE1 = 260,
-		TR4_OBJ_PUZZLE_HOLE2 = 261,
-		TR4_OBJ_PUZZLE_HOLE3 = 262,
-		TR4_OBJ_PUZZLE_HOLE4 = 263,
-		TR4_OBJ_PUZZLE_HOLE5 = 264,
-		TR4_OBJ_PUZZLE_HOLE6 = 265,
-		TR4_OBJ_PUZZLE_HOLE7 = 266,
-		TR4_OBJ_PUZZLE_HOLE8 = 267,
-		TR4_OBJ_PUZZLE_HOLE9 = 268,
-		TR4_OBJ_PUZZLE_HOLE10 = 269,
-		TR4_OBJ_PUZZLE_HOLE11 = 270,
-		TR4_OBJ_PUZZLE_HOLE12 = 271,
-		TR4_OBJ_PUZZLE_DONE1 = 272,
-		TR4_OBJ_PUZZLE_DONE2 = 273,
-		TR4_OBJ_PUZZLE_DONE3 = 274,
-		TR4_OBJ_PUZZLE_DONE4 = 275,
-		TR4_OBJ_PUZZLE_DONE5 = 276,
-		TR4_OBJ_PUZZLE_DONE6 = 277,
-		TR4_OBJ_PUZZLE_DONE7 = 278,
-		TR4_OBJ_PUZZLE_DONE8 = 279,
-		TR4_OBJ_PUZZLE_DONE9 = 280,
-		TR4_OBJ_PUZZLE_DONE10 = 281,
-		TR4_OBJ_PUZZLE_DONE11 = 282,
-		TR4_OBJ_PUZZLE_DONE12 = 283,
-		TR4_OBJ_KEY_HOLE1 = 284,
-		TR4_OBJ_KEY_HOLE2 = 285,
-		TR4_OBJ_KEY_HOLE3 = 286,
-		TR4_OBJ_KEY_HOLE4 = 287,
-		TR4_OBJ_KEY_HOLE5 = 288,
-		TR4_OBJ_KEY_HOLE6 = 289,
-		TR4_OBJ_KEY_HOLE7 = 290,
-		TR4_OBJ_KEY_HOLE8 = 291,
-		TR4_OBJ_KEY_HOLE9 = 292,
-		TR4_OBJ_KEY_HOLE10 = 293,
-		TR4_OBJ_KEY_HOLE11 = 294,
-		TR4_OBJ_KEY_HOLE12 = 295,
-		TR4_OBJ_WATERSKIN1_EMPTY = 296,
-		TR4_OBJ_WATERSKIN1_1 = 297,
-		TR4_OBJ_WATERSKIN1_2 = 298,
-		TR4_OBJ_WATERSKIN1_3 = 299,
-		TR4_OBJ_WATERSKIN2_EMPTY = 300,
-		TR4_OBJ_WATERSKIN2_1 = 301,
-		TR4_OBJ_WATERSKIN2_2 = 302,
-		TR4_OBJ_WATERSKIN2_3 = 303,
-		TR4_OBJ_WATERSKIN2_4 = 304,
-		TR4_OBJ_WATERSKIN2_5 = 305,
-		TR4_OBJ_SWITCH_TYPE1 = 306,
-		TR4_OBJ_SWITCH_TYPE2 = 307,
-		TR4_OBJ_SWITCH_TYPE3 = 308,
-		TR4_OBJ_SWITCH_TYPE4 = 309,
-		TR4_OBJ_SWITCH_TYPE5 = 310,
-		TR4_OBJ_SWITCH_TYPE6 = 311,
-		TR4_OBJ_SWITCH_TYPE7 = 312,
-		TR4_OBJ_SWITCH_TYPE8 = 313,
-		TR4_OBJ_UNDERWATER_SWITCH1 = 314,
-		TR4_OBJ_UNDERWATER_SWITCH2 = 315,
-		TR4_OBJ_TURN_SWITCH = 316,
-		TR4_OBJ_COG_SWITCH = 317,
-		TR4_OBJ_LEVER_SWITCH = 318,
-		TR4_OBJ_JUMP_SWITCH = 319,
-		TR4_OBJ_CROWBAR_SWITCH = 320,
-		TR4_OBJ_PULLEY = 321,
-		TR4_OBJ_DOOR_TYPE1 = 322,
-		TR4_OBJ_DOOR_TYPE2 = 323,
-		TR4_OBJ_DOOR_TYPE3 = 324,
-		TR4_OBJ_DOOR_TYPE4 = 325,
-		TR4_OBJ_DOOR_TYPE5 = 326,
-		TR4_OBJ_DOOR_TYPE6 = 327,
-		TR4_OBJ_DOOR_TYPE7 = 328,
-		TR4_OBJ_DOOR_TYPE8 = 329,
-		TR4_OBJ_PUSHPULL_DOOR1 = 330,
-		TR4_OBJ_PUSHPULL_DOOR2 = 331,
-		TR4_OBJ_KICK_DOOR1 = 332,
-		TR4_OBJ_KICK_DOOR2 = 333,
-		TR4_OBJ_UNDERWATER_DOOR = 334,
-		TR4_OBJ_DOUBLE_DOORS = 335,
-		TR4_OBJ_BRIDGE_FLAT = 336,
-		TR4_OBJ_BRIDGE_TILT1 = 337,
-		TR4_OBJ_BRIDGE_TILT2 = 338,
-		TR4_OBJ_SARCOPHAGUS = 339,
-		TR4_OBJ_SEQUENCE_DOOR1 = 340,
-		TR4_OBJ_SEQUENCE_SWITCH1 = 341,
-		TR4_OBJ_SEQUENCE_SWITCH2 = 342,
-		TR4_OBJ_SEQUENCE_SWITCH3 = 343,
-		TR4_OBJ_SARCOPHAGUS_CUT = 344,
-		TR4_OBJ_HORUS_STATUE = 345,
-		TR4_OBJ_GOD_HEAD = 346,
-		TR4_OBJ_SETH_DOOR = 347,
-		TR4_OBJ_STATUE_PLINTH = 348,
-		TR4_OBJ_PISTOLS_ITEM = 349,
-		TR4_OBJ_PISTOLS_AMMO_ITEM = 350,
-		TR4_OBJ_UZI_ITEM = 351,
-		TR4_OBJ_UZI_AMMO_ITEM = 352,
-		TR4_OBJ_SHOTGUN_ITEM = 353,
-		TR4_OBJ_SHOTGUN_AMMO1_ITEM = 354,
-		TR4_OBJ_SHOTGUN_AMMO2_ITEM = 355,
-		TR4_OBJ_CROSSBOW_ITEM = 356,
-		TR4_OBJ_CROSSBOW_AMMO1_ITEM = 357,
-		TR4_OBJ_CROSSBOW_AMMO2_ITEM = 358,
-		TR4_OBJ_CROSSBOW_AMMO3_ITEM = 359,
-		TR4_OBJ_CROSSBOW_BOLT = 360,
-		TR4_OBJ_GRENADE_GUN_ITEM = 361,
-		TR4_OBJ_GRENADE_GUN_AMMO1_ITEM = 362,
-		TR4_OBJ_GRENADE_GUN_AMMO2_ITEM = 363,
-		TR4_OBJ_GRENADE_GUN_AMMO3_ITEM = 364,
-		TR4_OBJ_GRENADE = 365,
-		TR4_OBJ_SIXSHOOTER_ITEM = 366,
-		TR4_OBJ_SIXSHOOTER_AMMO_ITEM = 367,
-		TR4_OBJ_BIGMEDI_ITEM = 368,
-		TR4_OBJ_SMALLMEDI_ITEM = 369,
-		TR4_OBJ_LASERSIGHT_ITEM = 370,
-		TR4_OBJ_BINOCULARS_ITEM = 371,
-		TR4_OBJ_FLARE_ITEM = 372,
-		TR4_OBJ_FLARE_INV_ITEM = 373,
-		TR4_OBJ_DIARY_ITEM = 374,
-		TR4_OBJ_COMPASS_ITEM = 375,
-		TR4_OBJ_MEMCARD_LOAD_INV_ITEM = 376,
-		TR4_OBJ_MEMCARD_SAVE_INV_ITEM = 377,
-		TR4_OBJ_PC_LOAD_INV_ITEM = 378,
-		TR4_OBJ_PC_SAVE_INV_ITEM = 379,
-		TR4_OBJ_SMOKE_EMITTER_WHITE = 380,
-		TR4_OBJ_SMOKE_EMITTER_BLACK = 381,
-		TR4_OBJ_STEAM_EMITTER = 382,
-		TR4_OBJ_EARTHQUAKE = 383,
-		TR4_OBJ_BUBBLES = 384,
-		TR4_OBJ_WATERFALLMIST = 385,
-		TR4_OBJ_GUNSHELL = 386,
-		TR4_OBJ_SHOTGUNSHELL = 387,
-		TR4_OBJ_GUN_FLASH = 388,
-		TR4_OBJ_BUTTERFLY = 389,
-		TR4_OBJ_SPRINKLER = 390,
-		TR4_OBJ_RED_LIGHT = 391,
-		TR4_OBJ_GREEN_LIGHT = 392,
-		TR4_OBJ_BLUE_LIGHT = 393,
-		TR4_OBJ_AMBER_LIGHT = 394,
-		TR4_OBJ_WHITE_LIGHT = 395,
-		TR4_OBJ_BLINKING_LIGHT = 396,
-		TR4_OBJ_LENS_FLARE = 397,
-		TR4_OBJ_AI_GUARD = 398,
-		TR4_OBJ_AI_AMBUSH = 399,
-		TR4_OBJ_AI_PATROL1 = 400,
-		TR4_OBJ_AI_MODIFY = 401,
-		TR4_OBJ_AI_FOLLOW = 402,
-		TR4_OBJ_AI_PATROL2 = 403,
-		TR4_OBJ_AI_X1 = 404,
-		TR4_OBJ_AI_X2 = 405,
-		TR4_OBJ_LARA_START_POS = 406,
-		TR4_OBJ_KILL_ALL_TRIGGERS = 407,
-		TR4_OBJ_TRIGGER_TRIGGERER = 408,
-		TR4_OBJ_SMASH_OBJECT1 = 409,
-		TR4_OBJ_SMASH_OBJECT2 = 410,
-		TR4_OBJ_SMASH_OBJECT3 = 411,
-		TR4_OBJ_SMASH_OBJECT4 = 412,
-		TR4_OBJ_SMASH_OBJECT5 = 413,
-		TR4_OBJ_SMASH_OBJECT6 = 414,
-		TR4_OBJ_SMASH_OBJECT7 = 415,
-		TR4_OBJ_SMASH_OBJECT8 = 416,
-		TR4_OBJ_MESHSWAP1 = 417,
-		TR4_OBJ_MESHSWAP2 = 418,
-		TR4_OBJ_MESHSWAP3 = 419,
-		TR4_OBJ_DEATH_SLIDE = 420,
-		TR4_OBJ_BODY_PART = 421,
-		TR4_OBJ_CAMERA_TARGET = 422,
-		TR4_OBJ_WATERFALL1 = 423,
-		TR4_OBJ_WATERFALL2 = 424,
-		TR4_OBJ_WATERFALL3 = 425,
-		TR4_OBJ_PLANET_EFFECT = 426,
-		TR4_OBJ_ANIMATING1 = 427,
-		TR4_OBJ_ANIMATING1_MIP = 428,
-		TR4_OBJ_ANIMATING2 = 429,
-		TR4_OBJ_ANIMATING2_MIP = 430,
-		TR4_OBJ_ANIMATING3 = 431,
-		TR4_OBJ_ANIMATING3_MIP = 432,
-		TR4_OBJ_ANIMATING4 = 433,
-		TR4_OBJ_ANIMATING4_MIP = 434,
-		TR4_OBJ_ANIMATING5 = 435,
-		TR4_OBJ_ANIMATING5_MIP = 436,
-		TR4_OBJ_ANIMATING6 = 437,
-		TR4_OBJ_ANIMATING6_MIP = 438,
-		TR4_OBJ_ANIMATING7 = 439,
-		TR4_OBJ_ANIMATING7_MIP = 440,
-		TR4_OBJ_ANIMATING8 = 441,
-		TR4_OBJ_ANIMATING8_MIP = 442,
-		TR4_OBJ_ANIMATING9 = 443,
-		TR4_OBJ_ANIMATING9_MIP = 444,
-		TR4_OBJ_ANIMATING10 = 445,
-		TR4_OBJ_ANIMATING10_MIP = 446,
-		TR4_OBJ_ANIMATING11 = 447,
-		TR4_OBJ_ANIMATING11_MIP = 448,
-		TR4_OBJ_ANIMATING12 = 449,
-		TR4_OBJ_ANIMATING12_MIP = 450,
-		TR4_OBJ_ANIMATING13 = 451,
-		TR4_OBJ_ANIMATING13_MIP = 452,
-		TR4_OBJ_ANIMATING14 = 453,
-		TR4_OBJ_ANIMATING14_MIP = 454,
-		TR4_OBJ_ANIMATING15 = 455,
-		TR4_OBJ_ANIMATING15_MIP = 456,
-		TR4_OBJ_ANIMATING16 = 457,
-		TR4_OBJ_ANIMATING16_MIP = 458,
-		TR4_OBJ_HORIZON = 459,
-		TR4_OBJ_SKY_GRAPHICS = 460,				   // Sprite (in SWD file)
-		TR4_OBJ_BINOCULAR_GRAPHICS = 461,
-		TR4_OBJ_TARGET_GRAPHICS = 462,
-		TR4_OBJ_DEFAULT_SPRITES = 463,				// Sprite (in SWD file)
-		TR4_OBJ_MISC_SPRITES = 464
+        TR4_OBJ_LARA = 0,
+        TR4_OBJ_PISTOLS_ANIM = 1,
+        TR4_OBJ_UZI_ANIM = 2,
+        TR4_OBJ_SHOTGUN_ANIM = 3,
+        TR4_OBJ_CROSSBOW_ANIM = 4,
+        TR4_OBJ_GRENADE_GUN_ANIM = 5,
+        TR4_OBJ_SIXSHOOTER_ANIM = 6,
+        TR4_OBJ_FLARE_ANIM = 7,
+        TR4_OBJ_LARA_SKIN = 8,
+        TR4_OBJ_LARA_SKIN_JOINTS = 9,
+        TR4_OBJ_LARA_SCREAM = 10,
+        TR4_OBJ_LARA_CROSSBOW_LASER = 11,
+        TR4_OBJ_LARA_REVOLVER_LASER = 12,
+        TR4_OBJ_LARA_HOLSTERS = 13,
+        TR4_OBJ_LARA_HOLSTERS_PISTOLS = 14,
+        TR4_OBJ_LARA_HOLSTERS_UZIS = 15,
+        TR4_OBJ_LARA_HOLSTERS_SIXSHOOTER = 16,
+        TR4_OBJ_LARA_SPEECH_HEAD1 = 17,
+        TR4_OBJ_LARA_SPEECH_HEAD2 = 18,
+        TR4_OBJ_LARA_SPEECH_HEAD3 = 19,
+        TR4_OBJ_LARA_SPEECH_HEAD4 = 20,
+        TR4_OBJ_ACTOR1_SPEECH_HEAD1 = 21,
+        TR4_OBJ_ACTOR1_SPEECH_HEAD2 = 22,
+        TR4_OBJ_ACTOR2_SPEECH_HEAD1 = 23,
+        TR4_OBJ_ACTOR2_SPEECH_HEAD2 = 24,
+        TR4_OBJ_LARA_WATER_MESH = 25,
+        TR4_OBJ_LARA_PETROL_MESH = 26,
+        TR4_OBJ_LARA_DIRT_MESH = 27,
+        TR4_OBJ_CROWBAR_ANIM = 28,
+        TR4_OBJ_TORCH_ANIM = 29,
+        TR4_OBJ_HAIR = 30,
+        TR4_OBJ_MOTORBIKE = 31,
+        TR4_OBJ_JEEP = 32,
+        TR4_OBJ_VEHICLE_EXTRA = 33,
+        TR4_OBJ_ENEMY_JEEP = 34,
+        TR4_OBJ_SKELETON = 35,
+        TR4_OBJ_SKELETON_MIP = 36,
+        TR4_OBJ_GUIDE = 37,
+        TR4_OBJ_GUIDE_MIP = 38,
+        TR4_OBJ_VON_CROY = 39,
+        TR4_OBJ_VON_CROY_MIP = 40,
+        TR4_OBJ_BADDY_1 = 41,
+        TR4_OBJ_BADDY_1_MIP = 42,
+        TR4_OBJ_BADDY_2 = 43,
+        TR4_OBJ_BADDY_2_MIP = 44,
+        TR4_OBJ_SETHA = 45,
+        TR4_OBJ_SETHA_MIP = 46,
+        TR4_OBJ_MUMMY = 47,
+        TR4_OBJ_MUMMY_MIP = 48,
+        TR4_OBJ_SPHINX = 49,
+        TR4_OBJ_SPHINX_MIP = 50,
+        TR4_OBJ_CROCODILE = 51,
+        TR4_OBJ_CROCODILE_MIP = 52,
+        TR4_OBJ_HORSEMAN = 53,
+        TR4_OBJ_HORSEMAN_MIP = 54,
+        TR4_OBJ_SCORPION = 55,
+        TR4_OBJ_SCORPION_MIP = 56,
+        TR4_OBJ_JEAN_YVES = 57,
+        TR4_OBJ_JEAN_YVES_MIP = 58,
+        TR4_OBJ_TROOPS = 59,
+        TR4_OBJ_TROOPS_MIP = 60,
+        TR4_OBJ_KNIGHTS_TEMPLAR = 61,
+        TR4_OBJ_KNIGHTS_TEMPLAR_MIP = 62,
+        TR4_OBJ_MUTANT = 63,
+        TR4_OBJ_MUTANT_MIP = 64,
+        TR4_OBJ_HORSE = 65,
+        TR4_OBJ_HORSE_MIP = 66,
+        TR4_OBJ_BABOON_NORMAL = 67,
+        TR4_OBJ_BABOON_NORMAL_MIP = 68,
+        TR4_OBJ_BABOON_INV = 69,
+        TR4_OBJ_BABOON_INV_MIP = 70,
+        TR4_OBJ_BABOON_SILENT = 71,
+        TR4_OBJ_BABOON_SILENT_MIP = 72,
+        TR4_OBJ_WILD_BOAR = 73,
+        TR4_OBJ_WILD_BOAR_MIP = 74,
+        TR4_OBJ_HARPY = 75,
+        TR4_OBJ_HARPY_MIP = 76,
+        TR4_OBJ_DEMIGOD1 = 77,
+        TR4_OBJ_DEMIGOD1_MIP = 78,
+        TR4_OBJ_DEMIGOD2 = 79,
+        TR4_OBJ_DEMIGOD2_MIP = 80,
+        TR4_OBJ_DEMIGOD3 = 81,
+        TR4_OBJ_DEMIGOD3_MIP = 82,
+        TR4_OBJ_LITTLE_BEETLE = 83,
+        TR4_OBJ_BIG_BEETLE = 84,
+        TR4_OBJ_BIG_BEETLE_MIP = 85,
+        TR4_OBJ_WRAITH1 = 86,
+        TR4_OBJ_WRAITH2 = 87,
+        TR4_OBJ_WRAITH3 = 88,
+        TR4_OBJ_WRAITH4 = 89,
+        TR4_OBJ_BAT = 90,
+        TR4_OBJ_DOG = 91,
+        TR4_OBJ_DOG_MIP = 92,
+        TR4_OBJ_HAMMERHEAD = 93,
+        TR4_OBJ_HAMMERHEAD_MIP = 94,
+        TR4_OBJ_SAS = 95,
+        TR4_OBJ_SAS_MIP = 96,
+        TR4_OBJ_SAS_DYING = 97,
+        TR4_OBJ_SAS_DYING_MIP = 98,
+        TR4_OBJ_SAS_CAPTAIN = 99,
+        TR4_OBJ_SAS_CAPTAIN_MIP = 100,
+        TR4_OBJ_SAS_DRAG_BLOKE = 101,
+        TR4_OBJ_AHMET = 102,
+        TR4_OBJ_AHMET_MIP = 103,
+        TR4_OBJ_LARA_DOUBLE = 104,
+        TR4_OBJ_LARA_DOUBLE_MIP = 105,
+        TR4_OBJ_SMALL_SCORPION = 106,
+        TR4_OBJ_FISH = 107,
+        TR4_OBJ_GAME_PIECE1 = 108,
+        TR4_OBJ_GAME_PIECE2 = 109,
+        TR4_OBJ_GAME_PIECE3 = 110,
+        TR4_OBJ_ENEMY_PIECE = 111,
+        TR4_OBJ_WHEEL_OF_FORTUNE = 112,
+        TR4_OBJ_SCALES = 113,
+        TR4_OBJ_DARTS = 114,
+        TR4_OBJ_DART_EMITTER = 115,
+        TR4_OBJ_HOMING_DART_EMITTER = 116,
+        TR4_OBJ_FALLING_CEILING = 117,
+        TR4_OBJ_FALLING_BLOCK = 118,
+        TR4_OBJ_FALLING_BLOCK2 = 119,
+        TR4_OBJ_SMASHABLE_BIKE_WALL = 120,
+        TR4_OBJ_SMASHABLE_BIKE_FLOOR = 121,
+        TR4_OBJ_TRAPDOOR1 = 122,
+        TR4_OBJ_TRAPDOOR2 = 123,
+        TR4_OBJ_TRAPDOOR3 = 124,
+        TR4_OBJ_FLOOR_TRAPDOOR1 = 125,
+        TR4_OBJ_FLOOR_TRAPDOOR2 = 126,
+        TR4_OBJ_CEILING_TRAPDOOR1 = 127,
+        TR4_OBJ_CEILING_TRAPDOOR2 = 128,
+        TR4_OBJ_SCALING_TRAPDOOR = 129,
+        TR4_OBJ_ROLLINGBALL = 130,
+        TR4_OBJ_SPIKEY_FLOOR = 131,
+        TR4_OBJ_TEETH_SPIKES = 132,
+        TR4_OBJ_JOBY_SPIKES = 133,
+        TR4_OBJ_SLICER_DICER = 134,
+        TR4_OBJ_CHAIN = 135,
+        TR4_OBJ_PLOUGH = 136,
+        TR4_OBJ_STARGATE = 137,
+        TR4_OBJ_HAMMER = 138,
+        TR4_OBJ_BURNING_FLOOR = 139,
+        TR4_OBJ_COG = 140,
+        TR4_OBJ_SPIKEBALL = 141,
+        TR4_OBJ_FLAME = 142,
+        TR4_OBJ_FLAME_EMITTER = 143,
+        TR4_OBJ_FLAME_EMITTER2 = 144,
+        TR4_OBJ_FLAME_EMITTER3 = 145,
+        TR4_OBJ_ROPE = 146,
+        TR4_OBJ_FIREROPE = 147,
+        TR4_OBJ_POLEROPE = 148,
+        TR4_OBJ_ONEBLOCK_PLATFORM = 149,
+        TR4_OBJ_TWOBLOCK_PLATFORM = 150,
+        TR4_OBJ_RAISING_BLOCK1 = 151,
+        TR4_OBJ_RAISING_BLOCK2 = 152,
+        TR4_OBJ_EXPANDING_PLATFORM = 153,
+        TR4_OBJ_SQUISHY_BLOCK1 = 154,
+        TR4_OBJ_SQUISHY_BLOCK2 = 155,
+        TR4_OBJ_PUSHABLE_OBJECT1 = 156,
+        TR4_OBJ_PUSHABLE_OBJECT2 = 157,
+        TR4_OBJ_PUSHABLE_OBJECT3 = 158,
+        TR4_OBJ_PUSHABLE_OBJECT4 = 159,
+        TR4_OBJ_PUSHABLE_OBJECT5 = 160,
+        TR4_OBJ_TRIPWIRE = 161,
+        TR4_OBJ_SENTRY_GUN = 162,
+        TR4_OBJ_MINE = 163,
+        TR4_OBJ_MAPPER = 164,
+        TR4_OBJ_OBELISK = 165,
+        TR4_OBJ_FLOOR_4BLADE = 166,
+        TR4_OBJ_ROOF_4BLADE = 167,
+        TR4_OBJ_BIRD_BLADE = 168,
+        TR4_OBJ_CATWALK_BLADE = 169,
+        TR4_OBJ_MOVING_BLADE = 170,
+        TR4_OBJ_PLINTH_BLADE = 171,
+        TR4_OBJ_SETH_BLADE = 172,
+        TR4_OBJ_LIGHTNING_CONDUCTOR = 173,
+        TR4_OBJ_ELEMENT_PUZZLE = 174,
+        TR4_OBJ_PUZZLE_ITEM1 = 175,
+        TR4_OBJ_PUZZLE_ITEM2 = 176,
+        TR4_OBJ_PUZZLE_ITEM3 = 177,
+        TR4_OBJ_PUZZLE_ITEM4 = 178,
+        TR4_OBJ_PUZZLE_ITEM5 = 179,
+        TR4_OBJ_PUZZLE_ITEM6 = 180,
+        TR4_OBJ_PUZZLE_ITEM7 = 181,
+        TR4_OBJ_PUZZLE_ITEM8 = 182,
+        TR4_OBJ_PUZZLE_ITEM9 = 183,
+        TR4_OBJ_PUZZLE_ITEM10 = 184,
+        TR4_OBJ_PUZZLE_ITEM11 = 185,
+        TR4_OBJ_PUZZLE_ITEM12 = 186,
+        TR4_OBJ_PUZZLE_ITEM1_COMBO1 = 187,
+        TR4_OBJ_PUZZLE_ITEM1_COMBO2 = 188,
+        TR4_OBJ_PUZZLE_ITEM2_COMBO1 = 189,
+        TR4_OBJ_PUZZLE_ITEM2_COMBO2 = 190,
+        TR4_OBJ_PUZZLE_ITEM3_COMBO1 = 191,
+        TR4_OBJ_PUZZLE_ITEM3_COMBO2 = 192,
+        TR4_OBJ_PUZZLE_ITEM4_COMBO1 = 193,
+        TR4_OBJ_PUZZLE_ITEM4_COMBO2 = 194,
+        TR4_OBJ_PUZZLE_ITEM5_COMBO1 = 195,
+        TR4_OBJ_PUZZLE_ITEM5_COMBO2 = 196,
+        TR4_OBJ_PUZZLE_ITEM6_COMBO1 = 197,
+        TR4_OBJ_PUZZLE_ITEM6_COMBO2 = 198,
+        TR4_OBJ_PUZZLE_ITEM7_COMBO1 = 199,
+        TR4_OBJ_PUZZLE_ITEM7_COMBO2 = 200,
+        TR4_OBJ_PUZZLE_ITEM8_COMBO1 = 201,
+        TR4_OBJ_PUZZLE_ITEM8_COMBO2 = 202,
+        TR4_OBJ_KEY_ITEM1 = 203,
+        TR4_OBJ_KEY_ITEM2 = 204,
+        TR4_OBJ_KEY_ITEM3 = 205,
+        TR4_OBJ_KEY_ITEM4 = 206,
+        TR4_OBJ_KEY_ITEM5 = 207,
+        TR4_OBJ_KEY_ITEM6 = 208,
+        TR4_OBJ_KEY_ITEM7 = 209,
+        TR4_OBJ_KEY_ITEM8 = 210,
+        TR4_OBJ_KEY_ITEM9 = 211,
+        TR4_OBJ_KEY_ITEM10 = 212,
+        TR4_OBJ_KEY_ITEM11 = 213,
+        TR4_OBJ_KEY_ITEM12 = 214,
+        TR4_OBJ_KEY_ITEM1_COMBO1 = 215,
+        TR4_OBJ_KEY_ITEM1_COMBO2 = 216,
+        TR4_OBJ_KEY_ITEM2_COMBO1 = 217,
+        TR4_OBJ_KEY_ITEM2_COMBO2 = 218,
+        TR4_OBJ_KEY_ITEM3_COMBO1 = 219,
+        TR4_OBJ_KEY_ITEM3_COMBO2 = 220,
+        TR4_OBJ_KEY_ITEM4_COMBO1 = 221,
+        TR4_OBJ_KEY_ITEM4_COMBO2 = 222,
+        TR4_OBJ_KEY_ITEM5_COMBO1 = 223,
+        TR4_OBJ_KEY_ITEM5_COMBO2 = 224,
+        TR4_OBJ_KEY_ITEM6_COMBO1 = 225,
+        TR4_OBJ_KEY_ITEM6_COMBO2 = 226,
+        TR4_OBJ_KEY_ITEM7_COMBO1 = 227,
+        TR4_OBJ_KEY_ITEM7_COMBO2 = 228,
+        TR4_OBJ_KEY_ITEM8_COMBO1 = 229,
+        TR4_OBJ_KEY_ITEM8_COMBO2 = 230,
+        TR4_OBJ_PICKUP_ITEM1 = 231,
+        TR4_OBJ_PICKUP_ITEM2 = 232,
+        TR4_OBJ_PICKUP_ITEM3 = 233,
+        TR4_OBJ_PICKUP_ITEM4 = 234,
+        TR4_OBJ_PICKUP_ITEM1_COMBO1 = 235,
+        TR4_OBJ_PICKUP_ITEM1_COMBO2 = 236,
+        TR4_OBJ_PICKUP_ITEM2_COMBO1 = 237,
+        TR4_OBJ_PICKUP_ITEM2_COMBO2 = 238,
+        TR4_OBJ_PICKUP_ITEM3_COMBO1 = 239,
+        TR4_OBJ_PICKUP_ITEM3_COMBO2 = 240,
+        TR4_OBJ_PICKUP_ITEM4_COMBO1 = 241,
+        TR4_OBJ_PICKUP_ITEM4_COMBO2 = 242,
+        TR4_OBJ_EXAMINE1 = 243,
+        TR4_OBJ_EXAMINE2 = 244,
+        TR4_OBJ_EXAMINE3 = 245,
+        TR4_OBJ_CROWBAR_ITEM = 246,
+        TR4_OBJ_BURNING_TORCH_ITEM = 247,
+        TR4_OBJ_CLOCKWORK_BEETLE = 248,
+        TR4_OBJ_CLOCKWORK_BEETLE_COMBO1 = 249,
+        TR4_OBJ_CLOCKWORK_BEETLE_COMBO2 = 250,
+        TR4_OBJ_MINE_DETECTOR = 251,
+        TR4_OBJ_QUEST_ITEM1 = 252,
+        TR4_OBJ_QUEST_ITEM2 = 253,
+        TR4_OBJ_QUEST_ITEM3 = 254,
+        TR4_OBJ_QUEST_ITEM4 = 255,
+        TR4_OBJ_QUEST_ITEM5 = 256,
+        TR4_OBJ_QUEST_ITEM6 = 257,
+        TR4_OBJ_MAP = 258,
+        TR4_OBJ_SECRET_MAP = 259,
+        TR4_OBJ_PUZZLE_HOLE1 = 260,
+        TR4_OBJ_PUZZLE_HOLE2 = 261,
+        TR4_OBJ_PUZZLE_HOLE3 = 262,
+        TR4_OBJ_PUZZLE_HOLE4 = 263,
+        TR4_OBJ_PUZZLE_HOLE5 = 264,
+        TR4_OBJ_PUZZLE_HOLE6 = 265,
+        TR4_OBJ_PUZZLE_HOLE7 = 266,
+        TR4_OBJ_PUZZLE_HOLE8 = 267,
+        TR4_OBJ_PUZZLE_HOLE9 = 268,
+        TR4_OBJ_PUZZLE_HOLE10 = 269,
+        TR4_OBJ_PUZZLE_HOLE11 = 270,
+        TR4_OBJ_PUZZLE_HOLE12 = 271,
+        TR4_OBJ_PUZZLE_DONE1 = 272,
+        TR4_OBJ_PUZZLE_DONE2 = 273,
+        TR4_OBJ_PUZZLE_DONE3 = 274,
+        TR4_OBJ_PUZZLE_DONE4 = 275,
+        TR4_OBJ_PUZZLE_DONE5 = 276,
+        TR4_OBJ_PUZZLE_DONE6 = 277,
+        TR4_OBJ_PUZZLE_DONE7 = 278,
+        TR4_OBJ_PUZZLE_DONE8 = 279,
+        TR4_OBJ_PUZZLE_DONE9 = 280,
+        TR4_OBJ_PUZZLE_DONE10 = 281,
+        TR4_OBJ_PUZZLE_DONE11 = 282,
+        TR4_OBJ_PUZZLE_DONE12 = 283,
+        TR4_OBJ_KEY_HOLE1 = 284,
+        TR4_OBJ_KEY_HOLE2 = 285,
+        TR4_OBJ_KEY_HOLE3 = 286,
+        TR4_OBJ_KEY_HOLE4 = 287,
+        TR4_OBJ_KEY_HOLE5 = 288,
+        TR4_OBJ_KEY_HOLE6 = 289,
+        TR4_OBJ_KEY_HOLE7 = 290,
+        TR4_OBJ_KEY_HOLE8 = 291,
+        TR4_OBJ_KEY_HOLE9 = 292,
+        TR4_OBJ_KEY_HOLE10 = 293,
+        TR4_OBJ_KEY_HOLE11 = 294,
+        TR4_OBJ_KEY_HOLE12 = 295,
+        TR4_OBJ_WATERSKIN1_EMPTY = 296,
+        TR4_OBJ_WATERSKIN1_1 = 297,
+        TR4_OBJ_WATERSKIN1_2 = 298,
+        TR4_OBJ_WATERSKIN1_3 = 299,
+        TR4_OBJ_WATERSKIN2_EMPTY = 300,
+        TR4_OBJ_WATERSKIN2_1 = 301,
+        TR4_OBJ_WATERSKIN2_2 = 302,
+        TR4_OBJ_WATERSKIN2_3 = 303,
+        TR4_OBJ_WATERSKIN2_4 = 304,
+        TR4_OBJ_WATERSKIN2_5 = 305,
+        TR4_OBJ_SWITCH_TYPE1 = 306,
+        TR4_OBJ_SWITCH_TYPE2 = 307,
+        TR4_OBJ_SWITCH_TYPE3 = 308,
+        TR4_OBJ_SWITCH_TYPE4 = 309,
+        TR4_OBJ_SWITCH_TYPE5 = 310,
+        TR4_OBJ_SWITCH_TYPE6 = 311,
+        TR4_OBJ_SWITCH_TYPE7 = 312,
+        TR4_OBJ_SWITCH_TYPE8 = 313,
+        TR4_OBJ_UNDERWATER_SWITCH1 = 314,
+        TR4_OBJ_UNDERWATER_SWITCH2 = 315,
+        TR4_OBJ_TURN_SWITCH = 316,
+        TR4_OBJ_COG_SWITCH = 317,
+        TR4_OBJ_LEVER_SWITCH = 318,
+        TR4_OBJ_JUMP_SWITCH = 319,
+        TR4_OBJ_CROWBAR_SWITCH = 320,
+        TR4_OBJ_PULLEY = 321,
+        TR4_OBJ_DOOR_TYPE1 = 322,
+        TR4_OBJ_DOOR_TYPE2 = 323,
+        TR4_OBJ_DOOR_TYPE3 = 324,
+        TR4_OBJ_DOOR_TYPE4 = 325,
+        TR4_OBJ_DOOR_TYPE5 = 326,
+        TR4_OBJ_DOOR_TYPE6 = 327,
+        TR4_OBJ_DOOR_TYPE7 = 328,
+        TR4_OBJ_DOOR_TYPE8 = 329,
+        TR4_OBJ_PUSHPULL_DOOR1 = 330,
+        TR4_OBJ_PUSHPULL_DOOR2 = 331,
+        TR4_OBJ_KICK_DOOR1 = 332,
+        TR4_OBJ_KICK_DOOR2 = 333,
+        TR4_OBJ_UNDERWATER_DOOR = 334,
+        TR4_OBJ_DOUBLE_DOORS = 335,
+        TR4_OBJ_BRIDGE_FLAT = 336,
+        TR4_OBJ_BRIDGE_TILT1 = 337,
+        TR4_OBJ_BRIDGE_TILT2 = 338,
+        TR4_OBJ_SARCOPHAGUS = 339,
+        TR4_OBJ_SEQUENCE_DOOR1 = 340,
+        TR4_OBJ_SEQUENCE_SWITCH1 = 341,
+        TR4_OBJ_SEQUENCE_SWITCH2 = 342,
+        TR4_OBJ_SEQUENCE_SWITCH3 = 343,
+        TR4_OBJ_SARCOPHAGUS_CUT = 344,
+        TR4_OBJ_HORUS_STATUE = 345,
+        TR4_OBJ_GOD_HEAD = 346,
+        TR4_OBJ_SETH_DOOR = 347,
+        TR4_OBJ_STATUE_PLINTH = 348,
+        TR4_OBJ_PISTOLS_ITEM = 349,
+        TR4_OBJ_PISTOLS_AMMO_ITEM = 350,
+        TR4_OBJ_UZI_ITEM = 351,
+        TR4_OBJ_UZI_AMMO_ITEM = 352,
+        TR4_OBJ_SHOTGUN_ITEM = 353,
+        TR4_OBJ_SHOTGUN_AMMO1_ITEM = 354,
+        TR4_OBJ_SHOTGUN_AMMO2_ITEM = 355,
+        TR4_OBJ_CROSSBOW_ITEM = 356,
+        TR4_OBJ_CROSSBOW_AMMO1_ITEM = 357,
+        TR4_OBJ_CROSSBOW_AMMO2_ITEM = 358,
+        TR4_OBJ_CROSSBOW_AMMO3_ITEM = 359,
+        TR4_OBJ_CROSSBOW_BOLT = 360,
+        TR4_OBJ_GRENADE_GUN_ITEM = 361,
+        TR4_OBJ_GRENADE_GUN_AMMO1_ITEM = 362,
+        TR4_OBJ_GRENADE_GUN_AMMO2_ITEM = 363,
+        TR4_OBJ_GRENADE_GUN_AMMO3_ITEM = 364,
+        TR4_OBJ_GRENADE = 365,
+        TR4_OBJ_SIXSHOOTER_ITEM = 366,
+        TR4_OBJ_SIXSHOOTER_AMMO_ITEM = 367,
+        TR4_OBJ_BIGMEDI_ITEM = 368,
+        TR4_OBJ_SMALLMEDI_ITEM = 369,
+        TR4_OBJ_LASERSIGHT_ITEM = 370,
+        TR4_OBJ_BINOCULARS_ITEM = 371,
+        TR4_OBJ_FLARE_ITEM = 372,
+        TR4_OBJ_FLARE_INV_ITEM = 373,
+        TR4_OBJ_DIARY_ITEM = 374,
+        TR4_OBJ_COMPASS_ITEM = 375,
+        TR4_OBJ_MEMCARD_LOAD_INV_ITEM = 376,
+        TR4_OBJ_MEMCARD_SAVE_INV_ITEM = 377,
+        TR4_OBJ_PC_LOAD_INV_ITEM = 378,
+        TR4_OBJ_PC_SAVE_INV_ITEM = 379,
+        TR4_OBJ_SMOKE_EMITTER_WHITE = 380,
+        TR4_OBJ_SMOKE_EMITTER_BLACK = 381,
+        TR4_OBJ_STEAM_EMITTER = 382,
+        TR4_OBJ_EARTHQUAKE = 383,
+        TR4_OBJ_BUBBLES = 384,
+        TR4_OBJ_WATERFALLMIST = 385,
+        TR4_OBJ_GUNSHELL = 386,
+        TR4_OBJ_SHOTGUNSHELL = 387,
+        TR4_OBJ_GUN_FLASH = 388,
+        TR4_OBJ_BUTTERFLY = 389,
+        TR4_OBJ_SPRINKLER = 390,
+        TR4_OBJ_RED_LIGHT = 391,
+        TR4_OBJ_GREEN_LIGHT = 392,
+        TR4_OBJ_BLUE_LIGHT = 393,
+        TR4_OBJ_AMBER_LIGHT = 394,
+        TR4_OBJ_WHITE_LIGHT = 395,
+        TR4_OBJ_BLINKING_LIGHT = 396,
+        TR4_OBJ_LENS_FLARE = 397,
+        TR4_OBJ_AI_GUARD = 398,
+        TR4_OBJ_AI_AMBUSH = 399,
+        TR4_OBJ_AI_PATROL1 = 400,
+        TR4_OBJ_AI_MODIFY = 401,
+        TR4_OBJ_AI_FOLLOW = 402,
+        TR4_OBJ_AI_PATROL2 = 403,
+        TR4_OBJ_AI_X1 = 404,
+        TR4_OBJ_AI_X2 = 405,
+        TR4_OBJ_LARA_START_POS = 406,
+        TR4_OBJ_KILL_ALL_TRIGGERS = 407,
+        TR4_OBJ_TRIGGER_TRIGGERER = 408,
+        TR4_OBJ_SMASH_OBJECT1 = 409,
+        TR4_OBJ_SMASH_OBJECT2 = 410,
+        TR4_OBJ_SMASH_OBJECT3 = 411,
+        TR4_OBJ_SMASH_OBJECT4 = 412,
+        TR4_OBJ_SMASH_OBJECT5 = 413,
+        TR4_OBJ_SMASH_OBJECT6 = 414,
+        TR4_OBJ_SMASH_OBJECT7 = 415,
+        TR4_OBJ_SMASH_OBJECT8 = 416,
+        TR4_OBJ_MESHSWAP1 = 417,
+        TR4_OBJ_MESHSWAP2 = 418,
+        TR4_OBJ_MESHSWAP3 = 419,
+        TR4_OBJ_DEATH_SLIDE = 420,
+        TR4_OBJ_BODY_PART = 421,
+        TR4_OBJ_CAMERA_TARGET = 422,
+        TR4_OBJ_WATERFALL1 = 423,
+        TR4_OBJ_WATERFALL2 = 424,
+        TR4_OBJ_WATERFALL3 = 425,
+        TR4_OBJ_PLANET_EFFECT = 426,
+        TR4_OBJ_ANIMATING1 = 427,
+        TR4_OBJ_ANIMATING1_MIP = 428,
+        TR4_OBJ_ANIMATING2 = 429,
+        TR4_OBJ_ANIMATING2_MIP = 430,
+        TR4_OBJ_ANIMATING3 = 431,
+        TR4_OBJ_ANIMATING3_MIP = 432,
+        TR4_OBJ_ANIMATING4 = 433,
+        TR4_OBJ_ANIMATING4_MIP = 434,
+        TR4_OBJ_ANIMATING5 = 435,
+        TR4_OBJ_ANIMATING5_MIP = 436,
+        TR4_OBJ_ANIMATING6 = 437,
+        TR4_OBJ_ANIMATING6_MIP = 438,
+        TR4_OBJ_ANIMATING7 = 439,
+        TR4_OBJ_ANIMATING7_MIP = 440,
+        TR4_OBJ_ANIMATING8 = 441,
+        TR4_OBJ_ANIMATING8_MIP = 442,
+        TR4_OBJ_ANIMATING9 = 443,
+        TR4_OBJ_ANIMATING9_MIP = 444,
+        TR4_OBJ_ANIMATING10 = 445,
+        TR4_OBJ_ANIMATING10_MIP = 446,
+        TR4_OBJ_ANIMATING11 = 447,
+        TR4_OBJ_ANIMATING11_MIP = 448,
+        TR4_OBJ_ANIMATING12 = 449,
+        TR4_OBJ_ANIMATING12_MIP = 450,
+        TR4_OBJ_ANIMATING13 = 451,
+        TR4_OBJ_ANIMATING13_MIP = 452,
+        TR4_OBJ_ANIMATING14 = 453,
+        TR4_OBJ_ANIMATING14_MIP = 454,
+        TR4_OBJ_ANIMATING15 = 455,
+        TR4_OBJ_ANIMATING15_MIP = 456,
+        TR4_OBJ_ANIMATING16 = 457,
+        TR4_OBJ_ANIMATING16_MIP = 458,
+        TR4_OBJ_HORIZON = 459,
+        TR4_OBJ_SKY_GRAPHICS = 460,                // Sprite (in SWD file)
+        TR4_OBJ_BINOCULAR_GRAPHICS = 461,
+        TR4_OBJ_TARGET_GRAPHICS = 462,
+        TR4_OBJ_DEFAULT_SPRITES = 463,              // Sprite (in SWD file)
+        TR4_OBJ_MISC_SPRITES = 464
 
 } tr4_objects_t;
 

include/Vector.h

@@ -36,373 +36,373 @@ template <class Object> class Vector
 {
 public:
 
-	Vector()
-	{
-		mData = 0x0;
-		mError = 0x0;
+    Vector()
+    {
+        mData = 0x0;
+        mError = 0x0;
 
-		mReserve = 0;
-		mStart = 0;
-		mEnd = 0;
+        mReserve = 0;
+        mStart = 0;
+        mEnd = 0;
 
-		mIndex = 0;
-	}
+        mIndex = 0;
+    }
 
 
-	Vector(Vector &vector)
-	{
-		mData = 0x0;
-		mError = 0x0;
+    Vector(Vector &vector)
+    {
+        mData = 0x0;
+        mError = 0x0;
 
-		mReserve = 0;
-		mStart = 0;
-		mEnd = 0;
+        mReserve = 0;
+        mStart = 0;
+        mEnd = 0;
 
-		copy(vector);
-	}
+        copy(vector);
+    }
 
 
-	Vector(unsigned int size)
-	{
-		mData = 0x0;
-		mError = 0x0;
+    Vector(unsigned int size)
+    {
+        mData = 0x0;
+        mError = 0x0;
 
-		mReserve = 0;
-		mStart = 0;
-		mEnd = 0;
+        mReserve = 0;
+        mStart = 0;
+        mEnd = 0;
 
-		mIndex = 0;
+        mIndex = 0;
 
-		resize(size);
-	}
+        resize(size);
+    }
 
 
-	~Vector()
-	{
-		if (!empty() && mData)
-		{
-			delete [] mData;
-		}
+    ~Vector()
+    {
+        if (!empty() && mData)
+        {
+            delete [] mData;
+        }
 
-		clear();
-		mReserve = 0;
-	}
+        clear();
+        mReserve = 0;
+    }
 
 
-	void clear()
-	{
-		mStart = 0;
-		mEnd = 0;
+    void clear()
+    {
+        mStart = 0;
+        mEnd = 0;
 
-		mIndex = 0;
-	}
+        mIndex = 0;
+    }
 
 
-	void erase()
-	{
-		for (start(); forward(); next())
-		{
-			if (current())
-			{
-				delete current();
-			}
-		}
+    void erase()
+    {
+        for (start(); forward(); next())
+        {
+            if (current())
+            {
+                delete current();
+            }
+        }
 
-		clear();
-	}
+        clear();
+    }
 
 
-	void reserve(unsigned int count)
-	{
-		unsigned int i;
-		Object *swap = 0x0;
+    void reserve(unsigned int count)
+    {
+        unsigned int i;
+        Object *swap = 0x0;
 
 
-		if (count > mReserve)
-		{
-			swap = mData;
-			mReserve = count;
-			mData = new Object[count];
-		}
+        if (count > mReserve)
+        {
+            swap = mData;
+            mReserve = count;
+            mData = new Object[count];
+        }
 
-		if (swap)
-		{
-			for (i = begin(); i < end(); ++i)
-			{
-				mData[i] = swap[i];
-			}
+        if (swap)
+        {
+            for (i = begin(); i < end(); ++i)
+            {
+                mData[i] = swap[i];
+            }
 
-			delete [] swap;
-		}
-	}
+            delete [] swap;
+        }
+    }
 
 
-	void resize(unsigned int count)
-	{
-		resize(count, 0x0);
-	}
+    void resize(unsigned int count)
+    {
+        resize(count, 0x0);
+    }
 
 
-	void resize(unsigned int count, Object object)
-	{
-		unsigned int i;
+    void resize(unsigned int count, Object object)
+    {
+        unsigned int i;
 
 
-		reserve(count);
+        reserve(count);
 
-		for (i = 0; i < count; ++i)
-		{
-			if (i < begin() || i >= end())
-			{
-				mData[i] = object;
-			}
-		}
+        for (i = 0; i < count; ++i)
+        {
+            if (i < begin() || i >= end())
+            {
+                mData[i] = object;
+            }
+        }
 
-		mEnd = count;
-	}
+        mEnd = count;
+    }
 
 
-	void pushBack()
-	{
-		pushBack(0x0);
-	}
+    void pushBack()
+    {
+        pushBack(0x0);
+    }
 
 
-	void pushBack(Object object)
-	{
-		resize(size() + 1);
-		mData[size()-1] = object;
-	}
+    void pushBack(Object object)
+    {
+        resize(size() + 1);
+        mData[size()-1] = object;
+    }
 
 
-	bool empty()
-	{
-		return (begin() == end());
-	}
+    bool empty()
+    {
+        return (begin() == end());
+    }
 
 
-	unsigned int capacity()
-	{
-		return mReserve;
-	}
+    unsigned int capacity()
+    {
+        return mReserve;
+    }
 
 
-	unsigned int begin()
-	{
-		return mStart;
-	}
+    unsigned int begin()
+    {
+        return mStart;
+    }
 
 
-	unsigned int end()
-	{
-		return mEnd;
-	}
+    unsigned int end()
+    {
+        return mEnd;
+    }
 
 
-	unsigned int size()
-	{
-		return mEnd;
-	}
+    unsigned int size()
+    {
+        return mEnd;
+    }
 
 
-	void copy(Vector<Object> &vector)
-	{
-		unsigned int i;
+    void copy(Vector<Object> &vector)
+    {
+        unsigned int i;
 
 
-		if (vector.capacity() > capacity())
-		{
-			resize(vector.capacity());
-		}
+        if (vector.capacity() > capacity())
+        {
+            resize(vector.capacity());
+        }
 
-		mStart = vector.begin();
-		mEnd = vector.end();
+        mStart = vector.begin();
+        mEnd = vector.end();
 
-		for (i = vector.begin(); i < vector.end(); ++i)
-		{
-			mData[i] = vector[i];
-			//Add(list->Current()); // WTFBBQ?
-		}
-	}
+        for (i = vector.begin(); i < vector.end(); ++i)
+        {
+            mData[i] = vector[i];
+            //Add(list->Current()); // WTFBBQ?
+        }
+    }
 
 
-	void qSort(int (*compareFunc)(const void *, const void *))
-	{
-		qsort(mData, end(), sizeof(Object), compareFunc);
-	}
+    void qSort(int (*compareFunc)(const void *, const void *))
+    {
+        qsort(mData, end(), sizeof(Object), compareFunc);
+    }
 
 
-	void swap(unsigned int index, unsigned int index2)
-	{
-		if (index < begin() || index > end())
-			return;
+    void swap(unsigned int index, unsigned int index2)
+    {
+        if (index < begin() || index > end())
+            return;
 
-		if (index2 < begin() || index2 > end())
-			return;
+        if (index2 < begin() || index2 > end())
+            return;
 
-		Object swap = mData[index];
-		mData[index] = mData[index2];
-		mData[index2] = swap;
-	}
+        Object swap = mData[index];
+        mData[index] = mData[index2];
+        mData[index2] = swap;
+    }
 
 
-	void assign(unsigned int index, Object object)
-	{
-		mData[index] = object;
-	}
+    void assign(unsigned int index, Object object)
+    {
+        mData[index] = object;
+    }
 
 
-	Object operator [] (unsigned int index)
-	{
-		if (mData == 0x0 || index < begin() || index > end() ||
-			 index >= size() || empty())
-			return mError;
+    Object operator [] (unsigned int index)
+    {
+        if (mData == 0x0 || index < begin() || index > end() ||
+             index >= size() || empty())
+            return mError;
 
-		return mData[index];
-	}
+        return mData[index];
+    }
 
 
-	void print(void (*print_func)(Object))
-	{
-		unsigned int i;
+    void print(void (*print_func)(Object))
+    {
+        unsigned int i;
 
 
-		for (i = begin(); i < end(); ++i)
-		{
-			if (print_func)
-			{
-				(*print_func)(mData[i]);
-			}
+        for (i = begin(); i < end(); ++i)
+        {
+            if (print_func)
+            {
+                (*print_func)(mData[i]);
+            }
 
-			fflush(stdout);
-		}
+            fflush(stdout);
+        }
 
-		printf("\n");
-	}
+        printf("\n");
+    }
 
 
-	// Built-in iterator methods ////////////////////////////////
+    // Built-in iterator methods ////////////////////////////////
 
-	void start(unsigned int index)
-	{
-		if (mData == 0x0 || index < begin() || index > end() ||
-			 index >= size() || empty())
-			return;
+    void start(unsigned int index)
+    {
+        if (mData == 0x0 || index < begin() || index > end() ||
+             index >= size() || empty())
+            return;
 
-		mIndex = index;
-	}
+        mIndex = index;
+    }
 
-	void start()
-	{
-		mIndex = begin();
-	}
+    void start()
+    {
+        mIndex = begin();
+    }
 
 
-	void finish()
-	{
-		mIndex = end() - 1;
-	}
+    void finish()
+    {
+        mIndex = end() - 1;
+    }
 
 
-	bool forward()
-	{
-		return (mIndex < end());
-	}
+    bool forward()
+    {
+        return (mIndex < end());
+    }
 
 
-	bool backward()
-	{
-		return (mIndex + 1 > begin());
-	}
+    bool backward()
+    {
+        return (mIndex + 1 > begin());
+    }
 
 
-	void next()
-	{
-		if (mIndex < end())
-			++mIndex;
-	}
+    void next()
+    {
+        if (mIndex < end())
+            ++mIndex;
+    }
 
-	void prev()
-	{
-		--mIndex;
-	}
+    void prev()
+    {
+        --mIndex;
+    }
 
 
-	void setError(Object object)
-	{
-		mError = object;
-	}
+    void setError(Object object)
+    {
+        mError = object;
+    }
 
 
-	unsigned int getCurrentIndex()
-	{
-		return mIndex;
-	}
+    unsigned int getCurrentIndex()
+    {
+        return mIndex;
+    }
 
 
-	unsigned int setCurrentIndex(unsigned int index)
-	{
-		if (index < end())
-		{
-			mIndex = index;
-		}
-	}
+    unsigned int setCurrentIndex(unsigned int index)
+    {
+        if (index < end())
+        {
+            mIndex = index;
+        }
+    }
 
 
-	Object current()
-	{
-		return mData[mIndex];
-	}
+    Object current()
+    {
+        return mData[mIndex];
+    }
 
 
-	/* Requires objects to support '=='  */
-	bool find(Object object)
-	{
-		for (start(); forward(); next())
-		{
-			if (object == current())
-			{
-				return true;
-			}
-		}
+    /* Requires objects to support '=='  */
+    bool find(Object object)
+    {
+        for (start(); forward(); next())
+        {
+            if (object == current())
+            {
+                return true;
+            }
+        }
 
-		return false;
-	}
+        return false;
+    }
 
-	// Instead of appending objects this apptempts replacing 'removed' objects
-	unsigned int add(Object object)
-	{
-		if (begin() > 0)
-		{
-			mData[begin() - 1] = object;
-			--mStart;
+    // Instead of appending objects this apptempts replacing 'removed' objects
+    unsigned int add(Object object)
+    {
+        if (begin() > 0)
+        {
+            mData[begin() - 1] = object;
+            --mStart;
 
-			return begin();
-		}
+            return begin();
+        }
 
-		pushBack(object);
-		return size();
-	}
+        pushBack(object);
+        return size();
+    }
 
 
-	// Hhhmm... dangerous and fun - this gets your data out of order
-	void remove(unsigned int index)
-	{
-		mData[index] = mData[begin()];
-		++mStart;
-	}
+    // Hhhmm... dangerous and fun - this gets your data out of order
+    void remove(unsigned int index)
+    {
+        mData[index] = mData[begin()];
+        ++mStart;
+    }
 
 private:
 
-	Object *mData;
+    Object *mData;
 
-	Object mError;
+    Object mError;
 
-	unsigned int mReserve;
-	unsigned int mStart;
-	unsigned int mEnd;
+    unsigned int mReserve;
+    unsigned int mStart;
+    unsigned int mEnd;
 
-	unsigned int mIndex;
+    unsigned int mIndex;
 };
 
 #endif

include/Vector3d.h

@@ -34,263 +34,263 @@ class Vector3d
 {
  public:
 
-	////////////////////////////////////////////////////////////
-	// Constructors
-	////////////////////////////////////////////////////////////
-
-	Vector3d();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Constructs an object of Vector3d
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.24:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	Vector3d(vec3_t v);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Constructs an object of Vector3d
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.24:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	Vector3d(vec_t x, vec_t y, vec_t z);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Constructs an object of Vector3d
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.24:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	~Vector3d();
-	/*------------------------------------------------------
-	 * Pre  : Vector3d object is allocated
-	 * Post : Deconstructs an object of Vector3d
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.24:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-
-	////////////////////////////////////////////////////////////
-	// Public Accessors
-	////////////////////////////////////////////////////////////
-
-	static vec_t dot(const Vector3d &u, const Vector3d &v);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Returns dot product of U and V vectors
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	static Vector3d cross(const Vector3d &u, const Vector3d &v);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Returns cross product of U and V vectors
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	vec_t magnitude();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Returns magnitude this vector
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	Vector3d unit();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Returns normalized copy of this vector
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	static Vector3d zeroVector();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Returns the Zero vector <0, 0, 0>
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2003.06.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	Vector3d operator +(const Vector3d &v);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Returns a vector = this vector + v
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	Vector3d operator -(const Vector3d &v);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Returns a vector = this vector - v
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	Vector3d operator -();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Returns a copy of this vector, negated
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	Vector3d operator *(vec_t s);
-	/*------------------------------------------------------
-	 * Pre  : S is scalar to scale by
-	 * Post : Returns scale by S of this vector ( mult )
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	Vector3d operator /(vec_t s);
-	/*------------------------------------------------------
-	 * Pre  : S is scalar to scale by
-	 * Post : Returns scale by S of this vector ( div )
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	vec_t operator *(const Vector3d &v);
-	/*------------------------------------------------------
-	 * Pre  : V is vector to dot by
-	 * Post : Returns dot by V with this vector
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-
-	////////////////////////////////////////////////////////////
-	// Public Mutators
-	////////////////////////////////////////////////////////////
-
-	void normalize();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Normalizes *this vector
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void zero();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post :This is set to the Zero vector <0, 0, 0>
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2003.06.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void operator =(const Vector3d &v);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : this = v, values are assigned   =)
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void operator +=(const Vector3d &v);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : this += v, values are sumed, assigned   =)
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void operator -=(const Vector3d &v);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : this -= v, values are diffed, assigned   =)
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void operator *=(vec_t s);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : this *= s, values are scaled, assigned   =)
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.05.08:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	vec3_t mVec;   /* Vector data */
+    ////////////////////////////////////////////////////////////
+    // Constructors
+    ////////////////////////////////////////////////////////////
+
+    Vector3d();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Constructs an object of Vector3d
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.24:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    Vector3d(vec3_t v);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Constructs an object of Vector3d
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.24:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    Vector3d(vec_t x, vec_t y, vec_t z);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Constructs an object of Vector3d
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.24:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    ~Vector3d();
+    /*------------------------------------------------------
+     * Pre  : Vector3d object is allocated
+     * Post : Deconstructs an object of Vector3d
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.24:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+
+    ////////////////////////////////////////////////////////////
+    // Public Accessors
+    ////////////////////////////////////////////////////////////
+
+    static vec_t dot(const Vector3d &u, const Vector3d &v);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Returns dot product of U and V vectors
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    static Vector3d cross(const Vector3d &u, const Vector3d &v);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Returns cross product of U and V vectors
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    vec_t magnitude();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Returns magnitude this vector
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    Vector3d unit();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Returns normalized copy of this vector
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    static Vector3d zeroVector();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Returns the Zero vector <0, 0, 0>
+     *
+     *-- History ------------------------------------------
+     *
+     * 2003.06.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    Vector3d operator +(const Vector3d &v);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Returns a vector = this vector + v
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    Vector3d operator -(const Vector3d &v);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Returns a vector = this vector - v
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    Vector3d operator -();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Returns a copy of this vector, negated
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    Vector3d operator *(vec_t s);
+    /*------------------------------------------------------
+     * Pre  : S is scalar to scale by
+     * Post : Returns scale by S of this vector ( mult )
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    Vector3d operator /(vec_t s);
+    /*------------------------------------------------------
+     * Pre  : S is scalar to scale by
+     * Post : Returns scale by S of this vector ( div )
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    vec_t operator *(const Vector3d &v);
+    /*------------------------------------------------------
+     * Pre  : V is vector to dot by
+     * Post : Returns dot by V with this vector
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+
+    ////////////////////////////////////////////////////////////
+    // Public Mutators
+    ////////////////////////////////////////////////////////////
+
+    void normalize();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Normalizes *this vector
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void zero();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post :This is set to the Zero vector <0, 0, 0>
+     *
+     *-- History ------------------------------------------
+     *
+     * 2003.06.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void operator =(const Vector3d &v);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : this = v, values are assigned   =)
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void operator +=(const Vector3d &v);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : this += v, values are sumed, assigned   =)
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void operator -=(const Vector3d &v);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : this -= v, values are diffed, assigned   =)
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void operator *=(vec_t s);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : this *= s, values are scaled, assigned   =)
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.05.08:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    vec3_t mVec;   /* Vector data */
 
  private:
 
-	////////////////////////////////////////////////////////////
-	// Private Accessors
-	////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////
+    // Private Accessors
+    ////////////////////////////////////////////////////////////
 
 
-	////////////////////////////////////////////////////////////
-	// Private Mutators
-	////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////
+    // Private Mutators
+    ////////////////////////////////////////////////////////////
 
 };
 

include/ViewVolume.h

@@ -34,261 +34,261 @@ class ViewVolume
 {
  public:
 
-	enum ViewVolumeSide
-	{
-		rightSide  = 0, // Right
-		leftSide   = 1, // Left
-		bottomSide = 2, // Bottom
-		topSide    = 3, // Top
-		farSide    = 4, // Back
-		nearSide   = 5  // Front
-	};
-
-	enum ViewVolumePlane
-	{
-		planeA = 0, // X value of normal
-		planeB = 1, // Y value of normal
-		planeC = 2, // Z value of normal
-		planeD = 3  // Distance to origin
-	};
-
-
-	////////////////////////////////////////////////////////////
-	// Constructors
-	////////////////////////////////////////////////////////////
-
-	ViewVolume();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Constructs an object of ViewVolume
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.15:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	~ViewVolume();
-	/*------------------------------------------------------
-	 * Pre  : ViewVolume object is allocated
-	 * Post : Deconstructs an object of ViewVolume
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.15:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-
-	////////////////////////////////////////////////////////////
-	// Public Accessors
-	////////////////////////////////////////////////////////////
-
-	bool isBoundingVolumeInFrustum(BoundingVolume bvol);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Returns true if frustum contains the given
-	 *        bounding volume
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.15:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	bool isBoundingSphereInFrustum(BoundingSphere bvol);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Returns true if frustum contains the given
-	 *        bounding volume
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.15:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	bool isBoundingBoxInFrustum(BoundingBox bvol);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Returns true if frustum contains the given
-	 *        bounding volume
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.15:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	bool isPointInFrustum(vec_t x, vec_t y, vec_t z);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post :
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.15:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	bool isSphereInFrustum(vec_t x, vec_t y, vec_t z, vec_t radius);
-	/*------------------------------------------------------
-	 * Pre  : Abstract sphere is valid
-	 * Post : Returns true if abstract sphere in view volume
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.15:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	bool isBboxInFrustum(vec3_t min, vec3_t max);
-	/*------------------------------------------------------
-	 * Pre  : Abstract bounding box is valid
-	 * Post : Returns true if abstract bounding box in view volume
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 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
-	 *        bounding volume
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.15:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	vec_t getDistToBboxFromNear(vec3_t min, vec3_t max);
-	/*------------------------------------------------------
-	 * Pre  : Abstract bounding box is valid
-	 * Post : Returns distance to abstract box
-	 *        bounding volume
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.15:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void getFrustum(vec_t frustum[6][4]);
-	/*------------------------------------------------------
-	 * Pre  : Frustum is allocated 6x4 vec_t
-	 * Post : Get a copy of the view volume
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.26:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void getPlane(ViewVolumeSide p, vec4_t plane);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Get a copy of a given plane in view volume
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.26:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-
-	////////////////////////////////////////////////////////////
-	// Public Mutators
-	////////////////////////////////////////////////////////////
-
-	void updateFrame(matrix_t proj, matrix_t mdl);
-	/*------------------------------------------------------
-	 * Pre  : Given valid projection and model matrices
-	 * Post : Updates view volume for this frame
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.15:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void updateFrame();
-	/*------------------------------------------------------
-	 * Pre  : Called setModel() and setProjection()
-	 * Post : Updates view volume for this frame
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.15:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void setModel(matrix_t mdl);
-	/*------------------------------------------------------
-	 * Pre  : It's valid model matrix
-	 * Post : Sets this class' model matrix
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.15:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void setProjection(matrix_t proj);
-	/*------------------------------------------------------
-	 * Pre  : It's the valid projection matrix
-	 * Post : Sets this class' projection matrix
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.15:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
+    enum ViewVolumeSide
+    {
+        rightSide  = 0, // Right
+        leftSide   = 1, // Left
+        bottomSide = 2, // Bottom
+        topSide    = 3, // Top
+        farSide    = 4, // Back
+        nearSide   = 5  // Front
+    };
+
+    enum ViewVolumePlane
+    {
+        planeA = 0, // X value of normal
+        planeB = 1, // Y value of normal
+        planeC = 2, // Z value of normal
+        planeD = 3  // Distance to origin
+    };
+
+
+    ////////////////////////////////////////////////////////////
+    // Constructors
+    ////////////////////////////////////////////////////////////
+
+    ViewVolume();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Constructs an object of ViewVolume
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.15:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    ~ViewVolume();
+    /*------------------------------------------------------
+     * Pre  : ViewVolume object is allocated
+     * Post : Deconstructs an object of ViewVolume
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.15:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+
+    ////////////////////////////////////////////////////////////
+    // Public Accessors
+    ////////////////////////////////////////////////////////////
+
+    bool isBoundingVolumeInFrustum(BoundingVolume bvol);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Returns true if frustum contains the given
+     *        bounding volume
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.15:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    bool isBoundingSphereInFrustum(BoundingSphere bvol);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Returns true if frustum contains the given
+     *        bounding volume
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.15:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    bool isBoundingBoxInFrustum(BoundingBox bvol);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Returns true if frustum contains the given
+     *        bounding volume
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.15:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    bool isPointInFrustum(vec_t x, vec_t y, vec_t z);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post :
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.15:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    bool isSphereInFrustum(vec_t x, vec_t y, vec_t z, vec_t radius);
+    /*------------------------------------------------------
+     * Pre  : Abstract sphere is valid
+     * Post : Returns true if abstract sphere in view volume
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.15:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    bool isBboxInFrustum(vec3_t min, vec3_t max);
+    /*------------------------------------------------------
+     * Pre  : Abstract bounding box is valid
+     * Post : Returns true if abstract bounding box in view volume
+     *
+     *-- History ------------------------------------------
+     *
+     * 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
+     *        bounding volume
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.15:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    vec_t getDistToBboxFromNear(vec3_t min, vec3_t max);
+    /*------------------------------------------------------
+     * Pre  : Abstract bounding box is valid
+     * Post : Returns distance to abstract box
+     *        bounding volume
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.15:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void getFrustum(vec_t frustum[6][4]);
+    /*------------------------------------------------------
+     * Pre  : Frustum is allocated 6x4 vec_t
+     * Post : Get a copy of the view volume
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.26:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void getPlane(ViewVolumeSide p, vec4_t plane);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Get a copy of a given plane in view volume
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.26:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+
+    ////////////////////////////////////////////////////////////
+    // Public Mutators
+    ////////////////////////////////////////////////////////////
+
+    void updateFrame(matrix_t proj, matrix_t mdl);
+    /*------------------------------------------------------
+     * Pre  : Given valid projection and model matrices
+     * Post : Updates view volume for this frame
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.15:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void updateFrame();
+    /*------------------------------------------------------
+     * Pre  : Called setModel() and setProjection()
+     * Post : Updates view volume for this frame
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.15:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void setModel(matrix_t mdl);
+    /*------------------------------------------------------
+     * Pre  : It's valid model matrix
+     * Post : Sets this class' model matrix
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.15:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void setProjection(matrix_t proj);
+    /*------------------------------------------------------
+     * Pre  : It's the valid projection matrix
+     * Post : Sets this class' projection matrix
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.15:
+     * Mongoose - Created
+     ------------------------------------------------------*/
 
  private:
 
-	////////////////////////////////////////////////////////////
-	// Private Accessors
-	////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////
+    // Private Accessors
+    ////////////////////////////////////////////////////////////
 
 
-	////////////////////////////////////////////////////////////
-	// Private Mutators
-	////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////
+    // Private Mutators
+    ////////////////////////////////////////////////////////////
 
-	void updateClip();
-	/*------------------------------------------------------
-	 * Pre  : model and projection matrices are set
-	 * Post : Computes clipping matrix
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.15:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
+    void updateClip();
+    /*------------------------------------------------------
+     * Pre  : model and projection matrices are set
+     * Post : Computes clipping matrix
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.15:
+     * Mongoose - Created
+     ------------------------------------------------------*/
 
-	void updateFrustum();
-	/*------------------------------------------------------
-	 * Pre  : model, projection, clip matrices are set
-	 * Post : Computes planes of frustum
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.15:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
+    void updateFrustum();
+    /*------------------------------------------------------
+     * Pre  : model, projection, clip matrices are set
+     * Post : Computes planes of frustum
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.15:
+     * Mongoose - Created
+     ------------------------------------------------------*/
 
 
-	Matrix mProjection;       	/* Projection matrix */
+    Matrix mProjection;         /* Projection matrix */
 
-	Matrix mModel;         	   /* Model matrix */
+    Matrix mModel;             /* Model matrix */
 
-	Matrix mClip;	            /* Clipping matrix */
+    Matrix mClip;               /* Clipping matrix */
 
-	vec_t mFrustum[6][4];      /* View volume */
+    vec_t mFrustum[6][4];      /* View volume */
 };
 
 #endif

include/World.h

@@ -41,64 +41,64 @@
 // Mirrors TombRaider class' room flags really
 typedef enum
 {
-	roomFlag_underWater    = 0x0001
+    roomFlag_underWater    = 0x0001
 
 } room_flags_t;
 
 typedef enum
 {
-	worldMoveType_walkNoSwim   = -1,
-	worldMoveType_walk         = 0,
-	worldMoveType_noClipping   = 1,
-	worldMoveType_fly          = 2,
-	worldMoveType_swim         = 3
+    worldMoveType_walkNoSwim   = -1,
+    worldMoveType_walk         = 0,
+    worldMoveType_noClipping   = 1,
+    worldMoveType_fly          = 2,
+    worldMoveType_swim         = 3
 
 } worldMoveType;
 
 
 typedef struct vertex_s
 {
-	vec3_t pos;
+    vec3_t pos;
 
 } vertex_t;
 
 
 typedef struct uv_s
 {
-	vec2_t uv;
+    vec2_t uv;
 
 } uv_t;
 
 typedef struct texel_s
 {
-	vec2_t st;
+    vec2_t st;
 
 } texel_t;
 
 
 typedef struct color_s
 {
-	vec4_t rgba;
+    vec4_t rgba;
 
 } color_t;
 
 
 typedef struct sprite_s
 {
-	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 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;
 
 } sprite_t;
 
 
 typedef struct sprite_seq_s
 {
-	int num_sprites;
-	sprite_t *sprite;
+    int num_sprites;
+    sprite_t *sprite;
 
 } sprite_seq_t;
 
@@ -110,32 +110,32 @@ typedef struct sprite_seq_s
 
 typedef struct texture_tri_s
 {
-	int index[3];
-	vec_t st[6];
-	int texture;
-	unsigned short transparency;
+    int index[3];
+    vec_t st[6];
+    int texture;
+    unsigned short transparency;
 
 } texture_tri_t;
 
 
 typedef struct model_mesh_s
 {
-	Vector<texture_tri_t *> texturedTriangles;
-	Vector<texture_tri_t *> coloredTriangles;
-	Vector<texture_tri_t *> texturedRectangles;
-	Vector<texture_tri_t *> coloredRectangles;
+    Vector<texture_tri_t *> texturedTriangles;
+    Vector<texture_tri_t *> coloredTriangles;
+    Vector<texture_tri_t *> texturedRectangles;
+    Vector<texture_tri_t *> coloredRectangles;
 
-	vec3_t center;
-	float radius;
+    vec3_t center;
+    float radius;
 
-	unsigned int vertexCount;
-	vec_t *vertices;
+    unsigned int vertexCount;
+    vec_t *vertices;
 
-	unsigned int colorCount;
-	vec_t *colors;
+    unsigned int colorCount;
+    vec_t *colors;
 
-	unsigned int normalCount;
-	vec_t *normals;
+    unsigned int normalCount;
+    vec_t *normals;
 
 } model_mesh_t;
 
@@ -145,40 +145,40 @@ typedef struct model_mesh_s
 
 typedef struct entity_s
 {
-	int id;                    // Unique identifier
-	float pos[3];              // World position
-	float angles[3];           // Eular angles (pitch, yaw, roll)
-	int type;                  // {(0x00, item), (0x01, ai), (0x02, player)}
-	int room;                  // Current room entity is in
-	worldMoveType moveType;    // Type of motion/clipping
-	bool moving;               // In motion?
-	struct entity_s *master;   // Part of entity chain?
-
-	int state;      // State of the Player, AI, or object
-	int objectId;              // What kind of entity?
-
-	int modelId;               // Animation model
-	void *tmpHook;
-	bool animate;
-
-	/*
-	  float time, lastTime;
-	  int state, lastState;
-	  int event, lastEvent;
-	  int goal;
-	 */
+    int id;                    // Unique identifier
+    float pos[3];              // World position
+    float angles[3];           // Eular angles (pitch, yaw, roll)
+    int type;                  // {(0x00, item), (0x01, ai), (0x02, player)}
+    int room;                  // Current room entity is in
+    worldMoveType moveType;    // Type of motion/clipping
+    bool moving;               // In motion?
+    struct entity_s *master;   // Part of entity chain?
+
+    int state;      // State of the Player, AI, or object
+    int objectId;              // What kind of entity?
+
+    int modelId;               // Animation model
+    void *tmpHook;
+    bool animate;
+
+    /*
+      float time, lastTime;
+      int state, lastState;
+      int event, lastEvent;
+      int goal;
+     */
 
 } entity_t;
 
 
 typedef struct static_model_s
 {
-	int index;     // model_mesh index
-	float yaw;     // angle of rotation on Y
-	float pos[3];  // position
+    int index;     // model_mesh index
+    float yaw;     // angle of rotation on Y
+    float pos[3];  // position
 
-	//vec3_t bboxMax;
-	//vec3_t bboxMin;
+    //vec3_t bboxMax;
+    //vec3_t bboxMin;
 
 } static_model_t;
 
@@ -186,48 +186,48 @@ typedef struct static_model_s
 
 typedef struct portal_s
 {
-	float vertices[4][3];
-	float normal[3];
-	int adjoining_room;
+    float vertices[4][3];
+    float normal[3];
+    int adjoining_room;
 
 } portal_t;
 
 
 typedef struct box_s
 {
-	vertex_t a;
-	vertex_t b;
-	vertex_t c;
-	vertex_t d;
+    vertex_t a;
+    vertex_t b;
+    vertex_t c;
+    vertex_t d;
 
 } box_t;
 
 typedef struct sector_s
 {
-	vec_t floor;
-	vec_t ceiling;
+    vec_t floor;
+    vec_t ceiling;
 
-	bool wall;
+    bool wall;
 
 } sector_t;
 
 //! \fixme No room mesh list or sprites and etc
 typedef struct room_mesh_s
 {
-	Vector<int> adjacentRooms;
-	Vector<portal_t *> portals;
-	Vector<static_model_t *> models;
-	Vector<sprite_t *> sprites;
-	Vector<box_t *> boxes;
-	Vector<sector_t *> sectors;
-
-	int id;
-	unsigned int flags;
-	unsigned int numXSectors;
-	unsigned int numZSectors;
-	float pos[3];
-	vec3_t bbox_min;
-	vec3_t bbox_max;
+    Vector<int> adjacentRooms;
+    Vector<portal_t *> portals;
+    Vector<static_model_t *> models;
+    Vector<sprite_t *> sprites;
+    Vector<box_t *> boxes;
+    Vector<sector_t *> sectors;
+
+    int id;
+    unsigned int flags;
+    unsigned int numXSectors;
+    unsigned int numZSectors;
+    float pos[3];
+    vec3_t bbox_min;
+    vec3_t bbox_max;
 
 } room_mesh_t;
 
@@ -235,57 +235,57 @@ typedef struct room_mesh_s
 // Workout generic entity and a client class from these entities
 typedef struct world_entity_s
 {
-	vec3_t pos;
-	vec3_t lastPos;
-	vec3_t angle;
-	vec_t ttl;
+    vec3_t pos;
+    vec3_t lastPos;
+    vec3_t angle;
+    vec_t ttl;
 
-	int type;
-	int state;
+    int type;
+    int state;
 
-	//struct world_entity_s *master;
+    //struct world_entity_s *master;
 
 } world_entity_t;
 
 
 typedef struct actor_entity_s
 {
-	vec3_t pos;
-	vec3_t lastPos;
-	vec3_t angle;
-	char clipping;
-	float time, eventTime, eventTimer;
-	int state, nextState;
-	float health;
-
-	// Client
-	unsigned int uid;
-	char name[32];
-	int actor, enemy;
-
-	// Render
-	unsigned int model;
-	unsigned int skin;
-	unsigned int animFrame;
+    vec3_t pos;
+    vec3_t lastPos;
+    vec3_t angle;
+    char clipping;
+    float time, eventTime, eventTimer;
+    int state, nextState;
+    float health;
+
+    // Client
+    unsigned int uid;
+    char name[32];
+    int actor, enemy;
+
+    // Render
+    unsigned int model;
+    unsigned int skin;
+    unsigned int animFrame;
 
 } actor_entity_t;
 
 enum OpenRaiderEvent
 {
-	eNone            = 0,
-	eWeaponDischarge,
-	eDying,
-	eDead,
-	eWounded,
-	eRunForward,
-	eRunBackward,
-	eJump,
-	eCrouchWalk,
-	eIdle,
-	eTaunt,
-	eTurn,
-	eRespawn,
-	eLand
+    eNone            = 0,
+    eWeaponDischarge,
+    eDying,
+    eDead,
+    eWounded,
+    eRunForward,
+    eRunBackward,
+    eJump,
+    eCrouchWalk,
+    eIdle,
+    eTaunt,
+    eTurn,
+    eRespawn,
+    eLand
 };
 
 
@@ -293,290 +293,290 @@ class World
 {
  public:
 
-	enum WorldFlag
-	{
-		fEnableHopping = 1
-	};
-
-	////////////////////////////////////////////////////////////
-	// Constructors
-	////////////////////////////////////////////////////////////
-
-	World();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Constructs an object of World
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.16:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	~World();
-	/*------------------------------------------------------
-	 * Pre  : World object is allocated
-	 * Post : Deconstructs an object of World
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.16:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-
-	////////////////////////////////////////////////////////////
-	// Public Accessors
-	////////////////////////////////////////////////////////////
-
-	int getRoomByLocation(int index, float x, float y, float z);
-	/*------------------------------------------------------
-	 * Pre  : index - Guessed room index
-	 * Post : Returns correct room index or -1 for unknown
-	 *
-	 *        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
-	 ------------------------------------------------------*/
-
-	int getRoomByLocation(float x, float y, float z);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Returns correct room index or -1 for unknown
-	 *
-	 *        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
-	 ------------------------------------------------------*/
-
-	int getAdjoiningRoom(int index,
-								float x, float y, float z,
-								float x2, float y2, float z2);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Looks for portal crossings from xyz to xyz2 segment
-	 *        from room[index] returns index of adjoined room or -1
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2003.05.29:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	int getSector(int room, float x, float z);
-	int getSector(int room, float x, float z, float *floor, float *ceiling);
-	/*------------------------------------------------------
-	 * Pre  : room - valid room index
-	 * Post : Gets the sector index of the position in room
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.20:
-	 * Mongoose - Created, factored out of Render class
-	 ------------------------------------------------------*/
-
-	unsigned int getRoomInfo(int room);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post :
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2003.05.28:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	bool isWall(int room, int sector);
-	/*------------------------------------------------------
-	 * Pre  : room - valid room index
-	 *        sector - valid sector index
-	 * Post : Returns true if this sector is a wall
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.20:
-	 * Mongoose - Created, factored out of Render class
-	 ------------------------------------------------------*/
-
-	bool getHeightAtPosition(int index, float x, float *y, float z);
-	/*------------------------------------------------------
-	 * Pre  : index - valid room index
-	 * Post : Returns true if position is in a room
-	 *        and sets y to the world height in that room
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.20:
-	 * Mongoose - Created, factored out of Render class
-	 ------------------------------------------------------*/
-
-	// Temp methods for rendering use until more refactoring is done
+    enum WorldFlag
+    {
+        fEnableHopping = 1
+    };
+
+    ////////////////////////////////////////////////////////////
+    // Constructors
+    ////////////////////////////////////////////////////////////
+
+    World();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Constructs an object of World
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.16:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    ~World();
+    /*------------------------------------------------------
+     * Pre  : World object is allocated
+     * Post : Deconstructs an object of World
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.16:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+
+    ////////////////////////////////////////////////////////////
+    // Public Accessors
+    ////////////////////////////////////////////////////////////
+
+    int getRoomByLocation(int index, float x, float y, float z);
+    /*------------------------------------------------------
+     * Pre  : index - Guessed room index
+     * Post : Returns correct room index or -1 for unknown
+     *
+     *        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
+     ------------------------------------------------------*/
+
+    int getRoomByLocation(float x, float y, float z);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Returns correct room index or -1 for unknown
+     *
+     *        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
+     ------------------------------------------------------*/
+
+    int getAdjoiningRoom(int index,
+                                float x, float y, float z,
+                                float x2, float y2, float z2);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Looks for portal crossings from xyz to xyz2 segment
+     *        from room[index] returns index of adjoined room or -1
+     *
+     *-- History ------------------------------------------
+     *
+     * 2003.05.29:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    int getSector(int room, float x, float z);
+    int getSector(int room, float x, float z, float *floor, float *ceiling);
+    /*------------------------------------------------------
+     * Pre  : room - valid room index
+     * Post : Gets the sector index of the position in room
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.20:
+     * Mongoose - Created, factored out of Render class
+     ------------------------------------------------------*/
+
+    unsigned int getRoomInfo(int room);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post :
+     *
+     *-- History ------------------------------------------
+     *
+     * 2003.05.28:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    bool isWall(int room, int sector);
+    /*------------------------------------------------------
+     * Pre  : room - valid room index
+     *        sector - valid sector index
+     * Post : Returns true if this sector is a wall
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.20:
+     * Mongoose - Created, factored out of Render class
+     ------------------------------------------------------*/
+
+    bool getHeightAtPosition(int index, float x, float *y, float z);
+    /*------------------------------------------------------
+     * Pre  : index - valid room index
+     * Post : Returns true if position is in a room
+     *        and sets y to the world height in that room
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.20:
+     * Mongoose - Created, factored out of Render class
+     ------------------------------------------------------*/
+
+    // Temp methods for rendering use until more refactoring is done
 #ifdef BAD_BLOOD
-	model_mesh_t *getMesh(int index);
-	skeletal_model_t *getModel(int index);
-	room_mesh_t *getRoom(int index);
-	Vector<entity_t *> *getEntities();
-	Vector<sprite_seq_t *> *getSprites();
-	Vector<room_mesh_t *> *getRooms();
+    model_mesh_t *getMesh(int index);
+    skeletal_model_t *getModel(int index);
+    room_mesh_t *getRoom(int index);
+    Vector<entity_t *> *getEntities();
+    Vector<sprite_seq_t *> *getSprites();
+    Vector<room_mesh_t *> *getRooms();
 #endif
 
-	////////////////////////////////////////////////////////////
-	// Public Mutators
-	////////////////////////////////////////////////////////////
-
-	void setFlag(WorldFlag flag);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Sets option flag
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.20:
-	 * Mongoose - Created, factored out of Render class
-	 ------------------------------------------------------*/
-
-	void clearFlag(WorldFlag flag);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Clears option flag
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.20:
-	 * Mongoose - Created, factored out of Render class
-	 ------------------------------------------------------*/
-
-	void destroy();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Clears all data in world, in future will check
-	 *        if data is in use before clearing
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.20:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
-
-	void addRoom(room_mesh_t *room);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Adds object to world
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.20:
-	 * Mongoose - Created, factored out of Render class
-	 ------------------------------------------------------*/
-
-	void addMesh(model_mesh_t *model);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Adds object to world
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.20:
-	 * Mongoose - Created, factored out of Render class
-	 ------------------------------------------------------*/
-
-	void addEntity(entity_t *e);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Adds object to world
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.20:
-	 * Mongoose - Created, factored out of Render class
-	 ------------------------------------------------------*/
-
-	int addModel(skeletal_model_t *model);
-	/*------------------------------------------------------
-	 * 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
-	 ------------------------------------------------------*/
-
-	void addSprite(sprite_seq_t *sprite);
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Adds object to world
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.20:
-	 * Mongoose - Created, factored out of Render class
-	 ------------------------------------------------------*/
-
-	void moveEntity(entity_t *e, char movement);
-	/*------------------------------------------------------
-	 * Pre  : movement - 'f' orward
-	 *                   'b' ackward
-	 *                   'l' eft
-	 *                   'r' ight
-	 *
-	 * Post : Move entity e in a given direction, unless
-	 *        a collision ocurrs
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.20:
-	 * Mongoose - Moved to WOrld class
-	 *
-	 * 2002.09.02:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
+    ////////////////////////////////////////////////////////////
+    // Public Mutators
+    ////////////////////////////////////////////////////////////
+
+    void setFlag(WorldFlag flag);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Sets option flag
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.20:
+     * Mongoose - Created, factored out of Render class
+     ------------------------------------------------------*/
+
+    void clearFlag(WorldFlag flag);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Clears option flag
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.20:
+     * Mongoose - Created, factored out of Render class
+     ------------------------------------------------------*/
+
+    void destroy();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Clears all data in world, in future will check
+     *        if data is in use before clearing
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.20:
+     * Mongoose - Created
+     ------------------------------------------------------*/
+
+    void addRoom(room_mesh_t *room);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Adds object to world
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.20:
+     * Mongoose - Created, factored out of Render class
+     ------------------------------------------------------*/
+
+    void addMesh(model_mesh_t *model);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Adds object to world
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.20:
+     * Mongoose - Created, factored out of Render class
+     ------------------------------------------------------*/
+
+    void addEntity(entity_t *e);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Adds object to world
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.20:
+     * Mongoose - Created, factored out of Render class
+     ------------------------------------------------------*/
+
+    int addModel(skeletal_model_t *model);
+    /*------------------------------------------------------
+     * 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
+     ------------------------------------------------------*/
+
+    void addSprite(sprite_seq_t *sprite);
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Adds object to world
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.20:
+     * Mongoose - Created, factored out of Render class
+     ------------------------------------------------------*/
+
+    void moveEntity(entity_t *e, char movement);
+    /*------------------------------------------------------
+     * Pre  : movement - 'f' orward
+     *                   'b' ackward
+     *                   'l' eft
+     *                   'r' ight
+     *
+     * Post : Move entity e in a given direction, unless
+     *        a collision ocurrs
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.20:
+     * Mongoose - Moved to WOrld class
+     *
+     * 2002.09.02:
+     * Mongoose - Created
+     ------------------------------------------------------*/
 
 
  private:
 
-	////////////////////////////////////////////////////////////
-	// Private Accessors
-	////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////
+    // Private Accessors
+    ////////////////////////////////////////////////////////////
 
 
-	////////////////////////////////////////////////////////////
-	// Private Mutators
-	////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////
+    // Private Mutators
+    ////////////////////////////////////////////////////////////
 
-	void clear();
-	/*------------------------------------------------------
-	 * Pre  :
-	 * Post : Clears all data in world
-	 *
-	 *-- History ------------------------------------------
-	 *
-	 * 2002.12.20:
-	 * Mongoose - Created
-	 ------------------------------------------------------*/
+    void clear();
+    /*------------------------------------------------------
+     * Pre  :
+     * Post : Clears all data in world
+     *
+     *-- History ------------------------------------------
+     *
+     * 2002.12.20:
+     * Mongoose - Created
+     ------------------------------------------------------*/
 
-	bool mClearLock;
+    bool mClearLock;
 
-	unsigned int mFlags;                   /* World flags */
+    unsigned int mFlags;                   /* World flags */
 
-	Vector<entity_t *> mEntities;	         /* World entities */
+    Vector<entity_t *> mEntities;            /* World entities */
 
-	Vector<room_mesh_t *> mRooms;	         /* Map data and meshes */
+    Vector<room_mesh_t *> mRooms;            /* Map data and meshes */
 
-	Vector<model_mesh_t *> mMeshes;	      /* Unanimated meshes */
+    Vector<model_mesh_t *> mMeshes;       /* Unanimated meshes */
 
-	Vector<sprite_seq_t *> mSprites;	      /* Sprites */
+    Vector<sprite_seq_t *> mSprites;          /* Sprites */
 
-	Vector<skeletal_model_t *> mModels; 	/* Skeletal animation models */
+    Vector<skeletal_model_t *> mModels;     /* Skeletal animation models */
 };
 
 #endif

include/tga.h

@@ -45,7 +45,7 @@ typedef struct mtk_image_tga_s
   unsigned char comment_lenght;       /* Number of bytes in comment */
   unsigned char colormap_type;        /* 0 No colormap; 1 Has colormap  */
   unsigned char image_type;           /* 1 Colormapped, 2 Unmapped;
-					 9 Colormapped RLE; 10 Unmapped RLE */
+                     9 Colormapped RLE; 10 Unmapped RLE */
 
   unsigned short colormap_index;      /* Index of first color map entry */
   unsigned short colormap_lenght;     /* Number of color map entries */
@@ -73,7 +73,7 @@ typedef struct mtk_image_tga_s
    ------------------------------------------------------*/
 
   int mtk_image__tga_load(FILE *f, unsigned char **image,
-			 unsigned int *width, unsigned int *height, char *type);
+             unsigned int *width, unsigned int *height, char *type);
   /*------------------------------------------------------
    * Pre  : Filename is a valid image file
    * Post : Image is either a valid pixmap or NULL
@@ -85,7 +85,7 @@ typedef struct mtk_image_tga_s
    ------------------------------------------------------*/
 
   int mtk_image__tga_save(FILE *f, unsigned char *image,
-			  unsigned int width, unsigned int height, char type);
+              unsigned int width, unsigned int height, char type);
   /*------------------------------------------------------
    * Pre  :
    * Post : Image is saved to diskfile if valid and can
@@ -98,9 +98,9 @@ typedef struct mtk_image_tga_s
 
 
   int mtk_image__tga_save_filename(unsigned char *image,
-				   unsigned int width, unsigned int height,
-				   char type,
-				   char *s, ...);
+                   unsigned int width, unsigned int height,
+                   char type,
+                   char *s, ...);
   /*------------------------------------------------------
    * Pre  :
    * Post : Image is saved to diskfile if valid and can

src/Camera.cpp

@@ -51,14 +51,14 @@ unsigned int Camera::mCounter = 0;
 
 Camera::Camera()
 {
-	mId = ++mCounter;
-	mFlags = 0;
-	mViewDistance = 14.0;
-	mTranslateDelta = 256.0;
-	mRotateDelta = HEL_DEG_TO_RAD(15.0);
- 	mRotateDelta2 = HEL_DEG_TO_RAD(5.0);
-	mFlags &= Camera_FlyMode;
-	reset();
+    mId = ++mCounter;
+    mFlags = 0;
+    mViewDistance = 14.0;
+    mTranslateDelta = 256.0;
+    mRotateDelta = HEL_DEG_TO_RAD(15.0);
+    mRotateDelta2 = HEL_DEG_TO_RAD(5.0);
+    mFlags &= Camera_FlyMode;
+    reset();
 }
 
 
@@ -73,49 +73,49 @@ Camera::~Camera()
 
 unsigned int Camera::getId()
 {
-	return mId;
+    return mId;
 }
 
 
 void Camera::getPosition(vec3_t pos)
 {
-	pos[0] = mPos[0];
-	pos[1] = mPos[1];
-	pos[2] = mPos[2];
+    pos[0] = mPos[0];
+    pos[1] = mPos[1];
+    pos[2] = mPos[2];
 }
 
 
 void Camera::getUp(vec3_t up)
 {
-	up[0] = mUp[0];
-	up[1] = mUp[1];
-	up[2] = mUp[2];
+    up[0] = mUp[0];
+    up[1] = mUp[1];
+    up[2] = mUp[2];
 }
 
 
 void Camera::getTarget(vec3_t target)
 {
-	target[0] = mTarget[0];
-	target[1] = mTarget[1];
-	target[2] = mTarget[2];
+    target[0] = mTarget[0];
+    target[1] = mTarget[1];
+    target[2] = mTarget[2];
 }
 
 
 float Camera::getYaw()
 {
-	return HEL_RAD_TO_DEG(mTheta);
+    return HEL_RAD_TO_DEG(mTheta);
 }
 
 
 double Camera::getRadianYaw()
 {
-	return mTheta;
+    return mTheta;
 }
 
 
 double Camera::getRadianPitch()
 {
-	return mTheta2;
+    return mTheta2;
 }
 
 
@@ -125,253 +125,253 @@ double Camera::getRadianPitch()
 
 void Camera::rotate(float angle, float x, float y, float z)
 {
-	Quaternion t, n;
-	Matrix matrix;
-	double side[4] = { 1, 0,  0, 1 };
-	double up[4] =   { 0, 1,  0, 1 };
-	double look[4] = { 0, 0, -1, 1 };
- 	unsigned int i;
-	matrix_t m;
-
-
-	t.set(angle, x, y, z);
-	n = mQ * t;
-	n.normalize();
-
-	n.getMatrix(m);
-	matrix.setMatrix(m);
-	matrix.multiply4d(side, mSide);
-	matrix.multiply4d(look, mTarget);
-	matrix.multiply4d(up, mUp);
-
-	for (i = 0; i < 3; ++i)
-	{
-		mSide[i] += mPos[i];
-		mTarget[i] += mPos[i];
-		mUp[i] += mPos[i];
-	}
-
-	mQ = n;
+    Quaternion t, n;
+    Matrix matrix;
+    double side[4] = { 1, 0,  0, 1 };
+    double up[4] =   { 0, 1,  0, 1 };
+    double look[4] = { 0, 0, -1, 1 };
+    unsigned int i;
+    matrix_t m;
+
+
+    t.set(angle, x, y, z);
+    n = mQ * t;
+    n.normalize();
+
+    n.getMatrix(m);
+    matrix.setMatrix(m);
+    matrix.multiply4d(side, mSide);
+    matrix.multiply4d(look, mTarget);
+    matrix.multiply4d(up, mUp);
+
+    for (i = 0; i < 3; ++i)
+    {
+        mSide[i] += mPos[i];
+        mTarget[i] += mPos[i];
+        mUp[i] += mPos[i];
+    }
+
+    mQ = n;
 }
 
 
 void Camera::translate(float x, float y, float z)
 {
-	int i;
-	double result[4];
-	double v[4];
-	matrix_t m;
-	Matrix matrix;
-
-
-	v[0] = x;
-	v[1] = y;
-	v[2] = -z;
-	v[3] = 1;
-
-	m[0] = mSide[0] - mPos[0];
-	m[1] = mUp[0] - mPos[0];
-	m[2] = mTarget[0] - mPos[0];
-	m[3] = 0;
-	m[4] = mSide[1] - mPos[1];
-	m[5] = mUp[1] - mPos[1];
-	m[6] = mTarget[1] - mPos[1];
-	m[7] = 0;
-	m[8] = mSide[2] - mPos[2];
-	m[9] = mUp[2] - mPos[2];
-	m[10] = mTarget[2] - mPos[2];
-	m[11] = 0;
-	m[12] = 0;
-	m[13] = 0;
-	m[14] = 0;
-	m[15] = 1;
-
-	matrix.setMatrix(m);
-	matrix.multiply4d(v, result);
-
-	for (i = 0; i < 3; ++i)
-	{
-		mSide[i] += result[i];
-		mUp[i] += result[i];
-		mTarget[i] += result[i];
-		mPos[i] += result[i];
-	}
-
-	mPos[0] = x;
-	mPos[1] = y;
-	mPos[2] = z;
+    int i;
+    double result[4];
+    double v[4];
+    matrix_t m;
+    Matrix matrix;
+
+
+    v[0] = x;
+    v[1] = y;
+    v[2] = -z;
+    v[3] = 1;
+
+    m[0] = mSide[0] - mPos[0];
+    m[1] = mUp[0] - mPos[0];
+    m[2] = mTarget[0] - mPos[0];
+    m[3] = 0;
+    m[4] = mSide[1] - mPos[1];
+    m[5] = mUp[1] - mPos[1];
+    m[6] = mTarget[1] - mPos[1];
+    m[7] = 0;
+    m[8] = mSide[2] - mPos[2];
+    m[9] = mUp[2] - mPos[2];
+    m[10] = mTarget[2] - mPos[2];
+    m[11] = 0;
+    m[12] = 0;
+    m[13] = 0;
+    m[14] = 0;
+    m[15] = 1;
+
+    matrix.setMatrix(m);
+    matrix.multiply4d(v, result);
+
+    for (i = 0; i < 3; ++i)
+    {
+        mSide[i] += result[i];
+        mUp[i] += result[i];
+        mTarget[i] += result[i];
+        mPos[i] += result[i];
+    }
+
+    mPos[0] = x;
+    mPos[1] = y;
+    mPos[2] = z;
 }
 
 
 void Camera::reset()
 {
-	mTheta = 0.0;
-	mTheta2 = 0.0;
+    mTheta = 0.0;
+    mTheta2 = 0.0;
 
-	mPos[0] = 0.0;
-	mPos[1] = 0.0;
-	mPos[2] = 0.0;
+    mPos[0] = 0.0;
+    mPos[1] = 0.0;
+    mPos[2] = 0.0;
 
-	mTarget[0] = 0.0;
-	mTarget[1] = 0.0;
-	mTarget[2] = mViewDistance;
+    mTarget[0] = 0.0;
+    mTarget[1] = 0.0;
+    mTarget[2] = mViewDistance;
 
-	mSide[0] = 1.0;
-	mSide[1] = 0.0;
-	mSide[2] = 0.0;
+    mSide[0] = 1.0;
+    mSide[1] = 0.0;
+    mSide[2] = 0.0;
 
-	mUp[0] = 0.0;
-	mUp[1] = 1.0;
-	mUp[2] = 0.0;
+    mUp[0] = 0.0;
+    mUp[1] = 1.0;
+    mUp[2] = 0.0;
 
-	mQ.setIdentity();
-	translate(0.0, 0.0, 0.0);
+    mQ.setIdentity();
+    translate(0.0, 0.0, 0.0);
 }
 
 
 void Camera::setSensitivityY(float angle)
 {
-	mRotateDelta2 = HEL_DEG_TO_RAD(angle);
+    mRotateDelta2 = HEL_DEG_TO_RAD(angle);
 }
 
 
 void Camera::setSensitivityX(float angle)
 {
-	mRotateDelta = HEL_DEG_TO_RAD(angle);
+    mRotateDelta = HEL_DEG_TO_RAD(angle);
 }
 
 
 ////////
 void Camera::command(enum camera_command cmd)
 {
-	switch (cmd)
-	{
-	case CAMERA_MOVE_FORWARD:
-		if (mFlags & Camera_FlyMode)
-		{
-			mPos[2] += (mTranslateDelta * cos(mTheta));
-		}
-
-	  mPos[0] += (mTranslateDelta * sin(mTheta));
-	  mPos[1] += (mTranslateDelta * sin(mTheta2));
-	  break;
-  case CAMERA_MOVE_BACKWARD:
-	  if (mFlags & Camera_FlyMode)
-	  {
-		  mPos[2] -= (mTranslateDelta * cos(mTheta));
-	  }
-
-	  mPos[0] -= (mTranslateDelta * sin(mTheta));
-	  mPos[1] -= (mTranslateDelta * sin(mTheta2));
-	  break;
-  case CAMERA_MOVE_LEFT:
-	  mPos[0] -= (mTranslateDelta * sin(mTheta - 90.0f));
-	  mPos[2] -= (mTranslateDelta * cos(mTheta - 90.0f));
-	  break;
-  case CAMERA_MOVE_RIGHT:
-	  mPos[0] -= (mTranslateDelta * sin(mTheta + 90.0f));
-	  mPos[2] -= (mTranslateDelta * cos(mTheta + 90.0f));
-	  break;
- case CAMERA_ROTATE_UP:
-     if (mTheta2 < (M_PI / 2)) {
-	    mTheta2 += mRotateDelta2;
-	    rotate(mTheta2, 1.0, 0.0, 0.0);
-     }
-	 break;
- case CAMERA_ROTATE_DOWN:
-     if (mTheta2 > -(M_PI / 2)) {
-         mTheta2 -= mRotateDelta2;
-         rotate(mTheta2, 1.0, 0.0, 0.0);
-     }
-     break;
- case CAMERA_ROTATE_RIGHT:
-	 mTheta += mRotateDelta;
-	 rotate(mTheta, 0.0, 1.0, 0.0);
-	 break;
-  case CAMERA_ROTATE_LEFT:
-	  mTheta -= mRotateDelta;
-	  rotate(mTheta, 0.0, 1.0, 0.0);
-	  break;
-  case CAMERA_MOVE_UP:
-	  mPos[1] -= mTranslateDelta / 2.0;
-	  mTarget[1] -= mTranslateDelta / 2.0;
-	  break;
-  case CAMERA_MOVE_DOWN:
-	  mPos[1] += mTranslateDelta / 2.0;
-	  mTarget[1] += mTranslateDelta / 2.0;
-	  break;
-  case CAMERA_SPEED_UP:
-    ++mTranslateDelta;
-    break;
-  case CAMERA_SPEED_DOWN:
-    if (--mTranslateDelta < 0.0)
-      mTranslateDelta = 1.0;
-    break;
-  default:
-    ;
-  }
+    switch (cmd)
+    {
+        case CAMERA_MOVE_FORWARD:
+            if (mFlags & Camera_FlyMode)
+            {
+                mPos[2] += (mTranslateDelta * cos(mTheta));
+            }
+
+            mPos[0] += (mTranslateDelta * sin(mTheta));
+            mPos[1] += (mTranslateDelta * sin(mTheta2));
+            break;
+        case CAMERA_MOVE_BACKWARD:
+            if (mFlags & Camera_FlyMode)
+            {
+                mPos[2] -= (mTranslateDelta * cos(mTheta));
+            }
+
+            mPos[0] -= (mTranslateDelta * sin(mTheta));
+            mPos[1] -= (mTranslateDelta * sin(mTheta2));
+            break;
+        case CAMERA_MOVE_LEFT:
+            mPos[0] -= (mTranslateDelta * sin(mTheta - 90.0f));
+            mPos[2] -= (mTranslateDelta * cos(mTheta - 90.0f));
+            break;
+        case CAMERA_MOVE_RIGHT:
+            mPos[0] -= (mTranslateDelta * sin(mTheta + 90.0f));
+            mPos[2] -= (mTranslateDelta * cos(mTheta + 90.0f));
+            break;
+        case CAMERA_ROTATE_UP:
+            if (mTheta2 < (M_PI / 2)) {
+                mTheta2 += mRotateDelta2;
+                rotate(mTheta2, 1.0, 0.0, 0.0);
+            }
+            break;
+        case CAMERA_ROTATE_DOWN:
+            if (mTheta2 > -(M_PI / 2)) {
+                mTheta2 -= mRotateDelta2;
+                rotate(mTheta2, 1.0, 0.0, 0.0);
+            }
+            break;
+        case CAMERA_ROTATE_RIGHT:
+            mTheta += mRotateDelta;
+            rotate(mTheta, 0.0, 1.0, 0.0);
+            break;
+        case CAMERA_ROTATE_LEFT:
+            mTheta -= mRotateDelta;
+            rotate(mTheta, 0.0, 1.0, 0.0);
+            break;
+        case CAMERA_MOVE_UP:
+            mPos[1] -= mTranslateDelta / 2.0;
+            mTarget[1] -= mTranslateDelta / 2.0;
+            break;
+        case CAMERA_MOVE_DOWN:
+            mPos[1] += mTranslateDelta / 2.0;
+            mTarget[1] += mTranslateDelta / 2.0;
+            break;
+        case CAMERA_SPEED_UP:
+            ++mTranslateDelta;
+            break;
+        case CAMERA_SPEED_DOWN:
+            if (--mTranslateDelta < 0.0)
+                mTranslateDelta = 1.0;
+            break;
+        default:
+            ;
+    }
 }
 
 
 //! \fixme Mostly invalid for QUAT_CAM (can rotate on XYZ)
 bool Camera::isBehind(int x, int z)
 {
-  double bTheta, bCameraX, bCameraZ, Distance;
+    double bTheta, bCameraX, bCameraZ, Distance;
 
 
-  // Set up a "virtual camera" a huge distance behind us
-  bTheta = mTheta + HEL_PI;
+    // Set up a "virtual camera" a huge distance behind us
+    bTheta = mTheta + HEL_PI;
 
-  if (bTheta > HEL_PI)
-    bTheta -= HEL_2_PI;
+    if (bTheta > HEL_PI)
+        bTheta -= HEL_2_PI;
 
-   // 64k is a fair distance away...
-  bCameraX = (65536.0 * sin(bTheta)) + mPos[0];
-  bCameraZ = (65536.0 * cos(bTheta)) + mPos[2];
+    // 64k is a fair distance away...
+    bCameraX = (65536.0 * sin(bTheta)) + mPos[0];
+    bCameraZ = (65536.0 * cos(bTheta)) + mPos[2];
 
-  bCameraX -= x;
-  bCameraZ -= z;
-  Distance = sqrt((bCameraX * bCameraX) + (bCameraZ * bCameraZ));
+    bCameraX -= x;
+    bCameraZ -= z;
+    Distance = sqrt((bCameraX * bCameraX) + (bCameraZ * bCameraZ));
 
-  return (Distance < 65536.0);
+    return (Distance < 65536.0);
 }
 
 
 void Camera::setSpeed(float s)
 {
-	mTranslateDelta = s;
+    mTranslateDelta = s;
 }
 
 
 void Camera::update()
 {
-   mTarget[2] = (mViewDistance * cos(mTheta)) + mPos[2];
-   mTarget[0] = (mViewDistance * sin(mTheta)) + mPos[0];
-	mTarget[1] = (mViewDistance * sin(mTheta2)) + mPos[1]; // + height_offset;
+    mTarget[2] = (mViewDistance * cos(mTheta)) + mPos[2];
+    mTarget[0] = (mViewDistance * sin(mTheta)) + mPos[0];
+    mTarget[1] = (mViewDistance * sin(mTheta2)) + mPos[1]; // + height_offset;
 }
 
 
 void Camera::setPosition(vec3_t pos)
 {
-	mPos[0] = pos[0];
-	mPos[1] = pos[1];
-	mPos[2] = pos[2];
+    mPos[0] = pos[0];
+    mPos[1] = pos[1];
+    mPos[2] = pos[2];
 }
 
 
 void Camera::setUp(vec3_t up)
 {
-	mUp[0] = up[0];
-	mUp[1] = up[1];
-	mUp[2] = up[2];
+    mUp[0] = up[0];
+    mUp[1] = up[1];
+    mUp[2] = up[2];
 }
 
 
 void Camera::setTarget(vec3_t target)
 {
-	mTarget[0] = target[0];
-	mTarget[1] = target[1];
-	mTarget[2] = target[2];
+    mTarget[0] = target[0];
+    mTarget[1] = target[1];
+    mTarget[2] = target[2];
 }
 
 

src/Emitter.cpp

@@ -41,312 +41,312 @@ vec_t Emitter::mFrustum[6][4];
 
 int Emitter::compareParticleDist(const void *voidA, const void *voidB)
 {
-	Particle *a = (Particle *)voidA, *b = (Particle *)voidB;
-	float x, y, z, distA, distB;
-
-	if (!a || !b)
-		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 +
-				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 +
-				Emitter::mFrustum[5][3]);
-
-	// reverse less/greater than
-	// less than
-	if (distA > distB)
-		return -1;
-
-	// greater than ( no need for equal )
-	return 1;
+    Particle *a = (Particle *)voidA, *b = (Particle *)voidB;
+    float x, y, z, distA, distB;
+
+    if (!a || !b)
+        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 +
+            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 +
+            Emitter::mFrustum[5][3]);
+
+    // reverse less/greater than
+    // less than
+    if (distA > distB)
+        return -1;
+
+    // greater than ( no need for equal )
+    return 1;
 }
 
 
 Emitter::Emitter(const char *name, int n)
 {
-	_name = NULL;
-	_flags = 0;
-	_particle = NULL;
-	_count = 0;
-	_pos[0] = _pos[1] = _pos[2] = 0.0;
-	_mangle[0] = _mangle[1] = _mangle[2] = 0.0;
-
-	Name(name);
-	ParticleArray(n);
+    _name = NULL;
+    _flags = 0;
+    _particle = NULL;
+    _count = 0;
+    _pos[0] = _pos[1] = _pos[2] = 0.0;
+    _mangle[0] = _mangle[1] = _mangle[2] = 0.0;
+
+    Name(name);
+    ParticleArray(n);
 }
 
 
 Emitter::~Emitter()
 {
-	if (_name)
-	{
-		delete [] _name;
-	}
+    if (_name)
+    {
+        delete [] _name;
+    }
 
-	if (_particle)
-	{
-		delete [] _particle;
-	}
+    if (_particle)
+    {
+        delete [] _particle;
+    }
 
-	_count = 0;
+    _count = 0;
 }
 
 Particle *Emitter::Particles()
 {
-	return _particle;
+    return _particle;
 }
 
 
 int Emitter::Count()
 {
-	return _count;
+    return _count;
 }
 
 
 void Emitter::Pos(float *x, float *y, float *z)
 {
-	*x = _pos[0];
-	*y = _pos[1];
-	*z = _pos[2];
+    *x = _pos[0];
+    *y = _pos[1];
+    *z = _pos[2];
 }
 
 
 void Emitter::Pos(float x, float y, float z)
 {
-	_pos[0] = x;
-	_pos[1] = y;
-	_pos[2] = z;
+    _pos[0] = x;
+    _pos[1] = y;
+    _pos[2] = z;
 }
 
 
 void Emitter::Orientation(float *x, float *y, float *z)
 {
-	*x = _mangle[0];
-	*y = _mangle[1];
-	*z = _mangle[2];
+    *x = _mangle[0];
+    *y = _mangle[1];
+    *z = _mangle[2];
 }
 
 
 void Emitter::Orientation(float x, float y, float z)
 {
-	_mangle[0] = x;
-	_mangle[1] = y;
-	_mangle[2] = z;
+    _mangle[0] = x;
+    _mangle[1] = y;
+    _mangle[2] = z;
 }
 
 
 unsigned int Emitter::Flags()
 {
-  return _flags;
+    return _flags;
 }
 
 
 void Emitter::Flags(unsigned int flag, bool op)
 {
-  _flags |= flag;
+    _flags |= flag;
 
-  if (!op)
-    _flags ^= flag;
+    if (!op)
+        _flags ^= flag;
 }
 
 
 void Emitter::ParticleArray(int n)
 {
-	if (n)
-	{
-		if (_particle)
-		{
-			_count = 0;
-			delete [] _particle;
-		}
-
-		_count = n;
-		_particle = new Particle[_count];
-	}
+    if (n)
+    {
+        if (_particle)
+        {
+            _count = 0;
+            delete [] _particle;
+        }
+
+        _count = n;
+        _particle = new Particle[_count];
+    }
 }
 
 
 void Emitter::Name(const char *name)
 {
-	int l;
+    int l;
 
 
-	if (name && name[0])
-	{
-		if (_name)
-		{
-			delete [] _name;
-		}
+    if (name && name[0])
+    {
+        if (_name)
+        {
+            delete [] _name;
+        }
 
-		l = strlen(name);
-		_name = new char[l+1];
+        l = strlen(name);
+        _name = new char[l+1];
 
-		// Mongoose 2002.01.09, Mongoose says 'Only you can prevent overflows'
-		strncpy(_name, name, l);
-		_name[l] = 0;
-	}
+        // Mongoose 2002.01.09, Mongoose says 'Only you can prevent overflows'
+        strncpy(_name, name, l);
+        _name[l] = 0;
+    }
 }
 
 
 void Emitter::SetTextureId(int id)
 {
-	unsigned int i;
+    unsigned int i;
 
 
-	for (i = 0; i < _count; i++)
-		_particle[i].TextureId(id);
+    for (i = 0; i < _count; i++)
+        _particle[i].TextureId(id);
 }
 
 
 void Emitter::TextureId(unsigned int particle_start,
-								unsigned int particle_end, int id)
+        unsigned int particle_end, int id)
 {
-	unsigned int i;
+    unsigned int i;
 
 
-	if ((particle_start < _count) &&
-		 (particle_end > 0 && particle_end <= _count) &&
-		 (particle_start < particle_end))
-	{
-		for (i = particle_start; i < particle_end; i++)
-			_particle[i].TextureId(id);
-	}
+    if ((particle_start < _count) &&
+            (particle_end > 0 && particle_end <= _count) &&
+            (particle_start < particle_end))
+    {
+        for (i = particle_start; i < particle_end; i++)
+            _particle[i].TextureId(id);
+    }
 }
 
 
 void Emitter::Color(unsigned int particle_start, unsigned int particle_end,
-						  float r, float g, float b)
+        float r, float g, float b)
 {
-	unsigned int i;
+    unsigned int i;
 
 
-	if ((particle_start < _count) &&
-		 (particle_end > 0 && particle_end <= _count) &&
-		 (particle_start < particle_end))
-	{
-		for (i = particle_start; i < particle_end; i++)
-			_particle[i].Color(r, g, b);
-	}
+    if ((particle_start < _count) &&
+            (particle_end > 0 && particle_end <= _count) &&
+            (particle_start < particle_end))
+    {
+        for (i = particle_start; i < particle_end; i++)
+            _particle[i].Color(r, g, b);
+    }
 }
 
 
 void Emitter::Speed(unsigned int particle_start, unsigned int particle_end,
-						  float x, float y, float z)
+        float x, float y, float z)
 {
-	unsigned int i;
+    unsigned int i;
 
 
-	if ((particle_start < _count) &&
-		 (particle_end > 0 && particle_end <= _count) &&
-		 (particle_start < particle_end))
-	{
-		for (i = particle_start; i < particle_end; i++)
-			_particle[i].Speed(x, y, z);
-	}
+    if ((particle_start < _count) &&
+            (particle_end > 0 && particle_end <= _count) &&
+            (particle_start < particle_end))
+    {
+        for (i = particle_start; i < particle_end; i++)
+            _particle[i].Speed(x, y, z);
+    }
 }
 
 
 void Emitter::Force(unsigned int particle_start, unsigned int particle_end,
-						  float x, float y, float z)
+        float x, float y, float z)
 {
-	unsigned int i;
+    unsigned int i;
 
 
-	if ((particle_start < _count) &&
-		 (particle_end > 0 && particle_end <= _count) &&
-		 (particle_start < particle_end))
-	{
-		for (i = particle_start; i < particle_end; i++)
-			_particle[i].Force(x, y, z);
-	}
+    if ((particle_start < _count) &&
+            (particle_end > 0 && particle_end <= _count) &&
+            (particle_start < particle_end))
+    {
+        for (i = particle_start; i < particle_end; i++)
+            _particle[i].Force(x, y, z);
+    }
 }
 
 
 void Emitter::Draw()
 {
-	unsigned int i, p;
-	float x, y, z;
-	float r, g, b;
-	float life;
-
-
-	if (!_count || !_particle)
-	{
-		printf("Emitter::Draw> No particles!\n");
-		return;
-	}
-
-	glPushMatrix();
-
-	//glRotatef(_mangle[0], 1.0, 0.0, 0.0);
-	//glRotatef(_mangle[1], 0.0, 1.0, 0.0);
-	//glRotatef(_mangle[2], 0.0, 0.0, 1.0);
-	//glTranslatef(_pos[0], _pos[1], _pos[2]);
-
-	if (_flags & fUseDepthSorting)
-	{
-		qsort(_particle, _count, sizeof(Particle), compareParticleDist);
-	}
-
-	for (i = 0; i < _count; i++)
-	{
-		if (_particle[i].isActive())
-		{
-			_particle[i].Pos(&x, &y, &z);
-
-			if (_flags & fUseFrustumCulling)
-			{
-				for (p = 0; p < 6; ++p)
-				{
-					if (mFrustum[p][0] * x +
-						 mFrustum[p][1] * y +
-						 mFrustum[p][2] * z +
-						 mFrustum[p][3] < 0)
-					{
-						_particle[i].setActive(false);
-						break;
-					}
-				}
-
-				if (!_particle[i].isActive())
-					continue;
-			}
-
-			_particle[i].Color(&r, &g, &b);
-			life = _particle[i].Life();
-
-			// Mongoose 2002.01.01, Removed Texture agent dep
-			glBindTexture(GL_TEXTURE_2D, _particle[i].Texture());
-
-			// Alpha is determined by life, which is affected by blend amount
-			glColor4f(r, g, b, life);
-
-			// Render tristrip quad
-			glBegin(GL_TRIANGLE_STRIP);
-		      glTexCoord2d(1.0, 1.0);
-		      glVertex3f(x + 0.5, y + 0.5, z);
-
-		      glTexCoord2d(0.0, 1.0);
-		      glVertex3f(x - 0.5, y + 0.5, z);
-
-		      glTexCoord2d(1.0, 0.0);
-		      glVertex3f(x + 0.5, y - 0.5, z);
-
-		      glTexCoord2d(0.0, 0.0);
-		      glVertex3f(x - 0.5, y - 0.5, z);
-		    glEnd();
-
-			 // Update particle's attributes for it's life cycle
-			 _particle[i].Update();
-		}
-	}
-
-	glPopMatrix();
+    unsigned int i, p;
+    float x, y, z;
+    float r, g, b;
+    float life;
+
+
+    if (!_count || !_particle)
+    {
+        printf("Emitter::Draw> No particles!\n");
+        return;
+    }
+
+    glPushMatrix();
+
+    //glRotatef(_mangle[0], 1.0, 0.0, 0.0);
+    //glRotatef(_mangle[1], 0.0, 1.0, 0.0);
+    //glRotatef(_mangle[2], 0.0, 0.0, 1.0);
+    //glTranslatef(_pos[0], _pos[1], _pos[2]);
+
+    if (_flags & fUseDepthSorting)
+    {
+        qsort(_particle, _count, sizeof(Particle), compareParticleDist);
+    }
+
+    for (i = 0; i < _count; i++)
+    {
+        if (_particle[i].isActive())
+        {
+            _particle[i].Pos(&x, &y, &z);
+
+            if (_flags & fUseFrustumCulling)
+            {
+                for (p = 0; p < 6; ++p)
+                {
+                    if (mFrustum[p][0] * x +
+                            mFrustum[p][1] * y +
+                            mFrustum[p][2] * z +
+                            mFrustum[p][3] < 0)
+                    {
+                        _particle[i].setActive(false);
+                        break;
+                    }
+                }
+
+                if (!_particle[i].isActive())
+                    continue;
+            }
+
+            _particle[i].Color(&r, &g, &b);
+            life = _particle[i].Life();
+
+            // Mongoose 2002.01.01, Removed Texture agent dep
+            glBindTexture(GL_TEXTURE_2D, _particle[i].Texture());
+
+            // Alpha is determined by life, which is affected by blend amount
+            glColor4f(r, g, b, life);
+
+            // Render tristrip quad
+            glBegin(GL_TRIANGLE_STRIP);
+            glTexCoord2d(1.0, 1.0);
+            glVertex3f(x + 0.5, y + 0.5, z);
+
+            glTexCoord2d(0.0, 1.0);
+            glVertex3f(x - 0.5, y + 0.5, z);
+
+            glTexCoord2d(1.0, 0.0);
+            glVertex3f(x + 0.5, y - 0.5, z);
+
+            glTexCoord2d(0.0, 0.0);
+            glVertex3f(x - 0.5, y - 0.5, z);
+            glEnd();
+
+            // Update particle's attributes for it's life cycle
+            _particle[i].Update();
+        }
+    }
+
+    glPopMatrix();
 }

src/GLString.cpp

@@ -25,232 +25,232 @@
 
 GLString::GLString()
 {
-	_num_string_max = 0;
-	_num_string = 0;
-	_scale = 1.0;
-	_string = NULL;
+    _num_string_max = 0;
+    _num_string = 0;
+    _scale = 1.0;
+    _string = NULL;
 }
 
 
 GLString::~GLString()
 {
-	unsigned int i;
+    unsigned int i;
 
-	if (_string)
-	{
+    if (_string)
+    {
 
-		for (i = 0; i < _num_string; ++i)
-		{
-			if (_string[i].text)
-			{
-				delete [] _string[i].text;
-			}
-		}
+        for (i = 0; i < _num_string; ++i)
+        {
+            if (_string[i].text)
+            {
+                delete [] _string[i].text;
+            }
+        }
 
-		delete [] _string;
-	}
+        delete [] _string;
+    }
 }
 
 
 void GLString::Init(unsigned int max_strings)
 {
-	if (!max_strings)
-	{
-		return;
-	}
+    if (!max_strings)
+    {
+        return;
+    }
 
-	_num_string_max = max_strings;
-	_string = new gl_string_t[max_strings];
+    _num_string_max = max_strings;
+    _string = new gl_string_t[max_strings];
 }
 
 
 void GLString::SetChar(unsigned int string, unsigned int pos, char c)
 {
-	gl_string_t *str = GetString(string);
+    gl_string_t *str = GetString(string);
 
 
-	if (str && pos < str->len)
-	{
-		str->text[pos] = c;
-	}
+    if (str && pos < str->len)
+    {
+        str->text[pos] = c;
+    }
 }
 
 
 unsigned int GLString::GetStringLen(unsigned int string)
 {
-	gl_string_t *str = GetString(string);
+    gl_string_t *str = GetString(string);
 
 
-	if (str)
-	{
-		return str->len;
-	}
+    if (str)
+    {
+        return str->len;
+    }
 
-	return 0;
+    return 0;
 }
 
 
 char *GLString::GetBuffer(unsigned int string)
 {
-	gl_string_t *str = GetString(string);
+    gl_string_t *str = GetString(string);
 
 
-	if (str)
-	{
-		return str->text;
-	}
+    if (str)
+    {
+        return str->text;
+    }
 
-	return 0;
+    return 0;
 }
 
 
 void GLString::setActive(unsigned int string, bool active)
 {
-	gl_string_t *str;
+    gl_string_t *str;
 
 
-	str = GetString(string);
+    str = GetString(string);
 
-	if (str)
-	{
-		str->active = active;
-	}
+    if (str)
+    {
+        str->active = active;
+    }
 }
 
 
 void GLString::SetString(unsigned int string, const char *s, ...)
 {
-	va_list args;
-	gl_string_t *str;
-	unsigned int len;
+    va_list args;
+    gl_string_t *str;
+    unsigned int len;
 
 
-	str = GetString(string);
+    str = GetString(string);
 
-	if (s && s[0] && str)
-	{
-		str->active = true;
+    if (s && s[0] && str)
+    {
+        str->active = true;
 
-		len = strlen(s);
+        len = strlen(s);
 
-		if (len > str->len)
-		{
-			len = str->len - 1;
-		}
+        if (len > str->len)
+        {
+            len = str->len - 1;
+        }
 
-		va_start(args, s);
-		vsnprintf(str->text, str->len-2, s, args);
-		str->text[str->len-1] = 0;
-		va_end(args);
-	}
+        va_start(args, s);
+        vsnprintf(str->text, str->len-2, s, args);
+        str->text[str->len-1] = 0;
+        va_end(args);
+    }
 }
 
 
 void GLString::Scale(float scale)
 {
-	_scale = scale;
+    _scale = scale;
 }
 
 
 int GLString::glPrintf(int x, int y, const char *string, ...)
 {
-	int sz = 60;
-	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])
-	{
-		return -1;
-	}
-
-	if (_num_string > _num_string_max)
-	{
-		return -2;
-	}
-
-	// Mongoose 2002.01.01, Assume no longer than 'sz' wide lines
-	//   on first try
-	_string[_num_string].text = new char[sz];
-
-	// Mongoose 2002.01.03, Setup scale factor
-	_string[_num_string].scale = _scale;
-
-	//  Mongoose 2002.01.01, Setup position
-	_string[_num_string].x = x;
-	_string[_num_string].y = y;
-
-	va_start(args, string);
-
-	// Mongoose 2002.01.01, Get exact size needed if the first try fails
-	n = vsnprintf(_string[_num_string].text, sz, string, args);
-
-	// Mongoose 2002.01.01, Realloc correct amount if truncated
-	while (1)
-	{
-		if (n > -1 && n < sz)
-		{
-			break;
-		}
-
-		// Mongoose 2002.01.01, For glibc 2.1
-		if (n > -1)
-		{
-			sz = n + 1;
-			delete [] _string[_num_string].text;
-			_string[_num_string].text = new char[sz];
-			n = vsnprintf(_string[_num_string].text, sz, string, args);
-
-			break;
-		}
-		else // glibc 2.0
-		{
-			sz *= 2;
-			delete [] _string[_num_string].text;
-			_string[_num_string].text = new char[sz];
-			n = vsnprintf(_string[_num_string].text, sz, string, args);
-		}
-	}
-
-	va_end(args);
-
-
-	// 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
-	//   allocated a string
-	++_num_string;
-
-	return 0;
+    int sz = 60;
+    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])
+    {
+        return -1;
+    }
+
+    if (_num_string > _num_string_max)
+    {
+        return -2;
+    }
+
+    // Mongoose 2002.01.01, Assume no longer than 'sz' wide lines
+    //   on first try
+    _string[_num_string].text = new char[sz];
+
+    // Mongoose 2002.01.03, Setup scale factor
+    _string[_num_string].scale = _scale;
+
+    //  Mongoose 2002.01.01, Setup position
+    _string[_num_string].x = x;
+    _string[_num_string].y = y;
+
+    va_start(args, string);
+
+    // Mongoose 2002.01.01, Get exact size needed if the first try fails
+    n = vsnprintf(_string[_num_string].text, sz, string, args);
+
+    // Mongoose 2002.01.01, Realloc correct amount if truncated
+    while (1)
+    {
+        if (n > -1 && n < sz)
+        {
+            break;
+        }
+
+        // Mongoose 2002.01.01, For glibc 2.1
+        if (n > -1)
+        {
+            sz = n + 1;
+            delete [] _string[_num_string].text;
+            _string[_num_string].text = new char[sz];
+            n = vsnprintf(_string[_num_string].text, sz, string, args);
+
+            break;
+        }
+        else // glibc 2.0
+        {
+            sz *= 2;
+            delete [] _string[_num_string].text;
+            _string[_num_string].text = new char[sz];
+            n = vsnprintf(_string[_num_string].text, sz, string, args);
+        }
+    }
+
+    va_end(args);
+
+
+    // 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
+    //   allocated a string
+    ++_num_string;
+
+    return 0;
 }
 
 
 void GLString::Render(int width, int height)
 {
-	unsigned int i;
-
-	for (i = 0; i < _num_string; ++i)
-	{
-		if (_string[i].active)
-		{
-			glPrint2d(_string[i].x, _string[i].y,
-						 _string[i].scale,
-						 _string[i].text);
-		}
-	}
+    unsigned int i;
+
+    for (i = 0; i < _num_string; ++i)
+    {
+        if (_string[i].active)
+        {
+            glPrint2d(_string[i].x, _string[i].y,
+                    _string[i].scale,
+                    _string[i].text);
+        }
+    }
 }
 
 
 gl_string_t *GLString::GetString(unsigned int id)
 {
-	if (id < _num_string)
-	{
-		return _string + id;
-	}
+    if (id < _num_string)
+    {
+        return _string + id;
+    }
 
-	return NULL;
+    return NULL;
 }
 

src/MatMath.cpp

@@ -15,253 +15,253 @@
 
 
 vec_t helIntersectionOfAbstractSpheres(vec3_t centerA, vec_t radiusA,
-													vec3_t centerB, vec_t radiusB)
+        vec3_t centerB, vec_t radiusB)
 {
-	Vector3d a = Vector3d(centerA);
-	Vector3d b = Vector3d(centerB);
-	Vector3d d = a - b;
-	vec_t dist, minDist;
+    Vector3d a = Vector3d(centerA);
+    Vector3d b = Vector3d(centerB);
+    Vector3d d = a - b;
+    vec_t dist, minDist;
 
-	dist = Vector3d::dot(d, d);
-	minDist = radiusA + radiusB;
+    dist = Vector3d::dot(d, d);
+    minDist = radiusA + radiusB;
 
-	return (dist <= minDist * minDist);
+    return (dist <= minDist * minDist);
 }
 
 
 inline vec_t square(vec_t a)
 {
-	return a * a;
+    return a * a;
 }
 
 
 // Returns number of intersections and intersection position(s)
 // Got algorithm from http://astronomy.swin.edu.au/~pbourke/geometry/
 int helIntersectionOfAbstractSphereAndLine(vec3_t center, vec_t radius,
-														 vec3_t posA, vec3_t posB,
-														 vec3_t intersectionA,
-														 vec3_t intersectionB)
+        vec3_t posA, vec3_t posB,
+        vec3_t intersectionA,
+        vec3_t intersectionB)
 {
-	// float x , y , z;
-	vec_t a, b, c, mu, i ;
-
-
-	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]) +
-				 (posB[2] - posA[2]) * (posA[2] - center[2])));
-	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]) -
-		  square(radius));
-
-	i = b * b - 4 * a * c;
-
-
-	if (i < 0.0)
-	{
-		// No intersection
-		return 0;
-	}
-	else if (i == 0.0)
-	{
-		// One intersection
-		mu = -b/(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]);
-
-		return 1;
-	}
-	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]);
-		intersectionB[1] = posA[1] + mu*(posB[1]-posA[1]);
-		intersectionB[2] = posA[2] + mu*(posB[2]-posA[2]);
-
-		return 2;
-	}
+    // float x , y , z;
+    vec_t a, b, c, mu, i ;
+
+
+    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]) +
+                (posB[2] - posA[2]) * (posA[2] - center[2])));
+    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]) -
+            square(radius));
+
+    i = b * b - 4 * a * c;
+
+
+    if (i < 0.0)
+    {
+        // No intersection
+        return 0;
+    }
+    else if (i == 0.0)
+    {
+        // One intersection
+        mu = -b/(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]);
+
+        return 1;
+    }
+    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]);
+        intersectionB[1] = posA[1] + mu*(posB[1]-posA[1]);
+        intersectionB[2] = posA[2] + mu*(posB[2]-posA[2]);
+
+        return 2;
+    }
 }
 
 
 int helIntersectionLineAndPolygon(vec3_t intersect,
-											 vec3_t p1, vec3_t p2,
-											 vec3_t *polygon)
+        vec3_t p1, vec3_t p2,
+        vec3_t *polygon)
 {
-	//	vec3_t normal, a, b;
-	Vector3d a, b, normal, pA, pB;
-	vec_t d, denominator, mu;
-	double theta;
-
-
-	pA = Vector3d(p1);
-	pB = Vector3d(p2);
-
-	// Find normal
-	//mtkVectorSubtract(polygon[1], polygon[0], a);
-	a = Vector3d(polygon[1]) - Vector3d(polygon[0]);
-	//mtkVectorSubtract(polygon[2], polygon[0], b);
-	b = Vector3d(polygon[2]) - Vector3d(polygon[0]);
-	normal = Vector3d::cross(a, b);
-	//mtkVectorCrossProduct(a, b, normal);
-	normal.normalize();
-	//mtkVectorNormalize(normal, normal);
-
-	// find D
-	//d = (normal[0] * polygon[0][0] -
-	//	  normal[1] * polygon[0][1] -
-	//	  normal[2] * polygon[0][2]);
-	d = (normal.mVec[0] * polygon[0][0] -
-		  normal.mVec[1] * polygon[0][1] -
-		  normal.mVec[2] * polygon[0][2]);
-
-	// line segment parallel to plane?
-	//mtkVectorSubtract(p2, p1, a); // cache p2 - p1 => a
-	a = pB - pA;
-
-	//denominator = (normal[0] * a[0] +
-	//					normal[1] * a[1] +
-	//					normal[2] * a[2]);
-	denominator = Vector3d::dot(normal, a);
-
-	if (denominator > 0.0)
-		return 0;
-
-	// Line segment contains intercept point?
-	//mu = - ((d + normal[0] * p1[0] + normal[1] * p1[1] + normal[2] * p1[2]) /
-	//		  denominator);
-	mu = -((d + Vector3d::dot(normal, pA)) / denominator);
-
-	if (mu < 0.0 || mu > 1.0)
-		return 0;
-
-	//intersect[0] = p1[0] + mu * a[0];
-	//intersect[1] = p1[1] + mu * a[1];
-	//intersect[2] = p1[2] + mu * a[2];
-	b = pA + (a * mu);
-	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
+    //  vec3_t normal, a, b;
+    Vector3d a, b, normal, pA, pB;
+    vec_t d, denominator, mu;
+    double theta;
+
+
+    pA = Vector3d(p1);
+    pB = Vector3d(p2);
+
+    // Find normal
+    //mtkVectorSubtract(polygon[1], polygon[0], a);
+    a = Vector3d(polygon[1]) - Vector3d(polygon[0]);
+    //mtkVectorSubtract(polygon[2], polygon[0], b);
+    b = Vector3d(polygon[2]) - Vector3d(polygon[0]);
+    normal = Vector3d::cross(a, b);
+    //mtkVectorCrossProduct(a, b, normal);
+    normal.normalize();
+    //mtkVectorNormalize(normal, normal);
+
+    // find D
+    //d = (normal[0] * polygon[0][0] -
+    //    normal[1] * polygon[0][1] -
+    //    normal[2] * polygon[0][2]);
+    d = (normal.mVec[0] * polygon[0][0] -
+            normal.mVec[1] * polygon[0][1] -
+            normal.mVec[2] * polygon[0][2]);
+
+    // line segment parallel to plane?
+    //mtkVectorSubtract(p2, p1, a); // cache p2 - p1 => a
+    a = pB - pA;
+
+    //denominator = (normal[0] * a[0] +
+    //                  normal[1] * a[1] +
+    //                  normal[2] * a[2]);
+    denominator = Vector3d::dot(normal, a);
+
+    if (denominator > 0.0)
+        return 0;
+
+    // Line segment contains intercept point?
+    //mu = - ((d + normal[0] * p1[0] + normal[1] * p1[1] + normal[2] * p1[2]) /
+    //        denominator);
+    mu = -((d + Vector3d::dot(normal, pA)) / denominator);
+
+    if (mu < 0.0 || mu > 1.0)
+        return 0;
+
+    //intersect[0] = p1[0] + mu * a[0];
+    //intersect[1] = p1[1] + mu * a[1];
+    //intersect[2] = p1[2] + mu * a[2];
+    b = pA + (a * mu);
+    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
-	mtkVectorSubtract(polygon[0], intersect, a);
-	mtkVectorNormalize(a, a);
-	mtkVectorSubtract(polygon[1], intersect, b);
-	mtkVectorNormalize(b, b);
-	mtkVectorSubtract(polygon[2], intersect, c);
-	mtkVectorNormalize(c, c);
+    mtkVectorSubtract(polygon[0], intersect, a);
+    mtkVectorNormalize(a, a);
+    mtkVectorSubtract(polygon[1], intersect, b);
+    mtkVectorNormalize(b, b);
+    mtkVectorSubtract(polygon[2], intersect, c);
+    mtkVectorNormalize(c, c);
 
-	t0 = mtkVectorDotProduct(a, b);
-	t1 = mtkVectorDotProduct(b, c);
-	t2 = mtkVectorDotProduct(c, a);
+    t0 = mtkVectorDotProduct(a, b);
+    t1 = mtkVectorDotProduct(b, c);
+    t2 = mtkVectorDotProduct(c, a);
 
-	total = HEL_RAD_TO_DEG(acos(t0) + acos(t1) + acos(t2));
+    total = HEL_RAD_TO_DEG(acos(t0) + acos(t1) + acos(t2));
 
-	if (total - 360 < 0.0)
-		return 0;
+    if (total - 360 < 0.0)
+        return 0;
 #else // assume convex polygons here for sure
-	//mtkVectorSubtract(intersect, polygon[0], a);
-	//theta = mtkVectorDotProduct(a, normal);
-	theta = Vector3d::dot(b - Vector3d(polygon[0]), normal); // b = intersect
+    //mtkVectorSubtract(intersect, polygon[0], a);
+    //theta = mtkVectorDotProduct(a, normal);
+    theta = Vector3d::dot(b - Vector3d(polygon[0]), normal); // b = intersect
 
-	if (theta >= 90.0) // Yeah I know
-		return 0;
+    if (theta >= 90.0) // Yeah I know
+        return 0;
 #endif
 
-	return 1;
+    return 1;
 }
 
 
-vec_t helDistToSphereFromPlane3v(vec3_t center,	vec_t radius, vec4_t plane)
+vec_t helDistToSphereFromPlane3v(vec3_t center, vec_t radius, vec4_t plane)
 {
-	vec_t d;
+    vec_t d;
 
 
-	d = (plane[0] * center[0] +
-		  plane[1] * center[1] +
-		  plane[2] * center[2] +
-		  plane[3]);
+    d = (plane[0] * center[0] +
+            plane[1] * center[1] +
+            plane[2] * center[2] +
+            plane[3]);
 
-	if (d <= -radius)
-		return 0;
+    if (d <= -radius)
+        return 0;
 
-	return d + radius;
+    return d + radius;
 }
 
 
 vec_t helDistToBboxFromPlane3v(vec3_t min, vec3_t max, vec4_t plane)
 {
-	vec3_t center;
-	vec_t d, radius;
+    vec3_t center;
+    vec_t d, radius;
 
 
-	helMidpoint3v(min, max, center);
+    helMidpoint3v(min, max, center);
 
-	d = (plane[0] * center[0] +
-		  plane[1] * center[1] +
-		  plane[2] * center[2] +
-		  plane[3]);
+    d = (plane[0] * center[0] +
+            plane[1] * center[1] +
+            plane[2] * center[2] +
+            plane[3]);
 
-	radius = helDist3v(max, center);
+    radius = helDist3v(max, center);
 
-	if (d <= -radius)
-		return 0;
+    if (d <= -radius)
+        return 0;
 
-	return d + radius;
+    return d + radius;
 }
 
 
 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[2] - a[2]) * (b[2] - a[2]))));
+    return (sqrt( ((b[0] - a[0]) * (b[0] - a[0])) +
+                ((b[1] - a[1]) * (b[1] - a[1])) +
+                ((b[2] - a[2]) * (b[2] - a[2]))));
 }
 
 
 void helMidpoint3v(vec3_t a, vec3_t b, vec3_t mid)
 {
-	mid[0] = (a[0] + b[0]) / 2;
-	mid[1] = (a[1] + b[1]) / 2;
-	mid[2] = (a[2] + b[2]) / 2;
+    mid[0] = (a[0] + b[0]) / 2;
+    mid[1] = (a[1] + b[1]) / 2;
+    mid[2] = (a[2] + b[2]) / 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]));
+    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]));
+    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]));
+    return (sqrt(v[0]*v[0] + v[1]*v[1]));
 }
 
 
 vec_t helRandomNum(vec_t from, vec_t to)
 {
-	return from + ((to - from) * rand() / (RAND_MAX + 1.0));
+    return from + ((to - from) * rand() / (RAND_MAX + 1.0));
 }
 

src/Matrix.cpp

@@ -31,23 +31,23 @@
 
 Matrix::Matrix()
 {
-	setIdentity();
+    setIdentity();
 }
 
 
 Matrix::Matrix(matrix_t m)
 {
-	setMatrix(m);
+    setMatrix(m);
 }
 
 
 Matrix::Matrix(Quaternion &q)
 {
-	matrix_t m;
+    matrix_t m;
 
 
-	q.getMatrix(m);
-	setMatrix(m);
+    q.getMatrix(m);
+    setMatrix(m);
 }
 
 
@@ -63,128 +63,128 @@ Matrix::~Matrix()
 
 bool Matrix::getInvert(matrix_t out)
 {
-	matrix_t m;
+    matrix_t m;
 
 #ifdef COLUMN_ORDER
-	getMatrix(m);
+    getMatrix(m);
 #else
-	getTransposeMatrix(m);
+    getTransposeMatrix(m);
 #endif
 
-	/* Mongoose: This code was from a Jeff Lander tutorial which was based
-		on MESA GL's InvertMatrix */
+    /* Mongoose: This code was from a Jeff Lander tutorial which was based
+       on MESA GL's InvertMatrix */
 
-	/* NB. OpenGL Matrices are COLUMN major. */
+    /* 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;
-
-	/* choose pivot - or die */
-	if (fabs(r3[0])>fabs(r2[0])) SWAP_ROWS(r3, r2);
-	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;
-	s = r0[2]; r1[2] -= m1 * s; r2[2] -= m2 * s; r3[2] -= m3 * s;
-	s = r0[3]; r1[3] -= m1 * s; r2[3] -= m2 * s; r3[3] -= m3 * s;
-	s = r0[4];
-	if (s != 0.0) { r1[4] -= m1 * s; r2[4] -= m2 * s; r3[4] -= m3 * s; }
-	s = r0[5];
-	if (s != 0.0) { r1[5] -= m1 * s; r2[5] -= m2 * s; r3[5] -= m3 * s; }
-	s = r0[6];
-	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];
-	r2[3] -= m2 * r1[3]; r3[3] -= m3 * r1[3];
-	s = r1[4]; if (0.0 != s) { r2[4] -= m2 * s; r3[4] -= m3 * s; }
-	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),
-	r2[6] = s * (r2[6] - r3[6] * m2), r2[7] = s * (r2[7] - r3[7] * m2);
-	m1 = r1[3];
-	r1[4] -= r3[4] * m1, r1[5] -= r3[5] * m1,
-	r1[6] -= r3[6] * m1, r1[7] -= r3[7] * m1;
-	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),
-	r1[6] = s * (r1[6] - r2[6] * m1), r1[7] = s * (r1[7] - r2[7] * 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,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];
-
-	return true;
+    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;
+
+    /* choose pivot - or die */
+    if (fabs(r3[0])>fabs(r2[0])) SWAP_ROWS(r3, r2);
+    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;
+    s = r0[2]; r1[2] -= m1 * s; r2[2] -= m2 * s; r3[2] -= m3 * s;
+    s = r0[3]; r1[3] -= m1 * s; r2[3] -= m2 * s; r3[3] -= m3 * s;
+    s = r0[4];
+    if (s != 0.0) { r1[4] -= m1 * s; r2[4] -= m2 * s; r3[4] -= m3 * s; }
+    s = r0[5];
+    if (s != 0.0) { r1[5] -= m1 * s; r2[5] -= m2 * s; r3[5] -= m3 * s; }
+    s = r0[6];
+    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];
+    r2[3] -= m2 * r1[3]; r3[3] -= m3 * r1[3];
+    s = r1[4]; if (0.0 != s) { r2[4] -= m2 * s; r3[4] -= m3 * s; }
+    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),
+        r2[6] = s * (r2[6] - r3[6] * m2), r2[7] = s * (r2[7] - r3[7] * m2);
+    m1 = r1[3];
+    r1[4] -= r3[4] * m1, r1[5] -= r3[5] * m1,
+        r1[6] -= r3[6] * m1, r1[7] -= r3[7] * m1;
+    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),
+        r1[6] = s * (r1[6] - r2[6] * m1), r1[7] = s * (r1[7] - r2[7] * 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,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];
+
+    return true;
 #undef MAT
 #undef SWAP_ROWS
 }
@@ -192,120 +192,120 @@ bool Matrix::getInvert(matrix_t out)
 
 void Matrix::getMatrix(matrix_t mat)
 {
-	copy(mMatrix, mat);
+    copy(mMatrix, mat);
 }
 
 
 void Matrix::getTransposeMatrix(matrix_t m)
 {
-	m[ 0]= mMatrix[0]; m[ 1]= mMatrix[4]; m[ 2]= mMatrix[ 8]; m[ 3]=mMatrix[12];
-	m[ 4]= mMatrix[1]; m[ 5]= mMatrix[5]; m[ 6]= mMatrix[ 9]; m[ 7]=mMatrix[13];
-	m[ 8]= mMatrix[2]; m[ 9]= mMatrix[6]; m[10]= mMatrix[10]; m[11]=mMatrix[14];
-	m[12]= mMatrix[3]; m[13]= mMatrix[7]; m[14]= mMatrix[11]; m[15]=mMatrix[15];
+    m[ 0]= mMatrix[0]; m[ 1]= mMatrix[4]; m[ 2]= mMatrix[ 8]; m[ 3]=mMatrix[12];
+    m[ 4]= mMatrix[1]; m[ 5]= mMatrix[5]; m[ 6]= mMatrix[ 9]; m[ 7]=mMatrix[13];
+    m[ 8]= mMatrix[2]; m[ 9]= mMatrix[6]; m[10]= mMatrix[10]; m[11]=mMatrix[14];
+    m[12]= mMatrix[3]; m[13]= mMatrix[7]; m[14]= mMatrix[11]; m[15]=mMatrix[15];
 }
 
 
 Matrix Matrix::multiply(const Matrix &a, const Matrix &b)
 {
-	Matrix c;
+    Matrix c;
 
 
-	multiply(a.mMatrix, b.mMatrix, c.mMatrix);
+    multiply(a.mMatrix, b.mMatrix, c.mMatrix);
 
-	return c;
+    return c;
 }
 
 
 Matrix Matrix::operator *(const Matrix &a)
 {
-	return multiply(a, *this);
+    return multiply(a, *this);
 }
 
 
 Vector3d Matrix::operator *(Vector3d v)
 {
-	vec_t x = v.mVec[0], y = v.mVec[1], z = v.mVec[2];
+    vec_t x = v.mVec[0], y = v.mVec[1], z = v.mVec[2];
 
 
 #ifdef COLUMN_ORDER
-	// Column order
-	return Vector3d(mMatrix[0]*x + mMatrix[4]*y + mMatrix[ 8]*z + mMatrix[12],
-						 mMatrix[1]*x + mMatrix[5]*y + mMatrix[ 9]*z + mMatrix[13],
-						 mMatrix[2]*x + mMatrix[6]*y + mMatrix[10]*z + mMatrix[14]);
+    // Column order
+    return Vector3d(mMatrix[0]*x + mMatrix[4]*y + mMatrix[ 8]*z + mMatrix[12],
+            mMatrix[1]*x + mMatrix[5]*y + mMatrix[ 9]*z + mMatrix[13],
+            mMatrix[2]*x + mMatrix[6]*y + mMatrix[10]*z + mMatrix[14]);
 #else
-	// Row order
-	return Vector3d(mMatrix[0]*x + mMatrix[1]*y + mMatrix[ 2]*z + mMatrix[ 3],
-						 mMatrix[4]*x + mMatrix[5]*y + mMatrix[ 6]*z + mMatrix[ 7],
-						 mMatrix[8]*x + mMatrix[9]*y + mMatrix[10]*z + mMatrix[11]);
+    // Row order
+    return Vector3d(mMatrix[0]*x + mMatrix[1]*y + mMatrix[ 2]*z + mMatrix[ 3],
+            mMatrix[4]*x + mMatrix[5]*y + mMatrix[ 6]*z + mMatrix[ 7],
+            mMatrix[8]*x + mMatrix[9]*y + mMatrix[10]*z + mMatrix[11]);
 #endif
 }
 
 
 void Matrix::multiply3v(vec3_t v, vec3_t result)
 {
-	vec_t x = v[0], y = v[1], z = v[2];
+    vec_t x = v[0], y = v[1], z = v[2];
 
 
-   result[0] = mMatrix[0]*x + mMatrix[1]*y + mMatrix[ 2]*z + mMatrix[ 3];
-	result[1] = mMatrix[4]*x + mMatrix[5]*y + mMatrix[ 6]*z + mMatrix[ 7];
-	result[2] = mMatrix[8]*x + mMatrix[9]*y + mMatrix[10]*z + mMatrix[11];
+    result[0] = mMatrix[0]*x + mMatrix[1]*y + mMatrix[ 2]*z + mMatrix[ 3];
+    result[1] = mMatrix[4]*x + mMatrix[5]*y + mMatrix[ 6]*z + mMatrix[ 7];
+    result[2] = mMatrix[8]*x + mMatrix[9]*y + mMatrix[10]*z + mMatrix[11];
 }
 
 
 void Matrix::multiply4d(double *v, double *result)
 {
-	double x = v[0], y = v[1], z = v[2], w = v[3];
+    double 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;
-	result[3] = mMatrix[12]*x + mMatrix[13]*y + mMatrix[14]*z + mMatrix[15]*w;
+    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;
+    result[3] = mMatrix[12]*x + mMatrix[13]*y + mMatrix[14]*z + mMatrix[15]*w;
 }
 
 
 void Matrix::multiply4v(vec4_t v, vec4_t result)
 {
-	vec_t x = v[0], y = v[1], z = v[2], w = v[3];
+    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;
-	result[3] = mMatrix[12]*x + mMatrix[13]*y + mMatrix[14]*z + mMatrix[15]*w;
+    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;
+    result[3] = mMatrix[12]*x + mMatrix[13]*y + mMatrix[14]*z + mMatrix[15]*w;
 }
 
 
 void Matrix::print()
 {
 #ifdef COLUMN_ORDER
-	printf("{\n%f %f %f %f\n%f %f %f %f\n%f %f %f %f\n%f %f %f %f\n}\n",
-			 mMatrix[0], mMatrix[4], mMatrix[ 8], mMatrix[12],
-			 mMatrix[1], mMatrix[5], mMatrix[ 9], mMatrix[13],
-			 mMatrix[2], mMatrix[6], mMatrix[10], mMatrix[14],
-			 mMatrix[3], mMatrix[7], mMatrix[11], mMatrix[15]);
+    printf("{\n%f %f %f %f\n%f %f %f %f\n%f %f %f %f\n%f %f %f %f\n}\n",
+            mMatrix[0], mMatrix[4], mMatrix[ 8], mMatrix[12],
+            mMatrix[1], mMatrix[5], mMatrix[ 9], mMatrix[13],
+            mMatrix[2], mMatrix[6], mMatrix[10], mMatrix[14],
+            mMatrix[3], mMatrix[7], mMatrix[11], mMatrix[15]);
 #else
-	printf("{\n%f %f %f %f\n%f %f %f %f\n%f %f %f %f\n%f %f %f %f\n}\n",
-			 mMatrix[ 0], mMatrix[ 1], mMatrix[ 2], mMatrix[ 3],
-			 mMatrix[ 4], mMatrix[ 5], mMatrix[ 6], mMatrix[ 7],
-			 mMatrix[ 8], mMatrix[ 9], mMatrix[10], mMatrix[11],
-			 mMatrix[12], mMatrix[13], mMatrix[14], mMatrix[15]);
+    printf("{\n%f %f %f %f\n%f %f %f %f\n%f %f %f %f\n%f %f %f %f\n}\n",
+            mMatrix[ 0], mMatrix[ 1], mMatrix[ 2], mMatrix[ 3],
+            mMatrix[ 4], mMatrix[ 5], mMatrix[ 6], mMatrix[ 7],
+            mMatrix[ 8], mMatrix[ 9], mMatrix[10], mMatrix[11],
+            mMatrix[12], mMatrix[13], mMatrix[14], mMatrix[15]);
 #endif
 }
 
 
 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 &&
-		 mMatrix[ 9] == 0 && mMatrix[10] == 1 && mMatrix[11] == 0 &&
-		 mMatrix[12] == 0 && mMatrix[13] == 0 && mMatrix[14] == 0 &&
-		 mMatrix[15] == 1)
-		return true;
-
-	return false;
+    // 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 &&
+            mMatrix[ 9] == 0 && mMatrix[10] == 1 && mMatrix[11] == 0 &&
+            mMatrix[12] == 0 && mMatrix[13] == 0 && mMatrix[14] == 0 &&
+            mMatrix[15] == 1)
+        return true;
+
+    return false;
 }
 
 
@@ -315,91 +315,91 @@ bool Matrix::isIdentity()
 
 void Matrix::setMatrix(matrix_t mat)
 {
-	copy(mat, mMatrix);
+    copy(mat, mMatrix);
 }
 
 
 void Matrix::setIdentity()
 {
-	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[15] = 1;
+    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[15] = 1;
 }
 
 
 void Matrix::scale(const vec_t *xyz)
 {
-	scale(xyz[0], xyz[1], xyz[2]);
+    scale(xyz[0], xyz[1], xyz[2]);
 }
 
 
 void Matrix::scale(vec_t sx, vec_t sy, vec_t sz)
 {
-   matrix_t smatrix;
-	matrix_t tmp;
+    matrix_t smatrix;
+    matrix_t tmp;
 
 
-   smatrix[ 0] = sx;smatrix[ 1] = 0; smatrix[ 2] = 0; smatrix[ 3] = 0;
-   smatrix[ 4] = 0; smatrix[ 5] = sy;smatrix[ 6] = 0; smatrix[ 7] = 0;
-   smatrix[ 8] = 0; smatrix[ 9] = 0; smatrix[10] = sz;smatrix[11] = 0;
-   smatrix[12] = 0; smatrix[13] = 0; smatrix[14] = 0; smatrix[15] = 1;
+    smatrix[ 0] = sx;smatrix[ 1] = 0; smatrix[ 2] = 0; smatrix[ 3] = 0;
+    smatrix[ 4] = 0; smatrix[ 5] = sy;smatrix[ 6] = 0; smatrix[ 7] = 0;
+    smatrix[ 8] = 0; smatrix[ 9] = 0; smatrix[10] = sz;smatrix[11] = 0;
+    smatrix[12] = 0; smatrix[13] = 0; smatrix[14] = 0; smatrix[15] = 1;
 
-	copy(mMatrix, tmp);
-	multiply(tmp, smatrix, mMatrix);
+    copy(mMatrix, tmp);
+    multiply(tmp, smatrix, mMatrix);
 }
 
 
 void Matrix::rotate(const vec_t *xyz)
 {
-	rotate(xyz[0], xyz[1], xyz[2]);
+    rotate(xyz[0], xyz[1], xyz[2]);
 }
 
 
 void Matrix::rotate(vec_t ax, vec_t ay, vec_t az)
 {
-   matrix_t xmat, ymat, zmat, tmp, tmp2;
+    matrix_t xmat, ymat, zmat, tmp, tmp2;
 
 
-   xmat[ 0]=1;        xmat[ 1]=0;        xmat[ 2]=0;        xmat[ 3]=0;
-   xmat[ 4]=0;        xmat[ 5]=cos(ax);  xmat[ 6]=sin(ax);  xmat[ 7]=0;
-   xmat[ 8]=0;        xmat[ 9]=-sin(ax); xmat[10]=cos(ax);  xmat[11]=0;
-   xmat[12]=0;        xmat[13]=0;        xmat[14]=0;        xmat[15]=1;
+    xmat[ 0]=1;        xmat[ 1]=0;        xmat[ 2]=0;        xmat[ 3]=0;
+    xmat[ 4]=0;        xmat[ 5]=cos(ax);  xmat[ 6]=sin(ax);  xmat[ 7]=0;
+    xmat[ 8]=0;        xmat[ 9]=-sin(ax); xmat[10]=cos(ax);  xmat[11]=0;
+    xmat[12]=0;        xmat[13]=0;        xmat[14]=0;        xmat[15]=1;
 
-   ymat[ 0]=cos(ay);  ymat[ 1]=0;        ymat[ 2]=-sin(ay); ymat[ 3]=0;
-   ymat[ 4]=0;        ymat[ 5]=1;        ymat[ 6]=0;        ymat[ 7]=0;
-   ymat[ 8]=sin(ay);  ymat[ 9]=0;        ymat[10]=cos(ay);  ymat[11]=0;
-   ymat[12]=0;        ymat[13]=0;        ymat[14]=0;        ymat[15]=1;
+    ymat[ 0]=cos(ay);  ymat[ 1]=0;        ymat[ 2]=-sin(ay); ymat[ 3]=0;
+    ymat[ 4]=0;        ymat[ 5]=1;        ymat[ 6]=0;        ymat[ 7]=0;
+    ymat[ 8]=sin(ay);  ymat[ 9]=0;        ymat[10]=cos(ay);  ymat[11]=0;
+    ymat[12]=0;        ymat[13]=0;        ymat[14]=0;        ymat[15]=1;
 
-   zmat[ 0]=cos(az);  zmat[ 1]=sin(az);  zmat[ 2]=0;        zmat[ 3]=0;
-   zmat[ 4]=-sin(az); zmat[ 5]=cos(az);  zmat[ 6]=0;        zmat[ 7]=0;
-   zmat[ 8]=0;        zmat[ 9]=0;        zmat[10]=1;        zmat[11]=0;
-   zmat[12]=0;        zmat[13]=0;        zmat[14]=0;        zmat[15]=1;
+    zmat[ 0]=cos(az);  zmat[ 1]=sin(az);  zmat[ 2]=0;        zmat[ 3]=0;
+    zmat[ 4]=-sin(az); zmat[ 5]=cos(az);  zmat[ 6]=0;        zmat[ 7]=0;
+    zmat[ 8]=0;        zmat[ 9]=0;        zmat[10]=1;        zmat[11]=0;
+    zmat[12]=0;        zmat[13]=0;        zmat[14]=0;        zmat[15]=1;
 
-   multiply(mMatrix, ymat, tmp);
-   multiply(tmp, xmat, tmp2);
-   multiply(tmp2, zmat, mMatrix);
+    multiply(mMatrix, ymat, tmp);
+    multiply(tmp, xmat, tmp2);
+    multiply(tmp2, zmat, mMatrix);
 }
 
 
 void Matrix::translate(const vec_t *xyz)
 {
-	translate(xyz[0], xyz[1], xyz[2]);
+    translate(xyz[0], xyz[1], xyz[2]);
 }
 
 
 void Matrix::translate(vec_t tx, vec_t ty, vec_t tz)
 {
-   matrix_t tmat, tmp;
+    matrix_t tmat, tmp;
 
 
-   tmat[ 0]=1;  tmat[ 1]=0;  tmat[ 2]=0;  tmat[ 3]=0;
-   tmat[ 4]=0;  tmat[ 5]=1;  tmat[ 6]=0;  tmat[ 7]=0;
-   tmat[ 8]=0;  tmat[ 9]=0;  tmat[10]=1;  tmat[11]=0;
-   tmat[12]=tx; tmat[13]=ty; tmat[14]=tz; tmat[15]=1;
+    tmat[ 0]=1;  tmat[ 1]=0;  tmat[ 2]=0;  tmat[ 3]=0;
+    tmat[ 4]=0;  tmat[ 5]=1;  tmat[ 6]=0;  tmat[ 7]=0;
+    tmat[ 8]=0;  tmat[ 9]=0;  tmat[10]=1;  tmat[11]=0;
+    tmat[12]=tx; tmat[13]=ty; tmat[14]=tz; tmat[15]=1;
 
-	copy(mMatrix, tmp);
-	multiply(tmp, tmat, mMatrix);
+    copy(mMatrix, tmp);
+    multiply(tmp, tmat, mMatrix);
 }
 
 
@@ -415,131 +415,131 @@ void Matrix::translate(vec_t tx, vec_t ty, vec_t tz)
 void Matrix::copy(matrix_t source, matrix_t dest)
 {
 #ifdef FASTER_MATRIX
-	memcpy(dest, source, sizeof(matrix_t));
+    memcpy(dest, source, sizeof(matrix_t));
 #else
-	dest[ 0] = source[ 0];
-	dest[ 1] = source[ 1];
-	dest[ 2] = source[ 2];
-	dest[ 3] = source[ 3];
-
-	dest[ 4] = source[ 4];
-	dest[ 5] = source[ 5];
-	dest[ 6] = source[ 6];
-	dest[ 7] = source[ 7];
-
-	dest[ 8] = source[8];
-	dest[ 9] = source[9];
-	dest[10] = source[10];
-	dest[11] = source[11];
-
-	dest[12] = source[12];
-	dest[13] = source[13];
-	dest[14] = source[14];
-	dest[15] = source[15];
+    dest[ 0] = source[ 0];
+    dest[ 1] = source[ 1];
+    dest[ 2] = source[ 2];
+    dest[ 3] = source[ 3];
+
+    dest[ 4] = source[ 4];
+    dest[ 5] = source[ 5];
+    dest[ 6] = source[ 6];
+    dest[ 7] = source[ 7];
+
+    dest[ 8] = source[8];
+    dest[ 9] = source[9];
+    dest[10] = source[10];
+    dest[11] = source[11];
+
+    dest[12] = source[12];
+    dest[13] = source[13];
+    dest[14] = source[14];
+    dest[15] = source[15];
 #endif
 }
 
 
 void Matrix::multiply(const matrix_t a, const matrix_t b, matrix_t result)
 {
-	/* Generated code for matrix mult
+    /* Generated code for matrix mult
      * Code used:
 
     // char order is argument
-	int i, j, k;
-	if (order == 'r')
-	{
-		printf("// Row order\n");
-	}
-	else
-	{
-		printf("// Column order\n");
-	}
-	for (i = 0; i < 4; ++i)
-	{
-		for (j = 0; j < 4; ++j)
-		{
-			if (order == 'r')
-			{
-				printf("result[%2i] = ", j+i*4);
-			}
-			else
-			{
-				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" : " + ");
-				}
-				else
-				{
-					printf("a[%2i] * b[%2i]%s",
-							 i+k*4, k+j*4, (k == 3) ? ";\n" : " + ");
-				}
-				//sum+=(elements[i+k*4]*m.elements[k+j*4]);
-			}
-			//result.elements[i+j*4]=sum;
-		}
-		printf("\n");
-	}
-	printf("\n");
-	printf("// Transpose\n");
-	for(i = 0; i < 4; ++i)
-	{
-		for (j = 0; j < 4; ++j)
-		{
-			printf("a[%2i] = b[%2i]%s",
-					 j+i*4, i+j*4, (j == 3) ? ";\n" : "; ");
-		}
-	}
+    int i, j, k;
+    if (order == 'r')
+    {
+        printf("// Row order\n");
+    }
+    else
+    {
+        printf("// Column order\n");
+    }
+    for (i = 0; i < 4; ++i)
+    {
+        for (j = 0; j < 4; ++j)
+        {
+            if (order == 'r')
+            {
+                printf("result[%2i] = ", j+i*4);
+            }
+            else
+            {
+                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" : " + ");
+                }
+                else
+                {
+                    printf("a[%2i] * b[%2i]%s",
+                    i+k*4, k+j*4, (k == 3) ? ";\n" : " + ");
+                }
+                //sum+=(elements[i+k*4]*m.elements[k+j*4]);
+            }
+            //result.elements[i+j*4]=sum;
+        }
+        printf("\n");
+    }
+    printf("\n");
+    printf("// Transpose\n");
+    for(i = 0; i < 4; ++i)
+    {
+        for (j = 0; j < 4; ++j)
+        {
+            printf("a[%2i] = b[%2i]%s",
+            j+i*4, i+j*4, (j == 3) ? ";\n" : "; ");
+        }
+    }
 
      * was in test/Matrix.cpp
      */
 #ifdef COLUMN_ORDER
-	/* Column order */
-	result[ 0] = a[ 0] * b[ 0] + a[ 4] * b[ 1] + a[ 8] * b[ 2] + a[12] * b[ 3];
-	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[15] = a[ 3] * b[12] + a[ 7] * b[13] + a[11] * b[14] + a[15] * b[15];
+    /* Column order */
+    result[ 0] = a[ 0] * b[ 0] + a[ 4] * b[ 1] + a[ 8] * b[ 2] + a[12] * b[ 3];
+    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[15] = a[ 3] * b[12] + a[ 7] * b[13] + a[11] * b[14] + a[15] * b[15];
 #else
-	/* Row order */
-	result[ 0] = a[ 0] * b[ 0] + a[ 1] * b[ 4] + a[ 2] * b[ 8] + a[ 3] * b[12];
-	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];
-	result[15] = a[12] * b[ 3] + a[13] * b[ 7] + a[14] * b[11] + a[15] * b[15];
+    /* Row order */
+    result[ 0] = a[ 0] * b[ 0] + a[ 1] * b[ 4] + a[ 2] * b[ 8] + a[ 3] * b[12];
+    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];
+    result[15] = a[12] * b[ 3] + a[13] * b[ 7] + a[14] * b[11] + a[15] * b[15];
 #endif
 }
 

src/Particle.cpp

@@ -17,13 +17,13 @@
 
 Particle::Particle()
 {
-	setActive(true);
-	TextureId(0);
-	Speed(2000.0, 2000.0, 2000.0);
-	Color(1.0, 1.0, 1.0);
-	Force(0.0, 0.8, 0.0);
+    setActive(true);
+    TextureId(0);
+    Speed(2000.0, 2000.0, 2000.0);
+    Color(1.0, 1.0, 1.0);
+    Force(0.0, 0.8, 0.0);
 
-	Reset();
+    Reset();
 }
 
 
@@ -34,130 +34,130 @@ Particle::~Particle()
 
 void Particle::TextureId(int id)
 {
-	_texture = id;
+    _texture = id;
 }
 
 
 void Particle::setActive(bool active)
 {
-	_active = active;
+    _active = active;
 }
 
 
 void Particle::Speed(float x, float y, float z)
 {
-	_speed[0] = x;
-	_speed[1] = y;
-	_speed[2] = z;
+    _speed[0] = x;
+    _speed[1] = y;
+    _speed[2] = z;
 }
 
 
 void Particle::Color(float r, float g, float b)
 {
-	_color[0] = r;
-	_color[1] = g;
-	_color[2] = b;
+    _color[0] = r;
+    _color[1] = g;
+    _color[2] = b;
 }
 
 
 void Particle::Force(float x, float y, float z)
 {
-	_force[0] = x;
-	_force[1] = y;
-	_force[2] = z;
+    _force[0] = x;
+    _force[1] = y;
+    _force[2] = z;
 }
 
 
 void Particle::Reset()
 {
-	// Mongoose 2002.01.01, Ah, how old is that code?
+    // Mongoose 2002.01.01, Ah, how old is that code?
 #ifdef OBSOLOETE
-	_active = true;
-	_life = 1.0;
-	_blend = (float)(rand() % 100) / 1000.0 + 0.003;
+    _active = true;
+    _life = 1.0;
+    _blend = (float)(rand() % 100) / 1000.0 + 0.003;
 
-	_pos[0] = _pos[1] = _pos[2] = 0.0;
+    _pos[0] = _pos[1] = _pos[2] = 0.0;
 
-	_dir[0] = (float)((rand() % 50) - 26.0) * 10.0;
-	_dir[1] = (float)((rand() % 50) - 25.0) * 10.0;
-	_dir[2] = _dir[1];
+    _dir[0] = (float)((rand() % 50) - 26.0) * 10.0;
+    _dir[1] = (float)((rand() % 50) - 25.0) * 10.0;
+    _dir[2] = _dir[1];
 
-	_force[0] = 0.0;
-	_force[1] = -0.8;
-	_force[2] = 0.0;
+    _force[0] = 0.0;
+    _force[1] = -0.8;
+    _force[2] = 0.0;
 #else
-	//! \fixme _blend prob should have nonstatic range
-	_blend = (float)(0.003 + (0.1 * rand() / (RAND_MAX + 1.0))); // high order
-	//_blend = (float)(rand() % 100) / 1000.0 + 0.003;
-
-	//! \fixme Reset these using some nonstatic functions and values later
-	_life = 1.0;
-
-	_pos[0] = _pos[1] = _pos[2] = 0.0;
-
-	_dir[0] = (float)(-26.0 + (50.0 * rand() / (RAND_MAX + 1.0))); // high order
-	_dir[0] *= 10.0;
-	//_dir[0] = (float)((rand() % 50) - 26.0) * 10.0;
-	_dir[1] = (float)(-25.0 + (50.0 * rand() / (RAND_MAX + 1.0))); // high order
-	_dir[1] *= 10.0;
-	//_dir[1] = (float)((rand() % 50) - 25.0) * 10.0;
-	_dir[2] = _dir[1];
+    //! \fixme _blend prob should have nonstatic range
+    _blend = (float)(0.003 + (0.1 * rand() / (RAND_MAX + 1.0))); // high order
+    //_blend = (float)(rand() % 100) / 1000.0 + 0.003;
+
+    //! \fixme Reset these using some nonstatic functions and values later
+    _life = 1.0;
+
+    _pos[0] = _pos[1] = _pos[2] = 0.0;
+
+    _dir[0] = (float)(-26.0 + (50.0 * rand() / (RAND_MAX + 1.0))); // high order
+    _dir[0] *= 10.0;
+    //_dir[0] = (float)((rand() % 50) - 26.0) * 10.0;
+    _dir[1] = (float)(-25.0 + (50.0 * rand() / (RAND_MAX + 1.0))); // high order
+    _dir[1] *= 10.0;
+    //_dir[1] = (float)((rand() % 50) - 25.0) * 10.0;
+    _dir[2] = _dir[1];
 #endif
 }
 
 
 void Particle::Pos(float *x, float *y, float *z)
 {
-	*x = _pos[0];
-	*y = _pos[1];
-	*z = _pos[2];
+    *x = _pos[0];
+    *y = _pos[1];
+    *z = _pos[2];
 }
 
 
 void Particle::Color(float *r, float *g, float *b)
 {
-	*r = _color[0];
-	*g = _color[1];
-	*b = _color[2];
+    *r = _color[0];
+    *g = _color[1];
+    *b = _color[2];
 }
 
 
 float Particle::Life()
 {
-	return _life;
+    return _life;
 }
 
 
 void Particle::Update()
 {
-	// Adjust particle position
-	_pos[0] += _dir[0] / _speed[0];
-	_pos[1] += _dir[1] / _speed[1];
-	_pos[2] += _dir[2] / _speed[2];
-
-	// Adjust particle direction
-	_dir[0] += _force[0];
-	_dir[1] += _force[1];
-	_dir[2] += _force[2];
-
-	// Adjust particle blending/life
-	_life -= _blend;
-
-	// Reset 'dead' OR fully blended particles
-	if (_life < 0.0)
-	{
-		Reset();
-	}
+    // Adjust particle position
+    _pos[0] += _dir[0] / _speed[0];
+    _pos[1] += _dir[1] / _speed[1];
+    _pos[2] += _dir[2] / _speed[2];
+
+    // Adjust particle direction
+    _dir[0] += _force[0];
+    _dir[1] += _force[1];
+    _dir[2] += _force[2];
+
+    // Adjust particle blending/life
+    _life -= _blend;
+
+    // Reset 'dead' OR fully blended particles
+    if (_life < 0.0)
+    {
+        Reset();
+    }
 }
 
 
 int Particle::Texture()
 {
-	return _texture;
+    return _texture;
 }
 
 
 bool Particle::isActive()
 {
-	return _active;
+    return _active;
 }

src/Quaternion.cpp

@@ -30,28 +30,28 @@
 
 Quaternion::Quaternion()
 {
-	mW = 0;
-	mX = 0;
-	mY = 0;
-	mZ = 0;
+    mW = 0;
+    mX = 0;
+    mY = 0;
+    mZ = 0;
 }
 
 
 Quaternion::Quaternion(vec_t w, vec_t x, vec_t y, vec_t z)
 {
-	mW = w;
-	mX = x;
-	mY = y;
-	mZ = z;
+    mW = w;
+    mX = x;
+    mY = y;
+    mZ = z;
 }
 
 
 Quaternion::Quaternion(vec4_t v)
 {
-	mW = v[0];
-	mX = v[1];
-	mY = v[2];
-	mZ = v[3];
+    mW = v[0];
+    mX = v[1];
+    mY = v[2];
+    mZ = v[3];
 }
 
 
@@ -66,96 +66,96 @@ Quaternion::~Quaternion()
 
 void Quaternion::getMatrix(matrix_t m)
 {
-	m[ 0] = 1.0f - 2.0f * (mY*mY + mZ*mZ);
-	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;
-	m[15] = 1.0f;
+    m[ 0] = 1.0f - 2.0f * (mY*mY + mZ*mZ);
+    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;
+    m[15] = 1.0f;
 }
 
 
 Quaternion Quaternion::operator =(const Quaternion &q)
 {
-	mW	= q.mW;
-	mX = q.mX;
-	mY = q.mY;
-	mZ = q.mZ;
+    mW  = q.mW;
+    mX = q.mX;
+    mY = q.mY;
+    mZ = q.mZ;
 
-  return (*this);
+    return (*this);
 }
 
 
 Quaternion Quaternion::operator *(const Quaternion &q)
 {
-	return multiply(*this, q);
+    return multiply(*this, q);
 }
 
 
 Quaternion Quaternion::operator /(const Quaternion &q)
 {
-	return divide(*this, q);
+    return divide(*this, q);
 }
 
 
 Quaternion Quaternion::operator +(const Quaternion &q)
 {
-	return add(*this, q);
+    return add(*this, q);
 }
 
 
 Quaternion Quaternion::operator -(const Quaternion &q)
 {
-	return subtract(*this, q);
+    return subtract(*this, q);
 }
 
 
 bool Quaternion::operator ==(const Quaternion &q)
 {
-	return (mX == q.mX && mY == q.mY && mZ == q.mZ && mW == q.mW);
+    return (mX == q.mX && mY == q.mY && mZ == q.mZ && mW == q.mW);
 }
 
 
 Quaternion Quaternion::conjugate()
 {
-	return Quaternion(mW, -mX, -mY, -mZ);
+    return Quaternion(mW, -mX, -mY, -mZ);
 }
 
 
 Quaternion Quaternion::scale(vec_t s)
 {
-   return Quaternion(mW * s, mX * s, mY * s, mZ * s);
+    return Quaternion(mW * s, mX * s, mY * s, mZ * s);
 }
 
 
 Quaternion Quaternion::inverse()
 {
-	return conjugate().scale(1/magnitude());
+    return conjugate().scale(1/magnitude());
 }
 
 
 vec_t Quaternion::dot(Quaternion a, Quaternion b)
 {
-	return ((a.mW * b.mW) + (a.mX * b.mX) + (a.mY * b.mY) + (a.mZ * b.mZ));
+    return ((a.mW * b.mW) + (a.mX * b.mX) + (a.mY * b.mY) + (a.mZ * b.mZ));
 }
 
 
 vec_t Quaternion::magnitude()
 {
-	return sqrt(dot(*this, *this));
+    return sqrt(dot(*this, *this));
 }
 
 
@@ -165,200 +165,200 @@ vec_t Quaternion::magnitude()
 
 void Quaternion::setIdentity()
 {
-	mW = 1.0;
-	mX = 0.0;
-	mY = 0.0;
-	mZ = 0.0;
+    mW = 1.0;
+    mX = 0.0;
+    mY = 0.0;
+    mZ = 0.0;
 }
 
 
 void Quaternion::set(vec_t angle, vec_t x, vec_t y, vec_t z)
 {
-	vec_t temp, dist;
+    vec_t temp, dist;
 
 
-	// Normalize
-	temp = x*x + y*y + z*z;
+    // Normalize
+    temp = x*x + y*y + z*z;
 
-	dist = (float)(1.0 / sqrt(temp));
+    dist = (float)(1.0 / sqrt(temp));
 
-	x *= dist;
-	y *= dist;
-	z *= dist;
+    x *= dist;
+    y *= dist;
+    z *= dist;
 
-	mX = x;
-	mY = y;
-	mZ = z;
+    mX = x;
+    mY = y;
+    mZ = z;
 
-	mW = (float)cos(angle / 2.0f);
+    mW = (float)cos(angle / 2.0f);
 }
 
 
 void Quaternion::normalize()
 {
-	vec_t dist, square;
+    vec_t dist, square;
 
 
-	square = mX * mX + mY * mY + mZ * mZ + mW * mW;
+    square = mX * mX + mY * mY + mZ * mZ + mW * mW;
 
-	if (square > 0.0)
-	{
-		dist = (float)(1.0 / sqrt(square));
-	}
-	else
-	{
-		dist = 1;
-	}
+    if (square > 0.0)
+    {
+        dist = (float)(1.0 / sqrt(square));
+    }
+    else
+    {
+        dist = 1;
+    }
 
-	mX *= dist;
-	mY *= dist;
-	mZ *= dist;
-	mW *= dist;
+    mX *= dist;
+    mY *= dist;
+    mZ *= dist;
+    mW *= dist;
 }
 
 
 void Quaternion::copy(Quaternion q)
 {
-	mW = q.mW;
-	mX = q.mX;
-	mY = q.mY;
-	mZ = q.mZ;
+    mW = q.mW;
+    mX = q.mX;
+    mY = q.mY;
+    mZ = q.mZ;
 }
 
 
 Quaternion Quaternion::slerp(Quaternion a, Quaternion b, vec_t time)
 {
-	/*******************************************************************
-	 * Spherical Linear Interpolation algorthim
-	 *-----------------------------------------------------------------
-	 *
-	 * Interpolate between A and B rotations ( Find qI )
-	 *
-	 * qI = (((qB . qA)^ -1)^ Time) qA
-	 *
-	 * http://www.magic-software.com/Documentation/quat.pdf
-	 *
-	 * Thanks to digiben for algorithms and basis of the notes in
-	 * this func
-	 *
-	 *******************************************************************/
-
-	vec_t result, scaleA, scaleB, theta, sinTheta;
-	Quaternion i;
-
-
-	// Don't bother if it's the same rotation, it's the same as the result
-	if (a == b)
-	{
-		return a;
-	}
-
-	// 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)
-	{
-		// Negate quaternion B and the result of the dot product
-		b = Quaternion(-b.mW, -b.mX, -b.mY, -b.mZ);
-		result = -result;
-	}
-
-	// Set the first and second scale for the interpolation
-	scaleA = 1 - time;
-	scaleB = time;
-
-	// Next, we want to actually calculate the spherical interpolation.  Since this
-	// calculation is quite computationally expensive, we want to only perform it
-	// if the angle between the 2 quaternions is large enough to warrant it.  If the
-	// 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
-	// interpolation using.  This is because you won't really notice the difference.
-
-	// Check if the angle between the 2 quaternions was big enough
-	// to warrant such calculations
-	if (1 - result > 0.1f)
-	{
-		// Get the angle between the 2 quaternions, and then
-		// store the sin() of that angle
-		theta = (float)acos(result);
-		sinTheta = (float)sin(theta);
-
-		// Calculate the scale for qA and qB, according to
-		// 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.
-	return (a.scale(scaleA) + b.scale(scaleB));
+    /*******************************************************************
+     * Spherical Linear Interpolation algorthim
+     *-----------------------------------------------------------------
+     *
+     * Interpolate between A and B rotations ( Find qI )
+     *
+     * qI = (((qB . qA)^ -1)^ Time) qA
+     *
+     * http://www.magic-software.com/Documentation/quat.pdf
+     *
+     * Thanks to digiben for algorithms and basis of the notes in
+     * this func
+     *
+     *******************************************************************/
+
+    vec_t result, scaleA, scaleB, theta, sinTheta;
+    Quaternion i;
+
+
+    // Don't bother if it's the same rotation, it's the same as the result
+    if (a == b)
+    {
+        return a;
+    }
+
+    // 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)
+    {
+        // Negate quaternion B and the result of the dot product
+        b = Quaternion(-b.mW, -b.mX, -b.mY, -b.mZ);
+        result = -result;
+    }
+
+    // Set the first and second scale for the interpolation
+    scaleA = 1 - time;
+    scaleB = time;
+
+    // Next, we want to actually calculate the spherical interpolation.  Since this
+    // calculation is quite computationally expensive, we want to only perform it
+    // if the angle between the 2 quaternions is large enough to warrant it.  If the
+    // 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
+    // interpolation using.  This is because you won't really notice the difference.
+
+    // Check if the angle between the 2 quaternions was big enough
+    // to warrant such calculations
+    if (1 - result > 0.1f)
+    {
+        // Get the angle between the 2 quaternions, and then
+        // store the sin() of that angle
+        theta = (float)acos(result);
+        sinTheta = (float)sin(theta);
+
+        // Calculate the scale for qA and qB, according to
+        // 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.
+    return (a.scale(scaleA) + b.scale(scaleB));
 }
 
 
 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
-	{
-		 // 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;
-			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])
-		{
-			// 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
-			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
-		{
-			// 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;
-			y = (matrix[9] + matrix[6]) / scale;
-			z = 0.25f * scale;
-		}
-	}
-
-	mW = w;
-	mX = x;
-	mY = y;
-	mZ = z;
+    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
+    {
+        // 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;
+            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])
+        {
+            // 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
+            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
+        {
+            // 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;
+            y = (matrix[9] + matrix[6]) / scale;
+            z = 0.25f * scale;
+        }
+    }
+
+    mW = w;
+    mX = x;
+    mY = y;
+    mZ = z;
 }
 
 
@@ -368,34 +368,34 @@ void Quaternion::setByMatrix(matrix_t matrix)
 
 Quaternion Quaternion::multiply(Quaternion a, Quaternion b)
 {
-	return Quaternion(a.mW * b.mW - a.mX * b.mX - a.mY * b.mY - a.mZ * b.mZ,
-							a.mW * b.mX + a.mX * b.mW + a.mY * b.mZ - a.mZ * b.mY,
-							a.mW * b.mY + a.mY * b.mW + a.mZ * b.mX - a.mX * b.mZ,
-							a.mW * b.mZ + a.mZ * b.mW + a.mX * b.mY - a.mY * b.mX);
+    return Quaternion(a.mW * b.mW - a.mX * b.mX - a.mY * b.mY - a.mZ * b.mZ,
+            a.mW * b.mX + a.mX * b.mW + a.mY * b.mZ - a.mZ * b.mY,
+            a.mW * b.mY + a.mY * b.mW + a.mZ * b.mX - a.mX * b.mZ,
+            a.mW * b.mZ + a.mZ * b.mW + a.mX * b.mY - a.mY * b.mX);
 }
 
 
 Quaternion Quaternion::divide(Quaternion a, Quaternion b)
 {
-	return (a * (b.inverse()));
+    return (a * (b.inverse()));
 }
 
 
 Quaternion Quaternion::add(Quaternion a, Quaternion b)
 {
-	return Quaternion(a.mW + b.mW,
-							a.mX + b.mX,
-							a.mY + b.mY,
-							a.mZ + b.mZ);
+    return Quaternion(a.mW + b.mW,
+            a.mX + b.mX,
+            a.mY + b.mY,
+            a.mZ + b.mZ);
 }
 
 
 Quaternion Quaternion::subtract(Quaternion a, Quaternion b)
 {
-	return Quaternion(a.mW - b.mW,
-							a.mX - b.mX,
-							a.mY - b.mY,
-							a.mZ - b.mZ);
+    return Quaternion(a.mW - b.mW,
+            a.mX - b.mX,
+            a.mY - b.mY,
+            a.mZ - b.mZ);
 }
 
 

src/SDLSystem.cpp

@@ -55,9 +55,9 @@ unsigned int *gHeight = 0x0;
 
 SDLSystem::SDLSystem() : System()
 {
-	mWindow = 0x0;
-	gWidth = &m_width;
-	gHeight = &m_height;
+    mWindow = 0x0;
+    gWidth = &m_width;
+    gHeight = &m_height;
     mFirstMouseEvent = false;
     mFullscreen = false;
 }
@@ -74,7 +74,7 @@ SDLSystem::~SDLSystem()
 
 unsigned int SDLSystem::getTicks()
 {
-	return SDL_GetTicks();
+    return SDL_GetTicks();
 }
 
 
@@ -85,89 +85,89 @@ unsigned int SDLSystem::getTicks()
 #ifdef FIXME
 void SDLSystem::bindKeyCommand(const char *cmd, int key, int event)
 {
-	if (key > 255)
-	{
-		printf("Currently key event mapping only handles ASCII characters\n");
-		return;
-	}
+    if (key > 255)
+    {
+        printf("Currently key event mapping only handles ASCII characters\n");
+        return;
+    }
 
-	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);
 
-	keyEvents[key] = event;
+    keyEvents[key] = event;
 }
 #endif
 
 
 void SDLSystem::setGrabMouse(bool on)
 {
-	SDL_WM_GrabInput(on ? SDL_GRAB_ON : SDL_GRAB_OFF);
+    SDL_WM_GrabInput(on ? SDL_GRAB_ON : SDL_GRAB_OFF);
 }
 
 
 void SDLSystem::initVideo(unsigned int width, unsigned int height,
-								  bool fullscreen)
+        bool fullscreen)
 {
-	int flags = 0; //, x, y;
+    int flags = 0; //, x, y;
 
 
-	// Create GL context
-	SDL_Init(SDL_INIT_VIDEO);
-	printf("Created OpenGL Context\n");
-	atexit(SDL_Quit);
+    // Create GL context
+    SDL_Init(SDL_INIT_VIDEO);
+    printf("Created OpenGL Context\n");
+    atexit(SDL_Quit);
 
-	m_width = width;
-	m_height = height;
+    m_width = width;
+    m_height = height;
 
 #ifndef __APPLE__
-	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)
-			{
-				fprintf(stderr, "initVideo> SDL_GL_LoadLibrary failed!\n");
-				fprintf(stderr, "initVideo> Error is [%s].\n", SDL_GetError());
-				shutdown(1);
-			}
-		}
-	}
+    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)
+            {
+                fprintf(stderr, "initVideo> SDL_GL_LoadLibrary failed!\n");
+                fprintf(stderr, "initVideo> Error is [%s].\n", SDL_GetError());
+                shutdown(1);
+            }
+        }
+    }
 #endif
 
-	flags |= SDL_OPENGL;
+    flags |= SDL_OPENGL;
 
     mFullscreen = fullscreen;
-	if (mFullscreen)
-		flags |= SDL_FULLSCREEN;
+    if (mFullscreen)
+        flags |= SDL_FULLSCREEN;
 
     SDL_ShowCursor(SDL_DISABLE);
     setGrabMouse(true); // Always grab mouse!
 
-	SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
-	SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 5);
-	SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
-	SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
-	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
-	mWindow = SDL_SetVideoMode(width, height, 16, flags);
-	SDL_WM_SetCaption(VERSION, VERSION);
-	//SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
-	SDL_EnableKeyRepeat(100, SDL_DEFAULT_REPEAT_INTERVAL);
+    SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
+    SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 5);
+    SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
+    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
+    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
+    mWindow = SDL_SetVideoMode(width, height, 16, flags);
+    SDL_WM_SetCaption(VERSION, VERSION);
+    //SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
+    SDL_EnableKeyRepeat(100, SDL_DEFAULT_REPEAT_INTERVAL);
 
 #ifdef UNICODE_SUPPORT
-	//@JML get Unicode value of key for international keyboard
-	SDL_EnableUNICODE(1);
+    //@JML get Unicode value of key for international keyboard
+    SDL_EnableUNICODE(1);
 #endif
 
-	// Start game renderer
-	initGL();
+    // Start game renderer
+    initGL();
 
-	// Resize context
-	resizeGL(width, height);
+    // Resize context
+    resizeGL(width, height);
 }
 
 
@@ -175,323 +175,323 @@ void SDLSystem::resize(unsigned int width, unsigned int height)
 {
     int flags = 0;
 
-	GLfloat aspect;
+    GLfloat aspect;
 
 
-	m_width = width;
-	m_height = height;
+    m_width = width;
+    m_height = height;
 
-	aspect = (GLfloat)width/(GLfloat)height;
+    aspect = (GLfloat)width/(GLfloat)height;
 
-	glViewport(0, 0, width, height);
+    glViewport(0, 0, width, height);
 
-	glMatrixMode(GL_PROJECTION);
-	glLoadIdentity();
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
 
     // gluPerspective is deprecated!
-	// gluPerspective(m_fovY, aspect, m_clipNear, m_clipFar);
+    // gluPerspective(m_fovY, aspect, m_clipNear, m_clipFar);
     // fix: http://stackoverflow.com/a/2417756
     GLfloat fH = tan(float(m_fovY / 360.0f * 3.14159f) ) * m_clipNear;
     GLfloat fW = fH * aspect;
     glFrustum(-fW, fW, -fH, fH, m_clipNear, m_clipFar);
 
-	glMatrixMode(GL_MODELVIEW);
-	glLoadIdentity();
+    glMatrixMode(GL_MODELVIEW);
+    glLoadIdentity();
 
-	// Resize window
+    // Resize window
     flags |= SDL_OPENGL;
 
     if (mFullscreen)
         flags |= SDL_FULLSCREEN;
 
-	mWindow = SDL_SetVideoMode(width, height, 16, flags);
+    mWindow = SDL_SetVideoMode(width, height, 16, flags);
 
-	// Resize context
-	resizeGL(width, height);
+    // Resize context
+    resizeGL(width, height);
 }
 
 
 void SDLSystem::runGame()
 {
-	SDL_Event event;
-	unsigned int mkeys, mod, key;
-	int btn;
-	bool specialKey;
-
-
-	for (;;)
-	{
-		// Pause for 10-20 ms
-		SDL_Delay(10);
-
-		while (SDL_PollEvent(&event))
-		{
-			switch (event.type)
-			{
-			case SDL_QUIT:
-				shutdown(0);
-				break;
-			case SDL_MOUSEMOTION:
-				// Wrap motion
-                if (!mFirstMouseEvent) {
-                    mFirstMouseEvent = true;
-                } else {
-                    handleMouseMotionEvent(event.motion.xrel/2, event.motion.yrel/2);
-                }
-				break;
-			case SDL_MOUSEBUTTONDOWN:
-			case SDL_MOUSEBUTTONUP:
-				//handleMouseEvent(event.button.button, event.button.state,
-				//			          event.button.x, event.button.y);
-
-				switch (event.button.button)
-				{
-				case SDL_BUTTON_LEFT:
-					btn = SYS_MOUSE_LEFT;
-					break;
-				case SDL_BUTTON_RIGHT:
-					btn = SYS_MOUSE_RIGHT;
-					break;
-				case SDL_BUTTON_MIDDLE:
-					btn = SYS_MOUSE_MIDDLE;
-					break;
-				}
-
-				if (event.button.state == SDL_PRESSED)
-				{
-					handleKeyPressEvent(btn, 0); //! \fixme mod not used
-				}
-				else
-				{
-					handleKeyReleaseEvent(btn, 0); //! \fixme mod not used
-				}
-				break;
-			case SDL_KEYUP:
-			case SDL_KEYDOWN:
-				//SDL_GetMouseState(&x, &y); // Get cursor pos
-
-				mkeys = (unsigned int)SDL_GetModState();
-				mod = 0;
-
-				if (mkeys & KMOD_LSHIFT)
-					mod |= SYS_MOD_KEY_LSHIFT;
-
-				if (mkeys & KMOD_RSHIFT)
-					mod |= SYS_MOD_KEY_RSHIFT;
-
-				if (mkeys & KMOD_LCTRL)
-					mod |= SYS_MOD_KEY_LCTRL;
-
-				if (mkeys & KMOD_RCTRL)
-					mod |= SYS_MOD_KEY_RCTRL;
-
-				if (mkeys & KMOD_LALT)
-					mod |= SYS_MOD_KEY_LALT;
-
-				if (mkeys & KMOD_RALT)
-					mod |= SYS_MOD_KEY_RALT;
-
-                if (mkeys & KMOD_LMETA)
-					mod |= SYS_MOD_KEY_LMETA;
-
-				if (mkeys & KMOD_RMETA)
-					mod |= SYS_MOD_KEY_RMETA;
-
-				key = event.key.keysym.sym;
-				specialKey = false;
-
-				switch (key)
-				{
-				case SDLK_F1:
-					key = SYS_KEY_F1;
-					specialKey = true;
-					break;
-				case SDLK_F2:
-					key = SYS_KEY_F2;
-					specialKey = true;
-					break;
-				case SDLK_F3:
-					key = SYS_KEY_F3;
-					specialKey = true;
-					break;
-				case SDLK_F4:
-					key = SYS_KEY_F4;
-					specialKey = true;
-					break;
-				case SDLK_F5:
-					key = SYS_KEY_F5;
-					specialKey = true;
-					break;
-				case SDLK_F6:
-					key = SYS_KEY_F6;
-					specialKey = true;
-					break;
-				case SDLK_F7:
-					key = SYS_KEY_F7;
-					specialKey = true;
-					break;
-				case SDLK_F8:
-					key = SYS_KEY_F8;
-					specialKey = true;
-					break;
-				case SDLK_F9:
-					key = SYS_KEY_F9;
-					specialKey = true;
-					break;
-				case SDLK_F10:
-					key = SYS_KEY_F10;
-					specialKey = true;
-					break;
-				case SDLK_F11:
-					key = SYS_KEY_F11;
-					specialKey = true;
-					break;
-				case SDLK_F12:
-					key = SYS_KEY_F12;
-					specialKey = true;
-					break;
-				case SDLK_UP:
-					key = SYS_KEY_UP;
-					specialKey = true;
-					break;
-				case SDLK_DOWN:
-					key = SYS_KEY_DOWN;
-					specialKey = true;
-					break;
-				case SDLK_RIGHT:
-					key = SYS_KEY_RIGHT;
-					specialKey = true;
-					break;
-				case SDLK_LEFT:
-					key = SYS_KEY_LEFT;
-					specialKey = true;
-					break;
-				case SDLK_PAGEDOWN:
-					key = SYS_KEY_PAGEDOWN;
-					specialKey = true;
-					break;
-				case SDLK_PAGEUP:
-					key = SYS_KEY_PAGEUP;
-					specialKey = true;
-					break;
-				}
+    SDL_Event event;
+    unsigned int mkeys, mod, key;
+    int btn;
+    bool specialKey;
+
+
+    for (;;)
+    {
+        // Pause for 10-20 ms
+        SDL_Delay(10);
+
+        while (SDL_PollEvent(&event))
+        {
+            switch (event.type)
+            {
+                case SDL_QUIT:
+                    shutdown(0);
+                    break;
+                case SDL_MOUSEMOTION:
+                    // Wrap motion
+                    if (!mFirstMouseEvent) {
+                        mFirstMouseEvent = true;
+                    } else {
+                        handleMouseMotionEvent(event.motion.xrel/2, event.motion.yrel/2);
+                    }
+                    break;
+                case SDL_MOUSEBUTTONDOWN:
+                case SDL_MOUSEBUTTONUP:
+                    //handleMouseEvent(event.button.button, event.button.state,
+                    //                    event.button.x, event.button.y);
+
+                    switch (event.button.button)
+                    {
+                        case SDL_BUTTON_LEFT:
+                            btn = SYS_MOUSE_LEFT;
+                            break;
+                        case SDL_BUTTON_RIGHT:
+                            btn = SYS_MOUSE_RIGHT;
+                            break;
+                        case SDL_BUTTON_MIDDLE:
+                            btn = SYS_MOUSE_MIDDLE;
+                            break;
+                    }
+
+                    if (event.button.state == SDL_PRESSED)
+                    {
+                        handleKeyPressEvent(btn, 0); //! \fixme mod not used
+                    }
+                    else
+                    {
+                        handleKeyReleaseEvent(btn, 0); //! \fixme mod not used
+                    }
+                    break;
+                case SDL_KEYUP:
+                case SDL_KEYDOWN:
+                    //SDL_GetMouseState(&x, &y); // Get cursor pos
+
+                    mkeys = (unsigned int)SDL_GetModState();
+                    mod = 0;
+
+                    if (mkeys & KMOD_LSHIFT)
+                        mod |= SYS_MOD_KEY_LSHIFT;
+
+                    if (mkeys & KMOD_RSHIFT)
+                        mod |= SYS_MOD_KEY_RSHIFT;
+
+                    if (mkeys & KMOD_LCTRL)
+                        mod |= SYS_MOD_KEY_LCTRL;
+
+                    if (mkeys & KMOD_RCTRL)
+                        mod |= SYS_MOD_KEY_RCTRL;
+
+                    if (mkeys & KMOD_LALT)
+                        mod |= SYS_MOD_KEY_LALT;
+
+                    if (mkeys & KMOD_RALT)
+                        mod |= SYS_MOD_KEY_RALT;
+
+                    if (mkeys & KMOD_LMETA)
+                        mod |= SYS_MOD_KEY_LMETA;
+
+                    if (mkeys & KMOD_RMETA)
+                        mod |= SYS_MOD_KEY_RMETA;
+
+                    key = event.key.keysym.sym;
+                    specialKey = false;
+
+                    switch (key)
+                    {
+                        case SDLK_F1:
+                            key = SYS_KEY_F1;
+                            specialKey = true;
+                            break;
+                        case SDLK_F2:
+                            key = SYS_KEY_F2;
+                            specialKey = true;
+                            break;
+                        case SDLK_F3:
+                            key = SYS_KEY_F3;
+                            specialKey = true;
+                            break;
+                        case SDLK_F4:
+                            key = SYS_KEY_F4;
+                            specialKey = true;
+                            break;
+                        case SDLK_F5:
+                            key = SYS_KEY_F5;
+                            specialKey = true;
+                            break;
+                        case SDLK_F6:
+                            key = SYS_KEY_F6;
+                            specialKey = true;
+                            break;
+                        case SDLK_F7:
+                            key = SYS_KEY_F7;
+                            specialKey = true;
+                            break;
+                        case SDLK_F8:
+                            key = SYS_KEY_F8;
+                            specialKey = true;
+                            break;
+                        case SDLK_F9:
+                            key = SYS_KEY_F9;
+                            specialKey = true;
+                            break;
+                        case SDLK_F10:
+                            key = SYS_KEY_F10;
+                            specialKey = true;
+                            break;
+                        case SDLK_F11:
+                            key = SYS_KEY_F11;
+                            specialKey = true;
+                            break;
+                        case SDLK_F12:
+                            key = SYS_KEY_F12;
+                            specialKey = true;
+                            break;
+                        case SDLK_UP:
+                            key = SYS_KEY_UP;
+                            specialKey = true;
+                            break;
+                        case SDLK_DOWN:
+                            key = SYS_KEY_DOWN;
+                            specialKey = true;
+                            break;
+                        case SDLK_RIGHT:
+                            key = SYS_KEY_RIGHT;
+                            specialKey = true;
+                            break;
+                        case SDLK_LEFT:
+                            key = SYS_KEY_LEFT;
+                            specialKey = true;
+                            break;
+                        case SDLK_PAGEDOWN:
+                            key = SYS_KEY_PAGEDOWN;
+                            specialKey = true;
+                            break;
+                        case SDLK_PAGEUP:
+                            key = SYS_KEY_PAGEUP;
+                            specialKey = true;
+                            break;
+                    }
 
 #ifdef __APPLE__
-                // Handle CMD+Q to quit in all circumstances
-                if (key == 'q') {
-                    if (mod & SYS_MOD_KEY_LMETA) {
-                        shutdown(0);
+                    // Handle CMD+Q to quit in all circumstances
+                    if (key == 'q') {
+                        if (mod & SYS_MOD_KEY_LMETA) {
+                            shutdown(0);
+                        }
                     }
-                }
 #endif
 
 #ifdef UNICODE_SUPPORT
-				// JML: if a std key was pressed get it ascii code
-				if (!specialKey && key != 0)
-				{
-					if ((event.key.keysym.unicode & 0xFF80) == 0)
-					{
-						key= (unsigned int)(event.key.keysym.unicode & 0x7F);
-					}
-					else
-					{
-						key = 0;
-					}
-				}
+                    // JML: if a std key was pressed get it ascii code
+                    if (!specialKey && key != 0)
+                    {
+                        if ((event.key.keysym.unicode & 0xFF80) == 0)
+                        {
+                            key= (unsigned int)(event.key.keysym.unicode & 0x7F);
+                        }
+                        else
+                        {
+                            key = 0;
+                        }
+                    }
 #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
-                 */
-				if (key > 255 && key < 1000)
-				{
-					key = 0;
-				}
+                    /*! \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)
-					{
-						mConsoleMode = !mConsoleMode;
-						// Tmp hack
-						handleConsoleKeyPressEvent(mConsoleKey, 0);
-					}
-				}
-				else if (mConsoleMode) // Console keying ( text input )
-				{
-					switch (event.type)
-					{
-					case SDL_KEYDOWN:
-						handleConsoleKeyPressEvent(key, mod);
-						break;
-					default:
-						;
-					}
-				}
-				else if (mKeyEvents[key] != 0)// Bound key
-				{
-					//if (key < 255 && mKeyEvents[key] != 0)
-					key = mKeyEvents[key];
-
-					switch (event.type)
-					{
-					case SDL_KEYDOWN:
-						handleBoundKeyPressEvent(key);
-						break;
-					default:
-						handleBoundKeyReleaseEvent(key);
-					}
-				}
-				else // 'Classic' key event handlers
-				{
-					switch (event.type)
-					{
-					case SDL_KEYDOWN:
-						handleKeyPressEvent(key, mod);
-						break;
-					default:
-						handleKeyReleaseEvent(key, mod);
-					}
-				}
-				break;
-			case SDL_VIDEORESIZE:
-				resizeGL(event.resize.w, event.resize.h);
-				gameFrame();
-				break;
-			}
-		}
-
-		// Game frame
-		gameFrame();
-	}
+                    if (key == mConsoleKey)
+                    {
+                        if (event.type == SDL_KEYDOWN)
+                        {
+                            mConsoleMode = !mConsoleMode;
+                            // Tmp hack
+                            handleConsoleKeyPressEvent(mConsoleKey, 0);
+                        }
+                    }
+                    else if (mConsoleMode) // Console keying ( text input )
+                    {
+                        switch (event.type)
+                        {
+                            case SDL_KEYDOWN:
+                                handleConsoleKeyPressEvent(key, mod);
+                                break;
+                            default:
+                                ;
+                        }
+                    }
+                    else if (mKeyEvents[key] != 0)// Bound key
+                    {
+                        //if (key < 255 && mKeyEvents[key] != 0)
+                        key = mKeyEvents[key];
+
+                        switch (event.type)
+                        {
+                            case SDL_KEYDOWN:
+                                handleBoundKeyPressEvent(key);
+                                break;
+                            default:
+                                handleBoundKeyReleaseEvent(key);
+                        }
+                    }
+                    else // 'Classic' key event handlers
+                    {
+                        switch (event.type)
+                        {
+                            case SDL_KEYDOWN:
+                                handleKeyPressEvent(key, mod);
+                                break;
+                            default:
+                                handleKeyReleaseEvent(key, mod);
+                        }
+                    }
+                    break;
+                case SDL_VIDEORESIZE:
+                    resizeGL(event.resize.w, event.resize.h);
+                    gameFrame();
+                    break;
+            }
+        }
+
+        // Game frame
+        gameFrame();
+    }
 }
 
 
 void SDLSystem::shutdown(int i)
 {
-	//SDL_QuitSubSystem(SDL_OPENGL);
-	//SDL_Quit(); // Moved to atexit() call
+    //SDL_QuitSubSystem(SDL_OPENGL);
+    //SDL_Quit(); // Moved to atexit() call
 
-	//#ifdef DEBUG_MEMORY
-	//printf("[Mongoose MEMORY_DEBUG]\nUnfreed memory table:\n");
-	//dump_memory_report();
-	//#endif
+    //#ifdef DEBUG_MEMORY
+    //printf("[Mongoose MEMORY_DEBUG]\nUnfreed memory table:\n");
+    //dump_memory_report();
+    //#endif
 
-	exit(0);
+    exit(0);
 }
 
 
 void SDLSystem::toggleFullscreen()
 {
-	if (mWindow)
-	{
+    if (mWindow)
+    {
         mFullscreen = !mFullscreen;
-		SDL_ShowCursor(SDL_DISABLE);
+        SDL_ShowCursor(SDL_DISABLE);
 
         // SDL_WM_ToggleFullScreen does not work on all platforms
         // eg. Mac OS X
-		// SDL_WM_ToggleFullScreen(mWindow);
+        // SDL_WM_ToggleFullScreen(mWindow);
 
         // I added a mFullscreen flag to this class. Then I modified it's
         // resize() method to use the SDL_FULLSCREEN flag in the
@@ -525,12 +525,12 @@ void SDLSystem::toggleFullscreen()
             height = m_old_height;
         }
         resize(width, height);
-	}
+    }
 }
 
 
 void SDLSystem::swapBuffersGL()
 {
-	SDL_GL_SwapBuffers();
+    SDL_GL_SwapBuffers();
 }
 

src/SkeletalModel.cpp

@@ -31,54 +31,54 @@
 
 SkeletalModel::SkeletalModel()
 {
-	model = 0x0;
-	flags = 0;
-	mBoneFrame = 0;
-	mAnimationFrame = 0;
-	mIdleAnimation = 0;
+    model = 0x0;
+    flags = 0;
+    mBoneFrame = 0;
+    mAnimationFrame = 0;
+    mIdleAnimation = 0;
 }
 
 
 SkeletalModel::~SkeletalModel()
 {
-	if (model)
-	{
-		for (model->animation.start();
-			  model->animation.forward();
-			  model->animation.next())
-		{
-			animation_frame_t *af = model->animation.current();
+    if (model)
+    {
+        for (model->animation.start();
+                model->animation.forward();
+                model->animation.next())
+        {
+            animation_frame_t *af = model->animation.current();
 
-			if (!af)
-				continue;
+            if (!af)
+                continue;
 
-			for (af->frame.start(); af->frame.forward(); af->frame.next())
-			{
-				bone_frame_t *bf = af->frame.current();
+            for (af->frame.start(); af->frame.forward(); af->frame.next())
+            {
+                bone_frame_t *bf = af->frame.current();
 
-				if (!bf)
-					continue;
+                if (!bf)
+                    continue;
 
-				bf->tag.erase();
+                bf->tag.erase();
 
-				//for (bf->tag.start(); bf->tag.forward(); bf->tag.next())
-				//{
-				//	if (bf->tag.current())
-				//		delete bf->tag.current();
-				//}
+                //for (bf->tag.start(); bf->tag.forward(); bf->tag.next())
+                //{
+                //  if (bf->tag.current())
+                //      delete bf->tag.current();
+                //}
 
-				delete bf;
-			}
+                delete bf;
+            }
 
-			af->frame.clear();
+            af->frame.clear();
 
-			delete af;
-		}
+            delete af;
+        }
 
-		model->animation.clear();
+        model->animation.clear();
 
-		delete model;
-	}
+        delete model;
+    }
 }
 
 
@@ -88,19 +88,19 @@ SkeletalModel::~SkeletalModel()
 
 int SkeletalModel::getAnimation()
 {
-	return mAnimationFrame;
+    return mAnimationFrame;
 }
 
 
 int SkeletalModel::getFrame()
 {
-	return mBoneFrame;
+    return mBoneFrame;
 }
 
 
 int SkeletalModel::getIdleAnimation()
 {
-	return mIdleAnimation;
+    return mIdleAnimation;
 }
 
 
@@ -110,57 +110,57 @@ int SkeletalModel::getIdleAnimation()
 
 void SkeletalModel::setModel(skeletal_model_t *mdl)
 {
-	if (mdl)
-		model = mdl;
+    if (mdl)
+        model = mdl;
 }
 
 
 void SkeletalModel::setAnimation(int index)
 {
-	if (!model) // index > (int)model->animation.size())
-		return;
+    if (!model) // index > (int)model->animation.size())
+        return;
 
-	animation_frame_t *a = model->animation[index];
+    animation_frame_t *a = model->animation[index];
 
-	if (a)
-	{
-		mAnimationFrame = index;
-		mBoneFrame = 0;
-		rate = a->rate;
-	}
+    if (a)
+    {
+        mAnimationFrame = index;
+        mBoneFrame = 0;
+        rate = a->rate;
+    }
 }
 
 
 void SkeletalModel::setFrame(int index)
 {
-	if (!model)
-		return;
+    if (!model)
+        return;
 
-	animation_frame_t *a = model->animation[mAnimationFrame];
+    animation_frame_t *a = model->animation[mAnimationFrame];
 
-	if (a) // index > (int)a->frame.size())
-	{
-		bone_frame_t *b = a->frame[index];
+    if (a) // index > (int)a->frame.size())
+    {
+        bone_frame_t *b = a->frame[index];
 
-		if (b)
-		{
-			mBoneFrame = index;
-		}
-	}
+        if (b)
+        {
+            mBoneFrame = index;
+        }
+    }
 }
 
 
 void SkeletalModel::setIdleAnimation(int index)
 {
-	if (!model)
-		return;
+    if (!model)
+        return;
 
-	animation_frame_t *a = model->animation[index];
+    animation_frame_t *a = model->animation[index];
 
-	if (a)
-	{
-		mIdleAnimation = index;
-	}
+    if (a)
+    {
+        mIdleAnimation = index;
+    }
 }
 
 

src/Sound.cpp

@@ -39,73 +39,73 @@
 
 Sound::Sound()
 {
-	mSource[0] = 0;
-	mBuffer[0] = 0;
-	mNextBuffer = 0;
-	mNextSource = 0;
-	mInit = false;
+    mSource[0] = 0;
+    mBuffer[0] = 0;
+    mNextBuffer = 0;
+    mNextSource = 0;
+    mInit = false;
 }
 
 
 Sound::~Sound()
 {
-	if (mInit)
-	{
+    if (mInit)
+    {
 #ifdef USING_OPENAL
-		alutExit();
+        alutExit();
 #endif
-	}
+    }
 }
 
 
 int Sound::init()
 {
 #ifndef __APPLE__
-	int fd;
+    int fd;
 
-	fd = open("/dev/dsp", O_RDWR);
+    fd = open("/dev/dsp", O_RDWR);
 
-	if (fd < 0)
-	{
-		perror("Sound::Init> Could not open /dev/dsp : ");
-		return -1;
-	}
+    if (fd < 0)
+    {
+        perror("Sound::Init> Could not open /dev/dsp : ");
+        return -1;
+    }
 
-	close(fd);
+    close(fd);
 #endif
 
 #ifdef USING_OPENAL
-	alutInit(NULL, 0);
+    alutInit(NULL, 0);
 
-	mInit = true;
-	printf("Created OpenAL Context\n");
+    mInit = true;
+    printf("Created OpenAL Context\n");
 #else
-	printf("Couldn't create sound Context!\n");
+    printf("Couldn't create sound Context!\n");
 #endif
 
-	return 0;
+    return 0;
 }
 
 
 void Sound::listenAt(float pos[3], float angle[3])
 {
-	if (!mInit)
-		return;
+    if (!mInit)
+        return;
 
 #ifdef USING_OPENAL
-	alListenerfv(AL_POSITION, pos);
-	alListenerfv(AL_ORIENTATION, angle);
+    alListenerfv(AL_POSITION, pos);
+    alListenerfv(AL_ORIENTATION, angle);
 #endif
 }
 
 
 void Sound::sourceAt(int source, float pos[3])
 {
-	if (!mInit || source < 0)
-		return;
+    if (!mInit || source < 0)
+        return;
 
 #ifdef USING_OPENAL
-	alSourcefv(mSource[source-1], AL_POSITION, pos);
+    alSourcefv(mSource[source-1], AL_POSITION, pos);
 #endif
 }
 
@@ -114,111 +114,111 @@ void Sound::sourceAt(int source, float pos[3])
 int Sound::addFile(const char *filename, int *source, unsigned int flags)
 {
 #ifdef USING_OPENAL
-   ALsizei size;
-   ALfloat freq;
-   ALenum format;
-   ALvoid *data;
+    ALsizei size;
+    ALfloat freq;
+    ALenum format;
+    ALvoid *data;
 #endif
 
 
-	if (!mInit || !filename || !source)
-	{
-		printf("Sound::AddFile> ERROR pre condition assertion failed\n");
-		return -1000;
-	}
+    if (!mInit || !filename || !source)
+    {
+        printf("Sound::AddFile> ERROR pre condition assertion failed\n");
+        return -1000;
+    }
 
-	*source = -1;
+    *source = -1;
 
 #ifdef USING_OPENAL
-   alGetError();
+    alGetError();
 
-	alGenBuffers(1, &mBuffer[mNextBuffer]);
+    alGenBuffers(1, &mBuffer[mNextBuffer]);
 
-	if (alGetError() != AL_NO_ERROR)
-   {
-		fprintf(stderr, "Sound::AddFile> alGenBuffers call failed\n");
-		return -1;
-	}
+    if (alGetError() != AL_NO_ERROR)
+    {
+        fprintf(stderr, "Sound::AddFile> alGenBuffers call failed\n");
+        return -1;
+    }
 
-   alGetError();
+    alGetError();
 
-   alGenSources(1, &mSource[mNextSource]);
+    alGenSources(1, &mSource[mNextSource]);
 
-	if (alGetError() != AL_NO_ERROR)
-   {
-		fprintf(stderr, "Sound::AddFile> alGenSources call failed\n");
-		return -2;
-	}
+    if (alGetError() != AL_NO_ERROR)
+    {
+        fprintf(stderr, "Sound::AddFile> alGenSources call failed\n");
+        return -2;
+    }
 
-   // err = alutLoadWAV(filename, &data, &format, &size, &bits, &freq);
-   // is deprecated!
-   data = alutLoadMemoryFromFile(filename, &format, &size, &freq);
+    // err = alutLoadWAV(filename, &data, &format, &size, &bits, &freq);
+    // is deprecated!
+    data = alutLoadMemoryFromFile(filename, &format, &size, &freq);
 
-   if (alGetError() != AL_NO_ERROR)
-	{
-	   fprintf(stderr, "Could not load %s\n", filename);
-	   return -3;
-   }
+    if (alGetError() != AL_NO_ERROR)
+    {
+        fprintf(stderr, "Could not load %s\n", filename);
+        return -3;
+    }
 
-   alBufferData(mBuffer[mNextBuffer], format, data, size, freq);
+    alBufferData(mBuffer[mNextBuffer], format, data, size, freq);
 
-   alSourcei(mSource[mNextSource], AL_BUFFER, mBuffer[mNextBuffer]);
+    alSourcei(mSource[mNextSource], AL_BUFFER, mBuffer[mNextBuffer]);
 
-	if (flags & SoundFlagsLoop)
-	{
-		alSourcei(mSource[mNextSource], AL_LOOPING, 1);
-	}
+    if (flags & SoundFlagsLoop)
+    {
+        alSourcei(mSource[mNextSource], AL_LOOPING, 1);
+    }
 
-   ++mNextBuffer;
-   ++mNextSource;
+    ++mNextBuffer;
+    ++mNextSource;
 
-	*source = mNextBuffer;
+    *source = mNextBuffer;
 
-   return 0;
+    return 0;
 #else
-	return -1;
+    return -1;
 #endif
 }
 
 int Sound::addWave(unsigned char *wav, unsigned int length, int *source, unsigned int flags)
 {
 #ifdef USING_OPENAL
-   ALsizei size;
-   ALfloat freq;
-   ALenum format;
-   ALvoid *data;
+    ALsizei size;
+    ALfloat freq;
+    ALenum format;
+    ALvoid *data;
 #endif
 
-	if (!mInit || !wav || !source)
-	{
-		printf("Sound::AddWave> ERROR pre condition assertion failed\n");
-		return -1000;
-	}
+    if (!mInit || !wav || !source)
+    {
+        printf("Sound::AddWave> ERROR pre condition assertion failed\n");
+        return -1000;
+    }
 
-	*source = -1;
+    *source = -1;
 
 #ifdef USING_OPENAL
-	data = wav;
+    data = wav;
 
-   alGetError();
+    alGetError();
 
-	alGenBuffers(1, &mBuffer[mNextBuffer]);
+    alGenBuffers(1, &mBuffer[mNextBuffer]);
 
-	if (alGetError() != AL_NO_ERROR)
-   {
-		fprintf(stderr, "Sound::AddWave> alGenBuffers call failed\n");
-		return -1;
-	}
+    if (alGetError() != AL_NO_ERROR)
+    {
+        fprintf(stderr, "Sound::AddWave> alGenBuffers call failed\n");
+        return -1;
+    }
 
-   alGetError();
+    alGetError();
 
-   alGenSources(1, &mSource[mNextSource]);
+    alGenSources(1, &mSource[mNextSource]);
 
-	if (alGetError() != AL_NO_ERROR)
-   {
-		fprintf(stderr, "Sound::AddWave> alGenSources call failed\n");
-		return -2;
-	}
+    if (alGetError() != AL_NO_ERROR)
+    {
+        fprintf(stderr, "Sound::AddWave> alGenSources call failed\n");
+        return -2;
+    }
 
     //AL_FORMAT_WAVE_EXT does not exist on Mac!"
     // alBufferData(mBuffer[mNextBuffer], AL_FORMAT_WAVE_EXT, data, size, freq);
@@ -229,62 +229,62 @@ int Sound::addWave(unsigned char *wav, unsigned int length, int *source, unsigne
     data = alutLoadMemoryFromFileImage(wav, length, &format, &size, &freq);
 
     if ((alGetError() != AL_NO_ERROR) || (data == NULL)) {
-	   fprintf(stderr, "Could not load wav buffer\n");
-	   return -3;
+        fprintf(stderr, "Could not load wav buffer\n");
+        return -3;
     }
 
 
-   alBufferData(mBuffer[mNextBuffer], format, data, size, freq);
+    alBufferData(mBuffer[mNextBuffer], format, data, size, freq);
 
-   alSourcei(mSource[mNextSource], AL_BUFFER, mBuffer[mNextBuffer]);
+    alSourcei(mSource[mNextSource], AL_BUFFER, mBuffer[mNextBuffer]);
 
-	if (flags & SoundFlagsLoop)
-	{
-		alSourcei(mSource[mNextSource], AL_LOOPING, 1);
-	}
+    if (flags & SoundFlagsLoop)
+    {
+        alSourcei(mSource[mNextSource], AL_LOOPING, 1);
+    }
 
-   ++mNextBuffer;
-   ++mNextSource;
+    ++mNextBuffer;
+    ++mNextSource;
 
-	*source = mNextBuffer;
+    *source = mNextBuffer;
 
-   return 0;
+    return 0;
 #else
-	return -1;
+    return -1;
 #endif
 }
 
 
 void Sound::play(int source)
 {
-	if (!mInit)
-	{
-		printf("Sound::Play> ERROR: Sound not initialized\n");
-		return;
-	}
-
-	if (source < 0)
-	{
-		printf("Sound::Play> ERROR: Source Id invalid\n");
-		return;
-	}
+    if (!mInit)
+    {
+        printf("Sound::Play> ERROR: Sound not initialized\n");
+        return;
+    }
+
+    if (source < 0)
+    {
+        printf("Sound::Play> ERROR: Source Id invalid\n");
+        return;
+    }
 
 #ifdef USING_OPENAL
-	alSourcePlay(mSource[source-1]);
+    alSourcePlay(mSource[source-1]);
 #endif
 }
 
 
 void Sound::stop(int source)
 {
-	if (!mInit || source < 0)
-	{
-		printf("Sound::Stop> ERROR pre condition assertion failed\n");
-		return;
-	}
+    if (!mInit || source < 0)
+    {
+        printf("Sound::Stop> ERROR pre condition assertion failed\n");
+        return;
+    }
 
 #ifdef USING_OPENAL
-	alSourceStop(mSource[source-1]);
+    alSourceStop(mSource[source-1]);
 #endif
 }
 

src/Vector3d.cpp

@@ -30,23 +30,23 @@
 
 Vector3d::Vector3d()
 {
-	mVec[0] = mVec[1] = mVec[2] = 0.0f;
+    mVec[0] = mVec[1] = mVec[2] = 0.0f;
 }
 
 
 Vector3d::Vector3d(vec3_t v)
 {
-	mVec[0] = v[0];
-	mVec[1] = v[1];
-	mVec[2] = v[2];
+    mVec[0] = v[0];
+    mVec[1] = v[1];
+    mVec[2] = v[2];
 }
 
 
 Vector3d::Vector3d(vec_t x, vec_t y, vec_t z)
 {
-	mVec[0] = x;
-	mVec[1] = y;
-	mVec[2] = z;
+    mVec[0] = x;
+    mVec[1] = y;
+    mVec[2] = z;
 }
 
 
@@ -61,91 +61,91 @@ Vector3d::~Vector3d()
 
 vec_t Vector3d::dot(const Vector3d &u, const Vector3d &v)
 {
-	return (u.mVec[0]*v.mVec[0] + u.mVec[1]*v.mVec[1] + u.mVec[2]*v.mVec[2]);
+    return (u.mVec[0]*v.mVec[0] + u.mVec[1]*v.mVec[1] + u.mVec[2]*v.mVec[2]);
 }
 
 
 Vector3d Vector3d::cross(const Vector3d &u, const Vector3d &v)
 {
-	return Vector3d(u.mVec[1] * v.mVec[2] - u.mVec[2] * v.mVec[1],
-						 u.mVec[2] * v.mVec[0] - u.mVec[0] * v.mVec[2],
-						 u.mVec[0] * v.mVec[1] - u.mVec[1] * v.mVec[0]);
+    return Vector3d(u.mVec[1] * v.mVec[2] - u.mVec[2] * v.mVec[1],
+            u.mVec[2] * v.mVec[0] - u.mVec[0] * v.mVec[2],
+            u.mVec[0] * v.mVec[1] - u.mVec[1] * v.mVec[0]);
 }
 
 
 vec_t Vector3d::magnitude()
 {
-	return sqrt(mVec[0]*mVec[0] + mVec[1]*mVec[1] + mVec[2]*mVec[2]);
+    return sqrt(mVec[0]*mVec[0] + mVec[1]*mVec[1] + mVec[2]*mVec[2]);
 }
 
 
 Vector3d Vector3d::unit()
 {
-	vec_t norm = magnitude();
+    vec_t norm = magnitude();
 
-	return Vector3d(mVec[0] / norm,
-						 mVec[1] / norm,
-						 mVec[2] / norm);
+    return Vector3d(mVec[0] / norm,
+            mVec[1] / norm,
+            mVec[2] / norm);
 }
 
 
 Vector3d Vector3d::zeroVector()
 {
-	return Vector3d(0, 0, 0);
+    return Vector3d(0, 0, 0);
 }
 
 
 Vector3d Vector3d::operator +(const Vector3d &v)
 {
-	return Vector3d(mVec[0] + v.mVec[0],
-						 mVec[1] + v.mVec[1],
-						 mVec[2] + v.mVec[2]);
+    return Vector3d(mVec[0] + v.mVec[0],
+            mVec[1] + v.mVec[1],
+            mVec[2] + v.mVec[2]);
 }
 
 
 Vector3d Vector3d::operator -(const Vector3d &v)
 {
-	return Vector3d(mVec[0] - v.mVec[0],
-						 mVec[1] - v.mVec[1],
-						 mVec[2] - v.mVec[2]);
+    return Vector3d(mVec[0] - v.mVec[0],
+            mVec[1] - v.mVec[1],
+            mVec[2] - v.mVec[2]);
 }
 
 
 Vector3d Vector3d::operator -()
 {
-	return Vector3d(-mVec[0],
-						 -mVec[1],
-						 -mVec[2]);
+    return Vector3d(-mVec[0],
+            -mVec[1],
+            -mVec[2]);
 }
 
 
 Vector3d Vector3d::operator *(vec_t s)
 {
-	return Vector3d(s * mVec[0],
-						 s * mVec[1],
-						 s * mVec[2]);
+    return Vector3d(s * mVec[0],
+            s * mVec[1],
+            s * mVec[2]);
 }
 
 
 Vector3d Vector3d::operator /(vec_t s)
 {
-	return Vector3d(mVec[0] / s,
-						 mVec[1] / s,
-						 mVec[2] / s);
+    return Vector3d(mVec[0] / s,
+            mVec[1] / s,
+            mVec[2] / s);
 }
 
 
 vec_t Vector3d::operator *(const Vector3d &v)
 {
-	return dot(*this, v);
+    return dot(*this, v);
 }
 
 
 //Vector3d Vector3d::operator *(const Matrix &m)
 //{
-//	vec3_t v;
+//  vec3_t v;
 //
-//	return
+//  return
 //}
 
 
@@ -155,51 +155,51 @@ vec_t Vector3d::operator *(const Vector3d &v)
 
 void Vector3d::normalize()
 {
-	vec_t norm = magnitude();
+    vec_t norm = magnitude();
 
-	mVec[0] /= norm;
-	mVec[1] /= norm;
-	mVec[2] /= norm;
+    mVec[0] /= norm;
+    mVec[1] /= norm;
+    mVec[2] /= norm;
 }
 
 
 void Vector3d::zero()
 {
-	mVec[0] = 0;
-	mVec[1] = 0;
-	mVec[2] = 0;
+    mVec[0] = 0;
+    mVec[1] = 0;
+    mVec[2] = 0;
 }
 
 
 void Vector3d::operator =(const Vector3d &v)
 {
-	mVec[0] = v.mVec[0];
-	mVec[1] = v.mVec[1];
-	mVec[2] = v.mVec[2];
+    mVec[0] = v.mVec[0];
+    mVec[1] = v.mVec[1];
+    mVec[2] = v.mVec[2];
 }
 
 
 void Vector3d::operator +=(const Vector3d &v)
 {
-	mVec[0] += v.mVec[0];
-	mVec[1] += v.mVec[1];
-	mVec[2] += v.mVec[2];
+    mVec[0] += v.mVec[0];
+    mVec[1] += v.mVec[1];
+    mVec[2] += v.mVec[2];
 }
 
 
 void Vector3d::operator -=(const Vector3d &v)
 {
-	mVec[0] -= v.mVec[0];
-	mVec[1] -= v.mVec[1];
-	mVec[2] -= v.mVec[2];
+    mVec[0] -= v.mVec[0];
+    mVec[1] -= v.mVec[1];
+    mVec[2] -= v.mVec[2];
 }
 
 
 void Vector3d::operator *=(vec_t s)
 {
-	mVec[0] *= s;
-	mVec[1] *= s;
-	mVec[2] *= s;
+    mVec[0] *= s;
+    mVec[1] *= s;
+    mVec[2] *= s;
 }
 
 

src/ViewVolume.cpp

@@ -46,176 +46,176 @@ ViewVolume::~ViewVolume()
 
 bool ViewVolume::isBoundingVolumeInFrustum(BoundingVolume bvol)
 {
-	return (isBoundingSphereInFrustum(bvol.mSphere) &&
-			  isBoundingBoxInFrustum(bvol.mBox));
+    return (isBoundingSphereInFrustum(bvol.mSphere) &&
+            isBoundingBoxInFrustum(bvol.mBox));
 }
 
 
 bool ViewVolume::isBoundingSphereInFrustum(BoundingSphere bvol)
 {
-	return (isSphereInFrustum(bvol.mCenter[0],
-									  bvol.mCenter[1],
-									  bvol.mCenter[2],
-									  bvol.mRadius));
+    return (isSphereInFrustum(bvol.mCenter[0],
+                bvol.mCenter[1],
+                bvol.mCenter[2],
+                bvol.mRadius));
 }
 
 
 bool ViewVolume::isBoundingBoxInFrustum(BoundingBox bvol)
 {
-	return (isBboxInFrustum(bvol.mMin, bvol.mMax));
+    return (isBboxInFrustum(bvol.mMin, bvol.mMax));
 }
 
 
 bool ViewVolume::isPointInFrustum(vec_t x, vec_t y, vec_t z)
 {
-   unsigned int p;
+    unsigned int p;
 
 
-   for (p = 0; p < 6; ++p)
-	{
-      if (mFrustum[p][0] * x + mFrustum[p][1] * y + mFrustum[p][2] * z +
-			 mFrustum[p][3] <= 0)
-		{
-         return false;
-		}
-	}
+    for (p = 0; p < 6; ++p)
+    {
+        if (mFrustum[p][0] * x + mFrustum[p][1] * y + mFrustum[p][2] * z +
+                mFrustum[p][3] <= 0)
+        {
+            return false;
+        }
+    }
 
-   return true;
+    return true;
 }
 
 
 bool ViewVolume::isSphereInFrustum(vec_t x, vec_t y, vec_t z, vec_t radius)
 {
-   unsigned int p;
-   vec_t d;
+    unsigned int p;
+    vec_t d;
 
 
-   for (p = 0; p < 6; ++p)
-   {
-      d = mFrustum[p][0] * x + mFrustum[p][1] * y + mFrustum[p][2] * z + mFrustum[p][3];
-      if (d <= -radius)
-         return false;
-   }
+    for (p = 0; p < 6; ++p)
+    {
+        d = mFrustum[p][0] * x + mFrustum[p][1] * y + mFrustum[p][2] * z + mFrustum[p][3];
+        if (d <= -radius)
+            return false;
+    }
 
-   return true;
+    return true;
 }
 
 
 bool ViewVolume::isBboxInFrustum(vec3_t min, vec3_t max)
 {
-   unsigned int p;
-
-
-   for (p = 0; p < 6; ++p)
-   {
-      if (mFrustum[p][0] * min[0] +
-			 mFrustum[p][1] * min[1] +
-			 mFrustum[p][2] * min[2] + mFrustum[p][3] > 0)
-         continue;
-
-      if (mFrustum[p][0] * max[0] +
-			 mFrustum[p][1] * max[1] +
-			 mFrustum[p][2] * max[2] + mFrustum[p][3] > 0)
-         continue;
-
-      if (mFrustum[p][0] * min[0] +
-			 mFrustum[p][1] * max[1] +
-			 mFrustum[p][2] * max[2] + mFrustum[p][3] > 0)
-         continue;
-
-      if (mFrustum[p][0] * min[0] +
-			 mFrustum[p][1] * min[1] +
-			 mFrustum[p][2] * max[2] + mFrustum[p][3] > 0)
-         continue;
-
-      if (mFrustum[p][0] * min[0] +
-			 mFrustum[p][1] * max[1] +
-			 mFrustum[p][2] * min[2] + mFrustum[p][3] > 0)
-         continue;
-
-      if (mFrustum[p][0] * max[0] +
-			 mFrustum[p][1] * min[1] +
-			 mFrustum[p][2] * min[2] + mFrustum[p][3] > 0)
-         continue;
-
-      if (mFrustum[p][0] * max[0] +
-			 mFrustum[p][1] * max[1] +
-			 mFrustum[p][2] * min[2] + mFrustum[p][3] > 0)
-         continue;
-
-      if (mFrustum[p][0] * max[0] +
-			 mFrustum[p][1] * min[1] +
-			 mFrustum[p][2] * max[2] + mFrustum[p][3] > 0)
-         continue;
-
-      return false;
-   }
-
-   return true;
+    unsigned int p;
+
+
+    for (p = 0; p < 6; ++p)
+    {
+        if (mFrustum[p][0] * min[0] +
+                mFrustum[p][1] * min[1] +
+                mFrustum[p][2] * min[2] + mFrustum[p][3] > 0)
+            continue;
+
+        if (mFrustum[p][0] * max[0] +
+                mFrustum[p][1] * max[1] +
+                mFrustum[p][2] * max[2] + mFrustum[p][3] > 0)
+            continue;
+
+        if (mFrustum[p][0] * min[0] +
+                mFrustum[p][1] * max[1] +
+                mFrustum[p][2] * max[2] + mFrustum[p][3] > 0)
+            continue;
+
+        if (mFrustum[p][0] * min[0] +
+                mFrustum[p][1] * min[1] +
+                mFrustum[p][2] * max[2] + mFrustum[p][3] > 0)
+            continue;
+
+        if (mFrustum[p][0] * min[0] +
+                mFrustum[p][1] * max[1] +
+                mFrustum[p][2] * min[2] + mFrustum[p][3] > 0)
+            continue;
+
+        if (mFrustum[p][0] * max[0] +
+                mFrustum[p][1] * min[1] +
+                mFrustum[p][2] * min[2] + mFrustum[p][3] > 0)
+            continue;
+
+        if (mFrustum[p][0] * max[0] +
+                mFrustum[p][1] * max[1] +
+                mFrustum[p][2] * min[2] + mFrustum[p][3] > 0)
+            continue;
+
+        if (mFrustum[p][0] * max[0] +
+                mFrustum[p][1] * min[1] +
+                mFrustum[p][2] * max[2] + mFrustum[p][3] > 0)
+            continue;
+
+        return false;
+    }
+
+    return true;
 }
 
 
 vec_t ViewVolume::getDistToSphereFromNear(vec_t x, vec_t y, vec_t z,
-														vec_t radius)
+        vec_t radius)
 {
-   unsigned int p;
-   vec_t d = 0.0;
+    unsigned int p;
+    vec_t d = 0.0;
 
-   for (p = 0; p < 6; ++p)
-   {
-      d = mFrustum[p][0] * x + mFrustum[p][1] * y + mFrustum[p][2] * z + mFrustum[p][3];
-      if (d <= -radius)
-         return 0;
-   }
+    for (p = 0; p < 6; ++p)
+    {
+        d = mFrustum[p][0] * x + mFrustum[p][1] * y + mFrustum[p][2] * z + mFrustum[p][3];
+        if (d <= -radius)
+            return 0;
+    }
 
-   return d + radius;
+    return d + radius;
 }
 
 
 vec_t ViewVolume::getDistToBboxFromNear(vec3_t min, vec3_t max)
 {
-	vec3_t center;
-   vec_t d, radius;
+    vec3_t center;
+    vec_t d, radius;
 
 
-	helMidpoint3v(min, max, center);
+    helMidpoint3v(min, max, center);
 
-	// 5 should be near plane
-	d = (mFrustum[5][0] * center[0] +
-		  mFrustum[5][1] * center[1] +
-		  mFrustum[5][2] * center[2] +
-		  mFrustum[5][3]);
+    // 5 should be near plane
+    d = (mFrustum[5][0] * center[0] +
+            mFrustum[5][1] * center[1] +
+            mFrustum[5][2] * center[2] +
+            mFrustum[5][3]);
 
-	radius = helDist3v(max, center);
+    radius = helDist3v(max, center);
 
-	if (d <= -radius)
-		return 0;
+    if (d <= -radius)
+        return 0;
 
-   return d + radius;
+    return d + radius;
 }
 
 
 void ViewVolume::getFrustum(vec_t frustum[6][4])
 {
-	unsigned int plane;
+    unsigned int plane;
 
 
-	for (plane = 0; plane < 6; ++plane)
-   {
-		frustum[plane][0] = mFrustum[plane][0];
-		frustum[plane][1] = mFrustum[plane][1];
-		frustum[plane][2] = mFrustum[plane][2];
-		frustum[plane][3] = mFrustum[plane][3];
-	}
+    for (plane = 0; plane < 6; ++plane)
+    {
+        frustum[plane][0] = mFrustum[plane][0];
+        frustum[plane][1] = mFrustum[plane][1];
+        frustum[plane][2] = mFrustum[plane][2];
+        frustum[plane][3] = mFrustum[plane][3];
+    }
 }
 
 
 void ViewVolume::getPlane(ViewVolumeSide p, vec4_t plane)
 {
-	plane[0] =  mFrustum[p][0];
-	plane[1] =  mFrustum[p][1];
-	plane[2] =  mFrustum[p][2];
-	plane[3] =  mFrustum[p][3];
+    plane[0] =  mFrustum[p][0];
+    plane[1] =  mFrustum[p][1];
+    plane[2] =  mFrustum[p][2];
+    plane[3] =  mFrustum[p][3];
 }
 
 
@@ -225,42 +225,42 @@ void ViewVolume::getPlane(ViewVolumeSide p, vec4_t plane)
 
 void ViewVolume::updateFrame(matrix_t proj, matrix_t mdl)
 {
-	setModel(mdl);
-	setProjection(proj);
-	updateClip();
-	updateFrustum();
+    setModel(mdl);
+    setProjection(proj);
+    updateClip();
+    updateFrustum();
 }
 
 
 void ViewVolume::updateFrame()
 {
-	updateClip();
-	updateFrustum();
+    updateClip();
+    updateFrustum();
 }
 
 
 void ViewVolume::setModel(matrix_t mdl)
 {
-	mModel.setMatrix(mdl);
+    mModel.setMatrix(mdl);
 }
 
 
 void ViewVolume::setProjection(matrix_t proj)
 {
-	/*void setProjection(viewAngle, aspectRatio, near, far)
-    ****************************
-	 *float far = 4000.0f;
-	 *float near = 4.0f;
-	 *float viewAngle = 45.0f;
-	 *float aspectRatio = 800.0f/600.0f;
-	 ****************************
-	 *float top = near * tan(PI/180 * viewAngle/2)
-    *float bottom = -top
-    *float right = top * aspectRatio
-    *float left = - right
-	 */
-
-	mProjection.setMatrix(proj);
+    /*void setProjection(viewAngle, aspectRatio, near, far)
+     ****************************
+     *float far = 4000.0f;
+     *float near = 4.0f;
+     *float viewAngle = 45.0f;
+     *float aspectRatio = 800.0f/600.0f;
+     ****************************
+     *float top = near * tan(PI/180 * viewAngle/2)
+     *float bottom = -top
+     *float right = top * aspectRatio
+     *float left = - right
+     */
+
+    mProjection.setMatrix(proj);
 }
 
 
@@ -276,108 +276,108 @@ void ViewVolume::setProjection(matrix_t proj)
 
 void ViewVolume::updateClip()
 {
-	//mClip = mModel * mProjection;
-	mClip = mProjection * mModel;
+    //mClip = mModel * mProjection;
+    mClip = mProjection * mModel;
 }
 
 
 void ViewVolume::updateFrustum()
 {
-	matrix_t clip;
-	vec_t t;
-
-
-	mClip.getMatrix(clip);
-
-   /* Extract the numbers for the RIGHT plane */
-   mFrustum[0][0] = clip[ 3] - clip[ 0];
-   mFrustum[0][1] = clip[ 7] - clip[ 4];
-   mFrustum[0][2] = clip[11] - clip[ 8];
-   mFrustum[0][3] = clip[15] - clip[12];
-
-   /* Normalize the result */
-   t = sqrt(mFrustum[0][0] * mFrustum[0][0] +
-				mFrustum[0][1] * mFrustum[0][1] +
-				mFrustum[0][2] * mFrustum[0][2]);
-   mFrustum[0][0] /= t;
-   mFrustum[0][1] /= t;
-   mFrustum[0][2] /= t;
-   mFrustum[0][3] /= t;
-
-   /* Extract the numbers for the LEFT plane */
-   mFrustum[1][0] = clip[ 3] + clip[ 0];
-   mFrustum[1][1] = clip[ 7] + clip[ 4];
-   mFrustum[1][2] = clip[11] + clip[ 8];
-   mFrustum[1][3] = clip[15] + clip[12];
-
-   /* Normalize the result */
-   t = sqrt(mFrustum[1][0] * mFrustum[1][0] +
-				mFrustum[1][1] * mFrustum[1][1] +
-				mFrustum[1][2] * mFrustum[1][2]);
-   mFrustum[1][0] /= t;
-   mFrustum[1][1] /= t;
-   mFrustum[1][2] /= t;
-   mFrustum[1][3] /= t;
-
-   /* Extract the BOTTOM plane */
-   mFrustum[2][0] = clip[ 3] + clip[ 1];
-   mFrustum[2][1] = clip[ 7] + clip[ 5];
-   mFrustum[2][2] = clip[11] + clip[ 9];
-   mFrustum[2][3] = clip[15] + clip[13];
-
-   /* Normalize the result */
-   t = sqrt(mFrustum[2][0] * mFrustum[2][0] +
-				mFrustum[2][1] * mFrustum[2][1] +
-				mFrustum[2][2] * mFrustum[2][2]);
-   mFrustum[2][0] /= t;
-   mFrustum[2][1] /= t;
-   mFrustum[2][2] /= t;
-   mFrustum[2][3] /= t;
-
-   /* Extract the TOP plane */
-   mFrustum[3][0] = clip[ 3] - clip[ 1];
-   mFrustum[3][1] = clip[ 7] - clip[ 5];
-   mFrustum[3][2] = clip[11] - clip[ 9];
-   mFrustum[3][3] = clip[15] - clip[13];
-
-   /* Normalize the result */
-   t = sqrt(mFrustum[3][0] * mFrustum[3][0] +
-				mFrustum[3][1] * mFrustum[3][1] +
-				mFrustum[3][2] * mFrustum[3][2]);
-   mFrustum[3][0] /= t;
-   mFrustum[3][1] /= t;
-   mFrustum[3][2] /= t;
-   mFrustum[3][3] /= t;
-
-   /* Extract the FAR plane */
-   mFrustum[4][0] = clip[ 3] - clip[ 2];
-   mFrustum[4][1] = clip[ 7] - clip[ 6];
-   mFrustum[4][2] = clip[11] - clip[10];
-   mFrustum[4][3] = clip[15] - clip[14];
-
-   /* Normalize the result */
-   t = sqrt(mFrustum[4][0] * mFrustum[4][0] +
-				mFrustum[4][1] * mFrustum[4][1] +
-				mFrustum[4][2] * mFrustum[4][2]);
-   mFrustum[4][0] /= t;
-   mFrustum[4][1] /= t;
-   mFrustum[4][2] /= t;
-   mFrustum[4][3] /= t;
-
-   /* Extract the NEAR plane */
-   mFrustum[5][0] = clip[ 3] + clip[ 2];
-   mFrustum[5][1] = clip[ 7] + clip[ 6];
-   mFrustum[5][2] = clip[11] + clip[10];
-   mFrustum[5][3] = clip[15] + clip[14];
-
-   /* Normalize the result */
-   t = sqrt(mFrustum[5][0] * mFrustum[5][0] +
-				mFrustum[5][1] * mFrustum[5][1] +
-				mFrustum[5][2] * mFrustum[5][2]);
-   mFrustum[5][0] /= t;
-   mFrustum[5][1] /= t;
-   mFrustum[5][2] /= t;
-   mFrustum[5][3] /= t;
+    matrix_t clip;
+    vec_t t;
+
+
+    mClip.getMatrix(clip);
+
+    /* Extract the numbers for the RIGHT plane */
+    mFrustum[0][0] = clip[ 3] - clip[ 0];
+    mFrustum[0][1] = clip[ 7] - clip[ 4];
+    mFrustum[0][2] = clip[11] - clip[ 8];
+    mFrustum[0][3] = clip[15] - clip[12];
+
+    /* Normalize the result */
+    t = sqrt(mFrustum[0][0] * mFrustum[0][0] +
+            mFrustum[0][1] * mFrustum[0][1] +
+            mFrustum[0][2] * mFrustum[0][2]);
+    mFrustum[0][0] /= t;
+    mFrustum[0][1] /= t;
+    mFrustum[0][2] /= t;
+    mFrustum[0][3] /= t;
+
+    /* Extract the numbers for the LEFT plane */
+    mFrustum[1][0] = clip[ 3] + clip[ 0];
+    mFrustum[1][1] = clip[ 7] + clip[ 4];
+    mFrustum[1][2] = clip[11] + clip[ 8];
+    mFrustum[1][3] = clip[15] + clip[12];
+
+    /* Normalize the result */
+    t = sqrt(mFrustum[1][0] * mFrustum[1][0] +
+            mFrustum[1][1] * mFrustum[1][1] +
+            mFrustum[1][2] * mFrustum[1][2]);
+    mFrustum[1][0] /= t;
+    mFrustum[1][1] /= t;
+    mFrustum[1][2] /= t;
+    mFrustum[1][3] /= t;
+
+    /* Extract the BOTTOM plane */
+    mFrustum[2][0] = clip[ 3] + clip[ 1];
+    mFrustum[2][1] = clip[ 7] + clip[ 5];
+    mFrustum[2][2] = clip[11] + clip[ 9];
+    mFrustum[2][3] = clip[15] + clip[13];
+
+    /* Normalize the result */
+    t = sqrt(mFrustum[2][0] * mFrustum[2][0] +
+            mFrustum[2][1] * mFrustum[2][1] +
+            mFrustum[2][2] * mFrustum[2][2]);
+    mFrustum[2][0] /= t;
+    mFrustum[2][1] /= t;
+    mFrustum[2][2] /= t;
+    mFrustum[2][3] /= t;
+
+    /* Extract the TOP plane */
+    mFrustum[3][0] = clip[ 3] - clip[ 1];
+    mFrustum[3][1] = clip[ 7] - clip[ 5];
+    mFrustum[3][2] = clip[11] - clip[ 9];
+    mFrustum[3][3] = clip[15] - clip[13];
+
+    /* Normalize the result */
+    t = sqrt(mFrustum[3][0] * mFrustum[3][0] +
+            mFrustum[3][1] * mFrustum[3][1] +
+            mFrustum[3][2] * mFrustum[3][2]);
+    mFrustum[3][0] /= t;
+    mFrustum[3][1] /= t;
+    mFrustum[3][2] /= t;
+    mFrustum[3][3] /= t;
+
+    /* Extract the FAR plane */
+    mFrustum[4][0] = clip[ 3] - clip[ 2];
+    mFrustum[4][1] = clip[ 7] - clip[ 6];
+    mFrustum[4][2] = clip[11] - clip[10];
+    mFrustum[4][3] = clip[15] - clip[14];
+
+    /* Normalize the result */
+    t = sqrt(mFrustum[4][0] * mFrustum[4][0] +
+            mFrustum[4][1] * mFrustum[4][1] +
+            mFrustum[4][2] * mFrustum[4][2]);
+    mFrustum[4][0] /= t;
+    mFrustum[4][1] /= t;
+    mFrustum[4][2] /= t;
+    mFrustum[4][3] /= t;
+
+    /* Extract the NEAR plane */
+    mFrustum[5][0] = clip[ 3] + clip[ 2];
+    mFrustum[5][1] = clip[ 7] + clip[ 6];
+    mFrustum[5][2] = clip[11] + clip[10];
+    mFrustum[5][3] = clip[15] + clip[14];
+
+    /* Normalize the result */
+    t = sqrt(mFrustum[5][0] * mFrustum[5][0] +
+            mFrustum[5][1] * mFrustum[5][1] +
+            mFrustum[5][2] * mFrustum[5][2]);
+    mFrustum[5][0] /= t;
+    mFrustum[5][1] /= t;
+    mFrustum[5][2] /= t;
+    mFrustum[5][3] /= t;
 }
 
 
@@ -388,17 +388,17 @@ void ViewVolume::updateFrustum()
 #ifdef UNIT_TEST_VIEWVOLUME
 int runViewVolumeUnitTest(int argc, char *argv[])
 {
-	return 0;
+    return 0;
 }
 
 
 int main(int argc, char *argv[])
 {
-	ViewVolume test;
+    ViewVolume test;
 
 
-	printf("[ViewVolume class test]\n");
+    printf("[ViewVolume class test]\n");
 
-	return runViewVolumeUnitTest(argc, argv);
+    return runViewVolumeUnitTest(argc, argv);
 }
 #endif

src/tga.cpp

@@ -36,458 +36,458 @@
 
 int mtk_image__tga_check(FILE *f)
 {
-  char buffer[10];
+    char buffer[10];
 
 
-  if (!f)
-  {
-    perror("tga_check> Passed invalid file.\n");
-    return -1;
-  }
+    if (!f)
+    {
+        perror("tga_check> Passed invalid file.\n");
+        return -1;
+    }
 
-  /* Read the header */
-  fseek(f, 0, SEEK_SET);
-  fread(buffer, 8, 1, f);
+    /* Read the header */
+    fseek(f, 0, SEEK_SET);
+    fread(buffer, 8, 1, f);
 
-  // buffer[1] = 0 - Means not color mapped ( 1 would mean mapped )
-  if (!(buffer[1] == 0 && (buffer[2] == TGA_TYPE__COLOR ||
-			   //buffer[2] == TGA_TYPE__GREYSCALE ||
-			   buffer[2] == TGA_TYPE__COLOR_RLE)))
-  {
-    printf("tga_check> Inavlid or unknown TGA format.\n");
-    return -2;
-  }
+    // buffer[1] = 0 - Means not color mapped ( 1 would mean mapped )
+    if (!(buffer[1] == 0 && (buffer[2] == TGA_TYPE__COLOR ||
+                    //buffer[2] == TGA_TYPE__GREYSCALE ||
+                    buffer[2] == TGA_TYPE__COLOR_RLE)))
+    {
+        printf("tga_check> Inavlid or unknown TGA format.\n");
+        return -2;
+    }
 
-  return 0;
+    return 0;
 }
 
 
 int mtk_image__tga_load(FILE *f, unsigned char **image,
-			unsigned int *width, unsigned int *height, char *type)
+        unsigned int *width, unsigned int *height, char *type)
 {
-  mtk_image_tga_t header;
-  char comment[256];
-  unsigned char pixel[4];
-  unsigned char *swap_row = NULL;
-  unsigned char tmp, packet;
-  bool must_flip = 0;
-  unsigned int size;
-  unsigned int i, j;
-
-
-  if (!f)
-  {
-    fprintf(stderr, "mtk_image__tga_load> Invalid parameters.\n");
-    return -1;
-  }
-
-  fseek(f, 0, SEEK_SET);
-
-  // Read TGA header
-  fread(&header.comment_lenght, 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);
-  fread(&header.colormap_bbp, 1, 1, f);
-
-  fread(&tmp, 1, 1, f);
-  header.origin_x = tmp;
-  fread(&tmp, 1, 1, f);
-  header.origin_x += tmp * 256;
-
-  fread(&tmp, 1, 1, f);
-  header.origin_y = tmp;
-  fread(&tmp, 1, 1, f);
-  header.origin_y += tmp * 256;
-
-  fread(&tmp, 1, 1, f);
-  header.width = tmp;
-  fread(&tmp, 1, 1, f);
-  header.width += tmp * 256;
-
-  fread(&tmp, 1, 1, f);
-  header.height = tmp;
-  fread(&tmp, 1, 1, f);
-  header.height += tmp * 256;
-
-  fread(&header.bpp, 1, 1, f);
-  fread(&header.desc_flags, 1, 1, f);
-
-  *width = header.width;
-  *height = header.height;
-
-  switch (header.bpp)
-  {
-  case 32:
-    *type = 2;//32;
-    break;
-  case 24:
-    *type = 1;//24;
-    break;
-  case 8:
-    *type = 0;//8;
-    break;
-  default:
-    *type = 0;
-  }
+    mtk_image_tga_t header;
+    char comment[256];
+    unsigned char pixel[4];
+    unsigned char *swap_row = NULL;
+    unsigned char tmp, packet;
+    bool must_flip = 0;
+    unsigned int size;
+    unsigned int i, j;
 
-#ifdef DEBUG_TGA
-  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)
-  {
-    fread(&comment, 1, header.comment_lenght, f);
-
-    for (i = 0; i < 255; ++i)
+    if (!f)
     {
-      if (comment[i] > 32 && comment[i] < 127)
-      {
-      }
-      else
-      {
-	comment[i] = 183; // print a dot for invalid text
-      }
+        fprintf(stderr, "mtk_image__tga_load> Invalid parameters.\n");
+        return -1;
     }
 
-    comment[255] = 0;
+    fseek(f, 0, SEEK_SET);
+
+    // Read TGA header
+    fread(&header.comment_lenght, 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);
+    fread(&header.colormap_bbp, 1, 1, f);
 
-    printf("Comment: '%s'\n", comment);
-  }
+    fread(&tmp, 1, 1, f);
+    header.origin_x = tmp;
+    fread(&tmp, 1, 1, f);
+    header.origin_x += tmp * 256;
 
-  size = header.width * header.height;
+    fread(&tmp, 1, 1, f);
+    header.origin_y = tmp;
+    fread(&tmp, 1, 1, f);
+    header.origin_y += tmp * 256;
 
-  if (!size || (!(header.colormap_type == 0 &&
-		  (header.image_type == 2 || header.image_type == 10))))
-  {
-    fprintf(stderr, "mtk_image__tga_load> Unknown image format.\n");
-    return -2;
-  }
+    fread(&tmp, 1, 1, f);
+    header.width = tmp;
+    fread(&tmp, 1, 1, f);
+    header.width += tmp * 256;
 
-  *image = NULL;
+    fread(&tmp, 1, 1, f);
+    header.height = tmp;
+    fread(&tmp, 1, 1, f);
+    header.height += tmp * 256;
 
-  // Mongoose: Added 'screen origin bit' support back here
-  if (!(header.desc_flags & 32))
-  {
-    must_flip = true;
-  }
+    fread(&header.bpp, 1, 1, f);
+    fread(&header.desc_flags, 1, 1, f);
 
-  switch (header.bpp)
-  {
-  case 32:
-    size *= 4;
-    *image = new unsigned char [size];
+    *width = header.width;
+    *height = header.height;
 
-    switch (header.image_type)
+    switch (header.bpp)
     {
-    case TGA_TYPE__COLOR_RLE:
-      for (i = 0; i < size;)
-      {
-	fread(&packet, 1, 1, f);
-
-	if (packet & 0x80)  // Run Lenght
-	{
-	  packet = (packet &0x7F) + 1;
-
-	  fread(&pixel, 4, 1, f);
-
-	  for (j = 0; j < packet; j++)
-	  {
-	    (*image)[i++] = pixel[2];
-	    (*image)[i++] = pixel[1];
-	    (*image)[i++] = pixel[0];
-	    (*image)[i++] = pixel[3];
-	  }
-	}
-	else // RAW
-	{
-	  packet = (packet &0x7F) + 1;
-
-	  for (j = 0; j < packet; j++)
-	  {
-	    fread(&pixel, 4, 1, f);
-
-	    (*image)[i++] = pixel[2];
-	    (*image)[i++] = pixel[1];
-	    (*image)[i++] = pixel[0];
-	    (*image)[i++] = pixel[3];
-	  }
-	}
-      }
-      break;
-    case TGA_TYPE__COLOR:
-      if (fread((*image), size, 1, f) < 1)
-      {
-	fprintf(stderr, "mtk_image__tga_load> Image fread failed.\n");
-	delete [] *image;
-	return -4;
-      }
-
-      for (i = 0; i < size; i += 4)
-      {
-	tmp = (*image)[i];
-	(*image)[i] = (*image)[i + 2];
-	(*image)[i + 2] = tmp;
-      }
-      break;
-    default:
-      ;
+        case 32:
+            *type = 2;//32;
+            break;
+        case 24:
+            *type = 1;//24;
+            break;
+        case 8:
+            *type = 0;//8;
+            break;
+        default:
+            *type = 0;
     }
 
-    if (must_flip)
+#ifdef DEBUG_TGA
+    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)
     {
-      swap_row = new unsigned char [header.width * 4];
+        fread(&comment, 1, header.comment_lenght, f);
+
+        for (i = 0; i < 255; ++i)
+        {
+            if (comment[i] > 32 && comment[i] < 127)
+            {
+            }
+            else
+            {
+                comment[i] = 183; // print a dot for invalid text
+            }
+        }
+
+        comment[255] = 0;
+
+        printf("Comment: '%s'\n", comment);
+    }
 
-      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],
-	       header.width*4);
-	memcpy(&(*image)[j*header.width*4], swap_row, header.width*4);
-      }
+    size = header.width * header.height;
 
-      delete [] swap_row;
+    if (!size || (!(header.colormap_type == 0 &&
+                    (header.image_type == 2 || header.image_type == 10))))
+    {
+        fprintf(stderr, "mtk_image__tga_load> Unknown image format.\n");
+        return -2;
     }
-    break;
-  case 24:
-    size *= 3;
-    *image = new unsigned char [size];
 
-    switch (header.image_type)
+    *image = NULL;
+
+    // Mongoose: Added 'screen origin bit' support back here
+    if (!(header.desc_flags & 32))
     {
-    case TGA_TYPE__COLOR_RLE:
-      for (i = 0; i < size;)
-      {
-	fread(&packet, 1, 1, f);
-
-	if (packet & 0x80)  // Run Lenght
-	{
-	  packet = (packet &0x7F) + 1;
-
-	  fread(&pixel, 3, 1, f);
-
-	  for (j = 0; j < packet; j++)
-	  {
-	    (*image)[i++] = pixel[2];
-	    (*image)[i++] = pixel[1];
-	    (*image)[i++] = pixel[0];
-	  }
-	}
-	else // RAW
-	{
-	  packet = (packet &0x7F) + 1;
-
-	  for (j = 0; j < packet; j++)
-	  {
-	    fread(&pixel, 3, 1, f);
-
-	    (*image)[i++] = pixel[2];
-	    (*image)[i++] = pixel[1];
-	    (*image)[i++] = pixel[0];
-	  }
-	}
-      }
-      break;
-    case TGA_TYPE__COLOR:
-      if (fread((*image), size, 1, f) < 1)
-      {
-	fprintf(stderr, "mtk_image__tga_load> Image fread failed.\n");
-	delete [] *image;
-	return -4;
-      }
-
-      for (i = 0; i < size; i += 3)
-      {
-	tmp = (*image)[i];
-	(*image)[i] = (*image)[i + 2];
-	(*image)[i + 2] = tmp;
-      }
-      break;
-    default:
-      ;
+        must_flip = true;
     }
 
-    if (must_flip)
+    switch (header.bpp)
     {
-      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],
-	       header.width*3);
-	memcpy(&(*image)[j*header.width*3], swap_row, header.width*3);
-      }
-
-      delete [] swap_row;
+        case 32:
+            size *= 4;
+            *image = new unsigned char [size];
+
+            switch (header.image_type)
+            {
+                case TGA_TYPE__COLOR_RLE:
+                    for (i = 0; i < size;)
+                    {
+                        fread(&packet, 1, 1, f);
+
+                        if (packet & 0x80)  // Run Lenght
+                        {
+                            packet = (packet &0x7F) + 1;
+
+                            fread(&pixel, 4, 1, f);
+
+                            for (j = 0; j < packet; j++)
+                            {
+                                (*image)[i++] = pixel[2];
+                                (*image)[i++] = pixel[1];
+                                (*image)[i++] = pixel[0];
+                                (*image)[i++] = pixel[3];
+                            }
+                        }
+                        else // RAW
+                        {
+                            packet = (packet &0x7F) + 1;
+
+                            for (j = 0; j < packet; j++)
+                            {
+                                fread(&pixel, 4, 1, f);
+
+                                (*image)[i++] = pixel[2];
+                                (*image)[i++] = pixel[1];
+                                (*image)[i++] = pixel[0];
+                                (*image)[i++] = pixel[3];
+                            }
+                        }
+                    }
+                    break;
+                case TGA_TYPE__COLOR:
+                    if (fread((*image), size, 1, f) < 1)
+                    {
+                        fprintf(stderr, "mtk_image__tga_load> Image fread failed.\n");
+                        delete [] *image;
+                        return -4;
+                    }
+
+                    for (i = 0; i < size; i += 4)
+                    {
+                        tmp = (*image)[i];
+                        (*image)[i] = (*image)[i + 2];
+                        (*image)[i + 2] = tmp;
+                    }
+                    break;
+                default:
+                    ;
+            }
+
+            if (must_flip)
+            {
+                swap_row = new unsigned char [header.width * 4];
+
+                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],
+                            header.width*4);
+                    memcpy(&(*image)[j*header.width*4], swap_row, header.width*4);
+                }
+
+                delete [] swap_row;
+            }
+            break;
+        case 24:
+            size *= 3;
+            *image = new unsigned char [size];
+
+            switch (header.image_type)
+            {
+                case TGA_TYPE__COLOR_RLE:
+                    for (i = 0; i < size;)
+                    {
+                        fread(&packet, 1, 1, f);
+
+                        if (packet & 0x80)  // Run Lenght
+                        {
+                            packet = (packet &0x7F) + 1;
+
+                            fread(&pixel, 3, 1, f);
+
+                            for (j = 0; j < packet; j++)
+                            {
+                                (*image)[i++] = pixel[2];
+                                (*image)[i++] = pixel[1];
+                                (*image)[i++] = pixel[0];
+                            }
+                        }
+                        else // RAW
+                        {
+                            packet = (packet &0x7F) + 1;
+
+                            for (j = 0; j < packet; j++)
+                            {
+                                fread(&pixel, 3, 1, f);
+
+                                (*image)[i++] = pixel[2];
+                                (*image)[i++] = pixel[1];
+                                (*image)[i++] = pixel[0];
+                            }
+                        }
+                    }
+                    break;
+                case TGA_TYPE__COLOR:
+                    if (fread((*image), size, 1, f) < 1)
+                    {
+                        fprintf(stderr, "mtk_image__tga_load> Image fread failed.\n");
+                        delete [] *image;
+                        return -4;
+                    }
+
+                    for (i = 0; i < size; i += 3)
+                    {
+                        tmp = (*image)[i];
+                        (*image)[i] = (*image)[i + 2];
+                        (*image)[i + 2] = tmp;
+                    }
+                    break;
+                default:
+                    ;
+            }
+
+            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],
+                            header.width*3);
+                    memcpy(&(*image)[j*header.width*3], swap_row, header.width*3);
+                }
+
+                delete [] swap_row;
+            }
+
+            break;
+        case 8:
+            printf("tga_load> 8bpp Not implemented\n");
+            break;
+        default:
+            ;
     }
 
-    break;
-  case 8:
-    printf("tga_load> 8bpp Not implemented\n");
-    break;
-  default:
-    ;
-  }
-
 #ifdef DEBUG_TGA
-  char c;
+    char c;
 
-  printf("Comment:\n");
+    printf("Comment:\n");
 
-  while (fread(&c, 1, 1, f) == 1)
-  {
-    printf("%c", c);
-  }
+    while (fread(&c, 1, 1, f) == 1)
+    {
+        printf("%c", c);
+    }
 
-  printf("\n");
+    printf("\n");
 #endif
 
-  return 0;
+    return 0;
 }
 
 
 int mtk_image__tga_save(FILE *f, unsigned char *image,
-			unsigned int width, unsigned int height, char type)
+        unsigned int width, unsigned int height, char type)
 {
-  mtk_image_tga_t header;
-  unsigned int size;
-  //  unsigned int i;
-  //  unsigned char tmp;
-  char comment[64];
-
-
-  if (!f || !image || !width || !height)
-  {
-    fprintf(stderr, "mtk_image__tga_save> Invalid parameters.\n");
-    return -1;
-  }
-
-  // Mongoose 2002.01.10, Heh, kind of silly
-  strncpy(comment, "Mongoose TGA 20030711", 63);
-  comment[63] = 0;
-
-  header.comment_lenght = strlen(comment);
-  header.colormap_type = 0;
-
-  // No colormaps
-  header.colormap_index = 0;
-  header.colormap_lenght = 0;
-  header.colormap_bbp = 0;
-
-  header.origin_x = header.origin_y = 0;
-  header.width = width;
-  header.height = height;
-
-  header.desc_flags = 0;
-
-  switch (type)
-  {
-  case 4:
-    header.image_type = TGA_TYPE__COLOR;
-    header.desc_flags = 32;
-    header.bpp = 32;
-    break;
-  case 2:
-    header.bpp = 32;
-    break;
-  case 1:
-    header.image_type = TGA_TYPE__GREYSCALE;
-    header.bpp = 8;
-    break;
-  default:
-    header.image_type = TGA_TYPE__COLOR;
-    header.bpp = 24;
-  }
-
-  // Write TGA header
-  fwrite(&header.comment_lenght, 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);
-  fwrite(&header.colormap_bbp, 1, 1, f);
-  fwrite(&header.origin_x, 2, 1, f);
-  fwrite(&header.origin_y, 2, 1, f);
-  fwrite(&header.width, 2, 1, f);
-  fwrite(&header.height, 2, 1, f);
-  fwrite(&header.bpp, 1, 1, f);
-  fwrite(&header.desc_flags, 1, 1, f);
-
-  // Write comment
-  fwrite(&comment, 1, header.comment_lenght, f);
-
-  size = header.width * header.height;
-
-  switch (header.bpp)
-  {
-  case 32:
-    size = header.width * header.height * 4;
-
-    //for (i = 0; i < size; i += 4)
-    //{
-    //  tmp = image[i];
-    //  image[i] = image[i + 2];
-    //  image[i + 2] = tmp;
-    //}
-    break;
-  case 24:
-    size = header.width * header.height * 3;
-
-    //for (i = 0; i < size; i += 3)
-    //{
-    //  tmp = image[i];
-    //  image[i] = image[i + 2];
-    //  image[i + 2] = tmp;
-    //}
-    break;
-  case 8:
+    mtk_image_tga_t header;
+    unsigned int size;
+    //  unsigned int i;
+    //  unsigned char tmp;
+    char comment[64];
+
+
+    if (!f || !image || !width || !height)
+    {
+        fprintf(stderr, "mtk_image__tga_save> Invalid parameters.\n");
+        return -1;
+    }
+
+    // Mongoose 2002.01.10, Heh, kind of silly
+    strncpy(comment, "Mongoose TGA 20030711", 63);
+    comment[63] = 0;
+
+    header.comment_lenght = strlen(comment);
+    header.colormap_type = 0;
+
+    // No colormaps
+    header.colormap_index = 0;
+    header.colormap_lenght = 0;
+    header.colormap_bbp = 0;
+
+    header.origin_x = header.origin_y = 0;
+    header.width = width;
+    header.height = height;
+
+    header.desc_flags = 0;
+
+    switch (type)
+    {
+        case 4:
+            header.image_type = TGA_TYPE__COLOR;
+            header.desc_flags = 32;
+            header.bpp = 32;
+            break;
+        case 2:
+            header.bpp = 32;
+            break;
+        case 1:
+            header.image_type = TGA_TYPE__GREYSCALE;
+            header.bpp = 8;
+            break;
+        default:
+            header.image_type = TGA_TYPE__COLOR;
+            header.bpp = 24;
+    }
+
+    // Write TGA header
+    fwrite(&header.comment_lenght, 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);
+    fwrite(&header.colormap_bbp, 1, 1, f);
+    fwrite(&header.origin_x, 2, 1, f);
+    fwrite(&header.origin_y, 2, 1, f);
+    fwrite(&header.width, 2, 1, f);
+    fwrite(&header.height, 2, 1, f);
+    fwrite(&header.bpp, 1, 1, f);
+    fwrite(&header.desc_flags, 1, 1, f);
+
+    // Write comment
+    fwrite(&comment, 1, header.comment_lenght, f);
+
     size = header.width * header.height;
-    break;
-  }
 
-  // Write image data
-  if (fwrite(image, size, 1, f) < 1)
-  {
-    perror("mtk_image__tga_save> Disk write failed.\n");
-    return -2;
-  }
+    switch (header.bpp)
+    {
+        case 32:
+            size = header.width * header.height * 4;
+
+            //for (i = 0; i < size; i += 4)
+            //{
+            //  tmp = image[i];
+            //  image[i] = image[i + 2];
+            //  image[i + 2] = tmp;
+            //}
+            break;
+        case 24:
+            size = header.width * header.height * 3;
+
+            //for (i = 0; i < size; i += 3)
+            //{
+            //  tmp = image[i];
+            //  image[i] = image[i + 2];
+            //  image[i + 2] = tmp;
+            //}
+            break;
+        case 8:
+            size = header.width * header.height;
+            break;
+    }
+
+    // Write image data
+    if (fwrite(image, size, 1, f) < 1)
+    {
+        perror("mtk_image__tga_save> Disk write failed.\n");
+        return -2;
+    }
 
-  return 0;
+    return 0;
 }
 
 
 int mtk_image__tga_save_filename(unsigned char *image,
-				 unsigned int width, unsigned int height,
-				 char type,
-				 char *s, ...)
+        unsigned int width, unsigned int height,
+        char type,
+        char *s, ...)
 {
-  char buffer[1024];
-  FILE *f;
-  int v;
-  va_list args;
+    char buffer[1024];
+    FILE *f;
+    int v;
+    va_list args;
 
 
-  va_start(args, s);
-  vsnprintf(buffer, 1023, s, args);
-  va_end(args);
+    va_start(args, s);
+    vsnprintf(buffer, 1023, s, args);
+    va_end(args);
 
-  f = fopen(buffer, "wb");
+    f = fopen(buffer, "wb");
 
-  if (!f)
-  {
-    perror(buffer);
-    return -1;
-  }
+    if (!f)
+    {
+        perror(buffer);
+        return -1;
+    }
 
-  v = mtk_image__tga_save(f, image, width, height, type);
-  fclose(f);
+    v = mtk_image__tga_save(f, image, width, height, type);
+    fclose(f);
 
-  return v;
+    return v;
 }
 

test/GLString.cpp

@@ -25,72 +25,72 @@ void swap_buffers();
 
 void event_resize(int width, int height)
 {
-	GLfloat aspect;
+    GLfloat aspect;
 
-	glMatrixMode(GL_PROJECTION);
-	aspect = (GLfloat)width/(GLfloat)height;
+    glMatrixMode(GL_PROJECTION);
+    aspect = (GLfloat)width/(GLfloat)height;
 
-	// Mongoose 2002.01.01, Setup view volume, with a nice FOV
+    // Mongoose 2002.01.01, Setup view volume, with a nice FOV
     // gluPerspective is deprecated!
-	// gluPerspective(40.0, aspect, 1, 2000);
+    // gluPerspective(40.0, aspect, 1, 2000);
     // fix: http://stackoverflow.com/a/2417756
     GLfloat fH = tan(float(40.0 / 360.0f * 3.14159f));
     GLfloat fW = fH * aspect;
     glFrustum(-fW, fW, -fH, fH, 1, 2000);
 
-	glMatrixMode(GL_MODELVIEW);
+    glMatrixMode(GL_MODELVIEW);
 }
 
 
 void event_display(int width, int height)
 {
-	static float x = 0.0, y = 0.0, z = -150.0, r = 0.0;
-
-
-	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-	glLoadIdentity();
-
-	glTranslatef(0.0, 0.0, -20.0);
-	glRotatef((float)cos(r)*180.0, 0.0, 0.0, 1.0);
-	r += 0.01;
-
-	// Mongoose 2002.01.01, Render color quad
-	glDisable(GL_TEXTURE_2D);
-	glBegin(GL_TRIANGLE_STRIP);
-	glColor3f(1.0, 0.0, 0.0);
-	glVertex3f(x + 50, y + 50, z);
-	glColor3f(0.0, 1.0, 0.0);
-	glVertex3f(x - 50, y + 50, z);
-	glColor3f(0.0, 0.0, 1.0);
-	glVertex3f(x + 50, y - 50, z);
-	glColor3f(0.5, 0.5, 0.5);
-	glVertex3f(x - 50, y - 50, z);
-	glEnd();
-
-	// Mongoose 2002.01.01, Render text
-	glDisable(GL_CULL_FACE);
-	glEnable(GL_BLEND);
-	glEnable(GL_TEXTURE_2D);
-	glColor3f(0.75, 0.5, 1.0);
+    static float x = 0.0, y = 0.0, z = -150.0, r = 0.0;
+
+
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    glLoadIdentity();
+
+    glTranslatef(0.0, 0.0, -20.0);
+    glRotatef((float)cos(r)*180.0, 0.0, 0.0, 1.0);
+    r += 0.01;
+
+    // Mongoose 2002.01.01, Render color quad
+    glDisable(GL_TEXTURE_2D);
+    glBegin(GL_TRIANGLE_STRIP);
+    glColor3f(1.0, 0.0, 0.0);
+    glVertex3f(x + 50, y + 50, z);
+    glColor3f(0.0, 1.0, 0.0);
+    glVertex3f(x - 50, y + 50, z);
+    glColor3f(0.0, 0.0, 1.0);
+    glVertex3f(x + 50, y - 50, z);
+    glColor3f(0.5, 0.5, 0.5);
+    glVertex3f(x - 50, y - 50, z);
+    glEnd();
+
+    // Mongoose 2002.01.01, Render text
+    glDisable(GL_CULL_FACE);
+    glEnable(GL_BLEND);
+    glEnable(GL_TEXTURE_2D);
+    glColor3f(0.75, 0.5, 1.0);
 
     glEnterMode2d(width, height);
-	TEXT->Render(width, height);
+    TEXT->Render(width, height);
     glExitMode2d();
 
-	glFlush();
-	swap_buffers();
+    glFlush();
+    swap_buffers();
 }
 
 
 void swap_buffers()
 {
-	SDL_GL_SwapBuffers();
+    SDL_GL_SwapBuffers();
 }
 
 
 void shutdown_gl()
 {
-	SDL_Quit();
+    SDL_Quit();
 }
 
 void init_gl(unsigned int width, unsigned int height)
@@ -98,41 +98,41 @@ void init_gl(unsigned int width, unsigned int height)
     int i;
     const char *errorText = "TEXT->glPrintf> ERROR code %i\n";
 
-	// Setup GL
-	glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
-	glShadeModel(GL_SMOOTH);
-	glEnable(GL_DEPTH_TEST);
-	glDepthFunc(GL_LESS);
-	glEnable(GL_BLEND);
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+    // Setup GL
+    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+    glShadeModel(GL_SMOOTH);
+    glEnable(GL_DEPTH_TEST);
+    glDepthFunc(GL_LESS);
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE);
 
-	event_resize(width, height);
+    event_resize(width, height);
 
-	// Mongoose 2002.01.01, Texture setup
-	gTexture.reset();
-	gTexture.setFlag(Texture::fUseMipmaps);
-	gTexture.setMaxTextureCount(32);
+    // Mongoose 2002.01.01, Texture setup
+    gTexture.reset();
+    gTexture.setFlag(Texture::fUseMipmaps);
+    gTexture.setMaxTextureCount(32);
 
     gTexture.loadFontTTF("data/test.ttf", 32, 126 - 32);  // ASCII
 
-	TEXT->Init(4);
+    TEXT->Init(4);
     i = TEXT->glPrintf((width/2)-50, height/2-32, "OpenRaider");
     if (i) {
         printf(errorText, i);
     }
-	i = TEXT->glPrintf((width/2)-50, height/2, "GLString");
-	if (i) {
-	    printf(errorText, i);
-	}
-	TEXT->Scale(1.2);
-	i = TEXT->glPrintf((width/2)-100, height/2+32, "Unit Test by Mongoose");
-	if (i) {
+    i = TEXT->glPrintf((width/2)-50, height/2, "GLString");
+    if (i) {
+        printf(errorText, i);
+    }
+    TEXT->Scale(1.2);
+    i = TEXT->glPrintf((width/2)-100, height/2+32, "Unit Test by Mongoose");
+    if (i) {
         printf(errorText, i);
     }
-	i = TEXT->glPrintf((width/2)-100, height/2+64, "ported to TTF by xythobuz");
-	if (i) {
+    i = TEXT->glPrintf((width/2)-100, height/2+64, "ported to TTF by xythobuz");
+    if (i) {
         printf(errorText, i);
-	}
+    }
     TEXT->setActive(0, true);
     TEXT->setActive(1, true);
     TEXT->setActive(2, true);
@@ -142,152 +142,152 @@ void init_gl(unsigned int width, unsigned int height)
 
 int main_gl(int argc, char *argv[])
 {
-  SDL_Event event;
-  unsigned int mkeys, mod, key;
-  int flags;
-  unsigned int width = 640;
-  unsigned int height = 480;
-  bool fullscreen = false;
+    SDL_Event event;
+    unsigned int mkeys, mod, key;
+    int flags;
+    unsigned int width = 640;
+    unsigned int height = 480;
+    bool fullscreen = false;
 #ifndef __APPLE__
-  char *driver = NULL;
+    char *driver = NULL;
 #endif
 
 
-  // Setup clean up on exit
-  atexit(shutdown_gl);
+    // Setup clean up on exit
+    atexit(shutdown_gl);
 
-  // Get user settings
-  //event_init(&width, &height, &fullscreen, &driver, argc, argv);
+    // Get user settings
+    //event_init(&width, &height, &fullscreen, &driver, argc, argv);
 
-  // Create GL context
-  SDL_Init(SDL_INIT_VIDEO);
+    // Create GL context
+    SDL_Init(SDL_INIT_VIDEO);
 
 #ifndef __APPLE__
-  if (!driver || !driver[0] || SDL_GL_LoadLibrary(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)
-		  {
-			  fprintf(stderr, "main_gl> SDL_GL_LoadLibrary failed!\n");
-			  fprintf(stderr, "main_gl> Error is [%s].\n", SDL_GetError());
-			  exit(1);
-		  }
-	  }
-  }
+    if (!driver || !driver[0] || SDL_GL_LoadLibrary(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)
+            {
+                fprintf(stderr, "main_gl> SDL_GL_LoadLibrary failed!\n");
+                fprintf(stderr, "main_gl> Error is [%s].\n", SDL_GetError());
+                exit(1);
+            }
+        }
+    }
 #endif
 
-  flags = SDL_OPENGL | SDL_GL_DOUBLEBUFFER;
-
-  if (fullscreen)
-  {
-	  flags |= SDL_FULLSCREEN;
-	  SDL_ShowCursor(SDL_DISABLE);
-  }
-
-  SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
-  SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 5);
-  SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
-  SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
-  SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
-  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);
-
-  for (;;)
-  {
-	  // Pause for 10-20 ms
-	  SDL_Delay(10);
-
-	  event_display(width, height);
-
-	  while (SDL_PollEvent(&event))
-	  {
-		  switch (event.type)
-		  {
-		  case SDL_QUIT:
-			  exit(0);
-			  break;
-		  case SDL_MOUSEMOTION:
-			  break;
-		  case SDL_MOUSEBUTTONDOWN:
-		  case SDL_MOUSEBUTTONUP:
-			  break;
-		  case SDL_KEYDOWN:
-			  mkeys = (unsigned int)SDL_GetModState();
-			  mod = 0;
-
-			  if (mkeys & KMOD_LSHIFT)
-				  mod |= KMOD_LSHIFT;
-
-			  if (mkeys & KMOD_RSHIFT)
-				  mod |= KMOD_RSHIFT;
-
-			  if (mkeys & KMOD_LCTRL)
-				  mod |= KMOD_LCTRL;
-
-			  if (mkeys & KMOD_RCTRL)
-				  mod |= KMOD_RCTRL;
-
-			  if (mkeys & KMOD_LALT)
-				  mod |= KMOD_LALT;
-
-			  if (mkeys & KMOD_RALT)
-				  mod |= KMOD_RALT;
-
-              if (mkeys & KMOD_LMETA)
-                  mod |= KMOD_LMETA;
-
-              if (mkeys & KMOD_RMETA)
-                  mod |= KMOD_RMETA;
-
-			  key = event.key.keysym.sym;
-
-			  switch (key)
-			  {
-			  case 0x1B: // 27d, ESC
-				  exit(0);
-				  break;
+    flags = SDL_OPENGL | SDL_GL_DOUBLEBUFFER;
+
+    if (fullscreen)
+    {
+        flags |= SDL_FULLSCREEN;
+        SDL_ShowCursor(SDL_DISABLE);
+    }
+
+    SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
+    SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 5);
+    SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
+    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
+    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
+    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);
+
+    for (;;)
+    {
+        // Pause for 10-20 ms
+        SDL_Delay(10);
+
+        event_display(width, height);
+
+        while (SDL_PollEvent(&event))
+        {
+            switch (event.type)
+            {
+                case SDL_QUIT:
+                    exit(0);
+                    break;
+                case SDL_MOUSEMOTION:
+                    break;
+                case SDL_MOUSEBUTTONDOWN:
+                case SDL_MOUSEBUTTONUP:
+                    break;
+                case SDL_KEYDOWN:
+                    mkeys = (unsigned int)SDL_GetModState();
+                    mod = 0;
+
+                    if (mkeys & KMOD_LSHIFT)
+                        mod |= KMOD_LSHIFT;
+
+                    if (mkeys & KMOD_RSHIFT)
+                        mod |= KMOD_RSHIFT;
+
+                    if (mkeys & KMOD_LCTRL)
+                        mod |= KMOD_LCTRL;
+
+                    if (mkeys & KMOD_RCTRL)
+                        mod |= KMOD_RCTRL;
+
+                    if (mkeys & KMOD_LALT)
+                        mod |= KMOD_LALT;
+
+                    if (mkeys & KMOD_RALT)
+                        mod |= KMOD_RALT;
+
+                    if (mkeys & KMOD_LMETA)
+                        mod |= KMOD_LMETA;
+
+                    if (mkeys & KMOD_RMETA)
+                        mod |= KMOD_RMETA;
+
+                    key = event.key.keysym.sym;
+
+                    switch (key)
+                    {
+                        case 0x1B: // 27d, ESC
+                            exit(0);
+                            break;
 #ifdef __APPLE__
-              case 113: // q
-                  if ((mod & KMOD_RMETA) || (mod & KMOD_LMETA))
-                      exit(0);
-                  break;
+                        case 113: // q
+                            if ((mod & KMOD_RMETA) || (mod & KMOD_LMETA))
+                                exit(0);
+                            break;
 #endif
-              case 114: // r
-                  break;
-			  }
-			  break;
-		  case SDL_KEYUP:
-			  break;
-		  case SDL_VIDEORESIZE:
-			  width = event.resize.w;
-			  height = event.resize.h;
-			  event_resize(width, height);
-			  event_display(width, height);
-			  break;
-		  }
-	  }
-  }
-
-  return 0;
+                        case 114: // r
+                            break;
+                    }
+                    break;
+                case SDL_KEYUP:
+                    break;
+                case SDL_VIDEORESIZE:
+                    width = event.resize.w;
+                    height = event.resize.h;
+                    event_resize(width, height);
+                    event_display(width, height);
+                    break;
+            }
+        }
+    }
+
+    return 0;
 }
 
 int main(int argc, char *argv[])
 {
-  printf("[GLString class test]\n");
+    printf("[GLString class test]\n");
 
-  TEXT = new GLString();
-  main_gl(argc, argv);
-  return 0;
+    TEXT = new GLString();
+    main_gl(argc, argv);
+    return 0;
 }
 

test/Matrix.cpp

@@ -40,19 +40,19 @@ TEST identity(vec_t init[4], int mode) {
     a.setMatrix(m);
 
     switch (mode) {
-    case 0:
-        a.setIdentity();
-        break;
-    case 1:
-        c.setIdentity();
-        b.setIdentity();
-        a = c * b;
-        break;
-    case 2:
-        a.setIdentity();
-        b.setIdentity();
-        a = a * b;
-        break;
+        case 0:
+            a.setIdentity();
+            break;
+        case 1:
+            c.setIdentity();
+            b.setIdentity();
+            a = c * b;
+            break;
+        case 2:
+            a.setIdentity();
+            b.setIdentity();
+            a = a * b;
+            break;
     }
     ASSERT(a.isIdentity());
     PASS();
@@ -95,22 +95,22 @@ TEST rotation(int axis) {
 
 TEST precision() {
     Matrix a;
-	printf("Prescision test...\n");
-	a.setIdentity();
-	printf(" -> Rotate (0, 0, 90 degrees)\n");
-	a.rotate(0, 0, 90*0.01745329251994329f);
-	printf(" -> Translate (10, 20, 30)\n");
-	a.translate(10, 20, 30);
-	printf(" -> scale (10, 10, 10)\n");
-	a.scale(10, 10, 10);
-	a.print();
-	printf("\n -> scale (0.1, 0.1, 0.1)\n");
-	a.scale(0.1, 0.1, 0.1);
-	printf(" -> Translate (-10, -20, -30)\n");
-	a.translate(-10, -20, -30);
-	printf(" -> Rotate (0, 0, -90 degrees)\n");
-	a.rotate(0, 0, -90*0.01745329251994329f);
-	a.print();
+    printf("Prescision test...\n");
+    a.setIdentity();
+    printf(" -> Rotate (0, 0, 90 degrees)\n");
+    a.rotate(0, 0, 90*0.01745329251994329f);
+    printf(" -> Translate (10, 20, 30)\n");
+    a.translate(10, 20, 30);
+    printf(" -> scale (10, 10, 10)\n");
+    a.scale(10, 10, 10);
+    a.print();
+    printf("\n -> scale (0.1, 0.1, 0.1)\n");
+    a.scale(0.1, 0.1, 0.1);
+    printf(" -> Translate (-10, -20, -30)\n");
+    a.translate(-10, -20, -30);
+    printf(" -> Rotate (0, 0, -90 degrees)\n");
+    a.rotate(0, 0, -90*0.01745329251994329f);
+    a.print();
     PASS();
 }
 

test/Network.cpp

@@ -29,82 +29,82 @@ extern network_frame_t gPiggyBack;
 
 void from_network_layer(network_packet_t *p, unsigned int *last_id)
 {
-	static unsigned int i = 0;
+    static unsigned int i = 0;
 
 
-	if (!p)
-	{
-		return;
-	}
+    if (!p)
+    {
+        return;
+    }
 
-	*last_id = i++;
+    *last_id = i++;
 
-	sleep(1);
+    sleep(1);
 
-	p->send = 1;
-	p->pos[0] = i*3;
-	p->pos[1] = i*3+1;
-	p->pos[2] = i*3+2;
+    p->send = 1;
+    p->pos[0] = i*3;
+    p->pos[1] = i*3+1;
+    p->pos[2] = i*3+2;
 
-	printf("<S>ending { %f %f %f }\n", p->pos[0], p->pos[1], p->pos[2]);
+    printf("<S>ending { %f %f %f }\n", p->pos[0], p->pos[1], p->pos[2]);
 }
 
 
 void to_network_layer(network_packet_t p)
 {
-	printf("<R>ecieved { %f %f %f }\n", p.pos[0], p.pos[1], p.pos[2]);
+    printf("<R>ecieved { %f %f %f }\n", p.pos[0], p.pos[1], p.pos[2]);
 
-	gPiggyBack.data.pos[0] = gPiggyBack.seq*4;
-	gPiggyBack.data.pos[1] = gPiggyBack.seq*4+1;
-	gPiggyBack.data.pos[2] = gPiggyBack.seq*4+2;
-	gPiggyBack.data.send = 1;
-	gPiggyBack.data.yaw = 90.0f;
+    gPiggyBack.data.pos[0] = gPiggyBack.seq*4;
+    gPiggyBack.data.pos[1] = gPiggyBack.seq*4+1;
+    gPiggyBack.data.pos[2] = gPiggyBack.seq*4+2;
+    gPiggyBack.data.send = 1;
+    gPiggyBack.data.yaw = 90.0f;
 }
 
 
 int main(int argc, char *argv[])
 {
-	printf("\n\n[Network class test]\n");
-	Network &test = *Network::Instance();
-
-
-	if (argc > 3)
-	{
-		if (argv[1][1] == 'v')
-		{
-			test.setDebug(true);
-		}
-
-		switch (argv[1][0])
-		{
-		case 'c':
-			test.setRemoteHost(argv[2]);
-			test.setPort(atoi(argv[3]));
-			test.runClient();
-			break;
-		case 's':
-			test.setBindHost(argv[2]);
-			test.setPort(atoi(argv[3]));
-			test.runServer();
-			break;
-		default:
-			printf("Error in command line, run %s for help\n", argv[0]);
-		}
-	}
-	else if (argc > 2)
-	{
-		test.setPort(atoi(argv[2]));
-		test.runServer();
-	}
-	else
-	{
-		printf("Server: %s s [bind_host_name] port\n", argv[0]);
-		printf("Client: %s c remote_host_name remote_host_port\n", argv[0]);
-		printf("Append 'v' behind c/s option for verbose. eg cv\n");
-	}
-
-	killNetworkSingleton();
-
-	return 0;
+    printf("\n\n[Network class test]\n");
+    Network &test = *Network::Instance();
+
+
+    if (argc > 3)
+    {
+        if (argv[1][1] == 'v')
+        {
+            test.setDebug(true);
+        }
+
+        switch (argv[1][0])
+        {
+            case 'c':
+                test.setRemoteHost(argv[2]);
+                test.setPort(atoi(argv[3]));
+                test.runClient();
+                break;
+            case 's':
+                test.setBindHost(argv[2]);
+                test.setPort(atoi(argv[3]));
+                test.runServer();
+                break;
+            default:
+                printf("Error in command line, run %s for help\n", argv[0]);
+        }
+    }
+    else if (argc > 2)
+    {
+        test.setPort(atoi(argv[2]));
+        test.runServer();
+    }
+    else
+    {
+        printf("Server: %s s [bind_host_name] port\n", argv[0]);
+        printf("Client: %s c remote_host_name remote_host_port\n", argv[0]);
+        printf("Append 'v' behind c/s option for verbose. eg cv\n");
+    }
+
+    killNetworkSingleton();
+
+    return 0;
 }
 

test/Sound.cpp

@@ -52,18 +52,18 @@ TEST loadFile() {
         FAIL();
     }
     fseek(f, 0, SEEK_END);
-	l = ftell(f);
-	fseek(f, 0, SEEK_SET);
-	buf = new unsigned char[l];
-	fread(buf, l, 1, f);
-	fclose(f);
-	if ((ret = sound.addWave(buf, l, &id, sound.SoundFlagsNone)) != 0) {
+    l = ftell(f);
+    fseek(f, 0, SEEK_SET);
+    buf = new unsigned char[l];
+    fread(buf, l, 1, f);
+    fclose(f);
+    if ((ret = sound.addWave(buf, l, &id, sound.SoundFlagsNone)) != 0) {
         printf("Couldn't add buffer (%d)!", ret);
         FAIL();
     }
-	sound.play(id);
-	delete [] buf;
-	sleep(2);
+    sound.play(id);
+    delete [] buf;
+    sleep(2);
     PASS();
 }
 

test/memory_test.cpp

@@ -36,140 +36,140 @@ extern long MAX_MEMORYC_USED;
 
 void tree_valid_report(rbtree_t *root);
 
-#define PRINT_TEST_BREAK_LINE	printf("\n############################################################\n\n");
+#define PRINT_TEST_BREAK_LINE   printf("\n############################################################\n\n");
 
 int memory_test_unit_test(int argc, char *argv[])
 {
-	int *i, *j, *k, *l, *m, *n, *o;
-
-
-	PRINT_TEST_BREAK_LINE
-	printf("Memory test\n");
-	PRINT_TEST_BREAK_LINE
-
-	i = new int;
-	printf(">\ti = new int; (%p)  %s:%i\n", i, __FILE__, __LINE__);
-	dump_memory_report();
-	tree_valid_report(MEMORY_INFO);
-
-	delete i;
-	printf(">\tdelete i; (%p)  %s:%i\n", i, __FILE__, __LINE__);
-	dump_memory_report();
-	tree_valid_report(MEMORY_INFO);
-
-	PRINT_TEST_BREAK_LINE
-
-	i = new int[3];
-	printf(">\ti = new int[3]; (%p)  %s:%i\n", i, __FILE__, __LINE__);
-	dump_memory_report();
-	tree_valid_report(MEMORY_INFO);
-
-	delete [] i;
-	printf(">\tdelete [] i; (%p)  %s:%i\n", i, __FILE__, __LINE__);
-	dump_memory_report();
-	tree_valid_report(MEMORY_INFO);
-
-	PRINT_TEST_BREAK_LINE
-
-	i = new int[3];
-	printf(">\ti = new int[3]; (%p)  %s:%i\n", i, __FILE__, __LINE__);
-	j = new int;
-	printf(">\tj = new int; (%p)  %s:%i\n", j, __FILE__, __LINE__);
-	k = new int[3];
-	printf(">\tk = new int[3]; (%p)  %s:%i\n", k, __FILE__, __LINE__);
-	dump_memory_report();
-	tree_valid_report(MEMORY_INFO);
-	delete [] i;
-	printf(">\tdelete [] i; (%p)  %s:%i\n", i, __FILE__, __LINE__);
-	delete j;
-	printf(">\tdelete j; (%p)  %s:%i\n", j, __FILE__, __LINE__);
-	delete [] k;
-	printf(">\tdelete [] k; (%p)  %s:%i\n", k, __FILE__, __LINE__);
-	dump_memory_report();
-	tree_valid_report(MEMORY_INFO);
-
-	PRINT_TEST_BREAK_LINE
-
-	i = new int[3];
-	printf(">\ti = new int[3]; (%p)  %s:%i\n", i, __FILE__, __LINE__);
-	j = new int;
-	printf(">\tj = new int; (%p)  %s:%i\n", j, __FILE__, __LINE__);
-	k = new int[3];
-	printf(">\tk = new int[3]; (%p)  %s:%i\n", k, __FILE__, __LINE__);
-	dump_memory_report();
-	tree_valid_report(MEMORY_INFO);
-	delete j;
-	printf(">\tdelete j; (%p)  %s:%i\n", j, __FILE__, __LINE__);
-	dump_memory_report();
-	tree_valid_report(MEMORY_INFO);
-	j = new int[3];
-	printf(">\tj = new int[3]; (%p)  %s:%i\n", j, __FILE__, __LINE__);
-	dump_memory_report();
-	tree_valid_report(MEMORY_INFO);
-	l = new int[3];
-	printf(">\tl = new int[3]; (%p)  %s:%i\n", l, __FILE__, __LINE__);
-	dump_memory_report();
-	tree_valid_report(MEMORY_INFO);
-	m = new int[3];
-	printf(">\tm = new int[3]; (%p)  %s:%i\n", m, __FILE__, __LINE__);
-	dump_memory_report();
-	tree_valid_report(MEMORY_INFO);
-
-	n = new int[3];
-	printf(">\tn = new int[3]; (%p)  %s:%i\n", n, __FILE__, __LINE__);
-	dump_memory_report();
-	tree_valid_report(MEMORY_INFO);
-
-	o = new int[3];
-	printf(">\to = new int[3]; (%p)  %s:%i\n", o, __FILE__, __LINE__);
-	dump_memory_report();
-	tree_valid_report(MEMORY_INFO);
-
-	delete [] k;
-	printf(">\tdelete [] k; (%p)  %s:%i\n", k, __FILE__, __LINE__);
-	dump_memory_report();
-	tree_valid_report(MEMORY_INFO);
-
-	delete [] j;
-	printf(">\tdelete [] j; (%p)  %s:%i\n", j, __FILE__, __LINE__);
-	dump_memory_report();
-	tree_valid_report(MEMORY_INFO);
-
-	delete [] l;
-	printf(">\tdelete [] l; (%p)  %s:%i\n", l, __FILE__, __LINE__);
-	dump_memory_report();
-	tree_valid_report(MEMORY_INFO);
-
-	delete [] m;
-	printf(">\tdelete [] m; (%p)  %s:%i\n", m, __FILE__, __LINE__);
-	dump_memory_report();
-	tree_valid_report(MEMORY_INFO);
-
-	delete [] n;
-	printf(">\tdelete [] n; (%p)  %s:%i\n", n, __FILE__, __LINE__);
-	dump_memory_report();
-	tree_valid_report(MEMORY_INFO);
-
-	delete [] o;
-	printf(">\tdelete [] o; (%p)  %s:%i\n", o, __FILE__, __LINE__);
-	dump_memory_report();
-	tree_valid_report(MEMORY_INFO);
-
-	delete [] i;
-	printf(">\tdelete [] i; (%p)  %s:%i\n", i, __FILE__, __LINE__);
-	dump_memory_report();
-	tree_valid_report(MEMORY_INFO);
-
-	PRINT_TEST_BREAK_LINE
-
-	return 0;
+    int *i, *j, *k, *l, *m, *n, *o;
+
+
+    PRINT_TEST_BREAK_LINE
+        printf("Memory test\n");
+    PRINT_TEST_BREAK_LINE
+
+        i = new int;
+    printf(">\ti = new int; (%p)  %s:%i\n", i, __FILE__, __LINE__);
+    dump_memory_report();
+    tree_valid_report(MEMORY_INFO);
+
+    delete i;
+    printf(">\tdelete i; (%p)  %s:%i\n", i, __FILE__, __LINE__);
+    dump_memory_report();
+    tree_valid_report(MEMORY_INFO);
+
+    PRINT_TEST_BREAK_LINE
+
+        i = new int[3];
+    printf(">\ti = new int[3]; (%p)  %s:%i\n", i, __FILE__, __LINE__);
+    dump_memory_report();
+    tree_valid_report(MEMORY_INFO);
+
+    delete [] i;
+    printf(">\tdelete [] i; (%p)  %s:%i\n", i, __FILE__, __LINE__);
+    dump_memory_report();
+    tree_valid_report(MEMORY_INFO);
+
+    PRINT_TEST_BREAK_LINE
+
+        i = new int[3];
+    printf(">\ti = new int[3]; (%p)  %s:%i\n", i, __FILE__, __LINE__);
+    j = new int;
+    printf(">\tj = new int; (%p)  %s:%i\n", j, __FILE__, __LINE__);
+    k = new int[3];
+    printf(">\tk = new int[3]; (%p)  %s:%i\n", k, __FILE__, __LINE__);
+    dump_memory_report();
+    tree_valid_report(MEMORY_INFO);
+    delete [] i;
+    printf(">\tdelete [] i; (%p)  %s:%i\n", i, __FILE__, __LINE__);
+    delete j;
+    printf(">\tdelete j; (%p)  %s:%i\n", j, __FILE__, __LINE__);
+    delete [] k;
+    printf(">\tdelete [] k; (%p)  %s:%i\n", k, __FILE__, __LINE__);
+    dump_memory_report();
+    tree_valid_report(MEMORY_INFO);
+
+    PRINT_TEST_BREAK_LINE
+
+        i = new int[3];
+    printf(">\ti = new int[3]; (%p)  %s:%i\n", i, __FILE__, __LINE__);
+    j = new int;
+    printf(">\tj = new int; (%p)  %s:%i\n", j, __FILE__, __LINE__);
+    k = new int[3];
+    printf(">\tk = new int[3]; (%p)  %s:%i\n", k, __FILE__, __LINE__);
+    dump_memory_report();
+    tree_valid_report(MEMORY_INFO);
+    delete j;
+    printf(">\tdelete j; (%p)  %s:%i\n", j, __FILE__, __LINE__);
+    dump_memory_report();
+    tree_valid_report(MEMORY_INFO);
+    j = new int[3];
+    printf(">\tj = new int[3]; (%p)  %s:%i\n", j, __FILE__, __LINE__);
+    dump_memory_report();
+    tree_valid_report(MEMORY_INFO);
+    l = new int[3];
+    printf(">\tl = new int[3]; (%p)  %s:%i\n", l, __FILE__, __LINE__);
+    dump_memory_report();
+    tree_valid_report(MEMORY_INFO);
+    m = new int[3];
+    printf(">\tm = new int[3]; (%p)  %s:%i\n", m, __FILE__, __LINE__);
+    dump_memory_report();
+    tree_valid_report(MEMORY_INFO);
+
+    n = new int[3];
+    printf(">\tn = new int[3]; (%p)  %s:%i\n", n, __FILE__, __LINE__);
+    dump_memory_report();
+    tree_valid_report(MEMORY_INFO);
+
+    o = new int[3];
+    printf(">\to = new int[3]; (%p)  %s:%i\n", o, __FILE__, __LINE__);
+    dump_memory_report();
+    tree_valid_report(MEMORY_INFO);
+
+    delete [] k;
+    printf(">\tdelete [] k; (%p)  %s:%i\n", k, __FILE__, __LINE__);
+    dump_memory_report();
+    tree_valid_report(MEMORY_INFO);
+
+    delete [] j;
+    printf(">\tdelete [] j; (%p)  %s:%i\n", j, __FILE__, __LINE__);
+    dump_memory_report();
+    tree_valid_report(MEMORY_INFO);
+
+    delete [] l;
+    printf(">\tdelete [] l; (%p)  %s:%i\n", l, __FILE__, __LINE__);
+    dump_memory_report();
+    tree_valid_report(MEMORY_INFO);
+
+    delete [] m;
+    printf(">\tdelete [] m; (%p)  %s:%i\n", m, __FILE__, __LINE__);
+    dump_memory_report();
+    tree_valid_report(MEMORY_INFO);
+
+    delete [] n;
+    printf(">\tdelete [] n; (%p)  %s:%i\n", n, __FILE__, __LINE__);
+    dump_memory_report();
+    tree_valid_report(MEMORY_INFO);
+
+    delete [] o;
+    printf(">\tdelete [] o; (%p)  %s:%i\n", o, __FILE__, __LINE__);
+    dump_memory_report();
+    tree_valid_report(MEMORY_INFO);
+
+    delete [] i;
+    printf(">\tdelete [] i; (%p)  %s:%i\n", i, __FILE__, __LINE__);
+    dump_memory_report();
+    tree_valid_report(MEMORY_INFO);
+
+    PRINT_TEST_BREAK_LINE
+
+        return 0;
 }
 
 
 int main(int argc, char *argv[])
 {
-	printf("[memory_test test]\n");
+    printf("[memory_test test]\n");
 
-	return memory_test_unit_test(argc, argv);
+    return memory_test_unit_test(argc, argv);
 }