doc/api/_gx_sys_resource_8h_source.html

//===========================================================================

//===========================================================================

#pragma once


GX_CORE_NAMESPACE_BEGIN()


#define GX_SYS_RESOURCE_LOCK    getGxSysResource()->lockFromOutside

#define GX_SYS_RESOURCE_UNLOCK  getGxSysResource()->unlockFromOutside


//===========================================================================

//          リソースパスには ファイル指定(拡張子あり), フォルダ指定(拡張子なし) どちらも指定可能です。

//          同一アーカイブIDが指定されているものが１つのバイナリデータになります。

//===========================================================================


struct GxResourceFileTable

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GX_FORCE_INLINE b32  isDirectory(void)      const   { return GxFilePath::isDirectoryPath(_pResourcePath); }

    GX_FORCE_INLINE b32  isEnd(void)            const   { return (_pResourcePath == nullptr); }

    static GxResourceFileTable* allocArray(const GxResourceFileTable* pResourceFileTable, s16 archiveId);


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GX_CSTR                     _pResourcePath;

    s16                         _archiveId;

    u16                         _isHddInstall;


};


//===========================================================================

//          ファイル名 (or フォルダ名) との単純比較なので、階層的なチェックは行いませんので注意して下さい。

//===========================================================================


struct GxResourceFileFilter

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GX_FORCE_INLINE b32 isEnd(void) const { return (_pFileName == nullptr); }


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GX_CSTR                     _pFileName;


};


//===========================================================================

//===========================================================================

typedef u32 (*GX_SYSRESOURCE_ERROR_FUNCTION)(GX_CSTR message, GX_CSTR filePath, u32 rttiId, u32 value);


//===========================================================================

//===========================================================================


enum class GX_ARCHIVE_PACKAGEMODE

{

    DEFAULT = 0,

    UP,

    DOWN,

    UP64,

    DOWN64,

};


#if GX_DEVELOP

GX_ENUM_BEGIN(GX_ARCHIVE_PACKAGEMODE)

    GX_ENUM_VALUE("ソートせずに名前順", GX_ARCHIVE_PACKAGEMODE::DEFAULT),

    GX_ENUM_VALUE("リソースIDの下位32bitを元にした昇順", GX_ARCHIVE_PACKAGEMODE::UP),

    GX_ENUM_VALUE("リソースIDの下位32bitを元にした降順", GX_ARCHIVE_PACKAGEMODE::DOWN),

    GX_ENUM_VALUE("リソースIDを元にした昇順", GX_ARCHIVE_PACKAGEMODE::UP64),

    GX_ENUM_VALUE("リソースIDを元にした降順", GX_ARCHIVE_PACKAGEMODE::DOWN64),

GX_ENUM_END()

#endif //GX_DEVELOP


//===========================================================================

//===========================================================================


class GxResourceInitialInformation : public GxClassBase

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    // RTTI定義

    GX_RTTI_CLASS(GxResourceInitialInformation, GxClassBase)

    // GxClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE(GxResourceInitialInformation)


    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    static constexpr u32 ASYNC_REQUEST_QUEUE_DEFAULT = GxMath::VALUE_256;


    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:


    GxResourceInitialInformation(void)

        : _pResourceFileTableArray(nullptr)

        , _pResourceFileFilterArray(nullptr)

        , _pArchiveSearchOrderArray(nullptr)

        , _enableExistOriginalData(false)

        , _disableFinalizeIgnoreOriginal(false)

        , _optimizeVertexCache(false)

        , _fileDecodeChunkSizeMax(0)

        , _streamReadCacheBufferSize(0)

        , _streamWriteCacheBufferSize(0)

        , _asyncLoadThreadStackSize(GX_ASYNC_LOAD_THREAD_STACKSIZE)

        , _asyncLoadMultiCount(1)

        , _asyncLoadCpuIndex(GX_ASYNC_LOAD_THREAD_CPU_INDEX)

        , _backgroundLoadMultiCount(1)

        , _optimizeTBNRemakeRange(0.1f)

        , _motionSequenceLineMax(32)

        , _asyncRequestQueueMax(ASYNC_REQUEST_QUEUE_DEFAULT)

        , _pUserErrorFunction(nullptr)

#if defined(_WINDOWS)

        , _resourecRootPath("../../resource/")

#endif

#if defined(_NX64)

        , _fsMountType(0)

#endif // _NX64

        , _separeteShaderConfig(false)

        , _archiveFileMax(16)

        , _archiveLocalThreadFileMax(16)

        , _optimizeAsyncloadThreadAssignment(false)

#if GX_DEVELOP

        , _disableSaveArchiveErr(false)

        , _outputMultiPlatformArchiveTable(false)

        , _disablePropertyChangedWarning(false)

        , _archivePackMode(GX_ARCHIVE_PACKAGEMODE::DEFAULT)

        , _disableIsExistMasterResErrMessage(false)

        , _vertexHashMaxNum(32768)  //< 256 * 1024 / 8 byte

        , _outputArchiveInfo(false)

#endif // GX_DEVELOP

    {}


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    void loadJson(const GxJson::GxJsonNode& jsonNode);


#if GX_DEVELOP

    static GxGuiBase* createGui(GxProperty& property, GxTypedObject* pOwner, const GxRtti& rtti, u32 index);

#endif // GX_DEVELOP


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GxResourceFileTable*        _pResourceFileTableArray;

    GxResourceFileFilter*       _pResourceFileFilterArray;

    s16*                        _pArchiveSearchOrderArray;

    b32                         _enableExistOriginalData;

    b32                         _disableFinalizeIgnoreOriginal;

    b32                         _optimizeVertexCache;

    u32                         _fileDecodeChunkSizeMax;

    u32                         _streamReadCacheBufferSize;

    u32                         _streamWriteCacheBufferSize;

    u32                         _asyncLoadThreadStackSize;

    u32                         _asyncLoadMultiCount;

    s32                         _asyncLoadCpuIndex;

    u32                         _backgroundLoadMultiCount;

    f32                         _optimizeTBNRemakeRange;

    u32                         _motionSequenceLineMax;

    u32                         _asyncRequestQueueMax;

    GX_SYSRESOURCE_ERROR_FUNCTION _pUserErrorFunction;

#if defined(_WINDOWS)

    GxString                    _resourecRootPath;

#endif

#if defined(_NX64)

    u32                         _fsMountType;

#endif // _NX64

    b32                         _separeteShaderConfig;

    u32                         _archiveFileMax;

    u32                         _archiveLocalThreadFileMax;

    b32                         _optimizeAsyncloadThreadAssignment;

#if GX_DEVELOP

    b32                         _disableSaveArchiveErr;

    b32                         _outputMultiPlatformArchiveTable;

    b32                         _disablePropertyChangedWarning;

    GX_ARCHIVE_PACKAGEMODE      _archivePackMode;

    b32                         _disableIsExistMasterResErrMessage;

    u32                         _vertexHashMaxNum;

    b32                         _outputArchiveInfo;

#endif // GX_DEVELOP


};


//===========================================================================

//===========================================================================


class GxSysResourceRegister : public GxClassBase

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    // RTTI宣言

    GX_RTTI_CLASS(GxSysResourceRegister, GxClassBase)

    // GxClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE(GxSysResourceRegister)


private:

    static constexpr u32            HASH_LINE_NUM    = (1 << 8);

    static constexpr u32            HASH_ELEMENT_NUM = GxMath::VALUE_32;


private:

    struct GxResourceInformation

    {

        //-----------------------------------------------------------

        //-----------------------------------------------------------

    public:

        constexpr void set(GxResBase* pResource) { _pResource = pResource; }

        constexpr void empty(void) { _pResource = nullptr; }

        GX_FORCE_INLINE b32 isEmpty(void) const { return (_pResource == nullptr); }


        //-----------------------------------------------------------

        //-----------------------------------------------------------

    public:

        GxResBase*              _pResource;


    };


    //-----------------------------------------------------------

    //-----------------------------------------------------------


public:

    GxSysResourceRegister(void);

    ~GxSysResourceRegister(void) override {}


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    b32        registerResource(GxResBase* pResource);

    b32        unregisterResource(GxResBase* pResource);

    GxResBase* findResource(u64 resourceId);

    GxResBase* getRegisterResource(u32 index);


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    u32 getResourceNum(void) const;


private:

    void getResourceTableForProperty(void* pValue, u32 index);

    u32 getHashTableValue(u64 resourceId) const;


    //-----------------------------------------------------------

    //-----------------------------------------------------------


private:

    GxResourceInformation       _registerTable[HASH_LINE_NUM][HASH_ELEMENT_NUM];

    u8                          _registerCount[HASH_LINE_NUM];

#if GX_DEVELOP

    GxArray                     _registerArray;

#endif //GX_DEVELOP


};


//===========================================================================

//===========================================================================


class GxSysResourceCallback : public GxClassBase

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    // RTTI宣言

    GX_RTTI_CLASS(GxSysResourceCallback, GxClassBase)

    // GxClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE(GxSysResourceCallback)


private:

    static constexpr u32 REQUEST_QUEUE_MAX = GxMath::VALUE_32;


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    GxSysResourceCallback(void);

    ~GxSysResourceCallback(void) override;


    b32  initialize(void);

    void terminate(void);


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    void update(void);

    void clear(void);

    b32  request(GxResBase* pResource);


    //-----------------------------------------------------------

    //-----------------------------------------------------------

private:

    GxLockFreeQueue<GxResBase*, GxAllocatorList::ALLOCATOR_TYPE::SYSTEM> _requestQueue;


};


//===========================================================================

//===========================================================================


class GxSysResourceAsyncLoadBase : public GxClassBase

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    // RTTI宣言

    GX_RTTI_CLASS(GxSysResourceAsyncLoadBase, GxClassBase)

    // GxClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE(GxSysResourceAsyncLoadBase)


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    GxSysResourceAsyncLoadBase(void);

    ~GxSysResourceAsyncLoadBase(void) override {}


    virtual b32 initialize(u32 /*queueMax*/, u32 /*asyncLoadThreadStackSize*/ = GX_ASYNC_LOAD_THREAD_STACKSIZE, u32 /*multiCount*/ = 1, s32 /*cpuIndex*/ = GX_ASYNC_LOAD_THREAD_CPU_INDEX

#if GX_DEVELOP

        , GxString /*threadName*/ = ""

#endif  // GX_DEVELOP

        ){ return true; }


    virtual void terminate(void){}


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    GX_FORCE_INLINE virtual void update(void) {}

    GX_FORCE_INLINE virtual void clear(void){}

    GX_FORCE_INLINE virtual b32 isEmpty(void){ return true; }

    GX_FORCE_INLINE virtual b32 request(GxResBase* /*pResource*/) { return true; }

    void loadAsync(void* pObject);

    void setOnTerminateCallback( void (*pFunction)(u32) );

    GX_FORCE_INLINE virtual void lockAsyncLoad(void){}

    GX_FORCE_INLINE virtual void unlockAsyncLoad(void){}

    GX_FORCE_INLINE virtual u32 getMultiCount(void) const { return 1; }


    //-----------------------------------------------------------

    //-----------------------------------------------------------


public:

#if GX_DEVELOP

    GX_FORCE_INLINE virtual GX_CSTR getAsyncLoadString(u32 /*multiIndex*/ = 0) const { return nullptr; }

    GX_FORCE_INLINE virtual GX_CSTR getAsyncLoadClassString(u32 /*multiIndex*/ = 0) const { return nullptr; }

    GX_FORCE_INLINE virtual void setAsyncLoadInfomation(GxResBase* /*pResource*/, u32 /*multiIndex*/ = 0) {}

#endif  // GX_DEVELOP


    //-----------------------------------------------------------

    //-----------------------------------------------------------

protected:

    void (*_onTerminateProc)(u32);


};


//===========================================================================

//===========================================================================


class GxSysResourceAsyncLoad : public GxSysResourceAsyncLoadBase

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    // RTTI宣言

    GX_RTTI_CLASS(GxSysResourceAsyncLoad, GxSysResourceAsyncLoadBase)

    // GxClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE(GxSysResourceAsyncLoad)


public:


    class GxAsyncLoadThread : public GxThread

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------

    public:

        GX_RTTI_CLASS(GxAsyncLoadThread, GxThread)

        // GxClassBase継承クラス用禁止宣言

        GX_PROHIBIT_CLASS_BASE(GxAsyncLoadThread)

        static constexpr s32 WAIT_INFINITY = -1;


        //-------------------------------------------------------------

        //-------------------------------------------------------------

    public:

        GxAsyncLoadThread(void) {}

        void threadMain(void* pArgument) override;


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GX_FORCE_INLINE b32 waitStartEvent(s32 milliSecond = WAIT_INFINITY) { return _startEvent.waitEvent(milliSecond); }

        GX_FORCE_INLINE b32 setStartEvent(void) { return _startEvent.setEvent(); }


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxCriticalSection   _pause;


    protected:

        GxEvent             _startEvent;


    };


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    GxSysResourceAsyncLoad(void);

    ~GxSysResourceAsyncLoad(void) override;


    b32 initialize(

        u32 queueMax,

        u32 asyncLoadThreadStackSize = GX_ASYNC_LOAD_THREAD_STACKSIZE,

        u32 multiCount = 1,

        s32 cpuIndex = GX_ASYNC_LOAD_THREAD_CPU_INDEX

#if GX_DEVELOP

        , GxString threadName = ""

#endif  // GX_DEVELOP

        ) override;

    void terminate(void) override;


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    void update(void) override;

    void clear(void) override;

    b32  isEmpty(void) override;

    b32  request(GxResBase* pResource) override;

    void lockAsyncLoad(void) override;

    void unlockAsyncLoad(void) override;


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

#if GX_DEVELOP

    GX_FORCE_INLINE GX_CSTR getAsyncLoadString(u32 multiIndex = 0) const override { GX_UNUSED(multiIndex); return _asyncPath; }

    GX_FORCE_INLINE GX_CSTR getAsyncLoadClassString(u32 multiIndex = 0) const override { GX_UNUSED(multiIndex); return _asyncClassName; }

    void setAsyncLoadInfomation(GxResBase* pResource, u32 multiIndex = 0) override;

