TextureManager now has independent storages

ChangeLog.md

 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20141122 ]
+    * TextureManager now knows the difference between level and system textures.
+
     [ 20141116 ]
     * Fixed background color of wireframe mode
 

include/Game.h

     void handleAction(ActionEvents action, bool isFinished);
     void handleMouseMotion(int xrel, int yrel, int xabs, int yabs);
 
-    unsigned int getTextureStart();
-    unsigned int getTextureOffset();
-
     Entity& getLara();
 
   private:
 
     TombRaider mTombRaider;
 
-    unsigned int mTextureStart;
-    unsigned int mTextureOffset;
-
     long mLara;
 };
 

include/TextureManager.h

 
 #include <vector>
 
+// These are loaded into TextureStorage::SYSTEM by initialize()!
+#define TEXTURE_WHITE 0
+#define TEXTURE_SPLASH 1
+
 /*!
  * \brief Texture registry
  */
 class TextureManager {
   public:
 
-    enum TextureFlag {
-        fUseMultiTexture = (1 << 0),
+    enum class TextureStorage {
+        GAME,
+        SYSTEM
     };
 
-    /*!
-    * \brief Constructs an object of Texture
-    */
-    TextureManager();
-
-    /*!
-     * \brief Deconstructs an object of Texture
-     */
     ~TextureManager();
 
-    /*!
-     * \brief Resets all texture data
-     */
-    void reset();
-
     int initialize();
 
     /*!
-     * \brief Get number of textures in use
-     * \returns used texture count, or -1 on error (uninitialized)
-     */
-    int getTextureCount();
-
-    /*!
-     * \brief Sets up multitexture rendering with passed ids
-     * \param texture0 first texture for multitexture
-     * \param texture1 second texture for multitexture
-     */
-    void bindMultiTexture(int texture0, int texture1);
-
-    /*!
      * \brief Binds the texture for use in GL
      * \param n valid texture index
+     * \param s Which TextureStorage should be accessed
      */
-    void bindTextureId(unsigned int n);
-
-    /*!
-     * \brief Clears an option flag
-     * \param flag flag to clear
-     */
-    void clearFlag(TextureFlag flag);
-
-    void disableMultiTexture();
+    void bindTextureId(unsigned int n, TextureStorage s = TextureStorage::GAME);
 
     /*!
      * \brief Loads Buffer as texture
      * \param height height of image
      * \param mode mode of image
      * \param bpp bits per pixel of image
+     * \param s Which TextureStorage should be accessed
      * \param slot slot (ID) of image
      * \param filter if the texture should be mipmap filtered
      * \returns texture ID or < 0 on error
     int loadBufferSlot(unsigned char* image,
                        unsigned int width, unsigned int height,
                        ColorMode mode, unsigned int bpp,
-                       unsigned int slot, bool filter = true);
+                       TextureStorage s = TextureStorage::GAME,
+                       int slot = -1, bool filter = true);
 
-    int loadImage(const char* filename);
-
-    /*!
-     * \brief Sets an option flag
-     * \param flag flag to set
-     */
-    void setFlag(TextureFlag flag);
-
-    void useMultiTexture(float aU, float aV, float bU, float bV);
+    int loadImage(const char* filename, TextureStorage s = TextureStorage::GAME, int slot = -1);
 
   private:
-    int loadTGA(const char* filename);
-    int loadPCX(const char* filename);
-    int loadPNG(const char* filename);
+    std::vector<unsigned int>& getIds(TextureStorage s);
+
+    int loadTGA(const char* filename, TextureStorage s, int slot);
+    int loadPCX(const char* filename, TextureStorage s, int slot);
+    int loadPNG(const char* filename, TextureStorage s, int slot);
 
-    std::vector<unsigned int> mTextureIds;
-    unsigned int mFlags;
+    std::vector<unsigned int> mTextureIdsGame;
+    std::vector<unsigned int> mTextureIdsSystem;
 };
 
 TextureManager& getTextureManager();

include/TombRaider.h

 
     int NumStaticMeshes();
 
-    int NumSprites();
-
     int NumSpriteSequences();
 
     int NumItems();
 
     tr2_item_t* Item();
 
-    tr2_object_texture_t* ObjectTextures();
-
-    /*!
-     * \brief Get number of boxes
-     * \returns number of boxes
-     */
-    unsigned int getNumBoxes();
-
     tr2_box_t* Box();
 
     tr2_mesh_t* Mesh();
     tr2_sprite_sequence_t* SpriteSequence();
 
     /*!
-     * \brief Makes a 32bit RGBA image from a stexture/bmap
-     * \param texture valid index into tex_special list
-     * \returns 32bit RGBA image or NULL on error
-     */
-    unsigned char* SpecialTexTile(int texture);
-
-    /*!
      * \brief Get copies of texture and it's bumpmap
      * \param texture valid textile index
      * \param image will be set to texture if found, or NULL
      */
     void Texture(int texture, unsigned char** image, unsigned char** bumpmap);
 
-    unsigned int* Palette16();
-
-    unsigned char* Palette8();
+    //unsigned int* Palette16();
+    //unsigned char* Palette8();
 
     tr2_room_t* Room();
 
     /*!
-     * \brief Check if a file is a TombRaider pak
-     * \param filename file to check
-     * \returns 0 if it is a TombRaider pak
-     */
-    static int checkMime(const char* filename);
-
-    /*!
      * \brief Loads TombRaider 1-5 pak into memory
      * and does some processing.
      * \param filename points to valid TombRaider pak
     int Load(const char* filename);
 
     /*!
-     * \brief Makes a clamped 0.0 to 1.0 texel from coord pair
-     * \param texel texel value, is modified, divided by 255.0 and returned
-     * \param offset if offset is negative, texel is decreased by one, else increased
-     * \returns modified texel divided by 255.0
-     */
-    float adjustTexel(unsigned char texel, char offset);
-
-    /*!
      * \brief Compute rotation angles from moveable animation data
      * \param frame moveable animation data
      * \param frame_offset moveable animation data
      */
     void computeUV(tr2_object_texture_vert_t* st, float* u, float* v);
 
-    /*!
-     * \brief Get number of bump maps in loaded pak
-     * \returns number of bump maps
-     */
-    int getBumpMapCount();
-
     void getColor(int index, float color[4]);
 
     tr2_version_type getEngine();
      */
     int getSkyModelId();
 
-    void getSprites();
-
     /*!
      * \brief Get a copy of a sound sample and its byte size
      * \param index sound sample index
 
     void reset();
 
-    void setDebug(bool toggle);
-
-    /*!
-     * \brief Sets lighting factor for each vertex color per room in TR3 paks
-     * \param f new lighting factor
-     */
-    void setRoomVertexLightingFactor(float f);
-
-    /*!
-     * \brief Set scaling for sprite texel alignment, etc.
-     * \param f new scaling factor
-     */
-    void setTexelScalingFactor(float f);
-
   private:
 
     void extractMeshes(unsigned char* mesh_data,

src/Game.cpp

 Game::Game() {
     mLoaded = false;
     mLara = -1;
-    mTextureStart = 0;
-    mTextureOffset = 0;
 }
 
 Game::~Game() {
 }
 
-unsigned int Game::getTextureStart() {
-    return mTextureStart;
-}
-
-unsigned int Game::getTextureOffset() {
-    return mTextureOffset;
-}
-
 int Game::initialize() {
     // Enable Renderer
     getRender().setMode(Render::modeLoadScreen);
 
-    mTextureStart = getTextureManager().getTextureCount();
-
     return 0;
 }
 
 
         // Overwrite any previous level textures on load
         getTextureManager().loadBufferSlot(image, 256, 256,
-                                           RGBA, 32, (mTextureStart - 1) + i);
+                                           RGBA, 32, TextureManager::TextureStorage::GAME, i);
 
 #ifdef MULTITEXTURE
-        gMapTex2Bump[(mTextureStart - 1) + i] = -1;
+        gMapTex2Bump[i] = -1;
 #endif
 
         if (bumpmap) {
 #ifdef MULTITEXTURE
-            gMapTex2Bump[(mTextureStart - 1) + i] = (mTextureStart - 1) + i +
-                                                    mTombRaider.NumTextures();
+            gMapTex2Bump[i] = i + mTombRaider.NumTextures();
 #endif
             getTextureManager().loadBufferSlot(bumpmap, 256, 256,
-                                               RGBA, 32,
-                                               (mTextureStart - 1) + i + mTombRaider.NumTextures());
+                                               RGBA, 32, TextureManager::TextureStorage::GAME,
+                                               i + mTombRaider.NumTextures());
         }
 
         if (image)
             delete [] bumpmap;
     }
 
