Bone.h

#ifndef __BONE_H__
#define __BONE_H__

#include "utils.h"
#include "ModelUtils.h"
#include "GeosetAnim.h"
#include "Texture.h"
#include <vector>
using namespace std;

namespace ParaEngine
{
class CSkeleton;

//line near 
struct LinearKeyFrame3{
    int         frameNum;
    D3DXVECTOR3 vec;
};
struct NonLinearKeyFrame3{
    int         frameNum;
    D3DXVECTOR3 vec;
    D3DXVECTOR3 inTan;
    D3DXVECTOR3 outTan;
};
struct LinearKeyFrame4{
    int         frameNum;
    D3DXQUATERNION  vec;
};
struct NonLinearKeyFrame4{
    int         frameNum;
    D3DXQUATERNION  vec;
    D3DXQUATERNION  inTan;
    D3DXQUATERNION  outTan;
};

class CBone1
{
public:
    CBone1(void);
    ~CBone1(void);

    void        Read(TypePointer inP,int inSize);

    int         GetGeosetID()       { return geosetID; };
    int         GetGeosetAnimID()   { return geosetAnimID; };
    void        SetGeosetAlpha(float alpha) {geosetAnimAlpha=alpha;};
    float       GetGeosetAlpha()    {return geosetAnimAlpha;};

    char*       GetBoneName()   { return boneName; };
    int         GetObjectID()   { return objectID; };
    int         GetParentID()   { return parentID; };

    D3DXMATRIX* GetFinalTransformMatrix() { return &finalMatrix; };
    D3DXMATRIX* GetCombinedTransformMatrix() { return &combinedMatrix; };
    D3DXMATRIX* CalcTransformMatrix(D3DXVECTOR3* center, const AnimInfo& animInfo,const D3DXMATRIX* parentMatrix);

    D3DXMATRIX* TransformMatrixMultiply(const D3DXMATRIX* matrix);

private:
bool            GetTransferMatrix(D3DXVECTOR3* vec,const AnimInfo& animInfo);
bool            GetTransferMatrixNoneBlending(D3DXVECTOR3* vec,const AnimInfo& animInfo);
bool            GetRotationMatrix(D3DXQUATERNION* quat,const AnimInfo& animInfo);
bool            GetRotationMatrixNoneBlending(D3DXQUATERNION* quat,const AnimInfo& animInfo);
bool            GetScaleMatrix(D3DXVECTOR3* vec,const AnimInfo& animInfo);
bool            GetScaleMatrixNoneBlending(D3DXVECTOR3* vec,const AnimInfo& animInfo);
bool            CheckHideByScale(const AnimInfo& animInfo);

public:

    enum LineType{
        NOT_INTERP=0,
        LINEAR,         
        HERMITE,
        BEZIER
    };

    enum MotionType{
        KGRT=0, 
        KGSC=1,
        KGTR=2,
        MAX_MOTION=3
    };

    int         objectID; 
    int         parentID; 
    int         nextID;   
    D3DXMATRIX  localMatrix;    
    D3DXMATRIX  combinedMatrix; 
    D3DXMATRIX  offsetMatrix;   
    D3DXMATRIX  finalMatrix;    


private:
    char*       boneName;
    int         nodeType;

    //key frames count
    int                 keyFrameCount[MAX_MOTION];  
    //Linear Type 
    int                 lineType[MAX_MOTION];   
    void*               keyFrames[MAX_MOTION];  

    int         geosetID;       
    int         geosetAnimID;   

    float       geosetAnimAlpha;
public:
    friend  class CMDXModel;
    friend  class CSkeleton;
};



class CBone2
{
public:
    CBone2(void);
    ~CBone2(void);

    void        Read(TypePointer &inP);

    D3DXMATRIX* GetFinalTransformMatrix() { return &transformMatrix; };
    D3DXMATRIX* CalcTransformMatrix(D3DXVECTOR3* center, const AnimInfo& animInfo,const D3DXMATRIX* parentMatrix);

private:
    
bool            GetTransferMatrix(D3DXVECTOR3* vec,const AnimInfo& animInfo);
bool            GetRotationMatrix(D3DXQUATERNION* quat,const AnimInfo& animInfo);
bool            GetScaleMatrix(D3DXVECTOR3* vec,const AnimInfo& animInfo);
bool            CheckHideByScale(const AnimInfo& animInfo);

public:

    int count;

    //Linear Type (0:don't interpret;1:linear;2:hermite;3:bezier)
    enum LineType{
        NOT_INTERP=0,
        LINEAR,
        HERMITE,
        BEZIER
    };

