Render StaticModels

ChangeLog.md

     * Mesh is now called RoomMesh
     * Removed non-functional GLUT windowing implementation
     * Created new windowing implementation using GLFW3
+    * World Meshes are loaded properly
+    * StaticModel/StaticMesh in Rooms are displayed (albeit not properly)
 
     [ 20141216 ]
     * Allow navigation with a free-floating Camera

include/Mesh.h

 #define _MESH_H_
 
 #include <map>
+#include <vector>
+#include <glm/mat4x4.hpp>
 #include <glm/vec2.hpp>
 #include <glm/vec3.hpp>
 
+struct IndexedRectangle {
+    unsigned int v1, v2, v3, v4; // Vertex list indices
+    unsigned int texture; // Index into object-texture list
+
+    IndexedRectangle(unsigned int t, unsigned int _v1,
+                     unsigned int _v2, unsigned int _v3, unsigned int _v4 = 0)
+        : v1(_v1), v2(_v2), v3(_v3), v4(_v4), texture(t) { }
+};
+
+struct IndexedColoredRectangle {
+    unsigned int v1, v2, v3, v4;
+    unsigned char r, g, b;
+
+    IndexedColoredRectangle(unsigned char _r, unsigned char _g, unsigned char _b,
+                            unsigned int _v1, unsigned int _v2,
+                            unsigned int _v3, unsigned int _v4 = 0)
+        : v1(_v1), v2(_v2), v3(_v3), v4(_v4), r(_r), g(_g), b(_b) { }
+};
+
+// --------------------------------------
+
 class Mesh {
+  public:
+    Mesh(const std::vector<glm::vec3>& vertices,
+         const std::vector<IndexedRectangle>& rectangles,
+         const std::vector<IndexedRectangle>& triangles,
+         const std::vector<IndexedColoredRectangle>& coloredRectangles,
+         const std::vector<IndexedColoredRectangle>& coloredTriangles);
+    void prepare();
+    void display(glm::mat4 model, glm::mat4 view, glm::mat4 projection);
+
+  private:
+    std::vector<unsigned short> indices;
+    std::vector<glm::vec3> vertices;
+    std::vector<glm::vec2> uvs;
+    std::vector<unsigned int> textures;
 
+    std::vector<unsigned short> indicesColor;
+    std::vector<glm::vec3> verticesColor;
+    std::vector<glm::vec3> colors;
 };
 
 // --------------------------------------
     unsigned int tex;
 
     PackedVertex(glm::vec3 p, glm::vec2 u, unsigned int t) : pos(p), uv(u), tex(t) { }
-    bool operator<(const PackedVertex& v) const { return memcmp(this, &v, sizeof(PackedVertex)) > 0; }
+
+    bool operator<(const PackedVertex& v) const {
+        return memcmp(this, &v, sizeof(PackedVertex)) > 0;
+    }
+};
+
+struct PackedColoredVertex {
+    glm::vec3 pos;
+    glm::vec3 col;
+
+    PackedColoredVertex(glm::vec3 p, glm::vec3 c) : pos(p), col(c) { }
+
+    bool operator<(const PackedColoredVertex& v) const {
+        return memcmp(this, &v, sizeof(PackedColoredVertex)) > 0;
+    }
 };
 
 template <typename T>

include/RoomData.h

 
 class BoundingBox {
   public:
-    BoundingBox(glm::vec3 min, glm::vec3 max);
-    void display(bool points, const unsigned char c1[4], const unsigned char c2[4]);
-    bool inBox(float x, float y, float z);
-    bool inBoxPlane(float x, float z);
+    BoundingBox(glm::vec3 min, glm::vec3 max) : a(min), b(max) { }
+    bool inBox(float x, float y, float z) { return ((y > a.y) && (y < b.y) && inBoxPlane(x, z)); }
+    bool inBoxPlane(float x, float z) { return ((x > a.x) && (x < b.x) && (z > a.z) && (z < b.z)); }
 
   private:
     glm::vec3 a, b;
 };
 
