TR3 level loader, assert macros

ChangeLog.md

     * The menu can be navigated using a controller
     * Vertical camera rotation is now also clamped when using a controller
     * Worked on rendering SkeletalModels, not yet working correctly
+    * Implemented level loader for TR3, but tries to access invalid textiles
 
     [ 20140211 ]
     * Updated imgui to version 1.32

include/RoomData.h

     }
 
     glm::vec3 getCorner(int i) {
-        assert((i >= 0) && (i < 8));
+        assertGreaterThanEqual(i, 0);
+        assertLessThan(i, 8);
         return corner[i];
     }
 
     }
     int getAdjoiningRoom() { return adjoiningRoom; }
     glm::vec3 getNormal() { return normal; }
-    glm::vec3 getVertex(int i) { assert((i >= 0) && (i < 4)); return vert[i]; }
+
+    glm::vec3 getVertex(int i) {
+        assertGreaterThanEqual(i, 0);
+        assertLessThan(i, 4);
+        return vert[i];
+    }
 
   private:
     int adjoiningRoom;

include/global.h

     std::cout << std::endl << "assertion failed:" << std::endl;
     std::cout << "\t" << exp << std::endl;
     if (print)
-        std::cout << "\t (" << a << " " << str << " " << b << ")" << std::endl;
+        std::cout << "\t(" << a << " " << str << " " << b << ")" << std::endl;
     std::cout << "in " << file << ":" << line << std::endl << std::endl;
 
     for (int i = 0; i < frames; i++)
                                   __FILE__, __LINE__, true, "=="); \
 }
 
+#define assertLessThan(x, y) { \
+    auto assertEvalTemp = x; \
+    auto assertEvalTemp2 = y; \
+    if (assertEvalTemp >= assertEvalTemp2) \
+        assertEqualImplementation(#x " < " #y, assertEvalTemp, assertEvalTemp2, \
+                                  __FILE__, __LINE__, true, ">="); \
+}
+
+#define assertLessThanEqual(x, y) { \
+    auto assertEvalTemp = x; \
+    auto assertEvalTemp2 = y; \
+    if (assertEvalTemp > assertEvalTemp2) \
+        assertEqualImplementation(#x " <= " #y, assertEvalTemp, assertEvalTemp2, \
+                                  __FILE__, __LINE__, true, ">"); \
+}
+
+#define assertGreaterThan(x, y) { \
+    auto assertEvalTemp = x; \
+    auto assertEvalTemp2 = y; \
+    if (assertEvalTemp <= assertEvalTemp2) \
+        assertEqualImplementation(#x " > " #y, assertEvalTemp, assertEvalTemp2, \
+                                  __FILE__, __LINE__, true, "<="); \
+}
+
+#define assertGreaterThanEqual(x, y) { \
+    auto assertEvalTemp = x; \
+    auto assertEvalTemp2 = y; \
+    if (assertEvalTemp < assertEvalTemp2) \
+        assertEqualImplementation(#x " >= " #y, assertEvalTemp, assertEvalTemp2, \
+                                  __FILE__, __LINE__, true, "<"); \
+}
+
 #else // NODEBUG
 
 #define assert(x)
 #define assertEqual(x, y)
 #define assertNotEqual(x, y)
+#define assertLessThan(x, y)
+#define assertLessThanEqual(x, y)
+#define assertGreaterThan(x, y)
+#define assertGreaterThanEqual(x, y)
 
 #endif // NODEBUG
 
 #include <cassert>
 #define assertEqual(x, y) assert((x) == (y))
 #define assertNotEqual(x, y) assert((x) != (y))
+#define assertLessThan(x, y) assert((x) < (y))
+#define assertLessThanEqual(x, y) assert((x) <= (y))
+#define assertGreaterThan(x, y) assert((x) > (y))
+#define assertGreaterThanEqual(x, y) assert((x) >= (y))
 
 #endif // EXECINFO
 

