GxSysMain.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
#include "flag.h"
#if GX_DEVELOP
#include "developFlag.h"
#endif //GX_DEVELOP
#if defined(_WINDOWS)
#if GX_DEVELOP
#if _MSC_VER >= 1900
#pragma warning(disable:4091) // VS2015 patch
#endif //_MSC_VER
#include <dbghelp.h>
#if _MSC_VER >= 1900
#pragma warning(default:4091)
#endif //_MSC_VER
#endif //GX_DEVELOP
#endif //_WINDOWS
 
GX_CORE_NAMESPACE_BEGIN()
class GxRenderDevice;
class GxProfiler;
class GxSysRenderBase;
class GxSysShader;
class GxSysFilterBase;
class GxSysResource;
class GxStageInitialInformationBase;
class GxRenderInitialInformation;
class GxSysPrimitive;
class GxPrimitiveInitialInformation;
class GxSysFile;
class GxResourceInitialInformation;
class GxSysUnit;
class GxSysStage;
class GxSysInput;
class GxInputInitialInformation;
class GxSysLightBase;
class GxSysEnvironment;
class GxSysGpgpu;
class GxSysCollisionBase;
class GxCollisionInitialInformationBase;
class GxSysDynamicsBase;
class GxDynamicsInitialInformationBase;
class GxSysP2PBase;
class GxSysFontBmpBase;
#if GX_DEVELOP
class GxSysTool;
class GxSysDebugCommunication;
class GxToolInitialInformation;
class GxDebugCommunicationInitialInformation;
class GxSysThread;
#endif //GX_DEVELOP
class GxSysEffectBase;
class GxEffectInitialInformationBase;
class GxFilterInitialInformationBase;
class GxSysSoundBase;
class GxSysNetworkBase;
class GxNetworkInitialInformation;
class GxUnitInitialInformation;
class GxSoundInitialInformationBase;
class GxSysMovieBase;
class GxMovieInitialInformationBase;
class GxSysFont;
class GxFontInitialInformation;
 
//===========================================================================
//===========================================================================
class GxMainInitialInformation : public GxClassBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS(GxMainInitialInformation, GxClassBase)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxMainInitialInformation)
 
    
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GxMainInitialInformation(
        GxStageInitialInformationBase* pStageInitialInformation,
        GxRenderInitialInformation* pRenderInitialInformation,
        GxPrimitiveInitialInformation* pPrimitiveInitialInformation,
        GxResourceInitialInformation* pResourceInitialInformation,
        GxEffectInitialInformationBase* pEffectInitialInformation,
        GxFilterInitialInformationBase* pFilterInitialInformation,
        GxInputInitialInformation* pInputInitialInformation,
        GxCollisionInitialInformationBase* pCollisionInitialInformation,
        GxDynamicsInitialInformationBase* pDynamicsInitialInformation,
        GxNetworkInitialInformation* pNetworkInitialInformation,
        GxUnitInitialInformation* pUnitInitialInformation,
        GxSoundInitialInformationBase* pSoundInitialInformation,
        GxMovieInitialInformationBase* pMovieInitialInformation,
        GxFontInitialInformation* pFontInitialInformation
#if GX_DEVELOP
        , GxToolInitialInformation* pToolInitialInformation
        , GxDebugCommunicationInitialInformation* pDebugCommunicationInitialInformation = nullptr
#endif //GX_DEVELOP
    );
 
private:
    GxMainInitialInformation(void);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    void loadJson(GX_CSTR path);
    void loadJson(const GxJson::GxJsonNode& jsonNode);
 
#if GX_DEVELOP
    static GxGuiBase* createGui(GxProperty& property, GxTypedObject* pOwner, const GxRtti& rtti, u32 index);
#endif // GX_DEVELOP
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GX_FORCE_INLINE void setUserAllocatorInformationArray(GxAllocatorList::GxCreateInformation* pUserAllocatorInformationArray, u32 count)
    {
        _pUserAllocatorInformationArray = pUserAllocatorInformationArray;
        _userAllocatorInformationCount = count;
    }
    constexpr GxAllocatorList::GxCreateInformation* getUserAllocatorInformationArray(void) const { return _pUserAllocatorInformationArray; }
    constexpr u32 getUserAllocatorInformationCount(void) const { return _userAllocatorInformationCount; }
    constexpr GxStageInitialInformationBase* getStageInitialInformation(void) const { return _pStageInitialInformation; }
    constexpr GxRenderInitialInformation* getRenderInitialInformation(void) const { return _pRenderInitialInformation; }
    constexpr GxPrimitiveInitialInformation* getPrimitiveInitialInformation(void) const { return _pPrimitiveInitialInformation; }
    constexpr GxResourceInitialInformation* getResourceInitialInformation(void) const { return _pResourceInitialInformation; }
    constexpr GxEffectInitialInformationBase* getEffectInitialInformation(void) const { return _pEffectInitialInformation; }
    constexpr GxFilterInitialInformationBase* getFilterInitialInformation(void) const { return _pFilterInitialInformation; }
    constexpr GxInputInitialInformation* getInputInitialInformation(void) const { return _pInputInitialInformation; }
    constexpr GxCollisionInitialInformationBase* getCollisionInitialInformation(void) const { return _pCollisionInitialInformation; }
    constexpr GxDynamicsInitialInformationBase* getDynamicsInitialInformation(void) const { return _pDynamicsInitialInformation; }
    constexpr GxNetworkInitialInformation* getNetworkInitialInformation(void) const { return _pNetworkInitialInformation; }
    constexpr GxUnitInitialInformation* getUnitInitialInformation(void) const { return _pUnitInitialInformation; }
    constexpr GxSoundInitialInformationBase* getSoundInitialInformation(void) const { return _pSoundInitialInformation; }
    constexpr GxMovieInitialInformationBase* getMovieInitialInformation(void) const { return _pMovieInitialInformation; }
    constexpr GxFontInitialInformation* getFontInitialInformation(void) const { return _pFontInitialInformation; }
