---

animadead.h

Go to the documentation of this file.

#ifndef MODEL_H
#define MODEL_H
/*
        Animadead: A Skeletal Animation Library
        Copyright (C) 2004 John C. Butterfield

        This library is free software; you can redistribute it and/or
        modify it under the terms of the GNU Lesser General Public
        License as published by the Free Software Foundation; either
        version 2.1 of the License, or (at your option) any later version.

        This library is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
        Lesser General Public License for more details.

        You should have received a copy of the GNU Lesser General Public
        License along with this library; if not, write to the Free Software
        Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

        John C. Butterfield
        johnb003@hotmail.com
*/

#include "vertex.h"

#include <string>
#include <vector>
#include <map>
#include <cstdlib>
#include <cstdio>

namespace jb
{
/**************************************************************************************
        Mesh Stuff
**************************************************************************************/
        struct SuperVertex                                                      // this is is all the information about each vertex
        {
                float x,y,z,a,b,c,u,v;                                  // x,y,z is the point, a,b,c is the normal, and u,v are the texture coordinates
                float *weights;                                                 // the size is Mesh::numInfluencestores, the index is the bone, and the value is the weight
                std::vector<unsigned int> nonzeros;             // nonzeros is a list of all of the indicies of bones that have some influence on this vertex

                SuperVertex();
                ~SuperVertex();
        };

        struct Face
        {
                unsigned int numIndices;
                unsigned int *indices;                                  // refers to the index of the vertex

                Face();
                ~Face();
        };

        class UserFunction
        {
        public:
                virtual void operator()(std::string filename, void *&userdata) {}
        };

        struct Surface                                                          // a surface is a mesh that contains a uv map, a texture and the mesh data.
        {                                                                                       // it's abstracted from a 'Mesh' to allow different textures within the same model for more detail
                unsigned int nameLength;
                char *texturename;                                              // every time a texture filename is read from the file, it passes it and the user data to the user function
                unsigned int numVerts;
                SuperVertex *superVerts;
                unsigned int numFaces;
                void *userData;                                                 // this can be used to store information about the surface. It is called when the user function is called
                Face *faces;

                Surface();
                void scaleto(const Surface &cp);                // used to create a bare structure with just enough space to accomidate data that changes between keyframes.
                ~Surface();
        };

        struct Mesh
        {
                unsigned int numInfluence;                              // number of bones that affect this mesh (if 0, mesh is static)
                unsigned int *influences;                               // the list of influences (if any) are the indicies of the bones relivant to this model
                unsigned int numSurfaces;
                Surface *surfaces;

                Mesh(std::string filename, UserFunction *loader = 0); // Loads a mesh from a .jbm file
                Mesh();
                ~Mesh();
                void scaleto(const Mesh &cp);                   // same as scaleto for Surface
        };

        class MeshCacher                                                        // loads a mesh and keeps track of the instances of previously loaded meshes.
        {
                MeshCacher();                                                   // singleton, use MeshCacher::instance() to use it.
                static MeshCacher *inst;
                std::map<std::string, Mesh *> cache;

        public:
                ~MeshCacher();
                static MeshCacher *instance();
                void release();
                Mesh *GetMesh(std::string filename, UserFunction *fp = 0);      // returns instance of loaded .jbm file, or loads it if it isn't already.
        };

/**************************************************************************************
        Anim Stuff
**************************************************************************************/
        struct Matrix                                                           // used to represent the orientation of each bone
        {
                float matrix[4][4];
        };

        struct Frame                                                            // a single frame of an animation
        {
                Matrix *bones;
                Vertex keyframeVelocity;                                // this vector represents the offset of the root bone from the previous frame to the current

                Frame();
                ~Frame();
        };

        struct Anim                                                                     // a collection of sampled frames making up an animation
        {
                unsigned int numFrames;
                Frame *frames;

                Anim(std::string filename);                             // loads a .jba file
                ~Anim();
        };

        class AnimCacher                                                        // loads an animation and keeps track of the instances of previously loaded animations.
        {
                AnimCacher();                                                   // singleton, use MeshCacher::instance() to use it.
                static AnimCacher *inst;
                std::map<std::string, Anim *> cache;

        public:
                ~AnimCacher();

                static AnimCacher *instance();
                void release();
                Anim *GetAnim(std::string filename);    // returns instance of loaded .jba file, or loads it if it isn't already.
        };

        class AnimPlayer                                                        // needed to play a single instance of an animation at different frames.
        {
                float timeweight;
                Vertex *currentPosition;
                Vertex *lastPosition;
                bool _animFinished;

        public:
                unsigned int previousFrame;
                Anim *anim;

                AnimPlayer(Anim *anim, unsigned int startFrame = 0);
                ~AnimPlayer();
                void GetKeyframeVelocity(Vertex *tempVel);
                void GetVelocity(Vertex *tempVel);
                void Update(float time);
                void Update(unsigned int framesPassed);
                bool getAnimFinished() { return _animFinished; }
                void reset() { previousFrame = 0; }
        };

/**************************************************************************************
        Model Base
**************************************************************************************/
        enum ModelType {
                STATIC,
                DEFORMABLE
        };

        class Model
        {
        protected:
                bool originSubtraction;
                float timeweight;
                AnimPlayer *velocityControl;
                AnimPlayer *_currentAnim;
                        // a model can be made up of several meshes
                std::vector<Mesh *> bindMesh;
                std::vector<Mesh *> *previousMesh;
                std::vector<Mesh *> *nextMesh;
                std::vector<AnimPlayer *> anims;
                std::vector<unsigned int> animFromBone;
                UserFunction *fp;
                ModelType type;
        public:
                Model(ModelType type, UserFunction *texture_loader = 0);
                virtual ~Model();
                unsigned int AddMesh(std::string filename);
                void SwapMesh(unsigned int index, std::string filename);
                unsigned int AddAnim(std::string filename, unsigned int startFrame = 0);
                void SwapAnim(unsigned int index, std::string filename, unsigned int startFrame = 0);
                void GetTransform(unsigned int bone, Matrix &matrix);
                void Bind(unsigned int bone, unsigned int anim);
                void MovingOrigin(bool);
                void OriginAnim(unsigned int index);
                void GetKeyframeVelocity(Vertex *velocity);
                void GetVelocity(Vertex *velocity);
                void Update(float timestep);            // time in seconds.
                void UpdateMeshes();
                void Reset() { _currentAnim->reset(); }
                bool getAnimFinished() { if (_currentAnim) return _currentAnim->getAnimFinished(); else return true; }
        };
}

#endif // MODEL_H

---