include/loader/Loader.h

 
 class Loader {
   public:
-
     typedef enum {
         TR_UNKNOWN = 0,
         TR_1 = 1,
     } LoaderVersion;
 
     static LoaderVersion checkFile(std::string f);
-
     static std::unique_ptr<Loader> createLoader(std::string f);
 
-    virtual ~Loader();
-
     virtual int load(std::string f) = 0;
 
   protected:

include/loader/LoaderTR2.h

 
 class LoaderTR2 : public Loader {
   public:
-    LoaderTR2();
-    virtual ~LoaderTR2();
-
     virtual int load(std::string f);
 
-  private:
-    void loadPaletteTextiles();
-    void loadRooms();
-    void loadFloorData();
-    void loadMeshes();
-    void loadMoveables();
-    void loadStaticMeshes();
-    void loadTextures();
-    void loadSprites();
-    void loadCameras();
-    void loadSoundSources();
-    void loadBoxesOverlapsZones();
-    void loadAnimatedTextures();
-    void loadItems();
-    void loadCinematicFrames();
-    void loadDemoData();
-    void loadSoundMap();
-    void loadSoundDetails();
-    void loadSampleIndices();
-
-    void loadExternalSoundFile(std::string f);
+  protected:
+    virtual void loadPaletteTextiles();
+    virtual void loadRoomLights();
+    virtual void loadRoomDataEnd(int16_t& alternateRoom, unsigned int& roomFlags);
+    virtual void loadRooms();
+    virtual void loadFloorData();
+    virtual void loadMeshes();
+    virtual void loadMoveables();
+    virtual void loadStaticMeshes();
+    virtual void loadTextures();
+    virtual void loadSprites();
+    virtual void loadCameras();
+    virtual void loadSoundSources();
+    virtual void loadBoxesOverlapsZones();
+    virtual void loadAnimatedTextures();
+    virtual void loadItems();
+    virtual void loadCinematicFrames();
+    virtual void loadDemoData();
+    virtual void loadSoundMap();
+    virtual void loadSoundDetails();
+    virtual void loadSampleIndices();
+
+    virtual void loadExternalSoundFile(std::string f);
 
     std::array<uint32_t, 256> palette;
 };

include/loader/LoaderTR3.h

 #ifndef _LOADER_LOADER_TR3_H_
 #define _LOADER_LOADER_TR3_H_
 
-#include "loader/Loader.h"
+#include "loader/LoaderTR2.h"
 
-class LoaderTR3 : public Loader {
+class LoaderTR3 : public LoaderTR2 {
   public:
-    LoaderTR3();
-    virtual ~LoaderTR3();
-
     virtual int load(std::string f);
 
-  private:
-
+  protected:
+    virtual void loadRoomLights();
+    virtual void loadRoomDataEnd(int16_t& alternateRoom, unsigned int& roomFlags);
 };
 
 #endif

src/Console.cpp

         for (unsigned long i = 0; i < Log::size(); i++) {
             auto& entry = Log::getEntry(i);
 
-            assert(entry.level < LOG_COUNT);
+            assertLessThan(entry.level, LOG_COUNT);
             if (!visibleLogs[entry.level]) {
                 continue;
             }

src/Entity.cpp

             }
         }
 
-        assert(cache > -1);
-        assert(cacheType > -1);
+        assertGreaterThan(cache, -1);
+        assertGreaterThan(cacheType, -1);
     }
 
     glm::mat4 translate = glm::translate(glm::mat4(1.0f), glm::vec3(pos.x, -pos.y, pos.z));

src/Game.cpp

 }
 
 void Game::handleAction(ActionEvents action, bool isFinished) {
-    assert(action < ActionEventCount);
+    assertLessThan(action, ActionEventCount);
 
     if (!mLoaded)
         return;
 }
 
 Entity& Game::getLara() {
-    assert(mLara >= 0);
-    assert(mLara < (int)getWorld().sizeEntity());
+    assertGreaterThanEqual(mLara, 0);
+    assertLessThan(mLara, getWorld().sizeEntity());
     return getWorld().getEntity(mLara);
 }
 
 void Game::setLara(long lara) {
-    assert(lara >= 0);
-    assert(lara < getWorld().sizeEntity());
+    assertGreaterThanEqual(lara, 0);
+    assertLessThan(lara, getWorld().sizeEntity());
     mLara = lara;
 }
 

src/Log.cpp

 std::vector<LogEntry> Log::wholeLog;
 
 LogLevel& Log::get(int level) {
-    assert(level >= 0);
-    assert(level < LOG_COUNT);
+    assertGreaterThanEqual(level, 0);
+    assertLessThan(level, LOG_COUNT);
     return logs[level];
 }
 