#if GX_DEVELOP
    constexpr GxToolInitialInformation* getToolInitialInformation(void) const { return _pToolInitialInformation; }
    constexpr GxDebugCommunicationInitialInformation* getDebugCommunicationInitialInformation(void) const { return _pDebugCommunicationInitialInformation; }
 
    constexpr GX_CSTR getInitialLoadPath( void ) { return _initialLoadPath; }
    constexpr GX_CSTR getLoadPath( void ) const { return _loadPath.getString(); }
    constexpr GX_CSTR getPlatformName( void ) const { return _platformName.getString(); }
#endif //GX_DEVELOP
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    s32 _threadJobMax;      
    b32 _fixThreadFlag;     
 
#if defined(_PS4) || defined(_PS5) || defined(_XBOX_XS)
    u32 _saveDataSize;      
#if defined(_PS4) || defined(_PS5)
    b32 _isCopySaveDataIcon;    
#endif // _PS4 || _PS5
#endif // _PS4 || _PS5 || _XBOX_XS
 
#if defined(_PS4) || defined(_PS5)
    b32 _isFixMainThreadCpuIndex;   
#elif defined(_XBOX_XS)
    GxString _scid;         
#elif defined(_WINDOWS)
    b32 _useSteamSDK;       
    u32 _steamAppId;        
#endif //_WINDOWS
#if GX_DEVELOP
    u32 _xmlReadSize;       
    b32 _deserializeSafety; 
#if defined(_WINDOWS)
    b32 _menuBarEnable;     
    b32 _toolBarEnable;     
#endif //_WINDOWS
#endif //GX_DEVELOP
    GxThread::PRIORITY _threadPriority;     
#if GX_USE_UNIT_PROFILE
    b32 _useUnitProfile;                    
#endif //GX_USE_UNIT_PROFILE
    b32 _useSequentialThreadManagerPrecede; 
    u32 _systemAllocatorSize[static_cast<u32>(GxAllocatorList::ALLOCATOR_TYPE::SYSTEM_MAX)];    
 
private:
    GxAllocatorList::GxCreateInformation*   _pUserAllocatorInformationArray;    
    u32                                     _userAllocatorInformationCount;     
    GxStageInitialInformationBase*          _pStageInitialInformation;          
    GxRenderInitialInformation*             _pRenderInitialInformation;         
    GxPrimitiveInitialInformation*          _pPrimitiveInitialInformation;      
    GxResourceInitialInformation*           _pResourceInitialInformation;       
    GxEffectInitialInformationBase*         _pEffectInitialInformation;         
    GxFilterInitialInformationBase*         _pFilterInitialInformation;         
    GxInputInitialInformation*              _pInputInitialInformation;          
    GxCollisionInitialInformationBase*      _pCollisionInitialInformation;      
    GxDynamicsInitialInformationBase*       _pDynamicsInitialInformation;       
    GxNetworkInitialInformation*            _pNetworkInitialInformation;        
    GxUnitInitialInformation*               _pUnitInitialInformation;           
    GxSoundInitialInformationBase*          _pSoundInitialInformation;          
    GxMovieInitialInformationBase*          _pMovieInitialInformation;          
    GxFontInitialInformation*               _pFontInitialInformation;           
#if GX_DEVELOP
    GxToolInitialInformation*               _pToolInitialInformation;           
    GxDebugCommunicationInitialInformation* _pDebugCommunicationInitialInformation; 
 
    GX_CSTR                                 _initialLoadPath;                   
    GxString                                _loadPath;                          
    GxString                                _platformName;                      
#endif //GX_DEVELOP
 
};
 
//===========================================================================
//===========================================================================
class GxSysMain : public GxSysBase, public SingletonBase<GxSysMain>
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GX_RTTI_ABSTRACT_CLASS(GxSysMain, GxSysBase)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxSysMain)
 
    class GxSequentialThreadManagerMain;        
    class GxSequentialThreadManagerMainPrecede; 
    enum class EXIT_CODE
    {
        NORMAL, 
        ERROR_, 
    };
 
    enum class INITIALIZE_APPLICATION_RESULT
    {
        FAIL,   
        SUCCESS,
        FINISH, 
    };
 
    enum class GX_INITIALIZE_APPLICATION_SEQUENCE
    {
        SYS_FILE,                   
        SYS_RESOURCE,               
        SYS_INPUT,                  
#if GX_DEVELOP
        SYS_DEBUG_COMMUNICATION,    
#endif  //GX_DEVELOP
        SYS_SHADER,                 
        RENDER_DEVICE,              
        SYS_RENDER,                 
        SYS_PRIMITIVE,              
        SYS_EFFECT,                 
        SYS_LIGHT,                  
        SYS_ENVIRONMENT,            
        SYS_GPGPU,                  
        SYS_COLLISION,              
        SYS_DYNAMICS,               
        SYS_UNIT,                   
        SYS_NETWORK,                
        SYS_P2P,                    
        SYS_FONT,                   
#if GX_DEVELOP
        SYS_TOOL,                   
        SYS_THREAD,                 
#endif  //GX_DEVELOP
        SYS_STAGE,                  
        SYS_FONT_BMP,               
        SYS_FILTER,                 
        SYS_SOUND,                  
        SYS_MOVIE,                  
        FINISH,                     
    };
 
