LoaderTR2 starts filling Rooms

ChangeLog.md

 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20141124 ]
+    * LoaderTR2 is starting to populate Room structures
+
     [ 20141123 ]
     * Added texture viewer debug UI
 

include/Mesh.h

 #ifndef _MESH_H_
 #define _MESH_H_
 
+#include "loader/Loader.h"
+
 /*!
  * \brief OpenGL Mesh
  */
 class Mesh {
   public:
 
+    struct rectangle_t {
+        struct vertex_t a, b, c, d;
+        uint16_t texture;
+    }
+
+    Mesh();
+    ~Mesh();
+
+    void drawAlpha();
+    void drawSolid();
+
+    // Warning: texture is not the GL texture id,
+    // it is an index into the object texture list!
+    void addTexturedRectangle(struct vertex_t a, struct vertex_t b,
+            struct vertex_t c, struct vertex_t d, uint16_t texture);
+    void addTexturedTriangle(struct vertex_t a, struct vertex_t b,
+            struct vertex_t c, uint16_t texture);
+
+    std::vector<struct rectangle_t> texturedRectangles;
+    std::vector<struct rectangle_t> coloredRectangles;
+    std::vector<struct rectangle_t> texturedTriangles;
+    std::vector<struct rectangle_t> coloredTriangles;
+
+
+
+    // Old API
+
     typedef enum {
         MeshModeSolid,
         MeshModeWireframe,
 
     } rect_t;
 
-    /*!
-     * \brief Constructs an object of Mesh
-     */
-    Mesh();
-
-    /*!
-     * \brief Deconstructs an object of Mesh
-     */
-    ~Mesh();
-
-    void drawAlpha();
-
-    void drawSolid();
+    void drawAlphaOld();
+    void drawSolidOld();
 
     void allocateColors(unsigned int n);
 

include/Room.h

 class Room {
   public:
     Room(TombRaider& tr, unsigned int index);
+
+    Room();
     ~Room();
 
     BoundingBox& getBoundingBox();
-    Mesh& getMesh();
     void display(bool alpha);
 
     bool isWall(unsigned long sector);
 
     unsigned long sizeAdjacentRooms();
     long getAdjacentRoom(unsigned long index);
+    void addAdjacentRoom(long r);
 
     unsigned long sizePortals();
     Portal& getPortal(unsigned long index);
+    void addPortal(Portal* p);
 
     unsigned long sizeSectors();
     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);
 
     unsigned long sizeLights();
     Light& getLight(unsigned long index);
+    void addLight(Light* l);
 
     unsigned long sizeSprites();
     Sprite& getSprite(unsigned long index);
+    void addSprite(Sprite* s);
 
   private:
     void sortModels();

include/RoomData.h

 
 class Portal {
   public:
+    Portal(float vert[4][3], float norm[3], int adj);
     Portal(TombRaider& tr, unsigned int room, unsigned int index, Matrix& transform);
 
     void getVertices(float vert[4][3]);

include/Sprite.h

 #ifndef _SPRITE_H_
 #define _SPRITE_H_
 
+#include <cstdint>
+
+#include "loader/Loader.h"
 #include "TombRaider.h"
 
 class Sprite {
   public:
+    Sprite(struct vertex_t vert, uint16_t tex);
+
+    // Old API
     Sprite(TombRaider& tr, unsigned int room, unsigned int index);
     Sprite(TombRaider& tr, unsigned int item, unsigned int sequence, unsigned int index);
     void display();

include/loader/Loader.h

 
 #include <memory>
 #include <string>
+#include <cstdint>
 
 #include "utils/binary.h"
 
+struct vertex_t {
+    int16_t x, y, z;
+    int16_t light1, light2;
+    int16_t attributes;
+};
+
 class Loader {
   public:
 

src/Game.cpp

         } else {
             mLoaded = true;
             getRender().setMode(Render::modeVertexLight);
-            return 0;
         }
     }
+
+    return 0;
 }
 
 void Game::handleAction(ActionEvents action, bool isFinished) {

src/Mesh.cpp

 #include "TextureManager.h"
 #include "Mesh.h"
 
+void Mesh::addTexturedRectangle(struct vertex_t a, struct vertex_t b,
+        struct vertex_t c, struct vertex_t d, uint16_t texture) {
+    struct rectangle_t r;
+    r.a = a;
+    r.b = b;
+    r.c = c;
+    r.d = d;
+    r.texture = texture;
+    texturedRectangles.push_back(r);
+}
+
+void Mesh::addTexturedTriangle(struct vertex_t a, struct vertex_t b,
+        struct vertex_t c, uint16_t texture) {
+    struct rectangle_t r;
+    r.a = a;
+    r.b = b;
+    r.c = c;
+    r.texture = texture;
+    texturedTriangles.push_back(r);
+}
+
+void Mesh::drawAlpha() {
+    if ((texturedRectangles.size() == 0)
+            && (texturedTriangles.size() == 0)
+            && (coloredRectangles.size() == 0)
+            && (coloredTriangles.size() == 0)) {
+        drawAlphaOld();
+        return;
+    }
+
+    // TODO replicate drawAlphaOld, but get object texture coord from World
+}
+
+void Mesh::drawSolid() {
+    if ((texturedRectangles.size() == 0)
+            && (texturedTriangles.size() == 0)
+            && (coloredRectangles.size() == 0)
+            && (coloredTriangles.size() == 0)) {
+        drawSolidOld();
+        return;
+    }
+
+
+}
+
 
 ////////////////////////////////////////////////////////////
 // Constructors
 // Public Accessors
 ////////////////////////////////////////////////////////////
 
-void Mesh::drawAlpha() {
+void Mesh::drawAlphaOld() {
     unsigned int i, j, k, index;
 
 
 }
 
 
-void Mesh::drawSolid() {
+void Mesh::drawSolidOld() {
     unsigned int i, j, k, index;
 
 

src/Room.cpp

 #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]; \
 
     switch (getRender().getMode()) {
         case Render::modeWireframe:
-            getMesh().mMode = Mesh::MeshModeWireframe;
+            mesh.mMode = Mesh::MeshModeWireframe;
             break;
         case Render::modeSolid:
-            getMesh().mMode = Mesh::MeshModeSolid;
+            mesh.mMode = Mesh::MeshModeSolid;
             break;
         default:
-            getMesh().mMode = Mesh::MeshModeTexture;
+            mesh.mMode = Mesh::MeshModeTexture;
             break;
     }
 
     if (alpha)
-        getMesh().drawAlpha();
+        mesh.drawAlpha();
     else
-        getMesh().drawSolid();
+        mesh.drawSolid();
 
     glPopMatrix();
 
     return adjacentRooms.at(index);
 }
 
+void Room::addAdjacentRoom(long r) {
+    adjacentRooms.push_back(r);
+}
+
 unsigned long Room::sizePortals() {
     return portals.size();
 }
     return *portals.at(index);
 }
 
+void Room::addPortal(Portal* p) {
+    portals.push_back(p);
+}
+
 unsigned long Room::sizeSectors() {
     return sectors.size();
 }
     return *sectors.at(index);
 }
 
+void Room::addSector(Sector* s) {
+    sectors.push_back(s);
+}
+
 unsigned long Room::sizeBox() {
     return boxes.size();
 }
     return *boxes.at(index);
 }
 
+void Room::addBox(Box* b) {
+    boxes.push_back(b);
+}
+
 unsigned long Room::sizeModels() {
     return models.size();
 }
     return *models.at(index);
 }
 
