Game is singleton. Started initializing Render.

Modified Camera and Render.

include/Game.h

 #ifndef _GAME_H_
 #define _GAME_H_
 
+#include "Camera.h"
 #include "global.h"
+#include "Render.h"
 #include "TombRaider.h"
 #include "World.h"
 
 class Game {
 public:
 
-    // Throw exception with negative integer error code if fails
-    Game(const char *level);
+    Game();
 
     ~Game();
 
+    int initialize();
+
+    int loadLevel(const char *level);
+
+    void destroy();
+
     void handleAction(ActionEvents action, bool isFinished);
 
     void handleMouseMotion(int xrel, int yrel);
 
     World mWorld;
     entity_t *mLara;
+    Render *mRender;
+    Camera *mCamera;
 
 private:
 
+    bool mLoaded;
     char *mName;
     TombRaider mTombRaider;
 
+    unsigned int mTextureStart;
+    unsigned int mTextureLevelOffset;
+    unsigned int mTextureOffset;
 };
 
 #endif

include/OpenRaider.h

     float mCameraRotationDeltaX;
     float mCameraRotationDeltaY;
 
+    char *mBaseDir;
+    char *mPakDir;
+    char *mAudioDir;
+    char *mDataDir;
+
 private:
 
     int command(const char *command, std::vector<char *> *args);
     bool mInit;
     bool mRunning;
 
-    char *mBaseDir;
-    char *mPakDir;
-    char *mAudioDir;
-    char *mDataDir;
-
     KeyboardButton keyBindings[ActionEventCount];
 };
 

include/Render.h

     void addRoom(RenderRoom *rRoom);
 
     /*!
-     * \brief Starts and sets up OpenGL target
-     * \param width width of window
-     * \param height height of window
-     */
-    void Init(int width, int height);
-
-    /*!
      * \brief Loads textures in a certain id slot
      * \param image Image to load
      * \param width width of image
 
     void setMode(int n);
 
-    void Update(int width, int height);
-
     /*!
      * \brief Renders a single game frame
      */
 
     void ViewModel(entity_t *ent, int index);
 
-    void RegisterCamera(Camera *camera);
-
     void addSkeletalModel(SkeletalModel *mdl);
 
 private:
     void tmpRenderModelMesh(model_mesh_t *r_mesh, texture_tri_t *ttri);
 
     Texture mTexture;                     //!< Texture subsystem
-    Camera *mCamera;                      //!< Camera subsystem
 
     std::vector<RenderRoom *> mRoomRenderList;
     std::vector<RenderRoom *> mRooms;
     std::vector<SkeletalModel *> mModels;
 
     unsigned int mFlags;                  //!< Rendering flags
-    unsigned int mWidth;                  //!< Viewport width
-    unsigned int mHeight;                 //!< Viewport height
     unsigned int mMode;                   //!< Rendering mode
     unsigned int *mNumTexturesLoaded;
     unsigned int *mNextTextureId;

src/Game.cpp

 #include "Game.h"
 #include "utils/strings.h"
 
+Game::Game() {
+    mLoaded = false;
+    mName = NULL;
+    mLara = NULL;
+
+    mTextureStart = 0;
+    mTextureLevelOffset = 0;
+    mTextureOffset = 0;
+
+    mCamera = NULL;
+    mRender = NULL;
+}
+
+Game::~Game() {
+    destroy();
+
+    if (mRender)
+        delete mRender;
+
+    if (mCamera)
+        delete mCamera;
+}
+
+int Game::initialize() {
+    mCamera = new Camera();
+    // TODO setup Camera
+
+    mRender = new Render();
+    mRender->initTextures(gOpenRaider->mDataDir, &mTextureStart, &mTextureLevelOffset);
+
+    return 0;
+}
+
 void percentCallbackTrampoline(int percent, void *data) {
     Game *self = static_cast<Game *>(data);
     self->percentCallback(percent);
 
 }
 