    enum MotionType{
        KGTR=0,
        KGRT,
        KGSC,
        MAX_MOTION
    };

private:
    //key frames count
    int                 keyFrameCount[MAX_MOTION];
    //Linear Type 
    int                 lineType[MAX_MOTION];
    void*               keyFrames[MAX_MOTION];

    D3DXMATRIX  transformMatrix;
};





#define MDX_MAX_PARTICLES   100

typedef struct                      // Create A Structure For Particle
{
    bool    used;
    bool    activated;                  // Active (Yes/No)
    float   life;                   // Particle Life
    float   fade;                   // Fade Speed
    float   r;                      // Red Value
    float   g;                      // Green Value
    float   b;                      // Blue Value
    float   x;                      // X Position
    float   y;                      // Y Position
    float   z;                      // Z Position
    float   xi;                     // X Direction
    float   yi;                     // Y Direction
    float   zi;                     // Z Direction
    float   xg;                     // X Gravity
    float   yg;                     // Y Gravity
    float   zg;                     // Z Gravity
} MyParticle;                           // Particle Structure




class CEmitter
{
public:
    CEmitter(void);
    ~CEmitter(void);

    void        Read(TypePointer inP,int inSize);
    void        Render(D3DXMATRIX *parentMatrix, D3DXVECTOR3 *center, const AnimInfo& animInfo, long texbindid, long texwidth, long texlength);
    void        SetCurrentOptions(const AnimInfo& animInfo);
    
    char*       GetName()       { return eName; };
    long        GetObjectID()   { return objectID; };
    long        GetParentID()   { return parentID; };
    
    struct TVisibility
    {
        long kframe;
        float f;
    };


    MyParticle Particles[MDX_MAX_PARTICLES];    // Particle Array (Room For Particle Info)  

    
    char*           eName;
    long            objectID;
    long            parentID;
    long            Flags;
    CBone2          bone;
    float           curSpeed;
    float           Variation;
    float           Latitude;
    float           Gravity;
    float           Lifespan;
    float           curEmissionRate;
    float           curLength;
    float           curWidth;
    long            FilterMode;
    long            Rows;
    long            Columns;
    long            Flag2;
    float           TailLength;
    float           Time;

    struct colors3
    {           
        float   B;
        float   G;
        float   R;
    } SegmentColor[3];

    unsigned char   Alpha1, Alpha2, Alpha3;
    float           ScalingX, ScalingY, ScalingZ;
    long            LifeSpanUVAnim1, LifeSpanUVAnim2, LifeSpanUVAnim3;
    long            DecayUVAnim1, DecayUVAnim2, DecayUVAnim3;
    long            TailUVAnim1, TailUVAnim2, TailUVAnim3;
    long            TailDecayUVAnim1, TailDecayUVAnim2, TailDecayUVAnim3;
    long            TextureID;
    long            Squirt;
    long            PriorityPlane;
    long            ReplaceableID;

    long            numParticles;

    TVisibility*    Visibility;
    long            numVisibility;
    float           curVisibility;

    TVisibility*    EmissnRate;
    long            numEmissnRate;

    TVisibility*    Length;
    long            numLength;

    TVisibility*    Width;
    long            numWidth;

    TVisibility*    Speed;
    long            numSpeed;
};



#define MAX_NUM_EMMITTERS   4

class CEmitters
{
public:
    CEmitters(void);
    ~CEmitters(void);
    void Cleanup();

    void        Read(TypePointer inP,int inSize);
    void        Render(const AnimInfo& animInfo, const CSkeleton *skel, CTexture *curtex);

    long        numEmitters;
    UINT        nEmitterArraySize;
    CEmitter*   Emitters;       // array
};

class CSkeleton
{
public:
    CSkeleton(void);
    ~CSkeleton(void);
    
    void        Cleanup();

    void        ReadGeosetAnims(TypePointer inP,int inSize);
    void        ReadHelpers(TypePointer inP,int inSize);
    void        ReadBones(TypePointer inP,int inSize);
    void        ReadPivotPoints(TypePointer inP,int inSize);

    void        SortBones();
    void        CalcTransformMatrix(const AnimInfo& animInfo);

    float       GetTransformMatrix(D3DXMATRIX &mat,float& animAlpha,int *index,int count);

    CBone1*     CreateNewBone();

private:
    void        CalcTransformMatrix(const AnimInfo& animInfo,D3DXMATRIX *parentMatrix,int parentID);

public:
    CGeosetAnim     geosetAnims;
    int         nFirstBoneID;

    vector <CBone1*> bones;

    CEmitters       BlizEmitters2;          
};

}
#endif //__BONE_H__