#endif  // GX_DEVELOP


    //-----------------------------------------------------------

    //-----------------------------------------------------------

protected:

    GxLockFreeQueue<GxResBase*, GxAllocatorList::ALLOCATOR_TYPE::SYSTEM> _requestQueue;

    GxAsyncLoadThread                                                   _thread;

    b32                                                                 _isStopThread;

#if GX_DEVELOP

    GX_CSTR                                                             _asyncPath;

    GX_CSTR                                                             _asyncClassName;

#endif // GX_DEVELOP


};


//===========================================================================

//===========================================================================


class GxSysResourceAsyncLoadMulti : public GxSysResourceAsyncLoadBase

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    // RTTI定義

    GX_RTTI_CLASS(GxSysResourceAsyncLoadMulti, GxSysResourceAsyncLoadBase)

    // GxClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE(GxSysResourceAsyncLoadMulti)


    class GxAsyncLoadThreadMulti : public GxThread

    {

        //-----------------------------------------------------------

        //-----------------------------------------------------------

    public:

        GX_RTTI_CLASS(GxAsyncLoadThreadMulti, GxThread)

        // GxClassBase継承クラス用禁止宣言

        GX_PROHIBIT_CLASS_BASE(GxAsyncLoadThreadMulti)

        static constexpr s32 WAIT_INFINITY = -1;


        //-----------------------------------------------------------

        //-----------------------------------------------------------

    public:


        GxAsyncLoadThreadMulti(void)

            : _multiIndex(0)

        {}


        void threadMain(void* pArgument) override;


        //-----------------------------------------------------------

        //-----------------------------------------------------------


        GX_FORCE_INLINE b32 waitStartEvent(s32 milliSecond = WAIT_INFINITY) { return _startEvent.waitEvent(milliSecond); }

        GX_FORCE_INLINE b32 setStartEvent(void) { return _startEvent.setEvent(); }

        constexpr void setMultiIndex(u32 index) { _multiIndex = index; }


        //-----------------------------------------------------------

        //-----------------------------------------------------------


        GxCriticalSection   _pause;

    protected:

        GxEvent             _startEvent;

        u32                 _multiIndex;


    };


    static constexpr u32 MAX_MULTI_PROCESS_COUNT = GxMath::VALUE_8;


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    GxSysResourceAsyncLoadMulti(void);

    ~GxSysResourceAsyncLoadMulti(void) override;


    b32 initialize(

        u32 queueMax,

        u32 asyncLoadThreadStackSize = GX_ASYNC_LOAD_THREAD_STACKSIZE,

        u32 multiCount = 4,

        s32 cpuIndex = GX_ASYNC_LOAD_THREAD_CPU_INDEX

#if GX_DEVELOP

        , GxString threadName = ""

#endif  // GX_DEVELOP

        ) override;

    void terminate(void) override;


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    void clear(void) override;

    b32  isEmpty(void) override;

    b32  request(GxResBase* pResource) override;

    void lockAsyncLoad(void) override;

    void unlockAsyncLoad(void) override;

    GX_FORCE_INLINE u32 getMultiCount(void) const override { return _multiCount; }


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

#if GX_DEVELOP

    GX_FORCE_INLINE GX_CSTR getAsyncLoadString(u32 multiIndex = 0) const override { return (_multiCount > multiIndex) ? _asyncPath[multiIndex] : nullptr; }

    GX_FORCE_INLINE GX_CSTR getAsyncLoadClassString(u32 multiIndex = 0) const override { return (_multiCount > multiIndex) ? _asyncClassName[multiIndex] : nullptr; }

    void    setAsyncLoadInfomation(GxResBase* pResource, u32 multiIndex = 0) override;

#endif  // GX_DEVELOP


    //-----------------------------------------------------------

    //-----------------------------------------------------------

protected:

    GxCriticalSection                                                   _requestQueueCriticalSection;

    GxLockFreeQueue<GxResBase*, GxAllocatorList::ALLOCATOR_TYPE::SYSTEM> _requestQueueMulti[ MAX_MULTI_PROCESS_COUNT ];

    GxAsyncLoadThreadMulti*                                             _threadMulti[ MAX_MULTI_PROCESS_COUNT ];

    b32                                                                 _isStopThread;

    u32                                                                 _currentIndexOfMulti;

    u32                                                                 _multiCount;

#if GX_DEVELOP

    GX_CSTR                                                             _asyncPath[ MAX_MULTI_PROCESS_COUNT ];

    GX_CSTR                                                             _asyncClassName[MAX_MULTI_PROCESS_COUNT];

#endif // GX_DEVELOP


};


//===========================================================================

//===========================================================================


class GxSysResourceAsyncLoadMultiWithSharedQueue : public GxSysResourceAsyncLoadMulti

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    // RTTI定義

    GX_RTTI_CLASS(GxSysResourceAsyncLoadMultiWithSharedQueue, GxSysResourceAsyncLoadMulti)

    // GxClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE(GxSysResourceAsyncLoadMultiWithSharedQueue)


    class GxAsyncLoadThreadMultiOpt : public GxAsyncLoadThreadMulti

    {

        //-----------------------------------------------------------

        //-----------------------------------------------------------

    public:

        GX_RTTI_CLASS(GxAsyncLoadThreadMultiOpt, GxAsyncLoadThreadMulti)

        // GxClassBase継承クラス用禁止宣言

        GX_PROHIBIT_CLASS_BASE(GxAsyncLoadThreadMultiOpt)


        //-----------------------------------------------------------

        //-----------------------------------------------------------

    public:

        GxAsyncLoadThreadMultiOpt(void) :Super(), _pNextRequestResource(nullptr) {  }

        void threadMain(void* pArgument) override;


        //-----------------------------------------------------------

        //-----------------------------------------------------------

        GX_FORCE_INLINE b32 isWaitResource(void) const { return _pNextRequestResource == nullptr; }


        constexpr void setRequestResource(GxResBase* pResource) { _pNextRequestResource = pResource; }


        //-----------------------------------------------------------

        //-----------------------------------------------------------

    private:

        GxResBase* _pNextRequestResource;


    };


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    GxSysResourceAsyncLoadMultiWithSharedQueue(void);

    ~GxSysResourceAsyncLoadMultiWithSharedQueue(void) override;


    b32 initialize(

        u32 queueMax,

        u32 asyncLoadThreadStackSize = GX_ASYNC_LOAD_THREAD_STACKSIZE,

        u32 multiCount = 4,

        s32 cpuIndex = GX_ASYNC_LOAD_THREAD_CPU_INDEX

#if GX_DEVELOP

        , GxString threadName = ""

#endif  // GX_DEVELOP

    ) override;

    void terminate(void) override;


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    void clear(void) override;

    b32  isEmpty(void) override;

    b32  request(GxResBase* pResource) override;

    b32 getNextRequestResource(GxResBase** pResource);


    //-----------------------------------------------------------

    //-----------------------------------------------------------


protected:

    GxLockFreeQueue<GxResBase*, GxAllocatorList::ALLOCATOR_TYPE::SYSTEM> _requestQueueSingle;


};


//===========================================================================

//===========================================================================


class GxSysResourceArchive : public GxClassBase

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    // RTTI宣言

    GX_RTTI_CLASS(GxSysResourceArchive, GxClassBase)

    // GxClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE(GxSysResourceArchive)


public:

    static constexpr u32        ARCHIVE_FILE_FOURCC     = GX_FOURCC('G','D','A','T');

    static constexpr u32        FILE_ARCHIVE_SIZE_MAX   = U32_MAX - 1;


    struct GxArchiveHeader

    {

        u32                 _fourCC;

        u32                 _fileCount;

    };


    struct GxArchiveOffsetInformation

    {

        u32                 _offset;

        u32                 _size;

    };


    struct GxArchiveFileInformation

    {

        GxString            _path;

        u64                 _resourceId;

    };


private:

    enum class ARCHIVE_ACCESSOR_COLUMN

    {

        RESOURCE_ID = 0,

        DATA_INDEX,

        MAX

    };


    static GX_CSTR          ARCHIVE_FILE_BASE_NAME;

    static GX_CSTR          ARCHIVE_FILE_EXTENSION;

    static GX_CSTR          ARCHIVE_INDEX_RESOURCE_PATH;


    struct GxArchiveFile

    {

        GxFile*             _pFile;

        GxThread*           _pFileThread;

        u32                 _referenceCount;

        s32                 _archiveId;

    };


    //-----------------------------------------------------------

    //-----------------------------------------------------------


public:

    GxSysResourceArchive(void);

    ~GxSysResourceArchive(void) override;


    b32  initialize(u32 archiveFileMax, u32 archiveLocalThreadFileMax,

                    const GxResourceFileTable* pResourceFileTable = nullptr,

                    const s16* pArchiveSearchOrderTable = nullptr );

    void terminate(void);


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    constexpr void update(void){}


    void openAllArchiveFiles(GX_CSTR basePath, const GxResourceFileTable* pResourceFileTable);

    b32 openArchiveFile(GX_CSTR basePath, const GxResourceFileTable* pResourceFileTable, s16 archiveId);

    void closeArchiveFile(s16 archiveId);

    void initializeArchiveSearchOrder(const s16* pArchiveSearchOrderTable = nullptr);


#if GX_DEVELOP

    static b32 createArchiveFile(s16 archiveId, const GxArray& archiveFileList);

    static u32 getArchiveSize(s16 archiveId, const GxArray& archiveFileList);

#endif  // GX_DEVELOP


protected:

    static b32 readArchiveHeader(GxStream& srcStream, GxArchiveHeader& dstHeader);

    static b32 readArchiveOffsetTable(GxStream& srcStream, GxArchiveOffsetInformation* pDstOffsetTable, u32 archiveCount);

#if GX_DEVELOP

    static b32 writeArchiveHeader(GxStream& dstStream, const GxArray& archiveFileList);

    static b32 writeArchiveOffsetTable(GxStream& dstStream, const GxArray& archiveFileList);

    static b32 writeArchiveFile(GxStream& dstStream, const GxArray& archiveFileList);

#endif  // GX_DEVELOP


    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    u32           getIndex(s16 archiveId, u64 resourceId) const;

    const GxArchiveOffsetInformation* getOffsetInformation(s16 archiveId, u32 archiveIndex) const;

    GxFile*       getFile(s16 archiveId);

    GxFileStream* getLocalThreadFileStream(s16 archiveId, u32 archiveIndex, GxFile** retFile);

    GxFile*       getLocalThreadFile(s16 archiveId);

    void          freeLocalThreadFile(s16 archiveId, GxFile* lsFile);

    //  GxResourceInitialInformation::_archiveFileMax で指定可能

    //  システム上限はプラットフォームによる

    constexpr u32 getArchiveFileMax(void) const { return _archiveFileMax; }

    constexpr u32 getArchiveLocalThreadFileMax(void) const { return _archiveLocalThreadFileMax; }

    b32           isArchiveOpened(s16 archiveId) const;

    const GxResourceFileTable* getResourceFileTable(const GX_CSTR srcResourcePath) const;


    static void   getArchiveFilePath(GxString& dst, s16 archiveId, GX_CSTR basePath);

    static void   getArchiveIndexResourcePath(GxString& dst, s16 archiveId);

#if GX_DEVELOP

    static void   getArchiveDevInfoResourcePath(GxString& dst, s16 archiveId);

#endif // GX_DEVELOP


    //-----------------------------------------------------------

    //-----------------------------------------------------------

private:

    GxArchiveFile*                  _pArchiveFileArray;

    GxArchiveHeader*                _pArchiveHeaderArray;

    GxArchiveOffsetInformation**    _ppArchiveOffsetTableArray;

    GxResCellSheet**                _ppArchiveIndexResourceArray;

    GxResourceFileTable**           _ppResourceFileTableArray;

    GxCriticalSection               _archiveFileArrayCriticalSection;

    u32                             _archiveFileMax;

    u32                             _archiveLocalThreadFileMax;

    s16*                            _pArchiveSearchOrder;


};


//===========================================================================

//===========================================================================


class GxSysResource : public GxSysBase, public SingletonBase<GxSysResource>

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    // RTTI定義

    GX_RTTI_ABSTRACT_CLASS(GxSysResource, GxSysBase)

    // GxClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE(GxSysResource)


    // フレンド宣言

    friend class GxSysResourceRegister;

    friend class GxSysResourceCallback;

    friend class GxSysResourceAsyncLoadBase;

    friend class GxSysResourceAsyncLoad;

    friend class GxSysResourceAsyncLoadMulti;

    friend class GxSysResourceAsyncLoadMultiWithSharedQueue;

    friend class GxSysResourceArchive;

    friend class GxResBase;


public:


    enum class LOAD_MODE

    {

        SYNC = 0,

        ASYNC

    };


    enum class LOAD_RESULT

    {

        CANCELED    = -2,

        ERROR_  = -1,

        OK      = 0

    };


    enum class PATH_TYPE

    {

        NONE        = -1,

        ORIGINAL    = 0,

        FINALIZED_COMMON,

        FINALIZED_NATIVE,

        MAX

    };


    static GX_CSTR RESOURCE_ORIGINAL_ROOT_NAME;

    static GX_CSTR RESOURCE_FINALIZED_COMMON_ROOT_NAME;


protected:

    typedef b32 (*RESOURCE_FILE_TABLE_SEARCH_CALLBACK)(const GxRttiResource& resRtti, GX_CSTR resourcePath, void* pArgument);


#if GX_DEVELOP

    struct GxFinalizeResourceInformation

    {

        GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP);


        const GxRttiResource*   _pRtti;

        GxString                _path;

    };


    static GX_CSTR BOOT_ARGUMENT_SKIP_FINALIZE;

    static GX_CSTR BOOT_ARGUMENT_OUTPUT_ARCHIVE_INFO;