-    mTextureOffset = (mTextureStart - 1) + mTombRaider.NumTextures();
-
     getLog() << "Found " << mTombRaider.NumTextures() << " textures." << Log::endl;
 }
 

src/Mesh.cpp

 #include <stdlib.h>
 
 #include "global.h"
+#include "TextureManager.h"
 #include "Mesh.h"
 
 
         switch (mMode) {
             case MeshModeWireframe:
                 glColor3f(0.0, 0.0, 1.0);
-                glBindTexture(GL_TEXTURE_2D, 0);
+                getTextureManager().bindTextureId(TEXTURE_WHITE, TextureManager::TextureStorage::SYSTEM);
                 break;
             case MeshModeSolid:
                 // Bind WHITE texture for solid colors
-                glBindTexture(GL_TEXTURE_2D, 0);
+                getTextureManager().bindTextureId(TEXTURE_WHITE, TextureManager::TextureStorage::SYSTEM);
                 break;
             case MeshModeTexture:
             case MeshModeMultiTexture:
                 // Bind texture id for textures
-                glBindTexture(GL_TEXTURE_2D, mQuads[i].texture + 1);
+                getTextureManager().bindTextureId(mQuads[i].texture);
                 break;
         }
 
         switch (mMode) {
             case MeshModeWireframe:
                 glColor3f(0.0, 1.0, 0.0);
-                glBindTexture(GL_TEXTURE_2D, 0);
+                getTextureManager().bindTextureId(TEXTURE_WHITE, TextureManager::TextureStorage::SYSTEM);
                 break;
             case MeshModeSolid:
                 // Bind WHITE texture for solid colors
-                glBindTexture(GL_TEXTURE_2D, 0);
+                getTextureManager().bindTextureId(TEXTURE_WHITE, TextureManager::TextureStorage::SYSTEM);
                 break;
             case MeshModeTexture:
             case MeshModeMultiTexture:
                 // Bind texture id for textures
-                glBindTexture(GL_TEXTURE_2D, mTris[i].texture + 1);
+                getTextureManager().bindTextureId(mTris[i].texture);
                 break;
         }
 
                 break;
             case MeshModeWireframe:
                 // Bind WHITE texture for solid colors
