MeshObject.h

#pragma once
#include "TileObject.h"


namespace ParaEngine
{
    class CViewCullingObject;
    class CMeshObject : public CTileObject
    {
    public:
        virtual CBaseObject::_SceneObjectType GetType(){return CBaseObject::MeshObject;};
        CMeshObject(void);
        virtual ~CMeshObject(void);

        virtual void SetPosition(const DVector3 & v);

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

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

        virtual void Reset();

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

        virtual int GetAnimation();

        virtual void SetAnimFrame(int nFrame);

        virtual int GetAnimFrame();

        virtual bool ViewTouch();

        virtual void SetUseGlobalTime(bool bUseGlobalTime);

        virtual bool IsUseGlobalTime();

        virtual bool IsPersistent();

        virtual void SetPersistent(bool bPersistent);

    public:

        // implementation of IAttributeFields

        virtual int GetAttributeClassID(){return ATTRIBUTE_CLASSID_CMeshObject;}
        virtual const char* GetAttributeClassName(){static const char name[] = "CMeshObject"; return name;}
        virtual const char* GetAttributeClassDescription(){static const char desc[] = ""; return desc;}
        virtual int InstallFields(CAttributeClass* pClass, bool bOverride);
        ATTRIBUTE_SUPPORT_CREATE_FACTORY(CMeshObject);
        ATTRIBUTE_METHOD1(CMeshObject, IsFaceCullingDisabled_s, bool*)      {*p1 = cls->IsFaceCullingDisabled(); return S_OK;}
        ATTRIBUTE_METHOD1(CMeshObject, SetFaceCullingDisabled_s, bool)      {cls->SetFaceCullingDisabled(p1); return S_OK;}
    public:
        // -- for init and delete
        HRESULT InitObject(MeshEntity* ppMesh, TextureEntity* ppTexture, Vector3 vPos);
        virtual HRESULT InitDeviceObjects();
        HRESULT RestoreDeviceObjects();
        HRESULT InvalidateDeviceObjects();
        virtual void Cleanup();

        // animate the object
        virtual void Animate( double dTimeDelta, int nRenderNumber=0 );

        // -- for rendering
        virtual HRESULT Draw( SceneState * sceneState);
    
        HRESULT DrawInner( SceneState * sceneState, const Matrix4* pMxWorld=0, float fCameraToObjectDist=0.f, CParameterBlock* materialParams = NULL);

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

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

        virtual AssetEntity* GetPrimaryAsset(){return (AssetEntity*)m_ppMesh.get();};               // used as KEY for batch rendering

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

        virtual bool HasAlphaBlendedObjects();

        virtual bool IsTransparent(){return m_bIsTransparent;};

        virtual void SetTransparent(bool bIsTransparent){m_bIsTransparent = bIsTransparent;};

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

        void SetLocalTransform(float fScale, float fRotX, float fRotY, float fRotZ);
        void SetLocalTransform(float fScale, const Quaternion& quat);
        void GetLocalTransform(float* fScale, Quaternion* quat);
    
        virtual IViewClippingObject* GetViewClippingObject();

        void ForceNoLight(bool bNoLight);
        bool IsNoLight();

        virtual int GetNumReplaceableTextures();

        virtual TextureEntity* GetDefaultReplaceableTexture(int ReplaceableTextureID); 

        virtual TextureEntity* GetReplaceableTexture(int ReplaceableTextureID); 

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

        void SearchXRefObject();

        int GetXRefInstanceCount();

        XRefObject* GetXRefInstanceByIndex(int nIndex);

        void CleanupXRefInstances();

        //int GetXRefMeshCount();

        //XRefObject* GetXRefMeshByIndex(int nIndex);

        //void CleanupXRefMesh();

    
        int GetXRefScriptCount();

        const char* GetXRefScript(int nIndex);

        Vector3 GetXRefScriptPosition(int nIndex);

        Vector3 GetXRefScriptScaling(int nIndex);

        float GetXRefScriptFacing(int nIndex);

        const char* GetXRefScriptLocalMatrix(int nIndex);


        void SetFaceCullingDisabled(bool bDisableFaceCulling);

        bool IsFaceCullingDisabled();
    private:

        bool SetParamsFromAsset();

    protected:
        CViewCullingObject* m_pViewClippingObject;

        Matrix4            m_mxLocalTransform;

        asset_ptr<MeshEntity>       m_ppMesh;
        vector< asset_ptr<TextureEntity> >      m_ReplaceableTextures;

        vector<XRefObject*> m_XRefObjects;
    
        asset_ptr<TextureEntity>          m_ppTexture;                  

        float       m_fCtorPercentage;

        int m_nAnimID;

        int m_nAnimFrame;

        bool m_bUseGlobalTime;

        bool m_bIsTransparent;

        bool m_bForceNoLight;

        bool m_bDisableFaceCulling;

        bool m_bViewClippingUpdated;

        bool m_XRefSearched;

        bool m_bIsPersistent;

        friend class CMeshPhysicsObject;
        friend class CSkyMesh;
    };
}