TextureManager using vector, now also global service

ChangeLog.md

     * Modified utils/png to allow compilation with different integer sizes
       Thanks to Christian for his help and his Linux machine :)
     * Removed TextureManagers fUseMipmaps flag, now always used
+    * TextureManager now using vector for GL texture IDs
+    * TextureManager now global object, no longer part of Render
 
     [ 20140623 ]
     * Use unsigned char instead of float for colors

include/Render.h

 #include <vector>
 
 #include "Room.h"
-#include "TextureManager.h"
 #include "ViewVolume.h"
 
 /*!
     int getMode();
 
     /*!
-     * \brief Loads textures in a certain id slot
-     * \param image Image to load
-     * \param width width of image
-     * \param height height of image
-     * \param id id for texture
-     * \sa Texture::loadBufferSlot()
-     */
-    void loadTexture(unsigned char *image,
-                          unsigned int width, unsigned int height,
-                          unsigned int id);
-
-    /*!
-     * \brief Sets up textures for OpenRaider
-     * \param textureDir Is valid and exists with textures
-     * \returns number of loaded textures
-     */
-    int initTextures(char *textureDir);
-
-    /*!
      * Removes current world/entity/etc geometry
      */
     void ClearWorld();
 
     //! \fixme should be private
     ViewVolume mViewVolume; //!< View Volume for frustum culling
-    TextureManager mTexture; //!< Texture subsystem
 
 private:
 

include/TextureManager.h

 #ifndef _TEXTURE_MANAGER_H
 #define _TEXTURE_MANAGER_H
 
+#include <vector>
+
 /*!
  * \brief Texture registry
  */
      */
     void reset();
 
-    /*!
-     * \brief Generates a texture buffer with (width * height * 4) bytes.
-     * \param rgba 32bpp RGBA color to fill into buffer
-     * \param width width of newly allocated buffer, power of 2, pref same as height
-     * \param height height of newly allocated buffer, power of 2, pref same as width
-     * \returns newly allocated texture buffer filled with specified color
-     */
-    static unsigned char *generateColorTexture(const unsigned char rgba[4],
-                                                unsigned int width,
-                                                unsigned int height);
+    int initialize();
 
     /*!
      * \brief Get number of textures in use
      * \param height height of image
      * \param mode mode of image
      * \param bpp bits per pixel of image
-     * \returns texture ID or < 0 on error
-     */
-    int loadBuffer(unsigned char *image,
-                    unsigned int width, unsigned int height,
-                    ColorMode mode, unsigned int bpp);
-
-    /*!
-     * \brief Loads Buffer as texture
-     * \param image pixmap matching other params
-     * \param width width of image
-     * \param height height of image
-     * \param mode mode of image
-     * \param bpp bits per pixel of image
      * \param slot slot (ID) of image
      * \returns texture ID or < 0 on error
      */
                         unsigned int slot);
 
     /*!
-     * \brief Generates and loads a solid color texture.
-     * \param rgba color for new texture
-     * \param width width of new texture
-     * \param height height of new texture
-     * \returns texture ID or -1 on error
-     */
-    int loadColorTexture(const unsigned char rgba[4],
-                            unsigned int width, unsigned int height);
-
-    /*!
      * \brief Loads TGA file as texture
      * \param filename Existing TGA file
      * \returns ID of new texture or -1 on error
      */
     void setFlag(TextureFlag flag);
 
-    /*!
-     * \brief Sets up GL texturing.
-     *
-     * Must be called as first setup step!
-     * \param n maximum number of textures you wish to allow
-     */
-    void setMaxTextureCount(unsigned int n);
-
-    void useMultiTexture(float u, float v);
-
     void useMultiTexture(float aU, float aV, float bU, float bV);
 
 private:
-    unsigned int *mTextureIds;  //!< GL texture list
-    unsigned int mTextureCount; //!< Texture counter
-    unsigned int mTextureLimit; //!< The texture limit
-    unsigned int mFlags;        //!< Class options
+    std::vector<unsigned int> mTextureIds;
+    unsigned int mFlags;
 };
 
