MilkShape.h

Go to the documentation of this file.

#ifndef _MILKSHAPE_H_
#define _MILKSHAPE_H_

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "../Graphics/OpenGL/OpenGLRenderer.h"
#include "../Common/OS/Windows.h"
#include "../Math/Matrix.h"
#include "../Math/Vector.h"
#include "Log.h"

//--------------------
// Defines
//--------------------
#define MS_MAX_NAME     32
#define MS_MAX_PATH     256

#define MS_PLAYER_MAX_GUNS      4

#ifndef byte
typedef unsigned char byte;
#endif

//--------------------
// Structs
//--------------------
struct MS_Vec {
        float x, y, z;
        float w;
        float u, v;
        int bone;
};

struct MS_Tri {
        int v[3];
        int n[3];
};

struct MS_Normal {
        float x, y, z;
};

struct MS_KeyFrameRot {
        float time;
        float position[3];
};

struct MS_KeyFramePos {
        float time;
        float position[3];
};

//--------------------
// Functions
//--------------------
void MS_Vec_Transform(MS_Vec *pV, const Mat4 *pM);
void MS_Vec_Transform3(MS_Vec *pV, const Mat4 *pM);

//--------------------
// MS_Material
//--------------------
class MS_Material {
        public:
                MS_Material();
                virtual ~MS_Material();
                void clear();

                void activate();
                void reloadTexture();
                bool loadFromAsciiSegment(const char *path, FILE *file);

        public:
                char    name[MS_MAX_NAME];
                float   ambient[4];
                float   diffuse[4];
                float   specular[4];
                float   emissive[4];
                float   shininess;
                float   transparency;
                char    diffuse_name[MS_MAX_NAME];
                char    alpha_name[MS_MAX_NAME];
                TextureID texture;
};

//--------------------
// MS_Bone
//--------------------
class MS_Bone {
        public:
                MS_Bone();
                virtual ~MS_Bone();
                void clear();

                void initialize();
                void advanceTo(float fCurrentTime);
                void render();
                bool loadFromAsciiSegment(FILE *file);

        public:
                char                    name[MS_MAX_NAME];
                char                    parentName[MS_MAX_NAME];
                MS_Bone                 *parent;
                byte                    flags;
                float                   rotation[3];
                float                   position[3];
                int                             numPosKeys;
                int                             numRotKeys;
                MS_KeyFrameRot  *keyFramesRot;
                MS_KeyFramePos  *keyFramesTrans;
                Mat4                    matRelative;
                Mat4                    matFinal;
};

//--------------------
// MS_Mesh
//--------------------
class MS_Mesh {
        public:
                MS_Mesh();
                virtual ~MS_Mesh();
                void clear();

                bool loadFromAsciiSegment(FILE *file);

                int getNumVertices() { return this->numVertices; }
                MS_Vec *getVertices() { return this->vertices; }
                int getNumTriangles() { return this->numTriangles; }
                MS_Tri *getTriangles() { return this->triangles; }
                int getNumNormals() { return this->numNormals; }
                MS_Normal *getNormals() { return this->normals; }

        public:
                int                     numVertices;
                MS_Vec          *vertices;

                int                     numTriangles;
                MS_Tri          *triangles;

                int                     numNormals;
                MS_Normal       *normals;
};

//--------------------
// MilkShape
//--------------------
class MilkShape {
        public:
                MilkShape();
                virtual ~MilkShape();
                void clear();

                bool linkBones();
                void initializeBones();
                void attachSkin();
                void renderBones();
                bool loadFromAsciiFile(const char *path, const char *filename);
                void advanceAnimation(float deltaTime);
                void render();

                int getNumMeshes() { return this->numMeshes; }
                MS_Mesh *getMeshes() { return this->pMeshes; }

        public:
                int                     numGuns;
                Vec3            guns[MS_PLAYER_MAX_GUNS];

        protected:
                float           fMaxTime;
                float           fCurrentTime;

                int                     numMeshes;
                MS_Mesh         *pMeshes;

                int                     *materialIndices;

                int                     numMaterials;
                MS_Material     *pMaterials;

                int                     numBones;
                MS_Bone         *pBones;
};

#endif

---