-// Throw exception with negative integer error code if fails
-Game::Game(const char *level) {
-    mLara = NULL;
+int Game::loadLevel(const char *level) {
+    destroy();
 
     mName = bufferString("%s", level);
 
     gOpenRaider->mConsole->print("Loading %s", mName);
     int error = mTombRaider.Load(mName, percentCallbackTrampoline, this);
     if (error != 0) {
-        throw error;
+        return error;
     }
 
     // If required, load the external sound effect file MAIN.SFX into TombRaider
         }
         delete [] tmp;
     }
+
+    mLoaded = true;
+    //mRender->setMode(Render::modeTexture);
+    // TODO enable Renderer
+    return 0;
 }
 
-Game::~Game() {
+void Game::destroy() {
     if (mName)
         delete [] mName;
+
+    mLoaded = false;
+    mRender->setMode(Render::modeDisabled);
 }
 
 void Game::handleAction(ActionEvents action, bool isFinished) {
+    if (mLoaded) {
 
+    }
 }
 
 void Game::handleMouseMotion(int xrel, int yrel) {
+    if (mLoaded) {
 
+    }
 }
 
 void Game::display() {
-    glClearColor(0.00f, 0.70f, 0.00f, 1.0f);
-    glClear(GL_COLOR_BUFFER_BIT);
+    if (mLoaded) {
+        //glClearColor(0.00f, 0.70f, 0.00f, 1.0f);
+        //glClear(GL_COLOR_BUFFER_BIT);
+
+        mRender->Display();
+    }
 }
 

src/OpenRaider.cpp

     mConsole = new Console();
     mSound = new Sound();
     mWindow = new WindowSDL();
-    mGame = NULL;
+    mGame = new Game();
 
     for (int i = 0; i < ActionEventCount; i++)
         keyBindings[i] = unknown;
             return -4;
         }
     } else if (strcmp(command, "load") == 0) {
-        if (mGame)
-            delete mGame;
         char *tmp = bufferString("%s/%s", mPakDir, args->at(0));
-        try {
-            mGame = new Game(tmp);
-            delete [] tmp;
-            return 0;
-        } catch (int error) {
-            delete [] tmp;
-            return error;
-        }
+        int error = mGame->loadLevel(tmp);
+        delete [] tmp;
+        return error;
     } else {
         mConsole->print("Unknown command: %s ", command);
         return -1;
     if (mSound->initialize() != 0)
         return -4;
 
+    // Initialize game engine
+    if (mGame->initialize() != 0)
+        return -5;
+
     mMenu->setVisible(true);
 
     mInit = true;
         glClear(GL_COLOR_BUFFER_BIT);
 
         // Draw game scene
-        if (mGame)
-            mGame->display();
+        mGame->display();
 
         // Draw 2D overlays (console and menu)
         mWindow->glEnter2D();
         } else if (!mConsole->isVisible()) {
             for (int i = forwardAction; i < ActionEventCount; i++) {
                 if (keyBindings[i] == key) {
-                    if (mGame)
-                        mGame->handleAction((ActionEvents)i, pressed);
+                    mGame->handleAction((ActionEvents)i, pressed);
                 }
             }
         } else {
     } else if (!mConsole->isVisible()) {
         for (int i = forwardAction; i < ActionEventCount; i++) {
             if (keyBindings[i] == button) {
-                if (mGame)
-                    mGame->handleAction((ActionEvents)i, !released);
+                mGame->handleAction((ActionEvents)i, !released);
             }
         }
     }
 
 void OpenRaider::handleMouseMotion(int xrel, int yrel) {
     if ((!mConsole->isVisible()) && (!mMenu->isVisible())) {
-        if (mGame)
-            mGame->handleMouseMotion(xrel, yrel);
+        mGame->handleMouseMotion(xrel, yrel);
     }
 }
 

src/Render.cpp

 #ifdef USING_EMITTER
     mEmitter = 0x0;
 #endif
