Touched up documentation

Makefile

@@ -296,7 +296,7 @@ endif
 #################################################################
 # Unit Test builds
 #################################################################
-TEST_FLAGS=$(FLAGS_ALL) -g -O0 -DDEBUG -lstdc++ -Iinclude
+TEST_FLAGS=$(FLAGS_ALL) -g -O0 -DDEBUG -DUNIT_TEST -lstdc++ -Iinclude
 
 TEST_MAP_TR5=~/.OpenRaider/paks/tr5/demo.trc
 TEST_MAP_TR4=~/.OpenRaider/paks/tr4/angkor1.tr4

include/Quaternion.h

@@ -1,365 +1,213 @@
-/* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
-/*================================================================
+/*!
+ * \file include/Quaternion.h
+ * \brief Quaternion
  *
- * Project : Hel
- * Author  : Terry 'Mongoose' Hendrix II
- * Website : http://www.westga.edu/~stu7440/
- * Email   : stu7440@westga.edu
- * Object  : Quaternion
- * License : No use w/o permission (C) 2002 Mongoose
- * Comments: Quaternion now in C++ class form fresh from the grove
- *
- *
- *           This file was generated using Mongoose's C++
- *           template generator script.  <stu7440@westga.edu>
- *
- *-- Test Defines -----------------------------------------------
- *
- * UNIT_TEST_QUATERNION - Builds Quaternion class as a console unit test
- *
- *-- History ------------------------------------------------
- *
- * 2002.12.16:
- * Mongoose - Created, based on mtk3d ( freyja )
- ================================================================*/
-
+ * \author Mongoose
+ */
 
 #ifndef _QUATERNION_H_
 #define _QUATERNION_H_
 
 #include <MatMath.h>
 
-class Quaternion
-{
- public:
-
-    ////////////////////////////////////////////////////////////
-    // Constructors
-    ////////////////////////////////////////////////////////////
+/*!
+ * \brief Quaternion
+ */
+class Quaternion {
+public:
 
+    /*!
+     * \brief Constructs an object of Quaternion
+     */
     Quaternion();
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : Constructs an object of Quaternion
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.12.16:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Constructs an object of Quaternion
+     * \param w W part of new Quaternion
+     * \param x X part of new Quaternion
+     * \param y Y part of new Quaternion
+     * \param z Z part of new Quaternion
+     */
     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
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Constructs an object of Quaternion
+     * \param v contents of new Quaternion
+     */
     Quaternion(vec4_t v);
-    /*------------------------------------------------------
-     * Pre  : v { w, x, y, z }
-     * Post : Constructs an object of Quaternion
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.12.16:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Deconstructs an object of Quaternion
+     */
     ~Quaternion();
-    /*------------------------------------------------------
-     * Pre  : Quaternion object is allocated
-     * Post : Deconstructs an object of Quaternion
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.12.16:
-     * Mongoose - Created
-     ------------------------------------------------------*/
-
-
-    ////////////////////////////////////////////////////////////
-    // Public Accessors
-    ////////////////////////////////////////////////////////////
 
+    /*!
+     * \brief Get column order matrix equivalent of this quaternion
+     * \param m where matrix will be stored
+     */
     void getMatrix(matrix_t m);
-    /*------------------------------------------------------
-     * Pre  : Matrix is valid
-     * Post : Returns col order matrix equiv of this quaternion
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.05.08:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Assign q to this quaternion
+     * \param q what to assign this quaternion to
+     * \returns this quaternion
+     */
     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 )
+    /*!
+     * \brief Multiplies this quaternion.
      *
-     *-- History ------------------------------------------
+     * Use normalize() call for unit quaternion.
      *
-     * 2002.05.08:
-     * Mongoose - Created
-     ------------------------------------------------------*/
+     * \param q what to multiply this quaternion with
+     * \returns resultant quaternion
+     * \sa Quaternion::normalize()
+     */
+    Quaternion operator *(const Quaternion &q);
 
+    /*!
+     * \brief Divide from this quaternion
+     * \param q what to divide from this quaternion
+     * \returns resultant quaternion
+     */
     Quaternion operator /(const Quaternion &q);
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : Dividess Q from this quaternion
-     *        returns quotient quaternion
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.05.08:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Add to this quaternion
+     * \param q what to add to this quaternion
+     * \returns resultant quaternion
+     */
     Quaternion operator +(const Quaternion &q);
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : Adds Q and this quaternion
-     *        returns resultant quaternion
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.05.08:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Subtract from this quaternion
+     * \param q what to subtract from this quaternion
+     * \returns resultant quaternion
+     */
     Quaternion operator -(const Quaternion &q);
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : Subtracts Q from this quaternion
-     *        returns resultant quaternion
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.05.08:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Compares q to this quaternion
+     * \param q what to compare this quaternion to
+     * \returns true if equal, false otherwise
+     */
     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
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Conjugate this quaternion
+     * \returns Conjugate of this quaternion
+     */
     Quaternion conjugate();
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : Returns conjugate of this quaternion
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.05.08:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Scale this quaternion
+     * \param s scaling factor
+     * \returns Scaled result of this quaternion
+     */
     Quaternion scale(vec_t s);
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : Returns scaled result of this quaternion
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.05.08:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Inverse this quaternion
+     * \brief Returns inverse of this quaternion
+     */
     Quaternion inverse();
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : Returns inverse of this quaternion
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.05.08:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Dot Product of quaternions
+     * \param a first argument to dot product
+     * \param b second argument to dot product
+     * \returns dot product between a and b quaternions
+     */
     static vec_t dot(Quaternion a, Quaternion b);
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : Returns dot product of A and B quaternions
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.05.08:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Magnitude of this quaternion
+     * \returns Magnitude of this quaternion
+     */
     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
+    /*!
+     * \brief Interpolates between a and b rotations.
      *
-     *-- History ------------------------------------------
+     * Using spherical linear interpolation:
+     * `I = (((B . A)^-1)^Time)A`
      *
-     * 2002.05.08:
-     * Mongoose - Created
-     ------------------------------------------------------*/
-
-
-    ////////////////////////////////////////////////////////////
-    // Public Mutators
-    ////////////////////////////////////////////////////////////
+     * \param a first argument for slerp
+     * \param b second argument for slerp
+     * \param t time argument for slerp
+     * \returns resultant quaternion
+     */
+    static Quaternion slerp(Quaternion a, Quaternion b, vec_t time);
 
+    /*!
+     * \brief Sets this quaternion to identity
+     */
     void setIdentity();
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : Sets this quaternion to identity
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.05.08:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Sets this quaternion
+     * \param angle new angle
+     * \param x new X coordinate
+     * \param y new Y coordinate
+     * \param z new Z coordinate
+     */
     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
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Normalize this quaternion
+     */
     void normalize();
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : Normalize this quaternion
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.05.08:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Set this quaternion
+     * \param q will be copied into this quaternion
+     */
     void copy(Quaternion q);
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : Set this quaternion using q
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.05.08:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Sets matrix equivalent of this quaternion
+     * \param m matrix in valid column order
+     */
     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:
+
+    /*!
+     * \brief Multiplies two quaternions
+     * \param a first argument to multiplication
+     * \param b second argument to multiplication
+     * \returns resultant quaternion
+     */
+    static Quaternion multiply(Quaternion a, Quaternion b);
+
+    /*!
+     * \brief Divides B from A quaternion
+     * \param a first argument to division
+     * \param b second argument to division
+     * \returns quotient quaternion
+     */
+    static Quaternion divide(Quaternion a, Quaternion b);
+
+    /*!
+     * \brief Adds A and B quaternions
+     * \param a first argument to addition
+     * \param b second argument to addition
+     * \returns resultant quaternion
+     */
+    static Quaternion add(Quaternion a, Quaternion b);
+
+    /*!
+     * \brief Subtracts B from A quaternion
+     * \param a first argument to subtraction
+     * \param b second argument to subtraction
+     * \returns resultant quaternion
+     */
+    static Quaternion subtract(Quaternion a, Quaternion b);
+
+    vec_t mW; //!< Quaternion, W part
+    vec_t mX; //!< Quaternion, X part
+    vec_t mY; //!< Quaternion, Y part
+    vec_t mZ; //!< Quaternion, Z part
 };
 
 #endif

include/SDLSystem.h

@@ -1,238 +1,129 @@
-/* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
-/*================================================================
+/*!
+ * \file include/SDLSystem.h
+ * \brief SDL System interface implementation
  *
- * Project : OpenRaider
- * Author  : Terry 'Mongoose' Hendrix II
- * Website : http://www.westga.edu/~stu7440/
- * Email   : stu7440@westga.edu
- * Object  : SDLSystem
- * License : No use w/o permission (C) 2002 Mongoose
- * Comments:
- *
- *
- *           This file was generated using Mongoose's C++
- *           template generator script.  <stu7440@westga.edu>
- *
- *-- History ------------------------------------------------
- *
- * 2002.06.06:
- * Mongoose - Created
- ================================================================*/
-
+ * \author Mongoose
+ */
 
 #ifndef _SDLSYSTEM_H_
 #define _SDLSYSTEM_H_
 
 #include <SDL/SDL.h>
-
 #include <System.h>
 
