AssetEntity.h

#pragma once
#include "IAttributeFields.h"
#include "VertexFVF.h"

#include <set>
#include <map>

namespace ParaEngine
{
    typedef std::string AssetKey;

    struct AssetEntity : public IAttributeFields
    {
    public:
        AssetEntity();
        AssetEntity(const AssetKey& key);
        virtual ~AssetEntity();
        ATTRIBUTE_DEFINE_CLASS(AssetEntity);

        virtual int InstallFields(CAttributeClass* pClass, bool bOverride);

        ATTRIBUTE_METHOD1(AssetEntity, GetLocalFileName_s, const char**)        { *p1 = cls->GetLocalFileName().c_str(); return S_OK; }
        ATTRIBUTE_METHOD1(AssetEntity, SetLocalFileName_s, const char*)     { cls->SetLocalFileName(p1); return S_OK; }

        ATTRIBUTE_METHOD1(AssetEntity, GetRemoteAssetURL_s, const char**)       { static std::string s;  s = cls->GetRemoteAssetURL().c_str(); *p1 = s.c_str(); return S_OK; }

        ATTRIBUTE_METHOD1(AssetEntity, IsValid_s, bool*)        { *p1 = cls->IsValid(); return S_OK; }
        ATTRIBUTE_METHOD1(AssetEntity, IsLoaded_s, bool*)       { *p1 = cls->IsLoaded(); return S_OK; }
        ATTRIBUTE_METHOD1(AssetEntity, IsLocked_s, bool*)       { *p1 = cls->IsLocked(); return S_OK; }
        ATTRIBUTE_METHOD1(AssetEntity, IsInitialized_s, bool*)      { *p1 = cls->IsInitialized(); return S_OK; }
        
        ATTRIBUTE_METHOD1(AssetEntity, GetState_s, int*)        { *p1 = (int)cls->GetState(); return S_OK; }
        ATTRIBUTE_METHOD1(AssetEntity, SetState_s, int)     { cls->SetState((AssetState)p1); return S_OK; }

    public:

        enum AssetState
        {
            ASSET_STATE_NORMAL,
            ASSET_STATE_LOCAL,
            ASSET_STATE_REMOTE,
            ASSET_STATE_CACHE,
            ASSET_STATE_SYNC_START,
            ASSET_STATE_SYNC_SUCCEED,
            ASSET_STATE_SYNC_FAIL,
            ASSET_STATE_FAILED_TO_LOAD,
        };

        enum AssetType
        {
            base=0,
            texture,
            mesh,
            multianimation,
            spritevertex,
            font,
            sound,
            mdx,
            parax,
            database,
            effectfile,
            dllplugin,
            datagrid,
            cadMesh,
            image,
        };
        virtual AssetType GetType(){return base;};

    public:
        virtual const std::string& GetIdentifier();

        virtual bool AutoSync(bool bForceSync = false, bool bLazyLoading=true);
        
        virtual void Refresh(const char* sFilename=NULL,bool bLazyLoad = false);

        virtual const string& GetLocalFileName();
        virtual void SetLocalFileName(const char* sFileName);

        virtual string GetRemoteAssetURL();

        virtual CParameterBlock* GetParamBlock(bool bCreateIfNotExist = false){return NULL;};


        bool IsValid() {return m_bIsValid;};

        bool IsInitialized();
        
        virtual bool IsLoaded();

        virtual int Release();

        static const string& GetAssetServerUrl();

        static void SetAssetServerUrl(const char* pStr);

    public:
        AssetKey& GetKey()
        {
            return m_key;
        }
        AssetState GetState()
        {
            return m_assetState;
        }
        void SetState(AssetState state)
        {
            m_assetState = state;
        }
        virtual IAttributeFields* GetAttributeObject();

        virtual HRESULT InitDeviceObjects(){m_bIsInitialized =true;return S_OK;};
        virtual HRESULT RestoreDeviceObjects(){return S_OK;};
        virtual HRESULT InvalidateDeviceObjects(){return S_OK;};
        virtual HRESULT DeleteDeviceObjects(){m_bIsInitialized =false;return S_OK;};
        virtual HRESULT RendererRecreated() { return S_OK; };

        virtual void Cleanup(){};

        void LoadAsset(){
            if(!m_bIsInitialized)
            {
                InitDeviceObjects();
                RestoreDeviceObjects();
                //m_bIsInitialized = true;
            }
        };
        void UnloadAsset(){
            if(m_bIsInitialized)
            {
                InvalidateDeviceObjects();
                DeleteDeviceObjects();
                //m_bIsInitialized = false;
            }
        }
        void GarbageCollectMe(){
            if(m_refcount<=0)
            {
                UnloadAsset();
                m_refcount = 0;
            }
        }

        inline bool IsLocked() {return m_bIsLocked;}

        virtual bool Lock(int nMethod=0);

        virtual void UnLock();

        virtual bool GetBoundingBox(Vector3* pMin, Vector3* pMax) { return false; };
    public:
        AssetKey m_key;

        bool        m_bIsInitialized;   

        bool        m_bIsValid;

    private:
        AssetState m_assetState;

        bool        m_bIsLocked;

        string m_localfilename;
    };
}

#include "AssetManager.h"