-                glBindTexture(GL_TEXTURE_2D, 0);
+                getTextureManager().bindTextureId(TEXTURE_WHITE, TextureManager::TextureStorage::SYSTEM);
                 break;
 #ifdef MULTITEXTURE
             case MeshModeMultiTexture:
                 glActiveTextureARB(GL_TEXTURE0_ARB);
                 glEnable(GL_TEXTURE_2D);
-                glBindTexture(GL_TEXTURE_2D, mQuads[i].texture + 1);
+                getTextureManager().bindTextureId(mQuads[i].texture);
 
                 glActiveTextureARB(GL_TEXTURE1_ARB);
                 glEnable(GL_TEXTURE_2D);
-                glBindTexture(GL_TEXTURE_2D, mQuads[i].bumpmap + 1);
+                getTextureManager().bindTextureId(mQuads[i].bumpmap);
                 break;
 #else
             case MeshModeMultiTexture:
             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);
+                getTextureManager().bindTextureId(mQuads[i].texture);
                 break;
         }
 
                 break;
             case MeshModeWireframe:
                 // Bind WHITE texture for solid colors
-                glBindTexture(GL_TEXTURE_2D, 0);
+                getTextureManager().bindTextureId(TEXTURE_WHITE, TextureManager::TextureStorage::SYSTEM);
                 break;
 #ifdef MULTITEXTURE
             case MeshModeMultiTexture:
                 glActiveTextureARB(GL_TEXTURE0_ARB);
                 glEnable(GL_TEXTURE_2D);
-                glBindTexture(GL_TEXTURE_2D, mTris[i].texture + 1);
+                getTextureManager().bindTextureId(mTris[i].texture);
 
                 glActiveTextureARB(GL_TEXTURE1_ARB);
                 glEnable(GL_TEXTURE_2D);
