Render is now also service

include/Game.h

 
     //! \fixme should be private
     entity_t *mLara;
-    Render *mRender;
 
 private:
 

include/main.h

 #include "Game.h"
 #include "Menu.h"
 #include "OpenRaider.h"
+#include "Render.h"
 #include "Sound.h"
 #include "Window.h"
 #include "World.h"
 
 OpenRaider &getOpenRaider();
 
+Render &getRender();
+
 Sound &getSound();
 
 Window &getWindow();

src/Game.cpp

     mTextureStart = 0;
     mTextureLevelOffset = 0;
     mTextureOffset = 0;
-
-    mRender = NULL;
 }
 
 Game::~Game() {
     destroy();
-
-    if (mRender)
-        delete mRender;
 }
 
 int Game::initialize() {
-    // Set up Renderer
-    mRender = new Render();
-    mRender->initTextures(getOpenRaider().mDataDir, &mTextureStart, &mTextureLevelOffset);
-
     // Enable Renderer
-    mRender->setMode(Render::modeLoadScreen);
+    getRender().initTextures(getOpenRaider().mDataDir, &mTextureStart, &mTextureLevelOffset);
+    getRender().setMode(Render::modeLoadScreen);
 
     // Enable World Hopping
     getWorld().setFlag(World::fEnableHopping);
         delete [] mName;
 
     mLoaded = false;
-    mRender->setMode(Render::modeDisabled);
+    getRender().setMode(Render::modeDisabled);
 
     getWorld().destroy();
-    mRender->ClearWorld();
+    getRender().ClearWorld();
     getSound().clear(); // Remove all previously loaded sounds
 }
 
     }
 
     mLoaded = true;