-class SDLSystem : public System
-{
- public:
-
-    ////////////////////////////////////////////////////////////
-    // Constructors
-    ////////////////////////////////////////////////////////////
+/*!
+ * \brief SDL System interface implementation
+ */
+class SDLSystem : public System {
+public:
 
+    /*!
+     * \brief Constructs an object of SDLSystem
+     */
     SDLSystem();
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : Constructs an object of SDLSystem
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.06.06:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Deconstructs an object of SDLSystem
+     */
     virtual ~SDLSystem();
-    /*------------------------------------------------------
-     * Pre  : SDL object is allocated
-     * Post : Deconstructs an object of SDLSystem
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.06.06:
-     * Mongoose - Created
-     ------------------------------------------------------*/
-
-
-    ////////////////////////////////////////////////////////////
-    // Public Accessors
-    ////////////////////////////////////////////////////////////
 
+    /*!
+     * \brief Get ticks
+     * \returns number of milliseconds since start of program
+     */
     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
-     *
-    * Post : Renders string in OpenGL ( 2d projection )
-     *
-     *        Call glExitMode2d() after finishing calls
-     *        to this method and other 2d rendering
-    *
-    *-- History ------------------------------------------
-    *
-     * 2003.06.03:
-     * Mongoose - Ported to SDL_TTF
-     *
-    * 2001.12.31:
-    * Mongoose - Created
-    ------------------------------------------------------*/
-
-   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
-     *
-    * Post : Renders string in OpenGL ( 3d projection )
-    *
-    *-- History ------------------------------------------
-    *
-     * 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
-     ------------------------------------------------------*/
 
+    /*
+     * \brief Sets Event binding Cmd to Key press
+     * \param cmd valid command string
+     * \param key valid keyboard code
+     * \param event valid game event id
+     */
+    //! \fixme void bindKeyCommand(const char *cmd, int key, int event);
+
+    /*!
+     * \brief Renders string in OpenGL (2D projection).
+     *
+     * Requires Texture::glEnterMode2d() call before entry.
+     *
+     * System::bufferString(..) can cache printf() style calls
+     * for use with this method.
+     *
+     * Call Texture::glExitMode2d after finishing calls to this method
+     * and other 2D rendering.
+     *
+     * \param x valid X world coordinate
+     * \param y valid Y world coordinate
+     * \param string valid string
+     *
+     * \sa System::bufferString()
+     * \sa Texture::glEnterMode2d()
+     * \sa Texture::glExitMode2d()
+     */
+    void glPrintf2d(float x, float y, char *string);
+
+    /*!
+     * \brief Renders string in OpenGL (3D projection).
+     *
+     * System::bufferString(..) can cache printf() style calls
+     * for use with this method.
+     *
+     * \param x valid X world coordinate
+     * \param y valid Y world coordinate
+     * \param z valid Z world coordinate
+     * \param string valid string
+     *
+     * \sa System::bufferString()
+     */
+    void glPrintf3d(float x, float y, float z, char *string);
+
+    /*!
+     * \brief Start up video subsystem
+     * \param width valid video mode width
+     * \param height valid video mode height
+     * \param fullscreen enables fullscreen rendering
+     */
+    void initVideo(unsigned int width, unsigned int height, bool fullscreen);
+
+    /*!
+     * \brief Resizes game window
+     * \param width new width
+     * \param height new height
+     */
     void resize(unsigned int width, unsigned int height);
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : Resizes game window
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.06.06:
-     * Mongoose - Created, from old SDLUnitTest code
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Start game loop
+     */
     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
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Shuts down the game subsystems, exits game loop
+     * \param i exit code
+     */
     void shutdown(int i);
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : Shutsdown the game subsystems, exits game loop
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.06.06:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Swaps OpenGL buffers.
+     * Call at end of frame.
+     */
     void swapBuffersGL();
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : Swaps OpenGL buufers ( call at end of frame )
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.06.06:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Toggle fullscreen windowing mode
+     */
     void toggleFullscreen();
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : Toggle fullscreen windowing mode
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.06.06:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
- protected:
+protected:
     int m_old_width;
     int m_old_height;
-    bool mFirstMouseEvent; // Filter first mouse event (SDL bug)
-    bool mFullscreen; //!< Current Fullscreen/Windowed mode
-
- private:
-
-    ////////////////////////////////////////////////////////////
-    // Private Accessors
-    ////////////////////////////////////////////////////////////
+    bool mFirstMouseEvent; //!< Filter first mouse event (SDL bug)
+    bool mFullscreen;      //!< Current Fullscreen/Windowed mode
 
-
-    ////////////////////////////////////////////////////////////
-    // Private Mutators
-    ////////////////////////////////////////////////////////////
-
-    SDL_Surface *mWindow;   /* This is the pointer to the SDL surface */
+private:
+    SDL_Surface *mWindow;  //!< This is the pointer to the SDL surface
 };
+
 #endif

include/Tree.h

@@ -658,116 +658,77 @@ public:
 
 private:
 
-    TreeNode<Key, Data> *GetSuccessor(TreeNode<Key, Data> *tree)
-    {
+    TreeNode<Key, Data> *GetSuccessor(TreeNode<Key, Data> *tree) {
         TreeNode<Key, Data> *successor;
-
-
         successor = tree->GetRight();
 
-        if (successor)
-        {
+        if (successor) {
             while (successor->GetLeft())
-            {
                 successor = successor->GetLeft();
-            }
-
-            return successor;
-        }
-        else
-        {
+        } else {
             successor = tree->GetParent();
 
-            while (tree == successor->GetRight())
-            {
+            while (tree == successor->GetRight()) {
                 tree = successor;
                 successor = successor->GetParent();
             }
 
             if (successor == _root)
-            {
                 return NULL;
-            }
-
-            return successor;
         }
-    }
 
+        return successor;
+    }
 
-    TreeNode<Key, Data> *GetPredecessor(TreeNode<Key, Data> *tree)
-    {
+    TreeNode<Key, Data> *GetPredecessor(TreeNode<Key, Data> *tree) {
         TreeNode<Key, Data> *predecessor;
-
-
         predecessor = tree->GetLeft();
 
-        if (predecessor)
-        {
+        if (predecessor) {
             while (predecessor->GetRight())
-            {
                 predecessor = predecessor->GetRight();
-            }
-
-            return predecessor;
-        }
-        else
-        {
+        } else {
             predecessor = tree->GetParent();
 
-            while (tree == predecessor->GetLeft())
-            {
+            while (tree == predecessor->GetLeft()) {
                 if (predecessor == _root)
-                {
                     return NULL;
-                }
 
                 tree = predecessor;
                 predecessor = predecessor->GetParent();
             }
-
-            return predecessor;
         }
-    }
 
+        return predecessor;
+    }
 
-    bool IsValidRedBlackTreeCheck(TreeNode<Key, Data> *current, bool valid)
-    {
+    bool IsValidRedBlackTreeCheck(TreeNode<Key, Data> *current, bool valid) {
         TreeNode<Key, Data> *right, *left;
         _tree_h_color_t color_red;
 
         if (!current)
-        {
             return valid;
-        }
 
         // Mongoose 2002.02.19, Check for a red root
         if (!current->GetParent() && current->GetColor() == _tree_h_red)
-        {
             return false;
-        }
 
         color_red = (current->GetColor() == _tree_h_red);
         left = current->GetLeft();
         right = current->GetRight();
 
         // Mongoose 2002.02.19, Check for adj red nodes
-        if (left)
-        {
+        if (left) {
             if (color_red && left->GetColor() == _tree_h_red)
-            {
                 return false;
-            }
 
             if (!IsValidRedBlackTreeCheck(left, valid))
                 return false;
         }
 
-        if (right)
-        {
+        if (right) {
             if (color_red && right->GetColor() == _tree_h_red)
-            {
                 return false;
-            }
 
             if (!IsValidRedBlackTreeCheck(right, valid))
                 return false;
@@ -776,16 +737,11 @@ private:
         return true;
     }
 
-
-    void RotateLeft(TreeNode<Key, Data> *tree)
-    {
+    void RotateLeft(TreeNode<Key, Data> *tree) {
         TreeNode<Key, Data> *right, *right_leftchild, *parent, *uncle;
 
-
         if (!tree || !_root)
-        {
             return;
-        }
 
         // Get tree's right node
         right = tree->GetRight();
@@ -794,207 +750,142 @@ private:
         right_leftchild = NULL;
 
         if (right)
-        {
             right_leftchild = right->GetLeft();
-        }
 
         // Set tree's right node to right's left child
         tree->SetRight(right_leftchild);
 
         // Child now has a new parent
         if (right_leftchild)
-        {
             right_leftchild->SetParent(tree);
-        }
 
         // Right also has a new parent
         if (right)
-        {
-        right->SetParent(tree->GetParent());
-        }
+            right->SetParent(tree->GetParent());
 
         // Get parent
         parent = tree->GetParent();
 
-        if (parent)  // Not root
-        {
+        if (parent) { // Not root
             uncle = parent->GetLeft();
 
             // Mix up at hosptial, switch parent's children!
             if (tree == uncle)
-            {
                 parent->SetLeft(right);
-            }
             else
-            {
                 parent->SetRight(right);
-            }
-        }
-        else // TreeNode 'tree' was root, so now right is root
-        {
+        } else { // TreeNode 'tree' was root, so now right is root
             _root = right;
         }
 
-        if (right)
-        {
+        if (right) {
             // TreeNode 'tree' is now right's left child
             right->SetLeft(tree);
 
             if (tree)
-            {
                 tree->SetParent(right);
-            }
         }
     }
 
-
-    void RotateRight(TreeNode<Key, Data> *tree)
-    {
+    void RotateRight(TreeNode<Key, Data> *tree) {
         TreeNode<Key, Data> *left, *left_rightchild, *parent, *uncle;
 
-
         if (!tree || !_root)
-        {
             return;
-        }
 
         left = tree->GetLeft();
 
         left_rightchild = NULL;
 
         if (left)
-        {
             left_rightchild = left->GetRight();
-        }
 
         tree->SetLeft(left_rightchild);
 
         if (left_rightchild)
-        {
-        left_rightchild->SetParent(tree);
-        }
+            left_rightchild->SetParent(tree);
 
         if (left)
-        {
-        left->SetParent(tree->GetParent());
-        }
+            left->SetParent(tree->GetParent());
 
         parent = tree->GetParent();
 
-        if (parent)    //if node is not the root
-        {
+        if (parent) { //if node is not the root
             uncle = parent->GetRight();
 
             if (tree == uncle)
-            {
                 parent->SetRight(left);
-            }
             else
-            {
                 parent->SetLeft(left);
-            }
-        }
-        else
-        {
+        } else {
         _root = left;
         }
 
         left->SetRight(tree);
 
         if (tree)
-        {
-        tree->SetParent(left);
-        }
+            tree->SetParent(left);
     }
 
 
     void TreeNodeShallowCopy(TreeNode<Key, Data> *src,
-                                     TreeNode<Key, Data> *dest, bool no_links)
-    {
+                                TreeNode<Key, Data> *dest, bool no_links) {
         if (!src || !dest)
-        {
             return;
-        }
 
         dest->SetKey(src->GetKey());
         dest->SetData(src->GetData());
         dest->SetColor(src->GetColor());
 
-        if (!no_links)
-        {
+        if (!no_links) {
             dest->SetRight(src->GetRight());
             dest->SetLeft(src->GetLeft());
             dest->SetParent(src->GetParent());
         }
     }
 
-
-    void Remove(TreeNode<Key, Data> *tree)
-    {
+    void Remove(TreeNode<Key, Data> *tree) {
         TreeNode<Key, Data> *left, *right, *parent, *prev, *cur;
 
-
         // Mongoose 2002.02.16, Nothing to remove
         if (!tree || !_root)
-        {
             return;
-        }
 
         left = tree->GetLeft();
         right = tree->GetRight();
         parent = tree->GetParent();
 
-
         if (!left || !right)
-        {
             prev = tree;
-        }
         else
-        {
             prev = GetSuccessor(tree);
-        }
 
         if (!prev)
             return; // Probably a good idea, as there's a check if(prev) later
 
         if (prev->GetLeft())
-        {
             cur = prev->GetLeft();
-        }
         else
-        {
             cur = prev->GetRight();
-        }
 
         if (cur)
-        {
             cur->SetParent(prev->GetParent());
-        }
 
-        if (!prev->GetParent())
-        {
+        if (!prev->GetParent()) {
             _root = cur;
-        }
-        else
-        {
+        } else {
             parent = prev->GetParent();
 
             if (prev == parent->GetLeft())
-            {
                 parent->SetLeft(cur);
-            }
             else
-            {
                 parent->SetRight(cur);
-            }
         }
 
-        if (prev != tree)
-        {
+        if (prev != tree) {
             TreeNodeShallowCopy(prev, tree, true);
 
-            if (prev->GetParent())
-            {
+            if (prev->GetParent()) {
                 if (prev == (prev->GetParent())->GetLeft())
                     (prev->GetParent())->SetLeft(tree);
                 else if (prev == (prev->GetParent())->GetRight())
@@ -1004,8 +895,7 @@ private:
 
         --_num_elements;
 
-        if (prev)
-        {
+        if (prev) {
             prev->SetRight(NULL);
             prev->SetParent(NULL);
             prev->SetLeft(NULL);
@@ -1014,58 +904,41 @@ private:
         }
 
         if (tree->GetColor() == _tree_h_black)
-        {
             RestoreRedBlackAfterRemove(cur);
-        }
     }
 
-
-    void RestoreRedBlackAfterRemove(TreeNode<Key, Data> *tree)
-    {
+    void RestoreRedBlackAfterRemove(TreeNode<Key, Data> *tree) {
         TreeNode<Key, Data> *parent, *sibling, *sleft, *sright;
 
-
         if (!tree || !_root)
-        {
             return;
-        }
 
         parent = tree->GetParent();
 
-        while ((tree != _root) && (parent->GetColor() == _tree_h_black))
-        {
-            if (tree == parent->GetLeft())
-            {
+        while ((tree != _root) && (parent->GetColor() == _tree_h_black)) {
+            if (tree == parent->GetLeft()) {
                 sibling = parent->GetRight();
 
-                if (sibling && sibling->GetColor() == _tree_h_red)
-                {
+                if (sibling && sibling->GetColor() == _tree_h_red) {
                     sibling->SetColor(_tree_h_black);
                     parent->SetColor(_tree_h_red);
                     RotateLeft(parent);
                     sibling = parent->GetRight();
                 }
 
-                if (sibling)
-                {
+                if (sibling) {
                     sleft = sibling->GetLeft();
                     sright = sibling->GetRight();
-                }
-                else
-                {
+                } else {
                     sleft = sright = NULL;
                 }
 
                 if (sright && sright->GetColor() == _tree_h_black &&
-                     sleft && sleft->GetColor() ==_tree_h_black)
-                {
+                        sleft && sleft->GetColor() ==_tree_h_black) {
                     sibling->SetColor(_tree_h_red);
                     tree = parent;
-                }
-                else
-                {
-                    if (sright && sright->GetColor() == _tree_h_black)
-                    {
+                } else {
+                    if (sright && sright->GetColor() == _tree_h_black) {
                         sibling->SetColor(_tree_h_red);
                         sleft->SetColor(_tree_h_black);
                         RotateRight(sibling);
@@ -1078,39 +951,29 @@ private:
                     RotateLeft(parent);
                     tree = _root;
                 }
-            }
-            else
-            {
+            } else {
                 sibling = parent->GetLeft();
 
-                if (sibling && sibling->GetColor() == _tree_h_red)
-                {
+                if (sibling && sibling->GetColor() == _tree_h_red) {
                     sibling->SetColor(_tree_h_black);
                     parent->SetColor(_tree_h_red);
                     RotateLeft(parent);
                     sibling = parent->GetLeft();
                 }
 
-                if (sibling)
-                {
+                if (sibling) {
                     sleft = sibling->GetLeft();
                     sright = sibling->GetRight();
-                }
-                else
-                {
+                } else {
                     sleft = sright = NULL;
                 }
 
                 if (sright && sright->GetColor() == _tree_h_black &&
-                     sleft && sleft->GetColor() ==_tree_h_black)
-                {
+                     sleft && sleft->GetColor() ==_tree_h_black) {
                     sibling->SetColor(_tree_h_red);
                     tree = parent;
-                }
-                else
-                {
-                    if (sleft && sleft->GetColor() == _tree_h_black)
-                    {
+                } else {
+                    if (sleft && sleft->GetColor() == _tree_h_black) {
                         sibling->SetColor(_tree_h_red);
                         sright->SetColor(_tree_h_black);
                         RotateLeft(sibling);
@@ -1131,43 +994,32 @@ private:
         tree->SetColor(_tree_h_black);
     }
 
-
-    void RestoreRedBlackAfterInsert(TreeNode<Key, Data> *tree)
-    {
+    void RestoreRedBlackAfterInsert(TreeNode<Key, Data> *tree) {
         TreeNode<Key, Data> *parent, *grandparent, *uncle;
 
-
         if (!tree || !_root || tree == _root)
-        {
             return;
-        }
 
         tree->SetColor(_tree_h_red);
 
         parent = tree->GetParent();
 
-        while ((tree != _root) && (parent->GetColor() == _tree_h_red))
-        {
+        while ((tree != _root) && (parent->GetColor() == _tree_h_red)) {
             grandparent = parent->GetParent();
 
-            if (parent == grandparent->GetLeft())
-            {
+            if (parent == grandparent->GetLeft()) {
                 uncle = grandparent->GetRight();
 
-                if (uncle && uncle->GetColor() == _tree_h_red)
-                {
-               // Case 1 - Change the colors
-               parent->SetColor(_tree_h_black);
+                if (uncle && uncle->GetColor() == _tree_h_red) {
+                    // Case 1 - Change the colors
+                    parent->SetColor(_tree_h_black);
                     uncle->SetColor(_tree_h_black);
                     grandparent->SetColor(_tree_h_red);
 
-               // Move up the tree
-               tree = grandparent;
-                }
-                else // Uncle is a black node
-                {
-               if (tree == parent->GetRight())
-                    {
+                    // Move up the tree
+                    tree = grandparent;
+                } else { // Uncle is a black node
+                    if (tree == parent->GetRight()) {
                         // Case 2 - Move up and rotate
                         tree = parent;
                         RotateLeft(tree);
@@ -1180,25 +1032,19 @@ private:
                     grandparent->SetColor(_tree_h_red);
                     RotateRight(grandparent);
                 }
-            }
-            else // TreeNode 'tree' is in right subtree
-            {
+            } else { // TreeNode 'tree' is in right subtree
                 uncle = grandparent->GetLeft();
 
-                if (uncle && uncle->GetColor() == _tree_h_red)
-                {
-               // Case 1 - Change the colors
-               parent->SetColor(_tree_h_black);
+                if (uncle && uncle->GetColor() == _tree_h_red) {
+                    // Case 1 - Change the colors
+                    parent->SetColor(_tree_h_black);
                     uncle->SetColor(_tree_h_black);
                     grandparent->SetColor(_tree_h_red);
 
-               // Move up the tree
-               tree = grandparent;
-                }
-                else // Uncle is a black node
-                {
-               if (tree == parent->GetLeft())
-                    {
+                    // Move up the tree
+                    tree = grandparent;
+                } else { // Uncle is a black node
+                    if (tree == parent->GetLeft()) {
                         // Case 2 - Move up and rotate
                         tree = parent;
                         RotateRight(tree);

include/Vector3d.h

@@ -1,297 +1,159 @@
-/* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
-/*================================================================
+/*!
+ * \file include/Vector3d.h
+ * \brief 3D Math vector
  *
- * Project : Hel
- * Author  : Terry 'Mongoose' Hendrix II
- * Website : http://www.westga.edu/~stu7440/
- * Email   : stu7440@westga.edu
- * Object  : Vector3d
- * License : No use w/o permission (C) 2002 Mongoose
- * Comments: Math vector
- *
- *
- *           This file was generated using Mongoose's C++
- *           template generator script.  <stu7440@westga.edu>
- *
- *-- Test Defines -----------------------------------------------
- *
- * UNIT_TEST_VECTOR3D - Builds Vector3d class as a console unit test
- *
- *-- History ------------------------------------------------
- *
- * 2002.12.24:
- * Mongoose - Created
- ================================================================*/
-
+ * \author Mongoose
+ */
 
 #ifndef _VECTOR3D_H_
 #define _VECTOR3D_H_
 
-
 #include <MatMath.h>
 
-class Vector3d
-{
- public:
-
-    ////////////////////////////////////////////////////////////
-    // Constructors
-    ////////////////////////////////////////////////////////////
+/*!
+ * \brief 3D Math Vector
+ */
+class Vector3d {
+public:
 
+    /*!
+     * \brief Constructs an object of Vector3d
+     */
     Vector3d();
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : Constructs an object of Vector3d
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.12.24:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Constructs an object of Vector3d
+     * \param v data to load into new Vector3d
+     */
     Vector3d(vec3_t v);
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : Constructs an object of Vector3d
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.12.24:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Constructs an object of Vector3d
+     * \param x X part of new Vector3d
+     * \param y Y part of new Vector3d
+     * \param z Z part of new Vector3d
+     */
     Vector3d(vec_t x, vec_t y, vec_t z);
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : Constructs an object of Vector3d
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.12.24:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Deconstructs an object of Vector3d
+     */
     ~Vector3d();
-    /*------------------------------------------------------
-     * Pre  : Vector3d object is allocated
-     * Post : Deconstructs an object of Vector3d
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.12.24:
-     * Mongoose - Created
-     ------------------------------------------------------*/
-
-
-    ////////////////////////////////////////////////////////////
-    // Public Accessors
-    ////////////////////////////////////////////////////////////
 
+    /*!
+     * \brief Calculate dot product
+     * \param u first argument
+     * \param v second argument
+     * \returns dot product of u and v vectors
+     */
     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
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Calculate cross product
+     * \param u first argument
+     * \param v second argument
+     * \returns cross product of u and v vectors
+     */
     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
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Get Magnitude
+     * \returns magnitude of this vector
+     */
     vec_t magnitude();
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : Returns magnitude this vector
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.05.08:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Normalize
+     * \returns normalized copy of this vector
+     */
     Vector3d unit();
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : Returns normalized copy of this vector
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.05.08:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Get the Zero vector
+     * \returns (0, 0, 0) vector
+     */
     static Vector3d zeroVector();
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : Returns the Zero vector <0, 0, 0>
-     *
-     *-- History ------------------------------------------
-     *
-     * 2003.06.08:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Add to this vector
+     * \param v addend
+     * \returns a vector = this vector + v
+     */
     Vector3d operator +(const Vector3d &v);
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : Returns a vector = this vector + v
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.05.08:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Subtract from this vector
+     * \param v subtrahend
+     * \returns a vector = this vector - v
+     */
     Vector3d operator -(const Vector3d &v);
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : Returns a vector = this vector - v
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.05.08:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Negate this vector
+     * \returns a copy of this vector, negated
+     */
     Vector3d operator -();
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : Returns a copy of this vector, negated
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.05.08:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Scale this vector
+     * \param s scaling factor
+     * \returns this vector multiplied with s
+     */
     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
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Scale this vactor
+     * \param s inverse scaling factor
+     * \returns this vector divided by s
+     */
     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
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Dot product this vector
+     * \param v second vector for dot product
+     * \returns dot product of V by this vector
+     */
     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
-    ////////////////////////////////////////////////////////////
 
+    /*!
+     * \brief Normalizes this vector
+     */
     void normalize();
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : Normalizes *this vector
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.05.08:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Set this vector to Zero (0, 0, 0)
+     */
     void zero();
-    /*------------------------------------------------------
-     * Pre  :
-     * Post :This is set to the Zero vector <0, 0, 0>
-     *
-     *-- History ------------------------------------------
-     *
-     * 2003.06.08:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Set this vector
+     * \param v what this vector will be set to
+     * \returns this vector, now equal to v
+     */
     Vector3d &operator =(const Vector3d &v);
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : this = v, values are assigned   =)
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.05.08:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Add to this vector, in place
+     * \param v what will be added to this vector
+     * \returns this vector, with v added
+     */
     Vector3d &operator +=(const Vector3d &v);
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : this += v, values are sumed, assigned   =)
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.05.08:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Subtract from this vector, in place
+     * \param v what will be subtracted from this vector
+     * \returns this vector, with v subtracted
+     */
     Vector3d &operator -=(const Vector3d &v);
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : this -= v, values are diffed, assigned   =)
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.05.08:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Scale this vector, in place
+     * \param s scaling factor
+     * \returns this vactor multiplied by s
+     */
     Vector3d &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 Mutators
-    ////////////////////////////////////////////////////////////
 
+    vec3_t mVec; //!< Vector data
 };
 
 #endif

include/ViewVolume.h

@@ -1,28 +1,9 @@
-/* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
-/*================================================================
+/*!
+ * \file include/ViewVolume.h
+ * \brief Viewing Volume for culling use
  *
- * Project : hel
- * Author  : Terry 'Mongoose' Hendrix II
- * Website : http://www.westga.edu/~stu7440/
- * Email   : stu7440@westga.edu
- * Object  : ViewVolume
- * License : No use w/o permission (C) 2002 Mongoose
- * Comments: This is the viewing volume for culling use
- *
- *
- *           This file was generated using Mongoose's C++
- *           template generator script.  <stu7440@westga.edu>
- *
- *-- Test Defines -----------------------------------------------
- *
- * UNIT_TEST_VIEWVOLUME - Builds ViewVolume class as a console unit test
- *
- *-- History ------------------------------------------------
- *
- * 2002.12.15:
- * Mongoose - Created
- ================================================================*/
-
+ * \author Mongoose
+ */
 
 #ifndef _VIEWVOLUME_H_
 #define _VIEWVOLUME_H_
@@ -30,265 +11,169 @@
 #include <Matrix.h>
 #include <BoundingVolume.h>
 
-class ViewVolume
-{
- public:
-
-    enum ViewVolumeSide
-    {
-        rightSide  = 0, // Right
-        leftSide   = 1, // Left
-        bottomSide = 2, // Bottom
-        topSide    = 3, // Top
-        farSide    = 4, // Back
-        nearSide   = 5  // Front
+/*!
+ * \brief Viewing Volume for culling use
+ */
+class ViewVolume {
+public:
+
+    /*!
+     * \brief Sides of the view volume
+     */
+    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
+    /*!
+     * \brief Planes of the view volume
+     */
+    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
-    ////////////////////////////////////////////////////////////
-
+    /*!
+     * \brief Constructs an object of ViewVolume
+     */
     ViewVolume();
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : Constructs an object of ViewVolume
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.12.15:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Deconstructs an object of ViewVolume
+     */
     ~ViewVolume();
-    /*------------------------------------------------------
-     * Pre  : ViewVolume object is allocated
-     * Post : Deconstructs an object of ViewVolume
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.12.15:
-     * Mongoose - Created
-     ------------------------------------------------------*/
-
-
-    ////////////////////////////////////////////////////////////
-    // Public Accessors
-    ////////////////////////////////////////////////////////////
 
+    /*!
+     * \brief Check if bounding volume is in view volume
+     * \param bvol bounding volume to check
+     * \returns true if frustum contains the given bounding volume
+     */
     bool isBoundingVolumeInFrustum(BoundingVolume bvol);
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : Returns true if frustum contains the given
-     *        bounding volume
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.12.15:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Check if bounding sphere is in view volume
+     * \param bvol bounding sphere to check
+     * \returns true if frustum contains the given bounding volume
+     */
     bool isBoundingSphereInFrustum(BoundingSphere bvol);
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : Returns true if frustum contains the given
-     *        bounding volume
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.12.15:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Check if bounding box is in view volume
+     * \param bvol bounding box to check
+     * \returns true if frustum contains the given bounding volume
+     */
     bool isBoundingBoxInFrustum(BoundingBox bvol);
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : Returns true if frustum contains the given
-     *        bounding volume
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.12.15:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Check if point is in view volume
+     * \param x X coordinate of point
+     * \param y Y coordinate of point
+     * \param z Z coordinate of point
+     * \returns true if point in view volume
+     */
     bool isPointInFrustum(vec_t x, vec_t y, vec_t z);
-    /*------------------------------------------------------
-     * Pre  :
-     * Post :
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.12.15:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Check if bounding sphere is in view volume
+     * \param x X coordinate of a valid abstract sphere
+     * \param y Y coordinate of a valid abstract sphere
+     * \param z Z coordinate of a valid abstract sphere
+     * \param radius radius of a valid abstract sphere
+     * \returns true if abstract sphere in view volume
+     */
     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
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Check if bounding box is in view volume
+     * \param min minimum point of valid abstract bounding box
+     * \param max maximum point of valid abstract bounding box
+     * \returns true if abstract bounding box in view volume
+     */
     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
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Distance to Bounding sphere
+     * \param x X coordinate of a valid abstract sphere
+     * \param y Y coordinate of a valid abstract sphere
+     * \param z Z coordinate of a valid abstract sphere
+     * \param radius radius of a valid abstract sphere
+     * \returns distance to abstract sphere bounding volume
+     */
     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
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Distance to Bounding box
+     * \param min minimum point of a valid abstract bounding box
+     * \param max maximum point of a valid abstract bounding box
+     * \returns distance to abstract box bounding volume
+     */
     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
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Get a copy of the view volume
+     * \param frustum where frustum will be stored
+     */
     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
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Get a copy of a given plane in view volume
+     * \param p side
+     * \param plane wher plane will be stored
+     */
     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
-    ////////////////////////////////////////////////////////////
 
+    /*!
+     * \brief Updates view volume for this frame.
+     * \param proj new projection matrix
+     * \param mdl new model matrix
+     */
     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 ------------------------------------------
+    /*!
+     * \brief Updates view volume for this frame.
      *
-     * 2002.12.15:
-     * Mongoose - Created
-     ------------------------------------------------------*/
+     * Model & Projection Matrices must be set.
+     */
+    void updateFrame();
 
+    /*!
+     * \brief Set this class' model matrix
+     * \param mdl new model matrix
+     */
     void setModel(matrix_t mdl);
-    /*------------------------------------------------------
-     * Pre  : It's valid model matrix
-     * Post : Sets this class' model matrix
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.12.15:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Set this class' projection matrix
+     * \param proj new projection matrix
+     */
     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:
 
-    ////////////////////////////////////////////////////////////
-    // Private Mutators
-    ////////////////////////////////////////////////////////////
-
-    void updateClip();
-    /*------------------------------------------------------
-     * Pre  : model and projection matrices are set
-     * Post : Computes clipping matrix
+    /*!
+     * \brief Computes clipping matrix.
      *
-     *-- History ------------------------------------------
-     *
-     * 2002.12.15:
-     * Mongoose - Created
-     ------------------------------------------------------*/
+     * Model & Projection matrices must be set!
+     */
+    void updateClip();
 
-    void updateFrustum();
-    /*------------------------------------------------------
-     * Pre  : model, projection, clip matrices are set
-     * Post : Computes planes of frustum
-     *
-     *-- History ------------------------------------------
+    /*!
+     * \brief Computes planes of frustum.
      *
-     * 2002.12.15:
-     * Mongoose - Created
-     ------------------------------------------------------*/
-
-
-    Matrix mProjection;         /* Projection matrix */
-
-    Matrix mModel;             /* Model matrix */
-
-    Matrix mClip;               /* Clipping matrix */
+     * Model, Projection & Clip matrices must be set!
+     */
+    void updateFrustum();
 
-    vec_t mFrustum[6][4];      /* View volume */
+    Matrix mProjection;   //!< Projection matrix
+    Matrix mModel;        //!< Model matrix
+    Matrix mClip;         //!< Clipping matrix
+    vec_t mFrustum[6][4]; //!< View volume
 };
 
 #endif

include/World.h

@@ -13,10 +13,6 @@
  *           This file was generated using Mongoose's C++
  *           template generator script.  <stu7440@westga.edu>
  *
- *-- Test Defines -----------------------------------------------
- *
- * UNIT_TEST_WORLD - Builds World class as a console unit test
- *
  *-- History ------------------------------------------------
  *
  * 2002.12.16:

src/Network.cpp

@@ -440,7 +440,7 @@ int Network::runServer()
 
         fflush(stdout);
 
-#ifdef UNIT_TEST_NETWORK
+#ifdef UNIT_TEST
         if ((rand() % 10 == 0))
         {
             printf("Server: Simulating a lost ack %u\n", f.seq);

src/Quaternion.cpp

@@ -1,71 +1,39 @@
-/* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
-/*================================================================
+/*!
+ * \file src/Quaternion.cpp
+ * \brief Quaternion
  *
- * Project : Hel
- * Author  : Terry 'Mongoose' Hendrix II
- * Website : http://www.westga.edu/~stu7440/
- * Email   : stu7440@westga.edu
- * Object  : Quaternion
- * License : No use w/o permission (C) 2002 Mongoose
- * Comments: Quaternion now in C++ class form fresh from the grove
- *
- *
- *           This file was generated using Mongoose's C++
- *           template generator script.  <stu7440@westga.edu>
- *
- *-- History -------------------------------------------------
- *
- * 2002.12.16:
- * Mongoose - Created, based on mtk3d ( freyja )
- =================================================================*/
+ * \author Mongoose
+ */
 
 #include <math.h>
 
 #include <Quaternion.h>
 
-
-////////////////////////////////////////////////////////////
-// Constructors
-////////////////////////////////////////////////////////////
-
-Quaternion::Quaternion()
-{
+Quaternion::Quaternion() {
     mW = 0;
     mX = 0;
     mY = 0;
     mZ = 0;
 }
 
-
-Quaternion::Quaternion(vec_t w, vec_t x, vec_t y, vec_t z)
-{
+Quaternion::Quaternion(vec_t w, vec_t x, vec_t y, vec_t z) {
     mW = w;
     mX = x;
     mY = y;
     mZ = z;
 }
 
-
-Quaternion::Quaternion(vec4_t v)
-{
+Quaternion::Quaternion(vec4_t v) {
     mW = v[0];
     mX = v[1];
     mY = v[2];
     mZ = v[3];
 }
 
-
-Quaternion::~Quaternion()
-{
+Quaternion::~Quaternion() {
 }
 
-
-////////////////////////////////////////////////////////////
-// Public Accessors
-////////////////////////////////////////////////////////////
-
-void Quaternion::getMatrix(matrix_t m)
-{
+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);
@@ -87,9 +55,7 @@ void Quaternion::getMatrix(matrix_t m)
     m[15] = 1.0f;
 }
 
-
-Quaternion &Quaternion::operator =(const Quaternion &q)
-{
+Quaternion &Quaternion::operator =(const Quaternion &q) {
     mW  = q.mW;
     mX = q.mX;
     mY = q.mY;
@@ -97,91 +63,62 @@ Quaternion &Quaternion::operator =(const Quaternion &q)
     return *this;
 }
 
-
-Quaternion Quaternion::operator *(const Quaternion &q)
-{
+Quaternion Quaternion::operator *(const Quaternion &q) {
     return multiply(*this, q);
 }
 
-
-Quaternion Quaternion::operator /(const Quaternion &q)
-{
+Quaternion Quaternion::operator /(const Quaternion &q) {
     return divide(*this, q);
 }
 
-
-Quaternion Quaternion::operator +(const Quaternion &q)
-{
+Quaternion Quaternion::operator +(const Quaternion &q) {
     return add(*this, q);
 }
 
-
-Quaternion Quaternion::operator -(const Quaternion &q)
-{
+Quaternion Quaternion::operator -(const Quaternion &q) {
     return subtract(*this, q);
 }
 
-
-bool Quaternion::operator ==(const Quaternion &q)
-{
+bool Quaternion::operator ==(const Quaternion &q) {
     //return (mX == q.mX && mY == q.mY && mZ == q.mZ && mW == q.mW);
     return (equalEpsilon(mX, q.mX) && equalEpsilon(mY, q.mY) &&
             equalEpsilon(mZ, q.mZ) && equalEpsilon(mW, q.mW));
 }
 
-
-Quaternion Quaternion::conjugate()
-{
+Quaternion Quaternion::conjugate() {
     return Quaternion(mW, -mX, -mY, -mZ);
 }
 
-
-Quaternion Quaternion::scale(vec_t s)
-{
+Quaternion Quaternion::scale(vec_t s) {
     return Quaternion(mW * s, mX * s, mY * s, mZ * s);
 }
 
-
-Quaternion Quaternion::inverse()
-{
+Quaternion Quaternion::inverse() {
     return conjugate().scale(1/magnitude());
 }
 
-
-vec_t Quaternion::dot(Quaternion a, Quaternion b)
-{
+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));
 }
 
-
-vec_t Quaternion::magnitude()
-{
+vec_t Quaternion::magnitude() {
     return sqrtf(dot(*this, *this));
 }
 
-
-////////////////////////////////////////////////////////////
-// Public Mutators
-////////////////////////////////////////////////////////////
-
-void Quaternion::setIdentity()
-{
+void Quaternion::setIdentity() {
     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)
-{
+void Quaternion::set(vec_t angle, vec_t x, vec_t y, vec_t z) {
     vec_t temp, dist;
 
-
     // Normalize
     temp = x*x + y*y + z*z;
 
-    dist = (float)(1.0 / sqrt(temp));
+    dist = 1.0f / sqrtf(temp);
 
     x *= dist;
     y *= dist;
@@ -191,23 +128,17 @@ void Quaternion::set(vec_t angle, vec_t x, vec_t y, vec_t z)
     mY = y;
     mZ = z;
 
-    mW = (float)cos(angle / 2.0f);
+    mW = cosf(angle / 2.0f);
 }
 
-
-void Quaternion::normalize()
-{
+void Quaternion::normalize() {
     vec_t dist, square;
 
-
     square = mX * mX + mY * mY + mZ * mZ + mW * mW;
 
-    if (square > 0.0)
-    {
-        dist = (float)(1.0 / sqrt(square));
-    }
-    else
-    {
+    if (square > 0.0) {
+        dist = 1.0f / sqrtf(square);
+    } else {
         dist = 1;
     }
 
@@ -217,18 +148,14 @@ void Quaternion::normalize()
     mW *= dist;
 }
 
-
-void Quaternion::copy(Quaternion q)
-{
+void Quaternion::copy(Quaternion q) {
     mW = q.mW;
     mX = q.mX;
     mY = q.mY;
     mZ = q.mZ;
 }
 
-
-Quaternion Quaternion::slerp(Quaternion a, Quaternion b, vec_t time)
-{
+Quaternion Quaternion::slerp(Quaternion a, Quaternion b, vec_t time) {
     /*******************************************************************
      * Spherical Linear Interpolation algorthim
      *-----------------------------------------------------------------
@@ -250,16 +177,13 @@ Quaternion Quaternion::slerp(Quaternion a, Quaternion b, vec_t time)
 
     // 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)
-    {
+    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;
@@ -280,8 +204,7 @@ Quaternion Quaternion::slerp(Quaternion a, Quaternion b, vec_t time)
 
     // Check if the angle between the 2 quaternions was big enough
     // to warrant such calculations
-    if (1 - result > 0.1f)
-    {
+    if (1 - result > 0.1f) {
         // Get the angle between the 2 quaternions, and then
         // store the sin() of that angle
         theta = (float)acos(result);
@@ -298,16 +221,12 @@ Quaternion Quaternion::slerp(Quaternion a, Quaternion b, vec_t time)
     return (a.scale(scaleA) + b.scale(scaleB));
 }
 
-
-void Quaternion::setByMatrix(matrix_t matrix)
-{
+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)
-    {
+    if (diagonal > 0.00000001) {
         // Calculate the scale of the diagonal
         scale = (float)(sqrt(diagonal) * 2);
 
@@ -315,12 +234,9 @@ void Quaternion::setByMatrix(matrix_t matrix)
         x = (matrix[9] - matrix[6]) / scale;
         y = (matrix[2] - matrix[8]) / scale;
         z = (matrix[4] - matrix[1]) / scale;
-    }
-    else
-    {
+    } else {
         // If the first element of the diagonal is the greatest value
-        if (matrix[0] > matrix[5] && matrix[0] > matrix[10])
-        {
+        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;
 
@@ -329,10 +245,8 @@ void Quaternion::setByMatrix(matrix_t matrix)
             x = 0.25f * scale;
             y = (matrix[4] + matrix[1]) / scale;
             z = (matrix[2] + matrix[8]) / scale;
-        }
-        // The second element of the diagonal is the greatest value
-        else if (matrix[5] > matrix[10])
-        {
+        } else if (matrix[5] > matrix[10]) {
+            // The second element of the diagonal is the greatest value
             // Find the scale according to the second element, and double it
             scale = (float)sqrt(1.0f + matrix[5] - matrix[0] - matrix[10])*2.0f;
 
@@ -341,10 +255,7 @@ void Quaternion::setByMatrix(matrix_t matrix)
             x = (matrix[4] + matrix[1]) / scale;
             y = 0.25f * scale;
             z = (matrix[9] + matrix[6]) / scale;
-        }
-        // The third element of the diagonal is the greatest value
-        else
-        {
+        } else { // The third element of the diagonal is the greatest value
             // Find the scale according to the third element, and double it
             scale = (float)sqrt(1.0f + matrix[10] - matrix[0] - matrix[5])*2.0f;
 
@@ -362,45 +273,28 @@ void Quaternion::setByMatrix(matrix_t matrix)
     mZ = z;
 }
 
-
-////////////////////////////////////////////////////////////
-// Private Accessors
-////////////////////////////////////////////////////////////
-
-Quaternion Quaternion::multiply(Quaternion a, Quaternion b)
-{
+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);
 }
 
-
-Quaternion Quaternion::divide(Quaternion a, Quaternion b)
-{
+Quaternion Quaternion::divide(Quaternion a, Quaternion b) {
     return (a * (b.inverse()));
 }
 
-
-Quaternion Quaternion::add(Quaternion a, Quaternion b)
-{
+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);
 }
 
-
-Quaternion Quaternion::subtract(Quaternion a, Quaternion b)
-{
+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);
 }
 
-
-////////////////////////////////////////////////////////////
-// Private Mutators
-////////////////////////////////////////////////////////////
-

src/SDLSystem.cpp

@@ -1,31 +1,9 @@
-/* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
-/*================================================================
+/*!
+ * \file src/SDLSystem.cpp
+ * \brief SDL System interface implementation
  *
- * Project : OpenRaider
- * Author  : Terry 'Mongoose' Hendrix II
- * Website : http://www.westga.edu/~stu7440/
- * Email   : stu7440@westga.edu
- * Object  : SDL
- * License : No use w/o permission (C) 2002 Mongoose
- * Comments:
- *
- *
- *           This file was generated using Mongoose's C++
- *           template generator script.  <stu7440@westga.edu>
- *
- *-- History -------------------------------------------------
- *
- * 2003.06.30,
- * Mongoose - SDL_TTF support moved to Texture class
- *
- * 2003.06.03:
- * Mongoose - SDL_TTF support based on Sam Lantinga's public domain
- *            SDL_TTF demo functions and algorithms
- *
- * 2002.06.06:
- * Mongoose - Created
- =================================================================*/
-
+ * \author Mongoose
+ */
 
 #include <stdlib.h>
 #include <stdio.h>
@@ -40,17 +18,10 @@
 
 #include <SDLSystem.h>
 
-
 unsigned int *gWidth = 0x0;
 unsigned int *gHeight = 0x0;
 
-
-////////////////////////////////////////////////////////////
-// Constructors
-////////////////////////////////////////////////////////////
-
-SDLSystem::SDLSystem() : System()
-{
+SDLSystem::SDLSystem() : System() {
     mWindow = 0x0;
     gWidth = &m_width;
     gHeight = &m_height;
@@ -58,31 +29,16 @@ SDLSystem::SDLSystem() : System()
     mFullscreen = false;
 }
 
-
-SDLSystem::~SDLSystem()
-{
+SDLSystem::~SDLSystem() {
 }
 
-
-////////////////////////////////////////////////////////////
-// Public Accessors
-////////////////////////////////////////////////////////////
-
-unsigned int SDLSystem::getTicks()
-{
+unsigned int SDLSystem::getTicks() {
     return SDL_GetTicks();
 }
 
-
-////////////////////////////////////////////////////////////
-// Public Mutators
-////////////////////////////////////////////////////////////
-
 #ifdef FIXME
-void SDLSystem::bindKeyCommand(const char *cmd, int key, int event)
-{
-    if (key > 255)
-    {
+void SDLSystem::bindKeyCommand(const char *cmd, int key, int event) {
+    if (key > 255) {
         printf("Currently key event mapping only handles ASCII characters\n");
         return;
     }
@@ -93,19 +49,13 @@ void SDLSystem::bindKeyCommand(const char *cmd, int key, int event)
 }
 #endif
 
-
-void SDLSystem::setGrabMouse(bool on)
-{
+void SDLSystem::setGrabMouse(bool on) {
     SDL_WM_GrabInput(on ? SDL_GRAB_ON : SDL_GRAB_OFF);
 }
 
-
-void SDLSystem::initVideo(unsigned int width, unsigned int height,
-        bool fullscreen)
-{
+void SDLSystem::initVideo(unsigned int width, unsigned int height, bool fullscreen) {
     int flags = 0; //, x, y;
 
-
     // Create GL context
     SDL_Init(SDL_INIT_VIDEO);
     printf("Created OpenGL Context\n");
@@ -115,18 +65,15 @@ void SDLSystem::initVideo(unsigned int width, unsigned int height,
     m_height = height;
 
 #ifndef __APPLE__
-    if (!m_driver || !m_driver[0] || SDL_GL_LoadLibrary(m_driver) < 0)
-    {
+    if (!m_driver || !m_driver[0] || SDL_GL_LoadLibrary(m_driver) < 0) {
         SDL_ClearError();
 
         // Fallback 1
-        if (SDL_GL_LoadLibrary("libGL.so") < 0)
-        {
+        if (SDL_GL_LoadLibrary("libGL.so") < 0) {
             SDL_ClearError();
 
             // Fallback 2
-            if (SDL_GL_LoadLibrary("libGL.so.1") < 0)
-            {
+            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);
@@ -166,14 +113,11 @@ void SDLSystem::initVideo(unsigned int width, unsigned int height,
     resizeGL(width, height);
 }
 
-
-void SDLSystem::resize(unsigned int width, unsigned int height)
-{
+void SDLSystem::resize(unsigned int width, unsigned int height) {
     int flags = 0;
 
     GLfloat aspect;
 
-
     m_width = width;
     m_height = height;
 
@@ -206,24 +150,18 @@ void SDLSystem::resize(unsigned int width, unsigned int height)
     resizeGL(width, height);
 }
 
-
-void SDLSystem::runGame()
-{
+void SDLSystem::runGame() {
     SDL_Event event;
     unsigned int mkeys, mod, key;
     int btn = 0;
     bool specialKey;
 
-
-    for (;;)
-    {
+    for (;;) {
         // Pause for 10-20 ms
         SDL_Delay(10);
 
-        while (SDL_PollEvent(&event))
-        {
-            switch (event.type)
-            {
+        while (SDL_PollEvent(&event)) {
+            switch (event.type) {
                 case SDL_QUIT:
                     shutdown(0);
                     break;
@@ -240,8 +178,7 @@ void SDLSystem::runGame()
                     //handleMouseEvent(event.button.button, event.button.state,
                     //                    event.button.x, event.button.y);
 
-                    switch (event.button.button)
-                    {
+                    switch (event.button.button) {
                         case SDL_BUTTON_LEFT:
                             btn = SYS_MOUSE_LEFT;
                             break;
@@ -253,12 +190,9 @@ void SDLSystem::runGame()
                             break;
                     }
 
-                    if (event.button.state == SDL_PRESSED)
-                    {
+                    if (event.button.state == SDL_PRESSED) {
                         handleKeyPressEvent(btn, 0); //! \fixme mod not used
-                    }
-                    else
-                    {
+                    } else {
                         handleKeyReleaseEvent(btn, 0); //! \fixme mod not used
                     }
                     break;
@@ -296,8 +230,7 @@ void SDLSystem::runGame()
                     key = event.key.keysym.sym;
                     specialKey = false;
 
-                    switch (key)
-                    {
+                    switch (key) {
                         case SDLK_F1:
                             key = SYS_KEY_F1;
                             specialKey = true;
@@ -383,14 +316,10 @@ void SDLSystem::runGame()
 
 #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
-                        {
+                    if (!specialKey && key != 0) {
+                        if ((event.key.keysym.unicode & 0xFF80) == 0) {
+                            key = (unsigned int)(event.key.keysym.unicode & 0x7F);
+                        } else {
                             key = 0;
                         }
                     }
@@ -399,50 +328,38 @@ void SDLSystem::runGame()
                      * consoles using this expect text characters, add unicode
                      * support later when they're able to handle it
                      */
-                    if (key > 255 && key < 1000)
-                    {
+                    if (key > 255 && key < 1000) {
                         key = 0;
                     }
 #endif
 
-                    if (key == mConsoleKey)
-                    {
-                        if (event.type == SDL_KEYDOWN)
-                        {
+                    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)
-                        {
+                    } 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
-                    {
+                    } else if (mKeyEvents[key] != 0) { // Bound key
                         //if (key < 255 && mKeyEvents[key] != 0)
                         key = mKeyEvents[key];
 
-                        switch (event.type)
-                        {
+                        switch (event.type) {
                             case SDL_KEYDOWN:
                                 handleBoundKeyPressEvent(key);
                                 break;
                             default:
                                 handleBoundKeyReleaseEvent(key);
                         }
-                    }
-                    else // 'Classic' key event handlers
-                    {
-                        switch (event.type)
-                        {
+                    } else { // 'Classic' key event handlers
+                        switch (event.type) {
                             case SDL_KEYDOWN:
                                 handleKeyPressEvent(key, mod);
                                 break;
@@ -463,9 +380,7 @@ void SDLSystem::runGame()
     }
 }
 
-
-void SDLSystem::shutdown(int i)
-{
+void SDLSystem::shutdown(int i) {
     //SDL_QuitSubSystem(SDL_OPENGL);
     //SDL_Quit(); // Moved to atexit() call
 
@@ -477,11 +392,8 @@ void SDLSystem::shutdown(int i)
     exit(i);
 }
 
-
-void SDLSystem::toggleFullscreen()
-{
-    if (mWindow)
-    {
+void SDLSystem::toggleFullscreen() {
+    if (mWindow) {
         mFullscreen = !mFullscreen;
         SDL_ShowCursor(SDL_DISABLE);
 
@@ -521,9 +433,7 @@ void SDLSystem::toggleFullscreen()
     }
 }
 
-
-void SDLSystem::swapBuffersGL()
-{
+void SDLSystem::swapBuffersGL() {
     SDL_GL_SwapBuffers();
 }
 

src/Vector3d.cpp

@@ -1,86 +1,48 @@
-/* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
-/*================================================================
+/*!
+ * \file src/Vector3d.cpp
+ * \brief 3D Math vector
  *
- * Project : Hel
- * Author  : Terry 'Mongoose' Hendrix II
- * Website : http://www.westga.edu/~stu7440/
- * Email   : stu7440@westga.edu
- * Object  : Vector3d
- * License : No use w/o permission (C) 2002 Mongoose
- * Comments: Math vector
- *
- *
- *           This file was generated using Mongoose's C++
- *           template generator script.  <stu7440@westga.edu>
- *
- *-- History -------------------------------------------------
- *
- * 2002.12.24:
- * Mongoose - Created
- =================================================================*/
+ * \author Mongoose
+ */
 
 #include <math.h>
 
 #include <Vector3d.h>
 
-
-////////////////////////////////////////////////////////////
-// Constructors
-////////////////////////////////////////////////////////////
-
-Vector3d::Vector3d()
-{
+Vector3d::Vector3d() {
     mVec[0] = mVec[1] = mVec[2] = 0.0f;
 }
 
-
-Vector3d::Vector3d(vec3_t v)
-{
+Vector3d::Vector3d(vec3_t v) {
     mVec[0] = v[0];
     mVec[1] = v[1];
     mVec[2] = v[2];
 }
 
-
-Vector3d::Vector3d(vec_t x, vec_t y, vec_t z)
-{
+Vector3d::Vector3d(vec_t x, vec_t y, vec_t z) {
     mVec[0] = x;
     mVec[1] = y;
     mVec[2] = z;
 }
 
-
-Vector3d::~Vector3d()
-{
+Vector3d::~Vector3d() {
 }
 
-
-////////////////////////////////////////////////////////////
-// Public Accessors
-////////////////////////////////////////////////////////////
-
-vec_t Vector3d::dot(const Vector3d &u, const Vector3d &v)
-{
+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]);
 }
 
-
-Vector3d Vector3d::cross(const Vector3d &u, const Vector3d &v)
-{
+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]);
 }
 
-
-vec_t Vector3d::magnitude()
-{
+vec_t Vector3d::magnitude() {
     return sqrtf(mVec[0]*mVec[0] + mVec[1]*mVec[1] + mVec[2]*mVec[2]);
 }
 
-
-Vector3d Vector3d::unit()
-{
+Vector3d Vector3d::unit() {
     vec_t norm = magnitude();
 
     return Vector3d(mVec[0] / norm,
@@ -88,73 +50,45 @@ Vector3d Vector3d::unit()
             mVec[2] / norm);
 }
 
-
-Vector3d Vector3d::zeroVector()
-{
+Vector3d Vector3d::zeroVector() {
     return Vector3d(0, 0, 0);
 }
 
-
-Vector3d Vector3d::operator +(const Vector3d &v)
-{
+Vector3d Vector3d::operator +(const Vector3d &v) {
     return Vector3d(mVec[0] + v.mVec[0],
             mVec[1] + v.mVec[1],
             mVec[2] + v.mVec[2]);
 }
 
-
-Vector3d Vector3d::operator -(const Vector3d &v)
-{
+Vector3d Vector3d::operator -(const Vector3d &v) {
     return Vector3d(mVec[0] - v.mVec[0],
             mVec[1] - v.mVec[1],
             mVec[2] - v.mVec[2]);
 }
 
-
-Vector3d Vector3d::operator -()
-{
+Vector3d Vector3d::operator -() {
     return Vector3d(-mVec[0],
             -mVec[1],
             -mVec[2]);
 }
 
-
-Vector3d Vector3d::operator *(vec_t s)
-{
+Vector3d Vector3d::operator *(vec_t s) {
     return Vector3d(s * mVec[0],
             s * mVec[1],
             s * mVec[2]);
 }
 
-
-Vector3d Vector3d::operator /(vec_t s)
-{
+Vector3d Vector3d::operator /(vec_t s) {
     return Vector3d(mVec[0] / s,
             mVec[1] / s,
             mVec[2] / s);
 }
 
-
-vec_t Vector3d::operator *(const Vector3d &v)
-{
+vec_t Vector3d::operator *(const Vector3d &v) {
     return dot(*this, v);
 }
 
-
-//Vector3d Vector3d::operator *(const Matrix &m)
-//{
-//  vec3_t v;
-//
-//  return
-//}
-
-
-////////////////////////////////////////////////////////////
-// Public Mutators
-////////////////////////////////////////////////////////////
-
-void Vector3d::normalize()
-{
+void Vector3d::normalize() {
     vec_t norm = magnitude();
 
     mVec[0] /= norm;
@@ -162,57 +96,37 @@ void Vector3d::normalize()
     mVec[2] /= norm;
 }
 
-
-void Vector3d::zero()
-{
+void Vector3d::zero() {
     mVec[0] = 0;
     mVec[1] = 0;
     mVec[2] = 0;
 }
 
-
-Vector3d &Vector3d::operator =(const Vector3d &v)
-{
+Vector3d &Vector3d::operator =(const Vector3d &v) {
     mVec[0] = v.mVec[0];
     mVec[1] = v.mVec[1];
     mVec[2] = v.mVec[2];
     return *this;
 }
 
-
-Vector3d &Vector3d::operator +=(const Vector3d &v)
-{
+Vector3d &Vector3d::operator +=(const Vector3d &v) {
     mVec[0] += v.mVec[0];
     mVec[1] += v.mVec[1];
     mVec[2] += v.mVec[2];
     return *this;
 }
 
-
-Vector3d &Vector3d::operator -=(const Vector3d &v)
-{
+Vector3d &Vector3d::operator -=(const Vector3d &v) {
     mVec[0] -= v.mVec[0];
     mVec[1] -= v.mVec[1];
     mVec[2] -= v.mVec[2];
     return *this;
 }
 
-
-Vector3d &Vector3d::operator *=(vec_t s)
-{
+Vector3d &Vector3d::operator *=(vec_t s) {
     mVec[0] *= s;
     mVec[1] *= s;
     mVec[2] *= s;
     return *this;
 }
 
-
-////////////////////////////////////////////////////////////
-// Private Accessors
-////////////////////////////////////////////////////////////
-
-
-////////////////////////////////////////////////////////////
-// Private Mutators
-////////////////////////////////////////////////////////////
-

src/ViewVolume.cpp

@@ -1,37 +1,17 @@
-/* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
-/*================================================================
+/*!
+ * \file include/ViewVolume.h
+ * \brief Viewing Volume for culling use
  *
- * Project : hel
- * Author  : Terry 'Mongoose' Hendrix II
- * Website : http://www.westga.edu/~stu7440/
- * Email   : stu7440@westga.edu
- * Object  : ViewVolume
- * License : No use w/o permission (C) 2002 Mongoose
- * Comments: This is the viewing volume for culling use
+ * Thanks Mark Morley for the article I used to get several algorithms.
  *
- *           Thanks Mark Morley for the article I used
- *           to get several algorithms.
- *
- *           This file was generated using Mongoose's C++
- *           template generator script.  <stu7440@westga.edu>
- *
- *-- History -------------------------------------------------
- *
- * 2002.12.15:
- * Mongoose - Created
- =================================================================*/
+ * \author Mongoose
+ */
 
 #include <math.h>
 
 #include <ViewVolume.h>
 
-
-////////////////////////////////////////////////////////////
-// Constructors
-////////////////////////////////////////////////////////////
-
-ViewVolume::ViewVolume()
-{
+ViewVolume::ViewVolume() {
     mFrustum[0][0] = mFrustum[0][1] = mFrustum[0][2] = mFrustum[0][3] = 0.0f;
     mFrustum[1][0] = mFrustum[1][1] = mFrustum[1][2] = mFrustum[1][3] = 0.0f;
     mFrustum[2][0] = mFrustum[2][1] = mFrustum[2][2] = mFrustum[2][3] = 0.0f;
@@ -40,80 +20,47 @@ ViewVolume::ViewVolume()
     mFrustum[5][0] = mFrustum[5][1] = mFrustum[5][2] = mFrustum[5][3] = 0.0f;
 }
 
-
-ViewVolume::~ViewVolume()
-{
+ViewVolume::~ViewVolume() {
 }
 
-
-////////////////////////////////////////////////////////////
-// Public Accessors
-////////////////////////////////////////////////////////////
-
-bool ViewVolume::isBoundingVolumeInFrustum(BoundingVolume bvol)
-{
+bool ViewVolume::isBoundingVolumeInFrustum(BoundingVolume bvol) {
     return (isBoundingSphereInFrustum(bvol.mSphere) &&
             isBoundingBoxInFrustum(bvol.mBox));
 }
 
-
-bool ViewVolume::isBoundingSphereInFrustum(BoundingSphere bvol)
-{
+bool ViewVolume::isBoundingSphereInFrustum(BoundingSphere bvol) {
     return (isSphereInFrustum(bvol.mCenter[0],
                 bvol.mCenter[1],
                 bvol.mCenter[2],
                 bvol.mRadius));
 }
 
-
-bool ViewVolume::isBoundingBoxInFrustum(BoundingBox bvol)
-{
+bool ViewVolume::isBoundingBoxInFrustum(BoundingBox bvol) {
     return (isBboxInFrustum(bvol.mMin, bvol.mMax));
 }
 
-
-bool ViewVolume::isPointInFrustum(vec_t x, vec_t y, vec_t z)
-{
-    unsigned int p;
-
-
-    for (p = 0; p < 6; ++p)
-    {
+bool ViewVolume::isPointInFrustum(vec_t x, vec_t y, vec_t z) {
+    for (unsigned int p = 0; p < 6; ++p) {
         if (mFrustum[p][0] * x + mFrustum[p][1] * y + mFrustum[p][2] * z +
-                mFrustum[p][3] <= 0)
-        {
+                mFrustum[p][3] <= 0) {
             return false;
         }
     }
-
     return true;
 }
 
-
-bool ViewVolume::isSphereInFrustum(vec_t x, vec_t y, vec_t z, vec_t radius)
-{
-    unsigned int p;
+bool ViewVolume::isSphereInFrustum(vec_t x, vec_t y, vec_t z, vec_t radius) {
     vec_t d;
-
-
-    for (p = 0; p < 6; ++p)
-    {
+    for (unsigned int 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;
 }
 
-
-bool ViewVolume::isBboxInFrustum(vec3_t min, vec3_t max)
-{
-    unsigned int p;
-
-
-    for (p = 0; p < 6; ++p)
-    {
+bool ViewVolume::isBboxInFrustum(vec3_t min, vec3_t max) {
+    for (unsigned int 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)
@@ -156,34 +103,23 @@ bool ViewVolume::isBboxInFrustum(vec3_t min, vec3_t max)
 
         return false;
     }
-
     return true;
 }
 
-
-vec_t ViewVolume::getDistToSphereFromNear(vec_t x, vec_t y, vec_t z,
-        vec_t radius)
-{
-    unsigned int p;
+vec_t ViewVolume::getDistToSphereFromNear(vec_t x, vec_t y, vec_t z, vec_t radius) {
     vec_t d = 0.0;
-
-    for (p = 0; p < 6; ++p)
-    {
+    for (unsigned int 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;
 }
 
-
-vec_t ViewVolume::getDistToBboxFromNear(vec3_t min, vec3_t max)
-{
+vec_t ViewVolume::getDistToBboxFromNear(vec3_t min, vec3_t max) {
     vec3_t center;
     vec_t d, radius;
 
-
     helMidpoint3v(min, max, center);
 
     // 5 should be near plane
@@ -200,99 +136,48 @@ vec_t ViewVolume::getDistToBboxFromNear(vec3_t min, vec3_t max)
     return d + radius;
 }
 
-
-void ViewVolume::getFrustum(vec_t frustum[6][4])
-{
-    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];
+void ViewVolume::getFrustum(vec_t frustum[6][4]) {
+    for (unsigned int p = 0; p < 6; ++p) {
+        for (unsigned int i = 0; i < 4; ++i) {
+            frustum[p][i] = mFrustum[p][i];
+        }
     }
 }
 
-
-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];
+void ViewVolume::getPlane(ViewVolumeSide p, vec4_t plane) {
+    for (unsigned int i = 0; i < 4; ++i) {
+        plane[i] =  mFrustum[p][i];
+    }
 }
 
-
-////////////////////////////////////////////////////////////
-// Public Mutators
-////////////////////////////////////////////////////////////
-
-void ViewVolume::updateFrame(matrix_t proj, matrix_t mdl)
-{
+void ViewVolume::updateFrame(matrix_t proj, matrix_t mdl) {
     setModel(mdl);
     setProjection(proj);
     updateClip();
     updateFrustum();
 }
 
-
-void ViewVolume::updateFrame()
-{
+void ViewVolume::updateFrame() {
     updateClip();
     updateFrustum();
 }
 
-
-void ViewVolume::setModel(matrix_t mdl)
-{
+void ViewVolume::setModel(matrix_t 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
-     */
-
+void ViewVolume::setProjection(matrix_t proj) {
     mProjection.setMatrix(proj);
 }
 
-
-
-////////////////////////////////////////////////////////////
-// Private Accessors
-////////////////////////////////////////////////////////////
-
-
-////////////////////////////////////////////////////////////
-// Private Mutators
-////////////////////////////////////////////////////////////
-
-void ViewVolume::updateClip()
-{
-    //mClip = mModel * mProjection;
+void ViewVolume::updateClip() {
     mClip = mProjection * mModel;
 }
 
-
-void ViewVolume::updateFrustum()
-{
+void ViewVolume::updateFrustum() {
     matrix_t clip;
     vec_t t;
 
-
     mClip.getMatrix(clip);
 
     /* Extract the numbers for the RIGHT plane */