#endif  // GX_DEVELOP


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    GxSysResource(void);

    ~GxSysResource(void) override;


    b32  initialize(const GxClassBase* pInitialInformation = nullptr) override;

    void terminate(void) override;


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    void update(void) override;


    GxResBase* createAndLoadResource(const GxRttiResource& resRtti, GX_CSTR path, LOAD_MODE loadMode = LOAD_MODE::SYNC, void* pCreateCallbackWork = nullptr);

    GxResBase* createAndLoadBackground(const GxRttiResource& resRtti, GX_CSTR path, void* pCreateCallbackWork = nullptr);

    GxResBase* createAndSetResource(const GxRttiResource& resRtti, GX_CSTR path, GxMemoryStream& stream, LOAD_MODE loadMode = LOAD_MODE::SYNC, void* pCreateCallbackWork = nullptr);

    GxResBase* createResource(const GxRttiResource& resRtti, GX_CSTR path, void* pCreateCallbackWork = nullptr);

    GxResBase* createResource(const GxRttiResource& resRtti, GX_CSTR path, b32& isNewCreate, void* pCreateCallbackWork = nullptr);

#if GX_DEVELOP

    GxResBase* createAndLoadResource(GX_CSTR fullPath, LOAD_MODE loadMode = LOAD_MODE::SYNC, b32 forceFinalized = false);

    b32 isReference(const GxRttiResource& resRtti, GX_CSTR path, GX_CSTR searchPath);

#endif  // GX_DEVELOP

    GX_FORCE_INLINE GxSysResource::LOAD_RESULT loadResourceFromStreamLoopHole(GxResBase& resource, GxStream& stream, u32 size){ return loadResourceFromStream(resource, stream, size);  }

    GxResBase* createAndLoadResource(const GxRttiResource& resRtti, GX_CSTR fullPath, u64 resId, LOAD_MODE loadMode = LOAD_MODE::SYNC);


    void* loadFileImage(const GxRttiResource& resRtti, GX_CSTR path, u32& dataSize, GxAllocatorList::ALLOCATOR_TYPE allocator = GxAllocatorList::ALLOCATOR_TYPE::TEMPORARY);

    GxResBase* createAndSetResourceFromFileImage(const GxRttiResource& resRtti, GX_CSTR path, void* pLoadBuffer, u32 dataSize, LOAD_MODE loadMode = LOAD_MODE::SYNC, void* pCreateCallbackWork = nullptr);


    //---- 非同期


    constexpr GxSysResourceAsyncLoadBase* getResourceAsyncLoadManager(void) const { return _resourceAsyncLoadManager; }

    constexpr GxSysResourceAsyncLoadBase* getResourceBackgroundLoadManager(void) const { return _resourceBackgroundLoadManager; }

    void cancelResource(GxResBase* pResource);

    GX_FORCE_INLINE void lockAsyncLoad(void) { getResourceAsyncLoadManager()->lockAsyncLoad(); }

    GX_FORCE_INLINE void unlockAsyncLoad(void) { getResourceAsyncLoadManager()->unlockAsyncLoad(); }


    b32 reloadResource(GxResBase* pResource, LOAD_MODE loadMode = LOAD_MODE::SYNC);


    void registerResource(GxResBase* pResource);

    void unregisterResource(GxResBase* pResource);


    void stopAsyncLoadSystem(void);


    b32 openArchiveFile(GX_CSTR base, const GxResourceFileTable* pResourceFileTable, s16 archiveId);

    constexpr u32 getArchiveFileMax(void) const { return _resourceArchiveManager.getArchiveFileMax(); }

    GX_FORCE_INLINE b32 isArchiveOpened(s16 archiveId) const { return _resourceArchiveManager.isArchiveOpened(archiveId); }

    void initializeArchiveSearchOrder(const s16* pArchiveSearchOrderTable = nullptr);


public:

#if GX_DEVELOP

    b32 createFinalizeResourceFileAsync(const GxResourceFileTable* pResourceFileTable, const GxResourceFileFilter* pFileFilterTable, const GxRttiResource* pRttiTarget = nullptr, b32 isFinalizeForce = false);

    b32 createMasterResourceFile(const GxResourceFileTable* pResourceFileTable, const GxResourceFileFilter* pFileFilterTable, b32 isCheckOriginalRootPath = true, b32 isCheckArchiveFileSize = true);


    b32 createConfigResource(GxResBase& resource);


    b32 isUpdateFinalizeResource(const GxRttiResource& resRtti, GX_CSTR resourcePath)           const;


    b32 save(GxResBase& resource, const GxRttiResource* pRttiResource = nullptr);

    b32 convert(GxResBase& resource, const GxRttiResource* pTargetRttiResource);

    b32 isModifiedFile(const GxResBase& resource);

    b32 getResourceTableProperty(GxClassBase*& pOwner, GxProperty*& pProperty);


    GX_FORCE_INLINE u64 getLastWriteTime(const GxResBase& resource)                             const;

    GX_FORCE_INLINE u64 getLastWriteTime(const GxRttiResource& resRtti, GX_CSTR resourcePath)   const;

    GX_FORCE_INLINE b32 isOutputMultiPlatformArchiveTable(void) const { return _outputMultiPlatformArchiveTable; }

    GX_FORCE_INLINE b32 isDisablePropertyChangedWarning(void)   const { return _disablePropertyChangedWarning; }

    constexpr u32 getVertexHashMaxNum(void) const { return _vertexHashMaxNum; }

    GX_FORCE_INLINE virtual GxResBase* useTextureAsDummyWhenFileNotFound(const GxRttiResource& /*resRtti*/, GX_CSTR /*path*/) { return nullptr; };

#endif  // GX_DEVELOP


    void setOnTerminateCallback(void (*func)(u32));


protected:

    //---- static関数


    static void analyseResourcePath(GX_CSTR path, PATH_TYPE* pType, s32* pRootPosition, u32* pRootLength);


    //---- システム初期化


    b32  initializeResourceRootPath(const GxResourceInitialInformation* pInitialInformation = nullptr);

#if GX_DEVELOP

    b32  isValidRttiResourceTree(void)              const;

    void normalizeConfigRttiResourceTree(void);

#endif  // GX_DEVELOP


    GxResBase* createResourceRoutine(const GxRttiResource& resRtti, GX_CSTR original, GX_CSTR replace, b32* pIsNewCreate, void* pCreateCallbackWork);

    LOAD_RESULT loadResourceSync(GxResBase& resource, void* pCreateCallbackWork = nullptr);

    LOAD_RESULT loadResourceAsync(GxResBase& resource, void* pCreateCallbackWork = nullptr);

    LOAD_RESULT loadResourceFromStream(GxResBase& resource, GxStream& stream, u32 size = 0);


    LOAD_RESULT loadResourceFileAsync(GxResBase& resource, GxFile& file, u32 offset, u32 size);

    static void callbackLoadStart(void* pUser, GX_HANDLE requestHandle);


    //  読み込み開始前なら ASYNC_STATE_LOADING を設定して true を返す

    //  開始後なら読み込み終わるまで待ち false を返す。

    b32 waitForLoadComplete(GxResBase* pResource);


    void getLoadPath(GxString& dst, const GxRttiResource& resRtti, GX_CSTR resourcePath);

    void getFinalizeResourcePath(GxString& dst, const GxResBase& resource);


#if GX_DEVELOP

public:

    const GxRttiResource* getFinalizeResource(const GxRttiResource& resRtti)                            const;

protected:

    b32 isSkipFinalizeBootArgument(const GxRttiResource& resRtti, GX_CSTR resourcePath)     const;

    b32 isUpdateFinalizeResourceCheckTimestamp(const GxRttiResource& resRtti, GX_CSTR resourcePath)     const;

    b32 isUpdateFinalizeResourceCheckInFile(const GxRttiResource& resRtti, GX_CSTR resourcePath)        const;

    b32 updateFinalizeResource(const GxRttiResource& resRtti, GX_CSTR resourcePath, void* pCreateCallbackWork = nullptr);


    b32 createResourceDirectory(const GxRttiResource& resRtti, GX_CSTR resourcePath);

    b32 createMasterDirectory(const GxRttiResource& resRtti, GX_CSTR resourcePath);


    b32 saveRawResourceFile(const GxResBase& resource, const GxRttiResource& resRtti);

    b32 saveNormalResourceFile(GxResBase& resource, const GxRttiResource& resRtti);

    u64 getSaveNormalResourceUpdateTime(const GxResBase& resource, const GxRttiResource& resRtti);


    static s32 _archiveErrorFileIndex;

    //  もしくはisExistFileFromMasterResourceでチェックした場合で、

    //  ファイルが見つからなかった場合のエラー詳細をCSVで出力する

    static void saveArchiveAccessError(const GxRttiResource& resRtti, GX_CSTR resourcePath, s16 archiveId, u32 methodtype);


    void sortArchiveTable(GxArray& archiveFileList, GX_ARCHIVE_PACKAGEMODE mode);


    void outputRttiInfo(const GxRttiResource& resRtti, GxFile& dstFile);

    void outputResourceTable(const GxResourceFileTable* pTable, const GxResourceFileFilter* pFilter, GxFile& dstFile);

#endif  // GX_DEVELOP

public:

    b32 searchResourceFileTableTargetLoop(GX_CSTR rootPath, const GxResourceFileTable& fileTableElement, const GxResourceFileFilter* pFileFilterTable, const GxRttiResource* pRttiTarget, RESOURCE_FILE_TABLE_SEARCH_CALLBACK function, void* pArgument);

protected:

    b32 isSkipSearchFileTableTargetName(GX_CSTR fileName, const GxResourceFileFilter* pFileFilterTable = nullptr);


#if GX_DEVELOP

    static b32 callbackResourceFileTableCopyMasterData(const GxRttiResource& resRtti, GX_CSTR resourcePath, void* pArgument);

    static b32 callbackResourceFileTableFinalize(const GxRttiResource& resRtti, GX_CSTR resourcePath, void* pArgument);

    static b32 callbackResourceFileTableAddArchiveList(const GxRttiResource& resRtti, GX_CSTR resourcePath, void* pArgument);

#endif  // GX_DEVELOP


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    constexpr GX_CSTR     getResourceRootPath(void)                         const   { return _resourceRootPath.getString(); }

    void        setResourceRootPath(GX_CSTR path = nullptr);


    constexpr GX_CSTR getOriginalRootPath(void)                         const { return _originalRootPath.getString(); }

    constexpr GX_CSTR getFinalizedCommonRootPath(void)                  const { return _finalizedCommonRootPath.getString(); }

    constexpr GX_CSTR getFinalizedNativeRootPath(void)                  const { return _finalizedNativeRootPath.getString(); }

    constexpr GX_CSTR getMasterRootPath(void)                           const { return _masterRootPath.getString(); }


    static b32  isOriginalPath(GX_CSTR path);

    static b32  isFinalizedCommonPath(GX_CSTR path);

    static b32  isFinalizedNativePath(GX_CSTR path);

#if GX_DEVELOP

    static void getNewFileName(GX_CSTR srcPath, GX_CSTR baseFileName, GX_CSTR fileExtension, GxString& newFileName);

    static void getNewFolderName(GX_CSTR srcPath, GX_CSTR oldFolderName, GxString& newFolderName);

    static b32  isDevelopPath(GX_CSTR path);

#endif //GX_DEVELOP


    static void getOriginalPath(GxString& dst, GX_CSTR path);

    static void getFinalizedCommonPath(GxString& dst, GX_CSTR path);

    static void getFinalizedNativePath(GxString& dst, GX_CSTR path);

    static void getResourcePath(GxString& dst, GX_CSTR path, b32 isDeleteExtension = true);

    static u64  getResourceId(const GxRttiResource& resRtti, GX_CSTR resourcePath);

#if GX_DEVELOP

    static void getResourcePathWithRootName(GxString& dst, GX_CSTR path, b32 isDeleteExtension = true);

    void        getTemporaryPath(GxString& dst);

#endif  // GX_DEVELOP

    virtual void getReplaceOriginalPath(GxString& dstPath, const GxRttiResource& /*resRtti*/, GX_CSTR srcPath);

    virtual void getReplacePath(GxString& dstPath, const GxRttiResource& /*resRtti*/, GX_CSTR srcPath) const;

    GX_FORCE_INLINE virtual b32  isRegisteredNonReplacedPath(GX_CSTR& /*original*/, GX_CSTR& /*replaced*/) const { return false; }


    GX_CSTR     getRootPath(const GxResBase& resource)                                                  const;

    GX_CSTR     getRootPath(const GxRttiResource& resRtti)                                              const;

    void        getFullPath(GxString& dst, const GxResBase& resource)                                   const;

    void        getFullPath(GxString& dst, const GxRttiResource& resRtti, GX_CSTR resourcePath)         const;

    void        getConvertPath(GxString& dst, const GxResBase& resource)                                const;

    void        getConvertPath(GxString& dst, const GxRttiResource& resRtti, GX_CSTR resourcePath)      const;

    void        getMasterPath(GxString& dst, const GxResBase& resource)                                 const;

    void        getMasterPath(GxString& dst, const GxRttiResource& resRtti, GX_CSTR resourcePath)       const;


    const GxResourceFileTable* getResourceFileTable(void)                       const;

    const GxResourceFileTable* getResourceFileTable(const GxResBase& resource)  const;

    const GxResourceFileTable* getResourceFileTable(const GX_CSTR srcResourcePath) const;

    const GxResourceFileFilter* getResourceFilterTable(void)                    const;

    GX_FORCE_INLINE void        setDisableFinalizeIgnoreOriginalFlag(b32 flag) { _disableFinalizeIgnoreOriginalFlag = flag; }

    const b32                   getDisableFinalizeIgnoreOriginalFlag(void)      const;

    const b32                   getOptimizeVertexCache(void)                    const;

    const b32                   getSeparateShaderConfig(void)                   const;

    const f32                   getOptimizeTBNRemakeRange(void)                 const;

    const b32                   getOptimizeAsyncloadThreadAssignment(void)      const;


    GX_FORCE_INLINE b32 isEmptyAsyncLoader(void) { return getResourceAsyncLoadManager()->isEmpty(); }

    GX_FORCE_INLINE b32 isEmptyBackgroundLoader(void){ return getResourceBackgroundLoadManager()->isEmpty(); }


    constexpr u32 getMotionSequenceLineMax(void) const { return _motionSequenceLineMax; }