+TextureManager &getTextureManager();
+
 #endif
 

include/utils/pixel.h

 #ifndef _UTILS_PIXEL_H_
 #define _UTILS_PIXEL_H_
 
+unsigned char *generateColorTexture(const unsigned char *rgba, unsigned int width,
+        unsigned int height, unsigned int bpp);
+
 void bgr2rgb24(unsigned char *image, unsigned int w, unsigned int h);
 void bgra2rgba32(unsigned char *image, unsigned int w, unsigned int h);
 void argb2rgba32(unsigned char *image, unsigned int w, unsigned int h);

src/Game.cpp

 #include "OpenRaider.h"
 #include "Sound.h"
 #include "StaticMesh.h"
+#include "TextureManager.h"
 #include "utils/strings.h"
 
 #include "games/TombRaider1.h"
 
 int Game::initialize() {
     // Enable Renderer
-    mTextureStart = getRender().initTextures(getOpenRaider().mDataDir);
     getRender().setMode(Render::modeLoadScreen);
 
+    mTextureStart = getTextureManager().getTextureCount();
+
     return 0;
 }
 
         mTombRaider.Texture(i, &image, &bumpmap);
 
         // Overwrite any previous level textures on load
-        getRender().loadTexture(image, 256, 256, (mTextureStart - 1) + i);
+        getTextureManager().loadBufferSlot(image, 256, 256,
+                TextureManager::RGBA, 32, (mTextureStart - 1) + i);
 
 #ifdef MULTITEXTURE
         gMapTex2Bump[(mTextureStart - 1) + i] = -1;
             gMapTex2Bump[(mTextureStart - 1) + i] = (mTextureStart - 1) + i +
                     mTombRaider.NumTextures();
 #endif
-            getRender().loadTexture(bumpmap, 256, 256, (mTextureStart - 1) + i +
-                    mTombRaider.NumTextures());
+            getTextureManager().loadBufferSlot(bumpmap, 256, 256,
+                    TextureManager::RGBA, 32,
+                    (mTextureStart - 1) + i + mTombRaider.NumTextures());
         }
 
         if (image)

src/OpenRaider.cpp

 #include "math/math.h"
 #include "Menu.h"
 #include "Sound.h"
+#include "TextureManager.h"
 #include "TombRaider.h"
 #include "utils/strings.h"
 #include "utils/time.h"
         return -4;
     }
 
+    // Initialize Texture Manager
+    error = getTextureManager().initialize();
+    if (error != 0) {
+        printf("Could not initialize Textures (%d)!\n", error);
+        return -5;
+    }
+
     // Initialize game engine
     error = getGame().initialize();
     if (error != 0) {
         printf("Could not initialize Game (%d)!\n", error);
-        return -5;
+        return -6;
     }
 
 #ifdef DEBUG

src/Render.cpp

 #include "Game.h"
 #include "OpenRaider.h"
 #include "Render.h"
+#include "TextureManager.h"
 #include "utils/strings.h"
 #include "utils/tga.h"
 #include "Window.h"
 }
 
 
