ParaXModelCanvas.h

#pragma once
#include "IAttributeFields.h"

namespace ParaEngine
{
    class CanvasAttachment;
    struct LightParams;

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

        ATTRIBUTE_DEFINE_CLASS(ParaXModelCanvas);
        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:
        bool Animate(SceneState * sceneState, CharacterPose* pPose, int nAnimID = 0, IAttributeFields* pAnimInstance = NULL);
        void Draw(SceneState * sceneState, CParameterBlock* materialParams = NULL);
        void BuildShadowVolume(SceneState * sceneState, ShadowVolume * pShadowVolume, LightParams* pLight, Matrix4* mxWorld);

        void SetAutoCharacterModel(bool bAutoCharacterModel);
        bool InitBaseModel(ParaXEntity * pModel);

        void MountOnModel(ParaXEntity *model, float fScale = 1.0f);
        void UnmountModel();
        bool IsMounted();
        ParaXEntity* GetBaseModel();
        ParaXEntity* GetAnimModel();
        CanvasAttachment* addAttachment(ParaXEntity *model, int id, int slot, float fScale = 1.0f);
        CanvasAttachment* addAttachment(MeshEntity *model, int id, int slot, float fScale = 1.0f);

        void clearAttachments();
        void deleteSlot(int slot);

        CanvasAttachment* GetChild(int id, int slot = -1);

        void deleteAttachment(int nAttachmentID);
    
    public:
        enum _MODEL_LIGHT{
            LT_AMBIENT,
            LT_DIRECTIONAL,
            LT_MODEL_ONLY
        };
        _MODEL_LIGHT m_lightType;

        ref_ptr<CanvasAttachment> m_root;

        bool m_bIsAutoCharacter : 1;

    private:
        asset_ptr<ParaXEntity> m_baseModel;
        asset_ptr<ParaXEntity> m_MountModel;
    };

    typedef ref_ptr<CanvasAttachment> CanvasAttachmentPtr;

    class CanvasAttachment : public IAttributeFields
    {
    public:
        CanvasAttachment();
        CanvasAttachment(CanvasAttachment *parent, ParaXEntity *model, int id, int slot, float scale = 1.0f);
        CanvasAttachment(CanvasAttachment *parent, MeshEntity *model, int id, int slot, float scale = 1.0f);
        virtual ~CanvasAttachment();

        ATTRIBUTE_DEFINE_CLASS(CanvasAttachment);

        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:
        void SetReplaceableTexture(TextureEntity* pTex);
        void SetModel(ParaXEntity* pModel);
        void SetModel(MeshEntity* pModel);

        void SetOffset(float x, float y, float z);

        bool SetupParantTransform(float fCameraToCurObjectDistance = 0.f);

        CanvasAttachment* addChild(ParaXEntity *model, int id, int slot, float scale = 1.0f);
        CanvasAttachment* addChild(MeshEntity *model, int id, int slot, float scale = 1.0f);

        CanvasAttachment* GetChild(int id, int slot = -1);

        IAttributeFields * GetAttributeObject();

        void AttachChild(CanvasAttachment* att);

        void delSlot(int slot);
        void delChildren();
        void delChild(CanvasAttachment* child);
        void delChildByID(int nID);

        void release();
        bool animate(SceneState * sceneState, CharacterPose* pPose, bool bUseGlobal = false, int nAnimID = 0, IAttributeFields* pAnimInstance = NULL);

        void draw(SceneState * sceneState, ParaXModelCanvas *c, CParameterBlock* materialParams = NULL);
        void BuildShadowVolume(SceneState * sceneState, ShadowVolume * pShadowVolume, LightParams* pLight, Matrix4* mxWorld);

    public:
        std::vector< CanvasAttachmentPtr > children;

        CanvasAttachment * parent;

        // model associated with this attachment
        asset_ptr<ParaXEntity> model;
        // static mesh entity, for backward compatibility
        // asset_ptr<MeshEntity> m_pMeshEntity;

        // static mesh object
        ref_ptr<CMeshObject> m_pMeshObject;

        // a replaceable texture for use with the model on this attachment.
        asset_ptr<TextureEntity> texReplaceable;
        

        int id;
        int slot;
        float scale;
        Vector3 m_vOffset;
        bool m_bIsAutoCharacter : 1;
    };

}