#if GX_DEVELOP

    GX_CSTR     getAsyncLoadString(u32 multiIndex = 0)              const;

    GX_CSTR     getAsyncLoadClassString(u32 multiIndex = 0)         const;

    GX_CSTR     getBackgroundLoadString(u32 multiIndex = 0)         const;

    GX_CSTR     getBackgroundLoadClassString(u32 multiIndex = 0)    const;

    u32         getAsyncLoadMultiCount(void)                        const;

    u32         getBackgroundLoadMultiCount(void)                   const;

    GX_FORCE_INLINE b32     isBootRom(void)                                     const { return _isBootRom; }

    GX_FORCE_INLINE b32     isRunningFinalizeAll(void)                          const { return (_allFinalizeTargetList.getCount() > 0); }

    constexpr u32           getFinalizeAllCount(void)                           const { return _allFinalizeTargetList.getCount(); }

    constexpr u32           getFinalizeAllIndex(void)                           const { return _allFinalizeTargetIndex; }

    constexpr GX_CSTR       getFinalizeAllString(void)                          const { return _allFinalizeString; }

#if defined(_WINDOWS) && GX_DEVELOP

    GX_FORCE_INLINE b32 isFinalizeEndian(GX_ENDIAN endian)          const { return getEndian(_finalizePlatform) == endian; }

    GX_FORCE_INLINE void setFinalizePlatform(GX_PLATFORM platform) { _finalizePlatform = platform; setResourceRootPath(); }

#endif //_WINDOWS && GX_DEVELOP


    GX_FORCE_INLINE void        setTextureAsDummyWhenFileNotFound(b32 enable) { _useDummyTextureWhenFileNotFound = enable; }

    GX_FORCE_INLINE b32         isTextureAsDummyWhenFileNotFound(void) const { return _useDummyTextureWhenFileNotFound; }

#endif  // GX_DEVELOP


    GX_FORCE_INLINE u32        getResourceNum(void);

    GX_FORCE_INLINE GxResBase* getResource(u32 index);

    GX_FORCE_INLINE b32        isExistFile(const GxResBase& resource) const;

    GX_FORCE_INLINE b32        isExistFile(const GxRttiResource& resRtti, GX_CSTR resourcePath) const;

    GX_FORCE_INLINE b32        isExistResource(const GxRttiResource& resRtti, GX_CSTR resourcePath);

    GX_FORCE_INLINE void       lockFromOutside(void);

    GX_FORCE_INLINE void       unlockFromOutside(void);

    b32                        isExistFileFromMasterResource(const GxRttiResource& resRtti, GX_CSTR resourcePath, b32 isCheckArchiveOnly = false, s16 archiveID = -1)const;


    GX_FORCE_INLINE GxDataResourceGuid& getDataResourceGuid(void) { return _dataResourceGuid; }


    //-----------------------------------------------------------

    //-----------------------------------------------------------

protected:

    GxSysResourceRegister       _resourceRegisterManager;

    GxSysResourceCallback       _resourceCallbackManager;

    GxSysResourceAsyncLoadBase* _resourceAsyncLoadManager;

    GxSysResourceAsyncLoadBase* _resourceBackgroundLoadManager;

    GxSysResourceArchive        _resourceArchiveManager;

    GxCriticalSection           _loadStateCriticalSection;


    GxResourceFileTable*        _pResourceFileTable;

    GxResourceFileFilter*       _pResourceFileFilter;

    s16*                        _pArchiveSearchOrder;

    b32                         _optimizeVertexCache;

    b32                         _enableExistOriginalDataFlag;

    b32                         _disableFinalizeIgnoreOriginalFlag;

    b32                         _separeteShaderConfig;

    GX_SYSRESOURCE_ERROR_FUNCTION _pUserErrorFunction;

    u32                         _fileDecodeChunkSizeMax;


    GxString                    _resourceRootPath;

    GxString                    _originalRootPath;

    GxString                    _finalizedCommonRootPath;

    GxString                    _finalizedNativeRootPath;

    GxString                    _masterRootPath;


    f32                         _optimizeTBNRemakeRange;

    u32                         _motionSequenceLineMax;

    b32                         _optimizeAsyncloadThreadAssignment;


    GxDataResourceGuid          _dataResourceGuid;

#if GX_DEVELOP

    b32                         _isBootRom;

    GxArray                     _allFinalizeTargetList;

    u32                         _allFinalizeTargetIndex;

    GX_CSTR                     _allFinalizeString;

    b32                         _isAllFinalizeForce;

    b32                         _isSkipFinalize;

    GxString                    _skipFinalizeTime;

#if defined(_WINDOWS) && GX_DEVELOP

    GX_PLATFORM                 _finalizePlatform;

#endif //_WINDOWS && GX_DEVELOP

    b32                         _disableSaveArchiveErr;

    b32                         _outputMultiPlatformArchiveTable;

    b32                         _disablePropertyChangedWarning;

    GX_ARCHIVE_PACKAGEMODE      _archivePackMode;

    b32                         _useDummyTextureWhenFileNotFound;

    b32                         _disableIsExistMasterResErrMessage;

    u32                         _vertexHashMaxNum;

    volatile s32                _temporaryFileIndex;

#endif //GX_DEVELOP


};


// アクセスインターフェース

GX_FORCE_INLINE GxSysResource* getGxSysResource(void){ return GxSysResource::getSingletonPointer(); }


//---------------------------------------------------------------------------

// 外部からのSysResourceのロック

//---------------------------------------------------------------------------


GX_FORCE_INLINE void GxSysResource::lockFromOutside(void)

{

    this->lock();

}


//---------------------------------------------------------------------------

// 外部からのSysResourceのアンロック

//---------------------------------------------------------------------------


GX_FORCE_INLINE void GxSysResource::unlockFromOutside(void)

{

    this->unlock();

}


//---------------------------------------------------------------------------

// リソースファイルテーブルポインタ取得

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxResourceFileTable* GxSysResource::getResourceFileTable(void) const

{

    return _pResourceFileTable;

}


//---------------------------------------------------------------------------

// リソースフィルタテーブルポインタ取得

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxResourceFileFilter* GxSysResource::getResourceFilterTable(void) const

{

    return _pResourceFileFilter;

}


//---------------------------------------------------------------------------

// オリジナル参照とタイムスタンプ比較を無視して、強制的にファイナライズを無効化するかどうか

//---------------------------------------------------------------------------


GX_FORCE_INLINE const b32 GxSysResource::getDisableFinalizeIgnoreOriginalFlag(void) const

{

    return _disableFinalizeIgnoreOriginalFlag;

}


//---------------------------------------------------------------------------

// 頂点キャッシュ最適化のためのインデックスソートを行うかどうかを取得

//---------------------------------------------------------------------------


GX_FORCE_INLINE const b32 GxSysResource::getOptimizeVertexCache(void) const

{

    return _optimizeVertexCache;

}


//---------------------------------------------------------------------------

// シェーダコンフィグファイルを各プラットフォームごとに変えるかどうか

//---------------------------------------------------------------------------


GX_FORCE_INLINE const b32 GxSysResource::getSeparateShaderConfig(void) const

{

    return _separeteShaderConfig;

}


//---------------------------------------------------------------------------

// モデルをファイナライズするときのTBNの再計算で利用する閾値を取得

//---------------------------------------------------------------------------


GX_FORCE_INLINE const f32 GxSysResource::getOptimizeTBNRemakeRange(void) const

{

    return _optimizeTBNRemakeRange;

}


//---------------------------------------------------------------------------

//  非同期ロード時にリソースのスレッド分配を単一キューから振り分けるようにするかどうか

//---------------------------------------------------------------------------


GX_FORCE_INLINE const b32   GxSysResource::getOptimizeAsyncloadThreadAssignment(void) const

{

    return _optimizeAsyncloadThreadAssignment;

}


#if GX_DEVELOP

//---------------------------------------------------------------------------

// 非同期ロード中文字列取得

//---------------------------------------------------------------------------

GX_FORCE_INLINE GX_CSTR GxSysResource::getAsyncLoadString(u32 multiIndex) const

{

    return getResourceAsyncLoadManager()->getAsyncLoadString(multiIndex);

}


//---------------------------------------------------------------------------

// 裏読みロード中文字列取得

//---------------------------------------------------------------------------

GX_FORCE_INLINE GX_CSTR GxSysResource::getBackgroundLoadString(u32 multiIndex) const

{

    return getResourceBackgroundLoadManager()->getAsyncLoadString(multiIndex);

}


//---------------------------------------------------------------------------

// 非同期ロード中文字列取得

//---------------------------------------------------------------------------

GX_FORCE_INLINE GX_CSTR GxSysResource::getAsyncLoadClassString(u32 multiIndex) const

{

    return getResourceAsyncLoadManager()->getAsyncLoadClassString(multiIndex);

}

//---------------------------------------------------------------------------

// 裏読みロード中文字列取得

//---------------------------------------------------------------------------

GX_FORCE_INLINE GX_CSTR GxSysResource::getBackgroundLoadClassString(u32 multiIndex) const

{

    return getResourceBackgroundLoadManager()->getAsyncLoadClassString(multiIndex);

}

//---------------------------------------------------------------------------

// 非同期ロード並列数を取得

//---------------------------------------------------------------------------

GX_FORCE_INLINE u32 GxSysResource::getAsyncLoadMultiCount(void) const

{

    return getResourceAsyncLoadManager()->getMultiCount();

}


//---------------------------------------------------------------------------

// 裏読みロード並列数を取得

//---------------------------------------------------------------------------

GX_FORCE_INLINE u32 GxSysResource::getBackgroundLoadMultiCount(void) const

{

    return getResourceBackgroundLoadManager()->getMultiCount();

}


#endif  // GX_DEVELOP


//---------------------------------------------------------------------------

// 登録リソース数取得

//---------------------------------------------------------------------------


GX_FORCE_INLINE u32 GxSysResource::getResourceNum(void)

{

    lock();

    u32 num = _resourceRegisterManager.getResourceNum();

    unlock();

    return num;

}


//---------------------------------------------------------------------------

// 登録済みリソース取得 (インデックス指定)

//---------------------------------------------------------------------------


GX_FORCE_INLINE GxResBase* GxSysResource::getResource(u32 index)

{

    lock();

    GxResBase* ret = _resourceRegisterManager.getRegisterResource(index);

    unlock();

    return ret;

}


//---------------------------------------------------------------------------

// リソースファイル存在チェック (リソース指定)

//---------------------------------------------------------------------------


GX_FORCE_INLINE b32 GxSysResource::isExistFile(const GxResBase& resource) const

{

    return isExistFile(resource.getRtti(), resource.getPath());

}


//---------------------------------------------------------------------------

// リソースファイル存在チェック (リソースRtti + リソースパス指定)

//---------------------------------------------------------------------------


GX_FORCE_INLINE b32 GxSysResource::isExistFile(const GxRttiResource& resRtti, GX_CSTR resourcePath) const

{

    GxString fullPath;

    GxString replacePath;

    getReplacePath(replacePath, resRtti, resourcePath);

    getFullPath(fullPath, resRtti, replacePath.getString());

    return GxFile::isExist(fullPath.getString());

}


//---------------------------------------------------------------------------

// メモリ上のリソースファイル存在チェック (リソースRtti + リソースパス指定)

//---------------------------------------------------------------------------


GX_FORCE_INLINE b32 GxSysResource::isExistResource(const GxRttiResource& resRtti, GX_CSTR resourcePath)

{

    lock();

    GxString realResourcePath;

    getResourcePath(realResourcePath, resourcePath);

    u64 resourceId = getResourceId(resRtti, realResourcePath.getString());

    GxResBase* pResource = _resourceRegisterManager.findResource(resourceId);

    unlock();

    return (b32)(pResource != nullptr);

}


#if GX_DEVELOP

//---------------------------------------------------------------------------

// 最終更新日時の取得 (リソース指定)

//---------------------------------------------------------------------------

GX_FORCE_INLINE u64 GxSysResource::getLastWriteTime(const GxResBase& resource) const

{

    return getLastWriteTime(resource.getRtti(), resource.getPath());

}


//---------------------------------------------------------------------------

// 最終更新日時の取得 (Rtti + リソースパス指定)

//---------------------------------------------------------------------------

GX_FORCE_INLINE u64 GxSysResource::getLastWriteTime(const GxRttiResource& resRtti, GX_CSTR resourcePath) const

{

    GxString fullPath;

    getFullPath(fullPath, resRtti, resourcePath);

    return GxFile::getLastWriteTime(fullPath.getString());

}

#endif  // GX_DEVELOP


GX_CORE_NAMESPACE_END()

GX_PROHIBIT_CLASS_BASE
#define GX_PROHIBIT_CLASS_BASE(__CLASS__)
GxClassBase継承の禁止宣言
Definition GxBase.h:240

GX_ENDIAN
GX_ENDIAN
エンディアン定義
Definition GxDefine.h:220

OUTPUT_TYPE::MAX
@ MAX
定義数

GxTypedObject
void GxTypedObject
その他
Definition GxDefine.h:213

GX_HANDLE
u32 GX_HANDLE
ハンドル
Definition GxDefine.h:214

threadMain
pThis threadMain(pThis->_pIn)

GX_SYSRESOURCE_ERROR_FUNCTION
u32(* GX_SYSRESOURCE_ERROR_FUNCTION)(GX_CSTR message, GX_CSTR filePath, u32 rttiId, u32 value)
Definition GxSysResource.h:87

GX_ARCHIVE_PACKAGEMODE
GX_ARCHIVE_PACKAGEMODE
アーカイブ用のパッケージング方式用列挙型
Definition GxSysResource.h:94

GX_ARCHIVE_PACKAGEMODE::UP64
@ UP64
リソースIDを元にした昇順

GX_ARCHIVE_PACKAGEMODE::DEFAULT
@ DEFAULT
ソートせずに名前順(デフォルト)

GX_ARCHIVE_PACKAGEMODE::DOWN64
@ DOWN64
リソースIDを元にした降順

GX_ARCHIVE_PACKAGEMODE::DOWN
@ DOWN
リソースIDの下位32bitを元にした降順

GX_ARCHIVE_PACKAGEMODE::UP
@ UP
リソースIDの下位32bitを元にした昇順

GxAllocatorList::ALLOCATOR_TYPE
ALLOCATOR_TYPE
アロケータ定義
Definition GxAllocator.h:355