#if defined(_WINDOWS)
    enum class WINDOW_MODE
    {
        WINDOW,         
        BORDER_LESS,    
        FULL_SCREEN,    
        MAX,            
    };
#if GX_DEVELOP
    GX_ENUM_TABLE_MAX(WINDOW_MODE)
#endif //GX_DEVELOP
#endif //_WINDOWS
 
    enum class PLAY_MODE
    {
        STOP = 0,   
        PAUSE,      
        PLAY,       
    };
 
#if GX_ASSERT_ENABLE
    enum class GX_ASSERT_MODE
    {
        BREAK = 0,              
        END,                    
    };
#endif  // GX_ASSERT_ENABLE
 
    struct BootConfigEnumMap
    {
        GX_CSTR     _name;      
        u32         _value;     
    };
 
    static constexpr u32 SYSTEM_FLAG_NUM    = GxMath::VALUE_2K / 32;
    static constexpr u32 SYSTEM_FLAG_MAX    = SYSTEM_FLAG_NUM * 32;  // (32bit × u32 work num)
 
    static constexpr u32 DEVELOP_FLAG_NUM   = GxMath::VALUE_1K / 32;
    static constexpr u32 DEVELOP_FLAG_MAX   = DEVELOP_FLAG_NUM * 32;
 
    static constexpr u32 BOOT_COMMAND_LINE_MAX              = GxMath::VALUE_1K;
    static constexpr u32 BOOT_COMMAND_LINE_ARGUMENT_MAX     = GxMath::VALUE_32;
    static GX_CSTR BOOT_ARGUMENT_AUTO_FINALIZE;
#if defined(_WINDOWS)
    static GX_CSTR BOOT_ARGUMENT_AUTO_FINALIZE_FBX;
#endif //_WINDOWS
 
protected:
#if GX_DEVELOP
#if defined(_WINDOWS)
    struct ICON_RESOURCE
    {
        GX_HANDLE _handleIcon;  
        HBITMAP _handleBitmap;  
        GxSize _bitmapSize;     
    };
#endif //_WINDOWS
#endif //GX_DEVELOP
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GxSysMain(void);
    ~GxSysMain(void) override {}
    b32 initialize(const GxClassBase* pInitialInformation) override;
    void terminate(void) override;
    void forceExit( EXIT_CODE code );
    GX_FORCE_INLINE b32 isExiting(void) const { return !_enable; }
 
protected:
    virtual GxSysRenderBase* createSysRender(void);
    virtual GxSysShader* createSysShader(void);
    virtual GxSysFilterBase* createSysFilter(void);
    virtual GxSysResource* createSysResource(void);
    virtual GxSysPrimitive* createSysPrimitive(void);
    virtual GxSysFile* createSysFile(void);
    virtual GxSysUnit* createSysUnit(void);
    virtual GxSysStage* createSysStage(void);
    virtual GxSysInput* createSysInput(void);
    virtual GxSysLightBase* createSysLight(void);
    virtual GxSysEnvironment* createSysEnvironment(void);
    virtual GxSysGpgpu* createSysGpGpu(void);
    virtual GxSysCollisionBase* createSysCollision(void);
    virtual GxSysDynamicsBase* createSysDynamics(void);
    virtual GxSysP2PBase* createSysP2P(void);
    virtual GxSysFontBmpBase* createSysFontBmp(void);
    virtual GxSysFont* createSysFont(void);
#if GX_DEVELOP
    virtual GxSysTool* createSysTool(void);
    virtual GxSysDebugCommunication* createSysDebugCommunication(void);
#endif //GX_DEVELOP
    virtual GxSysEffectBase* createSysEffect(void);
    virtual GxSysSoundBase* createSysSound(void);
    virtual GxSysMovieBase* createSysMovie(void);
    virtual GxSysNetworkBase* createSysNetwork(void);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
#if defined(_WINDOWS)
#if GX_DEVELOP
    void createMenuBar(void);
    void releaseMenuBar(void);
    void createToolBar(void);
    void releaseToolBar(void);
    void setToolBarButtonOn(u32 index, b32 on);
    void releaseMenubarAndToolbarBitmap(void);
#endif //GX_DEVELOP
    WINDOW_MODE getWindowMode(void);
    void setWindowMode(WINDOW_MODE windowMode);
#endif  //_WINDOWS
protected:
    virtual void loadModule(void);
    virtual void unloadModule(void);
    INITIALIZE_APPLICATION_RESULT initializeApplication(const GxMainInitialInformation* pMainInitialInformation, u32 initializeSequence);
    virtual void terminateApplication(void);
    virtual void initializeModule(const GxMainInitialInformation* pMainInitialInformation);
    virtual void terminateModule(void);
    virtual void releaseAllocator(void);
    b32 initializeLoop(const GxMainInitialInformation* pMainInitialInformation);
    virtual void callUsage(void) {}
 
private:
    void createSystem(void);
