Sprite support in LoaderTR2 and UI

ChangeLog.md

 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20141202 ]
+    * No longer crashing when LoaderTR2 does not find an SFX file
+    * LoaderTR2 now loads level-wide Sprites (no Room Sprites yet)
+    * Added Sprite Viewer Debug UI
+
     [ 20141201 ]
     * Moved Font, Sound, Window modules into system subfolder
     * Rewrote OpenAL sound implementation, separated sourcing and buffering

include/Render.h

     void debugDisplayTextile(int texture = -1,
                              float x = 0.0f, float y = 0.0f, float w = 64.0f, float h = 64.0f);
 
+    void debugDisplaySprite(int sprite = -1, int offset = 0,
+                            float x = 0.0f, float y = 0.0f, float w = 128.0f, float h = 128.0f);
+
   private:
 
     void drawTexture(float x, float y, float w, float h,
 
     void drawTextile(float x, float y, float w, float h, unsigned int textile);
 
+    void drawSprite(float x, float y, float w, float h, unsigned int sprite, unsigned int offset);
+
     static void lightRoom(Room& room);
 
     void drawLoadScreen();
     int mSkyMesh;                         //!< Skymesh model id
     bool mSkyMeshRotation;                //!< Should Skymesh be rotated?
 
-    int debugTexture, debugTextile;
+    int debugTexture, debugTextile, debugSprite, debugSpriteOffset;
     TextureManager::TextureStorage debugTextureStorage;
     float debugX, debugY, debugW, debugH;
 };

include/Sprite.h

 
 class Sprite {
   public:
-    Sprite(struct vertex_t vert, uint16_t tex);
+    Sprite(uint16_t tile, uint8_t x, uint8_t y, uint16_t width, uint16_t height);
 
-    // Old API
     Sprite(TombRaider& tr, unsigned int room, unsigned int index);
-    Sprite(TombRaider& tr, unsigned int item, unsigned int sequence, unsigned int index);
+
+    Sprite(TombRaider& tr, unsigned int item, unsigned int sequence, unsigned int index) :
+        Sprite((tr.Sprite() + ((tr.SpriteSequence() + sequence)->offset) + index)->tile,
+        (tr.Sprite() + ((tr.SpriteSequence() + sequence)->offset) + index)->x,
+        (tr.Sprite() + ((tr.SpriteSequence() + sequence)->offset) + index)->y,
+        (tr.Sprite() + ((tr.SpriteSequence() + sequence)->offset) + index)->width,
+        (tr.Sprite() + ((tr.SpriteSequence() + sequence)->offset) + index)->height) { }
+
     void display();
+    void display(float x, float y, float w, float h);
 
   private:
     float vertex[4][3];
     float texel[4][2];
-    float pos[3];
-    float radius; //!< \fixme yeah, I know (I don't? --xythobuz)
+    //float pos[3];
+    //float radius; //!< \fixme yeah, I know (I don't? --xythobuz)
     int texture;
 };
 
 class SpriteSequence {
   public:
+    SpriteSequence(int32_t objectID);
+    void add(Sprite s);
+
     SpriteSequence(TombRaider& tr, unsigned int item, unsigned int sequence);
     ~SpriteSequence();
 
     Sprite& get(unsigned long index);
 
   private:
-    std::vector<Sprite*> sprites;
+    int32_t id;
+    std::vector<Sprite> sprites;
+
+    std::vector<Sprite*> oldsprites;
 };
 
 #endif

include/World.h

      */
     void destroy();
 
-    void addRoom(Room& room);
+    void addRoom(Room* room);
     unsigned long sizeRoom();
     Room& getRoom(unsigned long index);
 
-    void addSprite(SpriteSequence& sprite);
+    void addSprite(SpriteSequence* sprite);
     unsigned long sizeSprite();
     SpriteSequence& getSprite(unsigned long index);
 
-    void addEntity(Entity& entity);
+    void addEntity(Entity* entity);
     unsigned long sizeEntity();
     Entity& getEntity(unsigned long index);
 
