LoaderTR2 loads most parts of the Rooms

ChangeLog.md

 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20141207 ]
+    * LoaderTR2 now also loads all important parts of the Room structures
+
     [ 20141206 ]
     * LoaderTR2 now tries to load Moveables and Entities
     * Added Meshes to World, taking role of StaticMeshes

include/Room.h

   public:
     Room(TombRaider& tr, unsigned int index);
 
-    Room();
+    Room(float p[3] = nullptr, unsigned int f = 0, unsigned int x = 0, unsigned int z = 0);
     ~Room();
 
     BoundingBox& getBoundingBox();
     unsigned int getNumZSectors();
     void getPos(float p[3]);
 
+    void setNumXSectors(unsigned int n);
+    void setNumZSectors(unsigned int n);
+    void setPos(float p[3]);
+
     void setFlags(unsigned int f);
     unsigned int getFlags();
 
     Sector& getSector(unsigned long index);
     void addSector(Sector* s);
 
-    unsigned long sizeBox();
-    Box& getBox(unsigned long index);
-    void addBox(Box* b);
-
     unsigned long sizeModels();
     StaticModel& getModel(unsigned long index);
     void addModel(StaticModel* s);
     std::vector<Sprite*> sprites;
     std::vector<StaticModel*> models;
     std::vector<Portal*> portals;
-    std::vector<Box*> boxes;
     std::vector<Sector*> sectors;
     std::vector<Light*> lights;
 

include/RoomData.h

     int adjoiningRoom;
 };
 
-class Box {
-  public:
-    Box(TombRaider& tr, unsigned int room, unsigned int index);
-
-  private:
-    float a[3], b[3], c[3], d[3];
-};
-
 class Sector {
   public:
+    Sector(float f, float c, bool w) : floor(f), ceiling(c), wall(w) { }
     Sector(TombRaider& tr, unsigned int room, unsigned int index);
     float getFloor();
     float getCeiling();

src/Game.cpp

 #include "StaticMesh.h"
 #include "system/Sound.h"
 #include "TextureManager.h"
+#include "UI.h"
 #include "World.h"
 #include "utils/strings.h"
 
                 mLoaded = true;
                 //getRender().setMode(Render::modeVertexLight);
             }
+
+            UI::setVisible(true);
         }
     }
 

src/Room.cpp

 extern std::map<int, int> gMapTex2Bump;
 #endif
 
-Room::Room(TombRaider& tr, unsigned int index) {
-    float box[2][3];
-    Matrix transform;
+Room::Room(float p[3], unsigned int f, unsigned int x, unsigned int z)
+    : flags(f), numXSectors(x), numZSectors(z) {
+    if (p == nullptr) {
+        pos[0] = 0.0f;
+        pos[1] = 0.0f;
+        pos[2] = 0.0f;
+    } else {
+        pos[0] = p[0];
+        pos[1] = p[0];
+        pos[2] = p[0];
+    }
+}
+
+void Room::setNumXSectors(unsigned int n) {
+    numXSectors = n;
+}
 
+void Room::setNumZSectors(unsigned int n) {
+    numZSectors = n;
+}
+
+void Room::setPos(float p[3]) {
+    for (int i = 0; i < 3; i++)
+        pos[i] = p[i];
+}
+
+Room::Room(TombRaider& tr, unsigned int index) {
     if (!tr.isRoomValid(index)) {
         getLog() << "WARNING: Handling invalid vertex array in room" << Log::endl;
         return;
 
     flags = 0;
     unsigned int trFlags = 0;
+    float box[2][3];
     tr.getRoomInfo(index, &trFlags, pos, box[0], box[1]);
 
     if (trFlags & tombraiderRoom_underWater)
     bbox.setBoundingBox(box[0], box[1]);
 
     // Mongoose 2002.04.03, Setup 3D transform
+    Matrix transform;
     transform.setIdentity();
     transform.translate(pos);
 
         adjacentRooms.push_back(portals.back()->getAdjoiningRoom());
     }
 
-    //! \fixme Use more of sector structure, boxes, and floordata
-
     // List of sectors in this room
     count = tr.getRoomSectorCount(index, &numZSectors, &numXSectors);
     for (unsigned int i = 0; i < count; i++)
         sectors.push_back(new Sector(tr, index, i));
 
-    // Setup collision boxes
-    //! fixme Should use sectors, but this is a test
-    count = tr.getRoomBoxCount(index);
-    for (unsigned int i = 0; i < count; i++)
-        boxes.push_back(new Box(tr, index, i));
-
     // Setup room lights
     count = tr.getRoomLightCount(index);
     for (unsigned int i = 0; i < count; i++)
 #endif
 }
 
-Room::Room() : flags(0), numXSectors(0), numZSectors(0) {
-    pos[0] = 0;
-    pos[1] = 0;
-    pos[2] = 0;
-}
-
 #define EMPTY_VECTOR(x)     \
 while (!x.empty()) {        \
     delete x[x.size() - 1]; \
     EMPTY_VECTOR(sprites);
     EMPTY_VECTOR(models);
     EMPTY_VECTOR(portals);
-    EMPTY_VECTOR(boxes);
     EMPTY_VECTOR(sectors);
     EMPTY_VECTOR(lights);
 }
     return -1;
 }
 