#if defined(_WINDOWS)
#if GX_DEVELOP
    u32 createSubMenuBar(HMENU hMenu, u32 tableIndex, GxPropertyTable& table);
    MENUITEMINFOW createMenuItemInfoSeparator(void);
    MENUITEMINFOW createMenuItemInfoNormalW(GX_WSTR name, u32 id, GX_HANDLE iconHandle = 0);
    MENUITEMINFOW createMenuItemInfoCheckmarkW(GX_WSTR name, u32 id, b32 value, GX_HANDLE iconHandle = 0);
    MENUITEMINFOW createMenuItemInfoPopupW(GX_WSTR name, u32 id, GX_HANDLE iconHandle = 0);
    HBITMAP searchOrCreateHbitmapFromIconHandle(GX_HANDLE iconHandle, GxSize* outBitMapSize = nullptr);
    HBITMAP createHbitmapFromIconHandle(GX_HANDLE iconHandle);
    u32 searchResourceIdFromIconHandle(GX_HANDLE iconHandle);
#endif //GX_DEVELOP
#endif  //_WINDOWS
 
public:
    EXIT_CODE    mainLoop(void);
 
    b32 dispatchQuitMessage(void);
 
protected:
    void update(void) override;
private:
    void updateDeltaTime(void);
 
#if defined(_WINDOWS)
public:
    static GX_CSTR CLASS_NAME;
    static constexpr u32 WINDOW_NAME_LENGTH = GxMath::VALUE_128;
    void getWindowName(GX_STR name);
    void setWindowName(GX_CSTR name);
    // style は WNDCLASSEXW.style を設定する。
    //   style = 0xffffffff の場合、標準的な組み合わせとして
    //   (CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS) が設定される
    b32 createWindow(const GxSize& size, b32 isFullScreen, GX_CSTR captionName = "", WORD iconResourceId = 0, GX_CSTR className = CLASS_NAME, UINT style = 0xffffffff);
    void storeWindowState(void);
    void restoreWindowState(void);
    GX_FORCE_INLINE HINSTANCE getInstance(void) const { return GetModuleHandle(nullptr); }
    constexpr HWND getHwnd(void) const { return _handleWindow; }
    constexpr HANDLE getCurrentProcess(void) const { return _handleProcess; }
    constexpr HWND getHwndParent(void) const { return _handleWindowParent; }
    constexpr HWND getHwndRoot(void) const { return (_handleWindowParent != nullptr) ? _handleWindowParent : _handleWindow; }
    HWND getHwndSelected(void) const;
    b32 setClientSize(const GxSize& size);
#if GX_DEVELOP
    constexpr HMENU getHmenu(void) const { return _handleMenu; }
    constexpr HWND getHwndToolbar(void) const { return _handleWindowToolbar; }
    constexpr GX_FORCE_INLINE PIMAGEHLP_SYMBOL getSymbolBuffer(void) const { return _pSymbolBuffer; }
    GxRect getToolAppWindowRect(void);
#endif //GX_DEVELOP
    GX_FORCE_INLINE const GxSize& getClientSize(void) const { return _clientSize; }
    void doEvents(void);
    GX_FORCE_INLINE b32 isActive(void) const { return _isActive; }
    GX_FORCE_INLINE const GxSize& getMaxClientSize(void) const { return _maxClientSize; }
    virtual void updateMaxClientSize(void);
    GX_FORCE_INLINE b32 isClipCursor(void) const { return _isClipCursor; }
    GX_FORCE_INLINE void setClipCursor(b32 enable) { _isClipCursor = enable; }
protected:
    virtual LRESULT wndProc(HWND handleWindow, UINT uMessage, WPARAM wParam, LPARAM lParam);
    virtual LRESULT wndProcFullScreen(HWND handleWindow, UINT uMessage, WPARAM wParam, LPARAM lParam);
    //  ウインドウメッセージはプリプロセッサの定義に関わらずワイド文字で処理していますので
    //  ...W 付の関数を使用してください。
    GX_FORCE_INLINE virtual LRESULT wndProcUser(HWND handleWindow, UINT uMessage, WPARAM wParam, LPARAM lParam, b32& inTextEdit)
    {
        if (inTextEdit)
        { // Text入力中の場合は inTextEdit に true が入ってくる(他のイベントを無視したい)
            // ここの DefWindowProcW() の戻り値を winProc の戻り値とします
            return DefWindowProcW(handleWindow, uMessage, wParam, lParam);
        }
        // OROCHI 標準の winProc に処理を渡したくない場合は inTextEdit に true を代入して返す
        // さらに DefWindowProcW() が呼ばれて欲しくない場合は独自の戻り値を返す
        return 0; // 戻り値は inTextEdit が true の場合のみ意味がある
    }
    static LRESULT CALLBACK wndProcInner(HWND handleWindow, UINT uMessage, WPARAM wParam, LPARAM lParam);
#elif defined(_XBOX_XS)
    b32 createWindow(HINSTANCE handleInstance, s32 nCmdShow);
    static LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
#endif //_XBOX_XS
 
