LoaderTR2 tries to load Meshes and StaticMeshes

ChangeLog.md

@@ -4,6 +4,8 @@
 
     [ 20141206 ]
     * LoaderTR2 now tries to load Moveables and Entities
+    * Added Meshes to World, taking role of StaticMeshes
+    * LoaderTR2 tries to load Meshes and StaticMeshes
 
     [ 20141203 ]
     * Renamed Vector3d to Vec3, small cleanup

include/Mesh.h

@@ -10,7 +10,7 @@
 #ifndef _MESH_H_
 #define _MESH_H_
 
-#include "loader/Loader.h"
+#include "math/Vec3.h"
 
 /*!
  * \brief OpenGL Mesh
@@ -19,8 +19,11 @@ class Mesh {
   public:
 
     struct rectangle_t {
-        struct vertex_t a, b, c, d;
+        Vec3 a, b, c, d;
         uint16_t texture;
+
+        rectangle_t(Vec3 _a, Vec3 _b, Vec3 _c, Vec3 _d, uint16_t t)
+            : a(_a), b(_b), c(_c), d(_d), texture(t) { }
     };
 
     Mesh();
@@ -29,17 +32,16 @@ class 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;
+    void addTexturedRectangle(Vec3 a, Vec3 b, Vec3 c, Vec3 d, uint16_t textile);
+    void addTexturedTriangle(Vec3 a, Vec3 b, Vec3 c, uint16_t textile);
+
+    void addColoredRectangle(Vec3 a, Vec3 b, Vec3 c, Vec3 d, uint16_t textile);
+    void addColoredTriangle(Vec3 a, Vec3 b, Vec3 c, uint16_t textile);
+
+    std::vector<rectangle_t> texturedRectangles;
+    std::vector<rectangle_t> coloredRectangles;
+    std::vector<rectangle_t> texturedTriangles;
+    std::vector<rectangle_t> coloredTriangles;
 
 
 

include/StaticMesh.h

@@ -25,6 +25,8 @@ class TexturedTriangle {
 
 class StaticMesh {
   public:
+    StaticMesh(int id, int mesh);
+
     StaticMesh(TombRaider& tr, unsigned int index);
     ~StaticMesh();
     void display();
@@ -44,6 +46,9 @@ class StaticMesh {
     float* normals;
 
     std::vector<TexturedTriangle*> triangles;
+
+    int id;
+    int mesh;
 };
 
 #endif

include/World.h

@@ -13,6 +13,7 @@
 #include <vector>
 
 #include "Entity.h"
+#include "Mesh.h"
 #include "Room.h"
 #include "SkeletalModel.h"
 #include "Sprite.h"
@@ -54,6 +55,10 @@ class World {
     unsigned long sizeStaticMesh();
     StaticMesh& getStaticMesh(unsigned long index);
 
+    void addMesh(Mesh* mesh);
+    unsigned long sizeMesh();
+    Mesh& getMesh(unsigned long index);
+
     /*!
      * \brief Find room a location is in.
      *
@@ -82,7 +87,8 @@ class World {
     std::vector<std::unique_ptr<SpriteSequence>> mSprites;
     std::vector<std::unique_ptr<Entity>> mEntities;
     std::vector<std::unique_ptr<SkeletalModel>> mModels;
-    std::vector<std::unique_ptr<StaticMesh>> mMeshes;
+    std::vector<std::unique_ptr<StaticMesh>> mStaticMeshes;
+    std::vector<std::unique_ptr<Mesh>> mMeshes;
 };
 
 World& getWorld();

include/loader/Loader.h

@@ -14,12 +14,6 @@
 
 #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

@@ -86,7 +86,7 @@ int Game::loadLevel(const char* level) {
             if (mLara == -1) {
                 getLog() << "Can't find Lara entity in level?!" << Log::endl;
             } else {
-                //mLoaded = true;
+                mLoaded = true;
                 //getRender().setMode(Render::modeVertexLight);
             }
         }

src/Mesh.cpp

@@ -11,25 +11,20 @@
 #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::addTexturedRectangle(Vec3 a, Vec3 b, Vec3 c, Vec3 d, uint16_t textile) {
+    texturedRectangles.emplace_back(a, b, c, d, textile);
 }
 
-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::addTexturedTriangle(Vec3 a, Vec3 b, Vec3 c, uint16_t textile) {
+    texturedTriangles.emplace_back(a, b, c, Vec3(), textile);
+}
+
+void Mesh::addColoredRectangle(Vec3 a, Vec3 b, Vec3 c, Vec3 d, uint16_t textile) {
+    coloredRectangles.emplace_back(a, b, c, d, textile);
+}
+
+void Mesh::addColoredTriangle(Vec3 a, Vec3 b, Vec3 c, uint16_t textile) {
+    coloredTriangles.emplace_back(a, b, c, Vec3(), textile);
 }
 
 void Mesh::drawAlpha() {
@@ -41,7 +36,6 @@ void Mesh::drawAlpha() {
         return;
     }
 
-    // TODO replicate drawAlphaOld, but get object texture coord from World
 }
 
 void Mesh::drawSolid() {
@@ -53,7 +47,6 @@ void Mesh::drawSolid() {
         return;
     }
 
-
 }
 
 

src/SkeletalModel.cpp

@@ -60,6 +60,7 @@ BoneTag::BoneTag(TombRaider& tr, unsigned int index, unsigned int i, unsigned in
 
 void BoneTag::display() {
     getWorld().getStaticMesh(mesh).display();
+    //getWorld().getMesh(mesh).drawSolid(); // TODO ?
 }
 
 void BoneTag::getOffset(float o[3]) {

src/StaticMesh.cpp

@@ -9,6 +9,7 @@
 #include "Game.h"
 #include "Render.h"
 #include "TextureManager.h"
+#include "World.h"
 #include "utils/pixel.h"
 #include "StaticMesh.h"
 
@@ -91,6 +92,10 @@ void TexturedTriangle::display(float* vertices, float* colors, float* normals) {
     glEnd();
 }
 
+// ----------------------------------------------------------------------------
+
+StaticMesh::StaticMesh(int i, int m) : id(i), mesh(m) { }
+
 #ifdef EXPERIMENTAL
 
 #include <map>
@@ -218,6 +223,8 @@ StaticMesh::StaticMesh(TombRaider& tr, unsigned int index) {
         triangles.push_back(
             new TexturedTriangle(vertexIndices + 3, st, texture, transparency));
     }
+
+    id = mesh = -1;
 }
 
 StaticMesh::~StaticMesh() {
@@ -232,6 +239,11 @@ StaticMesh::~StaticMesh() {
 }
 
 void StaticMesh::display() {
+    if ((id != -1) && (mesh != -1)) {
+        getWorld().getMesh(mesh).drawSolid();
+        return;
+    }
+
     if (!dontshow) {
         //! \fixme Duh, vis tests need to be put back
         //if (!isVisible(center, radius, bbox))
@@ -251,6 +263,7 @@ void StaticMesh::display() {
 }
 
 float StaticMesh::getRadius() {
+    assert((id != -1) && (mesh != -1));
     return radius;
 }
 

src/World.cpp

@@ -68,14 +68,27 @@ SkeletalModel& World::getSkeletalModel(unsigned long index) {
 }
 
 void World::addStaticMesh(StaticMesh* model) {
-    mMeshes.emplace_back(std::unique_ptr<StaticMesh>(model));
+    mStaticMeshes.emplace_back(std::unique_ptr<StaticMesh>(model));
 }
 
 unsigned long World::sizeStaticMesh() {
-    return mMeshes.size();
+    return mStaticMeshes.size();
 }
 
 StaticMesh& World::getStaticMesh(unsigned long index) {
+    assert(index < mStaticMeshes.size());
+    return *mStaticMeshes.at(index);
+}
+
+void World::addMesh(Mesh* mesh) {
+    mMeshes.emplace_back(mesh);
+}
+
+unsigned long World::sizeMesh() {
+    return mMeshes.size();
+}
+
+Mesh& World::getMesh(unsigned long index) {
     assert(index < mMeshes.size());
     return *mMeshes.at(index);
 }
@@ -114,6 +127,7 @@ void World::destroy() {
     mSprites.clear();
     mEntities.clear();
     mModels.clear();
+    mStaticMeshes.clear();
     mMeshes.clear();
 }
 

src/loader/LoaderTR2.cpp

@@ -17,6 +17,7 @@
 #include "SoundManager.h"
 #include "TextureManager.h"
 #include "World.h"
+#include "math/Vec3.h"
 #include "system/Sound.h"
 #include "utils/pixel.h"
 #include "loader/LoaderTR2.h"
@@ -191,28 +192,26 @@ void LoaderTR2::loadRooms() {
         // Number of data words (2 bytes) to follow
         uint32_t dataToFollow = file.readU32();
 
-        std::vector<vertex_t> vertices;
-
         uint16_t numVertices = file.readU16();
+        std::vector<Vec3> vertices;
         for (unsigned int v = 0; v < numVertices; v++) {
-            vertex_t vert;
             // Vertex coordinates, relative to x/zOffset
-            vert.x = file.read16();
-            vert.y = file.read16();
-            vert.z = file.read16();
+            int16_t x = file.read16();
+            int16_t y = file.read16();
+            int16_t z = file.read16();
 
-            vert.light1 = file.read16();
+            int16_t 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?
-            vert.attributes = file.readU16();
+            uint16_t attributes = file.readU16();
 
-            vert.light2 = file.read16(); // Almost always equal to light1
+            int16_t light2 = file.read16(); // Almost always equal to light1
 
-            vertices.push_back(vert);
+            vertices.emplace_back(x, y, z);
         }
 
         Room* room = new Room();
@@ -229,7 +228,8 @@ void LoaderTR2::loadRooms() {
             uint16_t texture = file.readU16();
 
             room->getMesh().addTexturedRectangle(vertices.at(vertex1), vertices.at(vertex2),
-                                                 vertices.at(vertex3), vertices.at(vertex4), texture);
+                                                 vertices.at(vertex3), vertices.at(vertex4),
+                                                 texture);
         }
 
         uint16_t numTriangles = file.readU16();
@@ -444,15 +444,16 @@ void LoaderTR2::loadMeshes() {
         int16_t mx = mem.read16();
         int16_t my = mem.read16();
         int16_t mz = mem.read16();
-
         int32_t collisionSize = mem.read32();
+        // TODO store mesh collision info somewhere
 
         uint16_t numVertices = mem.readU16();
+        std::vector<Vec3> vertices;
         for (int v = 0; v < numVertices; v++) {
             int16_t x = mem.read16();
             int16_t y = mem.read16();
             int16_t z = mem.read16();
-
+            vertices.emplace_back(x, y, z);
         }
 
         int16_t numNormals = mem.read16();
@@ -466,17 +467,19 @@ void LoaderTR2::loadMeshes() {
                 int16_t x = mem.read16();
                 int16_t y = mem.read16();
                 int16_t z = mem.read16();
-
+                // TODO store normals somewhere
             }
         } else if (numNormals < 0) {
             // Internal vertex lighting is used,
             // using the data included with the mesh
             for (int l = 0; l < (numNormals * -1); l++) {
                 int16_t light = mem.read16();
-
+                // TODO store lights somewhere
             }
         }
 
+        Mesh* mesh = new Mesh();
+
         int16_t numTexturedRectangles = mem.read16();
         for (int r = 0; r < numTexturedRectangles; r++) {
             uint16_t vertex1 = mem.readU16();
@@ -485,6 +488,9 @@ void LoaderTR2::loadMeshes() {
             uint16_t vertex4 = mem.readU16();
             uint16_t texture = mem.readU16();
 
+            mesh->addTexturedRectangle(vertices.at(vertex1), vertices.at(vertex2),
+                                       vertices.at(vertex3), vertices.at(vertex4),
+                                       texture);
         }
 
         int16_t numTexturedTriangles = mem.read16();
@@ -494,6 +500,8 @@ void LoaderTR2::loadMeshes() {
             uint16_t vertex3 = mem.readU16();
             uint16_t texture = mem.readU16();
 
+            mesh->addTexturedTriangle(vertices.at(vertex1), vertices.at(vertex2),
+                                      vertices.at(vertex3), texture);
         }
 
         int16_t numColoredRectangles = mem.read16();
@@ -504,6 +512,11 @@ void LoaderTR2::loadMeshes() {
             uint16_t vertex4 = mem.readU16();
             uint16_t texture = mem.readU16();
 
+            // TODO color?
+
+            mesh->addColoredRectangle(vertices.at(vertex1), vertices.at(vertex2),
+                                      vertices.at(vertex3), vertices.at(vertex4),
+                                      texture);
         }
 
         int16_t numColoredTriangles = mem.read16();
@@ -513,9 +526,13 @@ void LoaderTR2::loadMeshes() {
             uint16_t vertex3 = mem.readU16();
             uint16_t texture = mem.readU16();
 
+            // TODO color?
+
+            mesh->addColoredTriangle(vertices.at(vertex1), vertices.at(vertex2),
+                                     vertices.at(vertex3), texture);
         }
 
-        // TODO store mesh data somewhere
+        getWorld().addMesh(mesh);
     }
 
     if (numMeshPointers > 0)
@@ -550,7 +567,7 @@ void LoaderTR2::loadStaticMeshes() {
         // travel through, like TR2s skeletons and underwater plants
         uint16_t flags = file.readU16();
 
-        // TODO store static meshes somewhere
+        getWorld().addStaticMesh(new StaticMesh(objectID, mesh));
     }
 
     if (numStaticMeshes > 0)