Added support for TR1 levels

CMakeLists.txt

     set (WARNINGS "${WARNINGS} -Wno-padded -Wno-packed")
     set (WARNINGS "${WARNINGS} -Wno-global-constructors -Wno-exit-time-destructors")
     set (WARNINGS "${WARNINGS} -Wno-documentation-unknown-command -Wno-c++98-compat-pedantic")
+    set (WARNINGS "${WARNINGS} -Wno-shorten-64-to-32 -Wno-sign-compare -Wno-sign-conversion")
     set (OpenRaider_CXX_FLAGS "${OpenRaider_CXX_FLAGS} -std=c++11")
     set (OpenRaider_CXX_FLAGS_DEBUG "${OpenRaider_CXX_FLAGS_DEBUG} -g -O0 -ftrapv")
     set (OpenRaider_CXX_FLAGS_RELEASE "${OpenRaider_CXX_FLAGS_RELEASE} -O2 -fomit-frame-pointer")

ChangeLog.md

 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20140304 ]
+    * Added (more or less working) support for loading TR1 levels
+
     [ 20140222 ]
     * Updated imgui to version 1.33
 

include/Mesh.h

 };
 
 struct IndexedColoredRectangle {
-    unsigned int v1, v2, v3, v4;
-    unsigned char r, g, b;
+    unsigned int v1, v2, v3, v4, index;
 
-    IndexedColoredRectangle(unsigned char _r, unsigned char _g, unsigned char _b,
+    IndexedColoredRectangle(unsigned int paletteIndex,
                             unsigned int _v1, unsigned int _v2,
                             unsigned int _v3, unsigned int _v4 = 0)
-        : v1(_v1), v2(_v2), v3(_v3), v4(_v4), r(_r), g(_g), b(_b) { }
+        : v1(_v1), v2(_v2), v3(_v3), v4(_v4), index(paletteIndex) { }
 };
 
 // --------------------------------------
 
     std::vector<unsigned short> indicesColorBuff;
     std::vector<glm::vec3> verticesColorBuff;
-    std::vector<glm::vec3> colorsBuff;
+    std::vector<unsigned int> colorsBuff;
 
     ShaderBuffer indices, vertices, uvs;
     ShaderBuffer indicesColor, verticesColor, colors;

include/TextureManager.h

 #ifndef _TEXTURE_MANAGER_H
 #define _TEXTURE_MANAGER_H
 
+#include <array>
+#include <tuple>
 #include <vector>
 
 // These are loaded into TextureStorage::SYSTEM by initialize()!
     static int initializeSplash();
     static void shutdown();
     static void clear();
+    static void prepare();
 
     static int numTextures(TextureStorage s = TextureStorage::GAME);
 
 
     static unsigned int getTextureID(int n, TextureStorage s);
 
+    static void setPalette(int index, glm::vec4 color);
+    static glm::vec4 getPalette(int index);
+
+    static void addIndexedTexture(unsigned char* image, unsigned int width, unsigned int height);
+
   private:
     static std::vector<unsigned int>& getIds(TextureStorage s);
     static std::vector<int>& getUnits(TextureStorage s);
 
     static std::vector<BufferManager> gameBuffers;
     static std::vector<BufferManager> systemBuffers;
+
+    static std::array<glm::vec4, 256> colorPalette;
+    static std::vector<std::tuple<unsigned char*, unsigned int, unsigned int>> indexedTextures;
 };
 
 #endif