-void Render::loadTexture(unsigned char *image,
-        unsigned int width, unsigned int height,
-        unsigned int id)
-{
-    glColor3ubv(WHITE);
-    mTexture.loadBufferSlot(image, width, height, TextureManager::RGBA, 32, id);
-}
-
-
-int Render::initTextures(char *textureDir) {
-    char *filename;
-    unsigned int numTextures = 0;
-
-    mTexture.reset();
-    mTexture.setMaxTextureCount(128);  /* TR never needs more than 32 iirc
-                                          However, color texturegen is a lot */
-
-    if (mTexture.loadColorTexture(WHITE, 32, 32) > -1)
-        numTextures++;
-
-    // Temporary
-    filename = bufferString("%s/tr2/TITLE.PCX", getOpenRaider().mPakDir);
-    if (mTexture.loadPCX(filename) > -1) {
-        numTextures++;
-        delete [] filename;
-    } else {
-        delete [] filename;
-        //! \fixme Error Checking. Return negative error code, check in calling place too
-        filename = bufferString("%s/%s", textureDir, "splash.tga");
-        if (mTexture.loadTGA(filename) > -1)
-            numTextures++;
-        delete [] filename;
-    }
-
-    return numTextures;
-}
-
-
 // Texture must be set to WHITE solid color texture
 void renderTrace(int color, vec3_t start, vec3_t end)
 {
     float x = 0.0f, y = 0.0f, z = -160.0f;
     float w = getWindow().getWidth(), h = getWindow().getHeight();
 
-    if (mTexture.getTextureCount() <= 0)
+    if (getTextureManager().getTextureCount() <= 0)
         return;
 
     // Mongoose 2002.01.01, Rendered while game is loading...
     glTranslatef(0.0f, 0.0f, -2000.0f);
     glRotatef(180.0f, 1.0f, 0.0f, 0.0f);
 
-    mTexture.bindTextureId(1); //! \fixme store texture id somewhere
+    if (getTextureManager().getTextureCount() < 2)
+        getTextureManager().bindTextureId(0); //! \fixme store texture id somewhere
+    else
+        getTextureManager().bindTextureId(1);
 
     glBegin(GL_TRIANGLE_STRIP);
     glTexCoord2f(1.0, 1.0);

src/Room.cpp

 #include "Game.h"
 #include "Render.h"
 #include "Room.h"
+#include "TextureManager.h"
 
 #ifdef MULTITEXTURE
 #include <map>
     glPushMatrix();
     //LightingSetup();
 
-    getRender().mTexture.bindTextureId(0); // WHITE texture
+    getTextureManager().bindTextureId(0); // \fixme WHITE texture
 
     if ((!alpha) && getRender().getMode() == Render::modeWireframe) {
         glLineWidth(2.0);
 
     glPopMatrix();
 
-    //getRender().mTexture.bindTextureId(0);
-
     // Draw other room meshes and sprites
     if (alpha || (getRender().getMode() == Render::modeWireframe)
             || (getRender().getMode() == Render::modeSolid)) {

src/StaticMesh.cpp

 #include "global.h"
 #include "Game.h"
 #include "Render.h"
+#include "TextureManager.h"
+#include "utils/pixel.h"
 #include "StaticMesh.h"
 
-#ifdef EXPERIMENTAL
-std::vector<unsigned int> gColorTextureHACK;
-#endif
-
 TexturedTriangle::TexturedTriangle(int i[3], vec_t s[6], int tex, unsigned short trans) {
     index[0] = i[0];
     index[1] = i[1];
 }
 
 #ifdef EXPERIMENTAL
+
+#include <map>
+std::map<unsigned int, unsigned int> gColorTextureHACK;
+
 int setupTextureColor(float *colorf) {
     unsigned char color[4];
     unsigned int colorI;
-    int texture;
+    unsigned int texture;
 
     color[0] = (unsigned char)(colorf[0]*255.0f);
     color[1] = (unsigned char)(colorf[1]*255.0f);
     ((unsigned char *)(&colorI))[1] = color[2];
     ((unsigned char *)(&colorI))[0] = color[3];
 
-    bool found = false;
-    unsigned int foundIndex = 0;
-    for (foundIndex = 0; foundIndex < gColorTextureHACK.size(); foundIndex++) {
-        if (gColorTextureHACK[foundIndex] == colorI) {
-            found = true;
-            break;
-        }
-    }
-
-    if (!found) {
-        gColorTextureHACK.push_back(colorI);
-        texture = getGame().getTextureOffset() + gColorTextureHACK.size();
-
-        getRender().loadTexture(TextureManager::generateColorTexture(color, 32, 32),
-                32, 32, texture);
-    } else {
-        texture = getGame().getTextureOffset() + foundIndex;
+    try {
+        texture = gColorTextureHACK.at(colorI);
+    } catch (...) {
+        unsigned char *image = generateColorTexture(color, 32, 32, 32);
+        texture = getTextureManager().loadBufferSlot(image, 32, 32,
+                TextureManager::RGBA, 32, getTextureManager().getTextureCount());
+        delete [] image;
     }
 
     return texture;

src/TextureManager.cpp

 #include <stdarg.h>
 
 #include "global.h"
+#include "OpenRaider.h"
 #include "utils/pcx.h"
 #include "utils/pixel.h"
 #include "utils/strings.h"
 #include "TextureManager.h"
 
 TextureManager::TextureManager() {
-    mTextureIds = NULL;
     mFlags = 0;
-    mTextureCount = 0;
-    mTextureLimit = 0;
 }
 
 TextureManager::~TextureManager() {
     reset();
 }
 
-unsigned char *TextureManager::generateColorTexture(const unsigned char rgba[4],
-        unsigned int width, unsigned int height) {
-    assert(rgba != NULL);
-    assert(width > 0);
-    assert(height > 0);
-
-    unsigned char *image = new unsigned char[height * width * 4];
-
-    for (unsigned int i = 0; i < (width * height); i++) {
-        image[i * 4] = rgba[0];
-        image[(i * 4) + 1] = rgba[1];
-        image[(i * 4) + 2] = rgba[2];
-        image[(i * 4) + 3] = rgba[3];
+void TextureManager::reset() {
+    while (mTextureIds.size() > 0) {
+        unsigned int id = mTextureIds.at(mTextureIds.size() - 1);
+        glDeleteTextures(1, &id);
+        mTextureIds.pop_back();
     }
-
-    return image;
 }
 
-int TextureManager::loadColorTexture(const unsigned char rgba[4],
-        unsigned int width, unsigned int height) {
-    assert(rgba != NULL);
-    assert(width > 0);
-    assert(height > 0);
-
-    unsigned char *image = generateColorTexture(rgba, width, height);
-    int id = loadBuffer(image, width, height, RGBA, 32);
+int TextureManager::initialize() {
+    unsigned char *image = generateColorTexture(WHITE, 32, 32, 32);
+    loadBufferSlot(image, 32, 32, RGBA, 32, mTextureIds.size());
     delete [] image;
 
-    return id;
+    //! \fixme Temporary
+    char *filename = bufferString("%s/tr2/TITLE.PCX", getOpenRaider().mPakDir);
+    if (loadPCX(filename) < 0) {
+        delete [] filename;
+        //! \fixme Error Checking. Return negative error code, check in calling place too
+        filename = bufferString("%s/%s", getOpenRaider().mDataDir, "splash.tga");
+        loadTGA(filename);
+    }
+    delete [] filename;
+
+    return (mTextureIds.size() == 0) ? -1 : 0;
 }
 
 void TextureManager::setFlag(TextureFlag flag) {
     mFlags &= ~flag;
 }
 
-void TextureManager::reset() {
-    if (mTextureIds) {
-        glDeleteTextures(mTextureLimit, mTextureIds);
-        delete [] mTextureIds;
-    }
-
-    mTextureIds = NULL;
-    mTextureCount = 0;
-    mTextureLimit = 0;
+int TextureManager::getTextureCount() {
+    return mTextureIds.size();
 }
 
 void TextureManager::disableMultiTexture() {
     glMultiTexCoord2fARB(GL_TEXTURE1_ARB, bU, bV);
 }
 
-void TextureManager::useMultiTexture(float u, float v) {
-    useMultiTexture(u, v, u, v);
-}
-
 void TextureManager::bindMultiTexture(int texture0, int texture1) {
-    assert(mTextureIds != NULL);
     assert(texture0 >= 0);
     assert(texture1 >= 0);
-    assert((unsigned int)texture0 <= mTextureCount);
-    assert((unsigned int)texture1 <= mTextureCount);
+    assert((unsigned int)texture0 < mTextureIds.size());
+    assert((unsigned int)texture1 < mTextureIds.size());
 
     mFlags |= fUseMultiTexture;
 
     glActiveTextureARB(GL_TEXTURE0_ARB);
     glEnable(GL_TEXTURE_2D);
-    glBindTexture(GL_TEXTURE_2D, mTextureIds[texture0]);
+    glBindTexture(GL_TEXTURE_2D, mTextureIds.at(texture0));
 
     glActiveTextureARB(GL_TEXTURE1_ARB);
     glEnable(GL_TEXTURE_2D);
-    glBindTexture(GL_TEXTURE_2D, mTextureIds[texture1]);
-}
-
-void TextureManager::setMaxTextureCount(unsigned int n) {
-    mTextureLimit = n;
-    mTextureIds = new unsigned int[n];
-    glGenTextures(n, mTextureIds);
-}
-
-int TextureManager::getTextureCount() {
-    return mTextureCount - 1;
+    glBindTexture(GL_TEXTURE_2D, mTextureIds.at(texture1));
 }
 
-int TextureManager::loadBuffer(unsigned char *image,
+int TextureManager::loadBufferSlot(unsigned char *image,
         unsigned int width, unsigned int height,
-        ColorMode mode, unsigned int bpp) {
-    int id;
-
+        ColorMode mode, unsigned int bpp,
+        unsigned int slot) {
     assert(image != NULL);
     assert(width > 0);
     assert(height > 0);
-    assert((bpp == 8) || (bpp == 24) || (bpp == 32));
+    assert((mode == GREYSCALE) || (mode == RGB)
+            || (mode == BGR) || (mode == ARGB)
+            || (mode == RGBA) || (mode ==  BGRA));
+
+    switch (mode) {
+        case GREYSCALE:
+            assert(bpp == 8);
+            break;
 
-    id = loadBufferSlot(image, width, height, mode, bpp, mTextureCount++);
+        case RGB:
+        case BGR:
+            assert(bpp == 24);
+            break;
 
-    if (id < 0)
-        return id;
+        case ARGB:
+        case RGBA:
+        case BGRA:
+            assert(bpp == 32);
+            break;
+    }
 
-    return id;
-}
+    while (mTextureIds.size() <= slot) {
+        unsigned int id;
+        glGenTextures(1, &id);
+        mTextureIds.push_back(id);
+    }
 
-int TextureManager::loadBufferSlot(unsigned char *image,
-        unsigned int width, unsigned int height,
-        ColorMode mode, unsigned int bpp,
-        unsigned int slot) {
     unsigned char bytes;
     unsigned int glcMode;
 
-    assert(mTextureIds != NULL);
-    assert(slot < mTextureLimit);
-    assert(image != NULL);
-    assert(width > 0);
-    assert(height > 0);
-    assert((bpp == 8) || (bpp == 24) || (bpp == 32));
-
     switch (mode) {
         case GREYSCALE:
-            if (bpp != 8) {
-                printf("TextureManager::Load ERROR Unsupported GREYSCALE, %i bpp\n", bpp);
-                return -1;
-            }
             bytes = 1;
             glcMode = GL_LUMINANCE;
             break;
 
         case RGB:
-            if (bpp != 24) {
-                printf("TextureManager::Load ERROR Unsupported RGB, %i bpp\n", bpp);
-                return -1;
-            }
             bytes = 3;
             glcMode = GL_RGB;
             break;
 
         case ARGB:
-            if (bpp == 32) {
-                argb2rgba32(image, width, height);
-            } else {
-                printf("TextureManager::Load ERROR Unsupported ARGB, %i bpp\n", bpp);
-                return -1;
-            }
+            argb2rgba32(image, width, height);
             bytes = 4;
             glcMode = GL_RGBA;
             break;
 
         case RGBA:
-            if (bpp != 32) {
-                printf("TextureManager::Load ERROR Unsupported RGBA, %i bpp\n", bpp);
-                return -1;
-            }
             bytes = 4;
             glcMode = GL_RGBA;
             break;
 
         case BGR:
-            if (bpp != 24) {
-                printf("TextureManager::Load ERROR Unsupported BGR, %i bpp\n", bpp);
-                return -1;
-            }
             bytes = 3;
             glcMode = GL_BGR_EXT;
             break;
 
         case BGRA:
-            if (bpp != 32) {
-                printf("TextureManager::Load ERROR Unsupported BGRA, %i bpp\n", bpp);
-                return -1;
-            }
             bytes = 4;
             glcMode = GL_BGRA_EXT;
             break;
     }
 
+    glColor3ubv(WHITE);
     glClearColor(0.0, 0.0, 0.0, 0.0);
     glEnable(GL_DEPTH_TEST);
     glShadeModel(GL_SMOOTH);
 }
 
 void TextureManager::bindTextureId(unsigned int n) {
-    assert(mTextureIds != NULL);
-    assert(n <= mTextureCount);
+    assert(n < mTextureIds.size());
 
     glEnable(GL_TEXTURE_2D);
     //glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 
-    glBindTexture(GL_TEXTURE_2D, mTextureIds[n]);
+    glBindTexture(GL_TEXTURE_2D, mTextureIds.at(n));
 }
 
 int TextureManager::loadPCX(const char *filename) {
             delete [] image;
             image = image2;
         }
-        id = loadBuffer(image, w, h, c, bpp);
+        id = loadBufferSlot(image, w, h, c, bpp, mTextureIds.size());
         delete [] image;
     }
 
     assert(filename != NULL);
     assert(filename[0] != '\0');
 
-    unsigned char *image = NULL;
-    unsigned char *image2 = NULL;
+    unsigned char *image;
     unsigned int w, h;
     char type;
     int id = -1;
     if (!tgaCheck(filename)) {
         tgaLoad(filename, &image, &w, &h, &type);
 
-        image2 = scaleBuffer(image, &w, &h, (type == 2) ? 32 : 24);
-
+        unsigned char *image2 = scaleBuffer(image, &w, &h, (type == 2) ? 32 : 24);
         if (image2) {
             delete [] image;
             image = image2;
         }
-
         if (image) {
-            id = loadBuffer(image, w, h,
+            id = loadBufferSlot(image, w, h,
                     (type == 2) ? RGBA : RGB,
-                    (type == 2) ? 32 : 24);
-
+                    (type == 2) ? 32 : 24,
+                    mTextureIds.size());
             delete [] image;
         }
     }
 
-    if (id == -1) {
-        printf("TextureManager::loadTGA> ERROR: Failed to load '%s'\n", filename);
-    }
-
     return id;
 }
 

src/main.cpp

 #include "Menu.h"
 #include "OpenRaider.h"
 #include "Render.h"
+#include "TextureManager.h"
 #include "World.h"
 #include "utils/strings.h"
 #include "utils/time.h"
 Menu gMenu;
 OpenRaider gOpenRaider;
 Render gRender;
+TextureManager gTextureManager;
 World gWorld;
 
 #ifdef USING_AL
     return gSound;
 }
 
+TextureManager &getTextureManager() {
+    return gTextureManager;
+}
+
 Window &getWindow() {
     return gWindow;
 }

src/utils/pixel.cpp

 #include "global.h"
 #include "utils/pixel.h"
 
+unsigned char *generateColorTexture(const unsigned char *rgba, unsigned int width,
+        unsigned int height, unsigned int bpp) {
+    assert(rgba != NULL);
+    assert(width > 0);
+    assert(height > 0);
+    assert((bpp % 8) == 0);
+
+    unsigned char *image = new unsigned char[height * width * (bpp / 8)];
+    for (unsigned int i = 0; i < (width * height); i++) {
+        for (unsigned int a = 0; a < (bpp / 8); a++) {
+            image[(i * (bpp / 8)) + a] = rgba[a];
+        }
+    }
+    return image;
+}
+
 void bgr2rgb24(unsigned char *image, unsigned int w, unsigned int h) {
     assert(image != nullptr);
     assert(w > 0);