-                glBindTexture(GL_TEXTURE_2D, mTris[i].bumpmap + 1);
+                getTextureManager().bindTextureId(mTris[i].bumpmap);
                 break;
 #else
             case MeshModeMultiTexture:
             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);
+                getTextureManager().bindTextureId(mTris[i].texture);
                 break;
         }
 

src/Render.cpp

     float x = 0.0f, y = 0.0f, z = 0.0f;
     float w = getWindow().getWidth(), h = getWindow().getHeight();
 
-    if (getTextureManager().getTextureCount() <= 0)
-        return;
-
     // Mongoose 2002.01.01, Rendered while game is loading...
     //! \fixme seperate logo/particle coor later
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     glTranslatef(0.0f, 0.0f, -2000.0f);
     glRotatef(180.0f, 1.0f, 0.0f, 0.0f);
 
-    if (getTextureManager().getTextureCount() < 2)
-        getTextureManager().bindTextureId(0); //! \fixme store texture id somewhere
-    else
-        getTextureManager().bindTextureId(1);
+    getTextureManager().bindTextureId(TEXTURE_SPLASH, TextureManager::TextureStorage::SYSTEM);
 
     glBegin(GL_TRIANGLE_STRIP);
     glTexCoord2f(1.0, 1.0);

src/Room.cpp

     mesh.bufferNormalArray(normalCount, normalArray);
     mesh.bufferColorArray(vertexCount, colorArray);
 
-    tr.getRoomTriangles(index, getGame().getTextureStart(),
-                        &triCount, &indices, &texCoords, &textures,
-                        &fflags);
+    tr.getRoomTriangles(index, 0, &triCount, &indices, &texCoords, &textures, &fflags);
 
     mesh.bufferTriangles(triCount, indices, texCoords, textures, fflags);
 #else
         tr.getRoomTriangle(index, t,
                            indices, texCoords, &texture, &flags);
 
