Continued work on new Mesh implementation

ChangeLog.md

 
     [ 20141207 ]
     * LoaderTR2 now also loads all important parts of the Room structures
+    * Started work on new Mesh implementation used with LoaderTR2
 
     [ 20141206 ]
     * LoaderTR2 now tries to load Moveables and Entities

include/Mesh.h

     struct rectangle_t {
         Vec3 a, b, c, d;
         uint16_t texture;
+        float red, green, blue;
 
-        rectangle_t(Vec3 _a, Vec3 _b, Vec3 _c, Vec3 _d, uint16_t t)
-            : a(_a), b(_b), c(_c), d(_d), texture(t) { }
+        rectangle_t(Vec3 _a, Vec3 _b, Vec3 _c, Vec3 _d, uint16_t t,
+                    float re = 0.0f, float gr = 0.0f, float bl = 0.0f)
+            : a(_a), b(_b), c(_c), d(_d), texture(t), red(re), green(gr), blue(bl) { }
     };
 
     Mesh();
     void addTexturedRectangle(Vec3 a, Vec3 b, Vec3 c, Vec3 d, uint16_t textile);
     void addTexturedTriangle(Vec3 a, Vec3 b, Vec3 c, uint16_t textile);
 
-    void addColoredRectangle(Vec3 a, Vec3 b, Vec3 c, Vec3 d, uint16_t textile);
-    void addColoredTriangle(Vec3 a, Vec3 b, Vec3 c, uint16_t textile);
+    void addColoredRectangle(Vec3 a, Vec3 b, Vec3 c, Vec3 d, float re, float gr, float bl);
+    void addColoredTriangle(Vec3 a, Vec3 b, Vec3 c, float re, float gr, float bl);
+
+    void addNormal(Vec3 n);
 
     std::vector<rectangle_t> texturedRectangles;
     std::vector<rectangle_t> coloredRectangles;
     std::vector<rectangle_t> texturedTriangles;
     std::vector<rectangle_t> coloredTriangles;
-
+    std::vector<Vec3> normals;
 
 
     // Old API

include/TextureManager.h

 #include <cstdint>
 #include <vector>
 
+#include "math/Vec3.h"
+
 // These are loaded into TextureStorage::SYSTEM by initialize()!
 #define TEXTURE_WHITE 0
 #define TEXTURE_SPLASH 1
     bool isTriangle();
     void display(float x, float y, float w, float h, float z);
 
+    void displayTriangle(Vec3 a, Vec3 b, Vec3 c);
+    void displayRectangle(Vec3 a, Vec3 b, Vec3 c, Vec3 d);
+
   private:
     void displayTriangle(float x, float y, float w, float h, float z);
     void displayRectangle(float x, float y, float w, float h, float z);

include/loader/LoaderTR2.h

 #ifndef _LOADER_LOADER_TR2_H_
 #define _LOADER_LOADER_TR2_H_
 
+#include <array>
+#include <cstdint>
+
 #include "loader/Loader.h"
 
 class LoaderTR2 : public Loader {
     void loadSampleIndices();
 
     void loadExternalSoundFile(std::string f);
+
+    std::array<uint32_t, 256> palette;
 };
 
 #endif

src/Mesh.cpp

     texturedTriangles.emplace_back(a, b, c, Vec3(), textile);
 }
 
