World static, more debug infos, portal rendering.

ChangeLog.md

 
 ## OpenRaider (0.1.4) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20150404 ]
+    * World is now static
+    * Can display debug informations about Rooms and StaticMeshes
+    * Can now render portal outlines
+    * Building rendering list now also based on portal visibility
+
     [ 20150330 ]
     * Removed custom Font support
     * Some GL performance improvements

include/Room.h

     unsigned long sizePortals() { return portals.size(); }
     Portal& getPortal(unsigned long index) { return *portals.at(index); }
 
+    void displayUI();
+
     static void setShowBoundingBox(bool s) { showBoundingBox = s; }
     static bool getShowBoundingBox() { return showBoundingBox; }
 

include/RoomData.h

   public:
     StaticModel(glm::vec3 pos, float angle, int i);
     void display(glm::mat4 VP);
+    void displayUI();
 
   private:
     int id;
 class Portal {
   public:
     Portal(int adj, glm::vec3 n, glm::vec3 v1, glm::vec3 v2, glm::vec3 v3,
-           glm::vec3 v4) : adjoiningRoom(adj), normal(n) {
+           glm::vec3 v4) : adjoiningRoom(adj), normal(n), bbox(v1, v3) {
         vert[0] = v1; vert[1] = v2;
         vert[2] = v3; vert[3] = v4;
     }
+
     int getAdjoiningRoom() { return adjoiningRoom; }
     glm::vec3 getNormal() { return normal; }
+    BoundingBox getBoundingBox() { return bbox; }
+
+    void display(glm::mat4 VP);
+    void displayUI();
 
     glm::vec3 getVertex(int i) {
         orAssertGreaterThanEqual(i, 0);
         return vert[i];
     }
 
+    static void setShowBoundingBox(bool s) { showBoundingBox = s; }
+    static bool getShowBoundingBox() { return showBoundingBox; }
+
   private:
     int adjoiningRoom;
     glm::vec3 normal;
     glm::vec3 vert[4];
+    BoundingBox bbox;
+
+    static bool showBoundingBox;
 };
 
 // --------------------------------------

include/StaticMesh.h

     StaticMesh(int i, int m, BoundingBox* b1, BoundingBox* b2)
         : id(i), mesh(m), bbox1(b1), bbox2(b2) { }
     void display(glm::mat4 MVP);
+    void displayUI();
 
     int getID() { return id; }
 

include/World.h

  */
 class World {
   public:
+    static void destroy();
 
-    /*!
-     * \brief Deconstructs an object of World
-     */
-    ~World();
+    static void addRoom(Room* room);
+    static unsigned long sizeRoom();
+    static Room& getRoom(unsigned long index);
 
-    /*!
-     * \brief Clears all data in world
-     */
-    void destroy();
+    static void addSprite(Sprite* sprite);
+    static unsigned long sizeSprite();
+    static Sprite& getSprite(unsigned long index);
 
-    void addRoom(Room* room);
-    unsigned long sizeRoom();
-    Room& getRoom(unsigned long index);
+    static void addSpriteSequence(SpriteSequence* sprite);
+    static unsigned long sizeSpriteSequence();
+    static SpriteSequence& getSpriteSequence(unsigned long index);
 
-    void addSprite(Sprite* sprite);
-    unsigned long sizeSprite();
-    Sprite& getSprite(unsigned long index);
+    static void addEntity(Entity* entity);
+    static unsigned long sizeEntity();
+    static Entity& getEntity(unsigned long index);
 
-    void addSpriteSequence(SpriteSequence* sprite);
-    unsigned long sizeSpriteSequence();
-    SpriteSequence& getSpriteSequence(unsigned long index);
+    static void addSkeletalModel(SkeletalModel* model);
+    static unsigned long sizeSkeletalModel();
+    static SkeletalModel& getSkeletalModel(unsigned long index);
 
-    void addEntity(Entity* entity);
-    unsigned long sizeEntity();
-    Entity& getEntity(unsigned long index);
+    static void addStaticMesh(StaticMesh* model);
+    static unsigned long sizeStaticMesh();
+    static StaticMesh& getStaticMesh(unsigned long index);
 
-    void addSkeletalModel(SkeletalModel* model);
-    unsigned long sizeSkeletalModel();
-    SkeletalModel& getSkeletalModel(unsigned long index);
+    static void addMesh(Mesh* mesh);
+    static unsigned long sizeMesh();
+    static Mesh& getMesh(unsigned long index);
 
-    void addStaticMesh(StaticMesh* model);
-    unsigned long sizeStaticMesh();
-    StaticMesh& getStaticMesh(unsigned long index);
-
-    void addMesh(Mesh* mesh);
-    unsigned long sizeMesh();
-    Mesh& getMesh(unsigned long index);
+    static void displayUI();
 
   private:
-    std::vector<std::unique_ptr<Room>> mRooms;
-    std::vector<std::unique_ptr<Sprite>> mSprites;
-    std::vector<std::unique_ptr<SpriteSequence>> mSpriteSequences;
-    std::vector<std::unique_ptr<Entity>> mEntities;
-    std::vector<std::unique_ptr<SkeletalModel>> mModels;
-    std::vector<std::unique_ptr<StaticMesh>> mStaticMeshes;
-    std::vector<std::unique_ptr<Mesh>> mMeshes;
+    static std::vector<std::unique_ptr<Room>> rooms;
+    static std::vector<std::unique_ptr<Sprite>> sprites;
+    static std::vector<std::unique_ptr<SpriteSequence>> spriteSequences;
+    static std::vector<std::unique_ptr<Entity>> entities;
+    static std::vector<std::unique_ptr<SkeletalModel>> models;
+    static std::vector<std::unique_ptr<StaticMesh>> staticMeshes;
+    static std::vector<std::unique_ptr<Mesh>> meshes;
 };
 
