Added SkeletalModel, now using std::vector

include/SkeletalModel.h

@@ -0,0 +1,94 @@
+/*!
+ * \file include/SkeletalModel.h
+ * \brief This is the factored out skeletal model class
+ *
+ * \author Mongoose
+ * \author xythobuz
+ *
+ * \todo Start cutting off old hacks by simple force use of method interface.
+ * Also move the publicly exposed attributes out  =)
+ * Better animation system in general - this is memory wasteful
+ */
+
+#ifndef _SKELETALMODEL_H_
+#define _SKELETALMODEL_H_
+
+#include <vector>
+
+#include "math/math.h"
+
+typedef struct {
+    int mesh;
+    vec3_t off;
+    vec3_t rot;
+    char flag;
+} bone_tag_t;
+
+typedef struct {
+    std::vector<bone_tag_t *> tag;
+    vec3_t pos;
+    float yaw;
+} bone_frame_t;
+
+typedef struct {
+    int id;
+    char rate;
+    std::vector<bone_frame_t *> frame;
+} animation_frame_t;
+
+typedef struct {
+    int id;
+    bool tr4Overlay;
+    bool pigtails;
+    int ponytailId;
+    vec3_t ponytail;
+    int ponytailMeshId;
+    unsigned int ponytailNumMeshes;
+    float ponytailAngle;
+    float ponyOff;
+    float ponyOff2;
+    std::vector<animation_frame_t *> animation;
+} skeletal_model_t;
+
+/*!
+ * \brief This is the factored out skeletal model class
+ */
+class SkeletalModel {
+public:
+    /*!
+     * \brief Constructs an object of SkeletalModel
+     */
+    SkeletalModel();
+
+     /*!
+     * \brief Deconstructs an object of SkeletalModel
+     */
+    ~SkeletalModel();
+
+    int getAnimation();
+
+    int getFrame();
+
+    int getIdleAnimation();
+
+    void setModel(skeletal_model_t *mdl);
+
+    void setAnimation(int index);
+
+    void setFrame(int index);
+
+    void setIdleAnimation(int index);
+
+    unsigned int flags;
+    skeletal_model_t *model; //!< World render model
+    float time;              //!< Interpolation use
+    float lastTime;
+    float rate;              //!< \fixme temp cache this here for old animation system use
+
+private:
+    int mBoneFrame;      //!< Bone frame
+    int mAnimationFrame; //!< Animation frame
+    int mIdleAnimation;  //!< Idle animation
+};
+
+#endif

src/CMakeLists.txt

@@ -40,6 +40,7 @@ set (SRCS ${SRCS} "Menu.cpp")
 set (SRCS ${SRCS} "Mesh.cpp")
 set (SRCS ${SRCS} "OpenRaider.cpp")
 set (SRCS ${SRCS} "Particle.cpp")
+set (SRCS ${SRCS} "SkeletalModel.cpp")
 set (SRCS ${SRCS} "Sound.cpp")
 set (SRCS ${SRCS} "TombRaider.cpp")
 set (SRCS ${SRCS} "ViewVolume.cpp")

src/SkeletalModel.cpp

@@ -0,0 +1,103 @@
+/*!
+ * \file src/SkeletalModel.cpp
+ * \brief This is the factored out skeletal model class
+ *
+ * \author Mongoose
+ * \author xythobuz
+ */
+
+#include "SkeletalModel.h"
+
+SkeletalModel::SkeletalModel() {
+    model = NULL;
+    flags = 0;
+    mBoneFrame = 0;
+    mAnimationFrame = 0;
+    mIdleAnimation = 0;
+    time = 0.0f;
+    lastTime = 0.0f;
+    rate = 0.0f;
+}
+
+SkeletalModel::~SkeletalModel() {
+    if (model) {
+        for(std::vector<animation_frame_t>::size_type i = 0; i < model->animation.size(); i++) {
+            animation_frame_t *af = model->animation[i];
+
+            if (!af)
+                continue;
+
+            for(std::vector<bone_frame_t>::size_type j = 0; j < af->frame.size(); j++) {
+                bone_frame_t *bf = af->frame[j];
+
+                if (!bf)
+                    continue;
+
+                for(std::vector<bone_tag_t>::size_type k = 0; k < bf->tag.size(); k++) {
+                    if (bf->tag[i])
+                        delete bf->tag[i];
+                }
+
+                delete bf;
+            }
+
+            delete af;
+        }
+
+        // \fixme Causes "freeing already freed pointer" exception
+        delete model;
+    }
+}
+
+int SkeletalModel::getAnimation() {
+    return mAnimationFrame;
+}
+
+int SkeletalModel::getFrame() {
+    return mBoneFrame;
+}
+
+int SkeletalModel::getIdleAnimation() {
+    return mIdleAnimation;
+}
+
+void SkeletalModel::setModel(skeletal_model_t *mdl) {
+    if (mdl)
+        model = mdl;
+}
+
+void SkeletalModel::setAnimation(int index) {
+    if (!model) // index > (int)model->animation.size())
+        return;
+
+    animation_frame_t *a = model->animation[index];
+
+    if (a) {
+        mAnimationFrame = index;
+        mBoneFrame = 0;
+        rate = a->rate;
+    }
+}
+
+void SkeletalModel::setFrame(int index) {
+    if (!model)
+        return;
+
+    animation_frame_t *a = model->animation[mAnimationFrame];
+
+    if (a) { // index > (int)a->frame.size())
+        bone_frame_t *b = a->frame[index];
+
+        if (b)
+            mBoneFrame = index;
+    }
+}
+
+void SkeletalModel::setIdleAnimation(int index) {
+    if (!model)
+        return;
+
+    if (model->animation[index])
+        mIdleAnimation = index;
+}
+