-        texture += getGame().getTextureStart();
-
         if (texture > (int)TextureLimit) {
             getLog() << "Handling bad room[" << index << "].tris["
                      << t << "].texture = " << texture << Log::endl;
         tr.getRoomRectangle(index, r,
                             indices, texCoords, &texture, &flags);
 
-        texture += getGame().getTextureStart();
-
         if (texture > (int)TextureLimit) {
             getLog() << "Handling bad room[" << index << "].quad["
                      << r << "].texture = " << texture << Log::endl;
         tr.getRoomTriangle(index, t,
                            indices, texCoords, &texture, &flags);
 
-        // Adjust texture id using getGame().getTextureStart() to map into
-        // correct textures
-        texture += getGame().getTextureStart();
-
         unsigned int j = tris_mesh_map[texture] - 1;
 
         // Setup per vertex
         tr.getRoomRectangle(index, r,
                             indices, texCoords, &texture, &flags);
 
-        // Adjust texture id using getGame().getTextureStart() to map into
-        // correct textures
-        texture += getGame().getTextureStart();
-
         if (texture > (int)TextureLimit) {
             texture = TextureLimit - 1;
         }
     glPushMatrix();
     //LightingSetup();
 
-    getTextureManager().bindTextureId(0); // \fixme WHITE texture
+    getTextureManager().bindTextureId(TEXTURE_WHITE, TextureManager::TextureStorage::SYSTEM);
 
     if ((!alpha) && getRender().getMode() == Render::modeWireframe) {
         glLineWidth(2.0);

src/Sprite.cpp

 #include "Camera.h"
 #include "Game.h"
 #include "Render.h"
+#include "TextureManager.h"
 #include "Sprite.h"
 
 SpriteSequence::SpriteSequence(TombRaider& tr, unsigned int item, unsigned int sequence) {
     texel[0][0] = (float)(x) / texelScale;
     texel[0][1] = (float)(y + height) / texelScale;
 
-    texture = sprite->tile + getGame().getTextureStart();
+    texture = sprite->tile;
     radius = width2 / 2.0f;
 }
 
     tr.getRoomSprite(room, index,
                      10.0f, &texture, pos, spriteVertices, spriteTexCoords);
 
-    texture += getGame().getTextureStart(); // OpenRaider preloads some textures
-
     for (unsigned int j = 0; j < 12; j++)
         vertex[j / 3][j % 3] = spriteVertices[j];
 
             glColor3ubv(WHITE);
             break;
         default:
-            glBindTexture(GL_TEXTURE_2D, texture + 1);
+            getTextureManager().bindTextureId(texture);
 
             glBegin(GL_TRIANGLE_STRIP);
             glTexCoord2fv(texel[0]);

src/StaticMesh.cpp

 
     if ((getRender().getMode() != Render::modeWireframe)
         && (getRender().getMode() != Render::modeSolid)) {
-        glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
-        glBindTexture(GL_TEXTURE_2D, texture + 1);
+        getTextureManager().bindTextureId(texture);
     }
 
     glBegin(GL_TRIANGLES);
         texture = gColorTextureHACK.at(colorI);
     } catch (...) {
         unsigned char* image = generateColorTexture(color, 32, 32, 32);
-        texture = getTextureManager().loadBufferSlot(image, 32, 32,
-                  RGBA, 32, getTextureManager().getTextureCount());
+        texture = getTextureManager().loadBufferSlot(image, 32, 32, RGBA, 32);
         delete [] image;
     }
 
                                    vertexIndices, st,
                                    &texture, &transparency);
         triangles.push_back(
-            new TexturedTriangle(vertexIndices, st, texture + getGame().getTextureStart(), transparency));
+            new TexturedTriangle(vertexIndices, st, texture, transparency));
     }
 
     // Coloured Triangles
         transparency = 0;
 
         triangles.push_back(
-            new TexturedTriangle(vertexIndices, st, texture + getGame().getTextureStart(), transparency));
+            new TexturedTriangle(vertexIndices, st, texture, transparency));
     }
 
     // Textured Rectangles
                                     vertexIndices, st,
                                     &texture, &transparency);
         triangles.push_back(
-            new TexturedTriangle(vertexIndices, st, texture + getGame().getTextureStart(), transparency));
+            new TexturedTriangle(vertexIndices, st, texture, transparency));
         triangles.push_back(
-            new TexturedTriangle(vertexIndices + 3, st + 6, texture + getGame().getTextureStart(),
-                                 transparency));
+            new TexturedTriangle(vertexIndices + 3, st + 6, texture, transparency));
     }
 
     // Coloured Rectangles
         transparency = 0;
 
         triangles.push_back(
-            new TexturedTriangle(vertexIndices, st, texture + getGame().getTextureStart(), transparency));
+            new TexturedTriangle(vertexIndices, st, texture, transparency));
         triangles.push_back(
-            new TexturedTriangle(vertexIndices + 3, st, texture + getGame().getTextureStart(), transparency));
+            new TexturedTriangle(vertexIndices + 3, st, texture, transparency));
     }
 }
 
         if (getRender().getMode() == Render::modeWireframe)
             glColor3ubv(WHITE);
 
-        glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
-        glBindTexture(GL_TEXTURE_2D, 1);  // White texture for colors
+        getTextureManager().bindTextureId(TEXTURE_WHITE, TextureManager::TextureStorage::SYSTEM);
 
         for (unsigned int i = 0; i < triangles.size(); i++)
             triangles.at(i)->display(vertices, colors, normals);

src/TextureManager.cpp

 #include "utils/png.h"
 #endif
 