+void Room::setFlags(unsigned int f) {
+    flags = f;
+}
+
 unsigned int Room::getFlags() {
     return flags;
 }
     sectors.push_back(s);
 }
 
-unsigned long Room::sizeBox() {
-    return boxes.size();
-}
-
-Box& Room::getBox(unsigned long index) {
-    assert(index < boxes.size());
-    return *boxes.at(index);
-}
-
-void Room::addBox(Box* b) {
-    boxes.push_back(b);
-}
-
 unsigned long Room::sizeModels() {
     return models.size();
 }

src/RoomData.cpp

 }
 
 Portal::Portal(float vert[4][3], float norm[3], int adj) {
+    for (unsigned int i = 0; i < 4; i++) {
+        for (unsigned int j = 0; j < 3; j++) {
+            vertices[i][j] = vert[i][j];
+        }
+
+        if (i < 3) {
+            normal[i] = norm[i];
+        }
+    }
 
+    adjoiningRoom = adj;
 }
 
 void Portal::getVertices(float vert[4][3]) {
 
 // ----------------------------------------------------------------------------
 
-Box::Box(TombRaider& tr, unsigned int room, unsigned int index) {
-    tr.getRoomBox(room, index, a, b, c, d);
-}
-
-// ----------------------------------------------------------------------------
-
 Sector::Sector(TombRaider& tr, unsigned int room, unsigned int index) {
     unsigned int sectorFlags;
     int floorDataIndex, boxIndex, roomBelow, roomAbove;

src/SkeletalModel.cpp

 }
 
 void BoneTag::display() {
-    getWorld().getStaticMesh(mesh).display();
-    //getWorld().getMesh(mesh).drawSolid(); // TODO ?
+    if (getWorld().sizeMesh() > 0)
+        getWorld().getMesh(mesh).drawSolid(); // TODO ?
+    else
+        getWorld().getStaticMesh(mesh).display();
 }
 
 void BoneTag::getOffset(float o[3]) {

src/StaticMesh.cpp

 
 // ----------------------------------------------------------------------------
 
-StaticMesh::StaticMesh(int i, int m) : id(i), mesh(m) { }
+StaticMesh::StaticMesh(int i, int m) : id(i), mesh(m) {
+    vertices = colors = normals = nullptr;
+}
 
 #ifdef EXPERIMENTAL
 
 }
 
 float StaticMesh::getRadius() {
-    assert((id != -1) && (mesh != -1));
+    assert((id == -1) && (mesh == -1));
     return radius;
 }
 

src/loader/LoaderTR2.cpp

 #include "SoundManager.h"
 #include "TextureManager.h"
 #include "World.h"
+#include "math/Matrix.h"
 #include "math/Vec3.h"
 #include "system/Sound.h"
 #include "utils/pixel.h"
 
     if ((numAnimatedTextures > 0) || (numWords > 0))
         getLog() << "LoaderTR2: Found " << numAnimatedTextures << " Animated Textures!" << Log::endl;
+    else
+        getLog() << "LoaderTR2: No Animated Textures in this level?!" << Log::endl;
 
     if (pos != numWords)
         getLog() << "LoaderTR2: Extra bytes at end of AnimatedTextures?!" << Log::endl;
 
 void LoaderTR2::loadRooms() {
     uint16_t numRooms = file.readU16();
-
     for (unsigned int i = 0; i < numRooms; i++) {
         // Room Header
         int32_t xOffset = file.read32();
 
         uint16_t numVertices = file.readU16();
         std::vector<Vec3> vertices;
+        float bbox[2][3] = {
+            { 0.0f, 0.0f, 0.0f },
+            { 0.0f, 0.0f, 0.0f }
+        };
         for (unsigned int v = 0; v < numVertices; v++) {
             // Vertex coordinates, relative to x/zOffset
             int16_t x = file.read16();
             int16_t light2 = file.read16(); // Almost always equal to light1
 
             vertices.emplace_back(x, y, z);
+
+            if (v == 0) {
+                for (int i = 0; i < 2; i++) {
+                    bbox[i][0] = x;
+                    bbox[i][1] = y;
+                    bbox[i][2] = z;
+                }
+            } else {
+                if (x < bbox[0][0])
+                    bbox[0][0] = x;
+                if (x > bbox[1][0])
+                    bbox[1][0] = x;
+
+                if (y < bbox[0][1])
+                    bbox[0][1] = y;
+                if (y > bbox[1][1])
+                    bbox[1][1] = y;
+
+                if (z < bbox[0][2])
+                    bbox[0][2] = z;
+                if (z > bbox[1][2])
+                    bbox[1][2] = z;
+            }
         }
 
-        Room* room = new Room();
+        float pos[3] {
+            static_cast<float>(xOffset),
+            0.0f,
+            static_cast<float>(zOffset)
+        };
+        Room* room = new Room(pos);
+
+        bbox[0][0] += pos[0];
+        bbox[1][0] += pos[0];
+        bbox[0][2] += pos[2];
+        bbox[1][2] += pos[2];
+        room->getBoundingBox().setBoundingBox(bbox[0], bbox[1]);
 
         uint16_t numRectangles = file.readU16();
         for (unsigned int r = 0; r < numRectangles; r++) {
             // TODO store sprites somewhere
         }
 
+        Matrix transform;
+        transform.setIdentity();
+        transform.translate(pos);
+        room->addAdjacentRoom(i); // Always set room itself as first
+
         uint16_t numPortals = file.readU16();
         for (unsigned int p = 0; p < numPortals; p++) {
             // Which room this portal leads to
             int16_t yCorner4 = file.read16();
             int16_t zCorner4 = file.read16();
 
-            // TODO store portals somewhere
+            float vertices[4][3] = {
+                {
+                    static_cast<float>(xCorner1),
+                    static_cast<float>(yCorner1),
+                    static_cast<float>(zCorner1)
+                }, {
+                    static_cast<float>(xCorner2),
+                    static_cast<float>(yCorner2),
+                    static_cast<float>(zCorner2)
+                }, {
+                    static_cast<float>(xCorner3),
+                    static_cast<float>(yCorner3),
+                    static_cast<float>(zCorner3)
+                }, {
+                    static_cast<float>(xCorner4),
+                    static_cast<float>(yCorner4),
+                    static_cast<float>(zCorner4)
+                }
+            };
+
+            // Portals have relative coordinates
+            transform.multiply3v(vertices[0], vertices[0]);
+            transform.multiply3v(vertices[1], vertices[1]);
+            transform.multiply3v(vertices[2], vertices[2]);
+            transform.multiply3v(vertices[3], vertices[3]);
+
+            float normals[3] = {
+                static_cast<float>(xNormal),
+                static_cast<float>(yNormal),
+                static_cast<float>(zNormal)
+            };
+
+            room->addPortal(new Portal(vertices, normals, adjoiningRoom));
+            room->addAdjacentRoom(adjoiningRoom);
         }
 
         uint16_t numZSectors = file.readU16();
         uint16_t numXSectors = file.readU16();
+        room->setNumXSectors(numXSectors);
+        room->setNumZSectors(numZSectors);
         for (unsigned int s = 0; s < (numZSectors * numXSectors); s++) {
             // Sectors are 1024*1024 world coordinates. Floor and Ceiling are
             // signed numbers of 256 units of height.
             uint8_t roomAbove = file.readU8(); // 0xFF if none
             int8_t ceiling = file.read8(); // Absolute height of ceiling (/ 256)
 
-            // TODO store sectors somewhere
+            bool wall = false;
+            if ((((uint8_t)floor) == 0x81) || (((uint8_t)ceiling) == 0x81)) {
+                wall = true;
+            }
+
+            room->addSector(new Sector(floor * 256.0f, ceiling * 256.0f, wall));
         }
 
         int16_t intensity1 = file.read16();
             // TODO store static meshes somewhere
         }
 
-        int16_t alternateRoom = file.read16();
+        int16_t alternateRoom = file.read16(); // TODO
 
         uint16_t flags = file.readU16();
+        int roomFlags = 0;
+        if (flags & 0x0001) {
+            roomFlags |= RoomFlagUnderWater;
+        }
+        room->setFlags(room->getFlags() | roomFlags);
 
         getWorld().addRoom(room);
+
+        if ((numPortals == 0) || (numVertices == 0)
+            || ((numRectangles == 0) && (numTriangles == 0)))
+            getLog() << "LoaderTR2: Room " << i << " seems invalid: " << numPortals << "p "
+                     << numRectangles << "r " << numTriangles << "t " << numVertices
+                     << "v" << Log::endl;
     }
 
     if (numRooms > 0)
 
     if (numFloorData > 0)
         getLog() << "LoaderTR2: Found " << numFloorData << " words FloorData, unimplemented!" << Log::endl;
+    else
+        getLog() << "LoaderTR2: No FloorData in this level?!" << Log::endl;
 }
 
 void LoaderTR2::loadSprites() {
 
     uint32_t numMeshPointers = file.readU32();
 
-    if ((numMeshData == 0) || (numMeshPointers == 0)) {
-        getLog() << "LoaderTR2: No mesh data found!" << Log::endl;
-        return;
-    }
-
     for (unsigned int i = 0; i < numMeshPointers; i++) {
         uint32_t meshPointer = file.readU32();
 
+        if (numMeshData < (meshPointer / 2)) {
+            getLog() << "LoaderTR2: Invalid Mesh: "
+                     << (meshPointer / 2) << " > " << numMeshData << Log::endl;
+            continue;
+        }
+
         char* tmpPtr = reinterpret_cast<char*>(&buffer[meshPointer / 2]);
         BinaryMemory mem(tmpPtr, (numMeshData * 2) - meshPointer);
 
     }
 
     if (numMeshPointers > 0)
-        getLog() << "LoaderTR2: Found " << numMeshPointers << " Meshes, unimplemented!" << Log::endl;
+        getLog() << "LoaderTR2: Found " << numMeshPointers << " Meshes!" << Log::endl;
+    else
+        getLog() << "LoaderTR2: No Meshes in this level?!" << Log::endl;
 }
 
 void LoaderTR2::loadStaticMeshes() {
     }
 
     if (numStaticMeshes > 0)