GxAllocatorList::ALLOCATOR_TYPE::TEMPORARY
@ TEMPORARY
テンポラリ

GxArray
配列クラス
Definition GxArray.h:18

GxClassBase
オブジェクト基底クラス
Definition GxBase.h:88

GxClassBaseRoot::getRtti
virtual GxRtti & getRtti(void) const =0
Rttiの取得

GxCriticalSection
クリティカルセクションクラス
Definition GxThread.h:20

GxDataResourceGuid
リソースGUIDリストアクセスクラス
Definition GxDataResourceGuid.h:18

GxEvent
イベントクラス
Definition GxThread.h:132

GxEvent::setEvent
b32 setEvent(void)
イベントを設定
Definition GxThread.cpp:268

GxEvent::waitEvent
b32 waitEvent(s32 milliSecond=-1)
イベント待機
Definition GxThread.cpp:291

GxFile
ファイル管理クラス
Definition GxFile.h:157

GxFile::getLastWriteTime
static u64 getLastWriteTime(GX_CSTR path)
最終更新日時の取得
Definition GxFile.cpp:2058

GxFile::isExist
static b32 isExist(GX_CSTR path)
ファイル存在チェック
Definition GxFile.cpp:1922

GxFilePath::isDirectoryPath
static b32 isDirectoryPath(GX_CSTR path, GX_CCHAR separator=DEFAULT_SEPARATOR)
ディレクトリパス判定
Definition GxFile.cpp:2226

GxFileStream
ファイルストリームクラス
Definition GxStream.h:124

GxJson::GxJsonNode
JSON解析用ノード
Definition GxJson.h:108

GxLockFreeQueue
キュー (ロック不要)
Definition GxLockFreeQueue.h:19

GxMath::VALUE_32
static constexpr u32 VALUE_32
32
Definition GxMath.h:124

GxMath::VALUE_256
static constexpr u32 VALUE_256
256
Definition GxMath.h:127

GxMath::VALUE_8
static constexpr u32 VALUE_8
8
Definition GxMath.h:122

GxMemoryStream
メモリストリームクラス
Definition GxStream.h:248

GxProperty
プロパティクラス
Definition GxProperty.h:48

GxResBase
リソース基底クラス
Definition GxResBase.h:23

GxResBase::getPath
constexpr GX_CSTR getPath(void) const
パス取得
Definition GxResBase.h:171

GxResCellSheet
セルシートリソースクラス
Definition GxResCellSheet.h:19

GxResourceInitialInformation
初期化クラス
Definition GxSysResource.h:115

GxResourceInitialInformation::_archiveFileMax
u32 _archiveFileMax
アーカイブファイルの最大数(デフォルトは16　注意：オープンしたままなのでシステム上限に配慮したサイズ設定すること)
Definition GxSysResource.h:225

GxResourceInitialInformation::_optimizeVertexCache
b32 _optimizeVertexCache
頂点キャッシュ最適化のためのインデックスソートを行う
Definition GxSysResource.h:206

GxResourceInitialInformation::_pResourceFileFilterArray
GxResourceFileFilter * _pResourceFileFilterArray
リソースファイルフィルタ配列
Definition GxSysResource.h:202

GxResourceInitialInformation::_enableExistOriginalData
b32 _enableExistOriginalData
リソースの読み込み時にオリジナルデータの有無をチェックするか否か(trueでチェックを行う)
Definition GxSysResource.h:204

GxResourceInitialInformation::_fileDecodeChunkSizeMax
u32 _fileDecodeChunkSizeMax
圧縮リソースファイルの分割読み最大バッファサイズ。0 指定は分割しない。64k 以上
Definition GxSysResource.h:207

GxResourceInitialInformation::_separeteShaderConfig
b32 _separeteShaderConfig
各プラットフォームでシェーダコンフィグファイルを分ける
Definition GxSysResource.h:224

GxResourceInitialInformation::GxResourceInitialInformation
GxResourceInitialInformation(void)
コンストラクタ
Definition GxSysResource.h:142

GxResourceInitialInformation::_streamReadCacheBufferSize
u32 _streamReadCacheBufferSize
GxStream ファイル読み込みキャッシュサイズ。64k 以下はデフォルトとして 64k を採用。
Definition GxSysResource.h:208

GxResourceInitialInformation::_pArchiveSearchOrderArray
s16 * _pArchiveSearchOrderArray
リソースファイルテーブルアーカイブID検索順配列
Definition GxSysResource.h:203

GxResourceInitialInformation::_asyncLoadCpuIndex
s32 _asyncLoadCpuIndex
非同期ロードスレッドを実行する CPU コア番号 (デフォルトは -1 で自動)
Definition GxSysResource.h:212

GxResourceInitialInformation::_pUserErrorFunction
GX_SYSRESOURCE_ERROR_FUNCTION _pUserErrorFunction
ユーザー定義のエラーコールバック
Definition GxSysResource.h:217

GxResourceInitialInformation::_streamWriteCacheBufferSize
u32 _streamWriteCacheBufferSize
GxStream ファイル書き込みキャッシュサイズ。64k 以下はデフォルトとして 64k を採用。
Definition GxSysResource.h:209

GxResourceInitialInformation::ASYNC_REQUEST_QUEUE_DEFAULT
static constexpr u32 ASYNC_REQUEST_QUEUE_DEFAULT
リクエストキュー最大個数ディフォルト値
Definition GxSysResource.h:133

GxResourceInitialInformation::_archiveLocalThreadFileMax
u32 _archiveLocalThreadFileMax
別スレッドからのアーカイブ同時アクセス作業用ファイル数(デフォルトは16)
Definition GxSysResource.h:226

GxResourceInitialInformation::_asyncRequestQueueMax
u32 _asyncRequestQueueMax
非同期リクエストキューMAX
Definition GxSysResource.h:216

GxResourceInitialInformation::_asyncLoadMultiCount
u32 _asyncLoadMultiCount
非同期ロードスレッドの並列化の数(最大8)
Definition GxSysResource.h:211

GxResourceInitialInformation::_motionSequenceLineMax
u32 _motionSequenceLineMax
モーションシーケンスのラインの最大数
Definition GxSysResource.h:215

GxResourceInitialInformation::_disableFinalizeIgnoreOriginal
b32 _disableFinalizeIgnoreOriginal
オリジナル参照とタイムスタンプ比較を無視して、強制的にファイナライズを無効化。(すでにファイナライズがある前提)
Definition GxSysResource.h:205

GxResourceInitialInformation::_asyncLoadThreadStackSize
u32 _asyncLoadThreadStackSize
非同期ロードスレッドのスタックサイズ
Definition GxSysResource.h:210

GxResourceInitialInformation::_backgroundLoadMultiCount
u32 _backgroundLoadMultiCount
裏読みロードスレッドの並列化の数(最大8)
Definition GxSysResource.h:213

GxResourceInitialInformation::_pResourceFileTableArray
GxResourceFileTable * _pResourceFileTableArray
リソースファイルテーブル配列
Definition GxSysResource.h:201

GxResourceInitialInformation::loadJson
void loadJson(const GxJson::GxJsonNode &jsonNode)
JSONから読み込み
Definition GxSysResource.cpp:125

GxResourceInitialInformation::_optimizeTBNRemakeRange
f32 _optimizeTBNRemakeRange
モデルをファイナライズするときのTBNの再計算で利用する閾値(デフォルトは0.1f)
Definition GxSysResource.h:214

GxResourceInitialInformation::_optimizeAsyncloadThreadAssignment
b32 _optimizeAsyncloadThreadAssignment
非同期ロード時にリソースのスレッド分配をより効率化する
Definition GxSysResource.h:227

GxRtti
実行時型情報クラス
Definition GxRtti.h:154

GxRttiResource
リソース実行時型情報クラス
Definition GxRttiResource.h:188

GxStream
ストリーム基礎クラス
Definition GxStream.h:20

GxSysBase
システム基底クラス
Definition GxSysBase.h:18

GxSysBase::unlock
void unlock(LOCK_TYPE type=LOCK_TYPE::THREAD_SAFE)
クリティカルセクションを出る
Definition GxSysBase.cpp:123

GxSysBase::lock
void lock(LOCK_TYPE type=LOCK_TYPE::THREAD_SAFE)
クリティカルセクションに入る
Definition GxSysBase.cpp:94

GxSysResourceArchive
リソースファイルアーカイブ管理クラス
Definition GxSysResource.h:908

GxSysResourceArchive::freeLocalThreadFile
void freeLocalThreadFile(s16 archiveId, GxFile *lsFile)
getLocalThreadFile()で取得したファイルをシステムに返す
Definition GxSysResource.cpp:2185

GxSysResourceArchive::getArchiveFileMax
constexpr u32 getArchiveFileMax(void) const
アーカイブファイルが使用できる最大数。
Definition GxSysResource.h:1052

GxSysResourceArchive::GxSysResourceArchive
GxSysResourceArchive(void)
コンストラクタ
Definition GxSysResource.cpp:1422

GxSysResourceArchive::isArchiveOpened
b32 isArchiveOpened(s16 archiveId) const
アーカイブファイルがオープンしているか調べる
Definition GxSysResource.cpp:2229

GxSysResourceArchive::closeArchiveFile
void closeArchiveFile(s16 archiveId)
アーカイブファイルクローズ
Definition GxSysResource.cpp:1712

GxSysResourceArchive::getFile
GxFile * getFile(s16 archiveId)
アーカイブファイル取得
Definition GxSysResource.cpp:2044

GxSysResourceArchive::initialize
b32 initialize(u32 archiveFileMax, u32 archiveLocalThreadFileMax, const GxResourceFileTable *pResourceFileTable=nullptr, const s16 *pArchiveSearchOrderTable=nullptr)
初期化
Definition GxSysResource.cpp:1450

GxSysResourceArchive::~GxSysResourceArchive
~GxSysResourceArchive(void) override
デストラクタ
Definition GxSysResource.cpp:1437

GxSysResourceArchive::update
constexpr void update(void)
実行
Definition GxSysResource.h:997

GxSysResourceArchive::terminate
void terminate(void)
終了
Definition GxSysResource.cpp:1523

GxSysResourceArchive::getOffsetInformation
const GxArchiveOffsetInformation * getOffsetInformation(s16 archiveId, u32 archiveIndex) const
アーカイブファイルオフセット情報取得
Definition GxSysResource.cpp:2025

GxSysResourceArchive::initializeArchiveSearchOrder
void initializeArchiveSearchOrder(const s16 *pArchiveSearchOrderTable=nullptr)
アーカイブ検索順テーブルの作成。
Definition GxSysResource.cpp:1737

GxSysResourceArchive::getLocalThreadFile
GxFile * getLocalThreadFile(s16 archiveId)
Definition GxSysResource.cpp:2095

GxSysResourceArchive::getLocalThreadFileStream
GxFileStream * getLocalThreadFileStream(s16 archiveId, u32 archiveIndex, GxFile **retFile)
Definition GxSysResource.cpp:2065

GxSysResourceArchive::readArchiveOffsetTable
static b32 readArchiveOffsetTable(GxStream &srcStream, GxArchiveOffsetInformation *pDstOffsetTable, u32 archiveCount)
アーカイブオフセットテーブル読み込み
Definition GxSysResource.cpp:2394

GxSysResourceArchive::ARCHIVE_FILE_FOURCC
static constexpr u32 ARCHIVE_FILE_FOURCC
アーカイブファイルFOURCC
Definition GxSysResource.h:921

GxSysResourceArchive::getArchiveIndexResourcePath
static void getArchiveIndexResourcePath(GxString &dst, s16 archiveId)
アーカイブファイル内インデックスリソースパス取得
Definition GxSysResource.cpp:2319

GxSysResourceArchive::readArchiveHeader
static b32 readArchiveHeader(GxStream &srcStream, GxArchiveHeader &dstHeader)
アーカイブヘッダー読み込み
Definition GxSysResource.cpp:2359

GxSysResourceArchive::openArchiveFile
b32 openArchiveFile(GX_CSTR basePath, const GxResourceFileTable *pResourceFileTable, s16 archiveId)
アーカイブファイルオープン
Definition GxSysResource.cpp:1603

GxSysResourceArchive::getResourceFileTable
const GxResourceFileTable * getResourceFileTable(const GX_CSTR srcResourcePath) const
リソースパスからファイルテーブルを取得する
Definition GxSysResource.cpp:2244

GxSysResourceArchive::openAllArchiveFiles
void openAllArchiveFiles(GX_CSTR basePath, const GxResourceFileTable *pResourceFileTable)
アーカイブファイル群オープン(初期化時のみ内部使用)
Definition GxSysResource.cpp:1588

GxSysResourceArchive::getArchiveFilePath
static void getArchiveFilePath(GxString &dst, s16 archiveId, GX_CSTR basePath)
アーカイブファイルパス取得
Definition GxSysResource.cpp:2289

GxSysResourceArchive::getArchiveLocalThreadFileMax
constexpr u32 getArchiveLocalThreadFileMax(void) const
別スレッド同時アクセス作業用ファイル最大数
Definition GxSysResource.h:1054

GxSysResourceArchive::FILE_ARCHIVE_SIZE_MAX
static constexpr u32 FILE_ARCHIVE_SIZE_MAX
アーカイブファイル最大サイズ (4GB-1)
Definition GxSysResource.h:923

GxSysResourceArchive::getIndex
u32 getIndex(s16 archiveId, u64 resourceId) const
アーカイブファイル内インデックス取得
Definition GxSysResource.cpp:1995

GxSysResourceAsyncLoad::GxAsyncLoadThread
非同期ロードスレッドクラス
Definition GxSysResource.h:517

GxSysResourceAsyncLoad::GxAsyncLoadThread::setStartEvent
GX_FORCE_INLINE b32 setStartEvent(void)
開始イベント開始
Definition GxSysResource.h:549

GxSysResourceAsyncLoad::GxAsyncLoadThread::_pause
GxCriticalSection _pause
一時停止用
Definition GxSysResource.h:557

GxSysResourceAsyncLoad::GxAsyncLoadThread::waitStartEvent
GX_FORCE_INLINE b32 waitStartEvent(s32 milliSecond=WAIT_INFINITY)
開始イベント待ち
Definition GxSysResource.h:547

