TR3 level loader, assert macros

ChangeLog.md

@@ -6,6 +6,7 @@
     * 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

@@ -35,7 +35,8 @@ class BoundingBox {
     }
 
     glm::vec3 getCorner(int i) {
-        assert((i >= 0) && (i < 8));
+        assertGreaterThanEqual(i, 0);
+        assertLessThan(i, 8);
         return corner[i];
     }
 
@@ -81,7 +82,12 @@ class Portal {
     }
     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

@@ -115,7 +115,7 @@ template<typename T, typename U>
     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++)
@@ -150,11 +150,47 @@ template<typename T, typename U>
                                   __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
 
@@ -164,6 +200,10 @@ template<typename T, typename U>
 #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

@@ -16,7 +16,6 @@
 
 class Loader {
   public:
-
     typedef enum {
         TR_UNKNOWN = 0,
         TR_1 = 1,
@@ -27,11 +26,8 @@ class Loader {
     } 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

@@ -15,32 +15,31 @@
 
 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

@@ -8,17 +8,15 @@
 #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

@@ -110,7 +110,7 @@ void Console::display() {
         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

@@ -50,8 +50,8 @@ void Entity::display(glm::mat4 VP) {
             }
         }
 
-        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

@@ -81,7 +81,7 @@ int Game::loadLevel(const char* level) {
 }
 
 void Game::handleAction(ActionEvents action, bool isFinished) {
-    assert(action < ActionEventCount);
+    assertLessThan(action, ActionEventCount);
 
     if (!mLoaded)
         return;
@@ -112,14 +112,14 @@ void Game::handleControllerAxis(float value, KeyboardButton axis) {
 }
 
 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

@@ -12,8 +12,8 @@ LogLevel Log::logs[LOG_COUNT] = { 0, 1, 2, 3, 4 };
 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

@@ -14,12 +14,12 @@
 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;
@@ -93,7 +93,7 @@ void Menu::displayDialog() {
             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

@@ -78,9 +78,9 @@ void Mesh::prepare() {
         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);
@@ -112,8 +112,8 @@ void Mesh::prepare() {
         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

@@ -46,7 +46,7 @@ void Room::display(glm::mat4 VP) {
 }
 
 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

@@ -76,7 +76,7 @@ void StaticModel::display(glm::mat4 VP) {
                 cache = i;
             }
         }
-        assert(cache >= 0);
+        assertGreaterThanEqual(cache, 0);
     }
 
     getWorld().getStaticMesh(cache).display(VP * model);

src/RoomMesh.cpp

@@ -59,9 +59,9 @@ void RoomMesh::prepare() {
         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

@@ -54,12 +54,12 @@ void RunTime::initialize() {
 }
 
 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

@@ -228,12 +228,12 @@ unsigned int Script::levelCount() {
 }
 
 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);
 }
 
@@ -242,7 +242,7 @@ unsigned int Script::pictureCount() {
 }
 
 std::string Script::getPictureFilename(unsigned int i) {
-    assert(i < numPictures);
+    assertLessThan(i, numPictures);
     return pictureFilenames.at(i);
 }
 
@@ -251,7 +251,7 @@ unsigned int Script::cutsceneCount() {
 }
 
 std::string Script::getCutsceneFilename(unsigned int i) {
-    assert(i < numCutscenes);
+    assertLessThan(i, numCutscenes);
     return cutsceneFilenames.at(i);
 }
 
@@ -260,7 +260,7 @@ unsigned int Script::titleCount() {
 }
 
 std::string Script::getTitleFilename(unsigned int i) {
-    assert(i < numTitles);
+    assertLessThan(i, numTitles);
     return titleFilenames.at(i);
 }
 
@@ -269,7 +269,7 @@ unsigned int Script::videoCount() {
 }
 
 std::string Script::getVideoFilename(unsigned int i) {
-    assert(i < numFMVs);
+    assertLessThan(i, numFMVs);
     return fmvFilenames.at(i);
 }
 
@@ -278,7 +278,7 @@ unsigned int Script::gameStringCount() {
 }
 
 std::string Script::getGameString(unsigned int i) {
-    assert(i < numGameStrings);
+    assertLessThan(i, numGameStrings);
     return gameStrings.at(i);
 }
 
@@ -287,35 +287,35 @@ unsigned int Script::pcStringCount() {
 }
 
 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

@@ -29,7 +29,7 @@ unsigned long BoneFrame::size() {
 }
 
 BoneTag& BoneFrame::get(unsigned long i) {
-    assert(i < tag.size());
+    assertLessThan(i, tag.size());
     return *tag.at(i);
 }
 
@@ -49,7 +49,7 @@ unsigned long AnimationFrame::size() {
 }
 
 BoneFrame& AnimationFrame::get(unsigned long i) {
-    assert(i < frame.size());
+    assertLessThan(i, frame.size());
     return *frame.at(i);
 }
 
@@ -64,19 +64,19 @@ class MatrixStack {
     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;
@@ -101,8 +101,8 @@ SkeletalModel::~SkeletalModel() {
 #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);
@@ -173,7 +173,7 @@ unsigned long SkeletalModel::size() {
 }
 
 AnimationFrame& SkeletalModel::get(unsigned long i) {
-    assert(i < animation.size());
+    assertLessThan(i, animation.size());
     return *animation.at(i);
 }
 

src/SoundManager.cpp

@@ -30,10 +30,10 @@ int SoundManager::prepareSources() {
         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);
     }
 
@@ -42,7 +42,7 @@ int SoundManager::prepareSources() {
         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

@@ -52,8 +52,8 @@ void Sprite::display(glm::mat4 MVP) {
 // ----------------------------------------------------------------------------
 
 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

@@ -56,8 +56,8 @@ std::vector<BufferManager> TextureManager::gameBuffers;
 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;
@@ -132,8 +132,8 @@ int TextureManager::loadBufferSlot(unsigned char* image,
                                    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)
@@ -201,15 +201,15 @@ int TextureManager::numTextures(TextureStorage s) {
 }
 
 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));
@@ -233,8 +233,8 @@ int TextureManager::numTiles() {
 }
 
 TextureTile& TextureManager::getTile(int index) {
-    assert(index >= 0);
-    assert(index < tiles.size());
+    assertGreaterThanEqual(index, 0);
+    assertLessThan(index, tiles.size());
     return *tiles.at(index);
 }
 
@@ -250,13 +250,13 @@ int TextureManager::numAnimatedTiles() {
 }
 
 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

@@ -31,7 +31,7 @@ unsigned long World::sizeRoom() {
 }
 
 Room& World::getRoom(unsigned long index) {
-    assert(index < mRooms.size());
+    assertLessThan(index, mRooms.size());
     return *mRooms.at(index);
 }
 
@@ -44,7 +44,7 @@ unsigned long World::sizeSprite() {
 }
 
 Sprite& World::getSprite(unsigned long index) {
-    assert(index < mSprites.size());
+    assertLessThan(index, mSprites.size());
     return *mSprites.at(index);
 }
 
@@ -57,7 +57,7 @@ unsigned long World::sizeSpriteSequence() {
 }
 
 SpriteSequence& World::getSpriteSequence(unsigned long index) {
-    assert(index < mSpriteSequences.size());
+    assertLessThan(index, mSpriteSequences.size());
     return *mSpriteSequences.at(index);
 }
 
@@ -70,7 +70,7 @@ unsigned long World::sizeEntity() {
 }
 
 Entity& World::getEntity(unsigned long index) {
-    assert(index < mEntities.size());
+    assertLessThan(index, mEntities.size());
     return *mEntities.at(index);
 }
 
@@ -83,7 +83,7 @@ unsigned long World::sizeSkeletalModel() {
 }
 
 SkeletalModel& World::getSkeletalModel(unsigned long index) {
-    assert(index < mModels.size());
+    assertLessThan(index, mModels.size());
     return *mModels.at(index);
 }
 
@@ -96,7 +96,7 @@ unsigned long World::sizeStaticMesh() {
 }
 
 StaticMesh& World::getStaticMesh(unsigned long index) {
-    assert(index < mStaticMeshes.size());
+    assertLessThan(index, mStaticMeshes.size());
     return *mStaticMeshes.at(index);
 }
 
@@ -109,7 +109,7 @@ unsigned long World::sizeMesh() {
 }
 
 Mesh& World::getMesh(unsigned long index) {
-    assert(index < mMeshes.size());
+    assertLessThan(index, mMeshes.size());
     return *mMeshes.at(index);
 }
 

src/commands/Command.cpp

@@ -36,8 +36,6 @@ void Command::fillCommandList() {
 }
 
 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

@@ -8,6 +8,7 @@
 #include "global.h"
 #include "loader/Loader.h"
 #include "loader/LoaderTR2.h"
+#include "loader/LoaderTR3.h"
 
 Loader::LoaderVersion Loader::checkFile(std::string f) {
     BinaryFile file;
@@ -38,7 +39,6 @@ std::unique_ptr<Loader> Loader::createLoader(std::string f) {
     LoaderVersion v = checkFile(f);
     switch (v) {
         case TR_1:
-        case TR_3:
         case TR_4:
         case TR_5:
         case TR_UNKNOWN:
@@ -46,10 +46,9 @@ std::unique_ptr<Loader> Loader::createLoader(std::string f) {
 
         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

@@ -21,12 +21,6 @@
 
 #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
@@ -91,7 +85,7 @@ void LoaderTR2::loadPaletteTextiles() {
         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;
     }
 
@@ -106,9 +100,14 @@ void LoaderTR2::loadTextures() {
     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
@@ -179,6 +178,38 @@ void LoaderTR2::loadAnimatedTextures() {
 
 // ---- 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++) {
@@ -332,6 +363,10 @@ void LoaderTR2::loadRooms() {
             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;
@@ -341,25 +376,7 @@ void LoaderTR2::loadRooms() {
             // 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;
@@ -385,13 +402,9 @@ void LoaderTR2::loadRooms() {
                                                    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);
@@ -463,9 +476,9 @@ void LoaderTR2::loadSprites() {
         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);
@@ -1106,7 +1119,7 @@ void LoaderTR2::loadExternalSoundFile(std::string f) {
             buff[i] = sfx.readU8();
 
         int ret = Sound::loadBuffer(buff, riffSize + 8);
-        assert(ret >= 0);
+        assertGreaterThanEqual(ret, 0);
 
         riffCount++;
     }

src/loader/LoaderTR3.cpp

@@ -8,19 +8,77 @@
 #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

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