Mesh now RoomMesh, _fixed_ texture bleeding

ChangeLog.md

@@ -2,6 +2,10 @@
 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20141217 ]
+    * Introduced texel-offset in getUV() in an attempt to fix the texture-bleeding
+    * Mesh is now called RoomMesh
+
     [ 20141216 ]
     * Allow navigation with a free-floating Camera
     * Room Meshes are displayed more or less correctly

TODO.md

@@ -2,10 +2,6 @@
 
 ## General
 
-* Move to newer OpenGL (GL ES or 2.1 or 3.x or 4.x?)
-* Don't use C-Style code, try to replace with C++ lib
-* Mesh has 2 different approaches of storing the same data (eg. mColors and mColorArray), but half of ‘em isn’t implemented. Unify this, probably even combining Mesh and StaticMesh...
-* Don’t use float everywhere just because (eg. float colors)
 * Add verbose command line flag for debug output also in release builds
 * Don’t depend on setup: no data or config files should be necessary
 * Be able to change configuration from within OpenRaider
@@ -15,6 +11,7 @@
 * Screenshots are sometimes not written, sometimes distorted?
     * Seems to happen if OpenRaider.ini sets a resolution larger than the window can be
 * When the freeGLUT windowing interface is used, the first pressed button seems to be repeated
+    * Replace freeGLUT with glfw?
 
 ## Cmake
 

include/Mesh.h

@@ -2,37 +2,43 @@
  * \file include/Mesh.h
  * \brief OpenGL Mesh
  *
- * \author Mongoose
- *
- * \todo Unify the parallel systems here, arrays and the allocate/set
+ * \author xythobuz
  */
 
 #ifndef _MESH_H_
 #define _MESH_H_
 
-#include <vector>
-#include <glm/mat4x4.hpp>
+#include <map>
 #include <glm/vec2.hpp>
 #include <glm/vec3.hpp>
 
-#include "loader/LoaderTR2.h"
-
 class Mesh {
-  public:
-    Mesh(const std::vector<RoomVertexTR2>& vertices,
-         const std::vector<RoomRectangleTR2>& rectangles,
-         const std::vector<RoomTriangleTR2>& triangles);
 
-    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;
+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; }
 };
 
+template <typename T>
+bool findSimilarVertex(T& v,
+                       std::map<T, unsigned short> m,
+                       unsigned short& s) {
+    auto it = m.find(v);
+    if (it == m.end())
+        return false;
+    else {
+        s = it->second;
+        return true;
+    }
+}
+
 #endif
 

include/Room.h

@@ -13,9 +13,9 @@
 #include <glm/mat4x4.hpp>
 #include <glm/vec3.hpp>
 
-#include "Mesh.h"
 #include "Sprite.h"
 #include "RoomData.h"
+#include "RoomMesh.h"
 
 enum RoomFlags {
     RoomFlagUnderWater = (1 << 0)
@@ -23,10 +23,10 @@ enum RoomFlags {
 
 class Room {
   public:
-    Room(glm::vec3 _pos, BoundingBox* _bbox, Mesh* _mesh, unsigned int f)
+    Room(glm::vec3 _pos, BoundingBox* _bbox, RoomMesh* _mesh, unsigned int f)
         : pos(_pos), bbox(_bbox), mesh(_mesh), flags(f) { }
 
-    void prepare();
+    void prepare() { mesh->prepare(); }
     void display(glm::mat4 view, glm::mat4 projection);
 
     bool isWall(unsigned long sector);
@@ -37,7 +37,7 @@ class Room {
                          float x2, float y2, float z2);
 
     BoundingBox& getBoundingBox() { return *bbox; }
-    Mesh& getMesh() { return *mesh; }
+    RoomMesh& getMesh() { return *mesh; }
 
     void setNumXSectors(unsigned int n) { numXSectors = n; }
     unsigned int getNumXSectors() { return numXSectors; }
@@ -74,7 +74,7 @@ class Room {
   private:
     glm::vec3 pos;
     std::unique_ptr<BoundingBox> bbox;
-    std::unique_ptr<Mesh> mesh;
+    std::unique_ptr<RoomMesh> mesh;
 
     unsigned int flags;
     unsigned int numXSectors;

include/RoomMesh.h

@@ -0,0 +1,55 @@
+/*!
+ * \file include/RoomMesh.h
+ * \brief World Room Mesh
+ *
+ * \author xythobuz
+ */
+
+#ifndef _ROOM_MESH_H_
+#define _ROOM_MESH_H_
+
+#include <cstdint>
+#include <vector>
+#include <glm/mat4x4.hpp>
+#include <glm/vec2.hpp>
+#include <glm/vec3.hpp>
+
+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 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) { }
+};
+
+class RoomMesh {
+  public:
+    RoomMesh(const std::vector<RoomVertexTR2>& vertices,
+         const std::vector<IndexedRectangle>& rectangles,
+         const std::vector<IndexedRectangle>& triangles);
+
+    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;
+};
+
+#endif
+

include/TextureManager.h

@@ -32,8 +32,7 @@ class TextureTile {
     void add(TextureTileVertex t) { vertices.push_back(t); }
 
     unsigned int getTexture() { return texture; }
-    glm::vec2 getUV(unsigned int i) { return glm::vec2(vertices.at(i).xPixel / 255.0f,
-                                                       vertices.at(i).yPixel / 255.0f); }
+    glm::vec2 getUV(unsigned int i);
 
   private:
     unsigned int attribute;

include/loader/LoaderTR2.h

@@ -45,33 +45,5 @@ 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
 

src/CMakeLists.txt

@@ -77,6 +77,7 @@ set (SRCS ${SRCS} "Mesh.cpp" "../include/Mesh.h")
 set (SRCS ${SRCS} "Render.cpp" "../include/Render.h")
 set (SRCS ${SRCS} "Room.cpp" "../include/Room.h")
 set (SRCS ${SRCS} "RoomData.cpp" "../include/RoomData.h")
+set (SRCS ${SRCS} "RoomMesh.cpp" "../include/RoomMesh.h")
 set (SRCS ${SRCS} "RunTime.cpp" "../include/RunTime.h")
 set (SRCS ${SRCS} "Script.cpp" "../include/Script.h")
 set (SRCS ${SRCS} "SkeletalModel.cpp" "../include/SkeletalModel.h")

src/Mesh.cpp

@@ -2,118 +2,6 @@
  * \file src/Mesh.cpp
  * \brief OpenGL Mesh
  *
- * \author Mongoose
+ * \author xythobuz
  */
 
-#include <map>
-#include <stdlib.h>
-
-#include "global.h"
-#include "TextureManager.h"
-#include "system/Window.h"
-#include "Mesh.h"
-
-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);
-            }
-        }
-
-        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;
-    }
-
-    indices = ind;
-    vertices = vert;
-    textures = tex;
-
-    assert((indices.size() % 3) == 0);
-}
-
-void Mesh::display(glm::mat4 model, glm::mat4 view, glm::mat4 projection) {
-    glm::mat4 MVP = projection * view * model;
-
-    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));
-        }
-    }
-}
-

