Renamed OpenGLMesh to Mesh.

Documented OpenRaider, removed unused stuff.

ChangeLog

 
  OpenRaider (0.1.2) xythobuz <xythobuz@xythobuz.de>
 
+	[ 20140209 ]
+	* Renamed OpenGLMesh to Mesh
+	* Removed unused flags, enums, ...
+
 	[ 20140202 ]
 	* Fixed more cppcheck warnings
 	* Removed unnecessary defines (USING_xxx)

Makefile

 	$(BUILDDIR)/GLString.o \
 	$(BUILDDIR)/MatMath.o \
 	$(BUILDDIR)/Matrix.o \
+	$(BUILDDIR)/Mesh.o \
 	$(BUILDDIR)/Network.o \
-	$(BUILDDIR)/OpenGLMesh.o \
 	$(BUILDDIR)/OpenRaider.o \
 	$(BUILDDIR)/Particle.o \
 	$(BUILDDIR)/Quaternion.o \

include/Matrix.h

      * \param b second matrix
      * \returns resultant matrix
      */
-    Matrix multiply(const Matrix &a, const Matrix &b);
+    static Matrix multiply(const Matrix &a, const Matrix &b);
 
     /*!
      * \brief Multiplies v vector and this matrix
      * \param source source
      * \param dest destination
      */
-    void copy(matrix_t source, matrix_t dest);
+    static void copy(matrix_t source, matrix_t dest);
 
     /*!
      * \brief Multiplies matrices a and b. Neither a or b is also the result.
      * \param b second matrix
      * \param result wil be set to resultant matrix value
      */
-    void multiply(const matrix_t a, const matrix_t b, matrix_t result);
+    static void multiply(const matrix_t a, const matrix_t b, matrix_t result);
 };
 
 #endif

include/OpenGLMesh.h → include/Mesh.h

 /*!
- * \file include/OpenGLMesh.h
+ * \file include/Mesh.h
  * \brief OpenGL Mesh
  *
  * \author Mongoose
 /*!
  * \brief OpenGL Mesh
  */
-class OpenGLMesh {
+class Mesh {
 public:
 
     typedef enum {
-        OpenGLMeshModeSolid          = 0,
-        OpenGLMeshModeWireframe      = 1,
-        OpenGLMeshModeTexture        = 2,
-        OpenGLMeshModeMultiTexture   = 3
-    } OpenGLMeshMode;
+        MeshModeSolid,
+        MeshModeWireframe,
+        MeshModeTexture,
+        MeshModeMultiTexture
+    } MeshMode;
 
     typedef enum {
-        fOpenGLMesh_Transparent      = 1,
-        fOpenGLMesh_BumpMap          = 2,
-        fOpenGLMesh_UseVertexArray   = 4
-    } OpenGLMeshFlags;
+        fMesh_UseVertexArray = (1 << 0)
+    } MeshFlags;
 
     typedef struct tris_s {
         int texture;
     } rect_t;
 
     /*!
-     * \brief Constructs an object of OpenGLMesh
+     * \brief Constructs an object of Mesh
      */
-    OpenGLMesh();
+    Mesh();
 
     /*!
-     * \brief Deconstructs an object of OpenGLMesh
+     * \brief Deconstructs an object of Mesh
      */
-    ~OpenGLMesh();
+    ~Mesh();
 
     void drawAlpha();
 
 
     unsigned int mFlags;
 
-    OpenGLMeshMode mMode;
+    MeshMode mMode;
 
     unsigned int mNumVertices;
     vec3_t *mVertices; //!< XYZ

include/OpenRaider.h

-/* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
-/*================================================================
+/*!
+ * \file include/OpenRaider.h
+ * \brief Main Game Singleton
  *
- * Project : OpenRaider
- * Author  : Mongoose
- * Website : http://www.westga.edu/~stu7440/
- * Email   : stu7440@westga.edu
- * Object  : OpenRaider
- * License : No use w/o permission (C) 2001 Mongoose
- * Comments: This is the main class for OpenRaider
- *
- *
- *           This file was generated using Mongoose's C++
- *           template generator script.  <stu7440@westga.edu>
- *
- *-- History ------------------------------------------------
- *
- * 2002.08.24:
- * Mongoose - Finally made into Singleton
- *
- * 2001.05.21:
- * Mongoose - Created
- ================================================================*/
-
+ * \author Mongoose
+ */
 
 #ifndef _OPENRAIDER_H_
 #define _OPENRAIDER_H_
 
-
 #include <List.h>
 #include <Map.h>
 #include <Vector.h>
 #include <Network.h>
 #include <World.h>
 
