LoaderTR2 tries to load Meshes and StaticMeshes

ChangeLog.md

 
     [ 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

 #ifndef _MESH_H_
 #define _MESH_H_
 
-#include "loader/Loader.h"
+#include "math/Vec3.h"
 
 /*!
  * \brief OpenGL 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();
     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

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

include/World.h

 #include <vector>
 
 #include "Entity.h"
+#include "Mesh.h"
 #include "Room.h"
 #include "SkeletalModel.h"
 #include "Sprite.h"
     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.
      *
     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

 
 #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

             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

 #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() {
         return;
     }
 
-    // TODO replicate drawAlphaOld, but get object texture coord from World
 }
 
 void Mesh::drawSolid() {
         return;
     }
 
-
 }
 
 

src/SkeletalModel.cpp

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

src/StaticMesh.cpp

 #include "Game.h"
 #include "Render.h"
 #include "TextureManager.h"
+#include "World.h"
 #include "utils/pixel.h"
 #include "StaticMesh.h"
 
     glEnd();
 }
 
+// ----------------------------------------------------------------------------
+
+StaticMesh::StaticMesh(int i, int m) : id(i), mesh(m) { }
+
 #ifdef EXPERIMENTAL
 
 #include <map>
         triangles.push_back(
             new TexturedTriangle(vertexIndices + 3, st, texture, transparency));
     }
+
+    id = mesh = -1;
 }
 
 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))
 }
 
 float StaticMesh::getRadius() {
+    assert((id != -1) && (mesh != -1));
     return radius;
 }
 

src/World.cpp

 }
 
 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);
 }
     mSprites.clear();
     mEntities.clear();
     mModels.clear();
+    mStaticMeshes.clear();
     mMeshes.clear();
 }
 

src/loader/LoaderTR2.cpp

 #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"
         // 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();
             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();
         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();
                 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();
             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();
             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();
             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();
             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)
         // 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)