Camera movement, first Mesh drawing

ChangeLog.md

@@ -2,6 +2,10 @@
 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20141216 ]
+    * Allow navigation with a free-floating Camera
+    * Started drawing the Room Mesh structures
+
     [ 20141215 ]
     * Rewrote GL code for the Font implementations, ImGUI and the Main Menu
 

include/Camera.h

@@ -13,6 +13,10 @@
 
 class Camera {
   public:
+
+    static void reset();
+
+    static void handleAction(ActionEvents action, bool isFinished);
     static void handleMouseMotion(int x, int y);
     static glm::mat4 getViewMatrix();
 

include/Game.h

@@ -53,3 +53,4 @@ class Game {
 Game& getGame();
 
 #endif
+

include/Mesh.h

@@ -10,183 +10,29 @@
 #ifndef _MESH_H_
 #define _MESH_H_
 
+#include <vector>
+#include <glm/mat4x4.hpp>
+#include <glm/vec2.hpp>
 #include <glm/vec3.hpp>
 
-/*!
- * \brief OpenGL Mesh
- */
+#include "loader/LoaderTR2.h"
+
 class Mesh {
   public:
+    Mesh(const std::vector<RoomVertexTR2>& vertices,
+         const std::vector<RoomRectangleTR2>& rectangles,
+         const std::vector<RoomTriangleTR2>& triangles);
 
-    struct rectangle_t {
-        glm::vec3 a, b, c, d;
-        uint16_t texture;
-        float red, green, blue;
-
-        rectangle_t(glm::vec3 _a, glm::vec3 _b, glm::vec3 _c, glm::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();
-    ~Mesh();
-
-    void drawAlpha();
-    void drawSolid();
-
-    void addTexturedRectangle(glm::vec3 a, glm::vec3 b, glm::vec3 c, glm::vec3 d, uint16_t textile);
-    void addTexturedTriangle(glm::vec3 a, glm::vec3 b, glm::vec3 c, uint16_t textile);
-
-    void addColoredRectangle(glm::vec3 a, glm::vec3 b, glm::vec3 c, glm::vec3 d, float re, float gr,
-                             float bl);
-    void addColoredTriangle(glm::vec3 a, glm::vec3 b, glm::vec3 c, float re, float gr, float bl);
-
-    void addNormal(glm::vec3 n);
-
-    std::vector<rectangle_t> texturedRectangles;
-    std::vector<rectangle_t> coloredRectangles;
-    std::vector<rectangle_t> texturedTriangles;
-    std::vector<rectangle_t> coloredTriangles;
-    std::vector<glm::vec3> normals;
-
-
-    // Old API
-
-    typedef enum {
-        MeshModeSolid,
-        MeshModeWireframe,
-        MeshModeTexture,
-        MeshModeMultiTexture
-    } MeshMode;
-
-    typedef enum {
-        fMesh_UseVertexArray = (1 << 0)
-    } MeshFlags;
-
-    typedef struct {
-        int texture;
-#ifdef MULTITEXTURE
-        int bumpmap;
-#endif
-
-        unsigned int cnum_triangles;
-        unsigned int cnum_alpha_triangles;
-
-        unsigned int num_texcoors;
-        float** texcoors; // 2D
-
-        unsigned int num_texcoors2;
-        float** texcoors2; // 2D
-
-        //! Arrays of triangle indices sorted by texture
-        unsigned int num_triangles;
-        unsigned int* triangles; //!< ABCABCABC...
-
-        //! Arrays of alpha triangle indices sorted by texture
-        unsigned int num_alpha_triangles;
-        unsigned int* alpha_triangles; //!< ABCABCABC...
-    } tris_t;
-
-    typedef struct {
-
-        int texture;
-#ifdef MULTITEXTURE
-        int bumpmap;
-#endif
-
-        unsigned int cnum_quads;
-        unsigned int cnum_alpha_quads;
-
-        unsigned int num_texcoors;
-        float** texcoors; // 2D
-
-        unsigned int num_texcoors2;
-        float** texcoors2; // 2D
-
-        //! Arrays of rectangle indices sorted by texture
-        unsigned int num_quads;
-        unsigned int* quads; //!< ABCDABCDABCD...
-
-        //! Arrays of alpha rectangle indices sorted by texture
-        unsigned int num_alpha_quads;
-        unsigned int* alpha_quads; //!< ABCDABCDABCD...
+    void prepare();
 
-    } rect_t;
+    void display(glm::mat4 model, glm::mat4 view, glm::mat4 projection);
 
-    void drawAlphaOld();
-    void drawSolidOld();
-
-    void allocateColors(unsigned int n);
-
-    void allocateNormals(unsigned int n);
-
-    void allocateRectangles(unsigned int n);
-
-    void allocateTriangles(unsigned int n);
-
-    void allocateVertices(unsigned int n);
-
-    void bufferColorArray(unsigned int colorCount, float* colors);
-
-    void bufferNormalArray(unsigned int normalCount, float* normals);
-
-    void bufferTriangles(unsigned int count,
-                         unsigned int* indices, float* texCoords,
-                         int* textures, unsigned int* flags);
-
-    void bufferVertexArray(unsigned int vertexCount, float* vertices);
-
-    void setColor(unsigned int index, float r, float g, float b, float a);
-
-    void setColor(unsigned int index, float rgba[4]);
-
-    void setNormal(unsigned int index, float i, float j, float k);
-
-    void setVertex(unsigned int index, float x, float y, float z);
-
-#if 0
-    void sortFacesByTexture();
-
-    void addFace(int textureIndex, int textureIndexB, unsigned int flags,
-                 unsigned int vertexIndexCount, float* vertexIndices);
-
-    void addTexTiledFace(int textureIndex, int textureIndexB,
-                         unsigned int flags, unsigned int indexCount,
-                         float* vertexIndices, float* texcoords);
-
-    void bufferTexcoords(unsigned int texcoordCount, float* texcoords);
-
-    void duplicateArraysForTexTiledTexcoords();
-#endif
-
-    unsigned int mFlags;
-
-    MeshMode mMode;
-
-    unsigned int mNumVertices;
-    float** mVertices; //!< XYZ
-
-    unsigned int mNumNormals;
-    float** mNormals; //!< IJK
-
-    unsigned int mNumColors;
-    float** mColors; //!< RGBA
-
-    unsigned int mNumTris;
-    tris_t* mTris;
-
-    unsigned int mNumQuads;
-    rect_t* mQuads;
-
-    unsigned int mTriangleCount;
-    int* mTriangleTextures;
-    unsigned int* mTriangleIndices;
-    unsigned int* mTriangleFlags;
-    float* mTriangleTexCoordArray;
-
-    float* mVertexArray;
-    float* mNormalArray;
-    float* mColorArray;
+  private:
+    std::vector<unsigned short> indices;
+    std::vector<glm::vec3> vertices;
+    std::vector<glm::vec2> uvs;
+    std::vector<unsigned int> textures;
 };
 
 #endif
+

include/Room.h

@@ -8,22 +8,26 @@
 #ifndef _ROOM_H_
 #define _ROOM_H_
 
+#include <memory>
 #include <vector>
+#include <glm/mat4x4.hpp>
+#include <glm/vec3.hpp>
+
 #include "Mesh.h"
 #include "Sprite.h"
 #include "RoomData.h"
 
-typedef enum {
+enum RoomFlags {
     RoomFlagUnderWater = (1 << 0)
-} RoomFlags;
+};
 
 class Room {
   public:
-    Room(float p[3] = nullptr, unsigned int f = 0, unsigned int x = 0, unsigned int z = 0);
-    ~Room();
+    Room(glm::vec3 _pos, BoundingBox* _bbox, Mesh* _mesh, unsigned int f)
+        : pos(_pos), bbox(_bbox), mesh(_mesh), flags(f) { }
 
-    BoundingBox& getBoundingBox();
-    void display(bool alpha);
+    void prepare();
+    void display(glm::mat4 view, glm::mat4 projection);
 
     bool isWall(unsigned long sector);
     long getSector(float x, float z, float* floor, float* ceiling);
@@ -32,18 +36,16 @@ class Room {
     int getAdjoiningRoom(float x, float y, float z,
                          float x2, float y2, float z2);
 
-    Mesh& getMesh() { return mesh; }
+    BoundingBox& getBoundingBox() { return *bbox; }
+    Mesh& getMesh() { return *mesh; }
 
-    unsigned int getNumXSectors();
-    unsigned int getNumZSectors();
-    void getPos(float p[3]);
+    void setNumXSectors(unsigned int n) { numXSectors = n; }
+    unsigned int getNumXSectors() { return numXSectors; }
 
-    void setNumXSectors(unsigned int n);
-    void setNumZSectors(unsigned int n);
-    void setPos(float p[3]);
+    void setNumZSectors(unsigned int n) { numZSectors = n; }
+    unsigned int getNumZSectors() { return numZSectors; }
 
-    void setFlags(unsigned int f);
-    unsigned int getFlags();
+    unsigned int getFlags() { return flags; }
 
     unsigned long sizeAdjacentRooms();
     long getAdjacentRoom(unsigned long index);
@@ -70,20 +72,20 @@ class Room {
     void addSprite(Sprite* s);
 
   private:
+    glm::vec3 pos;
+    std::unique_ptr<BoundingBox> bbox;
+    std::unique_ptr<Mesh> mesh;
+
     unsigned int flags;
     unsigned int numXSectors;
     unsigned int numZSectors;
-    float pos[3];
-
-    BoundingBox bbox;
-    Mesh mesh;
 
     std::vector<long> adjacentRooms;
-    std::vector<Sprite*> sprites;
-    std::vector<StaticModel*> models;
-    std::vector<Portal*> portals;
-    std::vector<Sector*> sectors;
-    std::vector<Light*> lights;
+    std::vector<std::unique_ptr<Sprite>> sprites;
+    std::vector<std::unique_ptr<StaticModel>> models;
+    std::vector<std::unique_ptr<Portal>> portals;
+    std::vector<std::unique_ptr<Sector>> sectors;
+    std::vector<std::unique_ptr<Light>> lights;
 
     // Was used for "depth sorting" render list, but never assigned...?!
     //float dist; // Distance to near plane, move to room?

include/RoomData.h

@@ -14,15 +14,13 @@
 
 class BoundingBox {
   public:
-    BoundingBox();
-    void getBoundingBox(float box[2][3]);
-    void setBoundingBox(float min[3], float max[3]);
+    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);
 
   private:
-    float a[3], b[3];
+    glm::vec3 a, b;
 };
 
 class Light {

include/TextureManager.h

@@ -11,6 +11,7 @@
 
 #include <cstdint>
 #include <vector>
+#include <glm/vec2.hpp>
 
 // These are loaded into TextureStorage::SYSTEM by initialize()!
 #define TEXTURE_WHITE 0
@@ -18,7 +19,8 @@
 
 class TextureTileVertex {
   public:
-    TextureTileVertex(uint8_t xc, uint8_t xp, uint8_t yc, uint8_t yp);
+    TextureTileVertex(uint8_t xc, uint8_t xp, uint8_t yc, uint8_t yp)
+        : xCoordinate(xc), xPixel(xp), yCoordinate(yc), yPixel(yp) { }
 
     uint8_t xCoordinate, xPixel;
     uint8_t yCoordinate, yPixel;
@@ -26,18 +28,16 @@ class TextureTileVertex {
 
 class TextureTile {
   public:
-    TextureTile(uint16_t a, uint16_t t) : attribute(a), texture(t) { }
-    ~TextureTile();
+    TextureTile(unsigned int a, unsigned int t) : attribute(a), texture(t) { }
 
-    void add(TextureTileVertex* t);
-
-    void displayTriangle(float a[3], float b[3], float c[3]);
-    void displayRectangle(float a[3], float b[3], float c[3], float d[3]);
+    unsigned int getTexture() { return texture; }
+    glm::vec2 getUV(unsigned int i) { return glm::vec2(vertices.at(i).xPixel, vertices.at(i).yPixel); }
+    void add(TextureTileVertex t) { vertices.push_back(t); }
 
   private:
-    uint16_t attribute;
-    uint16_t texture;
-    std::vector<TextureTileVertex*> vertices;
+    unsigned int attribute;
+    unsigned int texture;
+    std::vector<TextureTileVertex> vertices;
 };
 
 /*!

include/loader/LoaderTR2.h

@@ -45,5 +45,33 @@ class LoaderTR2 : public Loader {
     std::array<uint32_t, 256> palette;
 };
 
+struct RoomVertexTR2 {
+    int16_t x, y, z; // Vertex coordinates, relative to x/zOffset
+    int16_t 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 RoomRectangleTR2 {
+    uint16_t v1, v2, v3, v4; // Vertex list indices
+    uint16_t texture; // Index into object-texture list
+
+    RoomRectangleTR2(uint16_t _v1, uint16_t _v2, uint16_t _v3, uint16_t _v4, uint16_t t)
+        : v1(_v1), v2(_v2), v3(_v3), v4(_v4), texture(t) { }
+};
+
+struct RoomTriangleTR2 {
+    uint16_t v1, v2, v3; // Vertex list indices
+    uint16_t texture; // Index into object-texture list
+
+    RoomTriangleTR2(uint16_t _v1, uint16_t _v2, uint16_t _v3, uint16_t t)
+        : v1(_v1), v2(_v2), v3(_v3), texture(t) { }
+};
+
 #endif
 

include/system/Window.h

@@ -9,7 +9,9 @@
 #define _WINDOW_H_
 
 #include <vector>
+#include <glm/mat4x4.hpp>
 #include <glm/vec2.hpp>
+#include <glm/vec3.hpp>
 #include <glm/vec4.hpp>
 
 class Shader {
@@ -63,6 +65,9 @@ class Window {
     static void drawTextGL(std::vector<glm::vec2>& vertices, std::vector<glm::vec2>& uvs,
                            glm::vec4 color, unsigned int texture);
 
+    static void drawGL(std::vector<glm::vec3>& vertices, std::vector<glm::vec2>& uvs,
+                       std::vector<unsigned short>& indices, glm::mat4 MVP, unsigned int texture);
+
   protected:
     bool mInit;
     bool mFullscreen;
@@ -80,6 +85,10 @@ class Window {
     static const char* imguiShaderVertex;
     static const char* imguiShaderFragment;
 
+    static Shader textureShader;
+    static const char* textureShaderVertex;
+    static const char* textureShaderFragment;
+
     static unsigned int vertexArrayID;
 
     friend class UI;

src/Camera.cpp

@@ -17,6 +17,48 @@ float Camera::thetaY = 0.0f;
 float Camera::rotationDeltaX = 0.75f;
 float Camera::rotationDeltaY = 0.75f;
 
+void Camera::reset() {
+    pos = glm::vec3(0.0f, 0.0f, 0.0f);
+    thetaX = glm::pi<float>();
+    thetaY = 0.0f;
+}
+
+void Camera::handleAction(ActionEvents action, bool isFinished) {
+    if (isFinished)
+        return;
+
+    const static float step = 256.0f;
+
+    glm::vec3 dir(
+        glm::cos(thetaY) * glm::sin(thetaX),
+        glm::sin(thetaY),
+        glm::cos(thetaY) * glm::cos(thetaX)
+    );
+    glm::vec3 right(
+        glm::sin(thetaX - glm::pi<float>() / 2.0f),
+        0.0f,
+        glm::cos(thetaX - glm::pi<float>() / 2.0f)
+    );
+    glm::vec3 up = glm::cross(right, dir);
+
+    if (action == forwardAction) {
+        pos += dir * step;
+    } else if (action == backwardAction) {
+        pos -= dir * step;
+    } else if (action == leftAction) {
+        pos -= right * step;
+    } else if (action == rightAction) {
+        pos += right * step;
+    } else if (action == jumpAction) {
+        pos += up * step;
+    } else if (action == crouchAction) {
+        pos -= up * step;
+    } else if (action == useAction) {
+    } else if (action == holsterAction) {
+    } else if (action == walkAction) {
+    }
+}
+
 void Camera::handleMouseMotion(int x, int y) {
     while (x > 0) {
         if (thetaX < (glm::pi<float>() / 2.0f)) {

src/Game.cpp

@@ -7,6 +7,7 @@
 
 #include <algorithm>
 #include <map>
+#include <sstream>
 #include <cstdlib>
 #include <cstring>
 
@@ -16,9 +17,12 @@
 #include "loader/Loader.h"
 #include "Log.h"
 #include "Render.h"
+#include "RunTime.h"
 #include "SoundManager.h"
 #include "StaticMesh.h"
+#include "system/Font.h"
 #include "system/Sound.h"
+#include "system/Window.h"
 #include "TextureManager.h"
 #include "UI.h"
 #include "World.h"
@@ -41,6 +45,24 @@ int Game::initialize() {
 
 void Game::display() {
     Render::display();
+
+    if (getRunTime().getShowFPS()) {
+        std::ostringstream s;
+        s << getRunTime().getFPS() << "FPS";
+        Font::drawText(10, getWindow().getHeight() - 25, 0.6f, BLUE, s.str());
+
+        s.str("");
+        s << "X: " << Camera::getPosition().x << " (" << Camera::getRadianPitch() << ")";
+        Font::drawText(10, getWindow().getHeight() - 70, 0.6f, BLUE, s.str());
+
+        s.str("");
+        s << "Y: " << Camera::getPosition().y << " (" << Camera::getRadianYaw() << ")";
+        Font::drawText(10, getWindow().getHeight() - 55, 0.6f, BLUE, s.str());
+
+        s.str("");
+        s << "Z: " << Camera::getPosition().z;
+        Font::drawText(10, getWindow().getHeight() - 40, 0.6f, BLUE, s.str());
+    }
 }
 
 void Game::destroy() {
@@ -48,10 +70,10 @@ void Game::destroy() {
     mLara = -1;
     Render::setMode(RenderMode::LoadScreen);
 
-    getWorld().destroy();
-    Sound::clear(); // Remove all previously loaded sounds
+    Camera::reset();
     SoundManager::clear();
     getTextureManager().clear();
+    getWorld().destroy();
 }
 
 bool Game::isLoaded() {
@@ -64,65 +86,51 @@ int Game::loadLevel(const char* level) {
     getLog() << "Loading " << levelName << Log::endl;
     auto loader = Loader::createLoader(level);
     if (loader) {
-        // First Loader test
-        getLog() << "Trying to load using new loader..." << Log::endl;
         int error = loader->load(level);
         if (error != 0) {
-            getLog() << "Error while trying new loader (" << error << ")..." << Log::endl;
+            getLog() << "Error loading level (" << error << ")..." << Log::endl;
             destroy();
             return -2;
-        } else {
-            SoundManager::prepareSources();
+        }
+
+        for (int i = 0; i < getWorld().sizeRoom(); i++) {
+            getWorld().getRoom(i).prepare();
+        }
 
-            if (mLara == -1) {
-                getLog() << "Can't find Lara entity in level?!" << Log::endl;
-            } else {
-                mLoaded = true;
-                //Render::setMode(RenderMode::Texture);
-            }
+        SoundManager::prepareSources();
 
+        if (mLara == -1) {
+            getLog() << "Can't find Lara entity in level?!" << Log::endl;
             UI::setVisible(true);
-            return 0;
+        } else {
+            mLoaded = true;
+            Render::setMode(RenderMode::Texture);
         }
     } else {
         getLog() << "No suitable loader for this level!" << Log::endl;
         return -1;
     }
+
+    return 0;
 }
 
 void Game::handleAction(ActionEvents action, bool isFinished) {
-    if (mLoaded && (!isFinished)) {
-        if (action == forwardAction) {
-            getLara().move('f');
-        } else if (action == backwardAction) {
-            getLara().move('b');
-        } else if (action == leftAction) {
-            getLara().move('l');
-        } else if (action == rightAction) {
-            getLara().move('r');
-        } else if (action == jumpAction) {
-
-        } else if (action == crouchAction) {
-
-        } else if (action == useAction) {
-
-        } else if (action == holsterAction) {
+    if (isFinished || (!mLoaded))
+        return;
 
-        } else if (action == walkAction) {
-
-        }
-    }
+    Camera::handleAction(action, isFinished);
 }
 
 void Game::handleMouseMotion(int xrel, int yrel, int xabs, int yabs) {
-    if (mLoaded) {
-        Camera::handleMouseMotion(xrel, yrel);
+    if (!mLoaded)
+        return;
 
-        /*
-        float angles[3] = { 0.0f, getCamera().getRadianYaw(), getCamera().getRadianPitch() };
-        getLara().setAngles(angles);
-        */
-    }
+    Camera::handleMouseMotion(xrel, yrel);
+
+    /* TODO
+    float angles[3] = { 0.0f, getCamera().getRadianYaw(), getCamera().getRadianPitch() };
+    getLara().setAngles(angles);
+    */
 }
 
 Entity& Game::getLara() {

src/Mesh.cpp

@@ -5,648 +5,99 @@
  * \author Mongoose
  */
 
+#include <map>
 #include <stdlib.h>
 
 #include "global.h"
 #include "TextureManager.h"
+#include "system/Window.h"
 #include "Mesh.h"
 
-void Mesh::addTexturedRectangle(glm::vec3 a, glm::vec3 b, glm::vec3 c, glm::vec3 d,
-                                uint16_t textile) {
-    texturedRectangles.emplace_back(a, b, c, d, textile);
-}
-
-void Mesh::addTexturedTriangle(glm::vec3 a, glm::vec3 b, glm::vec3 c, uint16_t textile) {
-    texturedTriangles.emplace_back(a, b, c, glm::vec3(), textile);
-}
-
-void Mesh::addColoredRectangle(glm::vec3 a, glm::vec3 b, glm::vec3 c, glm::vec3 d, float re,
-                               float gr, float bl) {
-    coloredRectangles.emplace_back(a, b, c, d, -1, re, gr, bl);
-}
-
-void Mesh::addColoredTriangle(glm::vec3 a, glm::vec3 b, glm::vec3 c, float re, float gr, float bl) {
-    coloredTriangles.emplace_back(a, b, c, glm::vec3(), -1, re, gr, bl);
-}
-
-void Mesh::addNormal(glm::vec3 n) {
-    normals.emplace_back(n);
-}
-
-void Mesh::drawAlpha() {
-    if ((texturedRectangles.size() == 0)
-        && (texturedTriangles.size() == 0)
-        && (coloredRectangles.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)
-        && (normals.size() == 0)) {
-        drawSolidOld();
-        return;
-    }
-
-    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 == MeshModeSolid) {
-            // TODO
-        } else if (mMode == MeshModeTexture) {
-            //getTextureManager().getTile(q.texture).displayRectangle(q.a, q.b, q.c, q.d);
-        }
-    }
-
-    for (auto& t : texturedTriangles) {
-        if (mMode == MeshModeWireframe) {
-            getTextureManager().bindTextureId(TEXTURE_WHITE, TextureManager::TextureStorage::SYSTEM);
-            /*
-            glBegin(GL_TRIANGLES);
-            glTexCoord2f(0.0f, 0.0f);
-            glVertex3f(t.a.x, t.a.y, t.a.z);
-            glTexCoord2f(1.0f, 0.0f);
-            glVertex3f(t.b.x, t.b.y, t.b.z);
-            glTexCoord2f(1.0f, 1.0f);
-            glVertex3f(t.c.x, t.c.y, t.c.z);
-            glEnd();
-            */
-        } else if (mMode == MeshModeSolid) {
-            // TODO
-        } else if (mMode == MeshModeTexture) {
-            //getTextureManager().getTile(t.texture).displayTriangle(t.a, t.b, t.c);
-        }
-    }
-
-    for (auto& q : coloredRectangles) {
-        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 == MeshModeSolid) {
-            // TODO
-        } else if (mMode == MeshModeTexture) {
-            // TODO
-        }
-    }
-
-    for (auto& t : coloredTriangles) {
-        if (mMode == MeshModeWireframe) {
-            getTextureManager().bindTextureId(TEXTURE_WHITE, TextureManager::TextureStorage::SYSTEM);
-            /*
-            glBegin(GL_TRIANGLES);
-            glTexCoord2f(0.0f, 0.0f);
-            glVertex3f(t.a.x, t.a.y, t.a.z);
-            glTexCoord2f(1.0f, 0.0f);
-            glVertex3f(t.b.x, t.b.y, t.b.z);
-            glTexCoord2f(1.0f, 1.0f);
-            glVertex3f(t.c.x, t.c.y, t.c.z);
-            glEnd();
-            */
-        } else if (mMode == MeshModeSolid) {
-            // TODO
-        } else if (mMode == MeshModeTexture) {
-            // TODO
-        }
-    }
-}
-
-
-////////////////////////////////////////////////////////////
-// Constructors
-////////////////////////////////////////////////////////////
-
-Mesh::Mesh() {
-    mNumVertices = 0;
-    mVertices = 0x0;
-
-    mNumNormals = 0;
-    mNormals = 0x0;
-
-    mNumColors = 0;
-    mColors = 0x0;
-
-    mNumTris = 0;
-    mTris = 0x0;
-
-    mNumQuads = 0;
-    mQuads = 0x0;
-
-    mVertexArray = 0x0;
-    mNormalArray = 0x0;
-    mColorArray = 0x0;
-
-    mTriangleCount = 0;
-    mTriangleTextures = 0x0;
-    mTriangleIndices = 0x0;
-    mTriangleFlags = 0x0;
-    mTriangleTexCoordArray = 0x0;
-
-    mFlags = 0;
-    mMode = MeshModeTexture;
-}
-
-
-Mesh::~Mesh() {
-    for (unsigned int i = 0; i < mNumVertices; i++)
-        delete [] mVertices[i];
-    delete [] mVertices;
-    mVertices = nullptr;
-
-    for (unsigned int i = 0; i < mNumNormals; i++)
-        delete [] mNormals[i];
-    delete [] mNormals;
-    mNormals = nullptr;
-
-    for (unsigned int i = 0; i < mNumColors; i++)
-        delete [] mColors[i];
-    delete [] mColors;
-    mColors = nullptr;
-
-    if (mTris) {
-        for (unsigned int i = 0; i < mNumTris; ++i) {
-            delete [] mTris[i].triangles;
-            delete [] mTris[i].alpha_triangles;
-            delete [] mTris[i].texcoors;
-            delete [] mTris[i].texcoors2;
-        }
-
-        delete [] mTris;
-        mTris = nullptr;
-    }
-
-    if (mQuads) {
-        for (unsigned int i = 0; i < mNumQuads; ++i) {
-            delete [] mQuads[i].quads;
-            delete [] mQuads[i].alpha_quads;
-            delete [] mQuads[i].texcoors;
-            delete [] mQuads[i].texcoors2;
-        }
-
-        delete [] mQuads;
-        mQuads = nullptr;
-    }
-
-    delete [] mVertexArray;
-    mVertexArray = nullptr;
-
-    delete [] mNormalArray;
-    mNormalArray = nullptr;
-
-    delete [] mColorArray;
-    mColorArray = nullptr;
-
-    delete [] mTriangleTextures;
-    mTriangleTextures = nullptr;
-
-    delete [] mTriangleIndices;
-    mTriangleIndices = nullptr;
-
-    delete [] mTriangleFlags;
-    mTriangleFlags = nullptr;
-
-    delete [] mTriangleTexCoordArray;
-    mTriangleTexCoordArray = nullptr;
-}
-
-
-////////////////////////////////////////////////////////////
-// Public Accessors
-////////////////////////////////////////////////////////////
-
-void Mesh::drawAlphaOld() {
-    unsigned int i, j, k, index;
-
-    /*
-
-    // Render quadralaterals
-    for (mQuads ? i = 0 : i = mNumQuads; i < mNumQuads; ++i) {
-        switch (mMode) {
-            case MeshModeWireframe:
-                glColor3f(0.0, 0.0, 1.0);
-                getTextureManager().bindTextureId(TEXTURE_WHITE, TextureManager::TextureStorage::SYSTEM);
-                break;
-            case MeshModeSolid:
-                // Bind WHITE texture for solid colors
-                getTextureManager().bindTextureId(TEXTURE_WHITE, TextureManager::TextureStorage::SYSTEM);
-                break;
-            case MeshModeTexture:
-            case MeshModeMultiTexture:
-                // Bind texture id for textures
-                getTextureManager().bindTextureId(mQuads[i].texture);
-                break;
-        }
-
-        glBegin(GL_QUADS);
-
-        for (j = 0; j < mQuads[i].num_alpha_quads; ++j) {
-            for (k = 0; k < 4; ++k) {
-                index = mQuads[i].alpha_quads[j * 4 + k];
-
-                glTexCoord2fv(mQuads[i].texcoors2[j * 4 + k]);
-                glColor4fv(mColors[index]);
-                glVertex3fv(mVertices[index]);
-            }
-        }
-
-        glEnd();
-    }
-
-    // Render triangles
-    for (mTris ? i = 0 : i = mNumTris; i < mNumTris; ++i) {
-        switch (mMode) {
-            case MeshModeWireframe:
-                glColor3f(0.0, 1.0, 0.0);
-                getTextureManager().bindTextureId(TEXTURE_WHITE, TextureManager::TextureStorage::SYSTEM);
-                break;
-            case MeshModeSolid:
-                // Bind WHITE texture for solid colors
-                getTextureManager().bindTextureId(TEXTURE_WHITE, TextureManager::TextureStorage::SYSTEM);
-                break;
-            case MeshModeTexture:
-            case MeshModeMultiTexture:
-                // Bind texture id for textures
-                getTextureManager().bindTextureId(mTris[i].texture);
-                break;
-        }
-
-        glBegin(GL_TRIANGLES);
-
-        for (j = 0; j < mTris[i].num_alpha_triangles; ++j) {
-            for (k = 0; k < 3; ++k) {
-                index = mTris[i].alpha_triangles[j * 3 + k];
-
-                glTexCoord2fv(mTris[i].texcoors2[j * 3 + k]);
-                glColor4fv(mColors[index]);
-                glVertex3fv(mVertices[index]);
-            }
-        }
-
-        glEnd();
-    }
-
-    */
-}
-
-
-void Mesh::drawSolidOld() {
-    unsigned int i, j, k, index;
-
-    /*
-
-
-    // Render quadralaterals
-    for (mQuads ? i = 0 : i = mNumQuads; i < mNumQuads; ++i) {
-        switch (mMode) {
-            case MeshModeSolid:
-                glColor3f(0.0, 0.0, 0.0);
-                break;
-            case MeshModeWireframe:
-                // Bind WHITE texture for solid colors
-                getTextureManager().bindTextureId(TEXTURE_WHITE, TextureManager::TextureStorage::SYSTEM);
-                break;
-#ifdef MULTITEXTURE
-            case MeshModeMultiTexture:
-                glActiveTextureARB(GL_TEXTURE0_ARB);
-                glEnable(GL_TEXTURE_2D);
-                getTextureManager().bindTextureId(mQuads[i].texture);
-
-                glActiveTextureARB(GL_TEXTURE1_ARB);
-                glEnable(GL_TEXTURE_2D);
-                getTextureManager().bindTextureId(mQuads[i].bumpmap);
-                break;
-#else
-            case MeshModeMultiTexture:
-#endif
-            case MeshModeTexture:
-                // Bind texture id for textures
-                glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
-                getTextureManager().bindTextureId(mQuads[i].texture);
-                break;
-        }
-
-        glBegin(GL_QUADS);
-
-        for (j = 0; j < mQuads[i].num_quads; ++j) {
-            for (k = 0; k < 4; ++k) {
-                index = mQuads[i].quads[j * 4 + k];
-
-                glColor4fv(mColors[index]);
-
-#ifdef MULTITEXTURE
-                if (mMode == MeshModeMultiTexture) {
-                    glMultiTexCoord2fvARB(GL_TEXTURE0_ARB,
-                                          mQuads[i].texcoors[j * 4 + k]);
-                    glMultiTexCoord2fvARB(GL_TEXTURE1_ARB,
-                                          mQuads[i].texcoors[j * 4 + k]);
-                } else
-#endif
-                    glTexCoord2fv(mQuads[i].texcoors[j * 4 + k]);
-
-                glVertex3fv(mVertices[index]);
+Mesh::Mesh(const std::vector<RoomVertexTR2>& vert,
+     const std::vector<RoomRectangleTR2>& rect,
+     const std::vector<RoomTriangleTR2>& 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));
+        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);
+    }
+}
+
+struct PackedVertex {
+    glm::vec3 pos;
+    glm::vec2 uv;
+    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; }
+};
+
+static bool findSimilarVertex(PackedVertex& v,
+                              std::map<PackedVertex, unsigned short> m,
+                              unsigned short& s) {
+    auto it = m.find(v);
+    if (it == m.end())
+        return false;
+    else {
+        s = it->second;
+        return true;
+    }
+}
+
+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);
             }
         }
 
-        glEnd();
-    }
-
-    // Render triangles
-    for (mTris ? i = 0 : i = mNumTris; i < mNumTris; ++i) {
-        switch (mMode) {
-            case MeshModeSolid:
-                glColor3f(1.0, 0.0, 0.0);
-                break;
-            case MeshModeWireframe:
-                // Bind WHITE texture for solid colors
-                getTextureManager().bindTextureId(TEXTURE_WHITE, TextureManager::TextureStorage::SYSTEM);
-                break;
-#ifdef MULTITEXTURE
-            case MeshModeMultiTexture:
-                glActiveTextureARB(GL_TEXTURE0_ARB);
-                glEnable(GL_TEXTURE_2D);
-                getTextureManager().bindTextureId(mTris[i].texture);
-
-                glActiveTextureARB(GL_TEXTURE1_ARB);
-                glEnable(GL_TEXTURE_2D);
-                getTextureManager().bindTextureId(mTris[i].bumpmap);
-                break;
-#else
-            case MeshModeMultiTexture:
-#endif
-            case MeshModeTexture:
-                // Bind texture id for textures
-                glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
-                getTextureManager().bindTextureId(mTris[i].texture);
-                break;
-        }
-
-        glBegin(GL_TRIANGLES);
-
-        for (j = 0; j < mTris[i].num_triangles; ++j) {
-            for (k = 0; k < 3; ++k) {
-                index = mTris[i].triangles[j * 3 + k];
-
-#ifdef MULTITEXTURE
-                if (mMode == MeshModeMultiTexture) {
-                    glMultiTexCoord2fvARB(GL_TEXTURE0_ARB,
-                                          mTris[i].texcoors[j * 3 + k]);
-                    glMultiTexCoord2fvARB(GL_TEXTURE1_ARB,
-                                          mTris[i].texcoors[j * 3 + k]);
-                } else
-#endif
-                    glTexCoord2fv(mTris[i].texcoors[j * 3 + k]);
-
-                glColor4fv(mColors[index]);
-                glVertex3fv(mVertices[index]);
-            }
+        if (indices.at(i) == 0) {
+            ind.push_back(ind.at(ind.size() - 1));
+            ind.push_back(ind.at(ind.size() - 3));
         }
 
-        glEnd();
-    }
-
-#ifdef MULTITEXTURE
-    if (mMode == MeshModeMultiTexture) {
-        glDisable(GL_TEXTURE_2D);
-        glActiveTextureARB(GL_TEXTURE0_ARB);
-    }
-#endif
-
-    */
-}
-
-
-////////////////////////////////////////////////////////////
-// Public Mutators
-////////////////////////////////////////////////////////////
-
-void Mesh::allocateColors(unsigned int n) {
-    if (mColors) {
-        for (unsigned int i = 0; i < mNumColors; i++)
-            delete [] mColors[i];
-        delete [] mColors;
-        mNumColors = 0;
-    }
-
-    if (!n) {
-        return;
-    }
-
-    mNumColors = n;
-    mColors = new float *[mNumColors];
-    for (unsigned int i = 0; i < mNumColors; i++)
-        mColors[i] = new float[4];
-}
-
-
-void Mesh::allocateNormals(unsigned int n) {
-    if (mNormals) {
-        for (unsigned int i = 0; i < mNumNormals; i++)
-            delete [] mNormals[i];
-        delete [] mNormals;
-        mNumNormals = 0;
-    }
-
-    if (!n) {
-        return;
-    }
-
-    mNumNormals = n;
-    mNormals = new float *[mNumNormals];
-    for (unsigned int i = 0; i < mNumNormals; i++)
-        mNormals[i] = new float[3];
-}
-
-
-void Mesh::allocateRectangles(unsigned int n) {
-    if (mQuads) {
-        mNumQuads = 0;
-        delete [] mQuads;
-    }
-
-    if (!n) {
-        return;
-    }
-
-    mNumQuads = n;
-    mQuads = new rect_t[mNumQuads];
-}
-
-
-void Mesh::allocateTriangles(unsigned int n) {
-    if (mTris) {
-        mNumTris = 0;
-        delete [] mTris;
-    }
-
-    if (!n) {
-        return;
-    }
-
-    mNumTris = n;
-    mTris = new tris_t[mNumTris];
-}
-
-
-void Mesh::allocateVertices(unsigned int n) {
-    if (mVertices) {
-        for (unsigned int i = 0; i < mNumVertices; i++)
-            delete [] mVertices[i];
-        delete [] mVertices;
-        mNumVertices = 0;
-    }
-
-    if (!n) {
-        return;
-    }
-
-    mNumVertices = n;
-    mVertices = new float *[mNumVertices];
-    for (unsigned int i = 0; i < mNumVertices; i++)
-        mVertices[i] = new float[3];
-}
-
-
-void Mesh::bufferColorArray(unsigned int colorCount, float* colors) {
-    if (mColors) {
-        for (unsigned int i = 0; i < mNumColors; i++)
-            delete [] mColors[i];
-        delete [] mColors;
-        mNumColors = 0;
-    }
-
-    if (!colorCount) {
-        return;
-    }
-
-    mNumColors = colorCount;
-    mColorArray = colors;
-}
-
-
-void Mesh::bufferNormalArray(unsigned int normalCount, float* normals) {
-    if (mNormals) {
-        for (unsigned int i = 0; i < mNumNormals; i++)
-            delete [] mNormals[i];
-        delete [] mNormals;
-        mNumNormals = 0;
-    }
-
-    if (!normalCount) {
-        return;
-    }
-
-    mNumNormals = normalCount;
-    mNormalArray = normals;
-}
-
-
-void Mesh::bufferTriangles(unsigned int count,
-                           unsigned int* indices, float* texCoords,
-                           int* textures, unsigned int* flags) {
-
-    mTriangleCount = count;
-    mTriangleTextures = textures;
-    mTriangleIndices = indices;
-    mTriangleFlags = flags;
-    mTriangleTexCoordArray = texCoords;
-
-    //! \fixme sortTrianglesByTexture();
-}
-
-
-void Mesh::bufferVertexArray(unsigned int vertexCount, float* vertices) {
-    if (mVertices) {
-        for (unsigned int i = 0; i < mNumVertices; i++)
-            delete [] mVertices[i];
-        delete [] mVertices;
-        mNumVertices = 0;
-    }
-
-    if (!vertexCount) {
-        return;
+        vertIndex += (indices.at(i) == 0) ? 4 : 3;
     }
 
-    mNumVertices = vertexCount;
-    mVertexArray = vertices;
-    mFlags |= fMesh_UseVertexArray;
-}
-
-
-void Mesh::setColor(unsigned int index,
-                    float r, float g, float b, float a) {
-    assert(index < mNumColors);
-
-    mColors[index][0] = r;
-    mColors[index][1] = g;
-    mColors[index][2] = b;
-    mColors[index][3] = a;
+    indices = ind;
+    vertices = vert;
+    textures = tex;
 }
 
+void Mesh::display(glm::mat4 model, glm::mat4 view, glm::mat4 projection) {
+    glm::mat4 MVP = projection * view * model;
 
-void Mesh::setColor(unsigned int index, float rgba[4]) {
-    assert(index < mNumColors);
+    // TODO handle different textures!
 
-    mColors[index][0] = rgba[0];
-    mColors[index][1] = rgba[1];
-    mColors[index][2] = rgba[2];
-    mColors[index][3] = rgba[3];
+    Window::drawGL(vertices, uvs, indices, MVP, textures.at(0));
 }
 
-
-void Mesh::setNormal(unsigned int index, float i, float j, float k) {
-    assert(index < mNumNormals);
-
-    mNormals[index][0] = i;
-    mNormals[index][1] = j;
-    mNormals[index][2] = k;
-}
-
-
-void Mesh::setVertex(unsigned int index, float x, float y, float z) {
-    assert(index < mNumVertices);
-
-    mVertices[index][0] = x;
-    mVertices[index][1] = y;
-    mVertices[index][2] = z;
-}
-
-
-////////////////////////////////////////////////////////////
-// Private Accessors
-////////////////////////////////////////////////////////////
-
-
-////////////////////////////////////////////////////////////
-// Private Mutators
-////////////////////////////////////////////////////////////
-

src/Render.cpp

@@ -8,6 +8,7 @@
 
 #include <algorithm>
 #include <sstream>
+#include <glm/gtc/matrix_transform.hpp>
 
 #include <stdlib.h>
 #include <math.h>
@@ -64,9 +65,15 @@ void Render::display() {
         glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
     }
 
-    // TODO Setup matrices
+    glm::mat4 view = Camera::getViewMatrix();
+    glm::mat4 projection = glm::perspective(45.0f, // Field of View
+                                            (float)getWindow().getWidth() / (float)getWindow().getHeight(),
+                                            0.1f, // Min Distance
+                                            100000.0f); // Max Distance
 
-    // TODO Render world
+    // Just draw all rooms, as a test
+    for (int i = 0; i < getWorld().sizeRoom(); i++)
+        getWorld().getRoom(i).display(view, projection);
 
     if (mode == RenderMode::Wireframe) {
         glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

src/Room.cpp

@@ -6,6 +6,7 @@
  */
 
 #include <algorithm>
+#include <glm/gtc/matrix_transform.hpp>
 #include <glm/gtx/intersect.hpp>
 
 #include "global.h"
@@ -15,48 +16,17 @@
 #include "Room.h"
 #include "TextureManager.h"
 
-Room::Room(float p[3], unsigned int f, unsigned int x, unsigned int z)
-    : flags(f), numXSectors(x), numZSectors(z) {
-    if (p == nullptr) {
-        pos[0] = 0.0f;
-        pos[1] = 0.0f;
-        pos[2] = 0.0f;
-    } else {
-        pos[0] = p[0];
-        pos[1] = p[0];
-        pos[2] = p[0];
-    }
-}
-
-void Room::setNumXSectors(unsigned int n) {
-    numXSectors = n;
+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);
 }
 
-void Room::setNumZSectors(unsigned int n) {
-    numZSectors = n;
-}
-
-void Room::setPos(float p[3]) {
-    for (int i = 0; i < 3; i++)
-        pos[i] = p[i];
-}
-
-#define EMPTY_VECTOR(x)     \
-while (!x.empty()) {        \
-    delete x[x.size() - 1]; \
-    x.pop_back();           \
-}
-
-Room::~Room() {
-    EMPTY_VECTOR(sprites);
-    EMPTY_VECTOR(models);
-    EMPTY_VECTOR(portals);
-    EMPTY_VECTOR(sectors);
-    EMPTY_VECTOR(lights);
+void Room::prepare() {
+    mesh->prepare();
 }
 
+/*
 void Room::display(bool alpha) {
-    /*
     glPushMatrix();
     //LightingSetup();
 
@@ -80,9 +50,7 @@ void Room::display(bool alpha) {
         }
 
         glLineWidth(1.0);
-    }
 
-    if (Render::getMode() == RenderMode::Wireframe && (!alpha)) {
         bbox.display(true, RED, GREEN);
     }
 
@@ -120,8 +88,8 @@ void Room::display(bool alpha) {
         for (unsigned int i = 0; i < sizeSprites(); i++)
             getSprite(i).display();
     }
-    */
 }
+*/
 
 bool Room::isWall(unsigned long sector) {
     assert(sector < sectors.size());
@@ -183,27 +151,6 @@ int Room::getAdjoiningRoom(float x, float y, float z,
     return -1;
 }
 
-void Room::setFlags(unsigned int f) {
-    flags = f;
-}
-
-unsigned int Room::getFlags() {
-    return flags;
-}
-
-unsigned int Room::getNumXSectors() {
-    return numXSectors;
-}
-
-unsigned int Room::getNumZSectors() {
-    return numZSectors;
-}
-
-void Room::getPos(float p[3]) {
-    for (unsigned int i = 0; i < 3; i++)
-        p[i] = pos[i];
-}
-
 unsigned long Room::sizeAdjacentRooms() {
     return adjacentRooms.size();
 }
@@ -214,7 +161,7 @@ long Room::getAdjacentRoom(unsigned long index) {
 }
 
 void Room::addAdjacentRoom(long r) {
-    adjacentRooms.push_back(r);
+    adjacentRooms.emplace_back(r);
 }
 
 unsigned long Room::sizePortals() {
@@ -227,7 +174,7 @@ Portal& Room::getPortal(unsigned long index) {
 }
 
 void Room::addPortal(Portal* p) {
-    portals.push_back(p);
+    portals.emplace_back(p);
 }
 
 unsigned long Room::sizeSectors() {
@@ -240,7 +187,7 @@ Sector& Room::getSector(unsigned long index) {
 }
 
 void Room::addSector(Sector* s) {
-    sectors.push_back(s);
+    sectors.emplace_back(s);
 }
 
 unsigned long Room::sizeModels() {
@@ -253,7 +200,7 @@ StaticModel& Room::getModel(unsigned long index) {
 }
 
 void Room::addModel(StaticModel* s) {
-    models.push_back(s);
+    models.emplace_back(s);
 }
 
 unsigned long Room::sizeLights() {
@@ -266,7 +213,7 @@ Light& Room::getLight(unsigned long index) {
 }
 
 void Room::addLight(Light* l) {
-    lights.push_back(l);
+    lights.emplace_back(l);
 }
 
 unsigned long Room::sizeSprites() {
@@ -279,10 +226,6 @@ Sprite& Room::getSprite(unsigned long index) {
 }
 
 void Room::addSprite(Sprite* s) {
-    sprites.push_back(s);
-}
-
-BoundingBox& Room::getBoundingBox() {
-    return bbox;
+    sprites.emplace_back(s);
 }
 

src/RoomData.cpp

@@ -10,36 +10,15 @@
 #include "World.h"
 #include "RoomData.h"
 
-BoundingBox::BoundingBox() {
-    a[0] = a[1] = a[2] = 0;
-    b[0] = b[1] = b[2] = 0;
-}
-
-void BoundingBox::getBoundingBox(float box[2][3]) {
-    box[0][0] = a[0];
-    box[1][0] = b[0];
-    box[0][1] = a[1];
-    box[1][1] = b[1];
-    box[0][2] = a[2];
-    box[1][2] = b[2];
-}
-
-void BoundingBox::setBoundingBox(float min[3], float max[3]) {
-    a[0] = min[0];
-    b[0] = max[0];
-    a[1] = min[1];
-    b[1] = max[1];
-    a[2] = min[2];
-    b[2] = max[2];
-}
+BoundingBox::BoundingBox(glm::vec3 min, glm::vec3 max) : a(min), b(max) { }
 
 bool BoundingBox::inBox(float x, float y, float z) {
-    return ((y > a[1]) && (y < b[1]) && inBoxPlane(x, z));
+    return ((y > a.y) && (y < b.y) && inBoxPlane(x, z));
 }
 
 bool BoundingBox::inBoxPlane(float x, float z) {
-    return ((x > a[0]) && (x < b[0])
-            && (z > a[2]) && (z < b[2]));
+    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]) {

src/SkeletalModel.cpp

@@ -21,10 +21,12 @@ BoneTag::BoneTag(int m, float o[3], float r[3], char f) {
 }
 
 void BoneTag::display() {
+    /*
     if (getWorld().sizeMesh() > 0)
         getWorld().getMesh(mesh).drawSolid(); // TODO ?
     else
         getWorld().getStaticMesh(mesh).display();
+    */
 }
 
 void BoneTag::getOffset(float o[3]) {

src/SoundManager.cpp

@@ -19,6 +19,8 @@ void SoundManager::clear() {
     soundMap.clear();
     soundDetails.clear();
     sampleIndices.clear();
+
+    Sound::clear();
 }
 
 int SoundManager::prepareSources() {

src/TextureManager.cpp

@@ -24,40 +24,21 @@
 #include "utils/png.h"
 #endif
 
-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 a[3], float b[3], float c[3], float d[3]) {
     //! \fixme TR Rosetta Stone says this, but looks strange?
-    /*
     if (attribute == 0) {
         // Ignore transparency
         glDisable(GL_BLEND);
     }
-    */
 
     float xmin = 256.0f, xmax = 0.0f;
     float ymin = 256.0f, ymax = 0.0f;
     for (int i = 0; i < 4; i++) {
         if (vertices.at(i)->xCoordinate == 255) {
-            if (vertices.at(i)->xPixel > xmax)
-                xmax = vertices.at(i)->xPixel;
+            xmax = vertices.at(i)->xPixel;
         } else {
-            if (vertices.at(i)->xPixel < xmin)
-                xmin = vertices.at(i)->xPixel;
+            xmin = vertices.at(i)->xPixel;
         }
 
         if (vertices.at(i)->yCoordinate == 255) {
@@ -67,7 +48,6 @@ void TextureTile::displayRectangle(float a[3], float b[3], float c[3], float d[3
         }
     }
 
-    /*
     glBegin(GL_QUADS);
     glTexCoord2f(xmin / 256.0f, ymin / 256.0f);
     glVertex3f(a.x, a.y, a.z);
@@ -78,12 +58,8 @@ void TextureTile::displayRectangle(float a[3], float b[3], float c[3], float d[3
     glTexCoord2f(xmin / 256.0f, ymax / 256.0f);
     glVertex3f(d.x, d.y, d.z);
     glEnd();
-    */
-}
-
-void TextureTile::displayTriangle(float a[3], float b[3], float c[3]) {
-
 }
+*/
 
 // ----------------------------------------------------------------------------
 

src/loader/LoaderTR2.cpp

@@ -131,7 +131,7 @@ void LoaderTR2::loadTextures() {
             assert((xCoordinate == 1) || (xCoordinate == 255) || (xCoordinate == 0));
             assert((yCoordinate == 1) || (yCoordinate == 255) || (yCoordinate == 0));
 
-            t->add(new TextureTileVertex(xCoordinate, xPixel, yCoordinate, yPixel));
+            t->add(TextureTileVertex(xCoordinate, xPixel, yCoordinate, yPixel));
         }
 
         getTextureManager().addTile(t);
@@ -187,72 +187,56 @@ void LoaderTR2::loadRooms() {
         int32_t yBottom = file.read32(); // lowest point == largest y value
         int32_t yTop = file.read32(); // highest point == smallest y value
 
+        glm::vec3 pos(xOffset, 0.0f, zOffset);
+
         // Number of data words (2 bytes) to follow
         uint32_t dataToFollow = file.readU32();
 
-        uint16_t numVertices = file.readU16();
-        std::vector<glm::vec3> vertices;
-        float bbox[2][3] = {
-            { 0.0f, 0.0f, 0.0f },
-            { 0.0f, 0.0f, 0.0f }
+        glm::vec3 bbox[2] = {
+            glm::vec3(0.0f, 0.0f, 0.0f),
+            glm::vec3(0.0f, 0.0f, 0.0f)
         };
-        for (unsigned int v = 0; v < numVertices; v++) {
-            // Vertex coordinates, relative to x/zOffset
-            int32_t x = file.read16() + xOffset;
-            int16_t y = file.read16();
-            int32_t z = file.read16() + zOffset;
-
-            int16_t light1 = file.read16();
-
-            // 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 = file.readU16();
-
-            int16_t light2 = file.read16(); // Almost always equal to light1
-
-            vertices.emplace_back(x, y, z);
 
+        uint16_t numVertices = file.readU16();
+        std::vector<RoomVertexTR2> vertices;
+        for (unsigned int v = 0; v < numVertices; v++) {
+            RoomVertexTR2 vert;
+            vert.x = file.read16();
+            vert.y = file.read16();
+            vert.z = file.read16();
+            vert.light1 = file.read16();
+            vert.attributes = file.readU16();
+            vert.light2 = file.read16();
+            vertices.push_back(vert);
+
+            // Fill bounding box
             if (v == 0) {
                 for (int i = 0; i < 2; i++) {
-                    bbox[i][0] = x;
-                    bbox[i][1] = y;
-                    bbox[i][2] = z;
+                    bbox[i].x = vert.x;
+                    bbox[i].y = vert.y;
+                    bbox[i].z = vert.z;
                 }
             } else {
-                if (x < bbox[0][0])
-                    bbox[0][0] = x;
-                if (x > bbox[1][0])
-                    bbox[1][0] = x;
-
-                if (y < bbox[0][1])
-                    bbox[0][1] = y;
-                if (y > bbox[1][1])
-                    bbox[1][1] = y;
-
-                if (z < bbox[0][2])
-                    bbox[0][2] = z;
-                if (z > bbox[1][2])
-                    bbox[1][2] = z;
+                if (vert.x < bbox[0].x)
+                    bbox[0].x = vert.x;
+                if (vert.x > bbox[1].x)
+                    bbox[1].x = vert.x;
+                if (vert.y < bbox[0].y)
+                    bbox[0].y = vert.y;
+                if (vert.y > bbox[1].y)
+                    bbox[1].y = vert.y;
+                if (vert.z < bbox[0].z)
+                    bbox[0].z = vert.z;
+                if (vert.z > bbox[1].z)
+                    bbox[1].z = vert.z;
             }
         }
 
-        float pos[3] {
-            static_cast<float>(xOffset),
-            0.0f,
-            static_cast<float>(zOffset)
-        };
-        Room* room = new Room(pos);
-
-        bbox[0][0] += pos[0];
-        bbox[1][0] += pos[0];
-        bbox[0][2] += pos[2];
-        bbox[1][2] += pos[2];
-        room->getBoundingBox().setBoundingBox(bbox[0], bbox[1]);
+        bbox[0] += pos;
+        bbox[1] += pos;
 
         uint16_t numRectangles = file.readU16();
+        std::vector<RoomRectangleTR2> rectangles;
         for (unsigned int r = 0; r < numRectangles; r++) {
             // Indices into the vertex list read just before
             uint16_t vertex1 = file.readU16();
@@ -263,12 +247,11 @@ void LoaderTR2::loadRooms() {
             // Index into the object-texture list
             uint16_t texture = file.readU16();
 
-            room->getMesh().addTexturedRectangle(vertices.at(vertex1), vertices.at(vertex2),
-                                                 vertices.at(vertex3), vertices.at(vertex4),
-                                                 texture);
+            rectangles.emplace_back(vertex1, vertex2, vertex3, vertex4, texture);
         }
 
         uint16_t numTriangles = file.readU16();
+        std::vector<RoomTriangleTR2> triangles;
         for (unsigned int t = 0; t < numTriangles; t++) {
             // Indices into the room vertex list
             uint16_t vertex1 = file.readU16();
@@ -278,8 +261,7 @@ void LoaderTR2::loadRooms() {
             // Index into the object-texture list
             uint16_t texture = file.readU16();
 
-            room->getMesh().addTexturedTriangle(vertices.at(vertex1), vertices.at(vertex2),
-                                                vertices.at(vertex3), texture);
+            triangles.emplace_back(vertex1, vertex2, vertex3, texture);
         }
 
         uint16_t numSprites = file.readU16();
@@ -290,8 +272,7 @@ void LoaderTR2::loadRooms() {
             // TODO store sprites somewhere
         }
 
-        glm::mat4 transform = glm::translate(glm::mat4(1.0f), glm::vec3(pos[0], pos[1], pos[2]));
-        room->addAdjacentRoom(i); // Always set room itself as first
+        //room->addAdjacentRoom(i); // Always set room itself as first
 
         uint16_t numPortals = file.readU16();
         for (unsigned int p = 0; p < numPortals; p++) {
@@ -320,57 +301,13 @@ void LoaderTR2::loadRooms() {
             int16_t yCorner4 = file.read16();
             int16_t zCorner4 = file.read16();
 
-            glm::vec4 vertices[4] = {
-                glm::vec4(
-                    static_cast<float>(xCorner1),
-                    static_cast<float>(yCorner1),
-                    static_cast<float>(zCorner1),
-                    1.0f
-                ), glm::vec4(
-                    static_cast<float>(xCorner2),
-                    static_cast<float>(yCorner2),
-                    static_cast<float>(zCorner2),
-                    1.0f
-                ), glm::vec4(
-                    static_cast<float>(xCorner3),
-                    static_cast<float>(yCorner3),
-                    static_cast<float>(zCorner3),
-                    1.0f
-                ), glm::vec4(
-                    static_cast<float>(xCorner4),
-                    static_cast<float>(yCorner4),
-                    static_cast<float>(zCorner4),
-                    0.0f
-                )
-            };
-
-            // Portals have relative coordinates
-            vertices[0] = transform * vertices[0];
-            vertices[1] = transform * vertices[1];
-            vertices[2] = transform * vertices[2];
-            vertices[3] = transform * vertices[3];
-
-            float normals[3] = {
-                static_cast<float>(xNormal),
-                static_cast<float>(yNormal),
-                static_cast<float>(zNormal)
-            };
-
-            glm::vec3 verts[4] = {
-                glm::vec3(vertices[0]),
-                glm::vec3(vertices[1]),
-                glm::vec3(vertices[2]),
-                glm::vec3(vertices[3])
-            };
-
-            room->addPortal(new Portal(verts, normals, adjoiningRoom));
-            room->addAdjacentRoom(adjoiningRoom);
+            // TODO store portals
         }
 
         uint16_t numZSectors = file.readU16();
         uint16_t numXSectors = file.readU16();
-        room->setNumXSectors(numXSectors);
-        room->setNumZSectors(numZSectors);
+        //room->setNumXSectors(numXSectors);
+        //room->setNumZSectors(numZSectors);
         for (unsigned int s = 0; s < (numZSectors * numXSectors); s++) {
             // Sectors are 1024*1024 world coordinates. Floor and Ceiling are
             // signed numbers of 256 units of height.
@@ -393,7 +330,7 @@ void LoaderTR2::loadRooms() {
                 wall = true;
             }
 
-            room->addSector(new Sector(floor * 256.0f, ceiling * 256.0f, wall));
+            //room->addSector(new Sector(floor * 256.0f, ceiling * 256.0f, wall));
         }
 
         int16_t intensity1 = file.read16();
@@ -440,14 +377,18 @@ void LoaderTR2::loadRooms() {
         int16_t alternateRoom = file.read16(); // TODO
 
         uint16_t flags = file.readU16();
-        int roomFlags = 0;
+        unsigned int roomFlags = 0;
         if (flags & 0x0001) {
             roomFlags |= RoomFlagUnderWater;
         }
-        room->setFlags(room->getFlags() | roomFlags);
+
+        BoundingBox* boundingbox = new BoundingBox(bbox[0], bbox[1]);
+        Mesh* mesh = new Mesh(vertices, rectangles, triangles);
+        Room* room = new Room(pos, boundingbox, mesh, roomFlags);
 
         getWorld().addRoom(room);
 
+        // Sanity check
         if ((numPortals == 0) && (numVertices == 0)
             && (numRectangles == 0) && (numTriangles == 0))
             getLog() << "LoaderTR2: Room " << i << " seems invalid: " << numPortals << "p "
@@ -560,7 +501,7 @@ void LoaderTR2::loadMeshes() {
             vertices.emplace_back(x, y, z);
         }
 
-        Mesh* mesh = new Mesh();
+        //Mesh* mesh = new Mesh();
 
         int16_t numNormals = mem.read16();
         if (numNormals > 0) {
@@ -574,7 +515,7 @@ void LoaderTR2::loadMeshes() {
                 int16_t y = mem.read16();
                 int16_t z = mem.read16();
 
-                mesh->addNormal(glm::vec3(x, y, z));
+                //mesh->addNormal(glm::vec3(x, y, z));
             }
         } else if (numNormals < 0) {
             // Internal vertex lighting is used,
@@ -593,9 +534,9 @@ void LoaderTR2::loadMeshes() {
             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);
+            //mesh->addTexturedRectangle(vertices.at(vertex1), vertices.at(vertex2),
+            //                           vertices.at(vertex3), vertices.at(vertex4),
+            //                           texture);
         }
 
         int16_t numTexturedTriangles = mem.read16();
@@ -605,8 +546,8 @@ void LoaderTR2::loadMeshes() {
             uint16_t vertex3 = mem.readU16();
             uint16_t texture = mem.readU16();
 
-            mesh->addTexturedTriangle(vertices.at(vertex1), vertices.at(vertex2),
-                                      vertices.at(vertex3), texture);
+            //mesh->addTexturedTriangle(vertices.at(vertex1), vertices.at(vertex2),
+            //                          vertices.at(vertex3), texture);
         }
 
         int16_t numColoredRectangles = mem.read16();
@@ -623,9 +564,9 @@ void LoaderTR2::loadMeshes() {
                   blue = (palette.at(index) & 0x0000FF00) >> 8;
 
 
-            mesh->addColoredRectangle(vertices.at(vertex1), vertices.at(vertex2),
-                                      vertices.at(vertex3), vertices.at(vertex4),
-                                      red, green, blue);
+            //mesh->addColoredRectangle(vertices.at(vertex1), vertices.at(vertex2),
+            //                          vertices.at(vertex3), vertices.at(vertex4),
+            //                          red, green, blue);
         }
 
         int16_t numColoredTriangles = mem.read16();
@@ -640,11 +581,11 @@ void LoaderTR2::loadMeshes() {
                   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);
+            //mesh->addColoredTriangle(vertices.at(vertex1), vertices.at(vertex2),
+            //                         vertices.at(vertex3), red, green, blue);
         }
 
-        getWorld().addMesh(mesh);
+        //getWorld().addMesh(mesh);
     }
 
     if (numMeshPointers > 0)

src/main.cpp

@@ -7,7 +7,6 @@
 
 #include <iostream>
 #include <memory>
-#include <sstream>
 
 #include "global.h"
 #include "Exception.h"
@@ -204,19 +203,7 @@ void renderFrame() {
     getGame().display();
     getMenu().display();
     UI::display();
-
-    /*
-    if (getRunTime().getShowFPS()) {
-        std::ostringstream s;
-        s << getRunTime().getFPS() << "FPS";
-        getWindow().glEnter2D();
-        Font::drawText(10, getWindow().getHeight() - 25, 0.6f, BLUE, s.str());
-        getWindow().glExit2D();
-    }
-    */
-
     getWindow().swapBuffersGL();
-
     getRunTime().updateFPS();
 }
 

src/system/Window.cpp

@@ -35,6 +35,7 @@ bool Window::getTextInput() {
 
 Shader Window::textShader;
 Shader Window::imguiShader;
+Shader Window::textureShader;
 unsigned int Window::vertexArrayID = 0;
 
 int Window::initializeGL() {
@@ -75,6 +76,14 @@ int Window::initializeGL() {
         return -7;
     imguiShader.addBuffer(3);
 
+    if (textureShader.compile(textureShaderVertex, textureShaderFragment) < 0)
+        return -8;
+    if (textureShader.addUniform("MVP") < 0)
+        return -9;
+    if (textureShader.addUniform("textureSampler") < 0)
+        return -10;
+    textureShader.addBuffer(3);
+
     glEnable(GL_BLEND);
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
@@ -125,6 +134,43 @@ void Window::drawTextGL(std::vector<glm::vec2>& vertices, std::vector<glm::vec2>
     glDisableVertexAttribArray(1);
 }
 
+void Window::drawGL(std::vector<glm::vec3>& vertices, std::vector<glm::vec2>& uvs,
+                    std::vector<unsigned short>& indices, glm::mat4 MVP, unsigned int texture) {
+    assert(vertices.size() == uvs.size());
+    assert((indices.size() % 3) == 0);
+
+    glBindBuffer(GL_ARRAY_BUFFER, textureShader.getBuffer(0));
+    glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(glm::vec3), &vertices[0], GL_STATIC_DRAW);
+
+    glBindBuffer(GL_ARRAY_BUFFER, textureShader.getBuffer(1));
+    glBufferData(GL_ARRAY_BUFFER, uvs.size() * sizeof(glm::vec2), &uvs[0], GL_STATIC_DRAW);
+
+    glBindBuffer(GL_ARRAY_BUFFER, textureShader.getBuffer(2));
+    glBufferData(GL_ARRAY_BUFFER, indices.size() * sizeof(unsigned short), &indices[0], GL_STATIC_DRAW);
+
+    textureShader.use();
+
+    glUniformMatrix4fv(textureShader.getUniform(0), 1, GL_FALSE, &MVP[0][0]);
+
+    getTextureManager().bindTextureId(texture, TextureManager::TextureStorage::GAME, 0);
+    glUniform1i(textureShader.getUniform(1), 0);
+
+    glEnableVertexAttribArray(0);
+    glBindBuffer(GL_ARRAY_BUFFER, textureShader.getBuffer(0));
+    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
+
+    glEnableVertexAttribArray(1);
+    glBindBuffer(GL_ARRAY_BUFFER, textureShader.getBuffer(1));
+    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, nullptr);
+
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, textureShader.getBuffer(2));
+
+    glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_SHORT, nullptr);
+
+    glDisableVertexAttribArray(0);
+    glDisableVertexAttribArray(1);
+}
+
 // ----------------------------------------------------------------------------
 
 Shader::~Shader() {
@@ -318,5 +364,37 @@ void main() {
 }
 )!?!";
 
+// --------------------------------------
+
+const char* Window::textureShaderVertex = R"!?!(
+#version 330 core
+
+layout(location = 0) in vec3 vertexPosition_modelspace;
+layout(location = 1) in vec2 vertexUV;
+
+out vec2 UV;
+
+uniform mat4 MVP;
+
+void main() {
+    gl_Position = MVP * vec4(vertexPosition_modelspace, 1);
+    UV = vertexUV;
+}
+)!?!";
+
+const char* Window::textureShaderFragment = R"!?!(
+#version 330 core
+
+in vec2 UV;
+
+out vec4 color;
+
+uniform sampler2D textureSampler;
+
+void main() {
+    color = texture(textureSampler, UV);
+}
+)!?!";
+
 // *INDENT-ON*