GxResBase.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_CORE_NAMESPACE_BEGIN()
 
// クラス宣言
class  GxToolResourceEditBase;
struct GxResourceFileTable;
 
//===========================================================================
//===========================================================================
class GxResBase : public GxClassBaseReference
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_RESOURCE_ICON(GxResBase, GxClassBaseReference, GxRtti::ICON_TYPE::TEXT)
    // GxClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxResBase)
    // new, delete定義
    GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::RESOURCE)
 
    // フレンド設定 (インスタンス化をSysResouce::create～に統一する為)
    friend class GxSysResource;
    friend class GxSysResourceCallback;
    friend class GxSysResourceAsyncLoadBase;
 
    enum class ASYNC_STATE
    {
        LOADING         = 0,        
        COMPLETE,                   
        CANCEL_REQUAST,             
        INITIALIZED,                
 
        ERROR_          = -1,       
        CANCELED        = -2        
    };
 
    enum class ASYNC_PRIORITY
    {
        NORMAL = 0,                 
        LOW                         
    };
 
    static const u32 RESOURCE_VERSION;                              
 
    static constexpr u32 RESOURCE_PATH_MAX                   = GxMath::VALUE_256;
    static constexpr u32 RESOURCE_CUSTOM_PROPERTY_STRING_NUM = GxMath::VALUE_2;
    static constexpr u32 RESOURCE_PATH_ENCRYPT_KEY_NUM       = GxMath::VALUE_8;
 
    enum class RESOURCE_BASE_ATTRIBUTE
    {
        USE_DATA_FROM_SYSTEM,               
        ANY_PATH_RESOURCE,                  
        USE_MAIN_MEMORY,                    
        REGISTERED_NON_REPLACED,            
        ASYNC_SET_RESOURCE                  
    };
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxResBase(void);
 
public:
    void cleanup(void) override;
    s32 release(void) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    void createCallback(void* pUser);
    b32 load(GxStream& stream, u32 size);
    b32 loadBinary(GxStream& stream);
 
#if GX_DEVELOP
    b32 loadXml(GxStream& stream);
    b32 loadJson(GxStream& stream);
    b32 save(GxStream& stream);
    b32 saveBinary(GxStream& stream, const GxRttiResource& rttiResource);
    b32 saveXml(GxStream& stream, const GxRttiResource& rttiResource, b32 isDifference = true);
    b32 saveJson(GxStream& stream, const GxRttiResource& rttiResource, b32 isCompress = false, b32 useRtti = true, b32 isDifference = true);
    b32 finalize(void);
    static b32 isModified(GxStream& stream, u64 lastWriteTime, GX_CSTR resourcePath);
    virtual u64 getSaveLastWriteTime(void) const;
#endif  // GX_DEVELOP
 
public:
    GX_FORCE_INLINE virtual void callback(void) {}
 
    static void registerCustomProperty(void);
    static void customPropertyToString(GxProperty& property, GxTypedObject* pOwner, u32 index, GxString* pString, u32& stringCount);
    static void customPropertyFromString(GxProperty& property, GxTypedObject* pOwner, u32 index, GxString* pString, u32 stringCount);
#if GX_DEVELOP
    static GxGuiBase* customPropertyCreateGui(GxProperty& property, GxTypedObject* pOwner, const GxRtti& rtti, u32 index);
#endif //GX_DEVELOP
    static u32 customPropertyGetSerializedBinarySize(GxProperty& property, GxTypedObject* pOwner, u32 index);
    static void* customPropertySerializeBinary(GxProperty& property, GxTypedObject* pOwner, u32 index, void* pData);
    static const void* customPropertyDeserializeBinary(GxProperty& property, GxTypedObject* pOwner, u32 index, const void* pData);
private:
    static b32 isCustomResource(const GxProperty& property) { return (property.getFunction().getType() == GxProperty::GxFunction::TYPE::UNIQUE); }
    static void customPropertySetResourceAddress(GxProperty& property, GxTypedObject* pOwner, u32 index, GxResBase* pResource);
    static void* serializeResourcePath(u8* pSerialize, GX_CSTR path, u32 length);
    static const void* deserializeResourcePath(GX_STR path, u32 length, const u8* pSerialized);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    constexpr u64 getId(void) const { return _id; }
    GX_FORCE_INLINE void setPath(GX_CSTR path) { _path = path; }
    constexpr GX_CSTR getPath(void) const { return _path.getString(); }
    constexpr u32 getFileSize(void) const { return _fileSize; }
    constexpr u32 getSize(void) const { return _size; }
    constexpr GxResBase* getConfig(void) const { return _pConfig; }
    constexpr ASYNC_STATE getAsyncState(void) const { return _asyncState; }
    GX_FORCE_INLINE b32 isAsyncState(ASYNC_STATE asyncState) const { return (_asyncState == asyncState); }
    GX_FORCE_INLINE b32 isAsyncStateWorking(void) const { return (_asyncState == ASYNC_STATE::LOADING)||
                                                                                                         (_asyncState == ASYNC_STATE::CANCEL_REQUAST); }
    constexpr ASYNC_PRIORITY getAsyncPriority(void) const { return _asyncPriority; }
    GX_FORCE_INLINE b32 isUsable(void) const { return _isUsable; }
    constexpr GX_CSTR getExtension(void) const { return getRtti().getExtension(); }
