LoaderTR2 tries to load object textures

ChangeLog.md

 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20141127 ]
+    * Started work on loading the object texture mapping, with debug UI
+
     [ 20141126 ]
     * Reduced code duplication for BinaryFile/BinaryMemory
     * LoaderTR2 tries to load an external SFX file

include/Render.h

             TextureManager::TextureStorage s = TextureManager::TextureStorage::GAME,
             float x = 0.0f, float y = 0.0f, float w = 256.0f, float h = 256.0f);
 
+    void debugDisplayTextile(int texture = -1,
+            float x = 0.0f, float y = 0.0f, float w = 64.0f, float h = 64.0f);
+
   private:
 
     void drawTexture(float x, float y, float w, float h,
             unsigned int texture, TextureManager::TextureStorage s);
 
+    void drawTextile(float x, float y, float w, float h, unsigned int textile);
+
     static void lightRoom(Room& room);
 
     void drawLoadScreen();
     int mSkyMesh;                         //!< Skymesh model id
     bool mSkyMeshRotation;                //!< Should Skymesh be rotated?
 
-    int debugTexture;
+    int debugTexture, debugTextile;
     TextureManager::TextureStorage debugTextureStorage;
     float debugX, debugY, debugW, debugH;
 };

include/TextureManager.h

 #ifndef _TEXTURE_MANAGER_H
 #define _TEXTURE_MANAGER_H
 
+#include <cstdint>
 #include <vector>
 
 // These are loaded into TextureStorage::SYSTEM by initialize()!
 #define TEXTURE_WHITE 0
 #define TEXTURE_SPLASH 1
 
+class TextureTileVertex {
+  public:
+    TextureTileVertex(uint8_t xc, uint8_t xp, uint8_t yc, uint8_t yp);
+
+    uint8_t xCoordinate, xPixel;
+    uint8_t yCoordinate, yPixel;
+};
+
+class TextureTile {
+  public:
+    TextureTile(uint16_t a, uint16_t t) : attribute(a), texture(t) { }
+    ~TextureTile();
+
+    void add(TextureTileVertex* t);
+
+    void displayRectangle(float x, float y, float w, float h, float z);
+
+  private:
+    uint16_t attribute;
+    uint16_t texture;
+    std::vector<TextureTileVertex*> vertices;
+};
+
 /*!
  * \brief Texture registry
  */
 
     int loadImage(const char* filename, TextureStorage s = TextureStorage::GAME, int slot = -1);
 
+    void addTile(TextureTile* t);
+    int numTiles();
+    TextureTile& getTile(int index);
+
   private:
     std::vector<unsigned int>& getIds(TextureStorage s);
 
 
     std::vector<unsigned int> mTextureIdsGame;
     std::vector<unsigned int> mTextureIdsSystem;
+
+    std::vector<TextureTile*> tiles;
 };
 
 TextureManager& getTextureManager();

src/Render.cpp

     mFlags = (fRoomAlpha | fEntityModels | fRenderPonytail);
 
     debugTexture = -1;
+    debugTextile = -1;
     debugTextureStorage = TextureManager::TextureStorage::GAME;
     debugX = 0.0f;
     debugY = 0.0f;
             getWindow().glEnter2D();
             drawTexture(debugX, debugY, debugW, debugH, debugTexture, debugTextureStorage);
             getWindow().glExit2D();
+        } else if (debugTextile >= 0) {
+            getWindow().glEnter2D();
+            drawTextile(debugX, debugY, debugW, debugH, debugTextile);
+            getWindow().glExit2D();
         }
     }
 
 
     if (debugTexture >= 0)
         drawTexture(debugX, debugY, debugW, debugH, debugTexture, debugTextureStorage);
+    else if (debugTextile >= 0)
+        drawTextile(debugX, debugY, debugW, debugH, debugTextile);
 
     getWindow().glExit2D();
 
     debugY = y;
     debugW = w;
     debugH = h;
+    debugTextile = -1;
 }
 
 void Render::drawTexture(float x, float y, float w, float h,
         glEnable(GL_LIGHTING);
 }
 
+void Render::debugDisplayTextile(int texture, float x, float y, float w, float h) {
+    debugTextile = texture;
+    debugX = x;
+    debugY = y;
+    debugW = w;
+    debugH = h;
+    debugTexture = -1;
+}
+
+void Render::drawTextile(float x, float y, float w, float h, unsigned int textile) {
+    float z = 0.0f;
+
+    glColor3ubv(WHITE);
+
+    if (mFlags & Render::fGL_Lights)
+        glDisable(GL_LIGHTING);
+
+    getTextureManager().getTile(textile).displayRectangle(x, y, w, h, z);
+
+    if (mFlags & Render::fGL_Lights)
+        glEnable(GL_LIGHTING);
+}
+