+// --------------------------------------
+
+class StaticModel {
+  public:
+    StaticModel(glm::vec3 p, float a, int i) : pos(p), angle(a), id(i), cache(-1) { }
+    void display(glm::mat4 view, glm::mat4 projection);
+
+  private:
+    glm::vec3 pos;
+    float angle;
+    int id;
+    int cache;
+};
+
+// --------------------------------------
+
 class Light {
   public:
     /*!
     LightType type; //! Type of light
 };
 
-class StaticModel {
-  public:
-    void display();
-
-  private:
-    int index;
-    float yaw;
-    float pos[3];
-
-    // ?
-    //float bbox[2][3];
-};
+// --------------------------------------
 
 class Portal {
   public:
     int adjoiningRoom;
 };
 
+// --------------------------------------
+
 class Sector {
   public:
     Sector(float f, float c, bool w) : floor(f), ceiling(c), wall(w) { }

include/RoomMesh.h

 #ifndef _ROOM_MESH_H_
 #define _ROOM_MESH_H_
 
-#include <cstdint>
 #include <vector>
 #include <glm/mat4x4.hpp>
 #include <glm/vec2.hpp>
 #include <glm/vec3.hpp>
 
+#include "Mesh.h"
+
 struct RoomVertexTR2 {
-    int16_t x, y, z; // Vertex coordinates, relative to x/zOffset
-    int16_t light1, light2; // Almost always equal
+    int x, y, z; // Vertex coordinates, relative to x/zOffset
+    int light1, light2; // Almost always equal
 
     // Set of flags for special rendering effects
     // 0x8000 - Something to do with water surface?
     // 0x4000 - Underwater lighting modulation/movement if seen from above
     // 0x2000 - Water/Quicksand surface movement
     // 0x0010 - Normal?
-    uint16_t attributes;
-};
-
-struct IndexedRectangle {
-    unsigned int v1, v2, v3, v4; // Vertex list indices
-    unsigned int texture; // Index into object-texture list
-
-    IndexedRectangle(uint16_t t, uint16_t _v1, uint16_t _v2, uint16_t _v3, uint16_t _v4 = 0)
-        : v1(_v1), v2(_v2), v3(_v3), v4(_v4), texture(t) { }
+    unsigned int attributes;
 };
 
 class RoomMesh {
   public:
     RoomMesh(const std::vector<RoomVertexTR2>& vertices,
-         const std::vector<IndexedRectangle>& rectangles,
-         const std::vector<IndexedRectangle>& triangles);
-
+             const std::vector<IndexedRectangle>& rectangles,
+             const std::vector<IndexedRectangle>& triangles);
     void prepare();
-
     void display(glm::mat4 model, glm::mat4 view, glm::mat4 projection);
 
   private:

include/StaticMesh.h

 #ifndef _STATIC_MODEL_H_
 #define _STATIC_MODEL_H_
 
-#include <vector>
-
-class TexturedTriangle {
-  public:
-    TexturedTriangle(int i[3], float s[6], int tex, unsigned short trans);
-    void display(float* vertices, float* colors, float* normals);
-
-  private:
-    int index[3];
-    float st[6];
-    int texture;
-    unsigned short transparency;
-};
-
 class StaticMesh {
   public:
-    StaticMesh(int id, int mesh);
-    ~StaticMesh();
-    void display();
-    float getRadius();
+    StaticMesh(int i, int m) : id(i), mesh(m) { }
+    void display(glm::mat4 model, glm::mat4 view, glm::mat4 projection);
 
-  private:
-    bool dontshow;
-    float center[3];
-    float radius;
-
-    unsigned int vertexCount;
-    unsigned int colorCount;
-    unsigned int normalCount;
-
-    float* vertices;
-    float* colors;
-    float* normals;
-
-    std::vector<TexturedTriangle*> triangles;
+    int getID() { return id; }
 
+  private:
     int id;
     int mesh;
 };

include/system/Window.h

     static void drawGL(std::vector<glm::vec3>& vertices, std::vector<glm::vec2>& uvs,
                        std::vector<unsigned short>& indices, glm::mat4 MVP, unsigned int texture);
 
+    static void drawGL(std::vector<glm::vec3>& vertices, std::vector<glm::vec3>& colors,
+                       std::vector<unsigned short>& indices, glm::mat4 MVP);
+
   protected:
     bool mInit;
     bool mFullscreen;
     static const char* textureShaderVertex;
     static const char* textureShaderFragment;
 
+    static Shader colorShader;
+    static const char* colorShaderVertex;
+    static const char* colorShaderFragment;
+
     static unsigned int vertexArrayID;
 
     friend class UI;

src/Game.cpp

             return -2;
         }
 
+        for (int i = 0; i < getWorld().sizeMesh(); i++) {
+            getWorld().getMesh(i).prepare();
+        }
+
         for (int i = 0; i < getWorld().sizeRoom(); i++) {
             getWorld().getRoom(i).prepare();
         }

src/MenuFolder.cpp

     // Draw half-transparent overlay
     glm::vec4 color(0.0f, 0.0f, 0.0f, 0.75f);
     Render::drawTexture(0.0f, 0.0f, getWindow().getWidth(), getWindow().getHeight(),
-                    color, TEXTURE_WHITE, TextureManager::TextureStorage::SYSTEM);
+                        color, TEXTURE_WHITE, TextureManager::TextureStorage::SYSTEM);
 
     // Draw heading
     Font::drawTextCentered(0, 10, 1.2f, BLUE, getWindow().getWidth(), VERSION);

src/Mesh.cpp

  * \author xythobuz
  */
 
+#include "global.h"
+#include "TextureManager.h"
+#include "system/Window.h"
+#include "Mesh.h"
+
+Mesh::Mesh(const std::vector<glm::vec3>& vert,
+           const std::vector<IndexedRectangle>& rect,
+           const std::vector<IndexedRectangle>& tri,
+           const std::vector<IndexedColoredRectangle>& coloredRect,
+           const std::vector<IndexedColoredRectangle>& coloredTri) {
+    for (auto& t : rect) {
+        indices.push_back(0);
+        vertices.push_back(glm::vec3(vert.at(t.v1).x, vert.at(t.v1).y, vert.at(t.v1).z));
+        vertices.push_back(glm::vec3(vert.at(t.v2).x, vert.at(t.v2).y, vert.at(t.v2).z));
+        vertices.push_back(glm::vec3(vert.at(t.v3).x, vert.at(t.v3).y, vert.at(t.v3).z));
+        vertices.push_back(glm::vec3(vert.at(t.v4).x, vert.at(t.v4).y, vert.at(t.v4).z));
+        textures.push_back(t.texture);
+    }
+
+    for (auto& t : tri) {
+        indices.push_back(1);
+        vertices.push_back(glm::vec3(vert.at(t.v1).x, vert.at(t.v1).y, vert.at(t.v1).z));
+        vertices.push_back(glm::vec3(vert.at(t.v2).x, vert.at(t.v2).y, vert.at(t.v2).z));
+        vertices.push_back(glm::vec3(vert.at(t.v3).x, vert.at(t.v3).y, vert.at(t.v3).z));
+        textures.push_back(t.texture);
+    }
+
+    for (auto& t : coloredRect) {
+        indicesColor.push_back(0);
+        verticesColor.push_back(glm::vec3(vert.at(t.v1).x, vert.at(t.v1).y, vert.at(t.v1).z));
+        verticesColor.push_back(glm::vec3(vert.at(t.v2).x, vert.at(t.v2).y, vert.at(t.v2).z));
+        verticesColor.push_back(glm::vec3(vert.at(t.v3).x, vert.at(t.v3).y, vert.at(t.v3).z));
+        verticesColor.push_back(glm::vec3(vert.at(t.v4).x, vert.at(t.v4).y, vert.at(t.v4).z));
+        colors.push_back(glm::vec3(t.r, t.g, t.b));
+    }
+
+    for (auto& t : coloredTri) {
+        indicesColor.push_back(1);
+        verticesColor.push_back(glm::vec3(vert.at(t.v1).x, vert.at(t.v1).y, vert.at(t.v1).z));
+        verticesColor.push_back(glm::vec3(vert.at(t.v2).x, vert.at(t.v2).y, vert.at(t.v2).z));
+        verticesColor.push_back(glm::vec3(vert.at(t.v3).x, vert.at(t.v3).y, vert.at(t.v3).z));
+        colors.push_back(glm::vec3(t.r, t.g, t.b));
+    }
+}
+
+void Mesh::prepare() {
+    std::vector<unsigned short> ind;
+    std::vector<glm::vec3> vert;
+    std::vector<unsigned int> tex;
+    std::map<PackedVertex, unsigned short> vertexMap;
+    int vertIndex = 0;
+    for (int i = 0; i < indices.size(); i++) {
+        unsigned int texture = getTextureManager().getTile(textures.at(i)).getTexture();
+        for (int v = 0; v < ((indices.at(i) == 0) ? 4 : 3); v++) {
+            glm::vec2 uv = getTextureManager().getTile(textures.at(i)).getUV(v);
+            PackedVertex p(vertices.at(vertIndex + v), uv, texture);
+            unsigned short s;
+            if (findSimilarVertex(p, vertexMap, s)) {
+                ind.push_back(s); // Vertex already cached
+            } else {
+                vertexMap[p] = vert.size();
+                ind.push_back(vert.size());
+                vert.push_back(p.pos);
+                uvs.push_back(p.uv);
+                tex.push_back(p.tex);
+            }
+        }
+
+        if (indices.at(i) == 0) {
+            ind.push_back(ind.at(ind.size() - 2));
+            ind.push_back(ind.at(ind.size() - 5));
+        }
+
+        vertIndex += (indices.at(i) == 0) ? 4 : 3;
+    }
+    assert((ind.size() % 3) == 0);
+    assert(vert.size() == tex.size());
+    assert(vert.size() == uvs.size());
+    indices = ind;
+    vertices = vert;
+    textures = tex;
+
+    std::vector<unsigned short> indC;
+    std::vector<glm::vec3> vertC;
+    std::vector<glm::vec3> col;
+    std::map<PackedColoredVertex, unsigned short> vertexMapC;
+    vertIndex = 0;
+    for (int i = 0; i < indicesColor.size(); i++) {
+        for (int v = 0; v < ((indicesColor.at(i) == 0) ? 4 : 3); v++) {
+            PackedColoredVertex p(verticesColor.at(vertIndex + v), colors.at(i));
+            unsigned short s;
+            if (findSimilarVertex(p, vertexMapC, s)) {
+                indC.push_back(s); // Vertex already cached
+            } else {
+                vertexMapC[p] = vertC.size();
+                indC.push_back(vertC.size());
+                vertC.push_back(p.pos);
+                col.push_back(p.col);
+            }
+        }
+
+        if (indicesColor.at(i) == 0) {
+            indC.push_back(indC.at(indC.size() - 2));
+            indC.push_back(indC.at(indC.size() - 5));
+        }
+
+        vertIndex += (indicesColor.at(i) == 0) ? 4 : 3;
+    }
+    assert((indC.size() % 3) == 0);
+    assert(vertC.size() == col.size());
+    indicesColor = indC;
+    verticesColor = vertC;
+    colors = col;
+}
+
+void Mesh::display(glm::mat4 model, glm::mat4 view, glm::mat4 projection) {
+    glm::mat4 MVP = projection * view * model;
+
+    if (indices.size() > 0) {
+        unsigned int indexStart = 0;
+        unsigned int indexPos = 1;
+        unsigned int texture = textures.at(indices.at(0));
+
+        while ((indexStart != indexPos) && (indexPos < indices.size())) {
+            while ((indexPos < indices.size()) && (textures.at(indices.at(indexPos)) == texture))
+                indexPos++;
+
+            std::vector<unsigned short> ind(indices.begin() + indexStart, indices.begin() + indexPos);
+            Window::drawGL(vertices, uvs, ind, MVP, texture);
+
+            if (indexPos < indices.size()) {
+                indexStart = indexPos;
+                indexPos += 1;
+                texture = textures.at(indices.at(indexStart));
+            }
+        }
+    }
+
+    if (indicesColor.size() > 0)
+        Window::drawGL(verticesColor, colors, indicesColor, MVP);
+}
+

src/Render.cpp

     static unsigned int w = getWindow().getWidth();
     static unsigned int h = getWindow().getHeight();
     static glm::mat4 projection = glm::perspective(45.0f, // Field of View
-                                                   (float)getWindow().getWidth()
-                                                 / (float)getWindow().getHeight(),
-                                                   0.1f, // Min Distance
-                                                   100000.0f); // Max Distance
+                                  (float)getWindow().getWidth()
+                                  / (float)getWindow().getHeight(),
+                                  0.1f, // Min Distance
+                                  100000.0f); // Max Distance
 
     if ((w != getWindow().getWidth()) || (h != getWindow().getHeight())) {
         w = getWindow().getWidth();

src/Room.cpp

 void Room::display(glm::mat4 view, glm::mat4 projection) {
     glm::mat4 model = glm::translate(glm::mat4(1.0f), glm::vec3(pos[0], pos[1], pos[2]));
     mesh->display(model, view, projection);
+
+    for (auto& m : models) {
+        m->display(view, projection);
+    }
 }
 
 bool Room::isWall(unsigned long sector) {

src/RoomData.cpp

  * \author xythobuz
  */
 
+#include <glm/gtc/matrix_transform.hpp>
+
 #include "global.h"
 #include "SkeletalModel.h"
 #include "World.h"
 #include "RoomData.h"
 
-BoundingBox::BoundingBox(glm::vec3 min, glm::vec3 max) : a(min), b(max) { }
-
-bool BoundingBox::inBox(float x, float y, float z) {
-    return ((y > a.y) && (y < b.y) && inBoxPlane(x, z));
-}
-
-bool BoundingBox::inBoxPlane(float x, float z) {
-    return ((x > a.x) && (x < b.x)
-            && (z > a.z) && (z < b.z));
-}
-
-void BoundingBox::display(bool points, const unsigned char c1[4], const unsigned char c2[4]) {
-    /*
-    // Bind before entering now
-    //glBindTexture(GL_TEXTURE_2D, 1);
-    glPointSize(4.0);
-    //glLineWidth(1.25);
-
-    //! \fixme Need to make custom color key for this
-    glColor3ubv(c1);
-
-    glBegin(GL_POINTS);
-    glVertex3f(b[0], b[1], b[2]);
-    glVertex3f(a[0], a[1], a[2]);
-
-    if (points) {
-        glVertex3f(b[0], a[1], b[2]);
-        glVertex3f(a[0], b[1], b[2]);
-        glVertex3f(b[0], b[1], a[2]);
-        glVertex3f(a[0], a[1], b[2]);
-        glVertex3f(a[0], b[1], a[2]);
-        glVertex3f(b[0], a[1], a[2]);
+void StaticModel::display(glm::mat4 view, glm::mat4 projection) {
+    if (cache < 0) {
+        for (int i = 0; i < getWorld().sizeStaticMesh(); i++) {
+            if (getWorld().getStaticMesh(i).getID() == id) {
+                cache = i;
+            }
+        }
+        assert(cache >= 0);
     }
 
-    glEnd();
-
-    glColor3ubv(c2);
-
-    glBegin(GL_LINES);
-    // max, top quad
-    glVertex3f(b[0], b[1], b[2]);
-    glVertex3f(b[0], a[1], b[2]);
-
-    glVertex3f(b[0], b[1], b[2]);
-    glVertex3f(a[0], b[1], b[2]);
-
-    glVertex3f(b[0], b[1], b[2]);
-    glVertex3f(b[0], b[1], a[2]);
-
-    // max-min, vertical quads
-    glVertex3f(a[0], b[1], b[2]);
-    glVertex3f(a[0], b[1], a[2]);
-
-    glVertex3f(b[0], a[1], b[2]);
-    glVertex3f(b[0], a[1], a[2]);
-
-    glVertex3f(b[0], a[1], b[2]);
-    glVertex3f(a[0], a[1], b[2]);
-
-    // min-max, vertical quads
-    glVertex3f(b[0], b[1], a[2]);
-    glVertex3f(b[0], a[1], a[2]);
-
-    glVertex3f(b[0], b[1], a[2]);
-    glVertex3f(a[0], b[1], a[2]);
-
-    glVertex3f(a[0], b[1], b[2]);
-    glVertex3f(a[0], a[1], b[2]);
-
-
-    // min, bottom quad
-    glVertex3f(a[0], a[1], a[2]);
-    glVertex3f(a[0], b[1], a[2]);
-
-    glVertex3f(a[0], a[1], a[2]);
-    glVertex3f(b[0], a[1], a[2]);
-
-    glVertex3f(a[0], a[1], a[2]);
-    glVertex3f(a[0], a[1], b[2]);
-    glEnd();
-
-    glPointSize(1.0);
-    //glLineWidth(1.0);
-    */
+    glm::mat4 model = glm::rotate(glm::translate(glm::mat4(1.0f), pos),
+                                  angle, glm::vec3(0.0f, 1.0f, 0.0f));
+    getWorld().getStaticMesh(cache).display(model, view, projection);
 }
 
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 
-void StaticModel::display() {
-    StaticMesh& mesh = getWorld().getStaticMesh(index);
-
-    //if (!getRender().isVisible(pos[0], pos[1], pos[2], mesh.getRadius()))
-    //    return;
-
-    /*
-    glPushMatrix();
-    glTranslated(pos[0], pos[1], pos[2]);
-    glRotated(yaw, 0, 1, 0);
-    mesh.display();
-    glPopMatrix();
-    */
-}
-
-// ----------------------------------------------------------------------------
-
 Portal::Portal(glm::vec3 vert[4], float norm[3], int adj) {
     for (unsigned int i = 0; i < 4; i++) {
         for (unsigned int j = 0; j < 3; j++) {

src/RoomMesh.cpp

 #include "RoomMesh.h"
 
 RoomMesh::RoomMesh(const std::vector<RoomVertexTR2>& vert,
-     const std::vector<IndexedRectangle>& rect,
-     const std::vector<IndexedRectangle>& tri) {
+                   const std::vector<IndexedRectangle>& rect,
+                   const std::vector<IndexedRectangle>& tri) {
     for (auto& t : rect) {
         indices.push_back(0);
         vertices.push_back(glm::vec3(vert.at(t.v1).x, vert.at(t.v1).y, vert.at(t.v1).z));

src/StaticMesh.cpp

  */
 
 #include "global.h"
-#include "Game.h"
-#include "Render.h"
-#include "TextureManager.h"
 #include "World.h"
-#include "utils/pixel.h"
 #include "StaticMesh.h"
 
-TexturedTriangle::TexturedTriangle(int i[3], float s[6], int tex, unsigned short trans) {
-    index[0] = i[0];
-    index[1] = i[1];
-    index[2] = i[2];
-    st[0] = s[0];
-    st[1] = s[1];
-    st[2] = s[2];
-    st[3] = s[3];
-    st[4] = s[4];
-    st[5] = s[5];
-    texture = tex;
-    transparency = trans;
-}
-
-void TexturedTriangle::display(float* vertices, float* colors, float* normals) {
-    /*
-    assert(vertices != nullptr);
-
-    if ((Render::getMode() != RenderMode::Wireframe)
-        && (Render::getMode() != RenderMode::Solid)) {
-        getTextureManager().bindTextureId(texture);
-    }
-
-    glBegin(GL_TRIANGLES);
-
-    switch (Render::getMode()) {
-        case RenderMode::Solid:
-            //case RenderMode::VertexLight:
-            if (colors != nullptr) {
-                glColor3fv(colors + index[0]);
-                glTexCoord2fv(st);
-                glVertex3fv(vertices + (index[0] * 3));
-
-                glColor3fv(colors + index[1]);
-                glTexCoord2fv(st + 2);
-                glVertex3fv(vertices + (index[1] * 3));
-
-                glColor3fv(colors + index[2]);
-                glTexCoord2fv(st + 4);
-                glVertex3fv(vertices + (index[2] * 3));
-            } else if (normals != nullptr) {
-                glNormal3fv(normals + (index[0] * 3));
-                glTexCoord2fv(st);
-                glVertex3fv(vertices + (index[0] * 3));
-
-                glNormal3fv(normals + (index[1] * 3));
-                glTexCoord2fv(st + 2);
-                glVertex3fv(vertices + (index[1] * 3));
-
-                glNormal3fv(normals + (index[2] * 3));
-                glTexCoord2fv(st + 4);
-                glVertex3fv(vertices + (index[2] * 3));
-            } else {
-                glTexCoord2fv(st);
-                glVertex3fv(vertices + (index[0] * 3));
-                glTexCoord2fv(st + 2);
-                glVertex3fv(vertices + (index[1] * 3));
-                glTexCoord2fv(st + 4);
-                glVertex3fv(vertices + (index[2] * 3));
-            }
-            break;
-
-        case RenderMode::Wireframe:
-            glVertex3fv(vertices + (index[0] * 3));
-            glVertex3fv(vertices + (index[1] * 3));
-            glVertex3fv(vertices + (index[2] * 3));
-            break;
-
-        default:
-            glTexCoord2fv(st);
-            glVertex3fv(vertices + (index[0] * 3));
-            glTexCoord2fv(st + 2);
-            glVertex3fv(vertices + (index[1] * 3));
-            glTexCoord2fv(st + 4);
-            glVertex3fv(vertices + (index[2] * 3));
-    }
-
-    glEnd();
-    */
-}
-
-// ----------------------------------------------------------------------------
-
-StaticMesh::StaticMesh(int i, int m) : id(i), mesh(m) {
-    vertices = colors = normals = nullptr;
-}
-
-StaticMesh::~StaticMesh() {
-    while (!triangles.empty()) {
-        delete triangles.back();
-        triangles.pop_back();
-    }
-
-    delete [] vertices;
-    delete [] normals;
-    delete [] colors;
-}
-
-void StaticMesh::display() {
-    /*
-    if ((id != -1) && (mesh != -1)) {
-        getWorld().getMesh(mesh).drawSolid();
-        return;
-    }
-
-    if (!dontshow) {
-        //! \fixme Duh, vis tests need to be put back
-        //if (!isVisible(center, radius, bbox))
-        //   return;
-
-        //! \fixme 'AMBIENT' -- Mongoose 2002.01.08
-        glColor3ubv(WHITE);
-
-        if (Render::getMode() == RenderMode::Wireframe)
-            glColor3ubv(WHITE);
-
-        getTextureManager().bindTextureId(TEXTURE_WHITE, TextureManager::TextureStorage::SYSTEM);
-
-        for (unsigned int i = 0; i < triangles.size(); i++)
-            triangles.at(i)->display(vertices, colors, normals);
-    }
-    */
-}
-
-float StaticMesh::getRadius() {
-    assert((id == -1) && (mesh == -1));
-    return radius;
+void StaticMesh::display(glm::mat4 model, glm::mat4 view, glm::mat4 projection) {
+    getWorld().getMesh(mesh).display(model, view, projection);
 }
 

src/TextureManager.cpp

 
 int TextureManager::initializeSplash() {
     unsigned char* image = generateColorTexture(WHITE, 32, 32, 32);
-    int res = loadBufferSlot(image, 32, 32, ColorMode::RGBA, 32, TextureStorage::SYSTEM, TEXTURE_WHITE, false);
+    int res = loadBufferSlot(image, 32, 32, ColorMode::RGBA, 32, TextureStorage::SYSTEM, TEXTURE_WHITE,
+                             false);
     delete [] image;
     if (res < 0) {
         return -1;

src/loader/LoaderTR2.cpp

 #include "global.h"
 #include "Game.h"
 #include "Log.h"
+#include "Mesh.h"
 #include "Room.h"
 #include "SoundManager.h"
 #include "TextureManager.h"
         }
 
         uint16_t numStaticMeshes = file.readU16();
+        std::vector<StaticModel*> staticModels;
         for (unsigned int s = 0; s < numStaticMeshes; s++) {
             // Absolute position in world coordinates
             int32_t x = file.read32();
             // High two bits (0xC000) indicate steps of
             // 90 degrees (eg. (rotation >> 14) * 90)
             uint16_t rotation = file.readU16();
+            assert((rotation & 0x3FFF) == 0);
 
             // Constant lighting, 0xFFFF means use mesh lighting
             uint16_t intensity1 = file.readU16();
             // Which StaticMesh item to draw
             uint16_t objectID = file.readU16();
 
-            // TODO store static meshes somewhere
+            staticModels.push_back(new StaticModel(glm::vec3(x, y, z),
+                                                   (rotation >> 14) * 90.0f,
+                                                   objectID));
         }
 
         int16_t alternateRoom = file.read16(); // TODO
         RoomMesh* mesh = new RoomMesh(vertices, rectangles, triangles);
         Room* room = new Room(pos, boundingbox, mesh, roomFlags);
 
+        for (auto m : staticModels)
+            room->addModel(m);
+
         getWorld().addRoom(room);
 
         // Sanity check
             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 numTexturedRectangles = mem.read16();
+        std::vector<IndexedRectangle> texturedRectangles;
         for (int r = 0; r < numTexturedRectangles; r++) {
             uint16_t vertex1 = mem.readU16();
             uint16_t vertex2 = mem.readU16();
             uint16_t vertex4 = mem.readU16();
             uint16_t texture = mem.readU16();
 
-            //mesh->addTexturedRectangle(vertices.at(vertex1), vertices.at(vertex2),
-            //                           vertices.at(vertex3), vertices.at(vertex4),
-            //                           texture);
+            texturedRectangles.emplace_back(texture, vertex1, vertex2, vertex3, vertex4);
         }
 
         int16_t numTexturedTriangles = mem.read16();
+        std::vector<IndexedRectangle> texturedTriangles;
         for (int t = 0; t < numTexturedTriangles; t++) {
             uint16_t vertex1 = mem.readU16();
             uint16_t vertex2 = mem.readU16();
             uint16_t vertex3 = mem.readU16();
             uint16_t texture = mem.readU16();
 
-            //mesh->addTexturedTriangle(vertices.at(vertex1), vertices.at(vertex2),
-            //                          vertices.at(vertex3), texture);
+            texturedTriangles.emplace_back(texture, vertex1, vertex2, vertex3);
         }
 
         int16_t numColoredRectangles = mem.read16();
+        std::vector<IndexedColoredRectangle> coloredRectangles;
         for (int r = 0; r < numColoredRectangles; r++) {
             uint16_t vertex1 = mem.readU16();
             uint16_t vertex2 = mem.readU16();
             uint16_t texture = mem.readU16();
 
             int index = (texture & 0xFF00) >> 8;
-            float red = (palette.at(index) & 0xFF000000) >> 24,
-                  green = (palette.at(index) & 0x00FF0000) >> 16,
-                  blue = (palette.at(index) & 0x0000FF00) >> 8;
-
+            uint8_t 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),
-            //                          red, green, blue);
+            coloredRectangles.emplace_back(red, green, blue, vertex1, vertex2, vertex3, vertex4);
         }
 
         int16_t numColoredTriangles = mem.read16();
+        std::vector<IndexedColoredRectangle> coloredTriangles;
         for (int t = 0; t < numColoredTriangles; t++) {
             uint16_t vertex1 = mem.readU16();
             uint16_t vertex2 = mem.readU16();
             uint16_t texture = mem.readU16();
 
             int index = (texture & 0xFF00) >> 8;
-            float red = (palette.at(index) & 0xFF000000) >> 24,
-                  green = (palette.at(index) & 0x00FF0000) >> 16,
-                  blue = (palette.at(index) & 0x0000FF00) >> 8;
+            uint8_t 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), red, green, blue);
+            coloredTriangles.emplace_back(red, green, blue, vertex1, vertex2, vertex3);
         }
 
-        //getWorld().addMesh(mesh);
+        Mesh* mesh = new Mesh(vertices, texturedRectangles, texturedTriangles,
+                              coloredRectangles, coloredTriangles);
+        getWorld().addMesh(mesh);
     }
 
     if (numMeshPointers > 0)

src/system/FontSDL.cpp

 
         // Reserve slot
         mFontTexture = getTextureManager().loadBufferSlot(nullptr, 256, 256,
-                TextureManager::ColorMode::RGBA, 32, TextureManager::TextureStorage::SYSTEM);
+                       TextureManager::ColorMode::RGBA, 32, TextureManager::TextureStorage::SYSTEM);
 
         mFontInit = true;
     }

src/system/FontTRLE.cpp

     }
 
     mFontTexture = getTextureManager().loadBufferSlot(pixels, 256, 256,
-            TextureManager::ColorMode::BGRA, 32, TextureManager::TextureStorage::SYSTEM);
+                   TextureManager::ColorMode::BGRA, 32, TextureManager::TextureStorage::SYSTEM);
     delete [] pixels;
 
     // Try to load .lps file or use default glyph positions

src/system/Window.cpp

 Shader Window::textShader;
 Shader Window::imguiShader;
 Shader Window::textureShader;
+Shader Window::colorShader;
 unsigned int Window::vertexArrayID = 0;
 
 int Window::initializeGL() {
     getLog() << "GLSL V.: " << glGetString(GL_SHADING_LANGUAGE_VERSION) << Log::endl;
 
     glGenVertexArrays(1, &vertexArrayID);
-	glBindVertexArray(vertexArrayID);
+    glBindVertexArray(vertexArrayID);
 
     // Set background to black
     //glClearColor(BLACK[0] / 256.0f, BLACK[1] / 256.0f, BLACK[2] / 256.0f, BLACK[3] / 256.0f);
         return -10;
     textureShader.addBuffer(3);
 
+    if (colorShader.compile(colorShaderVertex, colorShaderFragment) < 0)
+        return -11;
+    if (colorShader.addUniform("MVP") < 0)
+        return -12;
+    colorShader.addBuffer(3);
+
     glEnable(GL_BLEND);
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
     glDisableVertexAttribArray(1);
 }
 
+void Window::drawGL(std::vector<glm::vec3>& vertices, std::vector<glm::vec3>& colors,
+                    std::vector<unsigned short>& indices, glm::mat4 MVP) {
+    assert(vertices.size() == colors.size());
+    assert((indices.size() % 3) == 0);
+
+    glBindBuffer(GL_ARRAY_BUFFER, colorShader.getBuffer(0));
+    glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(glm::vec3), &vertices[0], GL_STATIC_DRAW);
+
+    glBindBuffer(GL_ARRAY_BUFFER, colorShader.getBuffer(1));
+    glBufferData(GL_ARRAY_BUFFER, colors.size() * sizeof(glm::vec3), &colors[0], GL_STATIC_DRAW);
+
+    glBindBuffer(GL_ARRAY_BUFFER, colorShader.getBuffer(2));
+    glBufferData(GL_ARRAY_BUFFER, indices.size() * sizeof(unsigned short), &indices[0], GL_STATIC_DRAW);
+
+    colorShader.use();
+
+    glUniformMatrix4fv(colorShader.getUniform(0), 1, GL_FALSE, &MVP[0][0]);
+
+    glEnableVertexAttribArray(0);
+    glBindBuffer(GL_ARRAY_BUFFER, colorShader.getBuffer(0));
+    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
+
+    glEnableVertexAttribArray(1);
+    glBindBuffer(GL_ARRAY_BUFFER, colorShader.getBuffer(1));
+    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
+
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, colorShader.getBuffer(2));
+
+    glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_SHORT, nullptr);
+
+    glDisableVertexAttribArray(0);
+    glDisableVertexAttribArray(1);
+}
+
 // ----------------------------------------------------------------------------
 
 Shader::~Shader() {
 }
 )!?!";
 