#if GX_DEVELOP
    GX_CSTR getExtensionFinalized(void) const;
#endif //GX_DEVELOP
    constexpr u32 getMagicNumber(void) const { return getRtti().getMagicNumber(); }
    constexpr u32 getVersion(void) const { return getRtti().getVersion(); }
    GX_FORCE_INLINE void setOriginalPath(GX_CSTR path) { _originalPath = path; }
    constexpr GX_CSTR getOriginalPath(void) const { return _originalPath.getString(); }
    GX_FORCE_INLINE b32 isResourceBaseAttribute(RESOURCE_BASE_ATTRIBUTE attribute) const { return _resourceBaseAttribute.isFlag(attribute); }
#if GX_DEVELOP
    static void getReferencedResourceGuidList(const GxRttiResource& rttiResource, GX_CSTR path, GxArray& referencedGuidList);
    void getReferenceResourceList(GxArrayClassBase& resourceList);
#endif //GX_DEVELOP
protected:
    constexpr void setId(u64 id) { _id = id; }
    constexpr void setFileSize(u32 fileSize) { _fileSize = fileSize; }
    constexpr void setSize(u32 size) { _size = size; }
    GX_FORCE_INLINE void setConfig(GxResBase* pConfig) { GX_SET_CLASS_BASE_REFERENCE(_pConfig, pConfig); }
    constexpr void setAsyncState(ASYNC_STATE asyncState) { _asyncState = asyncState; }
    constexpr void setAsyncPriority(ASYNC_PRIORITY asyncPriority) { _asyncPriority = asyncPriority; }
    constexpr GX_HANDLE getAsyncHandle(void) const { return _asyncHandle; }
    constexpr void setAsyncHandle(GX_HANDLE handle) { _asyncHandle = handle; }
    GX_FORCE_INLINE void setUsable(b32 flag) { _isUsable = flag; }
    GX_FORCE_INLINE GxZlib& getZlib(void) { return _zlib; }
    constexpr void* getDataFromSystem(void) { return _pDataFromSystem; }
    GX_FORCE_INLINE void setResourceBaseAttribute(RESOURCE_BASE_ATTRIBUTE attribute, b32 enable) { _resourceBaseAttribute.setFlag(attribute, enable); }
 
public:
#if GX_DEVELOP
    static GxGuiBase* createGui(GxProperty& property, GxTypedObject* pOwner, const GxRtti& rtti, u32 index);
    GX_FORCE_INLINE virtual void getToolRtti( GxArray& /*arrayTool*/ ) const {}
    GX_FORCE_INLINE virtual GxRtti* getUnitRtti( void ){ return nullptr; }
#endif  // GX_DEVELOP
 
private:
    void getPropertyAttribute(void* pValue)                 const;
#if GX_DEVELOP
    void getPropertyExtension(void* pValue)                 const;
    void getPropertyRttiName(void* pValue)                  const;
#endif //GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    GxString                            _path;                  
    u64                                 _id;                    
    u32                                 _fileSize;              
    u32                                 _size;                  
    ASYNC_STATE                         _asyncState;            
    ASYNC_PRIORITY                      _asyncPriority;         
    GX_HANDLE                           _asyncHandle;           
    b32                                 _isUsable;              
    GxResBase*                          _pConfig;               
    GxZlib                              _zlib;                  
    void*                               _pDataFromSystem;       
    GxString                            _originalPath;          
    GxFlag32Index<RESOURCE_BASE_ATTRIBUTE> _resourceBaseAttribute;  
 
};
 
//===========================================================================
//===========================================================================
struct GxResHeader : public GxStructBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_STRUCT(GxResHeader)
 