src/Menu.cpp

 void Menu::showDialog(std::string msg, std::string btn1, std::string btn2,
                       std::function<int (bool state)> callback) {
     // Only show one dialog at a time
-    assert(dialogText.length() == 0);
-    assert(dialogButton1.length() == 0);
-    assert(dialogButton2.length() == 0);
+    assertEqual(dialogText.length(), 0);
+    assertEqual(dialogButton1.length(), 0);
+    assertEqual(dialogButton2.length(), 0);
 
-    assert(msg.length() > 0);
-    assert(btn1.length() > 0);
+    assertGreaterThan(msg.length(), 0);
+    assertGreaterThan(btn1.length(), 0);
 
     dialogText = msg;
     dialogButton1 = btn1;
             w0 = wMax;
         unsigned int h0 =  Font::heightText(1.0f, w0, dialogText) + 10;
 
-        assert(dialogButton1.length() > 0);
+        assertGreaterThan(dialogButton1.length(), 0);
         unsigned int w1 = Font::widthText(1.0f, dialogButton1) + 20;
         if (w1 > wMax)
             w1 = wMax;

src/Mesh.cpp

         vertIndex += (indicesBuff.at(i) == 0) ? 4 : 3;
     }
 
-    assert((ind.size() % 3) == 0);
-    assert(vert.size() == tex.size());
-    assert(vert.size() == uvBuff.size());
+    assertEqual(ind.size() % 3, 0);
+    assertEqual(vert.size(), tex.size());
+    assertEqual(vert.size(), uvBuff.size());
 
     indicesBuff = std::move(ind);
     vertices.bufferData(vert);
         vertIndex += (indicesColorBuff.at(i) == 0) ? 4 : 3;
     }
 
-    assert((indCol.size() % 3) == 0);
-    assert(vertCol.size() == cols.size());
+    assertEqual(indCol.size() % 3, 0);
+    assertEqual(vertCol.size(), cols.size());
 
     indicesColor.bufferData(indCol);
     verticesColor.bufferData(vertCol);

src/Room.cpp

 }
 
 bool Room::isWall(unsigned long sector) {
-    assert(sector < sectors.size());
+    assertLessThan(sector, sectors.size());
 
     //! \fixme is (sector > 0) correct??
     return ((sector > 0) && sectors.at(sector)->isWall());

src/RoomData.cpp

                 cache = i;
             }
         }
-        assert(cache >= 0);
+        assertGreaterThanEqual(cache, 0);
     }
 
     getWorld().getStaticMesh(cache).display(VP * model);

src/RoomMesh.cpp

         vertIndex += (indicesBuff.at(i) == 0) ? 4 : 3;
     }
 
-    assert((ind.size() % 3) == 0);
-    assert(vert.size() == tex.size());
-    assert(vert.size() == uvBuff.size());
+    assertEqual(ind.size() % 3, 0);
+    assertEqual(vert.size(), tex.size());
+    assertEqual(vert.size(), uvBuff.size());
 
     indicesBuff = std::move(ind);
     vertices.bufferData(vert);

src/RunTime.cpp

 }
 
 KeyboardButton RunTime::getKeyBinding(ActionEvents event) {
-    assert(event < ActionEventCount);
+    assertLessThan(event, ActionEventCount);
     return keyBindings[event];
 }
 
 void RunTime::setKeyBinding(ActionEvents event, KeyboardButton button) {
-    assert(event < ActionEventCount);
+    assertLessThan(event, ActionEventCount);
     keyBindings[event] = button;
 }
 