GxSysResourceAsyncLoad::GxAsyncLoadThread::WAIT_INFINITY
static constexpr s32 WAIT_INFINITY
イベント待ち無限設定値
Definition GxSysResource.h:527

GxSysResourceAsyncLoad::GxAsyncLoadThread::threadMain
void threadMain(void *pArgument) override
スレッドメイン
Definition GxSysResource.cpp:809

GxSysResourceAsyncLoad::GxAsyncLoadThread::_startEvent
GxEvent _startEvent
開始イベント
Definition GxSysResource.h:560

GxSysResourceAsyncLoadBase
リソース非同期読み込み要求管理基本クラス
Definition GxSysResource.h:413

GxSysResourceAsyncLoadBase::initialize
virtual b32 initialize(u32, u32=GX_ASYNC_LOAD_THREAD_STACKSIZE, u32=1, s32=GX_ASYNC_LOAD_THREAD_CPU_INDEX)
初期化
Definition GxSysResource.h:436

GxSysResourceAsyncLoadBase::setOnTerminateCallback
void setOnTerminateCallback(void(*pFunction)(u32))
Definition GxSysResource.cpp:637

GxSysResourceAsyncLoadBase::GxSysResourceAsyncLoadBase
GxSysResourceAsyncLoadBase(void)
コンストラクタ
Definition GxSysResource.cpp:597

GxSysResourceAsyncLoadBase::getMultiCount
virtual GX_FORCE_INLINE u32 getMultiCount(void) const
非同期読み込み並列化の数
Definition GxSysResource.h:468

GxSysResourceAsyncLoadBase::unlockAsyncLoad
virtual GX_FORCE_INLINE void unlockAsyncLoad(void)
非同期読み込みロック解除(必ず lockAsyncLoad() と対に使用すること)
Definition GxSysResource.h:466

GxSysResourceAsyncLoadBase::~GxSysResourceAsyncLoadBase
~GxSysResourceAsyncLoadBase(void) override
デストラクタ
Definition GxSysResource.h:433

GxSysResourceAsyncLoadBase::lockAsyncLoad
virtual GX_FORCE_INLINE void lockAsyncLoad(void)
非同期読み込みロック(読み込み中のファイルは終わるまでブロック)
Definition GxSysResource.h:464

GxSysResourceAsyncLoadBase::clear
virtual GX_FORCE_INLINE void clear(void)
クリア
Definition GxSysResource.h:453

GxSysResourceAsyncLoadBase::terminate
virtual void terminate(void)
終了
Definition GxSysResource.h:442

GxSysResourceAsyncLoadBase::request
virtual GX_FORCE_INLINE b32 request(GxResBase *)
リクエスト
Definition GxSysResource.h:457

GxSysResourceAsyncLoadBase::update
virtual GX_FORCE_INLINE void update(void)
更新
Definition GxSysResource.h:451

GxSysResourceAsyncLoadBase::loadAsync
void loadAsync(void *pObject)
非同期読み込みジョブ
Definition GxSysResource.cpp:606

GxSysResourceAsyncLoadBase::isEmpty
virtual GX_FORCE_INLINE b32 isEmpty(void)
リクエストキューが空かどうか
Definition GxSysResource.h:455

GxSysResourceAsyncLoad
リソース非同期読み込み要求管理クラス
Definition GxSysResource.h:503

GxSysResourceAsyncLoad::request
b32 request(GxResBase *pResource) override
リクエスト
Definition GxSysResource.cpp:789

GxSysResourceAsyncLoad::initialize
b32 initialize(u32 queueMax, u32 asyncLoadThreadStackSize=GX_ASYNC_LOAD_THREAD_STACKSIZE, u32 multiCount=1, s32 cpuIndex=GX_ASYNC_LOAD_THREAD_CPU_INDEX) override
初期化
Definition GxSysResource.cpp:680

GxSysResourceAsyncLoad::GxSysResourceAsyncLoad
GxSysResourceAsyncLoad(void)
コンストラクタ
Definition GxSysResource.cpp:654

GxSysResourceAsyncLoad::~GxSysResourceAsyncLoad
~GxSysResourceAsyncLoad(void) override
デストラクタ
Definition GxSysResource.cpp:666

GxSysResourceAsyncLoad::update
void update(void) override
更新
Definition GxSysResource.cpp:728

GxSysResourceAsyncLoad::_requestQueue
GxLockFreeQueue< GxResBase *, GxAllocatorList::ALLOCATOR_TYPE::SYSTEM > _requestQueue
リクエストキュー
Definition GxSysResource.h:631

GxSysResourceAsyncLoad::_isStopThread
b32 _isStopThread
非同期ロードスレッド停止要求フラグ
Definition GxSysResource.h:633

GxSysResourceAsyncLoad::terminate
void terminate(void) override
終了
Definition GxSysResource.cpp:706

GxSysResourceAsyncLoad::lockAsyncLoad
void lockAsyncLoad(void) override
非同期読み込みロック(読み込み中のファイルは終わるまでブロック)
Definition GxSysResource.cpp:864

GxSysResourceAsyncLoad::unlockAsyncLoad
void unlockAsyncLoad(void) override
非同期読み込みロック解除(必ず lockAsyncLoad() と対に使用すること)
Definition GxSysResource.cpp:872

GxSysResourceAsyncLoad::clear
void clear(void) override
クリア
Definition GxSysResource.cpp:744

GxSysResourceAsyncLoad::isEmpty
b32 isEmpty(void) override
リクエストキューが空かどうか
Definition GxSysResource.cpp:758

GxSysResourceAsyncLoad::_thread
GxAsyncLoadThread _thread
非同期ロードスレッド
Definition GxSysResource.h:632

GxSysResourceAsyncLoadMulti::GxAsyncLoadThreadMulti
非同期ロードスレッドクラス
Definition GxSysResource.h:659

GxSysResourceAsyncLoadMulti::GxAsyncLoadThreadMulti::_startEvent
GxEvent _startEvent
開始イベント
Definition GxSysResource.h:705

GxSysResourceAsyncLoadMulti::GxAsyncLoadThreadMulti::setMultiIndex
constexpr void setMultiIndex(u32 index)
マルチインデックスを設定
Definition GxSysResource.h:695

GxSysResourceAsyncLoadMulti::GxAsyncLoadThreadMulti::setStartEvent
GX_FORCE_INLINE b32 setStartEvent(void)
開始イベント開始
Definition GxSysResource.h:693

GxSysResourceAsyncLoadMulti::GxAsyncLoadThreadMulti::_multiIndex
u32 _multiIndex
マルチインデックス
Definition GxSysResource.h:706

GxSysResourceAsyncLoadMulti::GxAsyncLoadThreadMulti::waitStartEvent
GX_FORCE_INLINE b32 waitStartEvent(s32 milliSecond=WAIT_INFINITY)
開始イベント待ち
Definition GxSysResource.h:691

GxSysResourceAsyncLoadMulti::GxAsyncLoadThreadMulti::_pause
GxCriticalSection _pause
一時停止用
Definition GxSysResource.h:703

GxSysResourceAsyncLoadMulti
リソース非同期読み込み要求管理クラス（マルチリクエスト可能版）
Definition GxSysResource.h:646

GxSysResourceAsyncLoadMulti::_multiCount
u32 _multiCount
スレッド数
Definition GxSysResource.h:785

GxSysResourceAsyncLoadMulti::getMultiCount
GX_FORCE_INLINE u32 getMultiCount(void) const override
非同期読み込み並列化の数(この実装ではスレッド数)
Definition GxSysResource.h:755

GxSysResourceAsyncLoadMulti::MAX_MULTI_PROCESS_COUNT
static constexpr u32 MAX_MULTI_PROCESS_COUNT
最大マルチ化数
Definition GxSysResource.h:712

GxSysResourceAsyncLoadMulti::lockAsyncLoad
void lockAsyncLoad(void) override
非同期読み込みロック(読み込み中のファイルは終わるまでブロック)
Definition GxSysResource.cpp:1134

GxSysResourceAsyncLoadMulti::GxSysResourceAsyncLoadMulti
GxSysResourceAsyncLoadMulti(void)
デフォルトコンストラクタ
Definition GxSysResource.cpp:895

GxSysResourceAsyncLoadMulti::_requestQueueMulti
GxLockFreeQueue< GxResBase *, GxAllocatorList::ALLOCATOR_TYPE::SYSTEM > _requestQueueMulti[MAX_MULTI_PROCESS_COUNT]
リクエストキュー(通常処理)
Definition GxSysResource.h:781

GxSysResourceAsyncLoadMulti::initialize
b32 initialize(u32 queueMax, u32 asyncLoadThreadStackSize=GX_ASYNC_LOAD_THREAD_STACKSIZE, u32 multiCount=4, s32 cpuIndex=GX_ASYNC_LOAD_THREAD_CPU_INDEX) override
初期化
Definition GxSysResource.cpp:927

GxSysResourceAsyncLoadMulti::_requestQueueCriticalSection
GxCriticalSection _requestQueueCriticalSection
クリティカルセクション
Definition GxSysResource.h:780

GxSysResourceAsyncLoadMulti::terminate
void terminate(void) override
終了
Definition GxSysResource.cpp:965

GxSysResourceAsyncLoadMulti::isEmpty
b32 isEmpty(void) override
リクエストキューが空かどうか(全ての読み込みスレッドのキューが空かどうか)
Definition GxSysResource.cpp:1014

GxSysResourceAsyncLoadMulti::unlockAsyncLoad
void unlockAsyncLoad(void) override
非同期読み込みロック解除(必ず lockAsyncLoad() と対に使用すること)
Definition GxSysResource.cpp:1145

GxSysResourceAsyncLoadMulti::clear
void clear(void) override
クリア
Definition GxSysResource.cpp:997

GxSysResourceAsyncLoadMulti::~GxSysResourceAsyncLoadMulti
~GxSysResourceAsyncLoadMulti(void) override
デストラクタ
Definition GxSysResource.cpp:910

GxSysResourceAsyncLoadMulti::_isStopThread
b32 _isStopThread
非同期ロードスレッド停止要求フラグ
Definition GxSysResource.h:783

GxSysResourceAsyncLoadMulti::_currentIndexOfMulti
u32 _currentIndexOfMulti
カレントマルチインデックス
Definition GxSysResource.h:784

GxSysResourceAsyncLoadMulti::request
b32 request(GxResBase *pResource) override
リクエスト
Definition GxSysResource.cpp:1053

GxSysResourceAsyncLoadMulti::_threadMulti
GxAsyncLoadThreadMulti * _threadMulti[MAX_MULTI_PROCESS_COUNT]
非同期ロードスレッド
Definition GxSysResource.h:782

GxSysResourceAsyncLoadMultiWithSharedQueue::GxAsyncLoadThreadMultiOpt
非同期ロードスレッドクラス
Definition GxSysResource.h:810

GxSysResourceAsyncLoadMultiWithSharedQueue::GxAsyncLoadThreadMultiOpt::setRequestResource
constexpr void setRequestResource(GxResBase *pResource)
次の読み込みリソースを設定
Definition GxSysResource.h:840

GxSysResourceAsyncLoadMultiWithSharedQueue::GxAsyncLoadThreadMultiOpt::isWaitResource
GX_FORCE_INLINE b32 isWaitResource(void) const
Definition GxSysResource.h:837

GxSysResourceAsyncLoadMultiWithSharedQueue::GxAsyncLoadThreadMultiOpt::GxAsyncLoadThreadMultiOpt
GxAsyncLoadThreadMultiOpt(void)
コンストラクタ
Definition GxSysResource.h:827

GxSysResourceAsyncLoadMultiWithSharedQueue
リソース非同期読み込み要求管理クラス（シングルキューを振り分ける）
Definition GxSysResource.h:797

GxSysResourceAsyncLoadMultiWithSharedQueue::GxSysResourceAsyncLoadMultiWithSharedQueue
GxSysResourceAsyncLoadMultiWithSharedQueue(void)
コンストラクタ
Definition GxSysResource.cpp:1172

GxSysResourceAsyncLoadMultiWithSharedQueue::request
b32 request(GxResBase *pResource) override
リクエスト
Definition GxSysResource.cpp:1284

GxSysResourceAsyncLoadMultiWithSharedQueue::~GxSysResourceAsyncLoadMultiWithSharedQueue
~GxSysResourceAsyncLoadMultiWithSharedQueue(void) override
デストラクタ
Definition GxSysResource.cpp:1179

GxSysResourceAsyncLoadMultiWithSharedQueue::isEmpty
b32 isEmpty(void) override
リクエストキューが空かどうか(全ての読み込みスレッドのキューが空かどうか)
Definition GxSysResource.cpp:1274

GxSysResourceAsyncLoadMultiWithSharedQueue::initialize
b32 initialize(u32 queueMax, u32 asyncLoadThreadStackSize=GX_ASYNC_LOAD_THREAD_STACKSIZE, u32 multiCount=4, s32 cpuIndex=GX_ASYNC_LOAD_THREAD_CPU_INDEX) override
初期化
Definition GxSysResource.cpp:1193

GxSysResourceAsyncLoadMultiWithSharedQueue::clear
void clear(void) override
クリア
Definition GxSysResource.cpp:1260

GxSysResourceAsyncLoadMultiWithSharedQueue::_requestQueueSingle
GxLockFreeQueue< GxResBase *, GxAllocatorList::ALLOCATOR_TYPE::SYSTEM > _requestQueueSingle
リクエストキュー(_optThreadAlignment使用時)
Definition GxSysResource.h:899

GxSysResourceAsyncLoadMultiWithSharedQueue::terminate
void terminate(void) override
終了
Definition GxSysResource.cpp:1230

GxSysResourceAsyncLoadMultiWithSharedQueue::getNextRequestResource
b32 getNextRequestResource(GxResBase **pResource)
登録情報取り出し
Definition GxSysResource.cpp:1323

GxSysResourceCallback
リソースコールバック管理クラス
Definition GxSysResource.h:353

GxSysResourceCallback::clear
void clear(void)
クリア
Definition GxSysResource.cpp:556