public:
    static constexpr u32                    VERSION_SAVE_HIERARCY   = GxMath::VALUE_8;
    static constexpr GxMemory::ALIGNMENT    HEADER_ALIGNMENT        = GxMemory::ALIGNMENT::_128;
    static constexpr u32                    HEADER_SIZE             = static_cast<s32>(HEADER_ALIGNMENT);
    static constexpr u32                    PADDING_SIZE            = HEADER_SIZE - sizeof(u32) * (VERSION_SAVE_HIERARCY + 3);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxResHeader(void)
    {
        GX_ASSERT(HEADER_SIZE == sizeof(GxResHeader), "GxResHeader Size Error!! HEADER_SIZE(%d) sizeof(GxResHeader)(%d)", HEADER_SIZE, sizeof(GxResHeader));
        GX_MEMSET(_padding, 0, sizeof(_padding));
        clear();
    }
    GxResHeader(const GxRttiResource& resRtti)
    {
        GX_ASSERT(HEADER_SIZE == sizeof(GxResHeader), "GxResHeader Size Error!! HEADER_SIZE(%d) sizeof(GxResHeader)(%d)", HEADER_SIZE, sizeof(GxResHeader));
        GX_MEMSET(_padding, 0, sizeof(_padding));
        set(resRtti);
    }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    void set(const GxRttiResource& resRtti);
    void clear(void);
 
    b32 read(GxStream& stream);
    b32 write(GxStream& stream);
    b32 isSameRtti(const GxRttiResource& resRtti) const;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    constexpr u32                           getMagicNumber(void)            const   { return _magicNumber; }
    constexpr u32                           getVersionSavedNum(void)        const   { return _versionSavedNum; }
    constexpr u32                           getVersion(u32 hierarcy = 0)    const   { return _version[hierarcy]; }
    constexpr GxRttiResource::COMPRESS_TYPE getCompressType(void)           const   { return _compressType; }
    constexpr void setCompressType(const GxRttiResource::COMPRESS_TYPE compressType){ _compressType = compressType; }
 
    static constexpr u32                    getSize(void)                           { return HEADER_SIZE; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    u32                             _magicNumber;                           
    u32                             _versionSavedNum;                       
    u32                             _version[VERSION_SAVE_HIERARCY];        
    GxRttiResource::COMPRESS_TYPE   _compressType;                          
    u8                              _padding[PADDING_SIZE];                 
 
};
 
//---------------------------------------------------------------------------
// 生成時コールバック
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxResBase::createCallback(void* /*pUser*/)
{
    return;
}
 
//---------------------------------------------------------------------------
// ロード
//          シリアライズを行う場合は loadXml() ,loadJsonもしくは loadBinary() を呼び出すように実装してください
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxResBase::load(GxStream& /*stream*/, u32 /*size*/)
{
    GX_ASSERT(false, "load() method need override!!");
    return false;
}
 
//---------------------------------------------------------------------------
// バイナリリソースのロード
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxResBase::loadBinary(GxStream& stream)
{
    GxSerializer serializer;
    return serializer.deserializeBinary(stream, this, getRtti());
}
 
#if GX_DEVELOP
//---------------------------------------------------------------------------
// XMLリソースのロード
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxResBase::loadXml(GxStream& stream)
{
    GxSerializer serializer;
    return serializer.deserializeXml(stream, this, getRtti());
}
 
//---------------------------------------------------------------------------
// JSONリソースのロード
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxResBase::loadJson(GxStream& stream)
{
    GxSerializer serializer;
    return serializer.deserializeJson(stream, this, getRtti());
}
 
//---------------------------------------------------------------------------
// セーブ
//          シリアライズを行う場合は saveXml() , saveJson()もしくは saveBinary() を呼び出すように実装してください
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxResBase::save(GxStream& /*stream*/)
{
    GX_ASSERT(false, "load() method need override!!");
    return false;
}
 
//---------------------------------------------------------------------------
// バイナリリソースとしてセーブ
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxResBase::saveBinary(GxStream& stream, const GxRttiResource& rttiResource)
{
    GxSerializer serializer;
    return serializer.serializeBinary(stream, this, rttiResource);
}
 
//---------------------------------------------------------------------------
// XMLリソースとしてセーブ
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxResBase::saveXml(GxStream& stream, const GxRttiResource& rttiResource, b32 isDifference)
{
    GxSerializer serializer;
    return serializer.serializeXml(stream, this, rttiResource, isDifference);
}
 
//---------------------------------------------------------------------------
// JSONリソースとしてセーブ
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxResBase::saveJson(GxStream& stream, const GxRttiResource& rttiResource, b32 isCompress, b32 useRtti, b32 isDifference)
{
    GxSerializer serializer;
    return serializer.serializeJson(stream, this, rttiResource, isCompress, useRtti);
}
 
//---------------------------------------------------------------------------
// ファイナライズ
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxResBase::finalize(void)
{
    return true;
}
 
//---------------------------------------------------------------------------
// 変更チェック
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxResBase::isModified(GxStream& /*stream*/, u64 /*lastWriteTime*/, GX_CSTR /*resourcePath*/)
{
    return false;
}
 
//---------------------------------------------------------------------------
// セーブ設定更新時刻の取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE u64 GxResBase::getSaveLastWriteTime(void) const
{
    return 0;
}
#endif  // GX_DEVELOP
 
//---------------------------------------------------------------------------
// プロパティ属性取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxResBase::getPropertyAttribute(void* pValue) const
{
    *reinterpret_cast<u32*>(pValue) = getRtti().getAttribute();
}
 
#if GX_DEVELOP
//---------------------------------------------------------------------------
// 拡張子取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxResBase::getPropertyExtension(void* pValue) const
{
    *reinterpret_cast<GX_CSTR*>(pValue) = getRtti().getExtension();
}
 
//---------------------------------------------------------------------------
// RTTI取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxResBase::getPropertyRttiName(void* pValue) const
{
    *reinterpret_cast<GX_CSTR*>(pValue) = getRtti().getName();
}
#endif //GX_DEVELOP
 
GX_CORE_NAMESPACE_END()