MeshPhysicsObject.h

#pragma once
#include "TileObject.h"

namespace ParaEngine
{
    class CMeshObject;
    struct IParaPhysicsActor;
    class CPhysicsWorld;
    struct MeshEntity;

    class CMeshPhysicsObject : public CTileObject
    {
    public:
        virtual CBaseObject::_SceneObjectType GetType(){ return CBaseObject::MeshPhysicsObject; };
        virtual std::string ToString(DWORD nMethod);
        CMeshPhysicsObject(void);
        virtual ~CMeshPhysicsObject(void);

    private:
        void CreateMeshObject();

        void SetParamsFromAsset();

        vector<IParaPhysicsActor*> m_staticActors;

        bool m_bIsPersistent;

    public:

        // implementation of IAttributeFields

        virtual int GetAttributeClassID(){ return ATTRIBUTE_CLASSID_CMeshPhysicsObject; }
        virtual const char* GetAttributeClassName(){ static const char name[] = "CMeshPhysicsObject"; return name; }
        virtual const char* GetAttributeClassDescription(){ static const char desc[] = ""; return desc; }
        virtual int InstallFields(CAttributeClass* pClass, bool bOverride);

        ATTRIBUTE_SUPPORT_CREATE_FACTORY(CMeshPhysicsObject);
        ATTRIBUTE_METHOD1(CMeshPhysicsObject, IsFaceCullingDisabled_s, bool*)       { *p1 = cls->IsFaceCullingDisabled(); return S_OK; }
        ATTRIBUTE_METHOD1(CMeshPhysicsObject, SetFaceCullingDisabled_s, bool)       { cls->SetFaceCullingDisabled(p1); return S_OK; }

    public:
        void SetFaceCullingDisabled(bool bDisableFaceCulling);

        bool IsFaceCullingDisabled();

        virtual void SetPhysicsGroup(int nGroup);
        virtual int GetPhysicsGroup();

        int GetStaticActorCount();

        virtual bool CanHasPhysics();

        HRESULT InitObject(MeshEntity* ppMesh, float fOBB_X, float fOBB_Y, float fOBB_Z, bool bApplyPhysics, const Matrix4& localTransform);

        virtual void Cleanup();

        virtual void Rotate(float x, float y, float z);

        virtual void SetRotation(const Quaternion& quat);
        virtual void GetRotation(Quaternion* quat);

        virtual void SetScaling(float s);
        virtual float GetScaling();

        virtual void Reset();

        virtual void SetAnimation(int nAnimID);

        virtual int GetAnimation();

        virtual void SetAnimFrame(int nFrame);

        virtual int GetAnimFrame();

        virtual void SetUseGlobalTime(bool bUseGlobalTime);

        virtual bool IsUseGlobalTime();

        virtual void SetLocalTransform(const Matrix4& mXForm);
        virtual void GetLocalTransform(Matrix4* localTransform);

        virtual void SetBoundingBox(float fOBB_X, float fOBB_Y, float fOBB_Z, float fFacing);
        virtual void SetBoundRect(FLOAT fWidth, FLOAT fHeight, FLOAT fFacing);
        virtual void SetRadius(FLOAT fRadius);

        virtual Matrix4* GetRenderMatrix(Matrix4& out, int nRenderNumber = 0);

        virtual Matrix4* GetAttachmentMatrix(Matrix4& pOut, int nAttachmentID = 0, int nRenderNumber = 0);

        virtual bool HasAttachmentPoint(int nAttachmentID = 0);

        virtual bool IsPersistent();
        virtual void SetPersistent(bool bPersistent);

        CMeshObject* GetMeshObject();
        virtual void LoadPhysics();
        virtual void UnloadPhysics();

        virtual void SetAlwaysLoadPhysics(bool bEnable);

        virtual bool ViewTouch();

        virtual void EnablePhysics(bool bEnable);
        virtual bool IsPhysicsEnabled();

        virtual void CompressObject(CompressOption option = (CompressOption)0xffff);
        virtual void SetPosition(const DVector3 & v);
        virtual void SetYaw(float fFacing);

        // animate the object
        virtual void Animate(double dTimeDelta, int nRenderNumber = 0);
        virtual HRESULT Draw(SceneState * sceneState);
        // used as KEY for batch rendering
        virtual AssetEntity* GetPrimaryAsset();
        virtual IViewClippingObject* GetViewClippingObject();
        virtual int GetPrimaryTechniqueHandle();
        virtual void SetPrimaryTechniqueHandle(int nHandle);
        virtual CParameterBlock* GetEffectParamBlock(bool bCreateIfNotExist = false);

        virtual float GetCtorPercentage();
        virtual void SetCtorPercentage(float fPercentage);
        virtual void AutoSelectTechnique();

        virtual void SetOnAssetLoaded(const char* sCallbackScript);

        virtual void OnSelect(int nGroupID);
        virtual void OnDeSelect();

        virtual bool IsTransparent();

        virtual void SetTransparent(bool bIsTransparent);


        virtual bool HasAlphaBlendedObjects();

        virtual int GetNumReplaceableTextures();

        virtual TextureEntity* GetDefaultReplaceableTexture(int ReplaceableTextureID);

        virtual TextureEntity* GetReplaceableTexture(int ReplaceableTextureID);

        virtual bool  SetReplaceableTexture(int ReplaceableTextureID, TextureEntity* pTextureEntity);

    protected:
        // any bit wise combination of PHYSICS_METHOD
        DWORD m_dwPhysicsMethod;

        unsigned int m_nPhysicsGroup;
        union{
            CMeshObject * m_pMeshObject;
        };

    };
}