Work in progress

include/Entity.h

 
     Entity(TombRaider &tr);
 
-    // Animation State
+    bool operator<(Entity &o);
+    void display();
+
+    void setSkeletalModel(unsigned int model);
 
+    // Animation State
     unsigned int getAnimationFrame();
     void setAnimationFrame(unsigned int index);
-
     unsigned int getBoneFrame();
     void setBoneFrame(unsigned int index);
-
     unsigned int getIdleAnimation();
     void setIdleAnimation(unsigned int index);
 
     int objectId;
 
     // Animation State
-
     unsigned int boneFrame;
     unsigned int animationFrame;
     unsigned int idleAnimation;

include/Game.h

 #include <vector>
 
 #include "Camera.h"
+#include "Entity.h"
 #include "global.h"
 #include "Render.h"
 #include "TombRaider.h"
     unsigned int getTextureStart();
     unsigned int getTextureOffset();
 
-    //! \fixme should be private
-    entity_t *mLara;
+    Entity &getLara();
 
 private:
 
     void processTextures();
     void processSprites();
     void processMoveables();
-    void processMoveable(int index, int i, int *ent,
-                            std::vector<skeletal_model_t *> &cache2,
-                            std::vector<unsigned int> &cache, int object_id);
+    void processMoveable(int index, int i, int object_id);
     void processModels();
     void processRooms();
+
+#ifdef EXPERIMENTAL
     void setupTextureColor(texture_tri_t *r_tri, float *colorf);
+#endif
 
     char *mName;
     bool mLoaded;
 
     unsigned int mTextureStart;
     unsigned int mTextureOffset;
+
+    unsigned int mLara;
 };
 
 #endif

include/SkeletalModel.h

  *
  * \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_
 #include <vector>
 
 #include "math/math.h"
+#include "TombRaider.h"
+
+class BoneTag {
+public:
+    BoneTag();
 
-typedef struct {
+private:
     int mesh;
     vec3_t off;
     vec3_t rot;
     char flag;
-} bone_tag_t;
+};
 
-typedef struct {
-    std::vector<bone_tag_t *> tag;
+class BoneFrame {
+public:
+    BoneFrame();
+    ~BoneFrame();
+
+    unsigned int size();
+    BoneTag &get(unsigned int i);
+    void add(BoneTag &b);
+
+private:
     vec3_t pos;
-    float yaw;
-} bone_frame_t;
+    vec_t yaw;
+    std::vector<BoneTag *> tag;
+};
 
-typedef struct {
-    int id;
+class AnimationFrame {
+public:
+    AnimationFrame();
+    ~AnimationFrame();
+
+    unsigned int size();
+    BoneFrame &get(unsigned int i);
+    void add(BoneFrame &b);
+
+private:
     char rate;
-    std::vector<bone_frame_t *> frame;
-} animation_frame_t;
+    std::vector<BoneFrame *> frame;
+};
+
+class SkeletalModel {
+public:
+    SkeletalModel(TombRaider &tr, );
+    ~SkeletalModel();
+    int getId();
 
-typedef struct {
+    unsigned int size();
+    AnimationFrame &get(unsigned int i);
+    void add(AnimationFrame &a);
+
+private:
     int id;
     bool tr4Overlay;
     bool pigtails;
     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);
-
-    skeletal_model_t *model; //!< World render model
-
-private:
-    int mBoneFrame;      //!< Bone frame
-    int mAnimationFrame; //!< Animation frame
-    int mIdleAnimation;  //!< Idle animation
+    vec_t ponytailAngle;
+    vec_t ponyOff;
+    vec_t ponyOff2;
+    std::vector<AnimationFrame *> animation;
 };
 
 #endif

include/World.h

 #include <list>
 #include <vector>
 
+#include "Entity.h"
 #include "Room.h"
+#include "SkeletalModel.h"
 #include "Sprite.h"
 
 #include "WorldData.h"
     void destroy();
 
     void addRoom(Room &room);
-
     unsigned int sizeRoom();
-
     Room &getRoom(unsigned int index);
 
     void addSprite(SpriteSequence &sprite);
-
     unsigned int sizeSprite();
-
     SpriteSequence &getSprite(unsigned int index);
 