+void Room::addModel(StaticModel* s) {
+    models.push_back(s);
+}
+
 void Room::sortModels() {
     std::sort(models.begin(), models.end(), StaticModel::compare);
 }
     return *lights.at(index);
 }
 
+void Room::addLight(Light* l) {
+    lights.push_back(l);
+}
+
 unsigned long Room::sizeSprites() {
     return sprites.size();
 }
     return *sprites.at(index);
 }
 
-BoundingBox& Room::getBoundingBox() {
-    return bbox;
+void Room::addSprite(Sprite* s) {
+    sprites.push_back(s);
 }
 
-Mesh& Room::getMesh() {
-    return mesh;
+BoundingBox& Room::getBoundingBox() {
+    return bbox;
 }
 

src/RoomData.cpp

     }
 }
 
+Portal::Portal(float vert[4][3], float norm[3], int adj) {
+
+}
+
 void Portal::getVertices(float vert[4][3]) {
     for (unsigned int i = 0; i < 4; i++) {
         for (unsigned int j = 0; j < 3; j++) {

src/Sprite.cpp

     radius = 0.0f;
 }
 
+Sprite::Sprite(struct vertex_t vert, uint16_t tex) {
+
+}
+
 void Sprite::display() {
     if (!getRender().isVisible(pos[0], pos[1], pos[2], radius))
         return;

src/UI.cpp

             ImGui::PopItemWidth();
             ImGui::SameLine();
             if (ImGui::Checkbox("Game", &game)) {
-                if (game && !getGame().isLoaded())
+                if (game && (getTextureManager().numTextures(
+                        game ? TextureManager::TextureStorage::GAME
+                        : TextureManager::TextureStorage::SYSTEM) <= 0))
                     game = false;
             }
             ImGui::SameLine();

src/loader/LoaderTR2.cpp

 
 #include "global.h"
 #include "Log.h"
+#include "Mesh.h"
 #include "TextureManager.h"
 #include "utils/pixel.h"
 #include "loader/LoaderTR2.h"
     loadSoundDetails();
     loadSampleIndices();
 
-    return 42; // TODO Not finished with implementation!
+    return 0; // TODO Not finished with implementation!
 }
 
 void LoaderTR2::loadPaletteTextiles() {
         // Number of data words (2 bytes) to follow
         uint32_t dataToFollow = file.readU32();
 
+
+        std::vector<struct vertex> vertices;
+
         uint16_t numVertices = file.readU16();
         for (unsigned int v = 0; v < numVertices; v++) {
+            struct vertex v;
             // Vertex coordinates, relative to x/zOffset
-            int16_t relativeX = file.read16();
-            int16_t relativeY = file.read16();
-            int16_t relativeZ = file.read16();
+            v.x = file.read16();
+            v.y = file.read16();
+            v.z = file.read16();
 
-            int16_t lighting1 = file.read16();
+            v.light1 = file.read16();
 
             // Set of flags for special rendering effects
             // 0x8000 - Something to do with water surface?
             // 0x4000 - Underwater lighting modulation/movement if seen from above
             // 0x2000 - Water/Quicksand surface movement
             // 0x0010 - Normal?
-            uint16_t attributes = file.readU16();
+            v.attributes = file.readU16();
 
-            int16_t lighting2 = file.read16(); // Almost always equal to lighting1
+            v.light2 = file.read16(); // Almost always equal to light1
 
-            // TODO store vertex somewhere
+            vertices.push_back(v);
         }
 
+        Room* room = new Room();
+
         uint16_t numRectangles = file.readU16();
         for (unsigned int r = 0; r < numRectangles; r++) {
             // Indices into the vertex list read just before
             // Index into the object-texture list
             uint16_t texture = file.readU16();
 
-            // TODO store rectangles somewhere
+            room->getMesh().addTexturedRectangle(vertices.at(vertex1), vertices.at(vertex2),
+                    vertices.at(vertex3), vertices.at(vertex4), texture);
         }
 
         uint16_t numTriangles = file.readU16();
             // Index into the object-texture list
             uint16_t texture = file.readU16();
 
-            // TODO store triangles somewhere
+            room->getMesh().addTexturedTriangle(vertices.at(vertex1), vertices.at(vertex2),
+                    vertices.at(vertex3), texture);
         }
 
         uint16_t numSprites = file.readU16();
             uint16_t vertex = file.readU16(); // Index into vertex list
             uint16_t texture = file.readU16(); // Index into object-texture list
 
-            // TODO store sprites somewhere
+            room->addSprite(new Sprite(vertices.at(vertex), texture));
         }
 
         uint16_t numPortals = file.readU16();

src/utils/pixel.cpp

     for (unsigned int i = 0; i < (w * h); ++i) {
         /* 24-bit BGR to RGB */
         unsigned char swap = image[(i * 3) + 2];
-        image[(i * 3) + 2] = image[(i * 3)];
-        image[(i * 3)] = swap;
+        image[(i * 3) + 2] = image[i * 3];
+        image[i * 3] = swap;
     }
 }
 
         /* 32-bit BGRA to RGBA */
         unsigned char swap = image[(i * 4) + 2];
         image[(i * 4) + 2] = image[(i * 4)];