GxSysResourceCallback::~GxSysResourceCallback
~GxSysResourceCallback(void) override
デストラクタ
Definition GxSysResource.cpp:502

GxSysResourceCallback::initialize
b32 initialize(void)
初期化
Definition GxSysResource.cpp:511

GxSysResourceCallback::GxSysResourceCallback
GxSysResourceCallback(void)
コンストラクタ
Definition GxSysResource.cpp:495

GxSysResourceCallback::request
b32 request(GxResBase *pResource)
リクエスト
Definition GxSysResource.cpp:572

GxSysResourceCallback::terminate
void terminate(void)
終了
Definition GxSysResource.cpp:520

GxSysResourceCallback::update
void update(void)
実行
Definition GxSysResource.cpp:534

GxSysResource
リソース管理システムクラス
Definition GxSysResource.h:1092

GxSysResource::initializeResourceRootPath
b32 initializeResourceRootPath(const GxResourceInitialInformation *pInitialInformation=nullptr)
リソースルートパス初期化
Definition GxSysResource.cpp:5528

GxSysResource::PATH_TYPE
PATH_TYPE
リソースパスタイプ
Definition GxSysResource.h:1131

GxSysResource::PATH_TYPE::MAX
@ MAX
リソースパスタイプ数

GxSysResource::PATH_TYPE::FINALIZED_NATIVE
@ FINALIZED_NATIVE
ハードウェア固有ファイナライズリソースパス

GxSysResource::PATH_TYPE::ORIGINAL
@ ORIGINAL
オリジナルリソースパス

GxSysResource::PATH_TYPE::NONE
@ NONE
リソース指定パスではない

GxSysResource::PATH_TYPE::FINALIZED_COMMON
@ FINALIZED_COMMON
ハードウェア共通ファイナライズリソースパス

GxSysResource::getDisableFinalizeIgnoreOriginalFlag
const b32 getDisableFinalizeIgnoreOriginalFlag(void) const
オリジナル参照とタイムスタンプ比較を無視して、強制的にファイナライズを無効化しているかのフラグを取得
Definition GxSysResource.h:1665

GxSysResource::getConvertPath
void getConvertPath(GxString &dst, const GxResBase &resource) const
対象リソース変換先出力パス取得 (リソース指定)
Definition GxSysResource.cpp:4221

GxSysResource::_originalRootPath
GxString _originalRootPath
オリジナルリソースルートパス
Definition GxSysResource.h:1590

GxSysResource::createResource
GxResBase * createResource(const GxRttiResource &resRtti, GX_CSTR path, void *pCreateCallbackWork=nullptr)
リソース作成
Definition GxSysResource.cpp:3275

GxSysResource::getFinalizedCommonPath
static void getFinalizedCommonPath(GxString &dst, GX_CSTR path)
ハードウェア共通ファイナライズパス取得
Definition GxSysResource.cpp:3955

GxSysResource::getFinalizeResourcePath
void getFinalizeResourcePath(GxString &dst, const GxResBase &resource)
ファイナライズリソースパス取得
Definition GxSysResource.cpp:5806

GxSysResource::setOnTerminateCallback
void setOnTerminateCallback(void(*func)(u32))
Definition GxSysResource.cpp:7330

GxSysResource::isExistFileFromMasterResource
b32 isExistFileFromMasterResource(const GxRttiResource &resRtti, GX_CSTR resourcePath, b32 isCheckArchiveOnly=false, s16 archiveID=-1) const
マスターリソース内でのリソースファイル存在チェック (リソースRtti + リソースパス指定)
Definition GxSysResource.cpp:4316

GxSysResource::createAndLoadResource
GxResBase * createAndLoadResource(const GxRttiResource &resRtti, GX_CSTR path, LOAD_MODE loadMode=LOAD_MODE::SYNC, void *pCreateCallbackWork=nullptr)
リソース作成 ＋ 読み込み (Rtti + リソースパス指定)
Definition GxSysResource.cpp:2978

GxSysResource::isExistResource
GX_FORCE_INLINE b32 isExistResource(const GxRttiResource &resRtti, GX_CSTR resourcePath)
メモリ上のリソース存在チェック (リソースRtti + リソースパス指定)
Definition GxSysResource.h:1823

GxSysResource::_fileDecodeChunkSizeMax
u32 _fileDecodeChunkSizeMax
圧縮リソースファイル展開用の最大チャンクサイズ
Definition GxSysResource.h:1587

GxSysResource::getMasterRootPath
constexpr GX_CSTR getMasterRootPath(void) const
マスタールートパス取得
Definition GxSysResource.h:1424

GxSysResource::unlockAsyncLoad
GX_FORCE_INLINE void unlockAsyncLoad(void)
非同期ロードを再開(lockAsyncLoad() と対で使用すること)
Definition GxSysResource.h:1231

GxSysResource::isExistFile
GX_FORCE_INLINE b32 isExistFile(const GxResBase &resource) const
リソースファイル存在チェック (リソース指定)
Definition GxSysResource.h:1797

GxSysResource::waitForLoadComplete
b32 waitForLoadComplete(GxResBase *pResource)
読み込み完了までブロックする。
Definition GxSysResource.cpp:6426

GxSysResource::loadResourceSync
LOAD_RESULT loadResourceSync(GxResBase &resource, void *pCreateCallbackWork=nullptr)
リソース読み込み (同期)
Definition GxSysResource.cpp:5825

GxSysResource::getFinalizedCommonRootPath
constexpr GX_CSTR getFinalizedCommonRootPath(void) const
ハードウェア共通ファイナライズリソースルートパス取得
Definition GxSysResource.h:1420

GxSysResource::getResourceRootPath
constexpr GX_CSTR getResourceRootPath(void) const
リソースルートパス取得 (※カレントディレクトリからの相対パス)
Definition GxSysResource.h:1413

GxSysResource::getResourceNum
GX_FORCE_INLINE u32 getResourceNum(void)
登録済みリソース数取得
Definition GxSysResource.h:1770

GxSysResource::loadResourceFromStream
LOAD_RESULT loadResourceFromStream(GxResBase &resource, GxStream &stream, u32 size=0)
リソース読み込み (from ストリーム)
Definition GxSysResource.cpp:6178

GxSysResource::_pUserErrorFunction
GX_SYSRESOURCE_ERROR_FUNCTION _pUserErrorFunction
ユーザー定義のエラーコールバック
Definition GxSysResource.h:1586

GxSysResource::setResourceRootPath
void setResourceRootPath(GX_CSTR path=nullptr)
リソースルートパス設定 (※カレントディレクトリからの相対パス)
Definition GxSysResource.cpp:3732

GxSysResource::getResourcePath
static void getResourcePath(GxString &dst, GX_CSTR path, b32 isDeleteExtension=true)
リソースパス取得 (フルパス指定)
Definition GxSysResource.cpp:4036

GxSysResource::isEmptyBackgroundLoader
GX_FORCE_INLINE b32 isEmptyBackgroundLoader(void)
裏読みロードのリクエストキューが空かどうか
Definition GxSysResource.h:1505

GxSysResource::isRegisteredNonReplacedPath
virtual GX_FORCE_INLINE b32 isRegisteredNonReplacedPath(GX_CSTR &, GX_CSTR &) const
置き換え元のパスを登録
Definition GxSysResource.h:1462

GxSysResource::getOptimizeAsyncloadThreadAssignment
const b32 getOptimizeAsyncloadThreadAssignment(void) const
非同期ロード時にリソースのスレッド分配をより効率化する
Definition GxSysResource.h:1701

GxSysResource::createAndSetResource
GxResBase * createAndSetResource(const GxRttiResource &resRtti, GX_CSTR path, GxMemoryStream &stream, LOAD_MODE loadMode=LOAD_MODE::SYNC, void *pCreateCallbackWork=nullptr)
リソース作成 ＋ データ割り当て
Definition GxSysResource.cpp:3170

GxSysResource::_masterRootPath
GxString _masterRootPath
マスターリソースルートパス
Definition GxSysResource.h:1593

GxSysResource::getDataResourceGuid
GX_FORCE_INLINE GxDataResourceGuid & getDataResourceGuid(void)
リソースのGUID管理データを取得
Definition GxSysResource.h:1564

GxSysResource::_optimizeAsyncloadThreadAssignment
b32 _optimizeAsyncloadThreadAssignment
非同期ロード時にリソースのスレッド分配をより効率化する
Definition GxSysResource.h:1597

GxSysResource::_dataResourceGuid
GxDataResourceGuid _dataResourceGuid
リソースのGUID管理データ
Definition GxSysResource.h:1599

GxSysResource::analyseResourcePath
static void analyseResourcePath(GX_CSTR path, PATH_TYPE *pType, s32 *pRootPosition, u32 *pRootLength)
リソースパス解析
Definition GxSysResource.cpp:5451

GxSysResource::getMotionSequenceLineMax
constexpr u32 getMotionSequenceLineMax(void) const
モーションシーケンスのラインの最大数を取得
Definition GxSysResource.h:1508

GxSysResource::getOriginalRootPath
constexpr GX_CSTR getOriginalRootPath(void) const
オリジナルリソースルートパス取得
Definition GxSysResource.h:1418

GxSysResource::isArchiveOpened
GX_FORCE_INLINE b32 isArchiveOpened(s16 archiveId) const
アーカイブファイルがオープンしているか調べる
Definition GxSysResource.h:1256

GxSysResource::_finalizedNativeRootPath
GxString _finalizedNativeRootPath
ハードウェア固有ファイナライズリソースルートパス
Definition GxSysResource.h:1592

GxSysResource::lockFromOutside
GX_FORCE_INLINE void lockFromOutside(void)
外部からのlock処理
Definition GxSysResource.h:1630

GxSysResource::lockAsyncLoad
GX_FORCE_INLINE void lockAsyncLoad(void)
非同期ロードを一時停止(現在処理中のファイル読み込みが終わるまでブロックされる)
Definition GxSysResource.h:1229

GxSysResource::getArchiveFileMax
constexpr u32 getArchiveFileMax(void) const
アーカイブファイルの管理数の上限を取得
Definition GxSysResource.h:1254

GxSysResource::createResourceRoutine
GxResBase * createResourceRoutine(const GxRttiResource &resRtti, GX_CSTR original, GX_CSTR replace, b32 *pIsNewCreate, void *pCreateCallbackWork)
リソース作成内部ルーチン
Definition GxSysResource.cpp:5686

GxSysResource::reloadResource
b32 reloadResource(GxResBase *pResource, LOAD_MODE loadMode=LOAD_MODE::SYNC)
リソース再読み込み
Definition GxSysResource.cpp:3611

GxSysResource::_motionSequenceLineMax
u32 _motionSequenceLineMax
モーションシーケンスのラインの最大数
Definition GxSysResource.h:1596

GxSysResource::_loadStateCriticalSection
GxCriticalSection _loadStateCriticalSection
ロード開始状態用クリティカルセクション
Definition GxSysResource.h:1577

GxSysResource::getResourceAsyncLoadManager
constexpr GxSysResourceAsyncLoadBase * getResourceAsyncLoadManager(void) const
非同期リソース読み込み管理を取得
Definition GxSysResource.h:1223

GxSysResource::LOAD_RESULT
LOAD_RESULT
リソース読み込み結果
Definition GxSysResource.h:1123

GxSysResource::LOAD_RESULT::ERROR_
@ ERROR_
エラー

GxSysResource::LOAD_RESULT::CANCELED
@ CANCELED
キャンセル

GxSysResource::LOAD_RESULT::OK
@ OK
成功

GxSysResource::isOriginalPath
static b32 isOriginalPath(GX_CSTR path)
オリジナルリソースパス判定
Definition GxSysResource.cpp:3771

GxSysResource::_resourceRegisterManager
GxSysResourceRegister _resourceRegisterManager
リソース登録管理
Definition GxSysResource.h:1572

GxSysResource::terminate
void terminate(void) override
終了
Definition GxSysResource.cpp:2857

GxSysResource::RESOURCE_ORIGINAL_ROOT_NAME
static GX_CSTR RESOURCE_ORIGINAL_ROOT_NAME
オリジナルリソースパスルート名
Definition GxSysResource.h:1140

GxSysResource::getFinalizedNativePath
static void getFinalizedNativePath(GxString &dst, GX_CSTR path)
ハードウェア固有ファイナライズパス取得
Definition GxSysResource.cpp:3994

GxSysResource::searchResourceFileTableTargetLoop
b32 searchResourceFileTableTargetLoop(GX_CSTR rootPath, const GxResourceFileTable &fileTableElement, const GxResourceFileFilter *pFileFilterTable, const GxRttiResource *pRttiTarget, RESOURCE_FILE_TABLE_SEARCH_CALLBACK function, void *pArgument)
リソースファイルテーブル探索処理ループ
Definition GxSysResource.cpp:7116

GxSysResource::cancelResource
void cancelResource(GxResBase *pResource)
リソース非同期ロードキャンセル
Definition GxSysResource.cpp:3592

GxSysResource::getOptimizeTBNRemakeRange
const f32 getOptimizeTBNRemakeRange(void) const
モデルをファイナライズするときのTBNの再計算で利用する閾値を取得
Definition GxSysResource.h:1692

GxSysResource::getResourceId
static u64 getResourceId(const GxRttiResource &resRtti, GX_CSTR resourcePath)
リソースID生成
Definition GxSysResource.cpp:5517

GxSysResource::setDisableFinalizeIgnoreOriginalFlag
GX_FORCE_INLINE void setDisableFinalizeIgnoreOriginalFlag(b32 flag)
オリジナル参照とタイムスタンプ比較を無視して、強制的にファイナライズを無効化しているかのフラグを設定
Definition GxSysResource.h:1490

GxSysResource::getMasterPath
void getMasterPath(GxString &dst, const GxResBase &resource) const
対象リソースマスターパス取得 (リソース指定)
Definition GxSysResource.cpp:4260

GxSysResource::_resourceCallbackManager
GxSysResourceCallback _resourceCallbackManager
コールバック管理
Definition GxSysResource.h:1573

GxSysResource::LOAD_MODE
LOAD_MODE
リソース読み込みモード
Definition GxSysResource.h:1116

