SkeletalModel rendering tests

ChangeLog.md

     [ 20140213 ]
     * 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
 
     [ 20140211 ]
     * Updated imgui to version 1.32

include/SkeletalModel.h

 
 class BoneTag {
   public:
-    BoneTag(int m, float o[3], float r[3], char f);
-    void display();
+    BoneTag(int m, glm::vec3 o, glm::vec3 r, char f) : mesh(m), off(o), rot(r), flag(f) { }
+    void display(glm::mat4 MVP);
 
-    void getOffset(float o[3]);
-    void getRotation(float r[3]);
-    char getFlag();
+    glm::vec3 getOffset() { return off; }
+    glm::vec3 getRotation() { return rot; }
+    char getFlag() { return flag; }
 
   private:
     int mesh;
-    float off[3];
-    float rot[3];
+    glm::vec3 off, rot;
     char flag;
 };
 
 class BoneFrame {
   public:
-    BoneFrame(float p[3]);
+    BoneFrame(glm::vec3 p) : pos(p) { }
     ~BoneFrame();
 
-    void getPosition(float p[3]);
+    glm::vec3 getPosition() { return pos; }
 
     unsigned long size();
     BoneTag& get(unsigned long i);
     void add(BoneTag* t);
 
   private:
-    float pos[3];
+    glm::vec3 pos;
     std::vector<BoneTag*> tag;
 };
 
 class AnimationFrame {
   public:
-    AnimationFrame(char r);
+    AnimationFrame(char r) : rate(r) { }
     ~AnimationFrame();
 
     unsigned long size();

src/SkeletalModel.cpp

 #include "SkeletalModel.h"
 #include "World.h"
 
-BoneTag::BoneTag(int m, float o[3], float r[3], char f) {
-    mesh = m;
-    flag = f;
-    for (int i = 0; i < 3; i++) {
-        off[i] = o[i];
-        rot[i] = r[i];
-    }
-}
-
-void BoneTag::display() {
-    /*
-    if (getWorld().sizeMesh() > 0)
-        getWorld().getMesh(mesh).drawSolid(); // TODO ?
-    else
-        getWorld().getStaticMesh(mesh).display();
-    */
-}
-
-void BoneTag::getOffset(float o[3]) {
-    o[0] = off[0];
-    o[1] = off[1];
-    o[2] = off[2];
-}
-
-void BoneTag::getRotation(float r[3]) {
-    r[0] = rot[0];
-    r[1] = rot[1];
-    r[2] = rot[2];
-}
+#include <glm/gtc/matrix_transform.hpp>
 
-char BoneTag::getFlag() {
-    return flag;
+void BoneTag::display(glm::mat4 MVP) {
+    getWorld().getMesh(mesh).display(MVP);
 }
 
 // ----------------------------------------------------------------------------
 
-BoneFrame::BoneFrame(float p[3]) {
-    for (int i = 0; i < 3; i++)
-        pos[i] = p[i];
-}
-
 BoneFrame::~BoneFrame() {
     for (unsigned long i = 0; i < tag.size(); i++)
         delete tag[i];
     tag.push_back(t);
 }
 
-void BoneFrame::getPosition(float p[3]) {
-    p[0] = pos[0];
-    p[1] = pos[1];
-    p[2] = pos[2];
-}
-
 // ----------------------------------------------------------------------------
 
-AnimationFrame::AnimationFrame(char r) {
-    rate = r;
-}
-
 AnimationFrame::~AnimationFrame() {
     for (unsigned long i = 0; i < frame.size(); i++)
         delete frame[i];
 
 // ----------------------------------------------------------------------------
 
+class MatrixStack {
+  public:
+    MatrixStack(glm::mat4 start) : startVal(start) { stack.push_back(startVal); }
+
+    void push() {
+        //assert(stack.size() > 0);
+        if (stack.size() > 0)
+            stack.push_back(stack.at(stack.size() - 1));
+    }
+
+    void pop() {
+        //assert(stack.size() > 0);
+        if (stack.size() > 0)
+            stack.pop_back();
+    }
+
+    glm::mat4 get() {
+        //assert(stack.size() > 0);
+        if (stack.size() > 0)
+            return stack.at(stack.size() - 1);
+        return startVal;
+    }
+
+  private:
+    std::vector<glm::mat4> stack;
+    glm::mat4 startVal;
+};
+
+// ----------------------------------------------------------------------------
+
 SkeletalModel::~SkeletalModel() {
     for (unsigned long i = 0; i < animation.size(); i++)
         delete animation[i];
 }
 
+//#define DEBUG_MODELS
+
+#ifdef DEBUG_MODELS
+#include <bitset>
+#endif
+
 void SkeletalModel::display(glm::mat4 MVP, int aframe, int bframe) {
-    /*
     assert(aframe < size());
     assert(bframe < get(aframe).size());
 
     AnimationFrame& anim = get(aframe);
     BoneFrame& boneframe = anim.get(bframe);
 
-    float pos[3];
-    boneframe.getPosition(pos);
-    glTranslatef(pos[0], pos[1], pos[2]);
+    glm::vec3 pos = boneframe.getPosition();
+    glm::mat4 frameTrans = glm::translate(glm::mat4(1.0f), glm::vec3(pos.x, -pos.y, pos.z));
+
+    MatrixStack stack(MVP * frameTrans);
+
+#ifdef DEBUG_MODELS
+    Log::get(LOG_DEBUG) << "Starting SkeletalModel:" << Log::endl;
+    int cnt = 0;
+#endif
 
     for (unsigned int a = 0; a < boneframe.size(); a++) {
         BoneTag& tag = boneframe.get(a);
-        float rot[3], off[3];
-
-        tag.getRotation(rot);
-        tag.getOffset(off);
-
-        if (a == 0) {
-            glRotatef(rot[1], 0, 1, 0);
-            glRotatef(rot[0], 1, 0, 0);
-            glRotatef(rot[2], 0, 0, 1);
-        } else {
-            if (tag.getFlag() & 0x01)
-                glPopMatrix();
-
-            if (tag.getFlag() & 0x02)
-                glPushMatrix();
-
-            glTranslatef(off[0], off[1], off[2]);
-            glRotatef(rot[1], 0, 1, 0);
-            glRotatef(rot[0], 1, 0, 0);
-            glRotatef(rot[2], 0, 0, 1);
+
+        glm::mat4 translate(1.0f);
+
+        if (a != 0) {
+            if (tag.getFlag() & 0x01) {
+                stack.pop();
+#ifdef DEBUG_MODELS
+                Log::get(LOG_DEBUG) << "  --> pop" << Log::endl;
+                cnt--;
+#endif
+            }
+
+            if (tag.getFlag() & 0x02) {
+                stack.push();
+#ifdef DEBUG_MODELS
+                Log::get(LOG_DEBUG) << "  --> push" << Log::endl;
+                cnt++;
+#endif
+            }
+
+#ifdef DEBUG_MODELS
+            if (tag.getFlag() & ~0x03) {
+                std::bitset<8> bs(tag.getFlag());
+                Log::get(LOG_DEBUG) << "  Unexpected flag " << bs << Log::endl;
+            }
+#endif
+
+            glm::vec3 off = tag.getOffset();
+            translate = glm::translate(glm::mat4(1.0f), glm::vec3(off.x, -off.y, off.z));
         }
 
-        tag.display();
+        glm::vec3 rot = tag.getRotation();
+        glm::mat4 rotY = glm::rotate(glm::mat4(1.0f), rot[1], glm::vec3(0.0f, 1.0f, 0.0f));
+        glm::mat4 rotX = glm::rotate(glm::mat4(1.0f), rot[0], glm::vec3(1.0f, 0.0f, 0.0f));
+        glm::mat4 rotZ = glm::rotate(glm::mat4(1.0f), rot[2], glm::vec3(0.0f, 0.0f, 1.0f));
+        glm::mat4 rotate = rotZ * rotX * rotY;
+
+        glm::mat4 mod = translate * rotate;
+        tag.display(stack.get() * mod);
+#ifdef DEBUG_MODELS
+        Log::get(LOG_DEBUG) << "  --> get (" << cnt << ")" << Log::endl;
+#endif
     }
-    */
+
+#ifdef DEBUG_MODELS
+    Log::get(LOG_DEBUG) << "Done!" << Log::endl;
+#endif
 }
 
 unsigned long SkeletalModel::size() {

src/loader/LoaderTR2.cpp

         // Just add the frame indicated in frameOffset, nothing else
         char* tmp = reinterpret_cast<char*>(&frames[0]) + frameOffset;
         BinaryMemory frame(tmp + 12, (numFrames * 2) - frameOffset - 12); // skip two BBs
-        float pos[3];
-        pos[0] = frame.read16();
-        pos[1] = frame.read16();
-        pos[2] = frame.read16();
+        glm::vec3 pos;
+        pos.x = frame.read16();
+        pos.y = frame.read16();
+        pos.z = frame.read16();
         BoneFrame* bf = new BoneFrame(pos);
 
         for (int i = 0; i < numMeshes; i++) {
             int mesh = startingMesh + i;
-            float offset[3] = { 0.0f, 0.0f, 0.0f };
+            glm::vec3 offset;
             float rotation[3] = { 0.0f, 0.0f, 0.0f };
             char flag = (i == 0) ? 2 : 0;
 
                 tmp += (i - 1) * 16; // TODO ?
                 BinaryMemory tree(tmp, (numMeshTrees * 4) - meshTree - ((i - 1) * 16));
                 flag = (char)tree.readU32();
-                offset[0] = tree.read32();
-                offset[1] = tree.read32();
-                offset[2] = tree.read32();
+                offset.x = tree.read32();
+                offset.y = tree.read32();
+                offset.z = tree.read32();
 
                 uint16_t a = frame.readU16();
                 if (a & 0xC000) {
                 }
             }
 
-            BoneTag* bt = new BoneTag(mesh, offset, rotation, flag);
+            glm::vec3 rot(rotation[0], rotation[1], rotation[2]);
+            BoneTag* bt = new BoneTag(mesh, offset, rot, flag);
             bf->add(bt);
         }