CustomCharModelInstance.h

#pragma once
#include "IAttributeFields.h"
#include "CustomCharCommon.h"
#include "CustomCharFace.h"

namespace ParaEngine
{
    class CartoonFace;
    class ParaXModelCanvas;
    class CParaXModel;
    struct LightParams;
    struct AnimIndex;

    class CharModelInstance : public IAttributeFields
    {
    public:
        CharModelInstance();
        virtual ~CharModelInstance();

        ATTRIBUTE_DEFINE_CLASS(CharModelInstance);

        virtual int InstallFields(CAttributeClass* pClass, bool bOverride);

        virtual IAttributeFields* GetChildAttributeObject(const std::string& sName);
        virtual int GetChildAttributeObjectCount(int nColumnIndex = 0);
        virtual int GetChildAttributeColumnCount();
        virtual IAttributeFields* GetChildAttributeObject(int nRowIndex, int nColumnIndex = 0);

    public:
        static std::list <CharModelInstance*> g_listPendingCartoonFaces;

        static std::list <CharModelInstance*> g_listPendingBodyTextures;

        static void ProcessPendingTextures(int nMaxNumber = 20);

        static void AddPendingCartoonFace(CharModelInstance* pendingInstance);
        static bool HasPendingCartoonFace(CharModelInstance* pendingInstance);
        static bool RemovePendingCartoonFace(CharModelInstance* pendingInstance);

        static void AddPendingBodyTexture(CharModelInstance* pendingInstance);
        static bool HasPendingBodyTexture(CharModelInstance* pendingInstance);
        static bool RemovePendingBodyTexture(CharModelInstance* pendingInstance);


        void SetUpperBodyTurningAngle(float fAngle);
        float GetCurrrentUpperBodyTurningAngle();

        void SetUpperBodyUpdownAngle(float fAngle);
        float GetCurrrentUpperBodyUpdownAngle();

        void SetSkin(int nIndex = 0);

        int GetSkin();


        void SetSkinColorMask(DWORD dwColor);

        DWORD GetSkinColorMask();

        bool IsCustomModel();

        void SetCharacterSlot(int nSlotID, int nItemID);

        int  GetCharacterSlot(int nSlotID);

        void SetBodyParams(int skinColor, int faceType, int hairColor, int hairStyle, int facialHair);

        int GetBodyParams(int type);

        void SetDisplayOptions(int bShowUnderwear, int bShowEars, int bShowHair);

        bool GetDisplayOptions(int type);

        bool MapItemTypeToSlot(int nItemType, int& nSlotIndex);

        bool CanItemInSlot(int nItemType, int nSlotIndex);

        void SetModifiedModel();
        void SetModifiedEquipment();
        void SetModified();

        void UpdateBaseModelByEquipment(int slot, int itemnum, int layer, CharTexture &tex);

        void RefreshItem(int slot);


        bool AnimateModel(SceneState * sceneState, const AnimIndex& CurrentFrame, const AnimIndex& NextAnim, const AnimIndex& BlendingAnim, float blendingFactor, IAttributeFields* pAnimInstance = NULL);

        void Draw(SceneState * sceneState, CParameterBlock* materialParams = NULL);

        void BuildShadowVolume(SceneState * sceneState, ShadowVolume * pShadowVolume, LightParams* pLight, Matrix4* mxWorld);

        void AdvanceTime(float fDeltaTime);

        bool InitBaseModel(ParaXEntity * pModel);

        ParaXEntity* GetBaseModel();
        ParaXEntity* GetAnimModel();

        void reset();

        void CastEffect(int nEffectID, int nAttachmentID = ATT_ID_HAND_LEFT, int nSlotID = -1);
        void AddAttachment(ParaXEntity* pModelEntity, int nAttachmentID = ATT_ID_HAND_LEFT, int nSlotID = -1, float fScaling = 1.0, TextureEntity* pReplaceableTexture = NULL);
        void AddAttachment(MeshEntity* pModelEntity, int nAttachmentID = ATT_ID_HAND_LEFT, int nSlotID = -1, float fScaling = 1.0, TextureEntity* pReplaceableTexture = NULL);