src/TextureManager.cpp

 #include "utils/png.h"
 #endif
 
-std::vector<unsigned int>& TextureManager::getIds(TextureStorage s) {
-    if (s == TextureStorage::GAME)
-        return mTextureIdsGame;
-    else
-        return mTextureIdsSystem;
+TextureTileVertex::TextureTileVertex(uint8_t xc, uint8_t xp, uint8_t yc, uint8_t yp)
+        : xCoordinate(xc), xPixel(xp), yCoordinate(yc), yPixel(yp) { }
+
+// ----------------------------------------------------------------------------
+
+TextureTile::~TextureTile() {
+    while (!vertices.empty()) {
+        delete vertices.at(vertices.size() - 1);
+        vertices.pop_back();
+    }
 }
 
+void TextureTile::add(TextureTileVertex* t) {
+    vertices.push_back(t);
+}
+
+void TextureTile::displayRectangle(float x, float y, float w, float h, float z) {
+    assert(vertices.size() == 4);
+
+    getTextureManager().bindTextureId(texture);
+    //glBegin(GL_TRIANGLE_STRIP);
+    glBegin(GL_QUADS);
+
+    for (int i = 0; i < 4; i++) {
+        glTexCoord2f(vertices.at(i)->xPixel / 256.0f,
+                vertices.at(i)->yPixel / 256.0f);
+
+        if (vertices.at(i)->xCoordinate == 255) {
+            if (vertices.at(i)->yCoordinate == 255) {
+                glVertex3f(x + w, y + h, z);
+            } else {
+                glVertex3f(x + w, y, z);
+            }
+        } else {
+            if (vertices.at(i)->yCoordinate == 255) {
+                glVertex3f(x, y + h, z);
+            } else {
+                glVertex3f(x, y, z);
+            }
+        }
+    }
+
+    glEnd();
+}
+
+// ----------------------------------------------------------------------------
+
 TextureManager::~TextureManager() {
     while (mTextureIdsSystem.size() > 0) {
         unsigned int id = mTextureIdsSystem.at(mTextureIdsSystem.size() - 1);
         glDeleteTextures(1, &id);
         mTextureIdsGame.pop_back();
     }
+
+    while (!tiles.empty()) {
+        delete tiles.at(tiles.size() - 1);
+        tiles.pop_back();
+    }
+}
+
+void TextureManager::addTile(TextureTile* t) {
+    tiles.push_back(t);
+}
+
+int TextureManager::numTiles() {
+    return tiles.size();
+}
+
+TextureTile& TextureManager::getTile(int index) {
+    assert(index >= 0);
+    assert(index < tiles.size());
+    return *tiles.at(index);
+}
+
+std::vector<unsigned int>& TextureManager::getIds(TextureStorage s) {
+    if (s == TextureStorage::GAME)
+        return mTextureIdsGame;
+    else
+        return mTextureIdsSystem;
 }
 
 int TextureManager::initialize() {

src/UI.cpp

             ImGui::Text("Uptime: %lums", systemTimerGet());
         }
 
-        if (ImGui::CollapsingHeader("GL Textures")) {
+        static bool visibleTex = false;
+        static bool visibleTile = false;
+        if (ImGui::CollapsingHeader("Textures")) {
             static bool game = getGame().isLoaded();
             static int index = 0;
-            static bool visible = false;
             ImGui::PushItemWidth(ImGui::GetWindowWidth() * 0.5f);
-            ImGui::SliderInt("", &index, 0, getTextureManager().numTextures(
+            ImGui::SliderInt("##texslide", &index, 0, getTextureManager().numTextures(
                         game ? TextureManager::TextureStorage::GAME
                         : TextureManager::TextureStorage::SYSTEM) - 1);
             ImGui::PopItemWidth();
             ImGui::SameLine();
-            if (ImGui::Checkbox("Game", &game)) {
-                if (game && (getTextureManager().numTextures(
-                        game ? TextureManager::TextureStorage::GAME
-                        : TextureManager::TextureStorage::SYSTEM) <= 0))
-                    game = false;
+            if (ImGui::Button("+##texplus")) {
+                if (index < (getTextureManager().numTextures(
+                                game ? TextureManager::TextureStorage::GAME
+                                : TextureManager::TextureStorage::SYSTEM) - 1))
+                    index++;
+                else
+                    index = 0;
+            }
+            ImGui::SameLine();
+            if (ImGui::Button("-##texminus")) {
+                if (index > 0)
+                    index--;
+                else
+                    index = getTextureManager().numTextures(
+                                game ? TextureManager::TextureStorage::GAME
+                                : TextureManager::TextureStorage::SYSTEM) - 1;
+            }
+            ImGui::SameLine();
+            if ((getTextureManager().numTextures() > 0)) {
+                ImGui::Checkbox("Game##texgame", &game);
+            } else {
+                game = false;
             }
             ImGui::SameLine();
-            if (ImGui::Button("Show")) {
-                visible = true;
+            if (ImGui::Button("Show##texshow")) {
+                visibleTex = true;
+                visibleTile = false;
             }
             ImGui::SameLine();
-            if (ImGui::Button("Clear")) {
+            if (ImGui::Button("Clear##texclear")) {
                 getRender().debugDisplayTexture();
-                visible = false;
+                visibleTex = false;
             }
-            if (visible) {
+            if (visibleTex) {
                 getRender().debugDisplayTexture(index,
                         game ? TextureManager::TextureStorage::GAME
                         : TextureManager::TextureStorage::SYSTEM,
             }
         }
 
+        if (ImGui::CollapsingHeader("Textiles")) {
+            if (getTextureManager().numTiles() > 0) {
+                static int index = 0;
+                ImGui::PushItemWidth(ImGui::GetWindowWidth() * 0.5f);
+                ImGui::SliderInt("##tileslide", &index, 0, getTextureManager().numTiles() - 1);
+                ImGui::PopItemWidth();
+                ImGui::SameLine();
+                if (ImGui::Button("+##tileplus")) {
+                    if (index < (getTextureManager().numTiles() - 1))
+                        index++;
+                    else
+                        index = 0;
+                }
+                ImGui::SameLine();
+                if (ImGui::Button("-##tileminus")) {
+                    if (index > 0)
+                        index--;
+                    else
+                        index = getTextureManager().numTiles() - 1;
+                }
+                ImGui::SameLine();
+                if (ImGui::Button("Show##tileshow")) {
+                    visibleTile = true;
+                    visibleTex = false;
+                }
+                ImGui::SameLine();
+                if (ImGui::Button("Clear##tileclear")) {
+                    getRender().debugDisplayTextile();
+                    visibleTile = false;
+                }
+                if (visibleTile) {
+                    getRender().debugDisplayTextile(index,
+                            ImGui::GetWindowPos().x - (ImGui::GetWindowWidth() / 2),
+                            ImGui::GetWindowPos().y,
+                            (ImGui::GetWindowWidth() / 2), (ImGui::GetWindowWidth() / 2));
+                }
+            } else {
+                ImGui::Text("Please load a level!");
+            }
+        }
+
+        /*
         if (ImGui::CollapsingHeader("UI Help")) {
             ImGui::ShowUserGuide();
         }
+        */
     }
     ImGui::End();
 

src/loader/LoaderTR2.cpp

         // Index into the textile list
         uint16_t tile = file.readU16();
 
+        TextureTile* t = new TextureTile(attribute, tile);
+
         // The four corner vertices of the texture
         // The Pixel values are the actual coordinates of the vertexs pixel
         // The Coordinate values depend on where the other vertices are in
         // the object texture. And if the object texture is used to specify
         // a triangle, then the fourth vertexs values will all be zero
         // Coordinate is 1 if Pixel is the low val, 255 if high val in object texture
-        uint8_t xCoordinate1 = file.readU8();
-        uint8_t xPixel1 = file.readU8();
-        uint8_t yCoordinate1 = file.readU8();
-        uint8_t yPixel1 = file.readU8();
-        uint8_t xCoordinate2 = file.readU8();
-        uint8_t xPixel2 = file.readU8();
-        uint8_t yCoordinate2 = file.readU8();
-        uint8_t yPixel2 = file.readU8();
-        uint8_t xCoordinate3 = file.readU8();
-        uint8_t xPixel3 = file.readU8();
-        uint8_t yCoordinate3 = file.readU8();
-        uint8_t yPixel3 = file.readU8();
-        uint8_t xCoordinate4 = file.readU8();
-        uint8_t xPixel4 = file.readU8();
-        uint8_t yCoordinate4 = file.readU8();
-        uint8_t yPixel4 = file.readU8();
-
-        // TODO store object textures somewhere
+        for (int i = 0; i < 4; i++) {
+            uint8_t xCoordinate = file.readU8();
+            uint8_t xPixel = file.readU8();
+            uint8_t yCoordinate = file.readU8();
+            uint8_t yPixel = file.readU8();
+
+            assert((xCoordinate != 1) || (xCoordinate != 255));
+            assert((yCoordinate != 1) || (yCoordinate != 255));
+
+            t->add(new TextureTileVertex(xCoordinate, xPixel, yCoordinate, yPixel));
+        }
+
+        getTextureManager().addTile(t);
     }
 }