ParaWorldAsset.h

#pragma once
#include "TextureEntity.h"
#include "SpriteFontEntity.h"
#include "DatabaseEntity.h"
#include "ParaXEntity.h"
#include "MeshEntity.h"
#include "MiscEntity.h"
#include "SequenceManager.h"
#include "DynamicVertexBufferManager.h"
#include "effect_file.h"
#include "EffectManager.h"

#ifdef USE_DIRECTX_RENDERER
#include "HTMLBrowserManager.h"
#ifdef USE_FLASH_MANAGER
#include "FlashTextureManager.h"
#endif
#include "VoxelMesh/VoxelTerrainManager.h"
#include "CadModel/CadModel.h"
#include <vector>
namespace ParaEngine
{
    class LatentOcclusionQueryBank;
}
#endif

namespace ParaEngine
{
    class CVertexBufferPoolManager;
    class BufferPickingManager;
    struct CBufferPicking;
    using namespace std;

    class CParaWorldAsset : public IAttributeFields
    {
    public:
        CParaWorldAsset(void);
        virtual ~CParaWorldAsset(void);

        ATTRIBUTE_DEFINE_CLASS(CParaWorldAsset);

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

        ATTRIBUTE_METHOD1(CParaWorldAsset, IsAsyncLoading_s, bool*) { *p1 = cls->IsAsyncLoading(); return S_OK; }
        ATTRIBUTE_METHOD1(CParaWorldAsset, SetAsyncLoading_s, bool) { cls->SetAsyncLoading(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CParaWorldAsset, IsAssetManifestEnabled_s, bool*) { *p1 = cls->IsAssetManifestEnabled(); return S_OK; }
        ATTRIBUTE_METHOD1(CParaWorldAsset, EnableAssetManifest_s, bool) { cls->EnableAssetManifest(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CParaWorldAsset, IsUseLocalFileFirst_s, bool*)    { *p1 = cls->IsUseLocalFileFirst(); return S_OK; }
        ATTRIBUTE_METHOD1(CParaWorldAsset, SetUseLocalFileFirst_s, bool)    { cls->SetUseLocalFileFirst(p1); return S_OK; }

        ATTRIBUTE_METHOD(CParaWorldAsset, DeleteTempDiskTextures_s) { cls->DeleteTempDiskTextures(); return S_OK; }
    public:
        static CParaWorldAsset* GetSingleton();

        TextureAssetManager& GetTextureManager();
        CVertexBufferPoolManager& GetVertexBufferPoolManager();
        TextureEntity* GetTexture(const string& sIdentifier);
        TextureEntity* GetDefaultTexture(int nTextureID);
        TextureEntity* LoadTexture(const string&  sIdentifier, const string&  sTextureFileName, TextureEntity::_SurfaceType nSurfaceType = TextureEntity::StaticTexture);

        SpriteFontAssetManager& GetFontManager();
        SpriteFontEntity* GetFont(const string& sIdentifier);
        SpriteFontEntity* LoadGDIFont(const string&  sIdentifier, const string&  pstrFont, DWORD dwSize, bool bIsBold = true);

        DatabaseAssetManager& GetDatabaseManager();
        DatabaseEntity* GetDatabase(const string& sIdentifier);
        DatabaseEntity* LoadDatabase(const string&  sIdentifier, const string&  fileName);

        MeshEntityManager& GetMeshManager();
        MeshEntity* GetMesh(const string& sIdentifier);
        MeshEntity* LoadMesh(const string&  sIdentifier, const string&  sMeshFileName);

        ParaXEntityManager& GetParaXManager();
        ParaXEntity* GetParaX(const string& sIdentifier);
        ParaXEntity* LoadParaX(const string&  sIdentifier, const string&  fileName);
        ParaXEntity* LoadParaXByID(int nAssetID);

        CSequenceManager& GetSequenceManager(){ return m_SequenceManager; };
        SequenceEntity* LoadSequence(const string&  sName);

        EffectManager& GetEffectManager(){ return m_EffectsManager; };
        CEffectFile* LoadEffectFile(const string&  sIdentifier, const string&  sEffectFile);

        DynamicVertexBufferEntity* GetDynamicBuffer(DynamicVBAssetType nBufferType);

        BufferPickingManager& GetBufferPickingManager();
        CBufferPicking* GetBufferPick(const string& sIdentifier);
        CBufferPicking* LoadBufferPick(const string&  sIdentifier);

#ifdef USE_DIRECTX_RENDERER
        inline CHTMLBrowserManager& GetHTMLBrowserManager(){ return m_HTMLBrowserManager; };
        inline VoxelTerrainManager& GetVoxelTerrainManager(){ return m_VoxelTerrainManager; };
#ifdef USE_FLASH_MANAGER
        inline CFlashTextureManager& GetFlashManager(){ return m_FlashManager; };
#endif  
        //-- get resource primitives
        D3DXSpriteEntity* GetD3DXSprite(const string& sIdentifier);
        CadModel* LoadCadModel(const string&  sIdentifier, const string&  sMeshFileName);

        D3DXSpriteEntity* LoadD3DXSprite(const string&  sIdentifier, int nFrames, int nRow, int nCol);

        void CreateXFileParser(LPD3DXFILE* ppParser);
        LPD3DXFILE GetParaXFileParser();

        LPDIRECT3DVERTEXBUFFER9 GetShadowSquareVB(){ return m_pShadowSquareVB; }

        LPDIRECT3DQUERY9        GetOcclusionQuery(){ return m_pOcclusionQuery; }
        LatentOcclusionQueryBank* GetOcclusionQueryBank(int nID = 0);

        int PrintToFile(CParaFile* pOutputFile, DWORD dwSelection = 0xffffffff);
#endif

    public:
        bool RefreshAsset(const char* filename);

        void RenderFrameMove(float fElapsedTime);

        void LoadAsset();
        void UnloadAsset();

        bool UnloadAssetByKeyName(const string& keyname);

        void GarbageCollectAll();

        void    Cleanup();

        HRESULT InitDeviceObjects();    // device independent
        HRESULT RestoreDeviceObjects(); // device dependent
        HRESULT InvalidateDeviceObjects();
        HRESULT DeleteDeviceObjects();
        HRESULT RendererRecreated();

        bool DoAssetSearch(string& AssetFile, const char* searchDir);

        void CreateAttributeModel();

        bool IsAsyncLoading() const;
        void SetAsyncLoading(bool val);

        bool IsAssetManifestEnabled() const;
        void EnableAssetManifest(bool val);

        bool IsUseLocalFileFirst() const;
        void SetUseLocalFileFirst(bool val);
    private:
        void SaveAssetFileMapping();
        void DeleteTempDiskTextures();

    public:
        typedef boost::signals2::signal<void()>  DeviceEvent_Callback_t;

        DeviceEvent_Callback_t OnInitDeviceObjects;
        DeviceEvent_Callback_t OnRestoreDeviceObjects;
        DeviceEvent_Callback_t OnInvalidateDeviceObjects;
        DeviceEvent_Callback_t OnDeleteDeviceObjects;
        DeviceEvent_Callback_t OnRendererRecreated;
        DeviceEvent_Callback_t OnCleanup;

    protected:
        bool m_bUseAssetSearch;

        map<string, string> m_AssetMap;

    private:
        vector<IAttributeFields*> m_attribute_models;

        CSequenceManager                        m_SequenceManager;
        EffectManager                           m_EffectsManager;
        DynamicVertexBufferManager              m_DynamicVBManager;
        bool m_bAsyncLoading;

#ifdef USE_DIRECTX_RENDERER
        LPDIRECT3DVERTEXBUFFER9 m_pShadowSquareVB;
        LPDIRECT3DQUERY9        m_pOcclusionQuery;
        vector<LatentOcclusionQueryBank*> m_pOcclusionQueryBanks;

        AssetManager<D3DXSpriteEntity>          m_D3DXSpriteManager;
#ifdef USE_FLASH_MANAGER
        CFlashTextureManager                    m_FlashManager;
#endif
        CHTMLBrowserManager                     m_HTMLBrowserManager;
        VoxelTerrainManager                     m_VoxelTerrainManager;
        AssetManager<CadModel>                  m_CadModelManager;
        LPD3DXFILE                              m_pDXFile;  // for parsing X file
#endif
    };

}