src/Script.cpp

 }
 
 std::string Script::getLevelName(unsigned int i) {
-    assert(i < numLevels);
+    assertLessThan(i, numLevels);
     return levelNames.at(i);
 }
 
 std::string Script::getLevelFilename(unsigned int i) {
-    assert(i < numLevels);
+    assertLessThan(i, numLevels);
     return levelFilenames.at(i);
 }
 
 }
 
 std::string Script::getPictureFilename(unsigned int i) {
-    assert(i < numPictures);
+    assertLessThan(i, numPictures);
     return pictureFilenames.at(i);
 }
 
 }
 
 std::string Script::getCutsceneFilename(unsigned int i) {
-    assert(i < numCutscenes);
+    assertLessThan(i, numCutscenes);
     return cutsceneFilenames.at(i);
 }
 
 }
 
 std::string Script::getTitleFilename(unsigned int i) {
-    assert(i < numTitles);
+    assertLessThan(i, numTitles);
     return titleFilenames.at(i);
 }
 
 }
 
 std::string Script::getVideoFilename(unsigned int i) {
-    assert(i < numFMVs);
+    assertLessThan(i, numFMVs);
     return fmvFilenames.at(i);
 }
 
 }
 
 std::string Script::getGameString(unsigned int i) {
-    assert(i < numGameStrings);
+    assertLessThan(i, numGameStrings);
     return gameStrings.at(i);
 }
 
 }
 
 std::string Script::getPCString(unsigned int i) {
-    assert(i < numPCStrings);
+    assertLessThan(i, numPCStrings);
     return pcStrings.at(i);
 }
 
 std::string Script::getPuzzleString(unsigned int i, unsigned int j) {
-    assert(i < 4);
-    assert(j < numLevels);
+    assertLessThan(i, 4);
+    assertLessThan(j, numLevels);
     return puzzles.at(i).at(j);
 }
 
 std::string Script::getPickupString(unsigned int i, unsigned int j) {
-    assert(i < 2);
-    assert(j < numLevels);
+    assertLessThan(i, 2);
+    assertLessThan(j, numLevels);
     return pickups.at(i).at(j);
 }
 
 std::string Script::getKeyString(unsigned int i, unsigned int j) {
-    assert(i < 4);
-    assert(j < numLevels);
+    assertLessThan(i, 4);
+    assertLessThan(j, numLevels);
     return keys.at(i).at(j);
 }
 
 void Script::registerScriptHandler(ScriptOpCode op, std::function<int (bool, uint16_t)> func) {
-    assert(op < OP_UNKNOWN);
+    assertLessThan(op, OP_UNKNOWN);
     scriptHandlers[op] = func;
 }
 
 int Script::runScript(unsigned int level) {
-    assert(level < (numLevels + 1));
+    assertLessThan(level, (numLevels + 1));
     std::vector<uint16_t> s = script.at(level);
 
     for (unsigned int i = 0; i < s.size(); i++) {

src/SkeletalModel.cpp

 }
 
 BoneTag& BoneFrame::get(unsigned long i) {
-    assert(i < tag.size());
+    assertLessThan(i, tag.size());
     return *tag.at(i);
 }
 
 }
 
 BoneFrame& AnimationFrame::get(unsigned long i) {
-    assert(i < frame.size());
+    assertLessThan(i, frame.size());
     return *frame.at(i);
 }
 
     MatrixStack(glm::mat4 start) : startVal(start) { stack.push_back(startVal); }
 
     void push() {
-        //assert(stack.size() > 0);
+        //assertGreaterThan(stack.size(), 0);
         if (stack.size() > 0)
             stack.push_back(stack.at(stack.size() - 1));
     }
 
     void pop() {
-        //assert(stack.size() > 0);
+        //assertGreaterThan(stack.size(), 0);
         if (stack.size() > 0)
             stack.pop_back();
     }
 
     glm::mat4 get() {
-        //assert(stack.size() > 0);
+        //assertGreaterThan(stack.size(), 0);
         if (stack.size() > 0)
             return stack.at(stack.size() - 1);
         return startVal;
 #endif
 
 void SkeletalModel::display(glm::mat4 MVP, int aframe, int bframe) {
-    assert(aframe < size());
-    assert(bframe < get(aframe).size());
+    assertLessThan(aframe, size());
+    assertLessThan(bframe, get(aframe).size());
 
     AnimationFrame& anim = get(aframe);
     BoneFrame& boneframe = anim.get(bframe);
 }
 
 AnimationFrame& SkeletalModel::get(unsigned long i) {
-    assert(i < animation.size());
+    assertLessThan(i, animation.size());
     return *animation.at(i);
 }
 

src/SoundManager.cpp

         float vol;
         int index = getIndex(soundSources.at(i).id, &vol);
         int ret = Sound::addSource(index, vol, false, true);
-        assert(ret == i);
+        assertEqual(ret, i);
         float pos[3] = { soundSources.at(i).x, soundSources.at(i).y, soundSources.at(i).z };
         ret = Sound::sourceAt(i, pos);
-        assert(ret == 0);
+        assertEqual(ret, 0);
         Sound::play(i, false);
     }
 
         int index = getIndex(i, &vol);
         if ((index >= 0) && (index < Sound::numBuffers())) {
             int ret = Sound::addSource(index, vol, true, false);
-            assert(ret >= 0);
+            assertGreaterThanEqual(ret, 0);
         }
     }
 }

