Console, Game, Menu, OpenRaider and Window are global services.

include/OpenRaider.h

 
     //! \fixme should be private
 
-    Window *mWindow;
     Sound *mSound;
-    Menu *mMenu;
-    Console *mConsole;
-    Game *mGame;
 
     bool mMapListFilled;
     std::vector<char *> mMapList;

include/main.h

 #ifndef _MAIN_H_
 #define _MAIN_H_
 
+#include "Console.h"
+#include "Game.h"
+#include "Menu.h"
 #include "OpenRaider.h"
+#include "Window.h"
 
-extern OpenRaider *gOpenRaider; //!< Main Game Singleton
-
-/*!
- * \brief atexit() handler
- */
-void cleanupHandler(void);
+Console    &getConsole();
+Game       &getGame();
+Menu       &getMenu();
+OpenRaider &getOpenRaider();
+Window     &getWindow();
 
 /*!
  * \brief Program entry point

src/Camera.cpp

             break;
         case CAMERA_ROTATE_UP:
             if (mTheta2 < (M_PI / 2)) {
-                mTheta2 += gOpenRaider->mCameraRotationDeltaY;
+                mTheta2 += getOpenRaider().mCameraRotationDeltaY;
                 rotate(mTheta2, 1.0f, 0.0f, 0.0f);
             }
             break;
         case CAMERA_ROTATE_DOWN:
             if (mTheta2 > -(M_PI / 2)) {
-                mTheta2 -= gOpenRaider->mCameraRotationDeltaY;
+                mTheta2 -= getOpenRaider().mCameraRotationDeltaY;
                 rotate(mTheta2, 1.0f, 0.0f, 0.0f);
             }
             break;
         case CAMERA_ROTATE_RIGHT:
-            mTheta += gOpenRaider->mCameraRotationDeltaX;
+            mTheta += getOpenRaider().mCameraRotationDeltaX;
             rotate(mTheta, 0.0f, 1.0f, 0.0f);
             break;
         case CAMERA_ROTATE_LEFT:
-            mTheta -= gOpenRaider->mCameraRotationDeltaX;
+            mTheta -= getOpenRaider().mCameraRotationDeltaX;
             rotate(mTheta, 0.0f, 1.0f, 0.0f);
             break;
         case CAMERA_MOVE_UP:

src/Console.cpp

 
 void Console::setVisible(bool visible) {
     mVisible = visible;
-    gOpenRaider->mWindow->setTextInput(mVisible);
+    getWindow().setTextInput(mVisible);
 }
 
 bool Console::isVisible() {
 }
 
 #define LINE_GEOMETRY(window) unsigned int firstLine = 35; \
-        unsigned int lastLine = (window->mHeight / 2) - 55; \
-        unsigned int inputLine = (window->mHeight / 2) - 30; \
+        unsigned int lastLine = (window.mHeight / 2) - 55; \
+        unsigned int inputLine = (window.mHeight / 2) - 30; \
         unsigned int lineSteps = 20; \
         unsigned int lineCount = (lastLine - firstLine + lineSteps) / lineSteps; \
         while (((lineCount * lineSteps) + firstLine) < inputLine) { \
         }
 
 void Console::display() {
-    Window *window = gOpenRaider->mWindow;
-
     if (mVisible) {
         // Calculate line drawing geometry
         // Depends on window height, so recalculate every time
-        LINE_GEOMETRY(window);
+        LINE_GEOMETRY(getWindow());
 
         // Draw half-transparent *overlay*
         glColor4f(0.0f, 0.0f, 0.0f, 0.75f);
         glDisable(GL_TEXTURE_2D);
-        glRecti(0, 0, window->mWidth, window->mHeight / 2);
+        glRecti(0, 0, getWindow().mWidth, getWindow().mHeight / 2);
         glEnable(GL_TEXTURE_2D);
 
         int scrollIndicator;
             scrollIndicator = 100;
         }
 
-        gOpenRaider->mWindow->drawText(10, 10, 0.70f, OR_BLUE,
+        getWindow().drawText(10, 10, 0.70f, OR_BLUE,
                 "%s uptime %lus scroll %d%%", VERSION, systemTimerGet() / 1000, scrollIndicator);
 
         // Draw output log
             historyOffset = mHistory.size() - lineCount;
         }
         for (int i = 0; i < end; i++) {
-            gOpenRaider->mWindow->drawText(10, ((i + drawOffset) * lineSteps) + firstLine,
+            getWindow().drawText(10, ((i + drawOffset) * lineSteps) + firstLine,
                     0.75f, OR_BLUE, "%s", mHistory[i + historyOffset - mLineOffset]);
         }
 
         // Draw current input
         if ((mInputBufferPointer > 0) && (mInputBuffer[0] != '\0')) {
-            gOpenRaider->mWindow->drawText(10, inputLine, 0.75f, OR_BLUE, "> %s", mInputBuffer);
+            getWindow().drawText(10, inputLine, 0.75f, OR_BLUE, "> %s", mInputBuffer);
         } else {
-            gOpenRaider->mWindow->drawText(10, inputLine, 0.75f, OR_BLUE, ">");
+            getWindow().drawText(10, inputLine, 0.75f, OR_BLUE, ">");
         }
 
         //! \todo display the current mPartialInput. The UTF-8 segfaults SDL-TTF, somehow?
         if ((mInputBufferPointer > 0) && (mInputBuffer[0] != '\0')) {
             mHistory.push_back(bufferString("> %s", mInputBuffer));
             mCommandHistory.push_back(bufferString("%s", mInputBuffer));
-            int error = gOpenRaider->command(mInputBuffer);
+            int error = getOpenRaider().command(mInputBuffer);
             if (error != 0) {
                 print("Error Code: %d", error);
             }
 }
 
 void Console::handleMouseScroll(int xrel, int yrel) {
-    LINE_GEOMETRY(gOpenRaider->mWindow);
+    LINE_GEOMETRY(getWindow());
 
     if (mHistory.size() > lineCount) {
         if (yrel > 0) {

src/Game.cpp

 
     // Set up Renderer
     mRender = new Render();
-    mRender->initTextures(gOpenRaider->mDataDir, &mTextureStart, &mTextureLevelOffset);
+    mRender->initTextures(getOpenRaider().mDataDir, &mTextureStart, &mTextureLevelOffset);
 
     // Enable Renderer
     mRender->setMode(Render::modeLoadScreen);
 
     mWorld.destroy();
     mRender->ClearWorld();
-    gOpenRaider->mSound->clear(); // Remove all previously loaded sounds
+    getOpenRaider().mSound->clear(); // Remove all previously loaded sounds
 }
 
 int Game::loadLevel(const char *level) {
     mName = bufferString("%s", level);
 
     // Load the level pak into TombRaider
-    gOpenRaider->mConsole->print("Loading %s", mName);
+    getConsole().print("Loading %s", mName);
     int error = mTombRaider.Load(mName);
     if (error != 0) {
         return error;
         tmp[dir + 8] = '\0';
         error = mTombRaider.loadSFX(tmp);
         if (error != 0) {
-            gOpenRaider->mConsole->print("Could not load %s", tmp);
+            getConsole().print("Could not load %s", tmp);
         }
         delete [] tmp;
     }
 
     // Check if the level contains Lara
     if (mLara == NULL) {
-        gOpenRaider->mConsole->print("Can't find Lara entity in level pak!");
+        getConsole().print("Can't find Lara entity in level pak!");
         return -1;
     }
 
 
 int Game::command(std::vector<char *> *args) {
     if (args->size() < 1) {
-        gOpenRaider->mConsole->print("Invalid use of game-command!");
+        getConsole().print("Invalid use of game-command!");
         return -1;
     }
 
             if (strcmp(mode, "wireframe") == 0) {
                 if (mLoaded) {
                     mRender->setMode(Render::modeWireframe);
-                    gOpenRaider->mConsole->print("Wireframe mode");
+                    getConsole().print("Wireframe mode");
                 } else {
-                    gOpenRaider->mConsole->print("Load a level to set this mode!");
+                    getConsole().print("Load a level to set this mode!");
                     return -2;
                 }
             } else if (strcmp(mode, "solid") == 0) {
                 if (mLoaded) {
                     mRender->setMode(Render::modeSolid);
-                    gOpenRaider->mConsole->print("Solid mode");
+                    getConsole().print("Solid mode");
                 } else {
-                    gOpenRaider->mConsole->print("Load a level to set this mode!");
+                    getConsole().print("Load a level to set this mode!");
                     return -3;
                 }
             } else if (strcmp(mode, "texture") == 0) {
                 if (mLoaded) {
                     mRender->setMode(Render::modeTexture);
-                    gOpenRaider->mConsole->print("Texture mode");
+                    getConsole().print("Texture mode");
                 } else {
-                    gOpenRaider->mConsole->print("Load a level to set this mode!");
+                    getConsole().print("Load a level to set this mode!");
                     return -4;
                 }
             } else if (strcmp(mode, "vertexlight") == 0) {
                 if (mLoaded) {
                     mRender->setMode(Render::modeVertexLight);
-                    gOpenRaider->mConsole->print("Vertexlight mode");
+                    getConsole().print("Vertexlight mode");
                 } else {
-                    gOpenRaider->mConsole->print("Load a level to set this mode!");
+                    getConsole().print("Load a level to set this mode!");
                     return -5;
                 }
             } else if (strcmp(mode, "titlescreen") == 0) {
                 mRender->setMode(Render::modeLoadScreen);
-                gOpenRaider->mConsole->print("Titlescreen mode");
+                getConsole().print("Titlescreen mode");
             } else {
-                gOpenRaider->mConsole->print("Invalid use of mode command (%s)!", mode);
+                getConsole().print("Invalid use of mode command (%s)!", mode);
                 return -6;
             }
         } else {
-            gOpenRaider->mConsole->print("Invalid use of mode command!");
+            getConsole().print("Invalid use of mode command!");
             return -7;
         }
     } else if (strcmp(cmd, "move") == 0) {
                 char *move = args->at(1);
                 if (strcmp(move, "walk") == 0) {
                     mLara->moveType = worldMoveType_walk;
-                    gOpenRaider->mConsole->print("Lara is walking...");
+                    getConsole().print("Lara is walking...");
                 } else if (strcmp(move, "fly") == 0) {
                     mLara->moveType = worldMoveType_fly;
-                    gOpenRaider->mConsole->print("Lara is flying...");
+                    getConsole().print("Lara is flying...");
                 } else if (strcmp(move, "noclip") == 0) {
                     mLara->moveType = worldMoveType_noClipping;
-                    gOpenRaider->mConsole->print("Lara is noclipping...");
+                    getConsole().print("Lara is noclipping...");
                 } else {
-                    gOpenRaider->mConsole->print("Invalid use of move command (%s)!", move);
+                    getConsole().print("Invalid use of move command (%s)!", move);
                     return -8;
                 }
             } else {
-                gOpenRaider->mConsole->print("Load a level to change the movement type!");
+                getConsole().print("Load a level to change the movement type!");
                 return -9;
             }
         } else {
-            gOpenRaider->mConsole->print("Invalid use of move command!");
+            getConsole().print("Invalid use of move command!");
             return -10;
         }
     } else if (strcmp(cmd, "sound") == 0) {
         if (args->size() > 1) {
-            gOpenRaider->mSound->play(atoi(args->at(1)));
+            getOpenRaider().mSound->play(atoi(args->at(1)));
         } else {
-            gOpenRaider->mConsole->print("Invalid use of sound command!");
+            getConsole().print("Invalid use of sound command!");
             return -11;
         }
     } else if (strcmp(cmd, "animate") == 0) {
                                 m->setAnimation(0);
                     }
                 } else {
-                    gOpenRaider->mConsole->print("Animations need to be enabled!");
+                    getConsole().print("Animations need to be enabled!");
                 }
             } else if (c == 'p') {
                 // Step all skeletal models to their previous animation
                                 m->setAnimation(m->model->animation.size() - 1);
                     }
                 } else {
-                    gOpenRaider->mConsole->print("Animations need to be enabled!");
+                    getConsole().print("Animations need to be enabled!");
                 }
             } else {
                 // Enable or disable animating all skeletal models
                 bool b;
                 if (readBool(args->at(1), &b) < 0) {
-                    gOpenRaider->mConsole->print("Pass BOOL to animate command!");
+                    getConsole().print("Pass BOOL to animate command!");
                     return -12;
                 }
                 if (b)
                     mRender->setFlags(Render::fAnimateAllModels);
                 else
                     mRender->clearFlags(Render::fAnimateAllModels);
-                gOpenRaider->mConsole->print(b ? "Animating all models" : "No longer animating all models");
+                getConsole().print(b ? "Animating all models" : "No longer animating all models");
             }
         } else {
-            gOpenRaider->mConsole->print("Invalid use of animate command!");
+            getConsole().print("Invalid use of animate command!");
             return -13;
         }
     } else if (strcmp(cmd, "help") == 0) {
         if (args->size() < 2) {
-            gOpenRaider->mConsole->print("game-command Usage:");
-            gOpenRaider->mConsole->print("  game COMMAND");
-            gOpenRaider->mConsole->print("Available commands:");
-            gOpenRaider->mConsole->print("  move [walk|fly|noclip]");
-            gOpenRaider->mConsole->print("  sound INT");
-            gOpenRaider->mConsole->print("  mode MODE");
-            gOpenRaider->mConsole->print("  animate [BOOL|n|p]");
+            getConsole().print("game-command Usage:");
+            getConsole().print("  game COMMAND");
+            getConsole().print("Available commands:");
+            getConsole().print("  move [walk|fly|noclip]");
+            getConsole().print("  sound INT");
+            getConsole().print("  mode MODE");
+            getConsole().print("  animate [BOOL|n|p]");
         } else if (strcmp(args->at(1), "sound") == 0) {
-            gOpenRaider->mConsole->print("game-sound-command Usage:");
-            gOpenRaider->mConsole->print("  game sound INT");
-            gOpenRaider->mConsole->print("Where INT is a valid sound ID integer");
+            getConsole().print("game-sound-command Usage:");
+            getConsole().print("  game sound INT");
+            getConsole().print("Where INT is a valid sound ID integer");
         } else if (strcmp(args->at(1), "move") == 0) {
-            gOpenRaider->mConsole->print("game-move-command Usage:");
-            gOpenRaider->mConsole->print("  game move COMMAND");
-            gOpenRaider->mConsole->print("Where COMMAND is one of the following:");
-            gOpenRaider->mConsole->print("  walk");
-            gOpenRaider->mConsole->print("  fly");
-            gOpenRaider->mConsole->print("  noclip");
+            getConsole().print("game-move-command Usage:");
+            getConsole().print("  game move COMMAND");
+            getConsole().print("Where COMMAND is one of the following:");
+            getConsole().print("  walk");
+            getConsole().print("  fly");
+            getConsole().print("  noclip");
         } else if (strcmp(args->at(1), "mode") == 0) {
-            gOpenRaider->mConsole->print("game-mode-command Usage:");
-            gOpenRaider->mConsole->print("  game mode MODE");
-            gOpenRaider->mConsole->print("Where MODE is one of the following:");
-            gOpenRaider->mConsole->print("  wireframe");
-            gOpenRaider->mConsole->print("  solid");
-            gOpenRaider->mConsole->print("  texture");
-            gOpenRaider->mConsole->print("  vertexlight");
-            gOpenRaider->mConsole->print("  titlescreen");
+            getConsole().print("game-mode-command Usage:");
+            getConsole().print("  game mode MODE");
+            getConsole().print("Where MODE is one of the following:");
+            getConsole().print("  wireframe");
+            getConsole().print("  solid");
+            getConsole().print("  texture");
+            getConsole().print("  vertexlight");
+            getConsole().print("  titlescreen");
         } else if (strcmp(args->at(1), "animate") == 0) {
-            gOpenRaider->mConsole->print("game-animate-command Usage:");
-            gOpenRaider->mConsole->print("  game animate [n|p|BOOL]");
-            gOpenRaider->mConsole->print("Where the commands have the following meaning:");
-            gOpenRaider->mConsole->print("  BOOL to (de)activate animating all models");
-            gOpenRaider->mConsole->print("  n to step all models to their next animation");
-            gOpenRaider->mConsole->print("  p to step all models to their previous animation");
+            getConsole().print("game-animate-command Usage:");
+            getConsole().print("  game animate [n|p|BOOL]");
+            getConsole().print("Where the commands have the following meaning:");
+            getConsole().print("  BOOL to (de)activate animating all models");
+            getConsole().print("  n to step all models to their next animation");
+            getConsole().print("  p to step all models to their previous animation");
         } else {
-            gOpenRaider->mConsole->print("No help available for game %s.", args->at(1));
+            getConsole().print("No help available for game %s.", args->at(1));
             return -14;
         }
     } else {
-        gOpenRaider->mConsole->print("Invalid use of game-command (%s)!", cmd);
+        getConsole().print("Invalid use of game-command (%s)!", cmd);
         return -15;
     }
 
     {
         mTombRaider.getSoundSample(i, &riffSz, &riff);
 
-        gOpenRaider->mSound->addWave(riff, riffSz, &id, gOpenRaider->mSound->SoundFlagsNone);
+        getOpenRaider().mSound->addWave(riff, riffSz, &id, getOpenRaider().mSound->SoundFlagsNone);
 
         //if (((i + 1) == TR_SOUND_F_PISTOL) && (id > 0))
         //{
         //pos[0] = sound[i].x;
         //pos[1] = sound[i].y;
         //pos[2] = sound[i].z;
-        //gOpenRaider->mSound->SourceAt(id, pos);
+        //getOpenRaider().mSound->SourceAt(id, pos);
 
         //printf(".");
         //fflush(stdout);
                     }
 
                     mRender->setFlags(Render::fRenderPonytail);
-                    gOpenRaider->mConsole->print("Found known ponytail");
+                    getConsole().print("Found known ponytail");
                 }
                 break; // ?
             case TR_VERSION_1:
                     r_model->ponyOff2 = 0;
 
                     mRender->setFlags(Render::fRenderPonytail);
-                    gOpenRaider->mConsole->print("Found ponytail?");
+                    getConsole().print("Found ponytail?");
                 }
                 break;
         }
             //   if (frame_offset + 8 > _tombraider.NumFrames())
             if (frame_offset > mTombRaider.NumFrames())
             {
-                gOpenRaider->mConsole->print("WARNING: Bad animation frame %i > %i",
+                getConsole().print("WARNING: Bad animation frame %i > %i",
                         frame_offset, mTombRaider.NumFrames());
 
                 // Mongoose 2002.08.15, Attempt to skip more likely bad animation data
-                gOpenRaider->mConsole->print("WARNING: Handling bad animation data...");
+                getConsole().print("WARNING: Handling bad animation data...");
                 return; //continue;
             }
 
 
         if (!mTombRaider.isRoomValid(index))
         {
-            gOpenRaider->mConsole->print("WARNING: Handling invalid vertex array in room");
+            getConsole().print("WARNING: Handling invalid vertex array in room");
             mWorld.addRoom(0x0);
             mRender->addRoom(0x0);
 
 
             if (texture > (int)TextureLimit)
             {
-                gOpenRaider->mConsole->print("Handling bad room[%i].tris[%i].texture = %i",
+                getConsole().print("Handling bad room[%i].tris[%i].texture = %i",
                         index, t, texture);
                 texture = TextureLimit - 1;
             }
 
             if (texture > (int)TextureLimit)
             {
-                gOpenRaider->mConsole->print("Handling bad room[%i].quad[%i].texture = %i",
+                getConsole().print("Handling bad room[%i].quad[%i].texture = %i",
                         index, r, texture);
                 texture = TextureLimit - 1;
             }

src/Menu.cpp

 
 void Menu::displayMapList() {
     // Estimate displayable number of items
-    int items = (gOpenRaider->mWindow->mHeight - 110) / 25;
+    int items = (getWindow().mHeight - 110) / 25;
 
     // Select which part of the list to show
     int min, max;
     else
         min = 0;
 
-    if ((mCursor + (items / 2)) < gOpenRaider->mMapList.size())
+    if ((mCursor + (items / 2)) < getOpenRaider().mMapList.size())
         max = mCursor + (items / 2);
     else
-        max = gOpenRaider->mMapList.size();
+        max = getOpenRaider().mMapList.size();
 
     while ((max - min) < items) {
         if (min > 0)
             min--;
-        else if (max < ((int)gOpenRaider->mMapList.size()))
+        else if (max < ((int)getOpenRaider().mMapList.size()))
             max++;
         else
             break;
     mMin = min;
 
     for (int i = 0; i < (max - min); i++) {
-        char *map = gOpenRaider->mMapList[i + min];
+        char *map = getOpenRaider().mMapList[i + min];
         if ((i + min) == (int)mCursor)
-            gOpenRaider->mWindow->drawText(25, 100 + (25 * i), 0.75f, RED, "%s", map);
+            getWindow().drawText(25, 100 + (25 * i), 0.75f, RED, "%s", map);
         else
-            gOpenRaider->mWindow->drawText(25, 100 + (25 * i), 0.75f, OR_BLUE, "%s", map);
+            getWindow().drawText(25, 100 + (25 * i), 0.75f, OR_BLUE, "%s", map);
     }
 }
 
 void Menu::display() {
-    Window *window = gOpenRaider->mWindow;
-
     if (mVisible) {
         // Draw half-transparent *overlay*
         glColor4f(0.0f, 0.0f, 0.0f, 0.75f);
         glDisable(GL_TEXTURE_2D);
-        glRecti(0, 0, window->mWidth, window->mHeight);
+        glRecti(0, 0, getWindow().mWidth, getWindow().mHeight);
         glEnable(GL_TEXTURE_2D);
 
         // Draw heading text
-        mainText.x = (window->mWidth / 2) - (mainText.w / 2);
-        window->writeString(&mainText);
+        mainText.x = (getWindow().mWidth / 2) - (mainText.w / 2);
+        getWindow().writeString(&mainText);
 
-        if (!gOpenRaider->mMapListFilled) {
-            gOpenRaider->mWindow->drawText(25, (window->mHeight / 2) - 20, 0.75f, OR_BLUE, "Generating map list...");
+        if (!getOpenRaider().mMapListFilled) {
+            getWindow().drawText(25, (getWindow().mHeight / 2) - 20, 0.75f, OR_BLUE, "Generating map list...");
         } else {
-            if (gOpenRaider->mMapList.size() == 0) {
-                gOpenRaider->mWindow->drawText(25, (window->mHeight / 2) - 20, 0.75f, RED, "No maps found! See README.md");
+            if (getOpenRaider().mMapList.size() == 0) {
+                getWindow().drawText(25, (getWindow().mHeight / 2) - 20, 0.75f, RED, "No maps found! See README.md");
             } else {
                 // draw *play button* above list
                 glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
                 glDisable(GL_TEXTURE_2D);
                 glRecti(25, 25, 100, 75);
                 glEnable(GL_TEXTURE_2D);
-                gOpenRaider->mWindow->drawText(40, 35, 0.75f, BLACK, "Play");
+                getWindow().drawText(40, 35, 0.75f, BLACK, "Play");
 
                 displayMapList();
             }
         if (mCursor > 0)
             mCursor--;
         else
-            mCursor = gOpenRaider->mMapList.size() - 1;
+            mCursor = getOpenRaider().mMapList.size() - 1;
     } else if (key == down) {
-        if (mCursor < (gOpenRaider->mMapList.size() - 1))
+        if (mCursor < (getOpenRaider().mMapList.size() - 1))
             mCursor++;
         else
             mCursor = 0;
     } else if (key == right) {
         int i = 10;
-        if (mCursor > (gOpenRaider->mMapList.size() - 11))
-            i = gOpenRaider->mMapList.size() - 1 - mCursor;
+        if (mCursor > (getOpenRaider().mMapList.size() - 11))
+            i = getOpenRaider().mMapList.size() - 1 - mCursor;
         while (i-- > 0)
             handleKeyboard(down, true);
     } else if (key == left) {
         while (i-- > 0)
             handleKeyboard(up, true);
     } else if (key == enter) {
-        char *tmp = bufferString("load %s", gOpenRaider->mMapList[mCursor]);
-        if (gOpenRaider->command(tmp) == 0)
+        char *tmp = bufferString("load %s", getOpenRaider().mMapList[mCursor]);
+        if (getOpenRaider().command(tmp) == 0)
             setVisible(false);
         delete [] tmp;
     }
 }
 
 void Menu::handleMouseClick(unsigned int x, unsigned int y, KeyboardButton button, bool released) {
-    int items = (gOpenRaider->mWindow->mHeight - 110) / 25;
+    int items = (getWindow().mHeight - 110) / 25;
 
     if ((!released) || (button != leftmouse))
         return;

src/OpenRaider.cpp

 #include "config.h"
 #include "Console.h"
 #include "Game.h"
+#include "main.h"
 #include "math/math.h"
 #include "Menu.h"
 #include "Sound.h"
 #include "TombRaider.h"
-#include "Window.h"
 #include "utils/strings.h"
 #include "utils/time.h"
 #include "OpenRaider.h"
     mDataDir = NULL;
     mMapListFilled = false;
 
-    mMenu = new Menu();
-    mConsole = new Console();
     mSound = new Sound();
-    mWindow = new WindowSDL();
-    mGame = new Game();
 
     for (int i = 0; i < ActionEventCount; i++)
         keyBindings[i] = unknown;
 }
 
 OpenRaider::~OpenRaider() {
-    if (mGame)
-        delete mGame;
-
-    if (mMenu)
-        delete mMenu;
-
-    if (mConsole)
-        delete mConsole;
-
     if (mSound)
         delete mSound;
 
-    if (mWindow)
-        delete mWindow;
-
     if (mBaseDir)
         delete mBaseDir;
 
     assert(config[0] != '\0');
 
     char *configFile = fullPath(config, 0);
-    mConsole->print("Loading config from \"%s\"...", configFile);
+    getConsole().print("Loading config from \"%s\"...", configFile);
 
     FILE *f = fopen(configFile, "r");
     if (f == NULL) {
-        mConsole->print("Could not open file!");
+        getConsole().print("Could not open file!");
         return -1;
     }
 
     while (fgets(buffer, 256, f) != NULL) {
         int error = command(buffer);
         if (error != 0) {
-            mConsole->print("Error Code: %d", error);
+            getConsole().print("Error Code: %d", error);
         }
     }
 
 
     if (strcmp(command, "set") == 0) {
         if (args->size() != 2) {
-            mConsole->print("Invalid use of set-command");
+            getConsole().print("Invalid use of set-command");
             return -2;
         } else {
             return set(args->at(0), args->at(1));
         }
     } else if (strcmp(command, "bind") == 0) {
         if (args->size() != 2) {
-            mConsole->print("Invalid use of bind-command");
+            getConsole().print("Invalid use of bind-command");
             return -3;
         } else {
             return bind(args->at(0), args->at(1));
         exit(0);
     } else if (strcmp(command, "help") == 0) {
         if (args->size() == 0) {
-            mConsole->print("Available commands:");
-            mConsole->print("  load - load a level");
-            mConsole->print("  set  - set a parameter");
-            mConsole->print("  bind - bind a keyboard/mouse action");
-            mConsole->print("  game - send a command to the game engine");
-            mConsole->print("  help - print command help");
-            mConsole->print("  quit - exit OpenRaider");
-            mConsole->print("Use help COMMAND to get additional info");
+            getConsole().print("Available commands:");
+            getConsole().print("  load - load a level");
+            getConsole().print("  set  - set a parameter");
+            getConsole().print("  bind - bind a keyboard/mouse action");
+            getConsole().print("  game - send a command to the game engine");
+            getConsole().print("  help - print command help");
+            getConsole().print("  quit - exit OpenRaider");
+            getConsole().print("Use help COMMAND to get additional info");
         } else if (args->size() == 1) {
             return help(args->at(0));
         } else {
-            mConsole->print("Invalid use of help-command");
+            getConsole().print("Invalid use of help-command");
             return -4;
         }
     } else if (strcmp(command, "load") == 0) {
         char *tmp = bufferString("%s/%s", mPakDir, args->at(0));
-        int error = mGame->loadLevel(tmp);
+        int error = getGame().loadLevel(tmp);
         delete [] tmp;
         return error;
     } else if (strcmp(command, "game") == 0) {
-        return mGame->command(args);
+        return getGame().command(args);
     } else {
-        mConsole->print("Unknown command: %s ", command);
+        getConsole().print("Unknown command: %s ", command);
         return -1;
     }
 
     assert(cmd[0] != '\0');
 
     if (strcmp(cmd, "set") == 0) {
-        mConsole->print("set-Command Usage:");
-        mConsole->print("  set VAR VAL");
-        mConsole->print("Available Variables:");
-        mConsole->print("  basedir     STRING");
-        mConsole->print("  pakdir      STRING");
-        mConsole->print("  audiodir    STRING");
-        mConsole->print("  datadir     STRING");
-        mConsole->print("  font        STRING");
-        mConsole->print("  gldriver    STRING");
-        mConsole->print("  size        \"INTxINT\"");
-        mConsole->print("  fullscreen  BOOL");
-        mConsole->print("  audio       BOOL");
-        mConsole->print("  volume      BOOL");
-        mConsole->print("  mouse_x     FLOAT");
-        mConsole->print("  mouse_y     FLOAT");
-        mConsole->print("  fps         BOOL");
-        mConsole->print("Enclose STRINGs with \"\"!");
-        mConsole->print("size expects a STRING in the specified format");
+        getConsole().print("set-Command Usage:");
+        getConsole().print("  set VAR VAL");
+        getConsole().print("Available Variables:");
+        getConsole().print("  basedir     STRING");
+        getConsole().print("  pakdir      STRING");
+        getConsole().print("  audiodir    STRING");
+        getConsole().print("  datadir     STRING");
+        getConsole().print("  font        STRING");
+        getConsole().print("  gldriver    STRING");
+        getConsole().print("  size        \"INTxINT\"");
+        getConsole().print("  fullscreen  BOOL");
+        getConsole().print("  audio       BOOL");
+        getConsole().print("  volume      BOOL");
+        getConsole().print("  mouse_x     FLOAT");
+        getConsole().print("  mouse_y     FLOAT");
+        getConsole().print("  fps         BOOL");
+        getConsole().print("Enclose STRINGs with \"\"!");
+        getConsole().print("size expects a STRING in the specified format");
     } else if (strcmp(cmd, "bind") == 0) {
-        mConsole->print("bind-Command Usage:");
-        mConsole->print("  bind ACTION KEY");
-        mConsole->print("Available Actions:");
-        mConsole->print("  menu");
-        mConsole->print("  console");
-        mConsole->print("  forward");
-        mConsole->print("  backward");
-        mConsole->print("  left");
-        mConsole->print("  right");
-        mConsole->print("  jump");
-        mConsole->print("  crouch");
-        mConsole->print("  use");
-        mConsole->print("  holster");
-        mConsole->print("Key-Format:");
-        mConsole->print("  'a' or '1'    for character/number keys");
-        mConsole->print("  \"leftctrl\"  for symbols and special keys");
+        getConsole().print("bind-Command Usage:");
+        getConsole().print("  bind ACTION KEY");
+        getConsole().print("Available Actions:");
+        getConsole().print("  menu");
+        getConsole().print("  console");
+        getConsole().print("  forward");
+        getConsole().print("  backward");
+        getConsole().print("  left");
+        getConsole().print("  right");
+        getConsole().print("  jump");
+        getConsole().print("  crouch");
+        getConsole().print("  use");
+        getConsole().print("  holster");
+        getConsole().print("Key-Format:");
+        getConsole().print("  'a' or '1'    for character/number keys");
+        getConsole().print("  \"leftctrl\"  for symbols and special keys");
     } else if (strcmp(cmd, "load") == 0) {
-        mConsole->print("load-Command Usage:");
-        mConsole->print("  load levelfile.name");
+        getConsole().print("load-Command Usage:");
+        getConsole().print("  load levelfile.name");
     } else if (strcmp(cmd, "game") == 0) {
-        mConsole->print("Use \"game help\" for more info");
+        getConsole().print("Use \"game help\" for more info");
     } else {
-        mConsole->print("No help available for %s", cmd);
+        getConsole().print("No help available for %s", cmd);
         return -1;
     }
 
         // value has format like "\"1024x768\""
         unsigned int w = DEFAULT_WIDTH, h = DEFAULT_HEIGHT;
         if (sscanf(value, "\"%dx%d\"", &w, &h) != 2) {
-            mConsole->print("set-size-Error: Invalid value (%s)", value);
+            getConsole().print("set-size-Error: Invalid value (%s)", value);
             return -2;
         }
-        mWindow->setSize(w, h);
+        getWindow().setSize(w, h);
     } else if (strcmp(var, "fullscreen") == 0) {
         bool fullscreen = false;
         if (readBool(value, &fullscreen) != 0) {
-            mConsole->print("set-fullscreen-Error: Invalid value (%s)", value);
+            getConsole().print("set-fullscreen-Error: Invalid value (%s)", value);
             return -3;
         }
-        mWindow->setFullscreen(fullscreen);
+        getWindow().setFullscreen(fullscreen);
     } else if (strcmp(var, "gldriver") == 0) {
-        mWindow->setDriver(value);
+        getWindow().setDriver(value);
     } else if (strcmp(var, "audio") == 0) {
         bool audio = false;
         if (readBool(value, &audio) != 0) {
-            mConsole->print("set-audio-Error: Invalid value (%s)", value);
+            getConsole().print("set-audio-Error: Invalid value (%s)", value);
             return -4;
         }
         mSound->setEnabled(audio);
     } else if (strcmp(var, "volume") == 0) {
         float vol = 1.0f;
         if (sscanf(value, "%f", &vol) != 1) {
-            mConsole->print("set-volume-Error: Invalid value (%s)", value);
+            getConsole().print("set-volume-Error: Invalid value (%s)", value);
             return -5;
         }
         mSound->setVolume(vol);
     } else if (strcmp(var, "mouse_x") == 0) {
         float sense = 1.0f;
         if (sscanf(value, "%f", &sense) != 1) {
-            mConsole->print("set-mouse_x-Error: Invalid value (%s)", value);
+            getConsole().print("set-mouse_x-Error: Invalid value (%s)", value);
             return -6;
         }
         mCameraRotationDeltaX = OR_DEG_TO_RAD(sense);
     } else if (strcmp(var, "mouse_y") == 0) {
         float sense = 1.0f;
         if (sscanf(value, "%f", &sense) != 1) {
-            mConsole->print("set-mouse_y-Error: Invalid value (%s)", value);
+            getConsole().print("set-mouse_y-Error: Invalid value (%s)", value);
             return -7;
         }
         mCameraRotationDeltaY = OR_DEG_TO_RAD(sense);
     } else if (strcmp(var, "fps") == 0) {
         bool fps = false;
         if (readBool(value, &fps) != 0) {
-            mConsole->print("set-fps-Error: Invalid value (%s)", value);
+            getConsole().print("set-fps-Error: Invalid value (%s)", value);
             return -8;
         }
         mFPS = fps;
         char *quotes = stringReplace(value, "\"", "");
         char *tmp = expandDirectoryNames(quotes);
         if (tmp == NULL) {
-            mWindow->setFont(quotes);
+            getWindow().setFont(quotes);
         } else {
-            mWindow->setFont(tmp);
+            getWindow().setFont(tmp);
             delete [] tmp;
         }
         delete [] quotes;
     } else {
-        mConsole->print("set-Error: Unknown variable (%s = %s)", var, value);
+        getConsole().print("set-Error: Unknown variable (%s = %s)", var, value);
         return -1;
     }
 
     } else if (strcmp(tmp, "holster") == 0) {
         return bind(holsterAction, key);
     } else {
-        mConsole->print("bind-Error: Unknown action (%s --> %s)", key, action);
+        getConsole().print("bind-Error: Unknown action (%s --> %s)", key, action);
         return -1;
     }
 }
             || ((c >= 'a') && (c <= 'z'))) {
             keyBindings[action] = (KeyboardButton)c;
         } else {
-            mConsole->print("bind-\'\'-Error: Unknown key (%s)", key);
+            getConsole().print("bind-\'\'-Error: Unknown key (%s)", key);
             return -1;
         }
     } else if ((key[0] == '\"') && (key[length - 1] == '\"')) {
         } else if (strcmp(tmp, "rightmouse") == 0) {
             keyBindings[action] = rightmouse;
         } else {
-            mConsole->print("bind-\"\"-Error: Unknown key (%s)", key);
+            getConsole().print("bind-\"\"-Error: Unknown key (%s)", key);
             delete [] tmp;
             return -2;
         }
         delete [] tmp;
     } else {
-        mConsole->print("bind-Error: Unknown key (%s)", key);
+        getConsole().print("bind-Error: Unknown key (%s)", key);
         return -3;
     }
     return 0;
                         // Just load relative filename
                         mMapList.push_back(bufferString("%s", (fullPathMap + strlen(mPakDir) + 1)));
                     } else {
-                        mConsole->print("Error: pak file '%s' %s",
+                        getConsole().print("Error: pak file '%s' %s",
                                 fullPathMap, (error == -1) ? "not found" : "invalid");
                     }
                 }
         }
         closedir(pakDir);
     } else {
-        mConsole->print("Could not open PAK dir %s!", dir);
+        getConsole().print("Could not open PAK dir %s!", dir);
     }
 }
 
     assert(mInit == false);
     assert(mRunning == false);
 
-    // Initialize Windowing
-    if (mWindow->initialize() != 0)
-        return -1;
-
-    // Initialize OpenGL
-    if (mWindow->initializeGL() != 0)
-        return -2;
-
-    // Initialize window font
-    if (mWindow->initializeFont() != 0)
-        return -3;
-
     // Initialize sound
     if (mSound->initialize() != 0)
-        return -4;
-
-    // Initialize game engine
-    if (mGame->initialize() != 0)
-        return -5;
-
-    mMenu->setVisible(true);
+        return -1;
 
     mInit = true;
 
         clock_t startTime = systemTimerGet();
 
         // Get keyboard and mouse input
-        mWindow->eventHandling();
+        getWindow().eventHandling();
 
         // Clear screen
         glClearColor(0.00f, 0.00f, 0.00f, 1.0f);
         glClear(GL_COLOR_BUFFER_BIT);
 
         // Draw game scene
-        mGame->display();
+        getGame().display();
 
         // Draw 2D overlays (console and menu)
-        mWindow->glEnter2D();
+        getWindow().glEnter2D();
 
-        mConsole->display();
-        mMenu->display();
+        getConsole().display();
+        getMenu().display();
 
         // Draw FPS counter
         if (mFPS)
-            mWindow->drawText(10, mWindow->mHeight - 20, 0.5f, OR_BLUE, "%dFPS", fps);
+            getWindow().drawText(10, getWindow().mHeight - 20, 0.5f, OR_BLUE, "%dFPS", fps);
 
-        mWindow->glExit2D();
+        getWindow().glExit2D();
 
         // Put new frame on screen
-        mWindow->swapBuffersGL();
+        getWindow().swapBuffersGL();
 
         // Fill map list after first render pass,
         // so menu *loading screen* is visible
     assert(mRunning == true);
 
     if ((keyBindings[menuAction] == key) && pressed) {
-        mMenu->setVisible(!mMenu->isVisible());
-    } else if (!mMenu->isVisible()) {
+        getMenu().setVisible(!getMenu().isVisible());
+    } else if (!getMenu().isVisible()) {
         if ((keyBindings[consoleAction] == key) && pressed) {
-            mConsole->setVisible(!mConsole->isVisible());
-        } else if (!mConsole->isVisible()) {
+            getConsole().setVisible(!getConsole().isVisible());
+        } else if (!getConsole().isVisible()) {
             for (int i = forwardAction; i < ActionEventCount; i++) {
                 if (keyBindings[i] == key) {
-                    mGame->handleAction((ActionEvents)i, pressed);
+                    getGame().handleAction((ActionEvents)i, pressed);
                 }
             }
         } else {
-            mConsole->handleKeyboard(key, pressed);
+            getConsole().handleKeyboard(key, pressed);
         }
     } else {
-        mMenu->handleKeyboard(key, pressed);
+        getMenu().handleKeyboard(key, pressed);
     }
 
-    mWindow->setMousegrab(!(mMenu->isVisible() || mConsole->isVisible()));
+    getWindow().setMousegrab(!(getMenu().isVisible() || getConsole().isVisible()));
 }
 
 void OpenRaider::handleText(char *text, bool notFinished) {
     assert(mInit == true);
     assert(mRunning == true);
 
-    if ((mConsole->isVisible()) && (!mMenu->isVisible())) {
-        mConsole->handleText(text, notFinished);
+    if ((getConsole().isVisible()) && (!getMenu().isVisible())) {
+        getConsole().handleText(text, notFinished);
     }
 }
 
     assert(mInit == true);
     assert(mRunning == true);
 
-    if (mMenu->isVisible()) {
-        mMenu->handleMouseClick(x, y, button, released);
-    } else if (!mConsole->isVisible()) {
+    if (getMenu().isVisible()) {
+        getMenu().handleMouseClick(x, y, button, released);
+    } else if (!getConsole().isVisible()) {
         for (int i = forwardAction; i < ActionEventCount; i++) {
             if (keyBindings[i] == button) {
-                mGame->handleAction((ActionEvents)i, !released);
+                getGame().handleAction((ActionEvents)i, !released);
             }
         }
     }
     assert(mInit == true);
     assert(mRunning == true);
 
-    if ((!mConsole->isVisible()) && (!mMenu->isVisible())) {
-        mGame->handleMouseMotion(xrel, yrel);
+    if ((!getConsole().isVisible()) && (!getMenu().isVisible())) {
+        getGame().handleMouseMotion(xrel, yrel);
     }
 }
 
     assert(mInit == true);
     assert(mRunning == true);
 
-    if ((mConsole->isVisible()) && (!mMenu->isVisible())) {
-        mConsole->handleMouseScroll(xrel, yrel);
+    if ((getConsole().isVisible()) && (!getMenu().isVisible())) {
+        getConsole().handleMouseScroll(xrel, yrel);
     }
 }
 

src/Render.cpp

     if (!a || !b)
         return false; // error really
 
-    distA = gOpenRaider->mGame->mRender->mViewVolume.getDistToSphereFromNear(a->pos[0],
+    distA = getGame().mRender->mViewVolume.getDistToSphereFromNear(a->pos[0],
             a->pos[1],
             a->pos[2],
             1.0f);
-    distB = gOpenRaider->mGame->mRender->mViewVolume.getDistToSphereFromNear(b->pos[0],
+    distB = getGame().mRender->mViewVolume.getDistToSphereFromNear(b->pos[0],
             b->pos[1],
             b->pos[2],
             1.0f);
     if (!a || !b)
         return false; // error really
 
-    distA = gOpenRaider->mGame->mRender->mViewVolume.getDistToSphereFromNear(a->pos[0],
+    distA = getGame().mRender->mViewVolume.getDistToSphereFromNear(a->pos[0],
             a->pos[1],
             a->pos[2],
             128.0f);
-    distB = gOpenRaider->mGame->mRender->mViewVolume.getDistToSphereFromNear(b->pos[0],
+    distB = getGame().mRender->mViewVolume.getDistToSphereFromNear(b->pos[0],
             b->pos[1],
             b->pos[2],
             128.0f);
 
 void Render::screenShot(char *filenameBase)
 {
-    mTexture.glScreenShot(filenameBase, gOpenRaider->mWindow->mWidth, gOpenRaider->mWindow->mHeight);
+    mTexture.glScreenShot(filenameBase, getWindow().mWidth, getWindow().mHeight);
 }
 
 unsigned int Render::getFlags() {
 
 void Render::ClearWorld()
 {
-    gOpenRaider->mGame->mLara = NULL;
+    getGame().mLara = NULL;
 
     mRoomRenderList.clear();
 
 
     index = -1;
 
-    if (gOpenRaider->mGame->mLara)
+    if (getGame().mLara)
     {
         float yaw;
         int sector;
         float camOffsetH = 0.0f;
 
 
-        switch (gOpenRaider->mGame->mLara->moveType)
+        switch (getGame().mLara->moveType)
         {
             case worldMoveType_fly:
             case worldMoveType_noClipping:
                 break;
         }
 
-        curPos[0] = gOpenRaider->mGame->mLara->pos[0];
-        curPos[1] = gOpenRaider->mGame->mLara->pos[1];
-        curPos[2] = gOpenRaider->mGame->mLara->pos[2];
-        yaw = gOpenRaider->mGame->mLara->angles[1];
+        curPos[0] = getGame().mLara->pos[0];
+        curPos[1] = getGame().mLara->pos[1];
+        curPos[2] = getGame().mLara->pos[2];
+        yaw = getGame().mLara->angles[1];
 
-        index = gOpenRaider->mGame->mLara->room;
+        index = getGame().mLara->room;
 
         // Mongoose 2002.08.24, New 3rd person camera hack
         camPos[0] = curPos[0];
         camPos[0] -= (1024.0f * sinf(yaw));
         camPos[2] -= (1024.0f * cosf(yaw));
 
-        sector = gOpenRaider->mGame->mWorld.getSector(index, camPos[0], camPos[2]);
+        sector = getGame().mWorld.getSector(index, camPos[0], camPos[2]);
 
         // Handle camera out of world
-        if (sector < 0 || gOpenRaider->mGame->mWorld.isWall(index, sector))
+        if (sector < 0 || getGame().mWorld.isWall(index, sector))
         {
             camPos[0] = curPos[0] + (64.0f * sinf(yaw));
             camPos[1] -= 64.0f;
             camPos[2] = curPos[2] + (64.0f * cosf(yaw));
         }
 
-        gOpenRaider->mGame->mCamera->setPosition(camPos);
+        getGame().mCamera->setPosition(camPos);
     }
 
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     glLoadIdentity();
 
     // Setup view in OpenGL with camera
-    gOpenRaider->mGame->mCamera->update();
-    gOpenRaider->mGame->mCamera->getPosition(camPos);
-    gOpenRaider->mGame->mCamera->getTarget(atPos);
+    getGame().mCamera->update();
+    getGame().mCamera->getPosition(camPos);
+    getGame().mCamera->getTarget(atPos);
     // Mongoose 2002.08.13, Quick fix to render OpenRaider upside down
 
     gluLookAt(camPos[0], camPos[1], camPos[2], atPos[0], atPos[1], atPos[2], 0.0f, -1.0f, 0.0f);
     updateViewVolume();
 
     // Let's see the LoS -- should be event controled
-    if (gOpenRaider->mGame->mLara)
+    if (getGame().mLara)
     {
-        //      SkeletalModel *mdl = (SkeletalModel *)gOpenRaider->mGame->mLara->tmpHook;
+        //      SkeletalModel *mdl = (SkeletalModel *)getGame().mLara->tmpHook;
 
         // Draw in solid colors
         glDisable(GL_TEXTURE_2D);
         glDisable(GL_CULL_FACE);
 
-        if (gOpenRaider->mGame->mLara->state == 64) // eWeaponFire
+        if (getGame().mLara->state == 64) // eWeaponFire
         {
             vec3_t u, v; //, s, t;
 
-            // Center of gOpenRaider->mGame->mLara
+            // Center of getGame().mLara
             u[0] = curPos[0];
             u[1] = curPos[1] - 512.0f;
             u[2] = curPos[2];
 
-            // Location gOpenRaider->mGame->mLara is aiming at?  ( Not finished yet )
-            v[0] = u[0] + (9000.0f * sinf(gOpenRaider->mGame->mLara->angles[1]));
-            v[1] = u[1] + (9000.0f * sinf(gOpenRaider->mGame->mLara->angles[2]));
-            v[2] = u[2] + (9000.0f * cosf(gOpenRaider->mGame->mLara->angles[1]));
+            // Location getGame().mLara is aiming at?  ( Not finished yet )
+            v[0] = u[0] + (9000.0f * sinf(getGame().mLara->angles[1]));
+            v[1] = u[1] + (9000.0f * sinf(getGame().mLara->angles[2]));
+            v[2] = u[2] + (9000.0f * cosf(getGame().mLara->angles[1]));
 
             // Test tracing of aim
             renderTrace(0, u, v); // v = target
         }
 
-        entity_t *route = gOpenRaider->mGame->mLara->master;
+        entity_t *route = getGame().mLara->master;
 
         while (route)
         {
     {
         entity_t *e;
         std::vector<entity_t *> entityRenderList;
-        std::vector<entity_t *> *entities = gOpenRaider->mGame->mWorld.getEntities();
+        std::vector<entity_t *> *entities = getGame().mWorld.getEntities();
 
         for (unsigned int i = 0; i < entities->size(); i++)
         {
             e = entities->at(i);
 
             // Mongoose 2002.03.26, Don't show lara to it's own player
-            if (!e || e == gOpenRaider->mGame->mLara)
+            if (!e || e == getGame().mLara)
             {
                 continue;
             }
     float x = 0.0f, y = 0.0f, z = -160.0f;
     float w, h;
 
-    if (gOpenRaider->mWindow->mWidth < gOpenRaider->mWindow->mHeight)
-        w = h = (float)gOpenRaider->mWindow->mWidth;
+    if (getWindow().mWidth < getWindow().mHeight)
+        w = h = (float)getWindow().mWidth;
     else
-        w = h = (float)gOpenRaider->mWindow->mHeight;
+        w = h = (float)getWindow().mHeight;
 
 
     if (mTexture.getTextureCount() <= 0)
 
 void Render::drawSkyMesh(float scale)
 {
-    skeletal_model_t *model = gOpenRaider->mGame->mWorld.getModel(mSkyMesh);
+    skeletal_model_t *model = getGame().mWorld.getModel(mSkyMesh);
 
 
     if (!model)
     glTranslated(0.0, 1000.0, 0.0);
     glScaled(scale, scale, scale);
     //drawModel(model);
-    //drawModelMesh(gOpenRaider->mGame->mWorld.getMesh(mSkyMesh), );
+    //drawModelMesh(getGame().mWorld.getMesh(mSkyMesh), );
     glPopMatrix();
     glEnable(GL_DEPTH_TEST);
 }
 
 
     // Draw lara or other player model ( move to entity rendering method )
-    if (mFlags & Render::fViewModel && gOpenRaider->mGame->mLara && gOpenRaider->mGame->mLara->tmpHook)
+    if (mFlags & Render::fViewModel && getGame().mLara && getGame().mLara->tmpHook)
     {
-        SkeletalModel *mdl = static_cast<SkeletalModel *>(gOpenRaider->mGame->mLara->tmpHook);
+        SkeletalModel *mdl = static_cast<SkeletalModel *>(getGame().mLara->tmpHook);
 
         if (mdl)
         {
 
             // Mongoose 2002.03.22, Test 'idle' aniamtions
-            if (!gOpenRaider->mGame->mLara->moving)
+            if (!getGame().mLara->moving)
             {
                 frame = mdl->getIdleAnimation();
 
         glPushMatrix();
 
 #ifdef USING_FPS_CAMERA
-        gOpenRaider->mGame->mCamera->getPosition(curPos);
+        getGame().mCamera->getPosition(curPos);
         glTranslated(curPos[0], curPos[1], curPos[2]);
-        glRotated(gOpenRaider->mGame->mCamera->getYaw(), 0, 1, 0);
+        glRotated(getGame().mCamera->getYaw(), 0, 1, 0);
         glTranslated(0, 500, 1200);
 #else
-        glTranslated(gOpenRaider->mGame->mLara->pos[0], gOpenRaider->mGame->mLara->pos[1], gOpenRaider->mGame->mLara->pos[2]);
-        glRotated(gOpenRaider->mGame->mCamera->getYaw(), 0, 1, 0);
+        glTranslated(getGame().mLara->pos[0], getGame().mLara->pos[1], getGame().mLara->pos[2]);
+        glRotated(getGame().mCamera->getYaw(), 0, 1, 0);
 #endif
 
-        drawModel(static_cast<SkeletalModel *>(gOpenRaider->mGame->mLara->tmpHook));
+        drawModel(static_cast<SkeletalModel *>(getGame().mLara->tmpHook));
         glPopMatrix();
     }
 
     {
         std::vector<sprite_seq_t *> *sprites;
 
-        sprites = gOpenRaider->mGame->mWorld.getSprites();
+        sprites = getGame().mWorld.getSprites();
 
         for (unsigned int i = 0; i < sprites->size(); i++)
         {
 
                 if (tag2)
                 {
-                    drawModelMesh(gOpenRaider->mGame->mWorld.getMesh(tag2->mesh), Render::skeletalMesh);
+                    drawModelMesh(getGame().mWorld.getMesh(tag2->mesh), Render::skeletalMesh);
                 }
             }
         }
                     {
                         glPushMatrix();
                         glTranslatef(mdl->ponyOff2, 0.0, 0.0);
-                        drawModelMesh(gOpenRaider->mGame->mWorld.getMesh(mdl->ponytailMeshId + i),
+                        drawModelMesh(getGame().mWorld.getMesh(mdl->ponytailMeshId + i),
                                 Render::skeletalMesh);
                         glPopMatrix();
 
                         glPushMatrix();
                         glTranslatef(-mdl->ponyOff2, 0.0, 0.0);
-                        drawModelMesh(gOpenRaider->mGame->mWorld.getMesh(mdl->ponytailMeshId + i),
+                        drawModelMesh(getGame().mWorld.getMesh(mdl->ponytailMeshId + i),
                                 Render::skeletalMesh);
                         glPopMatrix();
                     }
                     else
                     {
-                        drawModelMesh(gOpenRaider->mGame->mWorld.getMesh(mdl->ponytailMeshId + i),
+                        drawModelMesh(getGame().mWorld.getMesh(mdl->ponytailMeshId + i),
                                 Render::skeletalMesh);
                     }
                 }
             }
         }
 
-        drawModelMesh(gOpenRaider->mGame->mWorld.getMesh(tag->mesh), Render::skeletalMesh);
+        drawModelMesh(getGame().mWorld.getMesh(tag->mesh), Render::skeletalMesh);
     }
 
     // Cycle frames ( cheap hack from old ent state based system )
     glTranslated(sprite->pos[0], sprite->pos[1], sprite->pos[2]);
 
     // Sprites must always face camera, because they have no depth  =)
-    glRotated(gOpenRaider->mGame->mCamera->getYaw(), 0, 1, 0);
+    glRotated(getGame().mCamera->getYaw(), 0, 1, 0);
 
     switch (mMode)
     {
     if (!mesh)
         return;
 
-    r_mesh = gOpenRaider->mGame->mWorld.getMesh(mesh->index);
+    r_mesh = getGame().mWorld.getMesh(mesh->index);
 
     if (!r_mesh)
         return;
         return;
     }
 
-    model = gOpenRaider->mGame->mWorld.getModel(index);
+    model = getGame().mWorld.getModel(index);
 
     if (model)
     {

src/WindowSDL.cpp

     while(SDL_PollEvent(&event)) {
         switch (event.type) {
             case SDL_MOUSEMOTION:
-                gOpenRaider->handleMouseMotion(event.motion.xrel, event.motion.yrel);
+                getOpenRaider().handleMouseMotion(event.motion.xrel, event.motion.yrel);
                 break;
 
             case SDL_MOUSEBUTTONDOWN:
                     button = rightmouse;
                 else
                     button = middlemouse;
-                gOpenRaider->handleMouseClick(event.button.x, event.button.y, button, (event.type == SDL_MOUSEBUTTONUP));
+                getOpenRaider().handleMouseClick(event.button.x, event.button.y, button, (event.type == SDL_MOUSEBUTTONUP));
                 break;
 
             case SDL_MOUSEWHEEL:
-                gOpenRaider->handleMouseScroll(event.wheel.x, event.wheel.y);
+                getOpenRaider().handleMouseScroll(event.wheel.x, event.wheel.y);
                 break;
 
             case SDL_TEXTINPUT:
             case SDL_TEXTEDITING:
-                gOpenRaider->handleText(event.text.text, (event.type == SDL_TEXTEDITING));
+                getOpenRaider().handleText(event.text.text, (event.type == SDL_TEXTEDITING));
                 break;
 
             case SDL_KEYDOWN:
                         break;
 
                 }
-                gOpenRaider->handleKeyboard(key, (event.type == SDL_KEYDOWN));
+                getOpenRaider().handleKeyboard(key, (event.type == SDL_KEYDOWN));
                 break;
 
             case SDL_WINDOWEVENT:

src/main.cpp

 #include "config.h"
 #include "main.h"
 #include "utils/time.h"
+#include "WindowSDL.h"
 
+Console *gConsole = NULL;
+Game *gGame = NULL;
+Menu *gMenu = NULL;
 OpenRaider *gOpenRaider = NULL;
+Window *gWindow = NULL;
+
+Console &getConsole() {
+    return *gConsole;
+}
+
+Game &getGame() {
+    return *gGame;
+}
+
+Menu &getMenu() {
+    return *gMenu;
+}
+
+OpenRaider &getOpenRaider() {
+    return *gOpenRaider;
+}
+
+Window &getWindow() {
+    return *gWindow;
+}
+
+void cleanupHandler(void) {
+    if (gConsole)
+        delete gConsole;
+
+    if (gGame)
+        delete gGame;
+
+    if (gMenu)
+        delete gMenu;
 
-void cleanupHandler() {
     if (gOpenRaider)
         delete gOpenRaider;
 
+    if (gWindow)
+        delete gWindow;
+
     printf("\nThanks for testing %s\n", VERSION);
     printf("Build date: %s @ %s\n", __DATE__, __TIME__);
     printf("Build host: %s\n", BUILD_HOST);
 int main(int argc, char *argv[]) {
     const char *config = NULL;
 
-    systemTimerReset();
-
     // Handle arguments
     if (argc == 1) {
         // Use default rc file path
     }
 
     // Create globals
-    atexit(cleanupHandler);
     printf("Initializing %s\n", VERSION);
+    atexit(cleanupHandler);
     gOpenRaider = new OpenRaider();
+    gWindow = new WindowSDL();
+    gConsole = new Console();
+    gMenu = new Menu();
+    gGame = new Game();
 
     // Try to load a configuration
     if (gOpenRaider->loadConfig(config) != 0) {
         }
     }
 
-    // Initialize the "subsystems"
-    gOpenRaider->initialize();
+    // Initialize Windowing
+    int error = gWindow->initialize();
+    if (error != 0) {
+        printf("Could not initialize Window (%d)!\n", error);
+        return 3;
+    }
+
+    // Initialize OpenGL
+    error = gWindow->initializeGL();
+    if (error != 0) {
+        printf("Could not initialize OpenGL (%d)!\n", error);
+        return 4;
+    }
+
+    error = gWindow->initializeFont();
+    if (error != 0) {
+        printf("Could not initialize SDL-TTF (%d)!\n", error);
+        return 5;
+    }
+
+    error = gOpenRaider->initialize();
+    if (error != 0) {
+        printf("Could not initialize OpenRaider (%d)!\n", error);
+        return 6;
+    }
+
+    // Initialize game engine
+    error = gGame->initialize();
+    if (error != 0) {
+        printf("Could not initialize Game Engine (%d)!\n", error);
+        return 7;
+    }
+
+    gMenu->setVisible(true);
+
+    systemTimerReset();
 
     // Enter Main loop
-    gOpenRaider->mConsole->print("Starting %s", VERSION);
+    gConsole->print("Starting %s", VERSION);
     gOpenRaider->run();
 
     return 0;