GxSysResource::LOAD_MODE::SYNC
@ SYNC
同期読み込み

GxSysResource::LOAD_MODE::ASYNC
@ ASYNC
非同期読み込み

GxSysResource::_resourceRootPath
GxString _resourceRootPath
リソース全体ルートパス
Definition GxSysResource.h:1589

GxSysResource::_optimizeTBNRemakeRange
f32 _optimizeTBNRemakeRange
モデルをファイナライズするときのTBNの再計算で利用する閾値(デフォルトは0.1f)
Definition GxSysResource.h:1595

GxSysResource::loadResourceFileAsync
LOAD_RESULT loadResourceFileAsync(GxResBase &resource, GxFile &file, u32 offset, u32 size)
リソースファイル非同期読み込み処理 (リソース非同期読み込み処理内サブルーチン)
Definition GxSysResource.cpp:6328

GxSysResource::getFinalizedNativeRootPath
constexpr GX_CSTR getFinalizedNativeRootPath(void) const
ハードウェア固有ファイナライズリソースルートパス取得
Definition GxSysResource.h:1422

GxSysResource::_disableFinalizeIgnoreOriginalFlag
b32 _disableFinalizeIgnoreOriginalFlag
オリジナル参照とタイムスタンプ比較を無視して、強制的にファイナライズを無効化。(すでにファイナライズがある前提)
Definition GxSysResource.h:1584

GxSysResource::isFinalizedCommonPath
static b32 isFinalizedCommonPath(GX_CSTR path)
ハードウェア共通ファイナライズパス判定
Definition GxSysResource.cpp:3786

GxSysResource::loadFileImage
void * loadFileImage(const GxRttiResource &resRtti, GX_CSTR path, u32 &dataSize, GxAllocatorList::ALLOCATOR_TYPE allocator=GxAllocatorList::ALLOCATOR_TYPE::TEMPORARY)
ファイルをメモリに直接読み込む
Definition GxSysResource.cpp:3469

GxSysResource::getResourceFilterTable
const GxResourceFileFilter * getResourceFilterTable(void) const
リソースフィルタテーブルポインタ取得
Definition GxSysResource.h:1656

GxSysResource::_resourceAsyncLoadManager
GxSysResourceAsyncLoadBase * _resourceAsyncLoadManager
非同期ロード管理
Definition GxSysResource.h:1574

GxSysResource::_resourceArchiveManager
GxSysResourceArchive _resourceArchiveManager
アーカイブ管理
Definition GxSysResource.h:1576

GxSysResource::unregisterResource
void unregisterResource(GxResBase *pResource)
リソース破棄
Definition GxSysResource.cpp:3677

GxSysResource::isFinalizedNativePath
static b32 isFinalizedNativePath(GX_CSTR path)
ハードウェア固有ファイナライズパス判定
Definition GxSysResource.cpp:3801

GxSysResource::getReplacePath
virtual void getReplacePath(GxString &dstPath, const GxRttiResource &, GX_CSTR srcPath) const
置き換えパスを取得
Definition GxSysResource.cpp:4141

GxSysResource::registerResource
void registerResource(GxResBase *pResource)
リソース登録
Definition GxSysResource.cpp:3661

GxSysResource::isSkipSearchFileTableTargetName
b32 isSkipSearchFileTableTargetName(GX_CSTR fileName, const GxResourceFileFilter *pFileFilterTable=nullptr)
リソースファイルテーブル探索スキップ判定
Definition GxSysResource.cpp:7213

GxSysResource::getSeparateShaderConfig
const b32 getSeparateShaderConfig(void) const
シェーダコンフィグファイルを各プラットフォームごとに分けるかどうかを取得
Definition GxSysResource.h:1683

GxSysResource::_enableExistOriginalDataFlag
b32 _enableExistOriginalDataFlag
リソースの読み込み時にオリジナルデータの有無をチェックするか否か(trueでチェックを行う)
Definition GxSysResource.h:1583

GxSysResource::openArchiveFile
b32 openArchiveFile(GX_CSTR base, const GxResourceFileTable *pResourceFileTable, s16 archiveId)
Definition GxSysResource.cpp:3705

GxSysResource::_pResourceFileTable
GxResourceFileTable * _pResourceFileTable
リソースファイルテーブル
Definition GxSysResource.h:1579

GxSysResource::_optimizeVertexCache
b32 _optimizeVertexCache
頂点キャッシュ最適化のためのインデックスソートを行う
Definition GxSysResource.h:1582

GxSysResource::_pArchiveSearchOrder
s16 * _pArchiveSearchOrder
アーカイブ検索順テーブル
Definition GxSysResource.h:1581

GxSysResource::getResourceBackgroundLoadManager
constexpr GxSysResourceAsyncLoadBase * getResourceBackgroundLoadManager(void) const
非同期リソース裏読み込み管理を取得
Definition GxSysResource.h:1225

GxSysResource::createAndLoadBackground
GxResBase * createAndLoadBackground(const GxRttiResource &resRtti, GX_CSTR path, void *pCreateCallbackWork=nullptr)
リソース作成 ＋ バックグラウンド読み込み (Rtti + リソースパス指定)
Definition GxSysResource.cpp:3126

GxSysResource::update
void update(void) override
実行
Definition GxSysResource.cpp:2887

GxSysResource::_separeteShaderConfig
b32 _separeteShaderConfig
各プラットフォームでシェーダコンフィグファイルを分ける
Definition GxSysResource.h:1585

GxSysResource::createAndSetResourceFromFileImage
GxResBase * createAndSetResourceFromFileImage(const GxRttiResource &resRtti, GX_CSTR path, void *pLoadBuffer, u32 dataSize, LOAD_MODE loadMode=LOAD_MODE::SYNC, void *pCreateCallbackWork=nullptr)
メモリ上のデータからリソースを作成
Definition GxSysResource.cpp:3575

GxSysResource::getOptimizeVertexCache
const b32 getOptimizeVertexCache(void) const
頂点キャッシュ最適化のためのインデックスソートを行うかどうかを取得
Definition GxSysResource.h:1674

GxSysResource::GxSysResource
GxSysResource(void)
コンストラクタ
Definition GxSysResource.cpp:2573

GxSysResource::isEmptyAsyncLoader
GX_FORCE_INLINE b32 isEmptyAsyncLoader(void)
非同期ロードのリクエストキューが空かどうか
Definition GxSysResource.h:1503

GxSysResource::getResource
GX_FORCE_INLINE GxResBase * getResource(u32 index)
登録済みリソース取得 (インデックス指定)
Definition GxSysResource.h:1784

GxSysResource::unlockFromOutside
GX_FORCE_INLINE void unlockFromOutside(void)
外部からのunlock処理
Definition GxSysResource.h:1638

GxSysResource::getFullPath
void getFullPath(GxString &dst, const GxResBase &resource) const
対象リソースフルパス取得 (リソース指定)
Definition GxSysResource.cpp:4195

GxSysResource::RESOURCE_FILE_TABLE_SEARCH_CALLBACK
b32(*) RESOURCE_FILE_TABLE_SEARCH_CALLBACK(const GxRttiResource &resRtti, GX_CSTR resourcePath, void *pArgument)
対象リソースファイル情報探索コールバック
Definition GxSysResource.h:1146

GxSysResource::getOriginalPath
static void getOriginalPath(GxString &dst, GX_CSTR path)
オリジナルリソースパス取得
Definition GxSysResource.cpp:3916

GxSysResource::loadResourceAsync
LOAD_RESULT loadResourceAsync(GxResBase &resource, void *pCreateCallbackWork=nullptr)
リソース読み込み (非同期)
Definition GxSysResource.cpp:6011

GxSysResource::_pResourceFileFilter
GxResourceFileFilter * _pResourceFileFilter
リソースファイルフィルタ
Definition GxSysResource.h:1580

GxSysResource::initialize
b32 initialize(const GxClassBase *pInitialInformation=nullptr) override
初期化
Definition GxSysResource.cpp:2624

GxSysResource::_finalizedCommonRootPath
GxString _finalizedCommonRootPath
ハードウェア共通ファイナライズリソースルートパス
Definition GxSysResource.h:1591

GxSysResource::initializeArchiveSearchOrder
void initializeArchiveSearchOrder(const s16 *pArchiveSearchOrderTable=nullptr)
Definition GxSysResource.cpp:3723

GxSysResource::~GxSysResource
~GxSysResource(void) override
デストラクタ
Definition GxSysResource.cpp:2613

GxSysResource::callbackLoadStart
static void callbackLoadStart(void *pUser, GX_HANDLE requestHandle)
リソースファイル非同期読み込み開始コールバック関数
Definition GxSysResource.cpp:6402

GxSysResource::RESOURCE_FINALIZED_COMMON_ROOT_NAME
static GX_CSTR RESOURCE_FINALIZED_COMMON_ROOT_NAME
ハードウェア共通ファイナライズリソースパスルート名
Definition GxSysResource.h:1142

GxSysResource::getLoadPath
void getLoadPath(GxString &dst, const GxRttiResource &resRtti, GX_CSTR resourcePath)
ロードファイルパス取得
Definition GxSysResource.cpp:6453

GxSysResource::getRootPath
GX_CSTR getRootPath(const GxResBase &resource) const
対象リソースルートパス取得 (リソース指定)
Definition GxSysResource.cpp:4157

GxSysResource::stopAsyncLoadSystem
void stopAsyncLoadSystem(void)
リソース非同期ロードシステム停止
Definition GxSysResource.cpp:3692

GxSysResource::getResourceFileTable
const GxResourceFileTable * getResourceFileTable(void) const
リソースファイルテーブルポインタ取得
Definition GxSysResource.h:1647

GxSysResource::_resourceBackgroundLoadManager
GxSysResourceAsyncLoadBase * _resourceBackgroundLoadManager
裏読みロード管理
Definition GxSysResource.h:1575

GxSysResourceRegister
リソース登録管理クラス
Definition GxSysResource.h:246

GxSysResourceRegister::findResource
GxResBase * findResource(u64 resourceId)
リソース探索
Definition GxSysResource.cpp:350

GxSysResourceRegister::registerResource
b32 registerResource(GxResBase *pResource)
リソース登録
Definition GxSysResource.cpp:268

GxSysResourceRegister::getResourceNum
u32 getResourceNum(void) const
リソース個数取得
Definition GxSysResource.cpp:448

GxSysResourceRegister::GxSysResourceRegister
GxSysResourceRegister(void)
コンストラクタ
Definition GxSysResource.cpp:257

GxSysResourceRegister::getRegisterResource
GxResBase * getRegisterResource(u32 index)
指定インデックス登録リソース取得
Definition GxSysResource.cpp:385

GxSysResourceRegister::unregisterResource
b32 unregisterResource(GxResBase *pResource)
リソース解除
Definition GxSysResource.cpp:306

GxSysResourceRegister::~GxSysResourceRegister
~GxSysResourceRegister(void) override
デストラクタ
Definition GxSysResource.h:300

GxThread
スレッドクラス
Definition GxThread.h:177

SingletonBase
シングルトン基礎クラス
Definition GxSingleton.h:19

SingletonBase< GxSysResource >::getSingletonPointer
static constexpr GxSysResource * getSingletonPointer(void)
Definition GxSingleton.h:59

GxResourceFileFilter
Definition GxSysResource.h:59

GxResourceFileFilter::isEnd
GX_FORCE_INLINE b32 isEnd(void) const
終端判定
Definition GxSysResource.h:66

GxResourceFileFilter::_pFileName
GX_CSTR _pFileName
フィルタ対象ファイル名(or ディレクトリ名) (※終端要素にはnullptrを設定する必要がある)
Definition GxSysResource.h:74

GxResourceFileTable
Definition GxSysResource.h:25

GxResourceFileTable::_pResourcePath
GX_CSTR _pResourcePath
リソースパス (※終端要素にはnullptrを設定する必要がある)
Definition GxSysResource.h:46

GxResourceFileTable::_isHddInstall
u16 _isHddInstall
HDDインストールフラグ (※予約)
Definition GxSysResource.h:48

GxResourceFileTable::isEnd
GX_FORCE_INLINE b32 isEnd(void) const
終端判定
Definition GxSysResource.h:34

GxResourceFileTable::allocArray
static GxResourceFileTable * allocArray(const GxResourceFileTable *pResourceFileTable, s16 archiveId)
Definition GxSysResource.cpp:198

GxResourceFileTable::_archiveId
s16 _archiveId
アーカイブID (※同一IDを１つのアーカイブとする。負数の場合は非アーカイブファイル)
Definition GxSysResource.h:47

GxResourceFileTable::isDirectory
GX_FORCE_INLINE b32 isDirectory(void) const
ディレクトリ指定判定
Definition GxSysResource.h:32

GxString
文字列型クラス
Definition GxString.h:18

GxString::getString
GX_FORCE_INLINE GX_STR getString(void)
文字列取得
Definition GxString.h:165

GxSysResourceArchive::GxArchiveFileInformation
アーカイブファイル情報
Definition GxSysResource.h:941

GxSysResourceArchive::GxArchiveFileInformation::_resourceId
u64 _resourceId
リソースID
Definition GxSysResource.h:943

GxSysResourceArchive::GxArchiveFileInformation::_path
GxString _path
ファイルパス
Definition GxSysResource.h:942

GxSysResourceArchive::GxArchiveHeader
アーカイブヘッダー
Definition GxSysResource.h:927

GxSysResourceArchive::GxArchiveHeader::_fileCount
u32 _fileCount
アーカイブファイル数
Definition GxSysResource.h:929

GxSysResourceArchive::GxArchiveHeader::_fourCC
u32 _fourCC
アーカイブヘッダーFourCC
Definition GxSysResource.h:928

GxSysResourceArchive::GxArchiveOffsetInformation
オフセットテーブル情報
Definition GxSysResource.h:934

GxSysResourceArchive::GxArchiveOffsetInformation::_size
u32 _size
ファイルサイズ
Definition GxSysResource.h:936

GxSysResourceArchive::GxArchiveOffsetInformation::_offset
u32 _offset
ファイル先頭オフセット位置
Definition GxSysResource.h:935

b32
32bitブーリアン
Definition GxDefine.h:173