public:
    constexpr u32 getBootArgumentCount(void) const { return _bootArgumentCount; }
    GX_CSTR getBootArgument(u32 index) const;
    s32 findBootArgumentIndex(GX_CSTR string) const;
    void analyzeBootCommandLine(s32 argc = 0, GX_CSTR argv[] = nullptr);
 
    void initializeBootConfig(GX_CSTR fname, void* pBootIniContents);
    b32 setBootConfigReadSection(GX_CSTR name);
    void getBootConfigValueString(GX_CSTR name, u32 index, GX_CSTR* pValue, GX_CSTR defaultValue);
    void getBootConfigValueU64(GX_CSTR name, u32 index, u64* pValue, u64 defaultValue);
    void getBootConfigValueS64(GX_CSTR name, u32 index, s64* pValue, s64 defaultValue);
    void getBootConfigValueF64(GX_CSTR name, u32 index, f64* pValue, f64 defaultValue);
    void getBootConfigValueB32(GX_CSTR name, u32 index, b32* pValue, b32 defaultValue);
    void getBootConfigValueByte(GX_CSTR name, u32 index, u64* pValue, u64 defaultValue);
    void getBootConfigValueSize(GX_CSTR name, u32 index, GxSize* pValue, const GxSize& defaultValue);
    void getBootConfigValueEnum(GX_CSTR name, u32 index, u32* pValue, const BootConfigEnumMap* pMapList);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GX_FORCE_INLINE b32 isInitialized(void) const { return _isInitialized; }
    constexpr u32 getWorkerStackSize(void) const { return _workerStackSize; }
    constexpr void setWorkerStackSize(u32 size){ _workerStackSize = size; }
 
    constexpr GxSequentialThreadManagerMain* getSequentialThreadManager(void) const { return _pSequentialThreadManager; }
    void setPlay(b32 flag, GxRtti* pStageRtti = nullptr);
    GX_FORCE_INLINE b32 isPlay(void) const { return (_playMode == PLAY_MODE::PLAY || _singleStepFlag); }
    GX_FORCE_INLINE b32 isStop(void) const { return (_playMode == PLAY_MODE::STOP) && !_singleStepFlag; }
    GX_FORCE_INLINE b32 isPause(void) const { return (_playMode == PLAY_MODE::PAUSE && !_singleStepFlag); }
    void setPause(b32 flag);
 
    GX_FORCE_INLINE b32 isSingleStep(void) const { return _singleStepFlag; }
    GX_FORCE_INLINE void setSingleStep(b32 singleStep){ _singleStepFlag = singleStep; }
 
    GX_FORCE_INLINE b32 isConstFrameRate(void) const { return _constFrameRateFlag; }
    GX_FORCE_INLINE void setConstFrameRate(b32 flag){ _constFrameRateFlag = flag; }
    constexpr f32 getDeltaTimeFactor(void) const { return _deltaTimeFactor; }
    constexpr void setDeltaTimeFactor(f32 deltaTimeFactor){ _deltaTimeFactor = deltaTimeFactor; }
    constexpr f32 getDeltaTime(void) const { return _deltaTime; }
    constexpr void setDeltaTime(f32 deltaTime){ _deltaTime = deltaTime; }
    constexpr f32 getDeltaTimeRatio(void)   const { return _deltaTimeRatio; }
    constexpr void setDeltaTimeRatio(f32 deltaTimeRatio){ _deltaTimeRatio = deltaTimeRatio; }
    constexpr f32    getVariableFrameLowerLimit(void) const { return _variableFrameLowerLimit; }
    constexpr void setVariableFrameLowerLimit(f32 lowerLimit){ _variableFrameLowerLimit = lowerLimit; }
 
#if GX_ASSERT_ENABLE
    constexpr GX_ASSERT_MODE getAssertMode(void) const { return _assertMode; }
    constexpr void setAssertMode(GX_ASSERT_MODE mode) { _assertMode = mode; }
#endif  // GX_ASSERT_ENABLE
    
#if defined(_PS4) || defined(_PS5)
    GX_FORCE_INLINE b32 isFixMainThreadCpuIndex(void) const { return _isFixMainThreadCpuIndex; }
#endif //_PS4 || _PS5
#if defined(_PS4) || defined(_PS5) || defined(_NX64)
    GX_FORCE_INLINE const GxNativeUserId& getUserId(void) const { return _userId; }
#endif // _PS4 || _PS5 || _NX64
#if defined(_XBOX_XS)
    GX_FORCE_INLINE XGameSaveProviderHandle getProviderHandle(void) const { return _pProviderHandle; }
#endif // _XBOX_XS
 
#if GX_DEVELOP
    constexpr u32 getXmlReadSize(void){ return _xmlReadSize; }
    GX_FORCE_INLINE b32 isDeserializeSafety(void){ return _deserializeSafety; }
    GX_FORCE_INLINE b32 isUseCoreProfile(void){ return _useCoreProfile; }
    GX_FORCE_INLINE void setUseCoreProfile(b32 useProfile){ _useCoreProfile = useProfile; }
#endif //GX_DEVELOP
#if GX_USE_UNIT_PROFILE
    GX_FORCE_INLINE b32 getUseUnitProfile(void){ return _useUnitProfile; }
#endif //GX_USE_UNIT_PROFILE
 
 
#if defined(_PS4) || defined(_PS5) || defined(_XBOX_XS)
    GX_FORCE_INLINE u32 getSaveDataSize(void) const { return _saveDataSize; }
#if defined(_PS4) || defined(_PS5)
    GX_FORCE_INLINE b32 isCopySaveDataIcon(void) const { return _isCopySaveDataIcon; }
#endif // _PS4 || _PS5
#endif // _PS4 || _PS5 || _XBOX_XS
 
#if defined(_PS4) || defined(_PS5)
protected:
    void setMainThreadCpuIndex( s32 cpuIndex );