include/global.h

 
 template<typename T, typename U>
 [[noreturn]] void assertEqualImplementation(const char* exp, T a, U b, const char* file, int line,
-        bool print = false, const char* str = nullptr) {
+                                            const char* str = nullptr) {
     const unsigned int maxSize = 128;
     void* callstack[maxSize];
     int frames = backtrace(callstack, maxSize);
 
     std::cout << std::endl << "assertion failed:" << std::endl;
     std::cout << "\t" << exp << std::endl;
-    if (print)
+    if (str != nullptr)
         std::cout << "\t(" << a << " " << str << " " << b << ")" << std::endl;
     std::cout << "in " << file << ":" << line << std::endl << std::endl;
 
     auto assertEvalTemp2 = y; \
     if (assertEvalTemp != assertEvalTemp2) \
         assertEqualImplementation(#x " == " #y, assertEvalTemp, assertEvalTemp2, \
-                                  __FILE__, __LINE__, true, "!="); \
+                                  __FILE__, __LINE__, "!="); \
 }
 
 #define assertNotEqual(x, y) { \
     auto assertEvalTemp2 = y; \
     if (assertEvalTemp == assertEvalTemp2) \
         assertEqualImplementation(#x " != " #y, assertEvalTemp, assertEvalTemp2, \
-                                  __FILE__, __LINE__, true, "=="); \
+                                  __FILE__, __LINE__, "=="); \
 }
 
 #define assertLessThan(x, y) { \
     auto assertEvalTemp2 = y; \
     if (assertEvalTemp >= assertEvalTemp2) \
         assertEqualImplementation(#x " < " #y, assertEvalTemp, assertEvalTemp2, \
-                                  __FILE__, __LINE__, true, ">="); \
+                                  __FILE__, __LINE__, ">="); \
 }
 
 #define assertLessThanEqual(x, y) { \
     auto assertEvalTemp2 = y; \
     if (assertEvalTemp > assertEvalTemp2) \
         assertEqualImplementation(#x " <= " #y, assertEvalTemp, assertEvalTemp2, \
-                                  __FILE__, __LINE__, true, ">"); \
+                                  __FILE__, __LINE__, ">"); \
 }
 
 #define assertGreaterThan(x, y) { \
     auto assertEvalTemp2 = y; \
     if (assertEvalTemp <= assertEvalTemp2) \
         assertEqualImplementation(#x " > " #y, assertEvalTemp, assertEvalTemp2, \
-                                  __FILE__, __LINE__, true, "<="); \
+                                  __FILE__, __LINE__, "<="); \
 }
 
 #define assertGreaterThanEqual(x, y) { \
     auto assertEvalTemp2 = y; \
     if (assertEvalTemp < assertEvalTemp2) \
         assertEqualImplementation(#x " >= " #y, assertEvalTemp, assertEvalTemp2, \
-                                  __FILE__, __LINE__, true, "<"); \
+                                  __FILE__, __LINE__, "<"); \
 }
 
 #else // NODEBUG

include/loader/LoaderTR1.h

 #ifndef _LOADER_LOADER_TR1_H_
 #define _LOADER_LOADER_TR1_H_
 
-#include "loader/Loader.h"
+#include "loader/LoaderTR2.h"
 
-class LoaderTR1 : public Loader {
+class LoaderTR1 : public LoaderTR2 {
   public:
-    LoaderTR1();
-    virtual ~LoaderTR1();
-
     virtual int load(std::string f);
 
-  private:
-
+  protected:
+    virtual void loadPalette();
+    virtual void loadTextures();
+    virtual void loadRoomLights();
+    virtual void loadRoomStaticMeshes(std::vector<StaticModel*>& staticModels);
+    virtual void loadRoomVertex(RoomVertexTR2& vert);
+    virtual void loadItems();
+    virtual void loadBoxesOverlapsZones();
+    virtual void loadSoundMap();
+    virtual void loadSoundSamples();
+
+    virtual int getPaletteIndex(uint16_t index);
 };
 
 #endif

include/loader/LoaderTR2.h

 #include <array>
 #include <cstdint>
 
+#include "RoomData.h"
+#include "RoomMesh.h"
 #include "loader/Loader.h"
 
 class LoaderTR2 : public Loader {
     virtual int load(std::string f);
 
   protected:
-    virtual void loadPaletteTextiles();
+    virtual void loadPalette();
+    virtual void loadTextures();
     virtual void loadRoomLights();
+    virtual void loadRoomStaticMeshes(std::vector<StaticModel*>& staticModels);
     virtual void loadRoomDataEnd(int16_t& alternateRoom, unsigned int& roomFlags);
+    virtual void loadRoomVertex(RoomVertexTR2& vert);
     virtual void loadRooms();
     virtual void loadFloorData();
     virtual void loadMeshes();
     virtual void loadMoveables();
     virtual void loadStaticMeshes();
-    virtual void loadTextures();
+    virtual void loadTextiles();
     virtual void loadSprites();
     virtual void loadCameras();
     virtual void loadSoundSources();
     virtual void loadSampleIndices();
 
     virtual void loadExternalSoundFile(std::string f);
+    virtual void loadSoundFiles(BinaryReader& sfx);
 
-    std::array<uint32_t, 256> palette;
+    virtual int getPaletteIndex(uint16_t index);
 };
 
 #endif

include/system/Shader.h

     void bindBuffer(int location, int size);
     void unbind(int location);
 
+    unsigned int getBuffer() { assert(created); return buffer; }
     int getSize() { return boundSize; }
 
   private:

src/Console.cpp

     if (!visible)
         return;
 
-    static bool scrollToBottom = false;
     if (ImGui::Begin("Console", &visible, ImVec2(600, 400))) {
+        static bool scrollToBottom = false;
         if (lastLogLength != Log::size()) {
             lastLogLength = Log::size();
             scrollToBottom = true;
 
         if (ImGui::IsItemHovered() || focusInput) {
             ImGui::SetKeyboardFocusHere(-1);
-            focusInput = false;
         }
     }
     ImGui::End();

src/Game.cpp

         }
 
         SoundManager::prepareSources();
+        TextureManager::prepare();
 
         mLoaded = true;
         Render::setMode(RenderMode::Texture);

src/MenuFolder.cpp

             // Filter files based on file name
             if ((f.getName().length() > 4)
                 && (f.getName().compare(f.getName().length() - 4, 4, ".phd") != 0)
+                && (f.getName().compare(f.getName().length() - 4, 4, ".psx") != 0)
+                && (f.getName().compare(f.getName().length() - 4, 4, ".tub") != 0)
                 && (f.getName().compare(f.getName().length() - 4, 4, ".tr2") != 0)
                 && (f.getName().compare(f.getName().length() - 4, 4, ".tr4") != 0)
                 && (f.getName().compare(f.getName().length() - 4, 4, ".trc") != 0)) {

src/Mesh.cpp

         verticesColorBuff.push_back(glm::vec3(vert.at(t.v2).x, vert.at(t.v2).y, vert.at(t.v2).z));
         verticesColorBuff.push_back(glm::vec3(vert.at(t.v3).x, vert.at(t.v3).y, vert.at(t.v3).z));
         verticesColorBuff.push_back(glm::vec3(vert.at(t.v4).x, vert.at(t.v4).y, vert.at(t.v4).z));
-        colorsBuff.push_back(glm::vec3(t.r, t.g, t.b));
+        colorsBuff.push_back(t.index);
     }
 
     for (auto& t : coloredTri) {
         verticesColorBuff.push_back(glm::vec3(vert.at(t.v1).x, vert.at(t.v1).y, vert.at(t.v1).z));
         verticesColorBuff.push_back(glm::vec3(vert.at(t.v2).x, vert.at(t.v2).y, vert.at(t.v2).z));
         verticesColorBuff.push_back(glm::vec3(vert.at(t.v3).x, vert.at(t.v3).y, vert.at(t.v3).z));
-        colorsBuff.push_back(glm::vec3(t.r, t.g, t.b));
+        colorsBuff.push_back(t.index);
     }
 }
 
                 v = 0;
             indCol.push_back(vertCol.size());
             vertCol.push_back(verticesColorBuff.at(vertIndex + v));