-World& getWorld();
-
 #endif
+

src/Entity.cpp

          * be displayed wrong (eg. 'bad guy' becomes 'clothes' in tr2/boat)...
          */
 
-        for (int i = 0; (i < getWorld().sizeSkeletalModel()) && (cache == -1); i++) {
-            auto& s = getWorld().getSkeletalModel(i);
+        for (int i = 0; (i < World::sizeSkeletalModel()) && (cache == -1); i++) {
+            auto& s = World::getSkeletalModel(i);
             if (s.getID() == id) {
                 cacheType = CACHE_MODEL;
                 cache = i;
             }
         }
 
-        for (int i = 0; (i < getWorld().sizeStaticMesh()) && (cache == -1); i++) {
-            auto& s = getWorld().getStaticMesh(i);
+        for (int i = 0; (i < World::sizeStaticMesh()) && (cache == -1); i++) {
+            auto& s = World::getStaticMesh(i);
             if (s.getID() == id) {
                 cacheType = CACHE_MESH;
                 cache = i;
             }
         }
 
-        for (int i = 0; i < getWorld().sizeSpriteSequence(); i++) {
-            auto& s = getWorld().getSpriteSequence(i);
+        for (int i = 0; i < World::sizeSpriteSequence(); i++) {
+            auto& s = World::getSpriteSequence(i);
             if (s.getID() == id) {
                 cacheType = CACHE_SPRITE;
                 cache = i;
 
     if (cacheType == CACHE_SPRITE) {
         if (showEntitySprites)
-            getWorld().getSpriteSequence(cache).display(MVP, sprite);
+            World::getSpriteSequence(cache).display(MVP, sprite);
     } else if (cacheType == CACHE_MESH) {
         if (showEntityMeshes)
-            getWorld().getStaticMesh(cache).display(MVP);
+            World::getStaticMesh(cache).display(MVP);
     } else if (cacheType == CACHE_MODEL) {
         if (showEntityModels)
-            getWorld().getSkeletalModel(cache).display(MVP, animation, frame);
+            World::getSkeletalModel(cache).display(MVP, animation, frame);
     }
 }
 

src/Game.cpp

     Render::clearRoomList();
     SoundManager::clear();
     TextureManager::clear();
-    getWorld().destroy();
+    World::destroy();
 }
 
 int Game::loadLevel(std::string level) {
             return -2;
         }
 
-        for (int i = 0; i < getWorld().sizeMesh(); i++) {
-            getWorld().getMesh(i).prepare();
+        for (int i = 0; i < World::sizeMesh(); i++) {
+            World::getMesh(i).prepare();
         }
 
-        for (int i = 0; i < getWorld().sizeRoom(); i++) {
-            getWorld().getRoom(i).prepare();
+        for (int i = 0; i < World::sizeRoom(); i++) {
+            World::getRoom(i).prepare();
         }
 
         SoundManager::prepareSources();
 
 Entity& Game::getLara() {
     orAssertGreaterThanEqual(mLara, 0);
-    orAssertLessThan(mLara, getWorld().sizeEntity());
-    return getWorld().getEntity(mLara);
+    orAssertLessThan(mLara, World::sizeEntity());
+    return World::getEntity(mLara);
 }
 
 void Game::setLara(long lara) {
     orAssertGreaterThanEqual(lara, 0);
-    orAssertLessThan(lara, getWorld().sizeEntity());
+    orAssertLessThan(lara, World::sizeEntity());
     mLara = lara;
 }
 

src/Render.cpp

     for (int r = roomList.size() - 1; r >= 0; r--) {
         roomList.at(r)->display(VP);
 
-        for (int i = 0; i < getWorld().sizeEntity(); i++) {
-            auto& e = getWorld().getEntity(i);
+        for (int i = 0; i < World::sizeEntity(); i++) {
+            auto& e = World::getEntity(i);
             if (roomList.at(r)->getIndex() == e.getRoom()) {
                 e.display(VP);
             }
 void Render::buildRoomList(int room, int budget) {
     if (room < -1) {
         // Check if the camera currently is in a room...
-        for (int i = 0; i < getWorld().sizeRoom(); i++) {
-            if (getWorld().getRoom(i).getBoundingBox().inBox(Camera::getPosition())) {
+        for (int i = 0; i < World::sizeRoom(); i++) {
+            if (World::getRoom(i).getBoundingBox().inBox(Camera::getPosition())) {
                 buildRoomList(i, budget);
                 return;
             }
         buildRoomList(-1, budget);
     } else if (room == -1) {
         // Check visibility for all rooms!
-        for (int i = 0; i < getWorld().sizeRoom(); i++) {
-            if (Camera::boxInFrustum(getWorld().getRoom(i).getBoundingBox())) {
-                roomList.push_back(&getWorld().getRoom(i));
+        for (int i = 0; i < World::sizeRoom(); i++) {
+            if (Camera::boxInFrustum(World::getRoom(i).getBoundingBox())) {
+                roomList.push_back(&World::getRoom(i));
             }
         }
     } else {
         // Check visibility of room and connected rooms, recursively
-        if (Camera::boxInFrustum(getWorld().getRoom(room).getBoundingBox())) {
-            roomList.push_back(&getWorld().getRoom(room));
-            for (int i = 0; i < getWorld().getRoom(room).sizePortals(); i++) {
-                int r = getWorld().getRoom(room).getPortal(i).getAdjoiningRoom();
+        if (Camera::boxInFrustum(World::getRoom(room).getBoundingBox())) {
+            roomList.push_back(&World::getRoom(room));
+            for (int i = 0; i < World::getRoom(room).sizePortals(); i++) {
+                auto& portal = World::getRoom(room).getPortal(i);
+
+                // Check if portal is visible / can be seen through
+                bool visible = Camera::boxInFrustum(portal.getBoundingBox());
+                if (!visible) {
+                    continue;
+                }
+
+                // Check if already in list...
                 bool found = false;
                 for (int n = 0; n < roomList.size(); n++) {
-                    if (roomList.at(n) == &getWorld().getRoom(r)) {
+                    if (roomList.at(n) == &World::getRoom(portal.getAdjoiningRoom())) {
                         found = true;
                         break;
                     }
                 }
+
+                // ...only render if not
                 if (!found) {
                     if (budget > 0) {
-                        buildRoomList(r, --budget);
+                        buildRoomList(portal.getAdjoiningRoom(), --budget);
                     }
                 }
             }
         if (ImGui::Checkbox("Overlay", &showOverlay)) {
             Camera::setShowOverlay(showOverlay);
         }
-        if (ImGui::Button("Reset Room ID")) {
-            Camera::setRoom(-1);
+        glm::vec3 camPos = Camera::getPosition();
+        if (ImGui::SliderFloat3("Position", &camPos.x, -100000, 100000)) {
+            Camera::setPosition(camPos);
         }
 
         ImGui::Separator();
         ImGui::Text("Bounding Boxes:");
         bool showBoundingBox = Room::getShowBoundingBox();
-        if (ImGui::Checkbox("Room##bbox", &showBoundingBox)) {
+        if (ImGui::Checkbox("Rooms##bbox", &showBoundingBox)) {
             Room::setShowBoundingBox(showBoundingBox);
         }
         ImGui::SameLine();
         bool showBoundingBox2 = StaticMesh::getShowBoundingBox();
-        if (ImGui::Checkbox("StaticMesh##bbox", &showBoundingBox2)) {
+        if (ImGui::Checkbox("StaticMeshes##bbox", &showBoundingBox2)) {
             StaticMesh::setShowBoundingBox(showBoundingBox2);
         }
+        ImGui::SameLine();
+        bool showBoundingBox3 = Portal::getShowBoundingBox();
+        if (ImGui::Checkbox("Portals##bbox", &showBoundingBox3)) {
+            Portal::setShowBoundingBox(showBoundingBox3);
+        }
 
         ImGui::Separator();
         ImGui::Text("Renderable Objects:");

src/Room.cpp

 #include "Log.h"
 #include "Room.h"
 
+#include "imgui/imgui.h"
+
 #include <glm/gtc/matrix_transform.hpp>
 #include <glm/gtx/intersect.hpp>
 
 }
 
 void Room::display(glm::mat4 VP) {
-    glm::mat4 MVP = VP * model;
-
-    if (showRoomGeometry)
-        mesh->display(MVP);
+    if (showRoomGeometry) {
+        mesh->display(VP * model);
+    }
 
     if (showRoomModels) {
         for (auto& m : models) {
         }
     }
 
-    if (showBoundingBox)
+    if (showBoundingBox) {
         bbox->display(VP, glm::vec3(0.0f, 1.0f, 0.0f), glm::vec3(1.0f, 0.0f, 1.0f));
+    }
+
+    if (Portal::getShowBoundingBox()) {
+        for (auto& p : portals) {
+            p->display(VP);
+        }
+    }
 }
 
 bool Room::isWall(unsigned long sector) {
     return -1;
 }
 
+void Room::displayUI() {
+    ImGui::PushID(roomIndex);
+    ImGui::Text("%03d", roomIndex);
+    ImGui::NextColumn();
+    ImGui::Text("%03d", alternateRoom);
+    ImGui::NextColumn();
+    ImGui::Text("0x%04X", flags);
+    ImGui::NextColumn();
+    if (models.size() > 0) {
+        if (ImGui::TreeNode("...##model")) {
+            for (auto& m : models) {
+                m->displayUI();
+            }
+            ImGui::TreePop();
+        }
+    } else {
+        ImGui::Text("None");
+    }
+    ImGui::NextColumn();
+    if (portals.size() > 0) {
+        if (ImGui::TreeNode("...##portal")) {
+            for (auto& p : portals) {
+                p->displayUI();
+            }
+            ImGui::TreePop();
+        }
+    } else {
+        ImGui::Text("None");
+    }
+    ImGui::NextColumn();
+    ImGui::PopID();
+}
+

src/RoomData.cpp

 #include "system/Shader.h"
 #include "RoomData.h"
 
+#include "imgui/imgui.h"
+
 #include <glbinding/gl/gl33.h>
 #include <glm/gtc/matrix_transform.hpp>
 
 
 void StaticModel::display(glm::mat4 VP) {
     if (cache < 0) {
-        for (int i = 0; i < getWorld().sizeStaticMesh(); i++) {
-            if (getWorld().getStaticMesh(i).getID() == id) {
+        for (int i = 0; i < World::sizeStaticMesh(); i++) {
+            if (World::getStaticMesh(i).getID() == id) {
                 cache = i;
             }
         }
         orAssertGreaterThanEqual(cache, 0);
     }
 
-    getWorld().getStaticMesh(cache).display(VP * model);
+    World::getStaticMesh(cache).display(VP * model);
+}
+
+void StaticModel::displayUI() {
+    ImGui::Text("ID %d; No. %d", id, cache);
 }
 
 // ----------------------------------------------------------------------------
                                    0.0f));
     glm::mat4 model = translate * rotate;
 
-    getWorld().getSprite(sprite).display(VP * model);
+    World::getSprite(sprite).display(VP * model);
+}
+
+// ----------------------------------------------------------------------------
+
+bool Portal::showBoundingBox = false;
+
+void Portal::display(glm::mat4 VP) {
+    if (showBoundingBox) {
+        bbox.display(VP, glm::vec3(1.0f, 0.0f, 0.0f), glm::vec3(0.0f, 0.0f, 1.0f));
+    }
+}
+
+void Portal::displayUI() {
+    ImGui::Text("To %03d", adjoiningRoom);
 }
 
 // ----------------------------------------------------------------------------

src/SkeletalModel.cpp

 #include <glm/gtc/matrix_transform.hpp>
 
 void BoneTag::display(glm::mat4 MVP, ShaderTexture* shaderTexture) {
-    getWorld().getMesh(mesh).display(MVP, shaderTexture);
+    World::getMesh(mesh).display(MVP, shaderTexture);
 }
 
 // ----------------------------------------------------------------------------

src/Sprite.cpp

 void SpriteSequence::display(glm::mat4 MVP, int index) {
     orAssertGreaterThanEqual(index, 0);
     orAssertLessThan(index, length);
-    getWorld().getSprite(start + index).display(MVP);
+    World::getSprite(start + index).display(MVP);
 }
 

src/StaticMesh.cpp

 #include "World.h"
 #include "StaticMesh.h"
 
+#include "imgui/imgui.h"
+
 bool StaticMesh::showBoundingBox = false;
 
 void StaticMesh::display(glm::mat4 MVP) {
-    getWorld().getMesh(mesh).display(MVP);
+    World::getMesh(mesh).display(MVP);
 
     if (showBoundingBox) {
         bbox1->display(MVP, glm::vec3(1.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f));
     }
 }
 
+void StaticMesh::displayUI() {
+    ImGui::Text("%03d", id);
+    ImGui::NextColumn();
+    ImGui::Text("%03d // and two bboxes", mesh);
+    ImGui::NextColumn();
+}
+

src/TextureManager.cpp

     }
 
     if (ImGui::CollapsingHeader("Sprite Sequence Viewer")) {
-        if (getWorld().sizeSprite() <= 0) {
+        if (World::sizeSprite() <= 0) {
             ImGui::Text("Please load a level containing sprites!");
         } else {
             static int index = 0;
             static int sprite = 0;
-            if (ImGui::SliderInt("##spriteslide", &index, 0, getWorld().sizeSpriteSequence() - 1)) {
+            if (ImGui::SliderInt("##spriteslide", &index, 0, World::sizeSpriteSequence() - 1)) {
                 sprite = 0;
             }
             ImGui::SameLine();
             if (ImGui::Button("+##spriteplus", ImVec2(0, 0), true)) {
-                if (index < (getWorld().sizeSpriteSequence() - 1))
+                if (index < (World::sizeSpriteSequence() - 1))
                     index++;
                 else
                     index = 0;
                 if (index > 0)
                     index--;
                 else
-                    index = getWorld().sizeSpriteSequence() - 1;
+                    index = World::sizeSpriteSequence() - 1;
                 sprite = 0;
             }
 
-            if (index >= getWorld().sizeSpriteSequence()) {
+            if (index >= World::sizeSpriteSequence()) {
                 index = 0;
                 sprite = 0;
             }
 
-            if (sprite >= getWorld().getSpriteSequence(index).size()) {
+            if (sprite >= World::getSpriteSequence(index).size()) {
                 sprite = 0;
             }
 
             ImGui::SameLine();
-            ImGui::Text("Sprite %d/%d", sprite + 1, getWorld().getSpriteSequence(index).size());
+            ImGui::Text("Sprite %d/%d", sprite + 1, World::getSpriteSequence(index).size());
 
-            auto& s = getWorld().getSprite(getWorld().getSpriteSequence(index).getStart() + sprite);
+            auto& s = World::getSprite(World::getSpriteSequence(index).getStart() + sprite);
             auto bm = getBufferManager(s.getTexture(), TextureStorage::GAME);
             ImVec2 size(ImGui::GetColumnWidth() * 2 / 3, ImGui::GetColumnWidth() * 2 / 3);
             auto uv = s.getUVs();
                 fr--;
             } else {
                 fr = RunTime::getFPS() / 10;
-                if (sprite < (getWorld().getSpriteSequence(index).size() - 1))
+                if (sprite < (World::getSpriteSequence(index).size() - 1))
                     sprite++;
                 else
                     sprite = 0;

src/UI.cpp

         RunTime::display();
         TextureManager::display();
         SoundManager::display();
+        World::displayUI();
 
         if (ImGui::CollapsingHeader("Library Versions")) {
             ImGui::TextWrapped("%s", VERSION);
         if (ImGui::CollapsingHeader("ShaderTexture Test")) {
             static ShaderTexture* st = nullptr;
             static int index = 0;
-            ImGui::SliderInt("SkeletalModel", &index, 0, getWorld().sizeSkeletalModel() - 1);
+            ImGui::SliderInt("SkeletalModel", &index, 0, World::sizeSkeletalModel() - 1);
 
             static glm::mat4 MVP(1.0f);
             static bool dirty = true, redraw = false;
                 dirty = false;
             }
 
-            if ((index >= 0) && (index < getWorld().sizeSkeletalModel())) {
-                auto& sm = getWorld().getSkeletalModel(index);
+            if ((index >= 0) && (index < World::sizeSkeletalModel())) {
+                auto& sm = World::getSkeletalModel(index);
                 if ((sm.size() > 0) && (sm.get(0).size() > 0)) {
                     if (ImGui::Button("(Re)Create ShaderTexture...")) {
                         if (st != nullptr) {

src/World.cpp

 #include "global.h"
 #include "World.h"
 
-World::~World() {
-    destroy();
-}
+#include "imgui/imgui.h"
+
+std::vector<std::unique_ptr<Room>> World::rooms;
+std::vector<std::unique_ptr<Sprite>> World::sprites;
+std::vector<std::unique_ptr<SpriteSequence>> World::spriteSequences;
+std::vector<std::unique_ptr<Entity>> World::entities;
+std::vector<std::unique_ptr<SkeletalModel>> World::models;
+std::vector<std::unique_ptr<StaticMesh>> World::staticMeshes;
+std::vector<std::unique_ptr<Mesh>> World::meshes;
 
 void World::destroy() {
-    mRooms.clear();
-    mSprites.clear();
-    mSpriteSequences.clear();
-    mEntities.clear();
-    mModels.clear();
-    mStaticMeshes.clear();
-    mMeshes.clear();
+    rooms.clear();
+    sprites.clear();
+    spriteSequences.clear();
+    entities.clear();
+    models.clear();
+    staticMeshes.clear();
+    meshes.clear();
 }
 
 void World::addRoom(Room* room) {
-    mRooms.emplace_back(std::unique_ptr<Room>(room));
+    rooms.emplace_back(std::unique_ptr<Room>(room));
 }
 
 unsigned long World::sizeRoom() {
-    return mRooms.size();
+    return rooms.size();
 }
 
 Room& World::getRoom(unsigned long index) {
-    orAssertLessThan(index, mRooms.size());
-    return *mRooms.at(index);
+    orAssertLessThan(index, rooms.size());
+    return *rooms.at(index);
 }
 
 void World::addSprite(Sprite* sprite) {
-    mSprites.emplace_back(std::unique_ptr<Sprite>(sprite));
+    sprites.emplace_back(std::unique_ptr<Sprite>(sprite));
 }
 
 unsigned long World::sizeSprite() {
-    return mSprites.size();
+    return sprites.size();
 }
 
 Sprite& World::getSprite(unsigned long index) {
-    orAssertLessThan(index, mSprites.size());
-    return *mSprites.at(index);
+    orAssertLessThan(index, sprites.size());
+    return *sprites.at(index);
 }
 
 void World::addSpriteSequence(SpriteSequence* sprite) {
-    mSpriteSequences.emplace_back(std::unique_ptr<SpriteSequence>(sprite));
+    spriteSequences.emplace_back(std::unique_ptr<SpriteSequence>(sprite));
 }
 
 unsigned long World::sizeSpriteSequence() {
-    return mSpriteSequences.size();
+    return spriteSequences.size();
 }
 
 SpriteSequence& World::getSpriteSequence(unsigned long index) {
-    orAssertLessThan(index, mSpriteSequences.size());
-    return *mSpriteSequences.at(index);
+    orAssertLessThan(index, spriteSequences.size());
+    return *spriteSequences.at(index);
 }
 
 void World::addEntity(Entity* entity) {
-    mEntities.emplace_back(std::unique_ptr<Entity>(entity));
+    entities.emplace_back(std::unique_ptr<Entity>(entity));
 }
 
 unsigned long World::sizeEntity() {
-    return mEntities.size();
+    return entities.size();
 }
 
 Entity& World::getEntity(unsigned long index) {
-    orAssertLessThan(index, mEntities.size());
-    return *mEntities.at(index);
+    orAssertLessThan(index, entities.size());
+    return *entities.at(index);
 }
 
 void World::addSkeletalModel(SkeletalModel* model) {
-    mModels.emplace_back(std::unique_ptr<SkeletalModel>(model));
+    models.emplace_back(std::unique_ptr<SkeletalModel>(model));
 }
 
 unsigned long World::sizeSkeletalModel() {
-    return mModels.size();
+    return models.size();
 }
 
 SkeletalModel& World::getSkeletalModel(unsigned long index) {
-    orAssertLessThan(index, mModels.size());
-    return *mModels.at(index);
+    orAssertLessThan(index, models.size());
+    return *models.at(index);
 }
 
 void World::addStaticMesh(StaticMesh* model) {
-    mStaticMeshes.emplace_back(std::unique_ptr<StaticMesh>(model));
+    staticMeshes.emplace_back(std::unique_ptr<StaticMesh>(model));
 }
 
 unsigned long World::sizeStaticMesh() {
-    return mStaticMeshes.size();
+    return staticMeshes.size();
 }
 
 StaticMesh& World::getStaticMesh(unsigned long index) {
-    orAssertLessThan(index, mStaticMeshes.size());
-    return *mStaticMeshes.at(index);
+    orAssertLessThan(index, staticMeshes.size());
+    return *staticMeshes.at(index);
 }
 
 void World::addMesh(Mesh* mesh) {
-    mMeshes.emplace_back(mesh);
+    meshes.emplace_back(mesh);
 }
 
 unsigned long World::sizeMesh() {
-    return mMeshes.size();
+    return meshes.size();
 }
 
 Mesh& World::getMesh(unsigned long index) {
-    orAssertLessThan(index, mMeshes.size());
-    return *mMeshes.at(index);
+    orAssertLessThan(index, meshes.size());
+    return *meshes.at(index);
+}
+
+void World::displayUI() {
+    // Rooms
+    static bool offsets = false;
+    if (ImGui::CollapsingHeader("Rooms")) {
+        ImGui::Columns(6, "rooms");
+        ImGui::Text("No");
+        ImGui::NextColumn();
+        ImGui::Text("Ind.");
+        ImGui::NextColumn();
+        ImGui::Text("Alt.");
+        ImGui::NextColumn();
+        ImGui::Text("Flags");
+        ImGui::NextColumn();
+        ImGui::Text("Models");
+        ImGui::NextColumn();
+        ImGui::Text("Portals");
+        ImGui::NextColumn();
+        ImGui::Separator();
+        if (!offsets) {
+            ImGui::SetColumnOffset(1, 40.0f);
+            ImGui::SetColumnOffset(2, 80.0f);
+            ImGui::SetColumnOffset(3, 120.0f);
+            ImGui::SetColumnOffset(4, 180.0f);
+            ImGui::SetColumnOffset(5, 300.0f);
+            offsets = true;
+        }
+        for (int i = 0; i < rooms.size(); i++) {
+            ImGui::Text("%03d", i);
+            ImGui::NextColumn();
+            rooms.at(i)->displayUI();
+        }
+        ImGui::Columns(1);
+    }
+
+    // Static Meshes
+    static bool offsets2 = false;
+    if (ImGui::CollapsingHeader("StaticMeshes")) {
+        ImGui::Columns(3, "staticmeshes");
+        ImGui::Text("No");
+        ImGui::NextColumn();
+        ImGui::Text("ID");
+        ImGui::NextColumn();
+        ImGui::Text("Mesh");
+        ImGui::NextColumn();
+        ImGui::Separator();
+        if (!offsets2) {
+            ImGui::SetColumnOffset(1, 40.0f);
+            ImGui::SetColumnOffset(2, 80.0f);
+            offsets2 = true;
+        }
+        for (int i = 0; i < staticMeshes.size(); i++) {
+            ImGui::Text("%03d", i);
+            ImGui::NextColumn();
+            staticMeshes.at(i)->displayUI();
+        }
+        ImGui::Columns(1);
+    }
 }
 

src/loader/LoaderTR1.cpp

         );
 
         Entity* e = new Entity(objectID, room, pos, rot);
-        getWorld().addEntity(e);
+        World::addEntity(e);
 
         if (objectID == 0) {
-            Game::setLara(getWorld().sizeEntity() - 1);
+            Game::setLara(World::sizeEntity() - 1);
         }
     }
 

src/loader/LoaderTR2.cpp

             // TODO translate vertices by room offset!
 
             portals.push_back(new Portal(adjoiningRoom,
-                                         glm::vec3(xNormal, yNormal, zNormal),
-                                         glm::vec3(xCorner1, yCorner1, zCorner1),
-                                         glm::vec3(xCorner2, yCorner2, zCorner2),
-                                         glm::vec3(xCorner3, yCorner3, zCorner3),
-                                         glm::vec3(xCorner4, yCorner4, zCorner4)));
+                                         glm::vec3(xNormal, yNormal, zNormal) + pos,
+                                         glm::vec3(xCorner1, yCorner1, zCorner1) + pos,
+                                         glm::vec3(xCorner2, yCorner2, zCorner2) + pos,
+                                         glm::vec3(xCorner3, yCorner3, zCorner3) + pos,
+                                         glm::vec3(xCorner4, yCorner4, zCorner4) + pos));
         }
 
         uint16_t numZSectors = file.readU16();
         for (auto s : roomSprites)
             room->addSprite(s);
 
-        getWorld().addRoom(room);
+        World::addRoom(room);
 
         // Sanity check
         if ((numPortals == 0) && (numVertices == 0)
         int16_t bottomSide = file.read16();
 
         Sprite* sp = new Sprite(tile, x, y, width, height);
-        getWorld().addSprite(sp);
+        World::addSprite(sp);
     }
 
     uint32_t numSpriteSequences = file.readU32();
         orAssertLessThanEqual(offset + (negativeLength * -1), numSpriteTextures);
 
         SpriteSequence* ss = new SpriteSequence(objectID, offset, (negativeLength * -1));
-        getWorld().addSpriteSequence(ss);
+        World::addSpriteSequence(ss);
     }
 
     if ((numSpriteTextures > 0) || (numSpriteSequences > 0))
 
         Mesh* mesh = new Mesh(vertices, texturedRectangles, texturedTriangles,
                               coloredRectangles, coloredTriangles);
-        getWorld().addMesh(mesh);
+        World::addMesh(mesh);
     }
 
     if (numMeshPointers > 0)
 
         BoundingBox* bbox1 = new BoundingBox(glm::vec3(x11, y11, z11), glm::vec3(x12, y12, z12));
         BoundingBox* bbox2 = new BoundingBox(glm::vec3(x21, y21, z21), glm::vec3(x22, y22, z22));
-        getWorld().addStaticMesh(new StaticMesh(objectID, mesh, bbox1, bbox2));
+        World::addStaticMesh(new StaticMesh(objectID, mesh, bbox1, bbox2));
     }
 
     if (numStaticMeshes > 0)
 
         SkeletalModel* sm = new SkeletalModel(objectID);
         sm->add(af);
-        getWorld().addSkeletalModel(sm);
+        World::addSkeletalModel(sm);
         /*
         } else {
             // TODO Add the whole animation hierarchy
 
             SkeletalModel* sm = new SkeletalModel(objectID);
             sm->add(af);
-            getWorld().addSkeletalModel(sm);
+            World::addSkeletalModel(sm);
         }
         */
     }
         );
 
         Entity* e = new Entity(objectID, room, pos, rot);
-        getWorld().addEntity(e);
+        World::addEntity(e);
 
         if (objectID == 0) {
-            Game::setLara(getWorld().sizeEntity() - 1);
+            Game::setLara(World::sizeEntity() - 1);
         }
     }
 

src/main.cpp

 #include <glbinding/Binding.h>
 
 static std::string configFileToUse;
-static std::shared_ptr<World> gWorld;
-
-World& getWorld() {
-    return *gWorld;
-}
 
 int main(int argc, char* argv[]) {
     command_t cmd;
     Log::initialize();
     RunTime::initialize(); // RunTime is required by other constructors
 
-    gWorld.reset(new World());
-
     Command::fillCommandList();
 
     Log::get(LOG_INFO) << "Initializing " << VERSION << Log::endl;
         renderFrame();
     }
 
+    World::destroy();
     Menu::shutdown();
     UI::shutdown();
     Sound::shutdown();