-void Mesh::addColoredRectangle(Vec3 a, Vec3 b, Vec3 c, Vec3 d, uint16_t textile) {
-    coloredRectangles.emplace_back(a, b, c, d, textile);
+void Mesh::addColoredRectangle(Vec3 a, Vec3 b, Vec3 c, Vec3 d, float re, float gr, float bl) {
+    coloredRectangles.emplace_back(a, b, c, d, -1, re, gr, bl);
 }
 
-void Mesh::addColoredTriangle(Vec3 a, Vec3 b, Vec3 c, uint16_t textile) {
-    coloredTriangles.emplace_back(a, b, c, Vec3(), textile);
+void Mesh::addColoredTriangle(Vec3 a, Vec3 b, Vec3 c, float re, float gr, float bl) {
+    coloredTriangles.emplace_back(a, b, c, Vec3(), -1, re, gr, bl);
+}
+
+void Mesh::addNormal(Vec3 n) {
+    normals.emplace_back(n);
 }
 
 void Mesh::drawAlpha() {
     if ((texturedRectangles.size() == 0)
         && (texturedTriangles.size() == 0)
         && (coloredRectangles.size() == 0)
-        && (coloredTriangles.size() == 0)) {
+        && (coloredTriangles.size() == 0)
+        && (normals.size() == 0)) {
         drawAlphaOld();
         return;
     }
 
+    // TODO
 }
 
 void Mesh::drawSolid() {
     if ((texturedRectangles.size() == 0)
         && (texturedTriangles.size() == 0)
         && (coloredRectangles.size() == 0)
-        && (coloredTriangles.size() == 0)) {
+        && (coloredTriangles.size() == 0)
+        && (normals.size() == 0)) {
         drawSolidOld();
         return;
     }
 
+    // Render textured quads
+    for (auto& q : texturedRectangles) {
+        if (mMode == MeshModeWireframe) {
+            getTextureManager().bindTextureId(TEXTURE_WHITE, TextureManager::TextureStorage::SYSTEM);
+            glBegin(GL_QUADS);
+            glTexCoord2f(0.0f, 0.0f);
+            glVertex3f(q.a.x, q.a.y, q.a.z);
+            glTexCoord2f(1.0f, 0.0f);
+            glVertex3f(q.b.x, q.b.y, q.b.z);
+            glTexCoord2f(1.0f, 1.0f);
+            glVertex3f(q.c.x, q.c.y, q.c.z);
+            glTexCoord2f(0.0f, 1.0f);
+            glVertex3f(q.d.x, q.d.y, q.d.z);
+            glEnd();
+        } else if (mMode == MeshModeTexture) {
+            getTextureManager().getTile(q.texture).displayRectangle(q.a, q.b, q.c, q.d);
+        }
+    }
 }
 
 

src/TextureManager.cpp

 }
 
 void TextureTile::displayRectangle(float x, float y, float w, float h, float z) {
+    displayRectangle(Vec3(x, y, z), Vec3(x + w, y, z), Vec3(x + w, y + h, z), Vec3(x, y + h, z));
+}
+
+void TextureTile::displayRectangle(Vec3 a, Vec3 b, Vec3 c, Vec3 d) {
     float xmin = 256.0f, xmax = 0.0f;
     float ymin = 256.0f, ymax = 0.0f;
     for (int i = 0; i < 4; i++) {
 
     glBegin(GL_QUADS);
     glTexCoord2f(xmin / 256.0f, ymin / 256.0f);
-    glVertex3f(x, y, z);
+    glVertex3f(a.x, a.y, a.z);
     glTexCoord2f(xmax / 256.0f, ymin / 256.0f);
-    glVertex3f(x + w, y, z);
+    glVertex3f(b.x, b.y, b.z);
     glTexCoord2f(xmax / 256.0f, ymax / 256.0f);
-    glVertex3f(x + w, y + h, z);
+    glVertex3f(c.x, c.y, c.z);
     glTexCoord2f(xmin / 256.0f, ymax / 256.0f);
-    glVertex3f(x, y + h, z);
+    glVertex3f(d.x, d.y, d.z);
     glEnd();
 }
 
 void TextureTile::displayTriangle(float x, float y, float w, float h, float z) {
-    glBegin(GL_TRIANGLE_STRIP);
-    for (int i = 0; i < 3; i++) {
-        glTexCoord2f(vertices.at(i)->xPixel / 256.0f,
-                     vertices.at(i)->yPixel / 256.0f);
+    displayTriangle(Vec3(x, y, z), Vec3(x + w, y, z), Vec3(x + w, y + h, z));
+}
 
-        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);
-            }
-        }
-    }
+void TextureTile::displayTriangle(Vec3 a, Vec3 b, Vec3 c) {
+    glBegin(GL_TRIANGLE_STRIP);
+    glTexCoord2f(vertices.at(0)->xPixel / 256.0f,
+                 vertices.at(0)->yPixel / 256.0f);
+    glVertex3f(a.x, a.y, a.z);
+    glTexCoord2f(vertices.at(1)->xPixel / 256.0f,
+                 vertices.at(1)->yPixel / 256.0f);
+    glVertex3f(b.x, b.y, b.z);
+    glTexCoord2f(vertices.at(2)->xPixel / 256.0f,
+                 vertices.at(2)->yPixel / 256.0f);
+    glVertex3f(c.x, c.y, c.z);
     glEnd();
 }
 