#endif // _PS4 || _PS5
 
public:
    GX_FORCE_INLINE void setSystemFlag(u32 flag, b32 enable = true){ GxFlag32Array::setFlag( &_systemFlag[0], flag, enable ); }
    GX_FORCE_INLINE b32 isOnSystemFlag(u32 flagIndex) const { return GxFlag32Array::isFlag(&_systemFlag[0], flagIndex); }
#if GX_DEVELOP
    GX_FORCE_INLINE void setDevelopFlag(u32 flag, b32 enable = true){ GxFlag32Array::setFlag( &_developFlag[0], flag, enable); }
    GX_FORCE_INLINE b32 isOnDevelopFlag(u32 flagIndex) const { return GxFlag32Array::isFlag(&_developFlag[0], flagIndex); }
    GX_FORCE_INLINE u32* getSystemFlagAddress(void){ return( &_systemFlag[0] );  }
    constexpr u32 getSystemFlagSize(void) const { return( sizeof(_systemFlag) ); }
 
    constexpr GxMainInitialInformation* getMainInitialInformation( void ) { return _pMainInitialInformation; }
#endif //GX_DEVELOP
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
protected:
    GxRenderDevice*         _pRenderDevice;         
    GxSysRenderBase*        _pRender;               
    GxSysShader*            _pShader;               
    GxSysFilterBase*        _pFilter;               
    GxSysResource*          _pResource;             
    GxSysPrimitive*         _pPrimitive;            
    GxSysFile*              _pFile;                 
    GxSysUnit*              _pUnit;                 
    GxSysStage*             _pStage;                
    GxSysInput*             _pInput;                
    GxSysLightBase*         _pLight;                
    GxSysEnvironment*       _pEnvironment;          
    GxSysGpgpu*             _pGpgpu;                
    GxSysCollisionBase*     _pCollision;            
    GxSysDynamicsBase*      _pDynamics;             
    GxSysP2PBase*           _pP2P;                  
    GxSysFontBmpBase*       _pFontBmp;              
    GxSysFont*              _pFont;                 
#if GX_DEVELOP
    GxSysTool*              _pTool;                 
    GxSysDebugCommunication*    _pDebugCommunication;   
    GxProfiler*             _pProfiler;             
    GxSysThread*            _pThread;               
#endif //GX_DEVELOP
    GxSysEffectBase*        _pEffect;               
    GxSysSoundBase*         _pSound;                
    GxSysMovieBase*         _pMovie;                
    GxSysNetworkBase*       _pNetwork;              
private:
    b32                     _isInitialized;         
    b32                     _enable;                
    EXIT_CODE               _exitCode;              
    u32                     _workerStackSize;       
    GxSequentialThreadManagerMain* _pSequentialThreadManager;   
    PLAY_MODE               _playMode;              
    b32                     _singleStepFlag;        
    b32                     _constFrameRateFlag;    
    f32                     _deltaTimeFactor;       
    f32                     _deltaTime;             
    f32                     _deltaTimeRatio;        
    f32                     _variableFrameLowerLimit; 
 
#if GX_DEVELOP
    GxMainInitialInformation* _pMainInitialInformation; 
#endif //GX_DEVELOP
    
#if defined(_WINDOWS)
    HWND                    _handleWindow;          
    HWND                    _handleWindowParent;    
    HANDLE                  _handleProcess;         
#if GX_DEVELOP
    PIMAGEHLP_SYMBOL        _pSymbolBuffer;         
    HMENU                   _handleMenu;            
    GxPropertyTable         _propertyTableMenubar;  
    GxPropertyTable         _propertyTableToolbar;  
    HWND                    _handleWindowToolbar;   
    HWND                    _handleWindowToolbarTip;
    GxArray*                _pIconResourceList;     
#endif //GX_DEVELOP
    GxSize                  _clientSize;            
    GX_WCHAR                _className[128];        
    u32                     _storedWindowStyle;     
    WINDOWPLACEMENT         _storedWindowPlacement; 
    b32                     _isFullScreen;          
    b32                     _isActive;              
    GxSize                  _maxClientSize;         
    b32                     _isClipCursor;          
#elif defined(_XBOX_XS)
    HANDLE                  _handleSuspendComplete; 
    HANDLE                  _handleSignalResume;    
#endif //_XBOX_XS
 
    // 各種フラグ
    u32                     _systemFlag[ SYSTEM_FLAG_NUM ];         
#if GX_DEVELOP
    u32                     _developFlag[ DEVELOP_FLAG_NUM ];       
    u32                     _xmlReadSize;                           
    b32                     _deserializeSafety;                     
    b32                     _useCoreProfile;                        
#endif //GX_DEVELOP
 
    GX_CHAR                 _bootCommandLine[ BOOT_COMMAND_LINE_MAX ];  
    GX_CSTR                 _bootArgumentPointerArray[ BOOT_COMMAND_LINE_ARGUMENT_MAX ];    
    u32                     _bootArgumentCount;                     
    void*                   _pBootConfigBinary;                     
    GX_HANDLE               _currentSectionBootConfig;              
 
#if GX_USE_UNIT_PROFILE
    b32                     _useUnitProfile;                        
#endif //GX_USE_UNIT_PROFILE
    b32                     _useSequentialThreadManagerPrecede;     
 
#if GX_ASSERT_ENABLE
    GX_ASSERT_MODE          _assertMode;                
#endif  // GX_ASSERT_ENABLE
 