+    void addEntity(Entity &entity);
+    unsigned int sizeEntity();
+    Entity &getEntity(unsigned int index);
+
+    void addSkeletalModel(SkeletalModel &model);
+    unsigned int sizeSkeletalModel();
+    SkeletalModel &getSkeletalModel(unsigned int index);
+
     /*!
      * \brief Adds mesh to world
      * \param model mesh to add
      */
     void addMesh(model_mesh_t *model);
 
-    /*!
-     * \brief Adds entity to world
-     * \param e entity to add
-     */
-    void addEntity(entity_t *e);
-
-    /*!
-     * \brief Adds model to world.
-     * \param model model to add
-     * \returns next model ID or -1 on error
-     */
-    int addModel(skeletal_model_t *model);
+    model_mesh_t *getMesh(int index);
 
     /*!
      * \brief Move entity in given direction unless collision occurs
      */
     void moveEntity(entity_t *e, char movement);
 
-    model_mesh_t *getMesh(int index);
-    skeletal_model_t *getModel(int index);
-    std::vector<entity_t *> *getEntities();
-
     /*!
      * \brief Find room a location is in.
      *
 private:
 
     // Old World
-    std::vector<entity_t *> mEntities;       //!< World entities
     std::vector<model_mesh_t *> mMeshes;     //!< Unanimated meshes
-    std::vector<skeletal_model_t *> mModels; //!< Skeletal animation models
 
     // New World
     std::vector<Room *> mRooms;
     std::vector<SpriteSequence *> mSprites;
-
-    //std::vector<Entity *> mEntities;
-    //std::vector<SkeletalModel *> mModels;
+    std::vector<Entity *> mEntities;
+    std::vector<SkeletalModel *> mModels;
 };
 
 #endif

include/WorldData.h

 #include "math/math.h"
 #include "SkeletalModel.h"
 
-typedef enum {
-    worldMoveType_walkNoSwim = -1,
-    worldMoveType_walk       = 0,
-    worldMoveType_noClipping = 1,
-    worldMoveType_fly        = 2,
-    worldMoveType_swim       = 3
-} worldMoveType;
-
 /*! \fixme For now shaders are textures on tex objects
  * and materials on color objects. If -1
  * then it doesn't have that information yet.
     vec_t *normals;
 } model_mesh_t;
 
-typedef struct {
-    float pos[3];            //!< World position
-    float angles[3];         //!< Euler angles (pitch, yaw, roll)
-    int room;                //!< Current room entity is in
-    worldMoveType moveType;  //!< Type of motion/clipping
-
-    int state;               //!< State of the Player, AI, or object
-    int objectId;            //!< What kind of entity?
-
-    SkeletalModel *tmpHook;
-} entity_t;
-
 #endif
 

src/Entity.cpp

  * \author xythobuz
  */
 
+#ifdef __APPLE__
+#include <OpenGL/gl.h>
+#include <OpenGL/glu.h>
+#elif defined WIN32
+#include <gl/glew.h>
+#include <gl/wglew.h>
+#else
+#include <GL/gl.h>
+#include <GL/glu.h>
+#endif
+
 #include "Entity.h"
+#include "main.h"
 
 Entity::Entity(TombRaider &tr) {
 
 }
 
+bool Entity::operator<(Entity &o) {
+    vec_t distA = getRender().mViewVolume.getDistToSphereFromNear(pos[0], pos[1], pos[2], 1.0f);
+    vec_t distB = getRender().mViewVolume.getDistToSphereFromNear(o.pos[0], o.pos[1], o.pos[2], 1.0f);
+    return (distA < distB);
+}
+
+void Entity::display() {
+    /*
+    glPushMatrix();
+    glTranslatef(pos[0], pos[1], pos[2]);
+    glRotatef(angles[1], 0, 1, 0);
+    getWorld().getSkeletalModel(skeletalModel).display();
+    glPopMatrix();
+    */
+}
+
+void Entity::setSkeletalModel(unsigned int model) {
+    skeletalModel = model;
+    animationFrame = 0;
+    boneFrame = 0;
+    idleAnimation = 0;
+}
+
 unsigned int Entity::getAnimationFrame() {
     return animationFrame;
 }
 
 void Entity::setAnimationFrame(unsigned int index) {
     animationFrame = index;
+    boneFrame = 0;
 }
 
 unsigned int Entity::getBoneFrame() {

src/Game.cpp

 Game::Game() {
     mLoaded = false;
     mName = NULL;
-    mLara = NULL;
-
+    mLara = 0;
     mTextureStart = 0;
     mTextureOffset = 0;
 }
     }
 }
 