        IAttributeFields * GetAttachmentAttObj(int nAttachmentID);

        TextureEntity* GetReplaceableTexture(int ReplaceableTextureID);

        bool  SetReplaceableTexture(int ReplaceableTextureID, TextureEntity* pTextureEntity);

        CartoonFace* GetCartoonFace(bool bCreateIfNotExist = true);

        bool IsSupportCartoonFace();

    public:
        static bool IsStaticMeshAsset(const std::string& filename);

    private:
        std::string makeSkinTexture(const char *texfn, const char *skin);

        std::string makeItemTexture(int region, const char *name);

        std::string makeItemModel(int region, const char *name);

        bool slotHasModel(int i);
        void adjustHairVisibility();
    
        //static DatabaseEntity* m_pDbCharacters;

        void RefreshModel_imp();

        void RefreshEquipment_imp();

        void UpdateGeosetsToModel(CParaXModel* pModel);
        void UpdateTexturesToModel(CParaXModel* pModel);

        /* check whether the model has custom geometry sets */
        bool HasCustomGeosets(CParaXModel* pModel);

    public:
        static const size_t NumItems = 8;

        enum CharSections
        {
            SkinType = 0,
            FaceType = 1,
            FacialHairType = 2,
            HairType = 3,
            UnderwearType = 4
        };

        enum {
            CHAR_TEX = 0,
            HAIR_TEX,
            FUR_TEX,
            CAPE_TEX,
            WING_TEX,
            CARTOON_FACE_TEX,
            NUM_TEX
        };
        asset_ptr<TextureEntity> m_textures[NUM_TEX];

        enum CharGeosets {
            CSET_HAIR = 0,
            CSET_FACIAL_HAIR1 = 1,
            CSET_FACIAL_HAIR2 = 2,
            CSET_FACIAL_HAIR3 = 3,
            CSET_GLOVES = 4,
            CSET_BOOTS = 5,
            CSET_EARS = 7,
            CSET_ARM_SLEEVES = 8,
            CSET_PANTS = 9,
            CSET_WINGS = 10, // newly added 2007.7.7
            CSET_TABARD = 12,
            CSET_ROBE = 13,
            CSET_SKIRT = 14,// newly added 2007.7.8
            CSET_CAPE = 15,
            // TOTAL
            NUM_CHAR_GEOSETS = 16
        };
        int geosets[NUM_CHAR_GEOSETS];

        ref_ptr<ParaXModelCanvas> m_pModelCanvas;

        /* model display information */
        int nSetID; 

        int skinColor; // for customizable character
        int m_skinIndex; // for non-customizable character

        int faceType;
        int hairColor;
        int hairStyle;
        int facialHair;

        //int maxHairStyle, maxHairColor, maxSkinColor, maxFaceType, maxFacialHair;

        int race, gender;

        bool m_bIsCustomModel : 1;
        bool m_bHasCustomGeosets : 1;

        bool showUnderwear, showEars, showHair, showFacialHair:1;
        bool hadRobe : 1;
        bool showAriesPantByItem, showAriesHandByItem, showAriesFootByItem, showAriesGlassByItem:1;
        bool autoHair : 1;

        int equipment[NUM_CHAR_SLOTS];

        DWORD m_dwSkinColorMask;

        CartoonFace * m_cartoonFace;
        CharTexture* m_bodyTexture;

        // temp character skin texture name
        std::string m_sSkinTextureName;

        // temp face texture name
        std::string m_sFaceTextureName;

        //static void LoadCharacterDatabase();
        //DatabaseEntity* GetCharDB();

        /* model pose information */
        float m_fUpperBodyTurningAngle;
        float m_fUpperBodyUpDownAngle;
    private:
        bool m_bNeedRefreshModel;
        bool m_bNeedRefreshEquipment;
        bool m_bNeedComposeBodyTexture;
    };
}