+// --------------------------------------
+
+const char* Window::colorShaderVertex = R"!?!(
+#version 330 core
+
+layout(location = 0) in vec3 vertexPosition_modelspace;
+layout(location = 1) in vec3 vertexColor;
+
+out vec3 Color;
+
+uniform mat4 MVP;
+
+void main() {
+    vec4 pos = MVP * vec4(vertexPosition_modelspace.x,
+                          -vertexPosition_modelspace.y,
+                          vertexPosition_modelspace.z,
+                          1);
+    gl_Position = vec4(-pos.x, pos.yzw);
+    Color = vertexColor;
+}
+)!?!";
+
+const char* Window::colorShaderFragment = R"!?!(
+#version 330 core
+
+in vec3 Color;
+
+out vec4 color;
+
+void main() {
+    color = vec4(Color, 1);
+}
+)!?!";
+
+// --------------------------------------
 // *INDENT-ON*
 

src/utils/png.cpp

 
     int color_type;
     if (((mode == TextureManager::ColorMode::RGB)
-                || (mode == TextureManager::ColorMode::BGR)) && (bpp == 24)) {
+         || (mode == TextureManager::ColorMode::BGR)) && (bpp == 24)) {
         if (mode == TextureManager::ColorMode::BGR) {
             bgr2rgb24(image, width, height);
         }