#if defined(_PS4) || defined(_PS5) || defined(_XBOX_XS)
    u32                     _saveDataSize;              
#if defined(_PS4) || defined(_PS5)
    b32                     _isCopySaveDataIcon;        
#endif // _PS4 || _PS5
#endif // _PS4 || _PS5 || _XBOX_XS
 
#if defined(_PS4) || defined(_PS5)
    b32                     _isFixMainThreadCpuIndex;   
#endif //_PS4 || _PS5
#if defined(_PS4) || defined(_PS5) || defined(_NX64)
    GxNativeUserId          _userId;                    
#endif //_PS4 || _PS5 || _NX64
#if defined(_NX64) || defined(_XBOX_XS)
    GxNativeUserHandle      _userHandle;                
#endif //_NX64 || _XBOX_XS
#if defined(_XBOX_XS)
    GxNativeProviderHandle  _pProviderHandle;           
    GxNativeTaskQueueHandle _pTaskQueue;                
#endif // _XBOX_XS
 
#if GX_OCTREE_INFO
public:
    static u32  _numCriticalSectionAll;                 
    static u32  _numCriticalSectionFrustumCulling;      
#endif // GX_OCTREE_INFO
 
};
 
//===========================================================================
//===========================================================================
class GxSysMain::GxSequentialThreadManagerMain : public GxSequentialThreadManager
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GX_RTTI_CLASS(GxSysMain::GxSequentialThreadManagerMain, GxSequentialThreadManager)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxSequentialThreadManagerMain)
 
    
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GxSequentialThreadManagerMain(void){}
    GxSequentialThreadManagerMain(b32 useMainThreadFlag) : GxSequentialThreadManager(useMainThreadFlag){}
protected:
    void initializeThreadLocalStorage(void) override;
 
};
 
//===========================================================================
//===========================================================================
class GxSysMain::GxSequentialThreadManagerMainPrecede : public GxSequentialThreadManagerMain
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GX_RTTI_CLASS(GxSysMain::GxSequentialThreadManagerMainPrecede, GxSequentialThreadManagerMain)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxSequentialThreadManagerMainPrecede)
 
    
    enum class PRECEDE_STATE
    {
        NONE,           
        BEGIN,          
        WAIT_COMPLETE,  
    };
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GxSequentialThreadManagerMainPrecede(void)
        : _isEnablePrecedeStartJob( false )
        , _precedeState( PRECEDE_STATE::NONE )
        , _numJobDiffOfPrecedingStart( 5 )
        , _numJobDiffOfPrecedingWait( 10 )
    {}
    GxSequentialThreadManagerMainPrecede(b32 useMainThreadFlag)
        : GxSequentialThreadManagerMain(useMainThreadFlag)
        , _isEnablePrecedeStartJob( false )
        , _precedeState( PRECEDE_STATE::NONE )
        , _numJobDiffOfPrecedingStart( 5 )
        , _numJobDiffOfPrecedingWait( 10 )
    {}
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GX_FORCE_INLINE virtual b32 isEnablePrecedeStartJob(void) const       { return _isEnablePrecedeStartJob; }
    GX_FORCE_INLINE virtual void setEnablePrecedeStartJob( b32 enable )   { _isEnablePrecedeStartJob = enable; }
    GX_FORCE_INLINE virtual s32 getNumJobDiffOfPrecedingStart(void) const { return _numJobDiffOfPrecedingStart; }
    GX_FORCE_INLINE virtual void setNumJobDiffOfPrecedingStart( s32 num ) { _numJobDiffOfPrecedingStart = num; }
    GX_FORCE_INLINE virtual s32 getNumJobDiffOfPrecedingWait(void) const  { return _numJobDiffOfPrecedingWait; }
    GX_FORCE_INLINE virtual void setNumJobDiffOfPrecedingWait( s32 num )  { _numJobDiffOfPrecedingWait = num; }
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    s32 addJob(GxClassBaseRoot* pObject, GX_OBJECT_FUNCTION pFunction) override;
    s32 addJob(GxClassBaseRoot* pObject, GX_OBJECT_FUNCTION_PARAM pFunction, u32 argument, ARGUMENT_TYPE argumentType = ARGUMENT_TYPE::U32) override;
    s32 addJob(GxClassBaseRoot* pObject, GX_OBJECT_FUNCTION_POINTER pFunction, void* pArgument) override;
    void startJob(void) override;
 
protected:
    void executeJob(GxThread* pThread) override;
    void startWorkerThreadAll(void) override;
    GX_FORCE_INLINE b32 isComplete(void) override;
 
    virtual void precedeStartJob(void);
    GX_FORCE_INLINE virtual b32 isPrecedingStartJob(void) const { return _precedeState != PRECEDE_STATE::NONE; }
    GX_FORCE_INLINE virtual b32 isPrecedeStateBegin(void) const { return _precedeState == PRECEDE_STATE::BEGIN; }
    GX_FORCE_INLINE virtual b32 isWaitingCompleteInStartJob(void) const { return _precedeState == PRECEDE_STATE::WAIT_COMPLETE; }
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
private:
    b32 _isEnablePrecedeStartJob;               
    PRECEDE_STATE _precedeState;                
    s32 _numJobDiffOfPrecedingStart;            
    s32 _numJobDiffOfPrecedingWait;             
 
};
 
//===========================================================================
//===========================================================================
#define GX_BOOTCONFIG_CURRENT_SECTION(_section) getGxSysMain()->setBootConfigReadSection(_section)
 