-        image[(i * 4)] = swap;
+        image[i * 4] = swap;
     }
 }
 
     assert(h > 0);
 
     for (unsigned int i = 0; i < (w * h); ++i) {
-        /* 32-bit ARGB to RGBA */
-        unsigned char swap = image[(i * 4) + 3];
-        image[(i * 4)] = image[(i * 4) + 1];
+        // 32-bit ARGB to RGBA
+        unsigned char swap = image[i * 4];
+        image[i * 4] = image[(i * 4) + 1];
         image[(i * 4) + 1] = image[(i * 4) + 2];
         image[(i * 4) + 2] = image[(i * 4) + 3];
         image[(i * 4) + 3] = swap;
 
     unsigned char* img = new unsigned char[w * h * 4];
     for (unsigned int i = 0; i < (w * h); ++i) {
-        img[i * 4] = ((image[i] >> 10) & 0x1F) * 8;
-        img[(i * 4) + 1] = ((image[i] >> 5) & 0x1F) * 8;
-        img[(i * 4) + 2] = (image[i] & 0x1F) * 8;
-        img[(i * 4) + 3] = (image[i] & 0x8000) ? 0xFF : 0;
+        // arrr.rrgg gggb.bbbb shift to 5bit
+        img[i * 4] = (image[(i * 2) + 1] & 0x80) ? 0xFF : 0; // A
+        img[(i * 4) + 1] = (image[(i * 2) + 1] & 0x7C) >> 2; // R
+        img[(i * 4) + 2] = (image[(i * 2) + 1] & 0x03) << 3;
+        img[(i * 4) + 2] |= (image[i * 2] & 0xE0) >> 5; // G
+        img[(i * 4) + 3] = image[i * 2] & 0x1F; // B
+
+        img[(i * 4) + 1] <<= 3; // R
+        img[(i * 4) + 2] <<= 3; // G
+        img[(i * 4) + 3] <<= 3; // B
     }
     return img;
 }