-    void addSkeletalModel(SkeletalModel& model);
+    void addSkeletalModel(SkeletalModel* model);
     unsigned long sizeSkeletalModel();
     SkeletalModel& getSkeletalModel(unsigned long index);
 
-    void addStaticMesh(StaticMesh& model);
+    void addStaticMesh(StaticMesh* model);
     unsigned long sizeStaticMesh();
     StaticMesh& getStaticMesh(unsigned long index);
 

src/Game.cpp

 
         for (int j = 0; j < mTombRaider.NumSpriteSequences(); j++) {
             if (mTombRaider.SpriteSequence()[j].object_id == mTombRaider.Item()[i].object_id)
-                getWorld().addSprite(*new SpriteSequence(mTombRaider, i, j));
+                getWorld().addSprite(new SpriteSequence(mTombRaider, i, j));
         }
     }
 
 
 void Game::processRooms() {
     for (int index = 0; index < mTombRaider.NumRooms(); index++)
-        getWorld().addRoom(*new Room(mTombRaider, index));
+        getWorld().addRoom(new Room(mTombRaider, index));
 
     getLog() << "Found " << mTombRaider.NumRooms() << " rooms." << Log::endl;
 }
 
 void Game::processModels() {
     for (int index = 0; index < mTombRaider.getMeshCount(); index++)
-        getWorld().addStaticMesh(*new StaticMesh(mTombRaider, index));
+        getWorld().addStaticMesh(new StaticMesh(mTombRaider, index));
 
     getLog() << "Found " << mTombRaider.getMeshCount() << " meshes." << Log::endl;
 }
 
     // Create a new SkeletalModel, if needed
     if (!cached)
-        getWorld().addSkeletalModel(*new SkeletalModel(mTombRaider, index, object_id));
+        getWorld().addSkeletalModel(new SkeletalModel(mTombRaider, index, object_id));
 
     // Create a new Entity, using the cached or the new SkeletalModel
-    Entity& entity = *new Entity(mTombRaider, index, i, model);
+    Entity* entity = new Entity(mTombRaider, index, i, model);
     getWorld().addEntity(entity);
 
     // Store reference to Lara
-    if (entity.getObjectId() == 0)
+    if (entity->getObjectId() == 0)
         mLara = getWorld().sizeEntity() - 1;
 
     // Store reference to the SkyMesh

src/Render.cpp

 
     debugTexture = -1;
     debugTextile = -1;
+    debugSprite = -1;
     debugTextureStorage = TextureManager::TextureStorage::GAME;
+    debugSpriteOffset = 0;
     debugX = 0.0f;
     debugY = 0.0f;
     debugW = 256.0f;
             getWindow().glEnter2D();
             drawTextile(debugX, debugY, debugW, debugH, debugTextile);
             getWindow().glExit2D();
+        } else if (debugSprite >= 0) {
+            getWindow().glEnter2D();
+            drawSprite(debugX, debugY, debugW, debugH, debugSprite, debugSpriteOffset);
+            getWindow().glExit2D();
         }
     }
 
         drawTexture(debugX, debugY, debugW, debugH, debugTexture, debugTextureStorage);
     else if (debugTextile >= 0)
         drawTextile(debugX, debugY, debugW, debugH, debugTextile);
+    else if (debugSprite >= 0)
+        drawSprite(debugX, debugY, debugW, debugH, debugSprite, debugSpriteOffset);
 
     getWindow().glExit2D();
 
 }
 
 void Render::drawTextile(float x, float y, float w, float h, unsigned int textile) {
-    float z = 0.0f;
+    glColor3ubv(WHITE);
+
+    if (mFlags & Render::fGL_Lights)
+        glDisable(GL_LIGHTING);
+
+    getTextureManager().getTile(textile).display(x, y, w, h, 0.0f);
+
+    if (mFlags & Render::fGL_Lights)
+        glEnable(GL_LIGHTING);
+}
+
+void Render::debugDisplaySprite(int sprite, int offset, float x, float y, float w, float h) {
+    debugSprite = sprite;
+    debugSpriteOffset = offset;
+    debugX = x;
+    debugY = y;
+    debugW = w;
+    debugH = h;
+    debugTexture = -1;
+    debugTextile = -1;
+}
 