src/loader/LoaderTR2.cpp

  * \author xythobuz
  */
 
-#include <array>
-#include <cstdint>
 #include <vector>
 
 #include "global.h"
     file.seek(file.tell() + 768); // Skip 8bit palette, 256 * 3 bytes
 
     // Read the 16bit palette, 256 * 4 bytes, RGBA, A unused
-    std::array<uint32_t, 256> palette; //!< RGBA, A unused
     for (auto& x : palette)
         x = file.readU32();
 
-    // TODO store palette somewhere?
-
     uint32_t numTextiles = file.readU32();
 
     file.seek(file.tell() + (numTextiles * 256 * 256)); // Skip 8bit textiles
 
         getWorld().addRoom(room);
 
-        if ((numPortals == 0) || (numVertices == 0)
-            || ((numRectangles == 0) && (numTriangles == 0)))
+        if ((numPortals == 0) && (numVertices == 0)
+            && (numRectangles == 0) && (numTriangles == 0))
             getLog() << "LoaderTR2: Room " << i << " seems invalid: " << numPortals << "p "
                      << numRectangles << "r " << numTriangles << "t " << numVertices
                      << "v" << Log::endl;
             vertices.emplace_back(x, y, z);
         }
 
+        Mesh* mesh = new Mesh();
+
         int16_t numNormals = mem.read16();
         if (numNormals > 0) {
             // External vertex lighting is used, with the lighting calculated
                 int16_t x = mem.read16();
                 int16_t y = mem.read16();
                 int16_t z = mem.read16();
-                // TODO store normals somewhere
+
+                mesh->addNormal(Vec3(x, y, z));
             }
         } else if (numNormals < 0) {
             // Internal vertex lighting is used,
             }
         }
 
-        Mesh* mesh = new Mesh();
-
         int16_t numTexturedRectangles = mem.read16();
         for (int r = 0; r < numTexturedRectangles; r++) {
             uint16_t vertex1 = mem.readU16();
             uint16_t vertex4 = mem.readU16();
             uint16_t texture = mem.readU16();
 
-            // TODO color?
+            int index = (texture & 0xFF00) >> 8;
+            float red = (palette.at(index) & 0xFF000000) >> 24,
+                  green = (palette.at(index) & 0x00FF0000) >> 16,
+                  blue = (palette.at(index) & 0x0000FF00) >> 8;
+
 
             mesh->addColoredRectangle(vertices.at(vertex1), vertices.at(vertex2),
                                       vertices.at(vertex3), vertices.at(vertex4),
-                                      texture);
+                                      red, green, blue);
         }
 
         int16_t numColoredTriangles = mem.read16();
             uint16_t vertex3 = mem.readU16();
             uint16_t texture = mem.readU16();
 
-            // TODO color?
+            int index = (texture & 0xFF00) >> 8;
+            float red = (palette.at(index) & 0xFF000000) >> 24,
+                  green = (palette.at(index) & 0x00FF0000) >> 16,
+                  blue = (palette.at(index) & 0x0000FF00) >> 8;
 
             mesh->addColoredTriangle(vertices.at(vertex1), vertices.at(vertex2),
-                                     vertices.at(vertex3), texture);
+                                     vertices.at(vertex3), red, green, blue);
         }
 
         getWorld().addMesh(mesh);