-TextureManager::TextureManager() {
-    mFlags = 0;
+std::vector<unsigned int>& TextureManager::getIds(TextureStorage s) {
+    if (s == TextureStorage::GAME)
+        return mTextureIdsGame;
+    else
+        return mTextureIdsSystem;
 }
 
 TextureManager::~TextureManager() {
-    reset();
-}
+    while (mTextureIdsSystem.size() > 0) {
+        unsigned int id = mTextureIdsSystem.at(mTextureIdsSystem.size() - 1);
+        glDeleteTextures(1, &id);
+        mTextureIdsSystem.pop_back();
+    }
 
-void TextureManager::reset() {
-    while (mTextureIds.size() > 0) {
-        unsigned int id = mTextureIds.at(mTextureIds.size() - 1);
+    while (mTextureIdsGame.size() > 0) {
+        unsigned int id = mTextureIdsGame.at(mTextureIdsGame.size() - 1);
         glDeleteTextures(1, &id);
-        mTextureIds.pop_back();
+        mTextureIdsGame.pop_back();
     }
 }
 
 int TextureManager::initialize() {
     unsigned char* image = generateColorTexture(WHITE, 32, 32, 32);
-    loadBufferSlot(image, 32, 32, RGBA, 32, mTextureIds.size());
+    int res = loadBufferSlot(image, 32, 32, RGBA, 32, TextureStorage::SYSTEM, TEXTURE_WHITE);
     delete [] image;
-
-    //! \fixme Temporary
-    std::string filename(getRunTime().getPakDir());
-    filename += "/tr2/TITLE.PCX";
-    if (loadPCX(filename.c_str()) < 0) {
-        //! \fixme Error Checking. Return negative error code, check in calling place too
-        filename = getRunTime().getDataDir();
-        filename += "/splash.tga";
-        loadTGA(filename.c_str());
+    if (res < 0) {
+        return -1;
     }
 
-    return (mTextureIds.size() == 0) ? -1 : 0;
-}
-
-void TextureManager::setFlag(TextureFlag flag) {
-    mFlags |= flag;
-}
-
-void TextureManager::clearFlag(TextureFlag flag) {
-    mFlags &= ~flag;
-}
-
-int TextureManager::getTextureCount() {
-    return mTextureIds.size();
-}
-
-void TextureManager::disableMultiTexture() {
-    mFlags &= ~fUseMultiTexture;
-
-#ifdef MULTITEXTURE
-    glDisable(GL_TEXTURE_2D);
-    glActiveTextureARB(GL_TEXTURE0_ARB);
-#endif
-}
-
-void TextureManager::useMultiTexture(float aU, float aV, float bU, float bV) {
-    if (!(mFlags & fUseMultiTexture))
-        return;
-
-#ifdef MULTITEXTURE
-    glMultiTexCoord2fARB(GL_TEXTURE0_ARB, aU, aV);
-    glMultiTexCoord2fARB(GL_TEXTURE1_ARB, bU, bV);
-#endif
-}
-
-void TextureManager::bindMultiTexture(int texture0, int texture1) {
-    assert(texture0 >= 0);
-    assert(texture1 >= 0);
-    assert((unsigned int)texture0 < mTextureIds.size());
-    assert((unsigned int)texture1 < mTextureIds.size());
-
-    mFlags |= fUseMultiTexture;
-
-#ifdef MULTITEXTURE
-    glActiveTextureARB(GL_TEXTURE0_ARB);
-    glEnable(GL_TEXTURE_2D);
-    glBindTexture(GL_TEXTURE_2D, mTextureIds.at(texture0));
+    //! \fixme Temporary?
+    std::string filename = getRunTime().getPakDir() + "/tr2/TITLE.PCX";
+    if (loadPCX(filename.c_str(), TextureStorage::SYSTEM, TEXTURE_SPLASH) < 0) {
+        filename = getRunTime().getDataDir() + "/splash.tga";
+        if (loadTGA(filename.c_str(), TextureStorage::SYSTEM, TEXTURE_SPLASH) < 0) {
+            return -2;
+        }
+    }
 
-    glActiveTextureARB(GL_TEXTURE1_ARB);
-    glEnable(GL_TEXTURE_2D);
-    glBindTexture(GL_TEXTURE_2D, mTextureIds.at(texture1));
-#endif
+    return 0;
 }
 
 int TextureManager::loadBufferSlot(unsigned char* image,
                                    unsigned int width, unsigned int height,
                                    ColorMode mode, unsigned int bpp,
-                                   unsigned int slot, bool filter) {
+                                   TextureStorage s, int slot, bool filter) {
     assert(image != NULL);
     assert(width > 0);
     assert(height > 0);
            || (mode == RGBA) || (mode ==  BGRA));
     assert((bpp == 8) || (bpp == 24) || (bpp == 32));
 
-    while (mTextureIds.size() <= slot) {
+    if (slot == -1)
+        slot = getIds(s).size();
+
+    while (getIds(s).size() <= slot) {
         unsigned int id;
         glGenTextures(1, &id);
-        mTextureIds.push_back(id);
+        getIds(s).push_back(id);
     }
 
     unsigned int glcMode;
     glColor3ubv(WHITE);
     glEnable(GL_DEPTH_TEST);
     glShadeModel(GL_SMOOTH);
-
     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-
-    glBindTexture(GL_TEXTURE_2D, mTextureIds.at(slot));
+    glBindTexture(GL_TEXTURE_2D, getIds(s).at(slot));
 
     if (filter) {
         glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
 
     glTexImage2D(GL_TEXTURE_2D, 0, bpp / 8, width, height, 0, glcMode, GL_UNSIGNED_BYTE, image);
 
-    //glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
-
     return slot;
 }
 
-void TextureManager::bindTextureId(unsigned int n) {
-    assert(n < mTextureIds.size());
+void TextureManager::bindTextureId(unsigned int n, TextureStorage s) {
+    assert(n < getIds(s).size());
 
     glEnable(GL_TEXTURE_2D);
-    //glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 
-    glBindTexture(GL_TEXTURE_2D, mTextureIds.at(n));
+    glBindTexture(GL_TEXTURE_2D, getIds(s).at(n));
 }
 
-int TextureManager::loadImage(const char* filename) {
+int TextureManager::loadImage(const char* filename, TextureStorage s, int slot) {
     if (stringEndsWith(filename, ".pcx") || stringEndsWith(filename, ".PCX")) {
-        return loadPCX(filename);
+        return loadPCX(filename, s, slot);
     } else if (stringEndsWith(filename, ".png") || stringEndsWith(filename, ".PNG")) {
-        return loadPNG(filename);
+        return loadPNG(filename, s, slot);
     } else if (stringEndsWith(filename, ".tga") || stringEndsWith(filename, ".TGA")) {
-        return loadTGA(filename);
+        return loadTGA(filename, s, slot);
     } else {
         getLog() << "No known image file type? (" << filename << ")" << Log::endl;
     }
     return -1;
 }
 
-int TextureManager::loadPCX(const char* filename) {
+int TextureManager::loadPCX(const char* filename, TextureStorage s, int slot) {
     assert(filename != NULL);
     assert(filename[0] != '\0');
 
             delete [] image;
             image = image2;
         }
-        id = loadBufferSlot(image, w, h, c, bpp, mTextureIds.size());
+        id = loadBufferSlot(image, w, h, c, bpp, s, slot);
         delete [] image;
     }
 
     return id;
 }
 
-int TextureManager::loadPNG(const char* filename) {
+int TextureManager::loadPNG(const char* filename, TextureStorage s, int slot) {
 #ifdef USING_PNG
     assert(filename != NULL);
     assert(filename[0] != '\0');
             delete [] image;
             image = image2;
         }
-        id = loadBufferSlot(image, w, h, c, bpp, mTextureIds.size());
+        id = loadBufferSlot(image, w, h, c, bpp, s, slot);
         delete [] image;
     }
 
 #endif
 }
 
-int TextureManager::loadTGA(const char* filename) {
+int TextureManager::loadTGA(const char* filename, TextureStorage s, int slot) {
     assert(filename != NULL);
     assert(filename[0] != '\0');
 
             id = loadBufferSlot(image, w, h,
                                 (type == 2) ? RGBA : RGB,
                                 (type == 2) ? 32 : 24,
-                                mTextureIds.size());
+                                s, slot);
             delete [] image;
         }
     }

src/TombRaider.cpp

     return _num_static_meshes;
 }
 
-
+/*
 int TombRaider::NumSprites() {
     return _num_sprite_textures;
 }
-
+*/
 
 int TombRaider::NumSpriteSequences() {
     return _num_sprite_sequences;
     return _items;
 }
 
-
+/*
 tr2_object_texture_t* TombRaider::ObjectTextures() {
     return _object_textures;
 }
 
-
 unsigned int TombRaider::getNumBoxes() {
     return _num_boxes;
 }
-
+*/
 
 tr2_box_t* TombRaider::Box() {
     return _boxes;
 
 
 tr2_moveable_t* TombRaider::Moveable() {
-    /*
-       if (n > 0 || n > (int)_num_moveables)
-       return NULL;
-       */
-
     return _moveables;
 }
 
 
 tr2_meshtree_t* TombRaider::MeshTree() {
-    /*
-       if (n > 0 || n > (int)_num_mesh_trees)
-       return NULL;
-       */
-
     return _mesh_trees;
 }
 
     return _sprite_sequences;
 }
 
-unsigned char* TombRaider::SpecialTexTile(int texture) {
-    unsigned char* image;
-    unsigned char* ptr;
-
-
-    image = NULL;
-
-    if (texture >= 0 && texture < NumSpecialTextures()) {
-        // Get base and offset into 32bit special textures/bump maps
-        ptr = _tex_special;
-        ptr += 256 * 256 * 4 * texture;
-
-        // Clone it as a single 256x256 @ 32bpp image
-        image = new unsigned char[256 * 256 * 4];
-        memcpy(image, ptr, 256 * 256 * 4);
-    }
-
-    return image;
-}
-
 
 int TombRaider::NumSpecialTextures() {
     return _num_tex_special;
 }
 
 
-unsigned int* TombRaider::Palette16() {
-    return _palette16;
-}
-
-
-unsigned char* TombRaider::Palette8() {
-    return (unsigned char*)_palette8;
-}
-
-
-int TombRaider::checkMime(const char* filename) {
-    FILE* f;
-    unsigned int version;
-
-    if (!filename || !filename[0]) {
-        print("checkFile", "Given filename was empty string or NULL");
-        return -1;
-    }
-
-    f = fopen(filename, "rb");
-
-    if (!f) {
-        perror(filename);
-        return -1;
-    }
-
-    //! \fixme Endianess
-    fread(&version, sizeof(version), 1, f);
-    fclose(f);
-
-    switch (version) {
-        case 0x00000020:
-        case 0x0000002d:
-        case 0xff080038:
-        case 0xff180038:
-        case 0xfffffff0: // bogus
-        case 0x00345254: // "TR4\0"
-            return 0;
-        default:
-            return 1;
-    }
-}
-
-
 int TombRaider::Load(const char* filename) {
     FILE* f;
     int i, j, l;
     unsigned int num_mesh_data_words, num_mesh_pointers, data_size, data_offset;
     unsigned int* mesh_pointer_list;
     unsigned char* raw_mesh_data;
-    bool tr5;
     long debugf;
 
 
 
     printDebug("Load", "mPakVersion = %u", mPakVersion);
 
-    tr5 = false;
-
     switch (mPakVersion) {
         case 0x00000020:
             mEngineVersion = TR_VERSION_1;
 // Public Accessors
 ////////////////////////////////////////////////////////////
 
-float TombRaider::adjustTexel(unsigned char texel, char offset) {
-    if (offset >= 0)
-        texel++;
-    else
-        texel--;
-
-    return ((float)texel / 255.0f);
-}
-
 
 void TombRaider::computeRotationAngles(unsigned short** frame,
                                        unsigned int* frame_offset,
     *v = (float)y / 255.0f;
 }
 
-
+/*
 int TombRaider::getBumpMapCount() {
     return _num_bump_map_textures / 2;
 }
-
+*/
 
 void TombRaider::getColor(int index, float color[4]) {
     switch (getEngine()) {
     return skyMesh;
 }
 
-
+#if 0
 void TombRaider::getSprites() {
-#ifdef FIXME
     int i, j, k, l, x, y, s_index, width, height;
     float scale, width2, height2;
     tr2_sprite_texture_t* sprite;
     }
 
     printf("\n");
-#endif
 }
-
+#endif
 
 void TombRaider::getSoundSample(unsigned int index,
                                 unsigned int* bytes, unsigned char** data) {
     _num_overlaps = 0;
 }
 
-
+/*
 void TombRaider::setDebug(bool toggle) {
     mDebug = toggle;
 }
 
-
 void TombRaider::setRoomVertexLightingFactor(float f) {
     mRoomVertexLightingFactor = f;
 }
 void TombRaider::setTexelScalingFactor(float f) {
     mTexelScale = f;
 }
+*/
 
 ////////////////////////////////////////////////////////////
 // Private Accessors

src/UI.cpp

 
     //! \fixme TODO use proper texture slot
     fontTex = getTextureManager().loadBufferSlot((unsigned char*)tex_data,
-              tex_x, tex_y, RGBA, 32, 0, false);
+              tex_x, tex_y, RGBA, 32, TextureManager::TextureStorage::SYSTEM, -1, false);
 
     stbi_image_free(tex_data);
 
     glEnableClientState(GL_COLOR_ARRAY);
 
     // Setup texture
-    getTextureManager().bindTextureId(fontTex);
+    getTextureManager().bindTextureId(fontTex, TextureManager::TextureStorage::SYSTEM);
 
     // Render command lists
     for (int n = 0; n < cmd_lists_count; n++) {