+void Render::drawSprite(float x, float y, float w, float h, unsigned int sprite, unsigned int offset) {
     glColor3ubv(WHITE);
 
     if (mFlags & Render::fGL_Lights)
         glDisable(GL_LIGHTING);
 
-    getTextureManager().getTile(textile).display(x, y, w, h, z);
+    getWorld().getSprite(sprite).get(offset).display(x, y, w, h);
 
     if (mFlags & Render::fGL_Lights)
         glEnable(GL_LIGHTING);

src/SoundManager.cpp

     for (int i = 0; i < soundMap.size(); i++) {
         float vol;
         int index = getIndex(i, &vol);
-        if (index >= 0) {
+        if ((index >= 0) && (index < Sound::numBuffers())) {
             int ret = Sound::addSource(index, vol, true, false);
             assert(ret >= 0);
         }

src/Sprite.cpp

 #include "TextureManager.h"
 #include "Sprite.h"
 
+SpriteSequence::SpriteSequence(int32_t objectID) {
+    id = objectID;
+}
+
+void SpriteSequence::add(Sprite s) {
+    sprites.push_back(s);
+}
+
+// -----------------------
+
 SpriteSequence::SpriteSequence(TombRaider& tr, unsigned int item, unsigned int sequence) {
     for (int i = 0; i < (-tr.SpriteSequence()[sequence].negative_length); i++)
-        sprites.push_back(new Sprite(tr, item, sequence, i));
+        oldsprites.push_back(new Sprite(tr, item, sequence, i));
 }
 
 SpriteSequence::~SpriteSequence() {
-    for (unsigned int i = 0; i < sprites.size(); i++)
-        delete sprites.at(i);
+    for (unsigned int i = 0; i < oldsprites.size(); i++)
+        delete oldsprites.at(i);
 }
 
 unsigned long SpriteSequence::size() {
-    return sprites.size();
+    if (oldsprites.size() > 0)
+        return oldsprites.size();
+    else
+        return sprites.size();
 }
 
 Sprite& SpriteSequence::get(unsigned long index) {
-    assert(index < sprites.size());
-    return *sprites.at(index);
+    if (oldsprites.size() > 0) {
+        assert(index < oldsprites.size());
+        return *oldsprites.at(index);
+    } else {
+        assert(index < sprites.size());
+        return sprites.at(index);
+    }
 }
 
-Sprite::Sprite(TombRaider& tr, unsigned int item, unsigned int sequence, unsigned int index) {
-    tr2_item_t* i = tr.Item();
-    tr2_sprite_texture_t* spriteTextures = tr.Sprite();
-    tr2_sprite_sequence_t* spriteSequence = tr.SpriteSequence();
+// ----------------------------------------------------------------------------
 
-    //! \fixme index was unused?!
-    tr2_sprite_texture_t* sprite = &spriteTextures[spriteSequence[sequence].offset + index];
+Sprite::Sprite(uint16_t tile, uint8_t x, uint8_t y, uint16_t width, uint16_t height) {
+    /*!
+     * \fixme TODO Can't do translation/visibility-check when rendering here.
+     * We don't know xyz of this Sprite because it could be used by
+     * different items at other coordinates in the world.
+     * Do translation/visibility-check at item/room level.
+     */
 
-    int width = sprite->width >> 8;
-    int height = sprite->height >> 8;
-    int x = sprite->x;
-    int y = sprite->y;
-    float scale = 4.0f;
-    float texelScale = 256.0f;
+    const float scale = 4.0f;
+    const float texelScale = 256.0f;
+
+    width >>= 8;
+    height >>= 8;
     int width2 = (int)(width * scale);
     int height2 = (int)(height * scale);
 
-    // For vising use
-    pos[0] = i[item].x;
-    pos[1] = i[item].y;
-    pos[2] = i[item].z;
-
     vertex[0][0] = -width2 / 2.0f;
     vertex[1][0] = -width2 / 2.0f;
     vertex[2][0] = width2 / 2.0f;
     texel[0][0] = (float)(x) / texelScale;
     texel[0][1] = (float)(y + height) / texelScale;
 
-    texture = sprite->tile;
-    radius = width2 / 2.0f;
+    texture = tile;
+    //radius = width2 / 2.0f;
 }
 
+// -----------------------
+
 Sprite::Sprite(TombRaider& tr, unsigned int room, unsigned int index) {
     float spriteVertices[12];
     float spriteTexCoords[8];
+    float posUnused[3];
 
     tr.getRoomSprite(room, index,
-                     10.0f, &texture, pos, spriteVertices, spriteTexCoords);
+                     10.0f, &texture, posUnused, spriteVertices, spriteTexCoords);
 
     for (unsigned int j = 0; j < 12; j++)
         vertex[j / 3][j % 3] = spriteVertices[j];
     for (unsigned int j = 0; j < 8; j++)
         texel[j / 2][j % 2] = spriteTexCoords[j];
 
-    radius = 0.0f;
-}
-
-Sprite::Sprite(struct vertex_t vert, uint16_t tex) {
-
+    //radius = 0.0f;
 }
 
 void Sprite::display() {
-    if (!getRender().isVisible(pos[0], pos[1], pos[2], radius))
-        return;
+    //if (!getRender().isVisible(pos[0], pos[1], pos[2], radius))
+    //    return;
 
     glPushMatrix();
-    glTranslated(pos[0], pos[1], pos[2]);
+    //glTranslated(pos[0], pos[1], pos[2]);
 
     // Sprites must always face camera, because they have no depth =)
     glRotated(OR_RAD_TO_DEG(getCamera().getRadianYaw()), 0, 1, 0);
     glPopMatrix();
 }
 
+void Sprite::display(float x, float y, float w, float h) {
+    float z = 0.0f;
+
+    getTextureManager().bindTextureId(texture);
+
+    glBegin(GL_QUADS);
+
+    glTexCoord2fv(texel[1]);
+    glVertex3f(x, y, z);
+
+    glTexCoord2fv(texel[2]);
+    glVertex3f(x + w, y, z);
+
+    glTexCoord2fv(texel[3]);
+    glVertex3f(x + w, y + h, z);
+
+    glTexCoord2fv(texel[0]);
+    glVertex3f(x, y + h, z);
+
+    glEnd();
+}
+

src/UI.cpp

 #include "RunTime.h"
 #include "SoundManager.h"
 #include "TextureManager.h"
+#include "World.h"
 #include "commands/Command.h"
 #include "system/Sound.h"
 #include "system/Window.h"
             }
         }
 
+        ImGui::Separator();
+
         static bool visibleTex = false;
         static bool visibleTile = false;
         static bool visibleAnim = false;
+        static bool visibleSprite = false;
         if (ImGui::CollapsingHeader("Texture Viewer")) {
             static bool game = getGame().isLoaded();
             static int index = 0;
                 visibleTex = true;
                 visibleTile = false;
                 visibleAnim = false;
+                visibleSprite = false;
             }
             ImGui::SameLine();
             if (ImGui::Button("Clear##texclear")) {
                     visibleTile = true;
                     visibleTex = false;
                     visibleAnim = false;
+                    visibleSprite = false;
                 }
                 ImGui::SameLine();
                 if (ImGui::Button("Clear##tileclear")) {
                     tile = getTextureManager().getFirstTileAnimation(index);
                 }
                 ImGui::SameLine();
-                static int fr = 0;
                 if (ImGui::Button("Show##animshow")) {
                     visibleAnim = true;
                     visibleTex = false;
                     visibleTile = false;
+                    visibleSprite = false;
                 }
                 ImGui::SameLine();
                 if (ImGui::Button("Clear##animclear")) {
                     visibleAnim = false;
                 }
                 if (visibleAnim) {
+                    static int fr = 0;
                     if (fr > 0) {
                         fr--;
                     } else {
             }
         }
 
-        if (ImGui::CollapsingHeader("SoundManager Player")) {
+        if (ImGui::CollapsingHeader("Sound Map Player")) {
             if (!Sound::getEnabled()) {
                 ImGui::Text("Please enable Sound first!");
                 if (ImGui::Button("Enable Sound!")) {
             }
         }
 
-        if (ImGui::CollapsingHeader("ImGui UI Help")) {
+        if (ImGui::CollapsingHeader("Sprite Sequence Viewer")) {
+            if (getWorld().sizeSprite() <= 0) {
+                ImGui::Text("Please load a level containing sprites!");
+            } else {
+                static int index = 0;
+                static int sprite = 0;
+                ImGui::PushItemWidth(ImGui::GetWindowWidth() * 0.5f);
+                if (ImGui::SliderInt("##spriteslide", &index, 0, getWorld().sizeSprite() - 1))
+                    sprite = 0;
+                ImGui::PopItemWidth();
+                ImGui::SameLine();
+                if (ImGui::Button("+##spriteplus", ImVec2(0, 0), true)) {
+                    if (index < (getWorld().sizeSprite() - 1))
+                        index++;
+                    else
+                        index = 0;
+                    sprite = 0;
+                }
+                ImGui::SameLine();
+                if (ImGui::Button("-##spriteminus", ImVec2(0, 0), true)) {
+                    if (index > 0)
+                        index--;
+                    else
+                        index = getWorld().sizeSprite() - 1;
+                    sprite = 0;
+                }
+                ImGui::SameLine();
+                if (ImGui::Button("Show##spriteshow")) {
+                    visibleSprite = true;
+                    visibleTex = false;
+                    visibleTile = false;
+                    visibleAnim = false;
+                    sprite = 0;
+                }
+                ImGui::SameLine();
+                if (ImGui::Button("Clear##spriteclear")) {
+                    getRender().debugDisplaySprite();
+                    visibleSprite = false;
+                }
+                if (visibleSprite) {
+                    static int fr = 0;
+                    if (fr > 0) {
+                        fr--;
+                    } else {
+                        getRender().debugDisplaySprite(index, sprite,
+                                                       ImGui::GetWindowPos().x - (ImGui::GetWindowWidth() / 2),
+                                                       ImGui::GetWindowPos().y,
+                                                       (ImGui::GetWindowWidth() / 2), (ImGui::GetWindowWidth() / 2));
+                        fr = getRunTime().getFPS() / 10;
+                        if (sprite < (getWorld().getSprite(index).size() - 1))
+                            sprite++;
+                        else
+                            sprite = 0;
+                    }
+
+                    ImGui::Text("Sprite %d/%d", sprite + 1, getWorld().getSprite(index).size());
+                }
+            }
+        }
+
+        ImGui::Separator();
+
+        if (ImGui::CollapsingHeader("ImGui/Debug UI Help")) {
+            ImGui::TextWrapped("DebugViewer Textures/Textiles/Sprites will be drawn on"
+                               " the left side and scale with the size of this window!");
+            ImGui::Separator();
             ImGui::ShowUserGuide();
         }
     }

src/World.cpp

     destroy();
 }
 
-void World::addRoom(Room& room) {
-    mRooms.push_back(std::unique_ptr<Room>(&room));
+void World::addRoom(Room* room) {
+    mRooms.emplace_back(std::unique_ptr<Room>(room));
 }
 
 unsigned long World::sizeRoom() {
     return *mRooms.at(index);
 }
 
-void World::addSprite(SpriteSequence& sprite) {
-    mSprites.push_back(std::unique_ptr<SpriteSequence>(&sprite));
+void World::addSprite(SpriteSequence* sprite) {
+    mSprites.emplace_back(std::unique_ptr<SpriteSequence>(sprite));
 }
 
 unsigned long World::sizeSprite() {
     return *mSprites.at(index);
 }
 
-void World::addEntity(Entity& entity) {
-    mEntities.push_back(std::unique_ptr<Entity>(&entity));
+void World::addEntity(Entity* entity) {
+    mEntities.emplace_back(std::unique_ptr<Entity>(entity));
 }
 
 unsigned long World::sizeEntity() {
     return *mEntities.at(index);
 }
 
-void World::addSkeletalModel(SkeletalModel& model) {
-    mModels.push_back(std::unique_ptr<SkeletalModel>(&model));
+void World::addSkeletalModel(SkeletalModel* model) {
+    mModels.emplace_back(std::unique_ptr<SkeletalModel>(model));
 }
 
 unsigned long World::sizeSkeletalModel() {
     return *mModels.at(index);
 }
 
-void World::addStaticMesh(StaticMesh& model) {
-    mMeshes.push_back(std::unique_ptr<StaticMesh>(&model));
+void World::addStaticMesh(StaticMesh* model) {
+    mMeshes.emplace_back(std::unique_ptr<StaticMesh>(model));
 }
 
 unsigned long World::sizeStaticMesh() {

src/loader/LoaderTR2.cpp

 #include "Room.h"
 #include "SoundManager.h"
 #include "TextureManager.h"
+#include "World.h"
 #include "system/Sound.h"
 #include "utils/pixel.h"
 #include "loader/LoaderTR2.h"
         uint16_t numSprites = file.readU16();
         for (unsigned int s = 0; s < numSprites; s++) {
             uint16_t vertex = file.readU16(); // Index into vertex list
-            uint16_t texture = file.readU16(); // Index into object-texture list
+            uint16_t sprite = file.readU16(); // Index into sprite list
 
-            room->addSprite(new Sprite(vertices.at(vertex), texture));
+            // TODO store sprites somewhere
         }
 
         uint16_t numPortals = file.readU16();
         int16_t alternateRoom = file.read16();
 
         uint16_t flags = file.readU16();
+
+        getWorld().addRoom(room);
     }
 }
 
 
 void LoaderTR2::loadSprites() {
     uint32_t numSpriteTextures = file.readU32();
+    std::vector<Sprite> sprites;
     for (unsigned int s = 0; s < numSpriteTextures; s++) {
         uint16_t tile = file.readU16();
         uint8_t x = file.readU8();
         uint8_t y = file.readU8();
         uint16_t width = file.readU16(); // Actually (width * 256) + 255
         uint16_t height = file.readU16(); // Actually (height * 256) + 255
+
+        // Required for what?
         int16_t leftSide = file.read16();
         int16_t topSide = file.read16();
         int16_t rightSide = file.read16();
         int16_t bottomSide = file.read16();
 
-        // TODO store sprite textures somewhere
+        sprites.emplace_back(tile, x, y, width, height);
     }
 
     uint32_t numSpriteSequences = file.readU32();
         int16_t negativeLength = file.read16(); // Negative sprite count
         int16_t offset = file.read16(); // Where sequence starts in sprite texture list
 
-        // TODO store sprite sequences somewhere
+        assert(negativeLength < 0);
+        assert(offset >= 0);
+        assert((offset + (negativeLength * -1)) <= numSpriteTextures);
+
+        SpriteSequence* ss = new SpriteSequence(objectID);
+        for (int i = 0; i < (negativeLength * -1); i++) {
+            ss->add(sprites.at(offset + i));
+        }
+        getWorld().addSprite(ss);
     }
 }
 
 
     for (unsigned int i = 0; i < numMeshPointers; i++) {
         uint32_t meshPointer = file.readU32();
-        char* tmpPtr = reinterpret_cast<char*>(&buffer[meshPointer]);
-        BinaryMemory mem(tmpPtr, numMeshData - meshPointer);
 
-        // TODO interpret the buffered mesh data
+        char* tmpPtr = reinterpret_cast<char*>(&buffer[meshPointer / 2]);
+        BinaryMemory mem(tmpPtr, (numMeshData * 2) - meshPointer);
+
+        int16_t mx = mem.read16();
+        int16_t my = mem.read16();
+        int16_t mz = mem.read16();
+
+        int32_t collisionSize = mem.read32();
+
+        uint16_t numVertices = mem.readU16();
+        for (int v = 0; v < numVertices; v++) {
+            int16_t x = mem.read16();
+            int16_t y = mem.read16();
+            int16_t z = mem.read16();
+
+        }
+
+        int16_t numNormals = mem.read16();
+        if (numNormals > 0) {
+            // External vertex lighting is used, with the lighting calculated
+            // from the rooms ambient and point-source lighting values. The
+            // latter appears to use a simple Lambert law for directionality:
+            // intensity is proportional to
+            //      max((normal direction).(direction to source), 0)
+            for (int n = 0; n < numNormals; n++) {
+                int16_t x = mem.read16();
+                int16_t y = mem.read16();
+                int16_t z = mem.read16();
+
+            }
+        } else if (numNormals < 0) {
+            // Internal vertex lighting is used,
+            // using the data included with the mesh
+            for (int l = 0; l < (numNormals * -1); l++) {
+                int16_t light = mem.read16();
+
+            }
+        }
+
+        int16_t numTexturedRectangles = mem.read16();
+        for (int r = 0; r < numTexturedRectangles; r++) {
+            uint16_t vertex1 = mem.readU16();
+            uint16_t vertex2 = mem.readU16();
+            uint16_t vertex3 = mem.readU16();
+            uint16_t vertex4 = mem.readU16();
+            uint16_t texture = mem.readU16();
+
+        }
+
+        int16_t numTexturedTriangles = mem.read16();
+        for (int t = 0; t < numTexturedTriangles; t++) {
+            uint16_t vertex1 = mem.readU16();
+            uint16_t vertex2 = mem.readU16();
+            uint16_t vertex3 = mem.readU16();
+            uint16_t texture = mem.readU16();
+
+        }
+
+        int16_t numColoredRectangles = mem.read16();
+        for (int r = 0; r < numColoredRectangles; r++) {
+            uint16_t vertex1 = mem.readU16();
+            uint16_t vertex2 = mem.readU16();
+            uint16_t vertex3 = mem.readU16();
+            uint16_t vertex4 = mem.readU16();
+            uint16_t texture = mem.readU16();
+
+        }
+
+        int16_t numColoredTriangles = mem.read16();
+        for (int t = 0; t < numColoredTriangles; t++) {
+            uint16_t vertex1 = mem.readU16();
+            uint16_t vertex2 = mem.readU16();
+            uint16_t vertex3 = mem.readU16();
+            uint16_t texture = mem.readU16();
+
+        }
+
+        // TODO store mesh data somewhere
     }
 }
 
 
 
         // Offset of mesh origin from the parent mesh origin
-
-        /* Where the hell does this come from?!
-        int32_t x = file.read32();
-        int32_t y = file.read32();
-        int32_t z = file.read32();
-        */
+        //int32_t x = file.read32();
+        //int32_t y = file.read32();
+        //int32_t z = file.read32();
+        // Does not appear to be true...?
 
         // TODO store mesh trees somewhere
     }

src/system/SoundAL.cpp

 
     alGetError();
     alDeleteBuffers(buffers.size(), &buffers[0]);
+    buffers.clear();
     if (alGetError() != AL_NO_ERROR) {
         getLog() << "SoundAL: Error while deleting buffers!" << Log::endl;
     }
 
     for (int i = 0; i < 3; i++)
         lastPosition[i] = 0.0f;
+
+    float orientation[6] = { 0.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f };
+    listenAt(lastPosition, orientation);
 }
 
 int SoundAL::numBuffers() {

src/utils/binary.cpp

     if ((offset + c) > max) {
         std::ostringstream ss;
         ss << "BinaryMemory read out of bounds ("
-           << offset << " + " << c << " > " << max;
+           << offset << " + " << c << " > " << max << ")";
         throw new Exception(ss.str());
     }