-        getLog() << "LoaderTR2: Found " << numStaticMeshes << " StaticMeshes, unimplemented!" << Log::endl;
+        getLog() << "LoaderTR2: Found " << numStaticMeshes << " StaticMeshes!" << Log::endl;
     else
         getLog() << "LoaderTR2: No StaticMeshes in this level?!" << Log::endl;
 }
         int32_t y = file.read32();
         int32_t z = file.read32();
 
-        int16_t angle = file.read16(); // (0xC000 >> 14) * 90deg
+        uint16_t angle = file.readU16(); // (0xC000 >> 14) * 90deg
         int16_t intensity1 = file.read16(); // Constant lighting; -1 means mesh lighting
         int16_t intensity2 = file.read16(); // Almost always like intensity1
 
     }
 
     if (numItems > 0)
-        getLog() << "LoaderTR2: Found " << numItems << " Items, unimplemented!" << Log::endl;
+        getLog() << "LoaderTR2: Found " << numItems << " Items!" << Log::endl;
     else
         getLog() << "LoaderTR2: No Items in this level?!" << Log::endl;
 }
 
         // Index into overlaps[]. The high bit is sometimes set
         // this occurs in front of swinging doors and the like
-        int16_t overlapIndex = file.read16();
+        uint16_t overlapIndex = file.readU16();
 
         // TODO store boxes somewhere
     }
 
     uint32_t numOverlaps = file.readU32();