src/Sprite.cpp

 // ----------------------------------------------------------------------------
 
 void SpriteSequence::display(glm::mat4 MVP, int index) {
-    assert(index >= 0);
-    assert(index < length);
+    assertGreaterThanEqual(index, 0);
+    assertLessThan(index, length);
     getWorld().getSprite(start + index).display(MVP);
 }
 

src/TextureManager.cpp

 std::vector<BufferManager> TextureManager::systemBuffers;
 
 int TextureManager::initialize() {
-    assert(mTextureIdsGame.size() == 0);
-    assert(mTextureIdsSystem.size() == 0);
+    assertEqual(mTextureIdsGame.size(), 0);
+    assertEqual(mTextureIdsSystem.size(), 0);
 
     while (mTextureIdsSystem.size() < 2) {
         unsigned int id;
                                    unsigned int width, unsigned int height,
                                    ColorMode mode, unsigned int bpp,
                                    TextureStorage s, int slot, bool filter) {
-    assert(width > 0);
-    assert(height > 0);
+    assertGreaterThan(width, 0);
+    assertGreaterThan(height, 0);
     assert((mode == ColorMode::RGB)
            || (mode == ColorMode::BGR)
            || (mode == ColorMode::ARGB)
 }
 
 void TextureManager::bindTextureId(unsigned int n, TextureStorage s, unsigned int unit) {
-    assert(n < getIds(s).size());
-    assert(unit < 80); //! \todo Query GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS
+    assertLessThan(n, getIds(s).size());
+    assertLessThan(unit, 80); //! \todo Query GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS
 
     glActiveTexture(GL_TEXTURE0 + unit);
     glBindTexture(GL_TEXTURE_2D, getIds(s).at(n));
 }
 
 int TextureManager::bindTexture(unsigned int n, TextureStorage s) {
-    assert(n < getIds(s).size());
+    assertLessThan(n, getIds(s).size());
 
     if ((n < getUnits(s).size()) && (getUnits(s).at(n) >= 0)) {
         bindTextureId(n, s, getUnits(s).at(n));
 }
 
 TextureTile& TextureManager::getTile(int index) {
-    assert(index >= 0);
-    assert(index < tiles.size());
+    assertGreaterThanEqual(index, 0);
+    assertLessThan(index, tiles.size());
     return *tiles.at(index);
 }
 
 }
 
 int TextureManager::getFirstTileAnimation(int index) {
-    assert(index < animations.size());
-    assert(animations.at(index).size() > 0);
+    assertLessThan(index, animations.size());
+    assertGreaterThan(animations.at(index).size(), 0);
     return animations.at(index).at(0);
 }
 
 int TextureManager::getNextTileAnimation(int index, int tile) {
-    assert(index < animations.size());
+    assertLessThan(index, animations.size());
     for (int i = 0; i < animations.at(index).size(); i++) {
         if (animations.at(index).at(i) == tile) {
             if (i < (animations.at(index).size() - 1))

src/World.cpp

 }
 
 Room& World::getRoom(unsigned long index) {
-    assert(index < mRooms.size());
+    assertLessThan(index, mRooms.size());
     return *mRooms.at(index);
 }
 
 }
 
 Sprite& World::getSprite(unsigned long index) {
-    assert(index < mSprites.size());
+    assertLessThan(index, mSprites.size());
     return *mSprites.at(index);
 }
 
 }
 
 SpriteSequence& World::getSpriteSequence(unsigned long index) {
-    assert(index < mSpriteSequences.size());
+    assertLessThan(index, mSpriteSequences.size());
     return *mSpriteSequences.at(index);
 }
 
 }
 
 Entity& World::getEntity(unsigned long index) {
-    assert(index < mEntities.size());
+    assertLessThan(index, mEntities.size());
     return *mEntities.at(index);
 }
 
 }
 
 SkeletalModel& World::getSkeletalModel(unsigned long index) {
-    assert(index < mModels.size());
+    assertLessThan(index, mModels.size());
     return *mModels.at(index);
 }
 
 }
 
 StaticMesh& World::getStaticMesh(unsigned long index) {
-    assert(index < mStaticMeshes.size());
+    assertLessThan(index, mStaticMeshes.size());
     return *mStaticMeshes.at(index);
 }
 
 }
 
 Mesh& World::getMesh(unsigned long index) {
-    assert(index < mMeshes.size());
+    assertLessThan(index, mMeshes.size());
     return *mMeshes.at(index);
 }
 