#define GX_BOOTCONFIG_STRING(_Type, _Name, _Index, _Value) { \
    GX_CSTR strVal_BCFG_, strDefaultVal_BCFG_ = (GX_CSTR) _Value; \
    getGxSysMain()->getBootConfigValueString(_Name, _Index, &strVal_BCFG_, strDefaultVal_BCFG_); \
    _Value = (_Type) strVal_BCFG_; }
 
#define GX_BOOTCONFIG_UINT(_Type, _Name, _Index, _Value) { \
    u64 uiVal_BCFG_, uiDefaultVal_BCFG_ = (u64) _Value; \
    getGxSysMain()->getBootConfigValueU64(_Name, _Index, &uiVal_BCFG_, uiDefaultVal_BCFG_); \
    _Value = (_Type) uiVal_BCFG_; }
 
#define GX_BOOTCONFIG_INT(_Type, _Name, _Index, _Value) { \
    s64 iVal_BCFG_, iDefaultVal_BCFG_ = (s64) _Value; \
    getGxSysMain()->getBootConfigValueS64(_Name, _Index, &iVal_BCFG_, iDefaultVal_BCFG_); \
    _Value = (_Type) iVal_BCFG_; }
 
#define GX_BOOTCONFIG_FLOAT(_Type, _Name, _Index, _Value) { \
    f64 fVal_BCFG_, fDefaultVal_BCFG_ = (f64) _Value; \
    getGxSysMain()->getBootConfigValueF64(_Name, _Index, &fVal_BCFG_, fDefaultVal_BCFG_); \
    _Value = (_Type) fVal_BCFG_; }
 
#define GX_BOOTCONFIG_BOOL(_Type, _Name, _Index, _Value) { \
    b32 boolVal_BCFG_, boolDefaultVal_BCFG_ = (b32) _Value; \
    getGxSysMain()->getBootConfigValueB32(_Name, _Index, &boolVal_BCFG_, boolDefaultVal_BCFG_); \
    _Value = (_Type) boolVal_BCFG_; }
 
#define GX_BOOTCONFIG_BYTE(_Type, _Name, _Index, _Value) { \
    u64 uiVal_BCFG_, uiDefaultVal_BCFG_ = (u64) _Value; \
    getGxSysMain()->getBootConfigValueByte(_Name, _Index, &uiVal_BCFG_, uiDefaultVal_BCFG_); \
    _Value = (_Type) uiVal_BCFG_; }
 
#define GX_BOOTCONFIG_SIZE(_Type, _Name, _Index, _Value) { \
    GxSize sizeVal_BCFG_, sizeDefaultVal_BCFG_ = _Value; \
    getGxSysMain()->getBootConfigValueSize(_Name, _Index, &sizeVal_BCFG_, sizeDefaultVal_BCFG_); \
    _Value = sizeVal_BCFG_; }
 
#define GX_BOOTCONFIG_ENUM(_Type, _Name, _Index, _Value, _enumMap) { \
    u32 enumVal_BCFG_, enumDefaultVal_BCFG_ = _Value; \
    _enumMap[(sizeof(_enumMap)/sizeof(GxSysMain::BootConfigEnumMap))-1]._value = enumDefaultVal_BCFG_; \
    getGxSysMain()->getBootConfigValueEnum(_Name, _Index, &enumVal_BCFG_, _enumMap); \
    _Value = (_Type) enumVal_BCFG_; }
 
#define GX_BOOTCONFIG_STRUCT_STRING(_Type, _StructBase, _NameValue) GX_BOOTCONFIG_STRING(_Type, #_NameValue, 0, _StructBase._NameValue)
#define GX_BOOTCONFIG_STRUCT_UINT(_Type, _StructBase, _NameValue) GX_BOOTCONFIG_UINT(_Type, #_NameValue, 0, _StructBase._NameValue)
#define GX_BOOTCONFIG_STRUCT_INT(_Type, _StructBase, _NameValue) GX_BOOTCONFIG_INT(_Type, #_NameValue, 0, _StructBase._NameValue)
#define GX_BOOTCONFIG_STRUCT_FLOAT(_Type, _StructBase, _NameValue) GX_BOOTCONFIG_FLOAT(_Type, #_NameValue, 0, _StructBase._NameValue)
#define GX_BOOTCONFIG_STRUCT_BOOL(_Type, _StructBase, _NameValue) GX_BOOTCONFIG_BOOL(_Type, #_NameValue, 0, _StructBase._NameValue)
#define GX_BOOTCONFIG_STRUCT_BYTE(_Type, _StructBase, _NameValue) GX_BOOTCONFIG_BYTE(_Type, #_NameValue, 0, _StructBase._NameValue)
#define GX_BOOTCONFIG_STRUCT_SIZE(_Type, _StructBase, _NameValue) GX_BOOTCONFIG_SIZE(_Type, #_NameValue, 0, _StructBase._NameValue)
#define GX_BOOTCONFIG_STRUCT_ENUM(_Type, _StructBase, _NameValue, _enumMap) GX_BOOTCONFIG_ENUM(_Type, #_NameValue, 0, _StructBase._NameValue, _enumMap)
 
// アクセスインターフェース
GX_FORCE_INLINE GxSysMain* getGxSysMain(void){ return GxSysMain::getSingletonPointer(); }
 
GX_CORE_NAMESPACE_END()