+Entity &Game::getLara() {
+    assert(mLara < getWorld().sizeEntity());
+    return getWorld().getEntity(mLara);
+}
+
 void Game::processSprites() {
     printf("Processing sprites: ");
     for (int i = 0; i < (mTombRaider.NumItems() - 1); i++) {
 
 void Game::processMoveables()
 {
-    std::vector<unsigned int> cache;
-    std::vector<skeletal_model_t *> cache2;
-    tr2_mesh_t *mesh = NULL;
-    tr2_moveable_t *moveable = NULL;
-    tr2_meshtree_t *meshtree = NULL;
-    tr2_item_t *item = NULL;
-    tr2_animation_t *animation = NULL;
-    unsigned short *frame = NULL;
-    tr2_sprite_sequence_t *sprite_sequence = NULL;
-    tr2_object_texture_t *object_texture = NULL;
-    int i, j, object_id;
-    int ent = 0;
     unsigned int statCount = 0;
 
-    frame = mTombRaider.Frame();
-    moveable = mTombRaider.Moveable();
-    meshtree = mTombRaider.MeshTree();
-    mesh = mTombRaider.Mesh();
-    object_texture = mTombRaider.ObjectTextures();
-    item = mTombRaider.Item();
-    animation = mTombRaider.Animation();
-    sprite_sequence = mTombRaider.SpriteSequence();
+    tr2_moveable_t *moveable = mTombRaider.Moveable();
+    tr2_item_t *item = mTombRaider.Item();
+    tr2_sprite_sequence_t *sprite_sequence = mTombRaider.SpriteSequence();
 
     printf("Processing skeletal models: ");
 
-    for (i = 0; i < mTombRaider.NumItems(); ++i)
+    for (int i = 0; i < mTombRaider.NumItems(); ++i)
     {
-        object_id = item[i].object_id;
+        int j;
+        int object_id = item[i].object_id;
 
         // It may not be a moveable, test for sprite
-        if (!(mTombRaider.Engine() == TR_VERSION_1 && item[i].intensity1 == -1))
-        {
-            for (j = 0; j < (int)mTombRaider.NumSpriteSequences(); ++j)
-            {
+        if (!(mTombRaider.Engine() == TR_VERSION_1 && item[i].intensity1 == -1)) {
+            for (j = 0; j < (int)mTombRaider.NumSpriteSequences(); ++j) {
                 if (sprite_sequence[j].object_id == object_id)
                     break;
             }
 
             // It's not a moveable, skip sprite
-            if (j != (int)mTombRaider.NumSpriteSequences())
-            {
-                //printf("s");
-                //fflush(stdout);
+            if (j < (int)mTombRaider.NumSpriteSequences())
                 continue;
-            }
         }
 
-        for (j = 0; j < (int)mTombRaider.NumMoveables(); ++j)
-        {
+        for (j = 0; j < (int)mTombRaider.NumMoveables(); ++j) {
             if ((int)moveable[j].object_id == object_id)
                 break;
         }
 
-        // It's not a moveable or even a sprite?, skip unknown
+        // It's not a moveable or even a sprite? Skip unknown
         if (j == (int)mTombRaider.NumMoveables())
-        {
-            //printf("?"); // what the wolf?
-            //fflush(stdout);
             continue;
-        }
 
-        processMoveable(j, i, &ent, cache2, cache, object_id);
+        processMoveable(j, i, object_id);
         statCount++;
     }
 
-    // Get models that aren't items
     /*
-    for (i = 0; i < mTombRaider.NumMoveables(); ++i)
+    // Get models that aren't items
+    for (int i = 0; i < mTombRaider.NumMoveables(); ++i)
     {
         switch ((int)moveable[i].object_id)
         {
             case 30:
             case 2: // Which tr needs this as model again?
-                processMoveable(i, i, &ent, cache2, cache,
-                        (int)moveable[i].object_id);
+                processMoveable(i, i, (int)moveable[i].object_id);
                 break;
             default:
                 switch (mTombRaider.Engine())
                         switch ((int)moveable[i].object_id)
                         {
                             case TombRaider1::LaraMutant:
-                                processMoveable(i, i, &ent, cache2, cache,
-                                        (int)moveable[i].object_id);
+                                processMoveable(i, i, (int)moveable[i].object_id);
                                 break;
                         }
                         break;
                             case TR4_CROSSBOW_ANIM:
                             case TR4_GRENADE_GUN_ANIM:
                             case TR4_SIXSHOOTER_ANIM:
-                                processMoveable(i, i, &ent, cache2, cache,
-                                        (int)moveable[i].object_id);
+                                processMoveable(i, i, (int)moveable[i].object_id);
                                 break;
                         }
                         break;
 }
 
 // index moveable, i item, sometimes both moveable
-void Game::processMoveable(int index, int i, int *ent,
-        std::vector<skeletal_model_t *> &cache2,
-        std::vector<unsigned int> &cache, int object_id)
+// object_id of item or moveable
+void Game::processMoveable(int index, int i, int object_id)
 {
+    //std::vector<skeletal_model_t *> &cache2
+    //std::vector<unsigned int> &cache
+
+    bool cached = false;
+    for (unsigned int mod = 0; mod < getWorld().sizeSkeletalModel(); mod++) {
+        if (getWorld().getSkeletalModel(mod).getId() == moveable[index].object_id) {
+            cached = true;
+            break;
+        }
+    }
+
+    if (!cached) {
+        getWorld().addSkeletalModel(*new SkeletalModel(mTombRaider /* ... */));
+    }
+
+    getWorld().addEntity(*new Entity(mTombRaider, /* ... */ mod));
+
+
+
     // This creates both Entity and SkeletalModel
     // Basic Idea:
     // - Move animation state from SkeletalModel into Entity
     // - Else store new skeletal model, tell new entity to use this one
 
 
-    skeletal_model_t *r_model = NULL;
-    skeletal_model_t *c_model = NULL;
-    animation_frame_t *animation_frame = NULL;
-    tr2_mesh_t *mesh = NULL;
-    tr2_moveable_t *moveable = NULL;
-    tr2_meshtree_t *meshtree = NULL;
-    tr2_item_t *item = NULL;
-    tr2_animation_t *animation = NULL;
-    tr2_meshtree_t *mesh_tree = NULL;
-    bone_frame_t *bone = NULL;
-    bone_tag_t *tag = NULL;
-    entity_t *thing = NULL;
-    SkeletalModel *sModel = 0x0;
-    unsigned short *frame;
+
+
     int j, k, a, frame_step;
     unsigned int l, frame_offset, frame_count, f;
-    float pos[3];
-    float yaw;
-    bool lara = false;
-    int skyMesh;
-
-    skyMesh = mTombRaider.getSkyModelId();
-    frame = mTombRaider.Frame();
-    moveable = mTombRaider.Moveable();
-    meshtree = mTombRaider.MeshTree();
-    mesh = mTombRaider.Mesh();
-    item = mTombRaider.Item();
-    animation = mTombRaider.Animation();
-
-    pos[0] = item[i].x;
-    pos[1] = item[i].y;
-    pos[2] = item[i].z;
-
-    yaw = ((item[i].angle >> 14) & 0x03);
+
+    unsigned short *frame = mTombRaider.Frame();
+    tr2_moveable_t *moveable = mTombRaider.Moveable();
+    tr2_meshtree_t *meshtree = mTombRaider.MeshTree();
+    tr2_mesh_t *mesh = mTombRaider.Mesh();
+    tr2_item_t *item = mTombRaider.Item();
+    tr2_animation_t *animation = mTombRaider.Animation();
+
+    float yaw = ((item[i].angle >> 14) & 0x03);
     yaw *= 90;
 
-    thing = new entity_t;
-    //thing->id = (*ent)++;
+    entity_t *thing = new entity_t;
     thing->pos[0] = item[i].x;
     thing->pos[1] = item[i].y;
     thing->pos[2] = item[i].z;
     thing->angles[1] = yaw;
     thing->objectId = moveable[index].object_id;
-    //thing->animate = false;
 
-    sModel = new SkeletalModel();
+    SkeletalModel *sModel = new SkeletalModel();
     getRender().addSkeletalModel(sModel);
     thing->tmpHook = sModel; // temp hack to keep a running version during refactoring
 
         {
             case TombRaider1::Wolf:
                 thing->state = TombRaider1::WolfState_Lying;
-                //thing->animate = true;
                 sModel->setAnimation(3);
                 sModel->setFrame(0);
                 break;
     //   return;
     // }
 
-    r_model = new skeletal_model_t;
+    skeletal_model_t *r_model = new skeletal_model_t;
     r_model->id = moveable[index].object_id;
 
     // Gather more info if this is lara
     if (moveable[index].object_id == 0)
     {
-        lara = true;
         mLara = thing; // Mongoose 2002.03.22, Cheap hack for now
 
-        switch (mTombRaider.Engine())
-        {
-            case TR_VERSION_3:
-                sModel->setAnimation(TR_ANIAMTION_RUN);
-                sModel->setIdleAnimation(TR_ANIAMTION_STAND);
-                r_model->tr4Overlay = false;
-                break;
-            case TR_VERSION_4:
-                sModel->setAnimation(TR_ANIAMTION_RUN);
-                sModel->setIdleAnimation(TR_ANIAMTION_STAND);
-                // Only TR4 lara has 2 layer bone tags/meshes per bone frame
-                r_model->tr4Overlay = true;
-                break;
-            case TR_VERSION_1:
-            case TR_VERSION_2:
-            case TR_VERSION_5:
-            case TR_VERSION_UNKNOWN:
-                sModel->setAnimation(TR_ANIAMTION_RUN);
-                sModel->setIdleAnimation(TR_ANIAMTION_STAND);
-                r_model->tr4Overlay = false;
-                break;
-        }
+        sModel->setAnimation(TR_ANIAMTION_RUN);
+        sModel->setIdleAnimation(TR_ANIAMTION_STAND);
 
+        // Only TR4 lara has 2 layer bone tags/meshes per bone frame
+        r_model->tr4Overlay = (mTombRaider.Engine() == TR_VERSION_4);
         r_model->ponytailId = 0;
     }
     else
     {
-        lara = false;
         r_model->ponytailId = -1;
     }
 
     frame_offset = animation[a].frame_offset / 2;
     frame_step = animation[a].frame_size;
 
-    int frame_cycle = 0;
-
     if (a >= (int)mTombRaider.NumAnimations())
     {
         a = mTombRaider.NumFrames() - frame_offset;
     if (frame_step != 0)  // prevent divide-by-zero errors
         a /= frame_step;
 
-    if (a != 0) // prevent divide-by-zero errors
-        frame_offset += frame_step * (frame_cycle % a);
-
     if (a < 0)
     {
         //continue;
         getConsole().print("Invalid animation data for model %d", index);
         delete r_model;
-        return;
+        return; // leaking thing here!
     }
 
     //! \fixme Might be better UID for each model, but this seems to work well
     {
         // Already cached
         delete r_model;
-        c_model = cache2[foundIndex];
-        sModel->model = c_model;
+        r_model = cache2[foundIndex];
+        sModel->model = r_model;
         getWorld().addEntity(thing);
-        getWorld().addModel(c_model);
+        getWorld().addModel(r_model);
         printf("c");
         return;
     }
 
     int aloop = mTombRaider.getNumAnimsForMoveable(index);
 
-#ifdef DEBUG_MOVEABLE
-    printf("\nanimation = %i, num_animations = %i\n",
-            moveable[index].animation, aloop);
-    printf("\nitem[%i].flags = %i\nentity[%i]\n",
-            i, item[i].flags, thing->id);
-#endif
-
     //a = moveable[index].animation;
     //frame_offset = animation[a].frame_offset / 2;
     //frame_step = animation[a].frame_size;
             frame_offset = animation[a].frame_offset / 2,
             frame_step = animation[a].frame_size)
     {
-        animation_frame = new animation_frame_t;
+        animation_frame_t *animation_frame = new animation_frame_t;
         r_model->animation.push_back(animation_frame);
 
         frame_count = (animation[a].frame_end - animation[a].frame_start) + 1;
         animation_frame->rate = animation[a].frame_rate;
 
-#ifdef DEBUG_MOVEABLE
-        printf("animation[%i] state and unknowns = %i, %i, %i, %i, %i\n",
-                a, animation[a].state_id, animation[a].unknown1,
-                animation[a].unknown2, animation[a].unknown3,
-                animation[a].unknown4);
-        printf("animation[%i].frame_rate = %i\n",
-                a, animation[a].frame_rate);
-        printf("animation[%i].next_animation = %i\n",
-                a, animation[a].next_animation);
-        printf("animation[%i].frame_offset = %u\n",
-                a, animation[a].frame_offset);
-        printf("animation[%i].anim_command = %i\n",
-                a, animation[a].anim_command);
-        printf("animation[%i].num_anim_commands = %i\n",
-                a, animation[a].num_anim_commands);
-        printf("animation[%i].state_change_offset = %i\n",
-                a, animation[a].state_change_offset);
-        printf("              frame_offset = %u\n",
-                frame_offset);
-#endif
-
         // Get all the frames for aniamtion
         for (f = 0; f < frame_count; ++f, frame_offset += frame_step)
         {
                 }
             }
 
-#ifdef DEBUG_MOVEABLE
-            printf("animation[%i].boneframe[%u] = offset %u, step %i\n",
-                    a, f, frame_offset, frame_step);
-#endif
-
             // Mongoose 2002.08.15, Was
             //   if (frame_offset + 8 > _tombraider.NumFrames())
             if (frame_offset > mTombRaider.NumFrames())
             {
                 getConsole().print("WARNING: Bad animation frame %i > %i",
                         frame_offset, mTombRaider.NumFrames());
-
-                // Mongoose 2002.08.15, Attempt to skip more likely bad animation data
-                getConsole().print("WARNING: Handling bad animation data...");
                 return; //continue;
             }
 
             // Generate bone frames and tags per frame ////////////
-            bone = new bone_frame_t;
+            bone_frame_t *bone = new bone_frame_t;
             animation_frame->frame.push_back(bone);
 
             // Init translate for bone frame
             // Run through the tag and calculate the rotation and offset
             for (j = 0; j < (int)moveable[index].num_meshes; ++j)
             {
-                tag = new bone_tag_t;
+                bone_tag_t *tag = new bone_tag_t;
                 bone->tag.push_back(tag);
                 tag->off[0] = 0.0;
                 tag->off[1] = 0.0;
                 // Setup offsets to produce skeletion
                 if (j == 0)
                 {
-                    // Since we use bone's offset, these aren't used
-                    tag->off[0] = 0.0;
-                    tag->off[1] = 0.0;
-                    tag->off[2] = 0.0;
-
                     // Always push tag[0], this isn't really used either
                     tag->flag = 0x02;
                 }
                     // Hack: moveable[index].mesh_tree is a byte offset
                     //       into mesh_tree[], so we have to convert to index
                     tree = (int *)(void *)meshtree;
-                    mesh_tree = (tr2_meshtree_t *)&tree[moveable[index].mesh_tree
+                    tr2_meshtree_t *mesh_tree = (tr2_meshtree_t *)&tree[moveable[index].mesh_tree
                         + ((j - 1) * 4)];
 
                     tag->off[0] = mesh_tree->x;
         }
     }
 
-    if (i == skyMesh)
-    {
+    if (i == mTombRaider.getSkyModelId())
         getRender().setSkyMesh(i, //moveable[i].starting_mesh,
                 (mTombRaider.Engine() == TR_VERSION_2));
-    }
-
-    //printf(".");
-    //fflush(stdout);
 }
 
 bool compareFaceTextureId(const void *voidA, const void *voidB)

src/SkeletalModel.cpp

  * \author xythobuz
  */
 
-#include <cstddef>
+#include <assert.h>
+
 #include "SkeletalModel.h"
 
-SkeletalModel::SkeletalModel() {
-    model = NULL;
-    mBoneFrame = 0;
-    mAnimationFrame = 0;
-    mIdleAnimation = 0;
+BoneTag::BoneTag() {
+
 }
 
-SkeletalModel::~SkeletalModel() {
-    // Model is really stored in World and deleted there
-    // Deleting it here causes EXEC_BAD_ACCESS...
-    /* if (model) {
-        for(std::vector<animation_frame_t>::size_type i = 0; i < model->animation.size(); i++) {
-            animation_frame_t *af = model->animation[i];
+BoneFrame::BoneFrame() {
 
-            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];
+BoneFrame::~BoneFrame() {
+    for (unsigned int i = 0; i < tag.size(); i++)
+        delete tag[i];
+}
 
-                if (!bf)
-                    continue;
+unsigned int BoneFrame::size() {
+    return tag.size();
+}
 
-                for(std::vector<bone_tag_t>::size_type k = 0; k < bf->tag.size(); k++) {
-                    if (bf->tag[i])
-                        delete bf->tag[i];
-                }
+BoneTag &BoneFrame::get(unsigned int i) {
+    assert(i < tag.size());
+    return *tag.at(i);
+}
 
-                delete bf;
-            }
+void BoneFrame::add(BoneTag &b) {
+    tag.push_back(&b);
+}
 
-            delete af;
-        }
+AnimationFrame::AnimationFrame() {
 
-        delete model;
-    } */
 }
 
-int SkeletalModel::getAnimation() {
-    return mAnimationFrame;
+AnimationFrame::~AnimationFrame() {
+    for (unsigned int i = 0; i < frame.size(); i++)
+        delete frame[i];
 }
 
-int SkeletalModel::getFrame() {
-    return mBoneFrame;
+unsigned int AnimationFrame::size() {
+    return frame.size();
 }
 
-int SkeletalModel::getIdleAnimation() {
-    return mIdleAnimation;
+BoneFrame &AnimationFrame::get(unsigned int i) {
+    assert(i < frame.size());
+    return *frame.at(i);
 }
 
-void SkeletalModel::setModel(skeletal_model_t *mdl) {
-    if (mdl)
-        model = mdl;
+void AnimationFrame::add(BoneFrame &b) {
+    frame.push_back(&b);
 }
 
-void SkeletalModel::setAnimation(int index) {
-    if (!model) // index > (int)model->animation.size())
-        return;
-
-    animation_frame_t *a = model->animation[index];
+SkeletalModel::SkeletalModel() {
 
-    if (a) {
-        mAnimationFrame = index;
-        mBoneFrame = 0;
-    }
 }
 
-void SkeletalModel::setFrame(int index) {
-    if (!model)
-        return;
-
-    animation_frame_t *a = model->animation[mAnimationFrame];
+SkeletalModel::~SkeletalModel() {
+    for (unsigned int i = 0; i < animation.size(); i++)
+        delete animation[i];
+}
 
-    if (a) { // index > (int)a->frame.size())
-        bone_frame_t *b = a->frame[index];
+int SkeletalModel::getId() {
+    return id;
+}
 
-        if (b)
-            mBoneFrame = index;
-    }
+unsigned int SkeletalModel::size() {
+    return animation.size();
 }
 
-void SkeletalModel::setIdleAnimation(int index) {
-    if (!model)
-        return;
+AnimationFrame &SkeletalModel::get(unsigned int i) {
+    assert(i < animation.size());
+    return *animation.at(i);
+}
 
-    if (model->animation[index])
-        mIdleAnimation = index;
+void SkeletalModel::add(AnimationFrame &a) {
+    animation.push_back(&a);
 }
 

src/World.cpp

 
 #include "World.h"
 
-World::~World()
-{
+World::~World() {
     destroy();
 }
 
-
 // Temp methods for rendering use until more refactoring is done
 model_mesh_t *World::getMesh(int index)
 {
     return mMeshes[index];
 }
 
-skeletal_model_t *World::getModel(int index)
-{
-    return mModels[index];
-}
-
-std::vector<entity_t *> *World::getEntities()
-{
-    return &mEntities;
-}
-
 void World::addMesh(model_mesh_t *mesh)
 {
     if (mesh)
         mMeshes.push_back(mesh);
 }
 
-
-void World::addEntity(entity_t *e)
-{
-    if (e)
-    {
-        e->moveType = worldMoveType_walk; // Walk
-        e->room = getRoomByLocation(e->pos[0], e->pos[1], e->pos[2]);
-        mEntities.push_back(e);
-    }
-}
-
-
-int World::addModel(skeletal_model_t *model)
-{
-    if (model)
-    {
-        mModels.push_back(model);
-        return mModels.size() - 1;
-    }
-
-    return -1;
-}
-
-
 void World::moveEntity(entity_t *e, char movement)
 {
     const float moved = 180.0f;
     return *mSprites.at(index);
 }
 
+void World::addEntity(Entity &entity) {
+    //e->moveType = worldMoveType_walk; // Walk
+    //e->room = getRoomByLocation(e->pos[0], e->pos[1], e->pos[2]);
+    mEntities.push_back(&entity);
+}
+
+unsigned int World::sizeEntity() {
+    return mEntities.size();
+}
+
+Entity &World::getEntity(unsigned int index) {
+    assert(index < mEntities.size());
+    return *mEntities.at(index);
+}
+
+void World::addSkeletalModel(SkeletalModel &model) {
+    mModels.push_back(&model);
+}
+
+unsigned int World::sizeSkeletalModel() {
+    return mModels.size();
+}
+
+SkeletalModel &World::getSkeletalModel(unsigned int index) {
+    assert(index < mModels.size());
+    return *mModels.at(index);
+}
+
 
 int World::getRoomByLocation(int index, float x, float y, float z)
 {
 }
 
 
-void World::destroy()
-{
+void World::destroy() {
     for (unsigned int i = 0; i != mRooms.size(); i++)
         delete mRooms[i];
+    mRooms.clear();
 
     for (unsigned int i = 0; i != mSprites.size(); i++)
         delete mSprites[i];
+    mSprites.clear();
 
-    model_mesh_t *mesh;
-    skeletal_model_t *model;
-    bone_frame_t *boneframe;
-    bone_tag_t *tag;
-    animation_frame_t *animation;
-    std::list<skeletal_model_t *> cache;
-
-    for (std::vector<int>::size_type i = 0; i != mEntities.size(); i++)
+    for (unsigned int i = 0; i != mEntities.size(); i++)
         delete mEntities[i];
+    mEntities.clear();
+
+    for (unsigned int i = 0; i != mModels.size(); i++)
+        delete mModels[i];
+    mModels.clear();
 
     for (std::vector<int>::size_type i = 0; i != mMeshes.size(); i++) {
-        mesh = mMeshes[i];
+        model_mesh_t *mesh = mMeshes[i];
 
         if (!mesh)
             continue;
 
         delete mesh;
     }
-
     mMeshes.clear();
-
-    for (std::vector<int>::size_type i = 0; i != mModels.size(); i++) {
-        model = mModels[i];
-
-        if (!model)
-            continue;
-
-        // No smart pointers, so skip if deleted once  =)
-        bool found = false;
-        for (std::list<skeletal_model_t *>::const_iterator iterator = cache.begin(), end = cache.end(); iterator != end; ++iterator) {
-            if (model == *iterator) {
-                found = true;
-                break;
-            }
-        }
-
-        if (!found)
-            cache.push_back(model);
-        else
-            continue;
-
-        for (std::vector<int>::size_type j = 0; j != model->animation.size(); j++) {
-            animation  = model->animation[j];
-
-            if (!animation)
-                continue;
-
-            for (std::vector<int>::size_type k = 0; k != animation->frame.size(); k++) {
-                boneframe = animation->frame[k];
-
-                if (!boneframe)
-                    continue;
-
-                for (std::vector<int>::size_type l = 0; l != boneframe->tag.size(); l++) {
-                    tag = boneframe->tag[l];
-
-                    if (!tag)
-                        continue;
-
-                    delete tag;
-                }
-
-                delete boneframe;
-            }
-
-            delete animation;
-        }
-
-        delete model;
-    }
-
-    mModels.clear();
 }