-    mCamera = 0x0;
     mSkyMesh = -1;
     mSkyMeshRotation = false;
     mMode = Render::modeDisabled;
 
     mNextTextureId = NULL;
     mNumTexturesLoaded = NULL;
-
-    mWidth = 640;
-    mHeight = 480;
 }
 
 
 
 void Render::screenShot(char *filenameBase)
 {
-    mTexture.glScreenShot(filenameBase, mWidth, mHeight);
+    mTexture.glScreenShot(filenameBase, gOpenRaider->mWindow->mWidth, gOpenRaider->mWindow->mHeight);
 }
 
 
         ++numTextures;
     }
 
-    snprintf(filename, 126, "%s%s", textureDir, "splash.tga");
+    snprintf(filename, 126, "%s/%s", textureDir, "splash.tga");
     filename[127] = 0;
 
     if ((bg_id = mTexture.loadTGA(filename)) > -1)
         ++numTextures;
     }
 
-    snprintf(filename, 126, "%s%s", textureDir, "snow.tga");
+    snprintf(filename, 126, "%s/%s", textureDir, "snow.tga");
     filename[127] = 0;
 
     if ((snow1_id = mTexture.loadTGA(filename)) > -1)
         ++numTextures;
     }
 
-    snprintf(filename, 126, "%s%s", textureDir, "snow2.tga");
+    snprintf(filename, 126, "%s/%s", textureDir, "snow2.tga");
     filename[127] = 0;
 
     if ((snow2_id = mTexture.loadTGA(filename)) > -1)
 }
 
 
-void Render::Init(int width, int height)
-{
-    char *s;
-
-    mWidth = width;
-    mHeight = height;
-
-    // Print driver support information
-    printf("GL Vendor   : %s\n", glGetString(GL_VENDOR));
-    printf("GL Renderer : %s\n", glGetString(GL_RENDERER));
-    printf("GL Version  : %s\n", glGetString(GL_VERSION));
-    //printf("Extensions : %s\n\n\n", (char*)glGetString(GL_EXTENSIONS));
-
-    // Testing for goodies
-    // Mongoose 2001.12.31, Fixed string use to check for bad strings
-    s = (char*)glGetString(GL_EXTENSIONS);
-
-    if (s && s[0])
-    {
-        //printf("\tGL_ARB_multitexture       \t\t");
-
-        if (strstr(s, "GL_ARB_multitexture"))
-        {
-            mFlags |= Render::fMultiTexture;
-            //printf("YES\n");
-        }
-        /*
-        else
-        {
-            printf("NO\n");
-        }
-
-        printf("\tGL_EXT_texture_env_combine\t\t");
-
-        if (strstr(s, "GL_EXT_texture_env_combine"))
-        {
-            printf("YES\n");
-        }
-        else
-        {
-            printf("NO\n");
-        }
-        */
-    }
-
-    // Set up Z buffer
-    glEnable(GL_DEPTH_TEST);
-    glDepthFunc(GL_LESS);
-
-    // Set up culling
-    glEnable(GL_CULL_FACE);
-    glFrontFace(GL_CW);
-    //glFrontFace(GL_CCW);
-    //glCullFace(GL_FRONT);
-
-    // Set background to black
-    glClearColor(BLACK[0], BLACK[1], BLACK[2], BLACK[3]);
-
-    // Disable lighting
-    glDisable(GL_LIGHTING);
-
-    // Set up alpha blending
-    glEnable(GL_BLEND);
-    glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
-
-    //glEnable(GL_ALPHA_TEST); // Disable per pixel alpha blending
-    glAlphaFunc(GL_GREATER, 0);
-
-    glPointSize(5.0);
-
-    // Setup shading
-    glShadeModel(GL_SMOOTH);
-
-    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
-    glHint(GL_FOG_HINT, GL_NICEST);
-    glEnable(GL_COLOR_MATERIAL);
-    glEnable(GL_DITHER);
-
-    // AA polygon edges
-    glEnable(GL_POLYGON_SMOOTH);
-    glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST);
-
-    glDisable(GL_LINE_SMOOTH);
-    glDisable(GL_POINT_SMOOTH);
-    glDisable(GL_AUTO_NORMAL);
-    glDisable(GL_LOGIC_OP);
-    glDisable(GL_TEXTURE_1D);
-    glDisable(GL_STENCIL_TEST);
-    glDisable(GL_FOG);
-
-    glDisable(GL_NORMALIZE);
-
-    glEnableClientState(GL_VERTEX_ARRAY);
-    glDisableClientState(GL_EDGE_FLAG_ARRAY);
-    glDisableClientState(GL_COLOR_ARRAY);
-    glDisableClientState(GL_NORMAL_ARRAY);
-
-    glPolygonMode(GL_FRONT, GL_FILL);
-
-    glMatrixMode(GL_MODELVIEW);
-}
-
-
 void setLighting(bool on)
 {
     if (on)
 }
 
 