-            cols.push_back(colorsBuff.at(i));
+            glm::vec4 c = TextureManager::getPalette(colorsBuff.at(i));
+            cols.push_back(glm::vec3(c.x, c.y, c.z));
         }
 
         if (indicesColorBuff.at(i) == 0) {

src/TextureManager.cpp

 
 // ----------------------------------------------------------------------------
 
+#define COLOR_PALETTE_SIZE 256
+
 std::vector<unsigned int> TextureManager::mTextureIdsGame;
 std::vector<unsigned int> TextureManager::mTextureIdsSystem;
 std::vector<TextureTile*> TextureManager::tiles;
 unsigned int TextureManager::nextFreeTextureUnit = 0;
 std::vector<BufferManager> TextureManager::gameBuffers;
 std::vector<BufferManager> TextureManager::systemBuffers;
+std::array<glm::vec4, 256> TextureManager::colorPalette;
+std::vector<std::tuple<unsigned char*, unsigned int, unsigned int>> TextureManager::indexedTextures;
 
 int TextureManager::initialize() {
     assertEqual(mTextureIdsGame.size(), 0);
     gameUnits.clear();
     systemUnits.clear();
     nextFreeTextureUnit = 0;
+
+    indexedTextures.clear();
 }
 
 int TextureManager::loadBufferSlot(unsigned char* image,
     return &(v.at(tex));
 }
 
+void TextureManager::setPalette(int index, glm::vec4 color) {
+    assertGreaterThanEqual(index, 0);
+    assertLessThan(index, COLOR_PALETTE_SIZE);
+    colorPalette[index] = color;
+}
+
+glm::vec4 TextureManager::getPalette(int index) {
+    assertGreaterThanEqual(index, 0);
+    assertLessThan(index, COLOR_PALETTE_SIZE);
+    return colorPalette[index];
+}
+
+void TextureManager::addIndexedTexture(unsigned char* image, unsigned int width, unsigned int height) {
+    unsigned char* img = new unsigned char[width * height];
+    for (unsigned int i = 0; i < (width * height); i++)
+        img[i] = image[i];
+    indexedTextures.emplace_back(img, width, height);
+}
+
+void TextureManager::prepare() {
+    for (int i = 0; i < indexedTextures.size(); i++) {
+        auto tex = indexedTextures.at(i);
+        unsigned char* img = std::get<0>(tex);
+        unsigned int width = std::get<1>(tex);
+        unsigned int height = std::get<2>(tex);
+        unsigned char* image = new unsigned char[width * height * 4];
+        for (unsigned int i = 0; i < (width * height); i++) {
+            auto col = getPalette(img[i]);
+            image[i * 4] = col.x * 255;
+            image[(i * 4) + 1] = col.y * 255;
+            image[(i * 4) + 2] = col.z * 255;
+            image[(i * 4) + 3] = col.w * 255;
+        }
+        delete [] img;
+        loadBufferSlot(image, width, height, ColorMode::RGBA, 32, TextureStorage::GAME, i, true);
+    }
+}
+
 int TextureManager::loadImage(std::string filename, TextureStorage s, int slot) {
     if (stringEndsWith(filename, ".pcx")) {
         return loadPCX(filename, s, slot);

src/UI.cpp

             static float rot[3];
 
             if (ImGui::SliderFloat3("Position", pos, -100.0f, 100.0f)) {
-                dirty = true;
+                //dirty = true;
             }
             if (ImGui::SliderFloat3("Rotation", rot, -6.0f, 6.0f)) {
-                dirty = true;
+                //dirty = true;
             }
             if (ImGui::SliderFloat("Zoom", &zoom, -1.0f, 2.0f)) {
-                dirty = true;
+                //dirty = true;
             }
 
             if (dirty) {
                 static glm::mat4 projection = glm::perspective(45.0f, 1.0f, 0.1f, 2000.0f);
 
-                glm::mat4 scale = glm::scale(glm::mat4(1.0f), glm::vec3(zoom, zoom, zoom));
                 glm::mat4 rotateX = glm::rotate(glm::mat4(1.0f), rot[0], glm::vec3(1.0f, 0.0f, 0.0f));
                 glm::mat4 rotateY = glm::rotate(glm::mat4(1.0f), rot[1], glm::vec3(0.0f, 1.0f, 0.0f));
                 glm::mat4 rotateZ = glm::rotate(glm::mat4(1.0f), rot[2], glm::vec3(0.0f, 0.0f, 1.0f));
-                glm::mat4 rotate = rotateZ * rotateY * rotateX;
+                glm::mat4 rotate = rotateZ * rotateX * rotateY;
                 glm::mat4 translate = glm::translate(glm::mat4(1.0f), glm::vec3(pos[0], pos[1], pos[2]));
-                glm::mat4 view = glm::inverse(scale * rotate * translate);
-                MVP = projection * view;
+                //glm::mat4 view = glm::inverse(rotate * translate);
+                glm::mat4 view = rotate * translate;
+                glm::mat4 scale = glm::scale(glm::mat4(1.0f), glm::vec3(zoom, zoom, zoom));
+                MVP = projection * view * scale;
 
                 redraw = true;
                 dirty = false;

src/loader/Loader.cpp

 
 #include "global.h"
 #include "loader/Loader.h"
+#include "loader/LoaderTR1.h"
 #include "loader/LoaderTR2.h"
 #include "loader/LoaderTR3.h"
 
 std::unique_ptr<Loader> Loader::createLoader(std::string f) {
     LoaderVersion v = checkFile(f);
     switch (v) {
-        case TR_1:
         case TR_4:
         case TR_5:
         case TR_UNKNOWN:
             return nullptr;
 
+        case TR_1:
+            return std::unique_ptr<Loader>(new LoaderTR1());
+
         case TR_2:
             return std::unique_ptr<Loader>(new LoaderTR2());
 

src/loader/LoaderTR1.cpp

  */
 
 #include "global.h"
+#include "Game.h"
+#include "Log.h"
+#include "SoundManager.h"
+#include "World.h"
 #include "loader/LoaderTR1.h"
 
-LoaderTR1::LoaderTR1() {
+int LoaderTR1::load(std::string f) {
+    if (file.open(f) != 0) {
+        return 1; // Could not open file
+    }
+
+    uint32_t version = file.readU32();
+    if (version != 0x20) {
+        return 2; // Not a TR1 level?!
+    }
+
+    loadTextures();
+
+    file.seek(file.tell() + 4); // Unused value?
+
+    loadRooms();
+    loadFloorData();
+    loadMeshes();
+    loadMoveables();
+    loadStaticMeshes();
+    loadTextiles();
+    loadSprites();
+    loadCameras();
+    loadSoundSources();
+    loadBoxesOverlapsZones();
+    loadAnimatedTextures();
+    loadItems();
+
+    file.seek(file.tell() + 8192); // TODO light map!
+
+    loadPalette();
+    loadCinematicFrames();
+    loadDemoData();
+    loadSoundMap();
+    loadSoundDetails();
+    loadSoundSamples();
+    loadSampleIndices();
+
+    return 0;
 }
 
-LoaderTR1::~LoaderTR1() {
+void LoaderTR1::loadPalette() {
+    // Read the 8bit palette, 256 * 3 bytes, RGB
+    for (int i = 0; i < 256; i++) {
+        uint8_t r = file.readU8();
+        uint8_t g = file.readU8();
+        uint8_t b = file.readU8();
+
+        //! \fixme Hack to make everything brighter
+        static const uint8_t lightHackFactor = 3;
+        r *= lightHackFactor;
+        if (r > 255)
+            r = 255;
+        g *= lightHackFactor;
+        if (g > 255)
+            g = 255;
+        b *= lightHackFactor;
+        if (b > 255)
+            b = 255;
+
+        glm::vec4 c(r / 255.0f, g / 255.0f, b / 255.0f, 1.0f);
+        TextureManager::setPalette(i, c);
+    }
 }
 
-int LoaderTR1::load(std::string f) {
-    if (file.open(f.c_str()) != 0) {
-        return 1; // Could not open file
+void LoaderTR1::loadTextures() {
+    uint32_t numTextures = file.readU32();
+    for (unsigned int i = 0; i < numTextures; i++) {
+        std::array<uint8_t, 256 * 256> arr;
+        for (auto& x : arr) {
+            x = file.readU8(); // Palette index
+        }
+
+        TextureManager::addIndexedTexture(&arr[0], 256, 256);
+    }
+
+    if (numTextures > 0)
+        Log::get(LOG_INFO) << "LoaderTR1: Found " << numTextures << " Textures!" << Log::endl;
+    else
+        Log::get(LOG_INFO) << "LoaderTR1: No Textures in this level?!" << Log::endl;
+}
+
+void LoaderTR1::loadRoomLights() {
+    int16_t intensity = file.read16();
+
+    uint16_t numLights = file.readU16();
+    for (unsigned int l = 0; l < numLights; l++) {
+        // Position of light, in world coordinates
+        int32_t x = file.read32();
+        int32_t y = file.read32();
+        int32_t z = file.read32();
+
+        uint16_t intensity1 = file.readU16();
+        uint32_t fade = file.readU32(); // Falloff value?
+
+        // TODO store light somewhere
+    }
+}
+
+void LoaderTR1::loadRoomStaticMeshes(std::vector<StaticModel*>& staticModels) {
+    uint16_t numStaticMeshes = file.readU16();
+    for (unsigned int s = 0; s < numStaticMeshes; s++) {
+        // Absolute position in world coordinates
+        int32_t x = file.read32();
+        int32_t y = file.read32();
+        int32_t z = file.read32();
+
+        // High two bits (0xC000) indicate steps of
+        // 90 degrees (eg. (rotation >> 14) * 90)
+        uint16_t rotation = file.readU16();
+
+        // Constant lighting, 0xFFFF means use mesh lighting
+        //! \todo Use static mesh lighting information
+        uint16_t intensity1 = file.readU16();
+
+        // Which StaticMesh item to draw
+        uint16_t objectID = file.readU16();
+
+        staticModels.push_back(new StaticModel(glm::vec3(x, y, z),
+                                               glm::radians((rotation >> 14) * 90.0f),
+                                               objectID));
+    }
+}
+
+void LoaderTR1::loadRoomVertex(RoomVertexTR2& vert) {
+    vert.x = file.read16();
+    vert.y = file.read16();
+    vert.z = file.read16();
+    vert.light1 = file.read16();
+    vert.attributes = 0;
+    vert.light2 = vert.light1;
+}
+
+void LoaderTR1::loadItems() {
+    uint32_t numItems = file.readU32();
+    for (unsigned int i = 0; i < numItems; i++) {
+        int16_t objectID = file.read16();
+        int16_t room = file.read16();
+
+        // Item position in world coordinates
+        int32_t x = file.read32();
+        int32_t y = file.read32();
+        int32_t z = file.read32();
+
+        uint16_t angle = file.readU16(); // (0xC000 >> 14) * 90deg
+        int16_t intensity = file.read16(); // Constant lighting; -1 means mesh lighting
+
+        // 0x0100 - Initially visible
+        // 0x3E00 - Activation mask, open, can be XORed with related FloorData list fields.
+        uint16_t flags = file.readU16();
+
+        glm::vec3 pos(
+            static_cast<float>(x),
+            static_cast<float>(y),
+            static_cast<float>(z)
+        );
+
+        glm::vec3 rot(
+            0.0f,
+            glm::radians(((angle >> 14) & 0x03) * 90.0f),
+            0.0f
+        );
+
+        Entity* e = new Entity(objectID, room, pos, rot);
+        getWorld().addEntity(e);
+
+        if (objectID == 0) {
+            Game::setLara(getWorld().sizeEntity() - 1);
+        }
     }
 
+    if (numItems > 0)
+        Log::get(LOG_INFO) << "LoaderTR1: Found " << numItems << " Items!" << Log::endl;
+    else
+        Log::get(LOG_INFO) << "LoaderTR1: No Items in this level?!" << Log::endl;
+}
+
+void LoaderTR1::loadBoxesOverlapsZones() {
+    uint32_t numBoxes = file.readU32();
+    for (unsigned int b = 0; b < numBoxes; b++) {
+        // Sectors (not scaled!)
+        int32_t zMin = file.read32();
+        int32_t zMax = file.read32();
+        int32_t xMin = file.read32();
+        int32_t xMax = file.read32();
+
+        int16_t trueFloor = file.read16(); // Y value (no scaling)
 
+        // Index into overlaps[]. The high bit is sometimes set
+        // this occurs in front of swinging doors and the like
+        uint16_t overlapIndex = file.readU16();
+
+        // TODO store boxes somewhere
+    }
+
+    uint32_t numOverlaps = file.readU32();
+    std::vector<std::vector<uint16_t>> overlaps;
+    overlaps.emplace_back();
+    unsigned int list = 0;
+    for (unsigned int o = 0; o < numOverlaps; o++) {
+        // Apparently used by NPCs to decide where to go next.
+        // List of neighboring boxes for each box.
+        // Each entry is a uint16, 0x8000 set marks end of list.
+        uint16_t e = file.readU16();
+        overlaps.at(list).push_back(e);
+        if (e & 0x8000) {
+            overlaps.emplace_back();
+            list++;
+        }
+    }
+
+    // TODO store overlaps somewhere
+
+    for (unsigned int z = 0; z < numBoxes; z++) {
+        // Normal room state
+        int16_t ground1 = file.read16();
+        int16_t ground2 = file.read16();
+        int16_t fly = file.read16();
+
+        // Alternate room state
+        int16_t ground1alt = file.read16();
+        int16_t ground2alt = file.read16();
+        int16_t flyAlt = file.read16();
+
+        // TODO store zones somewhere
+    }
+
+    if ((numBoxes > 0) || (numOverlaps > 0))
+        Log::get(LOG_INFO) << "LoaderTR1: Found NPC NavigationHints (" << numBoxes
+                           << ", " << numOverlaps << ", " << list << "), unimplemented!" << Log::endl;
+    else
+        Log::get(LOG_INFO) << "LoaderTR1: No NPC NavigationHints in this level?!" << Log::endl;
+}
+
+void LoaderTR1::loadSoundMap() {
+    for (int i = 0; i < 256; i++) {
+        SoundManager::addSoundMapEntry(file.read16());
+    }
+}
+
+void LoaderTR1::loadSoundSamples() {
+    uint32_t soundSampleSize = file.readU32();
+    if (soundSampleSize <= 0) {
+        return;
+    }
+
+    std::vector<uint8_t> buffer;
+    for (int i = 0; i < soundSampleSize; i++) {
+        buffer.push_back(file.readU8());
+    }
+
+    char* tmpPtr = reinterpret_cast<char*>(&buffer[0]);
+    BinaryMemory sfx(tmpPtr, soundSampleSize);
+    loadSoundFiles(sfx);
+}
 
-    return 1; // stub
+int LoaderTR1::getPaletteIndex(uint16_t index) {
+    return index;
 }
 

src/loader/LoaderTR2.cpp

         return 2; // Not a TR2 level?!
     }
 
-    loadPaletteTextiles();
+    loadPalette();
+    loadTextures();
 
     file.seek(file.tell() + 4); // Unused value?
 
     loadMeshes();
     loadMoveables();
     loadStaticMeshes();
-    loadTextures();
+    loadTextiles();
     loadSprites();
     loadCameras();
     loadSoundSources();
 
 // ---- Textures ----
 
-void LoaderTR2::loadPaletteTextiles() {
+void LoaderTR2::loadPalette() {
     file.seek(file.tell() + 768); // Skip 8bit palette, 256 * 3 bytes
 
     // Read the 16bit palette, 256 * 4 bytes, RGBA, A unused
-    for (auto& x : palette)
-        x = file.readU32();
+    for (int i = 0; i < 256; i++) {
+        uint8_t r = file.readU8();
+        uint8_t g = file.readU8();
+        uint8_t b = file.readU8();
+        uint8_t a = file.readU8();
+
+        glm::vec4 c(r / 255.0f, g / 255.0f, b / 255.0f, 1.0f);
+        TextureManager::setPalette(i, c);
+    }
+}
 
-    uint32_t numTextiles = file.readU32();
+void LoaderTR2::loadTextures() {
+    uint32_t numTextures = file.readU32();
 
-    file.seek(file.tell() + (numTextiles * 256 * 256)); // Skip 8bit textiles
+    file.seek(file.tell() + (numTextures * 256 * 256)); // Skip 8bit textures
 
-    // Read the 16bit textiles, numTextiles * 256 * 256 * 2 bytes
-    for (unsigned int i = 0; i < numTextiles; i++) {
+    // Read the 16bit textures, numTextures * 256 * 256 * 2 bytes
+    for (unsigned int i = 0; i < numTextures; i++) {
         std::array<uint8_t, 256 * 256 * 2> arr;
         for (auto& x : arr) {
             x = file.readU8();
         }
 
-        // Convert 16bit textile to 32bit textile
+        // Convert 16bit textures to 32bit textures
         unsigned char* img = argb16to32(&arr[0], 256, 256);
         int r = TextureManager::loadBufferSlot(img, 256, 256,
                                                ColorMode::ARGB, 32,
         delete [] img;
     }
 
-    if (numTextiles > 0)
-        Log::get(LOG_INFO) << "LoaderTR2: Found " << numTextiles << " Textures!" << Log::endl;
+    if (numTextures > 0)
+        Log::get(LOG_INFO) << "LoaderTR2: Found " << numTextures << " Textures!" << Log::endl;
     else
         Log::get(LOG_INFO) << "LoaderTR2: No Textures in this level?!" << Log::endl;
 }
 
-void LoaderTR2::loadTextures() {
+void LoaderTR2::loadTextiles() {
     uint32_t numObjectTextures = file.readU32();
     for (unsigned int o = 0; o < numObjectTextures; o++) {
         // 0 means that a texture is all-opaque, and that transparency
         // calculated as the maximum of the individual color values.
         uint16_t attribute = file.readU16();
 
-        // Index into the textile list
+        // Index into the texture list
         uint16_t tile = file.readU16();
 
         TextureTile* t = new TextureTile(attribute, tile);
     }
 }
 
+void LoaderTR2::loadRoomStaticMeshes(std::vector<StaticModel*>& staticModels) {
+    uint16_t numStaticMeshes = file.readU16();
+    for (unsigned int s = 0; s < numStaticMeshes; s++) {
+        // Absolute position in world coordinates
+        int32_t x = file.read32();
+        int32_t y = file.read32();
+        int32_t z = file.read32();
+
+        // High two bits (0xC000) indicate steps of
+        // 90 degrees (eg. (rotation >> 14) * 90)
+        uint16_t rotation = file.readU16();
+
+        // Constant lighting, 0xFFFF means use mesh lighting
+        //! \todo Use static mesh lighting information
+        uint16_t intensity1 = file.readU16();
+        uint16_t intensity2 = file.readU16();
+
+        // Which StaticMesh item to draw
+        uint16_t objectID = file.readU16();
+
+        staticModels.push_back(new StaticModel(glm::vec3(x, y, z),
+                                               glm::radians((rotation >> 14) * 90.0f),
+                                               objectID));
+    }
+}
+
 void LoaderTR2::loadRoomDataEnd(int16_t& alternateRoom, unsigned int& roomFlags) {
     alternateRoom = file.read16();
 
     }
 }
 
+void LoaderTR2::loadRoomVertex(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();
+}
+
 void LoaderTR2::loadRooms() {
     uint16_t numRooms = file.readU16();
     for (unsigned int i = 0; i < numRooms; i++) {
         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();
+            loadRoomVertex(vert);
             vertices.push_back(vert);
 
             // Fill bounding box
 
         loadRoomLights();
 
-        uint16_t numStaticMeshes = file.readU16();
         std::vector<StaticModel*> staticModels;
-        for (unsigned int s = 0; s < numStaticMeshes; s++) {
-            // Absolute position in world coordinates
-            int32_t x = file.read32();
-            int32_t y = file.read32();
-            int32_t z = file.read32();
-
-            // High two bits (0xC000) indicate steps of
-            // 90 degrees (eg. (rotation >> 14) * 90)
-            uint16_t rotation = file.readU16();
-
-            // Constant lighting, 0xFFFF means use mesh lighting
-            uint16_t intensity1 = file.readU16();
-            uint16_t intensity2 = file.readU16();
-
-            // Which StaticMesh item to draw
-            uint16_t objectID = file.readU16();
-
-            staticModels.push_back(new StaticModel(glm::vec3(x, y, z),
-                                                   glm::radians((rotation >> 14) * 90.0f),
-                                                   objectID));
-        }
+        loadRoomStaticMeshes(staticModels);
 
         int16_t alternateRoom = -1;
         unsigned int roomFlags = 0;
 
 // ---- Meshes ----
 
+int LoaderTR2::getPaletteIndex(uint16_t index) {
+    return (index & 0xFF00) >> 8; // Use index into 16bit palette
+}
+
 void LoaderTR2::loadMeshes() {
     // Number of bitu16s of mesh data to follow
     // Read all the mesh data into a buffer, because
             uint16_t vertex4 = mem.readU16();
             uint16_t texture = mem.readU16();
 
-            int index = (texture & 0xFF00) >> 8;
-            uint8_t red = (palette.at(index) & 0xFF000000) >> 24,
-                    green = (palette.at(index) & 0x00FF0000) >> 16,
-                    blue = (palette.at(index) & 0x0000FF00) >> 8;
-
-            coloredRectangles.emplace_back(red, green, blue, vertex1, vertex2, vertex3, vertex4);
+            int index = getPaletteIndex(texture);
+            coloredRectangles.emplace_back(index, vertex1, vertex2, vertex3, vertex4);
         }
 
         int16_t numColoredTriangles = mem.read16();
             uint16_t vertex3 = mem.readU16();
             uint16_t texture = mem.readU16();
 
-            int index = (texture & 0xFF00) >> 8;
-            uint8_t red = (palette.at(index) & 0xFF000000) >> 24,
-                    green = (palette.at(index) & 0x00FF0000) >> 16,
-                    blue = (palette.at(index) & 0x0000FF00) >> 8;
-
-            coloredTriangles.emplace_back(red, green, blue, vertex1, vertex2, vertex3);
+            int index = getPaletteIndex(texture);
+            coloredTriangles.emplace_back(index, vertex1, vertex2, vertex3);
         }
 
         Mesh* mesh = new Mesh(vertices, texturedRectangles, texturedTriangles,
         pos.x = frame.read16();
         pos.y = frame.read16();
         pos.z = frame.read16();
+        // TODO frame data format different for TR1!
         BoneFrame* bf = new BoneFrame(pos);
 
         for (int i = 0; i < numMeshes; i++) {
         return;
     }
 
+    loadSoundFiles(sfx);
+}
+
+void LoaderTR2::loadSoundFiles(BinaryReader& sfx) {
     int riffCount = 0;
     while (!sfx.eof()) {
         char test[5];
     }
 
     if (riffCount > 0)
-        Log::get(LOG_INFO) << "LoaderTR2: Found " << riffCount << " SoundSamples in SFX" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: Loaded " << riffCount << " SoundSamples" << Log::endl;
     else
-        Log::get(LOG_INFO) << "LoaderTR2: No SoundSamples in SFX?!" << Log::endl;
+        Log::get(LOG_INFO) << "LoaderTR2: No SoundSamples found!" << Log::endl;
 }
 
 // ---- Stuff ----

src/loader/LoaderTR3.cpp

         return 2; // Not a TR3 level?!
     }
 
-    loadPaletteTextiles();
+    loadPalette();
+    loadTextures();
 
     file.seek(file.tell() + 4); // Unused value?
 
     loadSoundSources();
     loadBoxesOverlapsZones();
     loadAnimatedTextures();
-    loadTextures();
+    loadTextiles();
     loadItems();
 
     file.seek(file.tell() + 8192); // Skip Light map, only for 8bit coloring

src/system/Shader.cpp

 
 // ----------------------------------------------------------------------------
 
-static int loadBufferSlot(unsigned char* image = nullptr,
-                          unsigned int width = 256, unsigned int height = 256,
-                          ColorMode mode = ColorMode::RGBA, unsigned int bpp = 32,
-                          TextureStorage s = TextureStorage::GAME,
-                          int slot = -1, bool filter = true);
-
 ShaderTexture::ShaderTexture(int w, int h) : width(w), height(h) {
     glGenFramebuffers(1, &framebuffer);
     bind();
         glViewport(0, 0, Window::getSize().x, Window::getSize().y);
     } else {
         target->bind();
+
+        unsigned int sz = vertices.getSize();
+        glm::vec3* buffer = new glm::vec3[sz];
+    glBindBuffer(GL_ARRAY_BUFFER, vertices.getBuffer());
+        glGetBufferSubData(GL_ARRAY_BUFFER, 0, sz * sizeof(glm::vec3), buffer);
+
+        Log::get(LOG_DEBUG) << "drawGL Vertex dump:" << Log::endl;
+        for (unsigned int i = 0; i < sz; i++) {
+            glm::vec4 tmp(buffer[i], 1.0f);
+            tmp = MVP * tmp;
+            glm::vec3 res(tmp.x, tmp.y, tmp.z);
+            Log::get(LOG_DEBUG) << buffer[i] << " -> " << res << Log::endl;
+        }
+
+        delete [] buffer;
     }
 
     shader.use();

src/utils/binary.cpp

 // ----------------------------------------------------------------------------
 
 BinaryFile::BinaryFile(std::string f) {
-    assert(open(f) == 0);
+    assertEqual(open(f), 0);
 }
 
 BinaryFile::~BinaryFile() {
 // ----------------------------------------------------------------------------
 
 BinaryMemory::BinaryMemory(const char* d, long long m) : data(nullptr), offset(0), max(-1) {
-    assert(open(d, m) == 0);
+    assertEqual(open(d, m), 0);
 }
 
 BinaryMemory::~BinaryMemory() {
 }
 
 long long BinaryMemory::tell() {
-    assert(offset >= 0);
+    assertGreaterThanEqual(offset, 0);
     return offset;
 }
 
 void BinaryMemory::seek(long long pos) {
-    assert(pos >= 0);
+    assertGreaterThanEqual(pos, 0);
     offset = pos;
 }
 
 bool BinaryMemory::eof() {
-    return (offset > max);
+    return (offset >= max);
 }
 
 void BinaryMemory::read(char* d, int c) {
-    assert(offset >= 0);
-    assert(c > 0);
-    assert((offset + c) <= max);
+    assertGreaterThanEqual(offset, 0);
+    assertGreaterThan(c, 0);
+    assertLessThanEqual(offset + c, max);
     for (int i = 0; i < c; i++) {
         d[i] = data[offset + i];
     }