src/Room.cpp

@@ -21,76 +21,6 @@ void Room::display(glm::mat4 view, glm::mat4 projection) {
     mesh->display(model, view, projection);
 }
 
-void Room::prepare() {
-    mesh->prepare();
-}
-
-/*
-void Room::display(bool alpha) {
-    glPushMatrix();
-    //LightingSetup();
-
-    getTextureManager().bindTextureId(TEXTURE_WHITE, TextureManager::TextureStorage::SYSTEM);
-
-    if ((!alpha) && Render::getMode() == RenderMode::Wireframe) {
-        glLineWidth(2.0);
-        glColor3ubv(RED);
-
-        for (unsigned int i = 0; i < sizePortals(); i++) {
-            Portal& portal = getPortal(i);
-            float vertices[4][3];
-            portal.getVertices(vertices);
-
-            glBegin(GL_LINE_LOOP);
-            glVertex3fv(vertices[0]);
-            glVertex3fv(vertices[1]);
-            glVertex3fv(vertices[2]);
-            glVertex3fv(vertices[3]);
-            glEnd();
-        }
-
-        glLineWidth(1.0);
-
-        bbox.display(true, RED, GREEN);
-    }
-
-    glTranslated(pos[0], pos[1], pos[2]);
-
-    // Reset since GL_MODULATE used, reset to WHITE
-    glColor3ubv(WHITE);
-
-    switch (Render::getMode()) {
-        case RenderMode::Wireframe:
-            mesh.mMode = Mesh::MeshModeWireframe;
-            break;
-        case RenderMode::Solid:
-            mesh.mMode = Mesh::MeshModeSolid;
-            break;
-        default:
-            mesh.mMode = Mesh::MeshModeTexture;
-            break;
-    }
-
-    if (alpha)
-        mesh.drawAlpha();
-    else
-        mesh.drawSolid();
-
-    glPopMatrix();
-
-    // Draw other room meshes and sprites
-    if (alpha || (Render::getMode() == RenderMode::Wireframe)
-        || (Render::getMode() == RenderMode::Solid)) {
-        //sortModels(); // TODO
-        for (unsigned int i = 0; i < sizeModels(); i++)
-            getModel(i).display();
-
-        for (unsigned int i = 0; i < sizeSprites(); i++)
-            getSprite(i).display();
-    }
-}
-*/
-
 bool Room::isWall(unsigned long sector) {
     assert(sector < sectors.size());
 
@@ -151,6 +81,8 @@ int Room::getAdjoiningRoom(float x, float y, float z,
     return -1;
 }
 
+// --------------------------------------
+
 unsigned long Room::sizeAdjacentRooms() {
     return adjacentRooms.size();
 }

src/RoomMesh.cpp

@@ -0,0 +1,96 @@
+/*!
+ * \file src/RoomMesh.cpp
+ * \brief World Room Mesh
+ *
+ * \author xythobuz
+ */
+
+#include "global.h"
+#include "Mesh.h"
+#include "TextureManager.h"
+#include "system/Window.h"
+#include "RoomMesh.h"
+
+RoomMesh::RoomMesh(const std::vector<RoomVertexTR2>& vert,
+     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));
+        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);
+    }
+}
+
+void RoomMesh::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);
+
+    indices = ind;
+    vertices = vert;
+    textures = tex;
+}
+
+void RoomMesh::display(glm::mat4 model, glm::mat4 view, glm::mat4 projection) {
+    glm::mat4 MVP = projection * view * model;
+
+    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));
+        }
+    }
+}
+