-void Render::Update(int width, int height)
-{
-    mWidth = width;
-    mHeight = height;
-}
-
-
 int Render::getMode()
 {
     return mMode;
     gl_test_reset();
 #endif
 
-    // Assertion: Rendering is disabled without texture or camera
-    if (!mCamera)
-    {
-        fprintf(stderr, "Render::Display> ERROR: No camera is registered\n");
-        return;
-    }
-
     switch (mMode)
     {
         case Render::modeDisabled:
             camPos[2] = curPos[2] + (64.0f * cosf(yaw));
         }
 
-        mCamera->setPosition(camPos);
+        gOpenRaider->mGame->mCamera->setPosition(camPos);
     }
 
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     glLoadIdentity();
 
     // Setup view in OpenGL with camera
-    mCamera->update();
-    mCamera->getPosition(camPos);
-    mCamera->getTarget(atPos);
+    gOpenRaider->mGame->mCamera->update();
+    gOpenRaider->mGame->mCamera->getPosition(camPos);
+    gOpenRaider->mGame->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.0, -1.0, 0.0);
 
         glPushMatrix();
 
 #ifdef USING_FPS_CAMERA
-        mCamera->getPosition(curPos);
+        gOpenRaider->mGame->mCamera->getPosition(curPos);
         glTranslated(curPos[0], curPos[1], curPos[2]);
-        glRotated(mCamera->getYaw(), 0, 1, 0);
+        glRotated(gOpenRaider->mGame->mCamera->getYaw(), 0, 1, 0);
         glTranslated(0, 500, 1200);
 #else
         glTranslated(LARA->pos[0], LARA->pos[1], LARA->pos[2]);
-        glRotated(mCamera->getYaw(), 0, 1, 0);
+        glRotated(gOpenRaider->mGame->mCamera->getYaw(), 0, 1, 0);
 #endif
 
         drawModel(static_cast<SkeletalModel *>(LARA->tmpHook));
     glTranslated(sprite->pos[0], sprite->pos[1], sprite->pos[2]);
 
     // Sprites must always face camera, because they have no depth  =)
-    glRotated(mCamera->getYaw(), 0, 1, 0);
+    glRotated(gOpenRaider->mGame->mCamera->getYaw(), 0, 1, 0);
 
     switch (mMode)
     {
 }
 
 
-void Render::RegisterCamera(Camera *camera)
-{
-    if (camera)
-    {
-        mCamera = camera;
-    }
-}
-
-
 void Render::addSkeletalModel(SkeletalModel *mdl)
 {
     mModels.push_back(mdl);

src/Window.cpp

 }
 
 void Window::resizeGL() {
-    float fovY = 45.0f;
-    float clipNear = 4.0f;
-    float clipFar = 4000.0f;
+    float fovY = 40.0f; // 45.0f
+    float clipNear = 10.0f; // 4.0f
+    float clipFar = 600000.0f; // 4000.0f
 
     glViewport(0, 0, mWidth, mHeight);
     glMatrixMode(GL_PROJECTION);