-    std::vector<uint16_t> overlaps;
+    std::vector<std::vector<uint16_t>> overlaps;
+    overlaps.emplace_back();
+    unsigned int list = 0;
     for (unsigned int o = 0; o < numOverlaps; o++) {
-        overlaps.push_back(file.readU16());
+        // 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
 
-    std::vector<int16_t> zones;
     for (unsigned int z = 0; z < numBoxes; z++) {
-        for (unsigned int i = 0; i < 10; i++) {
-            zones.push_back(file.read16());
-        }
+        // Normal room state
+        int16_t ground1 = file.read16();
+        int16_t ground2 = file.read16();
+        int16_t ground3 = file.read16();
+        int16_t ground4 = file.read16();
+        int16_t fly = file.read16();
+
+        // Alternate room state
+        int16_t ground1alt = file.read16();
+        int16_t ground2alt = file.read16();
+        int16_t ground3alt = file.read16();
+        int16_t ground4alt = file.read16();
+        int16_t flyAlt = file.read16();
+
+        // TODO store zones somewhere
     }
 
-    // TODO store zones somewhere
-
     if ((numBoxes > 0) || (numOverlaps > 0))
-        getLog() << "LoaderTR2: Found NPC NavigationHints, unimplemented!" << Log::endl;
+        getLog() << "LoaderTR2: Found NPC NavigationHints (" << numBoxes
+                 << ", " << numOverlaps << ", " << list << "), unimplemented!" << Log::endl;
+    else
+        getLog() << "LoaderTR2: No NPC NavigationHints in this level?!" << Log::endl;
 }
 
 // ---- Sound ----
 
     if (numSoundSources > 0)
         getLog() << "LoaderTR2: Found " << numSoundSources << " SoundSources" << Log::endl;
+    else
+        getLog() << "LoaderTR2: No SoundSources in this level?!" << Log::endl;
 }
 
 void LoaderTR2::loadSoundMap() {
 
     if (numSoundDetails > 0)
         getLog() << "LoaderTR2: Found " << numSoundDetails << " SoundDetails" << Log::endl;
+    else
+        getLog() << "LoaderTR2: No SoundDetails in this level?!" << Log::endl;
 }
 
 void LoaderTR2::loadSampleIndices() {
 
     if (numSampleIndices > 0)
         getLog() << "LoaderTR2: Found " << numSampleIndices << " SampleIndices" << Log::endl;
+    else
+        getLog() << "LoaderTR2: No SampleIndices in this level?!" << Log::endl;
 }
 
 void LoaderTR2::loadExternalSoundFile(std::string f) {
 
     if (riffCount > 0)
         getLog() << "LoaderTR2: Found " << riffCount << " SoundSamples in SFX" << Log::endl;
+    else
+        getLog() << "LoaderTR2: No SoundSamples in SFX?!" << Log::endl;
 }
 
 // ---- Stuff ----