src/commands/Command.cpp

 }
 
 int Command::command(std::string c) {
-    assert(commands.size() > 0);
-
     // Remove comment, if any
     size_t comment = c.find_first_of('#');
     if (comment != std::string::npos)

src/loader/Loader.cpp

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

src/loader/LoaderTR2.cpp

 
 #include <glm/gtc/matrix_transform.hpp>
 
-LoaderTR2::LoaderTR2() {
-}
-
-LoaderTR2::~LoaderTR2() {
-}
-
 int LoaderTR2::load(std::string f) {
     if (file.open(f) != 0) {
         return 1; // Could not open file
         int r = TextureManager::loadBufferSlot(img, 256, 256,
                                                ColorMode::ARGB, 32,
                                                TextureStorage::GAME, i);
-        assert(r >= 0); //! \fixme properly handle error when texture could not be loaded!
+        assertGreaterThanEqual(r, 0); //! \fixme properly handle error when texture could not be loaded!
         delete [] img;
     }
 
     for (unsigned int o = 0; o < numObjectTextures; o++) {
         // 0 means that a texture is all-opaque, and that transparency
         // information is ignored.
+        //
         // 1 means that transparency information is used. In 8-bit color,
         // index 0 is the transparent color, while in 16-bit color, the
         // top bit (0x8000) is the alpha channel (1 = opaque, 0 = transparent)
+        //
+        // 2 (TR3 only) means that the opacity (alpha) is equal to the intensity;
+        // the brighter the color, the more opaque it is. The intensity is probably
+        // calculated as the maximum of the individual color values.
         uint16_t attribute = file.readU16();
 
         // Index into the textile list
 
 // ---- Rooms ----
 
+void LoaderTR2::loadRoomLights() {
+    int16_t intensity1 = file.read16();
+    int16_t intensity2 = file.read16();
+    int16_t lightMode = 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();
+        uint16_t intensity2 = file.readU16(); // Almost always equal to intensity1
+
+        uint32_t fade1 = file.readU32(); // Falloff value?
+        uint32_t fade2 = file.readU32(); // Falloff value?
+
+        // TODO store light somewhere
+    }
+}
+
+void LoaderTR2::loadRoomDataEnd(int16_t& alternateRoom, unsigned int& roomFlags) {
+    alternateRoom = file.read16();
+
+    uint16_t flags = file.readU16();
+    roomFlags = 0;
+    if (flags & 0x0001) {
+        roomFlags |= RoomFlagUnderWater;
+    }
+}
+
 void LoaderTR2::loadRooms() {
     uint16_t numRooms = file.readU16();
     for (unsigned int i = 0; i < numRooms; i++) {
             uint8_t roomAbove = file.readU8(); // 0xFF if none
             int8_t ceiling = file.read8(); // Absolute height of ceiling (/ 256)
 
+            // In TR3 indexBox is more complicated. Only bits 4-14 are the 'real' index.
+            // Bits 0-3 are most likely some kind of flag (footstep sound?).
+            // There is a special value of the 'real' index, 2047 or 0x7FF.
+
             bool wall = false;
             if ((((uint8_t)floor) == 0x81) || (((uint8_t)ceiling) == 0x81)) {
                 wall = true;
             // TODO store sectors
         }
 
-        int16_t intensity1 = file.read16();
-        int16_t intensity2 = file.read16();
-        int16_t lightMode = 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();
-            uint16_t intensity2 = file.readU16(); // Almost always equal to intensity1
-
-            uint32_t fade1 = file.readU32(); // Falloff value?
-            uint32_t fade2 = file.readU32(); // Falloff value?
-
-            // TODO store light somewhere
-        }
+        loadRoomLights();
 
         uint16_t numStaticMeshes = file.readU16();
         std::vector<StaticModel*> staticModels;
                                                    objectID));
         }
 
