C:/Projects/ngn/include/models.h

/***************************************************************************
 *            models.h
 *
 *  Wed Mar 31 10:47:38 2004
 *  Copyright  2004  tite
 *  thierry.schartz@bluebottle.com
 ****************************************************************************/
/*
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program 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 Library General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */
 #ifndef MODELS_H
 #define MODELS_H
 
 #ifdef WIN32
 #include <windows.h>
 #endif

 
 #include <string>
 #include <vector>
 #include "vector2d.h"
 #include "vector3d.h"

namespace ngn {


        namespace core {
                 class AABB;
        }
        class Camera;
        typedef unsigned char byte;
 
                 // animation type
                enum NGNAnimType
                {
                        NGN_ANIM_STAND = 0,
                        NGN_ANIM_RUN,
                        NGN_ANIM_ATTACK,
                        NGN_ANIM_PAIN_A,
                        NGN_ANIM_PAIN_B,
                        NGN_ANIM_PAIN_C,
                        NGN_ANIM_JUMP,
                        NGN_ANIM_FLIP,
                        NGN_ANIM_SALUTE,
                        NGN_ANIM_FALLBACK,
                        NGN_ANIM_WAVE,
                        NGN_ANIM_POINT,
                        NGN_ANIM_CROUCH_STAND,
                        NGN_ANIM_CROUCH_WALK,
                        NGN_ANIM_CROUCH_ATTACK,
                        NGN_ANIM_CROUCH_PAIN,
                        NGN_ANIM_CROUCH_DEATH, 
                        NGN_ANIM_DEATH_FALLBACK,
                        NGN_ANIM_DEATH_FALLFORWARD,
                        NGN_ANIM_DEATH_FALLBACKSLOW,
                        NGN_ANIM_BOOM,
                        NGN_ANIM_MAX_ANIMATIONS = 21
                        
                };
 
                 struct SFace
                {
                        int vertIndex[3];           // indicies for the verts that make up this triangle
                        int coordIndex[3];          // indicies for the tex coords to texture this face
                };

                struct SMaterialInfo
                {
                        char  strName[255];         // The texture name
                        char  strFile[255];         // The texture file name (If this is set it's a texture map)
                        byte  colour[3];             // The color of the object (R, G, B)
                        int   textureID;             // the texture ID
                        float uTile;                // u tiling of texture  (Currently not used)
                        float vTile;                // v tiling of texture  (Currently not used)
                        float uOffset;              // u offset of texture  (Currently not used)
                        float vOffset;              // v offset of texture  (Currently not used)
                } ;

                struct SAnimationInfo
                {
                        char strName[255];          // This stores the name of the animation (Jump, Pain, etc..)
                        int startFrame;             // This stores the first frame number for this animation
                        int endFrame;               // This stores the last frame number for this animation
                };

                struct SObject 
                {
                        int  numVertices;                       // The number of verts in the model
                        int  numFaces;                  // The number of faces in the model
                        int  numTexCoords;                      // The number of texture coordinates
                        int  materialID;                        // The texture ID to use, which is the index into our texture array
                        bool hasTexture;                        // This is TRUE if there is a texture map for this object
                        char strName[255];                      // The name of the object
                        core::Vector3df  *pVerts;                       // The object's vertices
                        core::Vector3df  *pNormals;             // The object's normals
                        core::Vector2df  *pTexCoords;           // The texture's UV coordinates
                        SFace *pFaces;                          // The faces information of the object
                };


                class NGN_API Model
                {
                public:
                        Model();
                        virtual ~Model();

                        void setCurrentAnimation( unsigned int anim );
                        unsigned int getCurrentAnimation();
                        core::AABB* getBBox();
                        void setScaleFactor( float scale );
                        float getScaleFactor();
                        static void setAnimationSpeed( float speed );
                        float getAnimationSpeed();
                        void setPosition( const core::Vector3df& pos );
                        core::Vector3df& getPosition();
                        void setID( int id );
                        int getID() const;
                        void setName( const std::string& name );
                        const std::string& getName() const;
                        int getNumAnimations();
                        
                        virtual bool loadModel( std::string model_file, std::string texture_file ) = 0;
                        virtual void renderModel(  const Camera& cam ) = 0;
            
                        void rotateY( float rotation );

                protected:
                        virtual void calculateBBox() = 0;
                        void setNumObjects( int num_object );
                        int getNumObjects();
                        void setNumMaterials( int num_materials );
                        int getNumMaterials();
                        void setNumAnimations( int num_animations );
                        void setCurrentFrame( int current_frame );
                        int getCurrentFrame();
                        void addAnimation( SAnimationInfo anim );
                        void addMaterial( SMaterialInfo material );
                        void addObject( SObject object );
                                
                        int m_numObjects;                   
                int m_numMaterials;                 
                int m_numAnimations;               
                unsigned int m_currentAnim;                    
                int m_currentFrame;                   
                        std::vector<SAnimationInfo> m_animations; 
                        std::vector<SMaterialInfo> m_materials;   
                        std::vector<SObject> m_frames;   
                        core::AABB* m_bbox;
                        float m_scale;
                        float m_rotation;
                        static float m_animationSpeed;  // default = 5.0f

                        core::Vector3df m_position;
                                                
                        int m_ID;
                        std::string m_name;
                                
                };



}//ngn
#endif /* MODELS_H */

---