src/TextureManager.cpp

@@ -24,42 +24,27 @@
 #include "utils/png.h"
 #endif
 
-/*
-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);
+glm::vec2 TextureTile::getUV(unsigned int i) {
+    glm::vec2 uv(vertices.at(i).xPixel,
+                 vertices.at(i).yPixel);
+
+    /*! \fixme
+     * This is my somewhat hacky approach to fixing
+     * the bad texture-bleeding problems everywhere.
+     * That's better, but makes the seams between
+     * each sector much more visible!
+     */
+
+    if (vertices.at(i).xCoordinate == 1) {
+        uv.x += 0.375f;
     }
 
-    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) {
-            xmax = vertices.at(i)->xPixel;
-        } else {
-            xmin = vertices.at(i)->xPixel;
-        }
-
-        if (vertices.at(i)->yCoordinate == 255) {
-            ymax = vertices.at(i)->yPixel;
-        } else {
-            ymin = vertices.at(i)->yPixel;
-        }
+    if (vertices.at(i).yCoordinate == 1) {
+        uv.y += 0.375f;
     }
 
-    glBegin(GL_QUADS);
-    glTexCoord2f(xmin / 256.0f, ymin / 256.0f);
-    glVertex3f(a.x, a.y, a.z);
-    glTexCoord2f(xmax / 256.0f, ymin / 256.0f);
-    glVertex3f(b.x, b.y, b.z);
-    glTexCoord2f(xmax / 256.0f, ymax / 256.0f);
-    glVertex3f(c.x, c.y, c.z);
-    glTexCoord2f(xmin / 256.0f, ymax / 256.0f);
-    glVertex3f(d.x, d.y, d.z);
-    glEnd();
+    return uv / 256.0f;
 }
-*/
 
 // ----------------------------------------------------------------------------
 

src/loader/LoaderTR2.cpp

@@ -12,7 +12,6 @@
 #include "global.h"
 #include "Game.h"
 #include "Log.h"
-#include "Mesh.h"
 #include "Room.h"
 #include "SoundManager.h"
 #include "TextureManager.h"
@@ -236,7 +235,7 @@ void LoaderTR2::loadRooms() {
         bbox[1] += pos;
 
         uint16_t numRectangles = file.readU16();
-        std::vector<RoomRectangleTR2> rectangles;
+        std::vector<IndexedRectangle> rectangles;
         for (unsigned int r = 0; r < numRectangles; r++) {
             // Indices into the vertex list read just before
             uint16_t vertex1 = file.readU16();
@@ -247,11 +246,11 @@ void LoaderTR2::loadRooms() {
             // Index into the object-texture list
             uint16_t texture = file.readU16();
 
-            rectangles.emplace_back(vertex1, vertex2, vertex3, vertex4, texture);
+            rectangles.emplace_back(texture, vertex1, vertex2, vertex3, vertex4);
         }
 
         uint16_t numTriangles = file.readU16();
-        std::vector<RoomTriangleTR2> triangles;
+        std::vector<IndexedRectangle> triangles;
         for (unsigned int t = 0; t < numTriangles; t++) {
             // Indices into the room vertex list
             uint16_t vertex1 = file.readU16();
@@ -261,7 +260,7 @@ void LoaderTR2::loadRooms() {
             // Index into the object-texture list
             uint16_t texture = file.readU16();
 
-            triangles.emplace_back(vertex1, vertex2, vertex3, texture);
+            triangles.emplace_back(texture, vertex1, vertex2, vertex3);
         }
 
         uint16_t numSprites = file.readU16();
@@ -331,6 +330,7 @@ void LoaderTR2::loadRooms() {
             }
 
             //room->addSector(new Sector(floor * 256.0f, ceiling * 256.0f, wall));
+            // TODO store sectors
         }
 
         int16_t intensity1 = file.read16();
@@ -383,7 +383,7 @@ void LoaderTR2::loadRooms() {
         }
 
         BoundingBox* boundingbox = new BoundingBox(bbox[0], bbox[1]);
-        Mesh* mesh = new Mesh(vertices, rectangles, triangles);
+        RoomMesh* mesh = new RoomMesh(vertices, rectangles, triangles);
         Room* room = new Room(pos, boundingbox, mesh, roomFlags);
 
         getWorld().addRoom(room);