---

GXModel.h

Go to the documentation of this file.

#ifndef __GXMODEL_H
#define __GXMODEL_H


#include "GXStandardDefines.h"
#include "GXSkeleton.h"
#include "GXVertex.h"
#include "GXHashableString.h"
#include "GXBone.h"
#include "GXSphere.h"


struct SRenderCall
{
        UINT    uAnimationIndex;
        float   fAnimationPos;
        float   fLOD;

        SGXAnimationKeyFrame RootPos;

        D3DXVECTOR4 vLightDir;
        D3DXVECTOR4 vEyePos;

};



#define TEXTURE_MAP_COUNT 1
#define MODEL_DIFFUSE_TEXTURE_INDEX 0

class CGXModel
{
public:
        CGXModel();
        virtual ~CGXModel();

        virtual bool    AddAnimation(CGXKeyframeTemplate<SGXAnimationKeyFrame>* pAnimations);//count = bone count

        virtual bool    LoadFromStream(CGXDeviceContainer* pDevice, 
                                                                IStream* pStream);

        virtual bool    LoadFromData(CGXDeviceContainer* pDevice,
                                                                GXVertex* pVerts,
                                                                UINT* pIndices,
                                                                DWORD dwVertCount,
                                                                DWORD dwIndexCount,
                                                                char** ppTextureNames,//array of sizeTEXTURE_MAP_COUNT
                                                                UINT uBoneCount,
                                                                CGXBone* pBones,
                                                                float fDesiredSize);//each row is an animation, each column is a bone

        virtual bool    WriteToStream(IStream* pStream);

        virtual bool    LoadFromD3DXMesh(ID3DXMesh* pMesh,
                                                                        float fDesiredSize);
                                                                

        virtual bool    DrawPrimitive(SRenderCall& RenderInfo, 
                                                                UINT uVertexStream, 
                                                                UINT uTextureStream,
                                                                UINT uStartBoneConstant,
                                                                D3DXMATRIX* pViewProj,
                                                                UINT uViewProjIndex,
                                                                D3DXMATRIX* pOptionalWorldMat=NULL);

        virtual UINT    GetVertexCount();
        virtual UINT    GetIndexCount();
        virtual UINT    GetFaceCount();

        
        virtual UINT    GetBoneCount();
        virtual UINT    GetAnimationCount();

        inline IDirect3DTexture8* GetTexture(UINT uIndex)
        {
                if(uIndex>=TEXTURE_MAP_COUNT)
                {
                        return NULL;
                }
                return m_rgpTextures[uIndex];
        }

        inline  bool    ReadyToRender()
        {
                return (m_pMesh!=NULL);
        }

        inline float GetDiffuseFactor()
        {
                return m_fDiffuseFactor;
        }

        inline float GetSpecularCooef()
        {
                return m_fSpecularCooef;
        }

        inline void SetDiffuseFactor(float fFactor)
        {
                m_fDiffuseFactor=fFactor;
        }

        inline void SetSpecularCooef(float fNewCooef)
        {
                m_fSpecularCooef=fNewCooef;
        }



protected:
        ID3DXPMesh*                     m_pMesh;
        CGXDeviceContainer*     m_pDevice;
        CGXSkeleton                     m_Skeleton;
        IDirect3DTexture8*      m_rgpTextures[TEXTURE_MAP_COUNT];
        float                           m_fBoundingSphereRadius;

        float                           m_fDiffuseFactor;//lerp amount between diffuse and spec
        float                           m_fSpecularCooef;//higher (like 50)==sharper specular



protected:
        virtual void    Cleanup();
        virtual DWORD   GetOptions(CGXDeviceContainer* pDevice);
};


#endif

---