-        int16_t alternateRoom = file.read16();
-
-        uint16_t flags = file.readU16();
+        int16_t alternateRoom = -1;
         unsigned int roomFlags = 0;
-        if (flags & 0x0001) {
-            roomFlags |= RoomFlagUnderWater;
-        }
+        loadRoomDataEnd(alternateRoom, roomFlags);
 
         BoundingBox* boundingbox = new BoundingBox(bbox[0], bbox[1]);
         RoomMesh* mesh = new RoomMesh(vertices, rectangles, triangles);
         int16_t negativeLength = file.read16(); // Negative sprite count
         int16_t offset = file.read16(); // Where sequence starts in sprite texture list
 
-        assert(negativeLength < 0);
-        assert(offset >= 0);
-        assert((offset + (negativeLength * -1)) <= numSpriteTextures);
+        assertLessThan(negativeLength, 0);
+        assertGreaterThanEqual(offset, 0);
+        assertLessThanEqual(offset + (negativeLength * -1), numSpriteTextures);
 
         SpriteSequence* ss = new SpriteSequence(objectID, offset, (negativeLength * -1));
         getWorld().addSpriteSequence(ss);
             buff[i] = sfx.readU8();
 
         int ret = Sound::loadBuffer(buff, riffSize + 8);
-        assert(ret >= 0);
+        assertGreaterThanEqual(ret, 0);
 
         riffCount++;
     }

src/loader/LoaderTR3.cpp

 #include "global.h"
 #include "loader/LoaderTR3.h"
 
-LoaderTR3::LoaderTR3() {
-}
+int LoaderTR3::load(std::string f) {
+    if (file.open(f) != 0) {
+        return 1; // Could not open file
+    }
+
+    uint32_t version = file.readU32();
+    if ((version != 0xFF080038) && (version != 0xFF180038)) {
+        return 2; // Not a TR3 level?!
+    }
+
+    loadPaletteTextiles();
+
+    file.seek(file.tell() + 4); // Unused value?
+
+    loadRooms();
+    loadFloorData();
+    loadMeshes();
+    loadMoveables();
+    loadStaticMeshes();
+    loadSprites();
+    loadCameras();
+    loadSoundSources();
+    loadBoxesOverlapsZones();
+    loadAnimatedTextures();
+    loadTextures();
+    loadItems();
+
+    file.seek(file.tell() + 8192); // Skip Light map, only for 8bit coloring
 
-LoaderTR3::~LoaderTR3() {
+    loadCinematicFrames();
+    loadDemoData();
+    loadSoundMap();
+    loadSoundDetails();
+    loadSampleIndices();
+
+    loadExternalSoundFile(f);
+
+    // TODO load TR3 PC version CDAUDIO.WAD file
+    // TODO load TR3 Mac version CDAudio.db and WAV files
+
+    return 0;
 }
 
-int LoaderTR3::load(std::string f) {
-    if (file.open(f.c_str()) != 0) {
-        return 1; // Could not open file
+void LoaderTR3::loadRoomLights() {
+    int16_t intensity1 = file.read16();
+    int16_t intensity2 = 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();
+        uint16_t intensity2 = file.readU16(); // Almost always equal to intensity1
+
+        uint32_t fade1 = file.readU32(); // Falloff value?
+        uint32_t fade2 = file.readU32(); // Falloff value?
+
+        // TODO store light somewhere
     }
+}
 
+void LoaderTR3::loadRoomDataEnd(int16_t& alternateRoom, unsigned int& roomFlags) {
+    LoaderTR2::loadRoomDataEnd(alternateRoom, roomFlags);
 
+    uint8_t r = file.readU8();
+    uint8_t g = file.readU8();
+    uint8_t b = file.readU8();
 
-    return 1; // stub
+    // TODO store room-light color (?) somewhere
 }
 

src/utils/random.cpp

     if (max == min)
         return max;
 
-    assert(max > min);
+    assertGreaterThan(max, min);
 
     if (!engineIsSeeded) {
         engine.seed(std::chrono::system_clock::now().time_since_epoch().count());