MeshEntity.h

#pragma once
#include "AssetEntity.h"
#include "ParaXModel/ParaXModel.h"
#include "ParaXModel/ParaXStaticModel.h"

namespace ParaEngine
{
    struct MeshLOD
    {
    public:
        MeshLOD() :m_fromDepthSquared(0.f){}

        float m_fromDepthSquared;

        std::string m_sMeshFileName;

        ref_ptr<CParaXStaticBase> m_pStaticMesh;
        CParaXModelPtr m_pParaXMesh;
    };

    struct MeshLodSortLess :
        public std::binary_function<const MeshLOD&, const MeshLOD&, bool>
    {
        bool operator() (const MeshLOD& mesh1, const MeshLOD& mesh2)
        {
            // sort ascending by depth
            return mesh1.m_fromDepthSquared < mesh2.m_fromDepthSquared;
        }
    };

    //--------------------------------------------------------
    //--------------------------------------------------------
    struct MeshEntity : public AssetEntity
    {
    public:
        friend class CMeshProcessor;
        virtual AssetEntity::AssetType GetType(){return AssetEntity::mesh;};

        void Refresh(const char* sFilename=NULL,bool bLazyLoad = false);

        virtual bool IsLoaded();

        const string& GetFileName();
        
        void SetPrimaryTechniqueHandle(int nHandle);
        int GetPrimaryTechniqueHandle();
        virtual CParameterBlock* GetParamBlock(bool bCreateIfNotExist = false);

        void CreateMeshLODLevel(float fromDepth, const string& sFilename);

        void UpdateManualLodLevel(int index, const string& sFilename);

        int GetLodIndex(float depth) const;

        int GetLodIndexSquaredDepth(float squaredDepth) const;

        void RemoveLodLevels(void);
        HRESULT CreateMeshFromFile_Serial(RenderDevicePtr pDev=NULL, const char* sFileName=NULL);

        HRESULT CreateMeshFromFile_Async(void* pContext, RenderDevicePtr pDev = NULL, const char* sFileName = NULL);

    public:
        MeshEntity(const AssetKey& key)
            :AssetEntity(key),m_nTechniqueHandle(-1), m_pParamBlock(NULL), m_vMin(0,0,0), m_vMax(0,0,0)
        {
        }
        
        virtual HRESULT InitDeviceObjects();
        virtual HRESULT RestoreDeviceObjects();
        virtual HRESULT InvalidateDeviceObjects();
        virtual HRESULT DeleteDeviceObjects();
        virtual void Cleanup();

        virtual IAttributeFields* GetAttributeObject();

        CParaXStaticBase* GetMesh(int nLODIndex = 0);
        ref_ptr<CParaXStaticBase> CreateMesh(const char* sFilename);

        void Init(const char* sFilename=NULL);

        void SetAABB(const Vector3* vMin, const Vector3* vMax){ m_vMin = *vMin; m_vMax = *vMax; }

        const Vector3& GetAABBMin(){return m_vMin;}
        const Vector3& GetAABBMax(){return m_vMax;}

        virtual bool GetBoundingBox(Vector3* pMin, Vector3* pMax);
    public:
        Vector3 m_vMin;
        Vector3 m_vMax;

    private:
        std::vector<MeshLOD> m_MeshLODs;

        int m_nTechniqueHandle;

        CParameterBlock* m_pParamBlock;
    };

    typedef AssetManager<MeshEntity> MeshEntityManager;
}