-
-typedef enum
-{
-    OpenRaiderKey_console = 1, // Reserved 0 event for console in System
-    OpenRaiderKey_attack,
-    OpenRaiderKey_forward,
-    OpenRaiderKey_left,
-    OpenRaiderKey_right,
-    OpenRaiderKey_backward,
-    OpenRaiderKey_jump,
-    OpenRaiderKey_tiltUp,
-    OpenRaiderKey_tiltDown,
-    OpenRaiderKey_panLeft,
-    OpenRaiderKey_panRight,
-    OpenRaiderKey_crouch
-
+/*!
+ * \brief OpenRaider key events.
+ *
+ * 0 event reserved for console in System.
+ */
+typedef enum {
+    OpenRaiderKey_console = 1, //!< Toggle console
+    OpenRaiderKey_attack,      //!< Attack
+    OpenRaiderKey_forward,     //!< Move forward
+    OpenRaiderKey_left,        //!< Move left
+    OpenRaiderKey_right,       //!< Move right
+    OpenRaiderKey_backward,    //!< Move backward
+    OpenRaiderKey_jump,        //!< Jump
+    OpenRaiderKey_tiltUp,      //!< Tilt camera up
+    OpenRaiderKey_tiltDown,    //!< Tilt camera down
+    OpenRaiderKey_panLeft,     //!< Pan camera left
+    OpenRaiderKey_panRight,    //!< Pan camera right
+    OpenRaiderKey_crouch       //!< Crouch
 } OpenRaider_KeyEvent;
 
-
-typedef enum
-{
-    OpenRaider_ShowFPS      =   1,
-    OpenRaider_DebugMap     =   2,
-    OpenRaider_DebugModel   =   4,
-    OpenRaider_EnableSound  =   8,
-    OpenRaider_DumpTexture  =  16,
-    OpenRaider_FullScreen   =  32,
-    OpenRaider_Loading      =  64,
-    OpenRaider_GameRunning  = 128
-
-} OpenRaiderFlags;
-
-typedef enum
-{
-    OpenRaiderSound_Ambient = 1
-
-} OpenRaider_SoundEventType;
-
-
-class OpenRaider : public SDLSystem
-{
- public:
-
-    ////////////////////////////////////////////////////////////
-    // Constructors ( Singleton )
-    ////////////////////////////////////////////////////////////
-
+typedef enum {
+    OpenRaider_ShowFPS     = (1 << 0),
+    OpenRaider_DebugMap    = (1 << 1),
+    OpenRaider_DebugModel  = (1 << 2),
+    OpenRaider_EnableSound = (1 << 3),
+    OpenRaider_DumpTexture = (1 << 4),
+    OpenRaider_FullScreen  = (1 << 5),
+    OpenRaider_Loading     = (1 << 6)
+} OpenRaider_Flags;
+
+/*!
+ * \brief Main Game Singleton
+ */
+class OpenRaider : public SDLSystem {
+public:
+
+    /*!
+     * \brief Constructs or returns the OpenRaider Singleton
+     * \returns OpenRaider Singleton
+     */
     static OpenRaider *Instance();
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : Constructs the object of OpenRaider or
-     *        returns pointer to it if previously allocated
-     *
-     *-- History ------------------------------------------
-     *
-     * 2001.08.24:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Deconstructs an object of OpenRaider
+     */
     ~OpenRaider();
-    /*------------------------------------------------------
-     * Pre  : OpenRaider object is allocated
-     * Post : Deconstructs an object of OpenRaider
-     *
-     *-- History ------------------------------------------
-     *
-     * 2001.05.21:
-     * Mongoose - Created
-     ------------------------------------------------------*/
-
-
-    ////////////////////////////////////////////////////////////
-    // Public Accessors
-    ////////////////////////////////////////////////////////////
-
-
-    ////////////////////////////////////////////////////////////
-    // Public Mutators
-    ////////////////////////////////////////////////////////////
 
+    /*!
+     * \brief Initialize the Game
+     */
     void start();
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : Init the Game
-     *
-     *-- History ------------------------------------------
-     *
-     * 2001.05.21:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Mouse motion input
+     * \param x relative x motion
+     * \param y relative y motion
+     */
     void handleMouseMotionEvent(float x, float y);
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : Mouse motion input used
-     *
-     *-- History ------------------------------------------
-     *
-     * 2001.06.04:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Receives `Event` bound to `Cmd` from `Key` press
+     * \param key valid keyboard code
+     */
     void handleBoundKeyPressEvent(unsigned int key);
-    /*------------------------------------------------------
-     * Pre  : <Key> is a valid keyboard code
-     *
-     * Post : Recieves <Event> bound to <Cmd> from <Key> press
-     *
-     *-- History ------------------------------------------
-     *
-     * 2003.06.03:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Receives `Event` bound to `Cmd` from `Key` release
+     * \param key valid keyboard code
+     */
     void handleBoundKeyReleaseEvent(unsigned int key);
-    /*------------------------------------------------------
-     * Pre  : <Key> is a valid keyboard code
-     *
-     * Post : Recieves <Event> bound to <Cmd> from <Key> release
-     *
-     *-- History ------------------------------------------
-     *
-     * 2003.06.03:
-     * Mongoose - Created
-     ------------------------------------------------------*/
-
-     void handleCommand(char *command, unsigned int mode);
-    /*------------------------------------------------------
-     * Pre  : <Command> is valid keyword optionally followed
-     *        by ' ' (space) seperated and argument(s)
-     *
-     *        <Mode> is the current type or resource mode
-     *
-     * Post : Executes valid command based on keyword
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.03.23:
-     * Mongoose - Created
-     ------------------------------------------------------*/
-
-     void handleConsoleKeyPressEvent(unsigned int key, unsigned int mod);
-    /*------------------------------------------------------
-     * Pre  : <Key> is a valid keyboard code
-     *
-     * Post : Recieves <Key> code from text input in console mode
-     *
-     *-- History ------------------------------------------
-     *
-     * 2003.06.03:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Executes valid command based on keyword
+     * \param command valid keyword optionally followed by space separated arguments
+     * \param mode current type or resource mode
+     */
+    void handleCommand(char *command, unsigned int mode);
+
+    /*!
+     * \brief Receives `Key` code from text input in console mode
+     * \param key valid keyboard code
+     * \param mod valid modifier code
+     */
+    void handleConsoleKeyPressEvent(unsigned int key, unsigned int mod);
+
+    /*!
+     * \brief Executes command associated with key press, if any
+     * \param key valid keyboard code
+     * \param mod valid modifier code
+     */
     void handleKeyPressEvent(unsigned int key, unsigned int mod);
+
+    /*!
+     * \brief Executes command associated with key release, if any
+     * \param key valid keyboard code
+     * \param mod valid modifier code
+     */
     void handleKeyReleaseEvent(unsigned int key, unsigned int mod);
-    /*------------------------------------------------------
-     * Pre  : key and mod are valid key command
-     * Post : executes command acc with key, if any
-     *
-     *-- History ------------------------------------------
-     *
-     * 2001.05.27:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
     void initGL();
-    /*------------------------------------------------------
-     * Pre  :
-     * Post :
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.08.13:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Pass a time frame and render a new frame
+     */
     void gameFrame();
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : One game physics/time frame passes
-     *        Also renders one frame per call
-     *
-     *-- History ------------------------------------------
-     *
-     * 2001.05.21:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Outputs message in game console
+     * \param dump_stdout if true, also print to stdout
+     * \param format printf() style format string
+     */
     void print(bool dump_stdout, const char *format, ...);
-    /*------------------------------------------------------
-     * Pre  : Use like printf
-     *
-     * Post : Outputs message in game console
-     *
-     *        If dump_stdout is true, print to stdout also
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.08.13:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+protected:
 
- protected:
-
-    ////////////////////////////////////////////////////////////
-    // Constructors ( Singleton )
-    ////////////////////////////////////////////////////////////
-
+    /*!
+     * \brief Constructs an object of OpenRaider
+     */
     OpenRaider();
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : Constructs an object of OpenRaider
-     *
-     *-- History ------------------------------------------
-     *
-     * 2001.05.21:
-     * Mongoose - Created
-     ------------------------------------------------------*/
-
-
- private:
-
-    ////////////////////////////////////////////////////////////
-    // Private Accessors
-    ////////////////////////////////////////////////////////////
 
-
-    ////////////////////////////////////////////////////////////
-    // Private Mutators
-    ////////////////////////////////////////////////////////////
+private:
 
     void consoleCommand(char *cmd);
-    /*------------------------------------------------------
-     * Pre  :
-     * Post :
-     *
-     *-- History ------------------------------------------
-     *
-     * ????.??.??:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
     void soundEvent(int type, int id, vec3_t pos, vec3_t angles);
-    /*------------------------------------------------------
-     * Pre  :
-     * Post :
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.06.16:
-     * Mongoose - Created
-     ------------------------------------------------------*/
-
-//  void entityEvent(entity_t &e, RaiderEvent event);
-    /*------------------------------------------------------
-     * Pre  :
-     * Post :
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.06.16:
-     * Mongoose - Created
-     ------------------------------------------------------*/
+
+    //void entityEvent(entity_t &e, RaiderEvent event);
 
     void processPakSounds();
-    /*------------------------------------------------------
-     * Pre  :
-     * Post :
-     *
-     *-- History ------------------------------------------
-     *
-     * 2001.06.04:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
-    void initSound();
-    /*------------------------------------------------------
-     * Pre  : Sound system has been init
-     * Post : Loads and positions level sounds and music
+    /*!
+     * \brief Loads and positions level sounds and music.
      *
-     *-- History ------------------------------------------
-     *
-     * 2001.06.04:
-     * Mongoose - Created
-     ------------------------------------------------------*/
+     * Sound system has to be initialized.
+     */
+    void initSound();
 
+    /*!
+     * \brief Generates textures or mipmaps for fonts, splash,
+     * external particles.
+     */
     void initTextures();
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : Generates all textures or mipmaps
-     *        needed for fonts, splash, ext particles
-     *
-     *-- History ------------------------------------------
-     *
-     * 2001.05.28:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Generates tombraider textures or mipmaps for sprites,
+     * rooms and models.
+     */
     void processTextures();
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : Generates tombraider textures or mipmaps
-     *        needed for sprites, rooms, and models
-     *
-     *-- History ------------------------------------------
-     *
-     * 2001.05.28:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Generates render sprite sequences
+     */
     void processSprites();
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : Generates render sprite sequences
-     *
-     *-- History ------------------------------------------
-     *
-     * 2001.06.06:
-     * Mongoose - All new functionality
-     *
-     * 2001.05.28:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
     void processMoveables();
-    /*------------------------------------------------------
-     * Pre  :
-     * Post :
-     *
-     *-- History ------------------------------------------
-     *
-     * 2001.06.08:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
     void processMoveable(int index, int i, int *ent, List <skeletal_model_t *> &cache2, List <unsigned int> &cache, int object_id);
-    /*------------------------------------------------------
-     * Pre  :
-     * Post :
-     *
-     *-- History ------------------------------------------
-     *
-     * 2002.04.06:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Generates render mesh and any textures needed
+     * for the specified model.
+     * \param index valid model index
+     */
     void processModel(int index);
-    /*------------------------------------------------------
-     * Pre  : valid model index
-     * Post : Generates render mesh and any textures
-     *        needed for model[index]
-     *
-     *-- History ------------------------------------------
-     *
-     * 2001.05.26:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Generates render mesh and any textures needed
+     * for the specified room
+     * \param index valid room index
+     */
     void processRoom(int index);
-    /*------------------------------------------------------
-     * Pre  : valid room index
-     * Post : Generates render mesh and any textures
-     *        needed for room[index]
-     *
-     *-- History ------------------------------------------
-     *
-     * 2001.05.21:
-     * Mongoose - Created
-     ------------------------------------------------------*/
 
+    /*!
+     * \brief Loads validated level pak from diskfile using maplist
+     * \param filename level pak file name
+     */
     void loadLevel(char *filename);
-    /*------------------------------------------------------
-     * Pre  :
-     * Post : Loads validated level pak from diskfile
-     *        using maplist
-     *
-     *-- History ------------------------------------------
-     *
-     * 2001.05.21:
-     * Mongoose - Created
-     ------------------------------------------------------*/
-
-
-    static OpenRaider *mInstance; /* Singleton use */
-
-    TombRaider m_tombraider;      /* Tombraider data support */
-
-    Sound mSound;                 /* 3d Audio support */
-
-    Render m_render;              /* Rendering support */
 
-    Camera m_camera;              /* Client camera support */
+    static OpenRaider *mInstance; //!< Singleton use
+    TombRaider m_tombraider;      //!< Tombraider data support
+    Sound mSound;                 //!< 3d Audio support
+    Render m_render;              //!< Rendering support
+    Camera m_camera;              //!< Client camera support
+    GLString *mText;              //!< Hook to textbox like output
 
-    GLString *mText;              /* Hook to textbox like output */
-
-    int mNoClipping;              /* 0 - Clipping, 1 - No Clipping,
-                                               2 - No Clipping w/o gravity */
-
-    // RC vars //////////////////
-
-    unsigned int mMode[8];          /* Translate System's mode ids to OR's */
-
-    unsigned int m_flags;           /* Set options by flags */
-
-    int m_testSFX;                      /* Used for mixed channel sound tests */
-
-    float m_mouseX, m_mouseY;       /* XY axis rotation deltas */
-
-    unsigned int m_texOffset;       /* Offset of TombRaider textures in list */
+    // RC vars
 
+    unsigned int mMode[8];            //!< Translate System's mode ids to OR's
+    unsigned int m_flags;             //!< Set options by flags
+    int m_testSFX;                    //!< Used for mixed channel sound tests
+    float m_mouseX, m_mouseY;         //!< XY axis rotation deltas
+    unsigned int m_texOffset;         //!< Offset of TombRaider textures in list
     unsigned int mLevelTextureOffset;
 
-    // Game vars //////////////
-
-    Vector <char *> mMusicList;  /* List of game level music */
-
-    Vector <char *> mMapList;    /* List of game maps */
-
-    char m_mapName[32];          /* Current map filename */
-
-    char *m_pakDir;              /* Current pak directory */
-
-    char *m_audioDir;            /* Current audio directory */
-
-    char *m_homeDir;             /* Current home directory */
+    // Game vars
 
-    Vector<entity_t *> mClients; /* Player entity/clients */
+    Vector <char *> mMusicList;  //!< List of game level music
+    Vector <char *> mMapList;    //!< List of game maps
+    char m_mapName[32];          //!< Current map filename
+    char *m_pakDir;              //!< Current pak directory
+    char *m_audioDir;            //!< Current audio directory
+    char *m_homeDir;             //!< Current home directory
+    Vector<entity_t *> mClients; //!< Player entity/clients
 };
 
 #endif

include/Render.h

 #include <Light.h>
 #include <World.h>
 #include <SkeletalModel.h>
-#include <OpenGLMesh.h>
+#include <Mesh.h>
 #include <Texture.h>
 #include <Camera.h>
 #include <GLString.h>
 #endif
 
 
-class RenderRoom
-{
+class RenderRoom {
 public:
-    RenderRoom()
-    {
+    RenderRoom() {
         room = 0x0;
         dist = 0.0f;
         center[0] = center[1] = center[2] = 0.0f;
     }
 
-    ~RenderRoom()
-    {
+    ~RenderRoom() {
         //! \fixme Hangs when erasing - might be shared pointers somewhere
         //lights.erase();
     }
 
-    void computeCenter()
-    {
+    void computeCenter() {
         if (room)
-        {
             helMidpoint3v(room->bbox_min, room->bbox_max, center);
-        }
     }
 
-    vec_t dist;              /* Distance to near plane, move to room?  */
-
-    vec3_t center;           /* Center of bbox, move to room? */
-
-    room_mesh_t *room;       /* Physical room stored in World,
-                                         Very dangerous as allocated and used */
-
-    Vector<Light *> lights;  /* List of lights in this room */
-
-    OpenGLMesh mesh;         /* OpenGL mesh that represents this room */
+    vec_t dist;             //!< Distance to near plane, move to room?
+    vec3_t center;          //!< Center of bbox, move to room?
+    room_mesh_t *room;      //!< Physical room stored in World, very dangerous as allocated and used
+    Vector<Light *> lights; //!< List of lights in this room
+    Mesh mesh;              //!< OpenGL mesh that represents this room
 };
 
 
 {
  public:
 
-    typedef enum
-   {
-        modeDisabled    = 0,
-        modeLoadScreen  = 1,
-        modeVertexLight = 2,
-        modeSolid       = 3,
-        modeWireframe   = 4,
-        modeTexture     = 5
+    typedef enum {
+        modeDisabled,
+        modeLoadScreen,
+        modeVertexLight,
+        modeSolid,
+        modeWireframe,
+        modeTexture
     } RenderMode;
 
-    typedef enum
-   {
-        fParticles      = 1,
-        fPortals            = 2,
-        fRoomAlpha      = 4,
-        fViewModel    = 8,
-        fSprites      = 16,
-        fRoomModels   = 32,
-        fEntityModels = 64,
-        fFog          = 128,
-        fUsePortals   = 256,
-        fFastCard     = 1024,
-        fGL_Lights    = 2048,
-        fOneRoom      = 4096,
-        fRenderPonytail = 8192,
-        fMultiTexture = 16384,
-        fUpdateRoomListPerFrame = 32768,
-        fAnimateAllModels = 65536,
-        fAllRooms      =  131072
+    typedef enum {
+        fParticles              = (1 << 0),
+        fPortals                = (1 << 1),
+        fRoomAlpha              = (1 << 2),
+        fViewModel              = (1 << 3),
+        fSprites                = (1 << 4),
+        fRoomModels             = (1 << 5),
+        fEntityModels           = (1 << 6),
+        fFog                    = (1 << 7),
+        fUsePortals             = (1 << 8),
+        fFastCard               = (1 << 9),
+        fGL_Lights              = (1 << 10),
+        fOneRoom                = (1 << 11),
+        fRenderPonytail         = (1 << 12),
+        fMultiTexture           = (1 << 13),
+        fUpdateRoomListPerFrame = (1 << 14),
+        fAnimateAllModels       = (1 << 15),
+        fAllRooms               = (1 << 16)
     } RenderFlags;
 
-    typedef enum
-    {
-        roomMesh = 1,
-        skeletalMesh = 2
-
+    typedef enum {
+        roomMesh,
+        skeletalMesh
     } RenderMeshType;
 
     ////////////////////////////////////////////////////////////

src/Matrix.cpp

 
 #include <Matrix.h>
 
-Matrix::Matrix()
-{
+Matrix::Matrix() {
     setIdentity();
 }
 
-Matrix::Matrix(matrix_t m)
-{
+Matrix::Matrix(matrix_t m) {
     setMatrix(m);
 }
 
-Matrix::Matrix(Quaternion &q)
-{
+Matrix::Matrix(Quaternion &q) {
     matrix_t m;
-
-
     q.getMatrix(m);
     setMatrix(m);
 }
 
-Matrix::~Matrix()
-{
+Matrix::~Matrix() {
 }
 
-bool Matrix::getInvert(matrix_t out)
-{
+bool Matrix::getInvert(matrix_t out) {
     matrix_t m;
 
 #ifdef COLUMN_ORDER
     r0 = wtmp[0], r1 = wtmp[1], r2 = wtmp[2], r3 = wtmp[3];
 
     r0[0] = MAT(m,0,0), r0[1] = MAT(m,0,1),
-        r0[2] = MAT(m,0,2), r0[3] = MAT(m,0,3),
-        r0[4] = 1.0f, r0[5] = r0[6] = r0[7] = 0.0f,
+    r0[2] = MAT(m,0,2), r0[3] = MAT(m,0,3),
+    r0[4] = 1.0f, r0[5] = r0[6] = r0[7] = 0.0f,
 
-        r1[0] = MAT(m,1,0), r1[1] = MAT(m,1,1),
-        r1[2] = MAT(m,1,2), r1[3] = MAT(m,1,3),
-        r1[5] = 1.0f, r1[4] = r1[6] = r1[7] = 0.0f,
+    r1[0] = MAT(m,1,0), r1[1] = MAT(m,1,1),
+    r1[2] = MAT(m,1,2), r1[3] = MAT(m,1,3),
+    r1[5] = 1.0f, r1[4] = r1[6] = r1[7] = 0.0f,
 
-        r2[0] = MAT(m,2,0), r2[1] = MAT(m,2,1),
-        r2[2] = MAT(m,2,2), r2[3] = MAT(m,2,3),
-        r2[6] = 1.0f, r2[4] = r2[5] = r2[7] = 0.0f,
+    r2[0] = MAT(m,2,0), r2[1] = MAT(m,2,1),
+    r2[2] = MAT(m,2,2), r2[3] = MAT(m,2,3),
+    r2[6] = 1.0f, r2[4] = r2[5] = r2[7] = 0.0f,
 
-        r3[0] = MAT(m,3,0), r3[1] = MAT(m,3,1),
-        r3[2] = MAT(m,3,2), r3[3] = MAT(m,3,3),
-        r3[7] = 1.0f, r3[4] = r3[5] = r3[6] = 0.0f;
+    r3[0] = MAT(m,3,0), r3[1] = MAT(m,3,1),
+    r3[2] = MAT(m,3,2), r3[3] = MAT(m,3,3),
+    r3[7] = 1.0f, r3[4] = r3[5] = r3[6] = 0.0f;
 
     /* choose pivot - or die */
     if (fabs(r3[0])>fabs(r2[0])) SWAP_ROWS(r3, r2);
     /* eliminate third variable */
     m3 = r3[2]/r2[2];
     r3[3] -= m3 * r2[3], r3[4] -= m3 * r2[4],
-        r3[5] -= m3 * r2[5], r3[6] -= m3 * r2[6],
-        r3[7] -= m3 * r2[7];
+    r3[5] -= m3 * r2[5], r3[6] -= m3 * r2[6],
+    r3[7] -= m3 * r2[7];
 
     /* last check */
     if (0.0f == r3[3]) return false;
     m2 = r2[3];                 /* now back substitute row 2 */
     s  = 1.0f/r2[2];
     r2[4] = s * (r2[4] - r3[4] * m2), r2[5] = s * (r2[5] - r3[5] * m2),
-        r2[6] = s * (r2[6] - r3[6] * m2), r2[7] = s * (r2[7] - r3[7] * m2);
+    r2[6] = s * (r2[6] - r3[6] * m2), r2[7] = s * (r2[7] - r3[7] * m2);
     m1 = r1[3];
     r1[4] -= r3[4] * m1, r1[5] -= r3[5] * m1,
-        r1[6] -= r3[6] * m1, r1[7] -= r3[7] * m1;
+    r1[6] -= r3[6] * m1, r1[7] -= r3[7] * m1;
     m0 = r0[3];
     r0[4] -= r3[4] * m0, r0[5] -= r3[5] * m0,
-        r0[6] -= r3[6] * m0, r0[7] -= r3[7] * m0;
+    r0[6] -= r3[6] * m0, r0[7] -= r3[7] * m0;
 
     m1 = r1[2];                 /* now back substitute row 1 */
     s  = 1.0f/r1[1];
     r1[4] = s * (r1[4] - r2[4] * m1), r1[5] = s * (r1[5] - r2[5] * m1),
-        r1[6] = s * (r1[6] - r2[6] * m1), r1[7] = s * (r1[7] - r2[7] * m1);
+    r1[6] = s * (r1[6] - r2[6] * m1), r1[7] = s * (r1[7] - r2[7] * m1);
     m0 = r0[2];
     r0[4] -= r2[4] * m0, r0[5] -= r2[5] * m0,
-        r0[6] -= r2[6] * m0, r0[7] -= r2[7] * m0;
+    r0[6] -= r2[6] * m0, r0[7] -= r2[7] * m0;
 
     m0 = r0[1];                 /* now back substitute row 0 */
     s  = 1.0f/r0[0];
     r0[4] = s * (r0[4] - r1[4] * m0), r0[5] = s * (r0[5] - r1[5] * m0),
-        r0[6] = s * (r0[6] - r1[6] * m0), r0[7] = s * (r0[7] - r1[7] * m0);
+    r0[6] = s * (r0[6] - r1[6] * m0), r0[7] = s * (r0[7] - r1[7] * m0);
 
     MAT(out,0,0) = r0[4];
     MAT(out,0,1) = r0[5], MAT(out,0,2) = r0[6];
 #undef SWAP_ROWS
 }
 
-void Matrix::getMatrix(matrix_t mat)
-{
+void Matrix::getMatrix(matrix_t mat) {
     copy(mMatrix, mat);
 }
 
-void Matrix::getTransposeMatrix(matrix_t m)
-{
+void Matrix::getTransposeMatrix(matrix_t m) {
     m[ 0]= mMatrix[0]; m[ 1]= mMatrix[4]; m[ 2]= mMatrix[ 8]; m[ 3]=mMatrix[12];
     m[ 4]= mMatrix[1]; m[ 5]= mMatrix[5]; m[ 6]= mMatrix[ 9]; m[ 7]=mMatrix[13];
     m[ 8]= mMatrix[2]; m[ 9]= mMatrix[6]; m[10]= mMatrix[10]; m[11]=mMatrix[14];
     m[12]= mMatrix[3]; m[13]= mMatrix[7]; m[14]= mMatrix[11]; m[15]=mMatrix[15];
 }
 
-Matrix Matrix::multiply(const Matrix &a, const Matrix &b)
-{
+Matrix Matrix::multiply(const Matrix &a, const Matrix &b) {
     Matrix c;
-
     multiply(a.mMatrix, b.mMatrix, c.mMatrix);
-
     return c;
 }
 
-Matrix Matrix::operator *(const Matrix &a)
-{
+Matrix Matrix::operator *(const Matrix &a) {
     return multiply(a, *this);
 }
 
-Vector3d Matrix::operator *(Vector3d v)
-{
+Vector3d Matrix::operator *(Vector3d v) {
     vec_t x = v.mVec[0], y = v.mVec[1], z = v.mVec[2];
 
 #ifdef COLUMN_ORDER
-    // Column order
     return Vector3d(mMatrix[0]*x + mMatrix[4]*y + mMatrix[ 8]*z + mMatrix[12],
             mMatrix[1]*x + mMatrix[5]*y + mMatrix[ 9]*z + mMatrix[13],
             mMatrix[2]*x + mMatrix[6]*y + mMatrix[10]*z + mMatrix[14]);
 #else
-    // Row order
     return Vector3d(mMatrix[0]*x + mMatrix[1]*y + mMatrix[ 2]*z + mMatrix[ 3],
             mMatrix[4]*x + mMatrix[5]*y + mMatrix[ 6]*z + mMatrix[ 7],
             mMatrix[8]*x + mMatrix[9]*y + mMatrix[10]*z + mMatrix[11]);
 #endif
 }
 
-void Matrix::multiply3v(vec3_t v, vec3_t result)
-{
+void Matrix::multiply3v(vec3_t v, vec3_t result) {
     vec_t x = v[0], y = v[1], z = v[2];
 
     result[0] = mMatrix[0]*x + mMatrix[1]*y + mMatrix[ 2]*z + mMatrix[ 3];
     result[2] = mMatrix[8]*x + mMatrix[9]*y + mMatrix[10]*z + mMatrix[11];
 }
 
-void Matrix::multiply4v(vec4_t v, vec4_t result)
-{
+void Matrix::multiply4v(vec4_t v, vec4_t result) {
     vec_t x = v[0], y = v[1], z = v[2], w = v[3];
 
     result[0] = mMatrix[ 0]*x + mMatrix[ 1]*y + mMatrix[ 2]*z + mMatrix[ 3]*w;
     result[3] = mMatrix[12]*x + mMatrix[13]*y + mMatrix[14]*z + mMatrix[15]*w;
 }
 
-void Matrix::print()
-{
-#ifdef COLUMN_ORDER
+void Matrix::print() {
     printf("{\n%f %f %f %f\n%f %f %f %f\n%f %f %f %f\n%f %f %f %f\n}\n",
+#ifdef COLUMN_ORDER
             mMatrix[0], mMatrix[4], mMatrix[ 8], mMatrix[12],
             mMatrix[1], mMatrix[5], mMatrix[ 9], mMatrix[13],
             mMatrix[2], mMatrix[6], mMatrix[10], mMatrix[14],
             mMatrix[3], mMatrix[7], mMatrix[11], mMatrix[15]);
 #else
-    printf("{\n%f %f %f %f\n%f %f %f %f\n%f %f %f %f\n%f %f %f %f\n}\n",
             mMatrix[ 0], mMatrix[ 1], mMatrix[ 2], mMatrix[ 3],
             mMatrix[ 4], mMatrix[ 5], mMatrix[ 6], mMatrix[ 7],
             mMatrix[ 8], mMatrix[ 9], mMatrix[10], mMatrix[11],
 #endif
 }
 
-bool Matrix::isIdentity()
-{
-    // Hhhmm... floating point using direct comparisions
+bool Matrix::isIdentity() {
+    // Hhhmm... floating point using direct comparisons
     /*
     if (mMatrix[ 0] == 1 && mMatrix[ 1] == 0 && mMatrix[ 2] == 0 &&
             mMatrix[ 3] == 0 &&    mMatrix[ 4] == 0 && mMatrix[ 5] == 1 &&
     return false;
 }
 
-void Matrix::setMatrix(matrix_t mat)
-{
+void Matrix::setMatrix(matrix_t mat) {
     copy(mat, mMatrix);
 }
 
-void Matrix::setIdentity()
-{
+void Matrix::setIdentity() {
     mMatrix[ 0] = 1; mMatrix[ 1] = 0; mMatrix[ 2] = 0; mMatrix[ 3] = 0;
     mMatrix[ 4] = 0; mMatrix[ 5] = 1; mMatrix[ 6] = 0; mMatrix[ 7] = 0;
     mMatrix[ 8] = 0; mMatrix[ 9] = 0; mMatrix[10] = 1; mMatrix[11] = 0;
     mMatrix[12] = 0; mMatrix[13] = 0; mMatrix[14] = 0; mMatrix[15] = 1;
 }
 
-void Matrix::scale(const vec_t *xyz)
-{
+void Matrix::scale(const vec_t *xyz) {
     scale(xyz[0], xyz[1], xyz[2]);
 }
 
-void Matrix::scale(vec_t sx, vec_t sy, vec_t sz)
-{
+void Matrix::scale(vec_t sx, vec_t sy, vec_t sz) {
     matrix_t smatrix;
     matrix_t tmp;
 
-    smatrix[ 0] = sx;smatrix[ 1] = 0; smatrix[ 2] = 0; smatrix[ 3] = 0;
-    smatrix[ 4] = 0; smatrix[ 5] = sy;smatrix[ 6] = 0; smatrix[ 7] = 0;
-    smatrix[ 8] = 0; smatrix[ 9] = 0; smatrix[10] = sz;smatrix[11] = 0;
-    smatrix[12] = 0; smatrix[13] = 0; smatrix[14] = 0; smatrix[15] = 1;
+    smatrix[ 0] = sx; smatrix[ 1] = 0;  smatrix[ 2] = 0;  smatrix[ 3] = 0;
+    smatrix[ 4] = 0;  smatrix[ 5] = sy; smatrix[ 6] = 0;  smatrix[ 7] = 0;
+    smatrix[ 8] = 0;  smatrix[ 9] = 0;  smatrix[10] = sz; smatrix[11] = 0;
+    smatrix[12] = 0;  smatrix[13] = 0;  smatrix[14] = 0;  smatrix[15] = 1;
 
     copy(mMatrix, tmp);
     multiply(tmp, smatrix, mMatrix);
 }
 
-void Matrix::rotate(const vec_t *xyz)
-{
+void Matrix::rotate(const vec_t *xyz) {
     rotate(xyz[0], xyz[1], xyz[2]);
 }
 
-void Matrix::rotate(vec_t ax, vec_t ay, vec_t az)
-{
+void Matrix::rotate(vec_t ax, vec_t ay, vec_t az) {
     matrix_t xmat, ymat, zmat, tmp, tmp2;
 
-    xmat[ 0]=1;        xmat[ 1]=0;        xmat[ 2]=0;        xmat[ 3]=0;
-    xmat[ 4]=0;        xmat[ 5]=cosf(ax);  xmat[ 6]=sinf(ax);  xmat[ 7]=0;
-    xmat[ 8]=0;        xmat[ 9]=-sinf(ax); xmat[10]=cosf(ax);  xmat[11]=0;
-    xmat[12]=0;        xmat[13]=0;        xmat[14]=0;        xmat[15]=1;
+    xmat[ 0]=1;         xmat[ 1]=0;         xmat[ 2]=0;         xmat[ 3]=0;
+    xmat[ 4]=0;         xmat[ 5]=cosf(ax);  xmat[ 6]=sinf(ax);  xmat[ 7]=0;
+    xmat[ 8]=0;         xmat[ 9]=-sinf(ax); xmat[10]=cosf(ax);  xmat[11]=0;
+    xmat[12]=0;         xmat[13]=0;         xmat[14]=0;         xmat[15]=1;
 
-    ymat[ 0]=cosf(ay);  ymat[ 1]=0;        ymat[ 2]=-sinf(ay); ymat[ 3]=0;
-    ymat[ 4]=0;        ymat[ 5]=1;        ymat[ 6]=0;        ymat[ 7]=0;
-    ymat[ 8]=sinf(ay);  ymat[ 9]=0;        ymat[10]=cosf(ay);  ymat[11]=0;
-    ymat[12]=0;        ymat[13]=0;        ymat[14]=0;        ymat[15]=1;
+    ymat[ 0]=cosf(ay);  ymat[ 1]=0;         ymat[ 2]=-sinf(ay); ymat[ 3]=0;
+    ymat[ 4]=0;         ymat[ 5]=1;         ymat[ 6]=0;         ymat[ 7]=0;
+    ymat[ 8]=sinf(ay);  ymat[ 9]=0;         ymat[10]=cosf(ay);  ymat[11]=0;
+    ymat[12]=0;         ymat[13]=0;         ymat[14]=0;         ymat[15]=1;
 
-    zmat[ 0]=cosf(az);  zmat[ 1]=sinf(az);  zmat[ 2]=0;        zmat[ 3]=0;
-    zmat[ 4]=-sinf(az); zmat[ 5]=cosf(az);  zmat[ 6]=0;        zmat[ 7]=0;
-    zmat[ 8]=0;        zmat[ 9]=0;        zmat[10]=1;        zmat[11]=0;
-    zmat[12]=0;        zmat[13]=0;        zmat[14]=0;        zmat[15]=1;
+    zmat[ 0]=cosf(az);  zmat[ 1]=sinf(az);  zmat[ 2]=0;         zmat[ 3]=0;
+    zmat[ 4]=-sinf(az); zmat[ 5]=cosf(az);  zmat[ 6]=0;         zmat[ 7]=0;
+    zmat[ 8]=0;         zmat[ 9]=0;         zmat[10]=1;         zmat[11]=0;
+    zmat[12]=0;         zmat[13]=0;         zmat[14]=0;         zmat[15]=1;
 
     multiply(mMatrix, ymat, tmp);
     multiply(tmp, xmat, tmp2);
     multiply(tmp2, zmat, mMatrix);
 }
 
-void Matrix::translate(const vec_t *xyz)
-{
+void Matrix::translate(const vec_t *xyz) {
     translate(xyz[0], xyz[1], xyz[2]);
 }
 
-void Matrix::translate(vec_t tx, vec_t ty, vec_t tz)
-{
+void Matrix::translate(vec_t tx, vec_t ty, vec_t tz) {
     matrix_t tmat, tmp;
 
     tmat[ 0]=1;  tmat[ 1]=0;  tmat[ 2]=0;  tmat[ 3]=0;
     multiply(tmp, tmat, mMatrix);
 }
 
-void Matrix::copy(matrix_t source, matrix_t dest)
-{
-#ifdef FASTER_MATRIX
-    memcpy(dest, source, sizeof(matrix_t));
-#else
-    dest[ 0] = source[ 0];
-    dest[ 1] = source[ 1];
-    dest[ 2] = source[ 2];
-    dest[ 3] = source[ 3];
-
-    dest[ 4] = source[ 4];
-    dest[ 5] = source[ 5];
-    dest[ 6] = source[ 6];
-    dest[ 7] = source[ 7];
-
-    dest[ 8] = source[8];
-    dest[ 9] = source[9];
-    dest[10] = source[10];
-    dest[11] = source[11];
-
-    dest[12] = source[12];
-    dest[13] = source[13];
-    dest[14] = source[14];
-    dest[15] = source[15];
-#endif
+void Matrix::copy(matrix_t source, matrix_t dest) {
+    for (int i = 0; i < 16; i++)
+        dest[i] = source[i];
 }
 
-void Matrix::multiply(const matrix_t a, const matrix_t b, matrix_t result)
-{
+void Matrix::multiply(const matrix_t a, const matrix_t b, matrix_t result) {
     /* Generated code for matrix mult
      * Code used:
 
     // char order is argument
     int i, j, k;
-    if (order == 'r')
-    {
+    if (order == 'r') {
         printf("// Row order\n");
-    }
-    else
-    {
+    } else {
         printf("// Column order\n");
     }
-    for (i = 0; i < 4; ++i)
-    {
-        for (j = 0; j < 4; ++j)
-        {
-            if (order == 'r')
-            {
+    for (i = 0; i < 4; ++i) {
+        for (j = 0; j < 4; ++j) {
+            if (order == 'r') {
                 printf("result[%2i] = ", j+i*4);
-            }
-            else
-            {
+            } else {
                 printf("result[%2i] = ", j+i*4);
             }
-            for (k = 0; k < 4; ++k)
-            {
-                if (order == 'r')
-                {
+            for (k = 0; k < 4; ++k) {
+                if (order == 'r') {
                     printf("a[%2i] * b[%2i]%s",
                     k+i*4, j+k*4, (k == 3) ? ";\n" : " + ");
-                }
-                else
-                {
+                } else {
                     printf("a[%2i] * b[%2i]%s",
                     i+k*4, k+j*4, (k == 3) ? ";\n" : " + ");
                 }
     }
     printf("\n");
     printf("// Transpose\n");
-    for(i = 0; i < 4; ++i)
-    {
-        for (j = 0; j < 4; ++j)
-        {
+    for(i = 0; i < 4; ++i) {
+        for (j = 0; j < 4; ++j) {
             printf("a[%2i] = b[%2i]%s",
             j+i*4, i+j*4, (j == 3) ? ";\n" : "; ");
         }

src/OpenGLMesh.cpp → src/Mesh.cpp

 /*!
- * \file src/OpenGLMesh.cpp
+ * \file src/Mesh.cpp
  * \brief OpenGL Mesh
  *
  * \author Mongoose
 #include <GL/gl.h>
 #endif
 
-#include <OpenGLMesh.h>
+#include <Mesh.h>
 
 
 ////////////////////////////////////////////////////////////
 // Constructors
 ////////////////////////////////////////////////////////////
 
-OpenGLMesh::OpenGLMesh()
+Mesh::Mesh()
 {
     mNumVertices = 0;
     mVertices = 0x0;
     mTriangleTexCoordArray = 0x0;
 
     mFlags = 0;
-    mMode = OpenGLMeshModeTexture;
+    mMode = MeshModeTexture;
 }
 
 
-OpenGLMesh::~OpenGLMesh()
+Mesh::~Mesh()
 {
     unsigned int i;
 
 // Public Accessors
 ////////////////////////////////////////////////////////////
 
-void OpenGLMesh::drawAlpha()
+void Mesh::drawAlpha()
 {
     unsigned int i, j, k, index;
 
     {
         switch (mMode)
         {
-            case OpenGLMeshModeWireframe:
+            case MeshModeWireframe:
                 glColor3f(0.0, 0.0, 1.0);
                 glBindTexture(GL_TEXTURE_2D, 0);
                 break;
-            case OpenGLMeshModeSolid:
+            case MeshModeSolid:
                 // Bind WHITE texture for solid colors
                 glBindTexture(GL_TEXTURE_2D, 0);
                 break;
             default:
-            case OpenGLMeshModeTexture:
-            case OpenGLMeshModeMultiTexture:
+            case MeshModeTexture:
+            case MeshModeMultiTexture:
                 // Bind texture id for textures
                 glBindTexture(GL_TEXTURE_2D, mQuads[i].texture+1);
         }
     {
         switch (mMode)
         {
-            case OpenGLMeshModeWireframe:
+            case MeshModeWireframe:
                 glColor3f(0.0, 1.0, 0.0);
                 glBindTexture(GL_TEXTURE_2D, 0);
                 break;
-            case OpenGLMeshModeSolid:
+            case MeshModeSolid:
                 // Bind WHITE texture for solid colors
                 glBindTexture(GL_TEXTURE_2D, 0);
                 break;
             default:
-            case OpenGLMeshModeTexture:
-            case OpenGLMeshModeMultiTexture:
+            case MeshModeTexture:
+            case MeshModeMultiTexture:
                 // Bind texture id for textures
                 glBindTexture(GL_TEXTURE_2D, mTris[i].texture+1);
         }
 }
 
 
-void OpenGLMesh::drawSolid()
+void Mesh::drawSolid()
 {
     unsigned int i, j, k, index;
 
 
-    if (mFlags & fOpenGLMesh_UseVertexArray)
+    if (mFlags & fMesh_UseVertexArray)
     {
         //glEnableClientState(GL_VERTEX_ARRAY);
         //glVertexPointer(3, GL_FLOAT, 0, mVertexArray);
     {
         switch (mMode)
         {
-            case OpenGLMeshModeSolid:
+            case MeshModeSolid:
                 glColor3f(0.0, 0.0, 0.0);
                 break;
-            case OpenGLMeshModeWireframe:
+            case MeshModeWireframe:
                 // Bind WHITE texture for solid colors
                 glBindTexture(GL_TEXTURE_2D, 0);
                 break;
 #ifdef MULTITEXTURE
-            case OpenGLMeshModeMultiTexture:
+            case MeshModeMultiTexture:
                 glActiveTextureARB(GL_TEXTURE0_ARB);
                 glEnable(GL_TEXTURE_2D);
                 glBindTexture(GL_TEXTURE_2D, mQuads[i].texture+1);
                 glBindTexture(GL_TEXTURE_2D, mQuads[i].bumpmap+1);
                 break;
 #else
-            case OpenGLMeshModeMultiTexture:
+            case MeshModeMultiTexture:
 #endif
             default:
-            case OpenGLMeshModeTexture:
+            case MeshModeTexture:
                 // Bind texture id for textures
                 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
                 glBindTexture(GL_TEXTURE_2D, mQuads[i].texture+1);
                 glColor4fv(mColors[index]);
 
 #ifdef MULTITEXTURE
-                if (mMode == OpenGLMeshModeMultiTexture)
+                if (mMode == MeshModeMultiTexture)
                 {
                     glMultiTexCoord2fvARB(GL_TEXTURE0_ARB,
                             mQuads[i].texcoors[j*4+k]);
     {
         switch (mMode)
         {
-            case OpenGLMeshModeSolid:
+            case MeshModeSolid:
                 glColor3f(1.0, 0.0, 0.0);
                 break;
-            case OpenGLMeshModeWireframe:
+            case MeshModeWireframe:
                 // Bind WHITE texture for solid colors
                 glBindTexture(GL_TEXTURE_2D, 0);
                 break;
 #ifdef MULTITEXTURE
-            case OpenGLMeshModeMultiTexture:
+            case MeshModeMultiTexture:
                 glActiveTextureARB(GL_TEXTURE0_ARB);
                 glEnable(GL_TEXTURE_2D);
                 glBindTexture(GL_TEXTURE_2D, mTris[i].texture+1);
                 glBindTexture(GL_TEXTURE_2D, mTris[i].bumpmap+1);
                 break;
 #else
-            case OpenGLMeshModeMultiTexture:
+            case MeshModeMultiTexture:
 #endif
             default:
-            case OpenGLMeshModeTexture:
+            case MeshModeTexture:
                 // Bind texture id for textures
                 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
                 glBindTexture(GL_TEXTURE_2D, mTris[i].texture+1);
                 index = mTris[i].triangles[j*3+k];
 
 #ifdef MULTITEXTURE
-                if (mMode == OpenGLMeshModeMultiTexture)
+                if (mMode == MeshModeMultiTexture)
                 {
                     glMultiTexCoord2fvARB(GL_TEXTURE0_ARB,
                             mTris[i].texcoors[j*3+k]);
     }
 
 #ifdef MULTITEXTURE
-    if (mMode == OpenGLMeshModeMultiTexture)
+    if (mMode == MeshModeMultiTexture)
     {
         glDisable(GL_TEXTURE_2D);
         glActiveTextureARB(GL_TEXTURE0_ARB);
 // Public Mutators
 ////////////////////////////////////////////////////////////
 
-void OpenGLMesh::allocateColors(unsigned int n)
+void Mesh::allocateColors(unsigned int n)
 {
     if (mColors)
     {
 }
 
 
-void OpenGLMesh::allocateNormals(unsigned int n)
+void Mesh::allocateNormals(unsigned int n)
 {
     if (mNormals)
     {
 }
 
 
-void OpenGLMesh::allocateRectangles(unsigned int n)
+void Mesh::allocateRectangles(unsigned int n)
 {
     if (mQuads)
     {
 }
 
 
-void OpenGLMesh::allocateTriangles(unsigned int n)
+void Mesh::allocateTriangles(unsigned int n)
 {
     if (mTris)
     {
 }
 
 
-void OpenGLMesh::allocateVertices(unsigned int n)
+void Mesh::allocateVertices(unsigned int n)
 {
     if (mVertices)
     {
 }
 
 
-void OpenGLMesh::bufferColorArray(unsigned int colorCount, vec_t *colors)
+void Mesh::bufferColorArray(unsigned int colorCount, vec_t *colors)
 {
     if (mColors)
     {
 }
 
 
-void OpenGLMesh::bufferNormalArray(unsigned int normalCount, vec_t *normals)
+void Mesh::bufferNormalArray(unsigned int normalCount, vec_t *normals)
 {
     if (mNormals)
     {
 }
 
 
-void OpenGLMesh::bufferTriangles(unsigned int count,
+void Mesh::bufferTriangles(unsigned int count,
         unsigned int *indices, vec_t *texCoords,
         int *textures, unsigned int *flags)
 {
 }
 
 
-void OpenGLMesh::bufferVertexArray(unsigned int vertexCount, vec_t *vertices)
+void Mesh::bufferVertexArray(unsigned int vertexCount, vec_t *vertices)
 {
     if (mVertices)
     {
 
     mNumVertices = vertexCount;
     mVertexArray = vertices;
-    mFlags |= fOpenGLMesh_UseVertexArray;
+    mFlags |= fMesh_UseVertexArray;
 }
 
 
-void OpenGLMesh::setColor(unsigned int index,
+void Mesh::setColor(unsigned int index,
         float r, float g, float b, float a)
 {
     if (index > mNumColors)
 }
 
 
-void OpenGLMesh::setColor(unsigned int index, float rgba[4])
+void Mesh::setColor(unsigned int index, float rgba[4])
 {
     if (index > mNumColors)
     {
 }
 
 
-void OpenGLMesh::setNormal(unsigned int index, float i, float j, float k)
+void Mesh::setNormal(unsigned int index, float i, float j, float k)
 {
     if (index > mNumNormals)
     {
 }
 
 
-void OpenGLMesh::setVertex(unsigned int index, float x, float y, float z)
+void Mesh::setVertex(unsigned int index, float x, float y, float z)
 {
     if (index > mNumVertices)
     {

src/OpenRaider.cpp

-/* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
-/*================================================================
+/*!
+ * \file include/OpenRaider.h
+ * \brief Main Game Singleton
  *
- * Project : OpenRaider
- * Author  : Mongoose
- * Website : http://www.westga.edu/~stu7440/
- * Email   : stu7440@westga.edu
- * Object  : OpenRaider
- * License : No use w/o permission (C) 2001 Mongoose
- * Comments: This is the main class for OpenRaider
- *
- *
- *           This file was generated using Mongoose's C++
- *           template generator script.  <stu7440@westga.edu>
- *
- *-- History -------------------------------------------------
- *
- * 2001.05.21:
- * Mongoose - Created
- =================================================================*/
+ * \author Mongoose
+ */
 
 #include <stdlib.h>
 #include <string.h>
     m_texOffset = 0;
     mLevelTextureOffset = 0;
     m_testSFX = -1;
-    mNoClipping = 0;
 
     mText = NULL;
     m_flags = 0;
     }
     else if (rc_command("fly", cmd))
     {
-        mNoClipping = worldMoveType_fly;
-
         if (LARA)
         {
             LARA->moveType = worldMoveType_fly;
     }
     else if (rc_command("walk", cmd))
     {
-        mNoClipping = worldMoveType_walk;
-
         if (LARA)
         {
             LARA->moveType = worldMoveType_walk;
     }
     else if (rc_command("ghost", cmd))
     {
-        mNoClipping = worldMoveType_noClipping;
-
         if (LARA)
         {
             LARA->moveType = worldMoveType_noClipping;

src/Render.cpp

     switch (mMode)
     {
         case modeWireframe:
-            rRoom->mesh.mMode = OpenGLMesh::OpenGLMeshModeWireframe;
+            rRoom->mesh.mMode = Mesh::MeshModeWireframe;
             break;
         case modeSolid:
-            rRoom->mesh.mMode = OpenGLMesh::OpenGLMeshModeSolid;
+            rRoom->mesh.mMode = Mesh::MeshModeSolid;
             break;
         default:
-            rRoom->mesh.mMode = OpenGLMesh::OpenGLMeshModeTexture;
+            rRoom->mesh.mMode = Mesh::MeshModeTexture;
             break;
     }