-    mRender->setMode(Render::modeVertexLight);
+    getRender().setMode(Render::modeVertexLight);
 
     return 0;
 }
 }
 
 void Game::display() {
-    mRender->Display();
+    getRender().Display();
 }
 
 int Game::command(std::vector<char *> *args) {
             char *mode = args->at(1);
             if (strcmp(mode, "wireframe") == 0) {
                 if (mLoaded) {
-                    mRender->setMode(Render::modeWireframe);
+                    getRender().setMode(Render::modeWireframe);
                     getConsole().print("Wireframe mode");
                 } else {
                     getConsole().print("Load a level to set this mode!");
                 }
             } else if (strcmp(mode, "solid") == 0) {
                 if (mLoaded) {
-                    mRender->setMode(Render::modeSolid);
+                    getRender().setMode(Render::modeSolid);
                     getConsole().print("Solid mode");
                 } else {
                     getConsole().print("Load a level to set this mode!");
                 }
             } else if (strcmp(mode, "texture") == 0) {
                 if (mLoaded) {
-                    mRender->setMode(Render::modeTexture);
+                    getRender().setMode(Render::modeTexture);
                     getConsole().print("Texture mode");
                 } else {
                     getConsole().print("Load a level to set this mode!");
                 }
             } else if (strcmp(mode, "vertexlight") == 0) {
                 if (mLoaded) {
-                    mRender->setMode(Render::modeVertexLight);
+                    getRender().setMode(Render::modeVertexLight);
                     getConsole().print("Vertexlight mode");
                 } else {
                     getConsole().print("Load a level to set this mode!");
                     return -5;
                 }
             } else if (strcmp(mode, "titlescreen") == 0) {
-                mRender->setMode(Render::modeLoadScreen);
+                getRender().setMode(Render::modeLoadScreen);
                 getConsole().print("Titlescreen mode");
             } else {
                 getConsole().print("Invalid use of mode command (%s)!", mode);
             char c = args->at(1)[0];
             if (c == 'n') {
                 // Step all skeletal models to their next animation
-                if (mRender->getFlags() & Render::fAnimateAllModels) {
-                    for (unsigned int i = 0; i < mRender->mModels.size(); i++) {
-                        SkeletalModel *m = mRender->mModels[i];
+                if (getRender().getFlags() & Render::fAnimateAllModels) {
+                    for (unsigned int i = 0; i < getRender().mModels.size(); i++) {
+                        SkeletalModel *m = getRender().mModels[i];
                         if (m->getAnimation() < ((int)m->model->animation.size() - 1))
                             m->setAnimation(m->getAnimation() + 1);
                         else
                 }
             } else if (c == 'p') {
                 // Step all skeletal models to their previous animation
-                if (mRender->getFlags() & Render::fAnimateAllModels) {
-                    for (unsigned int i = 0; i < mRender->mModels.size(); i++) {
-                        SkeletalModel *m = mRender->mModels[i];
+                if (getRender().getFlags() & Render::fAnimateAllModels) {
+                    for (unsigned int i = 0; i < getRender().mModels.size(); i++) {
+                        SkeletalModel *m = getRender().mModels[i];
                         if (m->getAnimation() > 0)
                             m->setAnimation(m->getAnimation() - 1);
                         else
                     return -12;
                 }
                 if (b)
-                    mRender->setFlags(Render::fAnimateAllModels);
+                    getRender().setFlags(Render::fAnimateAllModels);
                 else
-                    mRender->clearFlags(Render::fAnimateAllModels);
+                    getRender().clearFlags(Render::fAnimateAllModels);
                 getConsole().print(b ? "Animating all models" : "No longer animating all models");
             }
         } else {
                 return -15;
             }
             if (b)
-                mRender->setFlags(Render::fGL_Lights);
+                getRender().setFlags(Render::fGL_Lights);
             else
-                mRender->clearFlags(Render::fGL_Lights);
+                getRender().clearFlags(Render::fGL_Lights);
             getConsole().print("GL-Lights are now %s", b ? "on" : "off");
         } else {
             getConsole().print("Invalid use of game-light-command!");
                 return -17;
             }
             if (b)
-                mRender->setFlags(Render::fFog);
+                getRender().setFlags(Render::fFog);
             else
-                mRender->clearFlags(Render::fFog);
+                getRender().clearFlags(Render::fFog);
             getConsole().print("Fog is now %s", b ? "on" : "off");
         } else {
             getConsole().print("Invalid use of game-fog-command!");
         mTombRaider.Texture(i, &image, &bumpmap);
 
         // Overwrite any previous level textures on load
-        mRender->loadTexture(image, 256, 256, mTextureLevelOffset + i);
+        getRender().loadTexture(image, 256, 256, mTextureLevelOffset + i);
 
 #ifdef MULTITEXTURE
         gMapTex2Bump[mTextureLevelOffset + i] = -1;
             gMapTex2Bump[mTextureLevelOffset + i] = mTextureLevelOffset + i +
                     mTombRaider.NumTextures();
 #endif
-            mRender->loadTexture(bumpmap, 256, 256, mTextureLevelOffset + i +
+            getRender().loadTexture(bumpmap, 256, 256, mTextureLevelOffset + i +
                     mTombRaider.NumTextures());
         }
 
     thing->animate = false;
 
     sModel = new SkeletalModel();
-    mRender->addSkeletalModel(sModel);
+    getRender().addSkeletalModel(sModel);
     thing->tmpHook = sModel; // temp hack to keep a running version during refactoring
 
     if (mTombRaider.Engine() == TR_VERSION_1)
     //! \fixme Check here and see if we already have one for object_id later
     // if (getWorld().isCachedSkeletalModel(moveable[index].object_id))
     // {
-    //   thing->modelId = mRender->add(sModel);
+    //   thing->modelId = getRender().add(sModel);
     //   return;
     // }
 
                         r_model->ponytail[1] -= 32;
                     }
 
-                    mRender->setFlags(Render::fRenderPonytail);
+                    getRender().setFlags(Render::fRenderPonytail);
                     getConsole().print("Found known ponytail");
                 }
                 break; // ?
                     r_model->ponyOff = 40;
                     r_model->ponyOff2 = 0;
 
-                    mRender->setFlags(Render::fRenderPonytail);
+                    getRender().setFlags(Render::fRenderPonytail);
                     getConsole().print("Found ponytail?");
                 }
                 break;
 
     if (i == skyMesh)
     {
-        mRender->setSkyMesh(i, //moveable[i].starting_mesh,
+        getRender().setSkyMesh(i, //moveable[i].starting_mesh,
                 (mTombRaider.Engine() == TR_VERSION_2));
     }
 
         gColorTextureHACK.push_back(colorI);
         r_tri->texture = mTextureOffset + gColorTextureHACK.size();
 
-        mRender->loadTexture(Texture::generateColorTexture(color, 32, 32),
+        getRender().loadTexture(Texture::generateColorTexture(color, 32, 32),
                 32, 32,
                 r_tri->texture);
 
         {
             getConsole().print("WARNING: Handling invalid vertex array in room");
             getWorld().addRoom(0x0);
-            mRender->addRoom(0x0);
+            getRender().addRoom(0x0);
 
             //printf("x");
             //fflush(stdout);
         getWorld().addRoom(r_mesh);
 
         rRoom->room = r_mesh;
-        mRender->addRoom(rRoom);
+        getRender().addRoom(rRoom);
 
         //printf(".");
         //fflush(stdout);

src/OpenRaider.cpp

             frame();
             frame(); // Double buffered
         }
-        getGame().mRender->screenShot(filename);
+        getRender().screenShot(filename);
         if (!console) {
             getConsole().setVisible(true);
             if (menu)

src/Render.cpp

     if (!a || !b)
         return false; // error really
 
-    distA = getGame().mRender->mViewVolume.getDistToSphereFromNear(a->pos[0],
+    distA = getRender().mViewVolume.getDistToSphereFromNear(a->pos[0],
             a->pos[1],
             a->pos[2],
             1.0f);
-    distB = getGame().mRender->mViewVolume.getDistToSphereFromNear(b->pos[0],
+    distB = getRender().mViewVolume.getDistToSphereFromNear(b->pos[0],
             b->pos[1],
             b->pos[2],
             1.0f);
     if (!a || !b)
         return false; // error really
 
-    distA = getGame().mRender->mViewVolume.getDistToSphereFromNear(a->pos[0],
+    distA = getRender().mViewVolume.getDistToSphereFromNear(a->pos[0],
             a->pos[1],
             a->pos[2],
             128.0f);
-    distB = getGame().mRender->mViewVolume.getDistToSphereFromNear(b->pos[0],
+    distB = getRender().mViewVolume.getDistToSphereFromNear(b->pos[0],
             b->pos[1],
             b->pos[2],
             128.0f);

src/main.cpp

 Game *gGame = NULL;
 Menu *gMenu = NULL;
 OpenRaider *gOpenRaider = NULL;
+Render *gRender = NULL;
 Sound *gSound = NULL;
 Window *gWindow = NULL;
 World *gWorld = NULL;
     return *gOpenRaider;
 }
 
+Render &getRender() {
+    assert(gRender != NULL);
+    return *gRender;
+}
+
 Sound &getSound() {
     assert(gSound != NULL);
     return *gSound;
     if (gWorld)
         delete gWorld;
 
+    if (gRender)
+        delete gRender;
+
     if (gCamera)
         delete gCamera;
 
     gSound = new SoundAL();
     gWorld = new World();
     gCamera = new Camera();
+    gRender = new Render();
     gConsole = new Console();
     gMenu = new Menu();
     gGame = new Game();