GxRenderDevice.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
// 定数バッファを共有する。Windows のみ動作確認済み
#define GX_ENABLE_DX11_SHARED_CONSTANTBUFFER    0
 
GX_CORE_NAMESPACE_BEGIN()
 
class GxSysRenderBase;
class GxRenderContext;
class GxRenderVertexBuffer;
class GxRenderIndexBuffer;
class GxRenderVertexDeclaration;
class GxRenderVertexShader;
class GxRenderPixelShader;
class GxResShaderVertex;
class GxResShaderPixel;
class GxRenderTexture;
struct GxRenderVertexElement;
class GxRenderQuery;
class GxUnitCameraBase;
 
//===========================================================================
//===========================================================================
typedef u32 (*GX_RENDERDEVICE_ERROR_FUNCTION)(GX_CSTR message, u32 returnValue, u32 errorId, u32 value);
 
//===========================================================================
//===========================================================================
class GxRenderDeviceInitialInformation : public GxClassBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS(GxRenderDeviceInitialInformation, GxClassBase)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxRenderDeviceInitialInformation)
 
    
    //-------------------------------------------------------------
    //-------------------------------------------------------------
#if GX_ENABLE_NEO
    class GxRenderDeviceNeoInitialInformation : public GxClassBase
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
public:
        // RTTI定義
        GX_RTTI_ABSTRACT_CLASS(GxRenderDeviceNeoInitialInformation, GxClassBase)
        // GxClassBase継承クラス用禁止宣言
        GX_PROHIBIT_CLASS_BASE(GxRenderDeviceNeoInitialInformation)
 
        
        //-------------------------------------------------------------
        //-------------------------------------------------------------
 
        GxRenderDeviceNeoInitialInformation(void) : _neoRenderMode(GX_NEO_RENDER_MODE::NONE){}
 
        //-------------------------------------------------------------
        //-------------------------------------------------------------
 
        GX_FORCE_INLINE void loadJson(const GxJson::GxJsonNode& jsonNode)
        {
            _neoRenderMode = static_cast<GX_NEO_RENDER_MODE>(jsonNode.getS32("_neoRenderMode", static_cast<s32>(_neoRenderMode)));
        }
 
        //-------------------------------------------------------------
        //-------------------------------------------------------------
 
        GX_NEO_RENDER_MODE      _neoRenderMode; 
 
    };
#endif  // GX_ENABLE_NEO
 
    struct GxRawAllocatorInfo
    {
        //-------------------------------------------------------------
        //-------------------------------------------------------------
 
        GxRawAllocatorInfo(u64 size, u32 blockCount)
            : _size(size)
            , _maxBlockCount(blockCount)
        {}
 
        //-------------------------------------------------------------
        //-------------------------------------------------------------
 
        constexpr void setSize(u64 size, u32 maxBlockCount)
        {
            _size = size;
            _maxBlockCount = maxBlockCount;
        }
 
        //-------------------------------------------------------------
        //-------------------------------------------------------------
 
        u64     _size;              
        u32     _maxBlockCount;     
 
    };
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GxRenderDeviceInitialInformation(void);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    void loadJson(const GxJson::GxJsonNode& jsonNode);
 
#if GX_DEVELOP
    static GxGuiBase* createGui(GxProperty& property, GxTypedObject* pOwner, const GxRtti& rtti, u32 index);
#endif // GX_DEVELOP
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    RENDER_FRAME_RATE       _frameRateTarget;                   
    u32                     _bufferCount;                       
    u32                     _commandBufferSize;                 
    u32                     _renderThreadStackSize;             
    b32                     _disableShadowPass;                 
    b32                     _disableOverPaintPass;              
    b32                     _disableProcedualPass;              
    b32                     _useDummyShader;                    
    b32                     _useBackBufferDepth;                
    b32                     _isNormalMap16FP;                   
    b32                     _enablePreZSortByDepth;             
    GxVector2               _resolutionScaleTextureSSAO;        
    GX_RENDERDEVICE_ERROR_FUNCTION  _pUserErrorFunction;        
    u32                     _maxSkinningJointCount;             //<! スキニングで使用できるジョイントの最大数
#if GX_DEVELOP
    b32                     _enableWarningShaderCompile;        
#endif // GX_DEVELOP
#if defined(_WINDOWS) || defined(_PS4) || defined(_PS5) || defined(_XBOX_XS)
    u32                     _useTexcoordCount;                  
    GxSize                  _backBufferResolution;              
#if GX_DEVELOP
    b32                     _disableSrgbTextureDevelop;         
#endif // GX_DEVELOP
#endif //_WINDOWS || _PS4 || _PS5 || _XBOX_XS
#if defined(_PS4) || defined(_PS5) || defined(_NX64)
    u64                     _mainMemorySize;                    
    u64                     _localMemorySize;                   
#endif //_PS4 || _PS5 || _NX64
#if defined(_PS4) || defined(_PS5)
    b32                     _useDefaultPoolForRenderResources;  
 
    u32                     _useMemArenaSize;                   
    u32                     _useMemArenaElementsCount;          
    u32                     _useMemArenaPoolElementSize;        
    f32                     _useMemArenaPoolElementsAssign;     
#if GX_ENABLE_LCUE
    u32                     _useCommandBufferAdditionalResourceBufferSize;  
#else   // GX_ENABLE_LCUE
    u32                     _useCommandBufferAdditionalCueHeapSize;         
#endif  // !GX_ENABLE_LCUE
 
#if GX_ENABLE_NEO
    GxRenderDeviceNeoInitialInformation _neoInitialInformation; 
#endif  // GX_ENABLE_NEO
    b32                     _enableHDRMonitor;                  
#endif // _PS4 || _PS5
#if GX_USE_DX11 || GX_USE_DX12
    b32                     _enableContextFlush;                
    u32                     _useShaderModel;                    
#endif //GX_USE_DX11 || GX_USE_DX12
#if GX_USE_DX12
    b32                     _enableRenderDeviceDebugLayer;      
#endif //GX_USE_DX12
#if defined(_WINDOWS)
    b32                     _isFullScreen;                      
    b32                     _isFullScreenReady;                 
    u32                     _fullScreenScalingMode;             
    b32                     _enableWindowResizeCheck;           
    GxSize                  _fullScreenResolution;              
    b32                     _useDefaultPoolForRenderResources;  
    u32                     _useDisplayDeviceIndex;             
    u32                     _useDxFeatureLevel;                 
    b32                     _useAltEnterKeyFullScreen;          
    b32                     _usePrintScreenKey;                 
#elif defined(_NX64)
    GxSize                  _maxBackBufferResolution;           
    GxSize                  _defaultBackBufferResolution;       
    u32                     _graphicsMemorySize;                
    u32                     _firmwareMemorySize;                
    s32                     _deviceFlags;                       
    u32                     _texturePoolCount;                  
    u32                     _samplerPoolCount;                  
    u32                     _nativeCommandBufferSize;           
    u32                     _controlBufferSize;                 
    u32                     _uniformBlockBufferSize;            
    u32                     _gpuFrameworkType;                  
    u32                     _shaderScratchMemorySize;           
    GxRawAllocatorInfo      _shaderPoolAllocator;               
    GxRawAllocatorInfo      _commonPoolAllocator;               
#elif defined(_PS5)
    u32                     _constBufferSize;                   
#endif //_PS5
 
};
 
#if GX_USE_DX11
//===========================================================================
//===========================================================================
template<class STATE, class DESC>
struct GxD3D11CreateStateFunction
{
    typedef HRESULT (STDMETHODCALLTYPE ID3D11Device::*type)(const DESC*, STATE**);
};
 
//===========================================================================
//===========================================================================
template<class STATE, class DESC, typename GxD3D11CreateStateFunction<STATE,DESC>::type CREATE_STATE>
class GxD3D11StateTable
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
private:
    struct GxD3D11StateEntry
    {
        u32     _hash;      
        DESC    _desc;      
        STATE*  _pState;    
    };
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GxD3D11StateTable(void);
 
    void terminate(void);
 
    ~GxD3D11StateTable(void) {};
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    STATE* get(const DESC& desc);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
private:
    GxArray _table;     
 
};
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
template<class STATE, class DESC, typename GxD3D11CreateStateFunction<STATE,DESC>::type CREATE_STATE>
GxD3D11StateTable<STATE, DESC, CREATE_STATE>::GxD3D11StateTable(void)
{
}
 
//---------------------------------------------------------------------------
// デストラクタ
//---------------------------------------------------------------------------
template<class STATE, class DESC, typename GxD3D11CreateStateFunction<STATE,DESC>::type CREATE_STATE>
void GxD3D11StateTable<STATE, DESC, CREATE_STATE>::terminate(void)
{
    for(u32 i = 0; i < _table.getCount(); i++)
    {
        auto* pEntry = static_cast<GxD3D11StateEntry*>(_table[i]);
        DIRECTX_SAFE_RELEASE(pEntry->_pState);
        GX_SAFE_FREE_MEMORY(pEntry);
    }
}
 
#if !defined(_PS4)
//---------------------------------------------------------------------------
// ステート記述からステートオブジェクトを取得
//---------------------------------------------------------------------------
template<class STATE, class DESC, typename GxD3D11CreateStateFunction<STATE,DESC>::type CREATE_STATE>
STATE* GxD3D11StateTable<STATE, DESC, CREATE_STATE>::get(const DESC& desc)
{
    const u32 hash = GxMath::getHash32(const_cast<DESC*>(&desc), sizeof(DESC*));
 
    for(u32 i = 0; i < _table.getCount(); i++)
    {
        auto* pEntry = static_cast<GxD3D11StateEntry*>(_table[i]);
        if( (pEntry->_hash == hash) && (GX_MEMCMP(&pEntry->_desc, &desc, sizeof(desc)) == 0) )
        {
            return pEntry->_pState;
        }
    }
 
    auto* pEntry = static_cast<GxD3D11StateEntry*>(GX_ALLOCATE_MEMORY(getGxAllocatorList(GxAllocatorList::ALLOCATOR_TYPE::RENDER), sizeof(GxD3D11StateEntry)));
    {
        pEntry->_hash = hash;
        pEntry->_desc = desc;
        (getGxRenderDevice()->getDevice()->*CREATE_STATE)(&pEntry->_desc, &pEntry->_pState);
    }
    _table.addBottom(pEntry);
    return pEntry->_pState;
}
#endif 
 
//---------------------------------------------------------------------------
// 各種ステートテーブルのtypedef
//---------------------------------------------------------------------------
using GxD3D11SamplerStateTable = GxD3D11StateTable<ID3D11SamplerState, D3D11_SAMPLER_DESC, &ID3D11Device::CreateSamplerState>;
using GxD3D11RasterizerStateTable = GxD3D11StateTable<ID3D11RasterizerState, D3D11_RASTERIZER_DESC, &ID3D11Device::CreateRasterizerState>;
using GxD3D11DepthStencilStateTable = GxD3D11StateTable<ID3D11DepthStencilState, D3D11_DEPTH_STENCIL_DESC, &ID3D11Device::CreateDepthStencilState>;
using GxD3D11BlendStateTable = GxD3D11StateTable<ID3D11BlendState, D3D11_BLEND_DESC, &ID3D11Device::CreateBlendState>;
 
//===========================================================================
//===========================================================================
class GxRenderShaderConstantPool : public GxClassBase
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS(GxRenderShaderConstantPool, GxClassBase)
    // new, delete定義
    GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::RENDER)
 
    
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GxRenderShaderConstantPool( void );
 
    ~GxRenderShaderConstantPool( void ) override {};
 
    b32     initialize( u32 initalItemNum );
 
    void    terminate(void);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    ID3D11Buffer*   allocateSharedBuffer(u32 bufferSize);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
private:
    ID3D11Buffer** _ppBuffer;   
    u32 _size;                  
    u32 _maxSize;               
 
};
#endif  // GX_USE_DX11
 
//===========================================================================
//===========================================================================
class GxRenderDevice : public GxClassBase, public SingletonBase<GxRenderDevice>
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GX_RTTI_ABSTRACT_CLASS(GxRenderDevice, GxClassBase)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxRenderDevice)
    // new, delete定義
    GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::RENDER)
 
    friend class GxSysRenderBase;
    friend class GxRenderContext;
    friend class GxRenderNotifier;
    friend class GxRenderNotifierForOnRender;
    friend class GxRenderResource;
    friend class GxRenderTexture;
    friend class GxRenderVertexDeclaration;
    class GxVramAllocator;
    class GxRawAllocator;
 
protected:
    class GxRenderThread;
private:
    class GxRenderResourceRegister;
 
public:
    struct GxVertexStream
    {
        union 
        {
            struct
            {
                GxRenderVertexBuffer*   _pVertexBuffer;     
                u16                     _offset;            
                u8                      _stride;            
                u8                      _frequencyType;     
            };
            u64     _access64;                              
        };
    };
 
protected:
 
    class GxPriority
    {
    public:
        using priorityType = u64;
        static constexpr GxPriority::priorityType priorityValueMax = U64_MAX;
 
        union GxPriorityUnion
        {
            struct
            {
#if GX_BITFIELD_LITTLEENDIAN
                u32             _subPriority:20;    
                RENDER_PASS     _pass:8;            
                RENDER_SUB_VIEW _subView:4;         
                RENDER_VIEW     _view:4;            
                u32             _reserved:28;       
#else //GX_BITFIELD_LITTLEENDIAN
                u32             _reserved:28;       
                RENDER_VIEW     _view:4;            
                RENDER_SUB_VIEW _subView:4;         
                RENDER_PASS     _pass:8;            
                u32             _subPriority:20;    
#endif // !GX_BITFIELD_LITTLEENDIAN
            };
            priorityType        _priorityValue;     
        };
    };
 
    enum class COMMAND_TYPE
    {
        SET_RENDER_STATE,               
        SET_DEPTH_TEST_STATE,           
        SET_STENCIL_TEST_STATE,         
        SET_ALPHA_TEST_STATE,           
        SET_BLEND_STATE,                
        SET_VIEWPORT,                   
        SET_SCISSOR_RECT,               
        SET_RENDER_TARGET,              
        SET_DEPTH_STENCIL,              
        FORCE_DRAW_STATE,               
        DRAW,                           
        DRAW_INDEXED,                   
        DRAW_MEMORY,                    
        DRAW_INDEXED_MEMORY,            
#if GX_ENABLE_COMPUTE_SHADER
        DISPATCH,                       
#endif //GX_ENABLE_COMPUTE_SHADER
#if GX_ENABLE_OCCLUSION_CULLING
        RESOLVE_OCCLUSION_QUERY,        
#endif //GX_ENABLE_OCCLUSION_CULLING
        CLEAR,                          
        CLEAR_HDR,                      
        COPY_RENDER_TARGET_TO_TEXTURE,  
        COPY_DEPTH_STENCIL_TO_TEXTURE,  
        COPY_RENDER_TARGET_TO_TEXTURE_STRETCH,      
        COPY_DEPTH_STENCIL_TO_TEXTURE_STRETCH,      
        COPY_RENDER_TARGET_TO_TEXTURE_WITH_MIPMAP,  
#if GX_ENABLE_HTILE_STENCIL_MASK
        MASK_HTILE_STENCIL_REGION,      
#endif // GX_ENABLE_HTILE_STENCIL_MASK
#if defined(_NX64)
        SET_TILED_CACHE_ACTION,         
        SET_TILED_CACHE_TILE_SIZE,      
        SAVE_ZCULL_DATA,                
        RESTORE_ZCULL_DATA,             
        RESERVE4,                       
#else //_NX64
        RESERVE0,                       
        RESERVE1,                       
        RESERVE2,                       
        RESERVE3,                       
        RESERVE4,                       
#endif // !_NX64
#if GX_DEVELOP
        BEGIN_MARKER,                   
        END_MARKER,                     
#else //GX_DEVELOP
        RESERVE5,                       
        RESERVE6,                       
#endif  // !GX_DEVELOP
        CALLBACK_,                      
        CALLBACK_COPYARG,               
        SET_PREDICATION,                
        FLUSH_GPU_COMMAND_BUFFER,       
        MAX,                            
    };
 
    struct GxViewportData
    {
        GxRect  _rect;      
        f32     _nearZ;     
        f32     _farZ;      
    };
 
public: // GxSysRenderから読みたいので仮でpublic
    struct GxCaps
    {
        enum class GPU_TYPE
        {
            UNKNOWN,    
            GEFORCE,    
            RADEON,     
        };
 
        GPU_TYPE    _gpuType;           
        b32         _hardwarePcf;       
        b32         _alphaToCoverage;   
    };
 
protected:
#if GX_USE_DX11
    struct GxD3D11State
    {
        ID3D11InputLayout*  _pInputLayout;  
 
        struct
        {
            ID3D11Buffer*   _pVertexBuffers[RENDER_VERTEX_STREAM_COUNT_MAX];    
            UINT            _strides[RENDER_VERTEX_STREAM_COUNT_MAX];           
            UINT            _offsets[RENDER_VERTEX_STREAM_COUNT_MAX];           
        } _vertexBuffers;
        b32 _isVertexBuffersDirty;  
 
        struct
        {
            ID3D11Buffer*   _pIndexBuffer;  
            DXGI_FORMAT     _format;        
            UINT            _offset;        
        } _indexBuffer;
        b32 _isIndexBufferDirty;            
 
        D3D11_PRIMITIVE_TOPOLOGY    _primitiveTopology;         
        D3D11_RASTERIZER_DESC       _rasterizerState;           
        b32                         _rasterizerStateDirty;      
 
        ID3D11ShaderResourceView*   _pShaderResources[static_cast<u32>(RENDER_SHADER::MAX)][RENDER_TEXTURE_SAMPLER_COUNT_MAX];  
        b32                         _shaderResourcesDirty[static_cast<u32>(RENDER_SHADER::MAX)];                                
        ID3D11UnorderedAccessView*  _pUnorderedAccess[static_cast<u32>(RENDER_SHADER::MAX)][RENDER_TEXTURE_SAMPLER_COUNT_MAX];  
        b32                         _unorderedAccessDirty[static_cast<u32>(RENDER_SHADER::MAX)];                                
        ID3D11SamplerState*         _pSamplers[static_cast<u32>(RENDER_SHADER::MAX)][D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT];    
        b32                         _samplersDirty[static_cast<u32>(RENDER_SHADER::MAX)];                                       
        ID3D11Buffer*               _pConstantBuffers[static_cast<u32>(RENDER_SHADER::MAX)][D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT]; 
        b32                         _constantBuffersDirty[static_cast<u32>(RENDER_SHADER::MAX)];                                
 
        struct
        {
            D3D11_BLEND_DESC    _blendState;        
            FLOAT               _blendFactor[4];    
            UINT                _sampleMask;        
        } _blendState;
        b32 _blendStateDirty;                       
 
        struct
        {
            D3D11_DEPTH_STENCIL_DESC    _depthStencilState;     
            UINT                        _stencilReference;      
            BOOL                        _stencilTwoSideEnable;  
        } _depthStencilState;
        b32 _depthStencilStateDirty;                            
 
        struct
        {
            ID3D11RenderTargetView* _pRenderTargetViews[RENDER_TARGET_COUNT_MAX];   
            ID3D11DepthStencilView* _pDepthStencilView;                             
        } _renderTargets;
        b32 _renderTargetsDirty;                                                    
    };
#endif  // GX_USE_DX11
 
    struct GxCommandInformation;
    struct GxPacket;
    struct GxDrawCommandCommonInformation;
    struct GxRegisterInformation;
    struct GxRegisterSet;
#if GX_USE_OPENGL
    struct GxRegisterBlockInformation
    {
        void*       _pBuffer;           
        u32         _blockSize;         
    };
#endif //GX_USE_OPENGL
    struct GxCommandSetRenderState;
    struct GxCommandSetDepthTestState;
    struct GxCommandSetStencilTestState;
    struct GxCommandSetAlphaTestState;
    struct GxCommandSetBlendState;
    struct GxCommandSetViewport;
    struct GxCommandSetScissorRect;
    struct GxCommandSetRenderTarget;
    struct GxCommandSetDepthStencil;
    struct GxCommandForceDrawState;
    struct GxCommandForceVertexStreamState;
    struct GxCommandDraw;
    struct GxCommandDrawIndexed;
    struct GxCommandDrawMemory;
    struct GxCommandDrawIndexedMemory;
#if GX_ENABLE_COMPUTE_SHADER
    struct GxCommandDispatch;
#endif //GX_ENABLE_COMPUTE_SHADER
#if GX_ENABLE_OCCLUSION_CULLING
    struct GxCommandResolveOcclusionQuery;
#endif //GX_ENABLE_OCCLUSION_CULLING
    struct GxCommandClear;
    struct GxCommandClearHDR;
    struct GxCommandCopyRenderTargetToTexture;
    struct GxCommandCopyDepthStencilToTexture;
    struct GxCommandCopyRenderTargetToTextureStretch;
    struct GxCommandCopyDepthStencilToTextureStretch;
    struct GxCommandCopyRenderTargetToTextureWithMipmap;
    struct GxCommandAssembleFinalVrImage;
    struct GxCommandBeginMarker;
    struct GxCommandEndMarker;
    struct GxCommandCallback;
    struct GxCommandCallbackCopy;
    struct GxCommandSetPredication;
#if defined(_NX64)
    struct GxCommandSetTiledCacheAction;
    struct GxCommandSetTiledCacheTileSize;
    struct GxCommandSaveZCullData;
    struct GxCommandRestoreZCullData;
#endif //_NX64
 
#if GX_ENABLE_HTILE_STENCIL_MASK
    struct GxCommandMaskHtileStencilRegion;
#endif // GX_ENABLE_HTILE_STENCIL_MASK
 
    static constexpr u32        CACHE_INVALIDATE_VALUE      = 0x8B8B8B8BUL;     
    static void*                CACHE_INVALIDATE_POINTER;                       
 
#if GX_DEVELOP
public:
    struct GxPerformanceCounter : public GxStructBase
    {
        //-------------------------------------------------------------
        //-------------------------------------------------------------
    public:
        GX_RTTI_STRUCT(GxPerformanceCounter)
 
        
        //-------------------------------------------------------------
        //-------------------------------------------------------------
 
        u32                     _renderPoint;       
        u32                     _renderLine;        
        u32                     _renderTriangle;    
        u32                     _renderVertex;      
        u32                     _renderCall;        
 
    };
 
    struct GxPerformanceCounterView : public GxStructBase
    {
        //-------------------------------------------------------------
        //-------------------------------------------------------------
    public:
        GX_RTTI_STRUCT(GxPerformanceCounterView)
 
        
        //-------------------------------------------------------------
        //-------------------------------------------------------------
 
        GxPerformanceCounter    _subView[static_cast<s32>(RENDER_SUB_VIEW::MAX)];   
 
        u32                     _renderPoint;       
        u32                     _renderLine;        
        u32                     _renderTriangle;    
        u32                     _renderVertex;      
        u32                     _renderCall;        
 
    };
 
protected:  
    class GxScreenshotStateStore
    {
        //-------------------------------------------------------------
        //-------------------------------------------------------------
    public:
        void    store(void);
        void    restore(void);
 
        //-------------------------------------------------------------
        //-------------------------------------------------------------
    private:
        b32 _useRenderThread;       
        b32 _enableFrameSkip;       
        b32 _enableCpuRenderSkip;   
 
    };
#endif  // GX_DEVELOP
 
#if defined(_WINDOWS)
public:
    struct GxDisplayConfig
    {
        GxSize _outputResolution;   
        GxSize _innerResolution;    
        GxSize _filterResolution;   
        b32 _isFilterAntialias;     
        b32 _isFullScreen;          
    };
 
    enum class DISPLAY_CONFIG
    {
        OK                  = 0,    
        INVALID_WINDOW_RESOLUTION,  
        INVALID_DISPLAY_RESOLUTION, 
        IS_NOT_FULLSCREEN_READY,    
        IS_NOT_READY,               
    };
 
    struct GxDisplayDeviceInformation : public GxStructBase
    {
        //-------------------------------------------------------------
        //-------------------------------------------------------------
 
        friend class GxRenderDevice;
        GX_RTTI_STRUCT(GxDisplayDeviceInformation)
 
        
        //-------------------------------------------------------------
        //-------------------------------------------------------------
    public:
        GxDisplayDeviceInformation(void)
            : _isUsing(false)
            , _displayReady(false)
            , _videoMemorySize(0)
            , _systemMemorySize(0)
            , _sharedMemorySize(0)
            , _pAdapter(nullptr)
            {}
 
        //-------------------------------------------------------------
        //-------------------------------------------------------------
 
        GxString    _deviceName;        
        b32         _isUsing;           
        b32         _displayReady;      
        u64         _videoMemorySize;   
        u64         _systemMemorySize;  
        u64         _sharedMemorySize;  
    private:
        void*       _pAdapter;          
 
    };
#endif //_WINDOWS
 
#if defined(_NX64)
public:
    enum class MEMORY_POOL_TYPE
    {
        COMMAND_BUFFER          = 1,    
        VERTEX_DEFAULT,                 
        TEXTURE_POOL,                   
        TEXTURE_DEFAULT,                
        COMMON_DEFAULT,                 
        GPU_DEFAULT,                    
        TEXTURE_RENDER_TARGET,          
        SHADER_CODE,                    
    };
 
    enum DIRTY_STATE
    {
        DIRTY_STATE_RENDER_TARGET               = (1 << 0),     
        DIRTY_STATE_POLYGON_STATE               = (1 << 1),     
        DIRTY_STATE_POLYGON_OFFSET              = (1 << 2),     
        DIRTY_STATE_MULTI_SAMPLE_STATE          = (1 << 3),     
        DIRTY_STATE_DEPTH_STENCIL_STATE         = (1 << 4),     
        DIRTY_STATE_STENCIL_VALUE_INITIALIZE    = (1 << 5),     
        DIRTY_STATE_VIEWPORT_INITIALIZE         = (1 << 6),     
        DIRTY_STATE_SCISSOR_INITIALIZE          = (1 << 7),     
        DIRTY_STATE_BARRIER                     = (1 << 8),     
    };
#endif // _NX64
 
public:
    static constexpr u32            FRAME_TIME_LOG_COUNT = (1 << 3);
    static constexpr u32            FRAME_TIME_LOG_COUNT_I = (1 << 3);
    static constexpr u32            PACKET_BLOCK_SIZE = GxMath::VALUE_8K;
    static constexpr u32            COMMAND_BLOCK_SIZE = GxMath::VALUE_32K;
private:
#if GX_USE_DX12
    // パイプラインステート最大数
    static constexpr u32            PIPELINE_STATE_MAX = GxMath::VALUE_1K;
#endif //GX_USE_DX12
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
public:
    GxRenderDevice(void);
    b32                 initialize(const GxRenderDeviceInitialInformation* pInitialInformation);
private:
#if GX_USE_DX11 || GX_USE_DX12
    b32                 initializeError(HRESULT hResult, u32 errorPosition);
#endif //GX_USE_DX11 || GX_USE_DX12
    b32                 initializeInner(const GxRenderDeviceInitialInformation* pInitialInformation);
#if GX_USE_DX11 || GX_USE_DX12
    void                createSwapChainDesc(DXGI_SWAP_CHAIN_DESC& desc);
#endif // GX_USE_DX11 || GX_USE_DX12
 
public:
    void                stopRenderThread(void);
    void                terminate(void);
 
    b32                 loadResource(void);
    b32                 unloadResource(void);
 
#if GX_DEVELOP
    GX_FORCE_INLINE void setGpuProfiling( b32 on ){ _enableGpuProfiling = on; }
#endif //GX_DEVELOP
 
protected:
    b32                 initializeThreadLocalStorage(u32 workerThreadIndex);
 
#if GX_DEVELOP
    static GxGuiBase*       createGui(GxProperty& property, GxTypedObject* pOwner, const GxRtti& rtti, u32 index);
    b32                     getResourceTableProperty(GxClassBase*& pOwner, GxProperty*& pProperty);
public:
    constexpr GxVramAllocator* getVramAllocator(void) const { return _pVramAllocator; };
#endif //GX_DEVELOP
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GX_FORCE_INLINE f32                 getElapsedFrameTime(void) const { return _frameRateTimer.getDiff(GxMath::PREFIX::NANO) / 1000.0f / 1000.0f; }
    constexpr RENDER_FRAME_RATE         getFrameRateTarget(void) const { return _frameRateTarget; }
    f32                                 getFrameRateTargetF32(void);
    void                                setFrameRateTarget(RENDER_FRAME_RATE frameRate);
    constexpr f32                       getFrameRate(void) const { return _frameRate; }
    constexpr f32                       getFrameRateAverage(void) const { return _frameRateAverage; }
    constexpr f32                       getFrameTime(void) const { return _frameTime; }
    constexpr f32                       getFrameTimeAverage(void) const { return _frameTimeAverage; }
    constexpr f32                       getGpuFrameTime(void) const { return _gpuFrameTime; }
    constexpr u64                       getGpuTimeStampFrequency(void) const { return _gpuTimeStampFrequency; }
    GX_FORCE_INLINE b32                 getFrameAverageAvailable(void) const { return _frameAverageAvailable; }
    
    // FrameSkip
    GX_FORCE_INLINE b32                 isCpuRenderSkipping(void) const { return false; }
 
    GX_FORCE_INLINE const GxSize&       getOutputResolution(void) const { return _outputResolution; }
#if defined(_WINDOWS)
    GX_FORCE_INLINE void                setOutputResolution(const GxSize& resolution) { _outputResolutionRequest = resolution; }
#endif //_WINDOWS
    GX_FORCE_INLINE const GxRect&       getSafetyArea(void) const { return _safetyArea; }
    constexpr f32                       getAspectRatio(void) const { return _aspectRatio; }
    constexpr f32                       getGamma(void) const { return _gamma; }
    constexpr void                      setGamma(f32 gamma) { _gamma = gamma; }
    
    constexpr u32                       getWriteBuffer(void) const { return _writeBuffer; }
    constexpr u32                       getRenderBuffer(void) const { return _renderBuffer; }
 
    GX_FORCE_INLINE GxRenderTexture*    getTextureByHandle(GX_HANDLE handle) const;
    GX_FORCE_INLINE GxRenderTexture*    getBackBuffer(void) const
    {
#if defined(_PS5) || GX_USE_DX12
        return _sharedContext[_writeBuffer]._pBackBuffer;
#else //_PS5 || GX_USE_DX12
        return _pBackBuffer;
#endif // !(_PS5 || GX_USE_DX12)
    }
 
    GX_FORCE_INLINE const GxString&     getDeviceName(void) const { return _deviceName; }
 
    GX_FORCE_INLINE u32                 getMaxSkinningJointCount(void);
 
#if GX_USE_DX11 || GX_USE_DX12
    GX_FORCE_INLINE GxNativeDevice getDevice(void) const { return _pDevice; }
    constexpr GxNativeSwapChain* getSwapChain(void) const { return _pSwapChain; }
#if GX_USE_DX11
    GX_FORCE_INLINE ID3D11DeviceContext*    getD3D11ImmediateContext(void) const { return _pD3D11ImmediateContext; }
    ID3D11DeviceContext*                    lockD3D11ImmediateContext(void);
    void                                    unlockD3D11ImmediateContext(void);
    ID3D11DeviceContext*                    lockD3D11DeferredContext(void);
    void                                    unlockD3D11DeferredContext(void);
#elif GX_USE_DX12
    GX_FORCE_INLINE ComPtr<ID3D12GraphicsCommandList> getGraphicsCommandList(void) const { return _pD3D12GraphicsCommandList; }
    GX_FORCE_INLINE ComPtr<ID3D12CommandQueue> getCommandQueue(void) const { return _pD3D12CommandQueue; }
#if defined(_WINDOWS)
    GX_FORCE_INLINE ComPtr<ID3D12Fence> getFence(void) const { return _pD3D12Fence; }
    constexpr u64 getFenceValue(u32 bufferIndex) const { return _sharedContext[bufferIndex]._fenceValue; }
#endif //_WINDOWS
    ComPtr<ID3D12GraphicsCommandList> lockGraphicsCommandListCopy(void);
    void unlockGraphicsCommandListCopy(void);
    GX_FORCE_INLINE ComPtr<ID3D12CommandAllocator> getCommandAllocatorCopy(void) const { return _pD3DCommandAllocatorCopy; }
#if defined(_XBOX_XS)
    GX_FORCE_INLINE ComPtr<ID3D12CommandQueue> getCommandQueueCopy(void) const { return _pD3D12CommandQueue; }
#else //_XBOX_XS
    GX_FORCE_INLINE ComPtr<ID3D12CommandQueue> getCommandQueueCopy(void) const { return _pD3D12CommandQueueCopy; }
#endif // !_XBOX_XS
    u32 createShaderResourceView(ID3D12Resource* pResource, const D3D12_SHADER_RESOURCE_VIEW_DESC& desc);
    u32 createUnorderedAccessView(ID3D12Resource* pResource, const D3D12_UNORDERED_ACCESS_VIEW_DESC& desc);
private:
    b32 barrierTexture(GxRenderTexture* pTexture, D3D12_RESOURCE_STATES beforeState, D3D12_RESOURCE_STATES afterState);
    GX_FORCE_INLINE b32 isSupportMeshShader(void) const { return _featureLevelOptions7.MeshShaderTier != D3D12_MESH_SHADER_TIER_NOT_SUPPORTED; }
#if GX_DEVELOP
    void outputDeviceRemovedExtendedData(void) const;
#endif //GX_DEVELOP
public:
#endif //GX_USE_DX12
#if defined(_WINDOWS)
    void resetContext(void);
#endif //_WINDOWS
#if GX_EDITOR
    GxNativeSwapChain*                      createSwapChain(HWND hwnd);
    void                                    deleteSwapChain(GxNativeSwapChain* pSwapChain);
#endif //GX_EDITOR
    GX_FORCE_INLINE b32                     getVBlankWait(void) const { return _forceVBlankWait; }
    GX_FORCE_INLINE void                    setVBlankWait(b32 vblank) { _forceVBlankWait = vblank; }
 
private:
#if GX_EDITOR
    IDXGIFactory*                           getDXGIFactory(void) const;
#endif //GX_EDITOR
#endif  // GX_USE_DX11 || GX_USE_DX12
 
public:
#if defined(_PS5)
    GX_FORCE_INLINE GxNativeRenderContext* getRenderContext(u32 bufferIndex) const { return &_sharedContext[bufferIndex]._context; }
#endif //_PS5
 
#if defined(_PS4) || defined(_PS5)
    s32                                 getVideoOutHandle(void) const;
#endif  // _PS4 || _PS5
#if defined(_PS4)
    b32                                 isMonitorHDR(void) const;
    b32                                 isVideoOutModeHDR(void) const;
#endif  // _PS4
 
#if defined(_WINDOWS)
    void getDisplayConfig(GxDisplayConfig& config);
    // 成功したかどうかは戻り値のステートで判断
    DISPLAY_CONFIG setDisplayConfig(const GxDisplayConfig& config);
    b32 isSetDisplayConfigReady(void);
    GX_FORCE_INLINE GxSize getDesktopSize(void) const { return _desktopSize; }
    b32 isSupportWindowResolution(const GxSize& resolution);
    b32 isSupportDisplayResolution(const GxSize& resolution);
    GxSize getEnumDisplayResolution(u32 index) const;
    const GxRenderDevice::GxDisplayDeviceInformation& getEnumDisplayDeviceInformation(u32 index) const;
    GX_FORCE_INLINE b32                 isFullScreen(void) const { return _isFullScreen; }
    GX_FORCE_INLINE void                setFullScreen(b32 fullScreen) { _isFullScreen = fullScreen; }
    GX_FORCE_INLINE u32                 getRefreshRate(void) const { return _refreshRate; }
#endif // _WINDOWS
 
#if defined(_WINDOWS) || defined(_PS4) || defined(_PS5) || defined(_XBOX_XS)
    GX_FORCE_INLINE GxCaps              getCaps(void) const { return _caps; }   // 仮
    constexpr u32                       getUseTexcoordCount(void) const { return _useTexcoordCount; }
#endif //_WINDOWS || _PS4 || _PS5 || _XBOX_XS
 
#if defined(_NX64)
    GX_FORCE_INLINE GxNativeDevice*     getDevice(void) { return &_device; }
    constexpr GxNativeCommandBuffer*    getCommandBuffer(void) { return _pCommandBuffer; }
    GX_FORCE_INLINE void                setOutputResolution(const GxSize& size) { _outputResolution = size; }
    b32 registerFastClearColor(RENDER_FORMAT format, const GxColor& color);
    b32 registerFastClearDepth(f32 depth);
#endif // _NX64
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
#if defined(_PS4) || defined(_PS5)
    b32                                 isDisplayOverFullHD( s32 videoHandle );
    GxSize                              getDisplayResolutionPS4( s32 videoHandle, const GxSize* pRequestedResolution = nullptr );
 
    enum class ORBIS_D3D11_VIDEO_OUT_MODE
    {
        SDR,                
        SDR_END = SDR,      
        HDR_PQ,             
        HDR_END = HDR_PQ,   
    };
 
#if GX_ENABLE_NEO
    enum class ORBIS_D3D11_NEO_RENDER_MODE
    {
        NONE,           
        _4K_STRETCH,    
        _4KG,           
        _4KCB,          
        MAX,            
    };
 
    ORBIS_D3D11_NEO_RENDER_MODE ConvertNeoRenderModeFromGxToOrbisD3D11( GX_NEO_RENDER_MODE neoRenderMode );
 
    constexpr GX_NEO_RENDER_MODE getNeoRenderMode(void) const { return _neoRenderMode; }
    void                        setNeoRenderMode( GX_NEO_RENDER_MODE neoRenderMode);
 
private:
    ORBIS_D3D11_NEO_RENDER_MODE getOrbisD3D11NeoRenderMode(void) const;
    void                        setOrbisD3D11NeoRenderMode( ORBIS_D3D11_NEO_RENDER_MODE neoRenderMode);
public:
    GX_FORCE_INLINE b32 isNeoRenderMode4KG(void) const              { return ( getNeoRenderMode() == GX_NEO_RENDER_MODE::_4KG ); }
    GX_FORCE_INLINE b32 isNeoRenderMode4KCB(void) const             { return ( getNeoRenderMode() == GX_NEO_RENDER_MODE::_4KCB ); }
    GX_FORCE_INLINE b32 isNeoRenderModeNeedToResolve(void) const    { return isNeoRenderMode4KG() || isNeoRenderMode4KCB(); }
    GX_FORCE_INLINE b32 isUsePrimitiveIdMap(void) const             { return isNeoRenderMode4KG() || isNeoRenderMode4KCB(); }
    GX_FORCE_INLINE b32 isUseDepthStencilNeo(void) const            { return isNeoRenderMode4KG() || isNeoRenderMode4KCB(); }
 
private:
    void                        updateNeoRenderMode(void);
 
    GX_FORCE_INLINE void        getPropertyNeoRenderMode(void* const pValue) { *static_cast<GX_NEO_RENDER_MODE*>(pValue) = getNeoRenderMode(); }
    GX_FORCE_INLINE void        setPropertyNeoRenderMode(const void* const pValue) { setNeoRenderMode(*static_cast<GX_NEO_RENDER_MODE*>(const_cast<void*>(pValue))); }
public:
#endif  // GX_ENABLE_NEO
#endif  // _PS4 || _PS5
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
#if GX_USE_DX11 || defined(_PS5) || defined(_NX64)
    static GxNativeShaderStage getShaderStage(RENDER_SHADER renderShader);
#endif // GX_USE_DX11 || _PS5 || _NX64
 
private:
    GX_FORCE_INLINE void    getPropertyFrameRateTarget(void* const pValue) { *static_cast<RENDER_FRAME_RATE*>(pValue) = getFrameRateTarget(); }
    GX_FORCE_INLINE void    setPropertyFrameRateTarget(const void* const pValue)  { setFrameRateTarget(*static_cast<RENDER_FRAME_RATE*>(const_cast<void*>(pValue))); }
 
#if defined(_NX64)
    void getPropertyFirmwareMemoryMinimumFreeSize(void* const pValue);
    void getPropertyGraphicsAllocatorFreeSize(void* const pValue);
#endif // _NX64
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
private:
    GX_FORCE_INLINE b32     registerRenderResource(GxRenderResource* pRenderResource);
    GX_FORCE_INLINE b32     unregisterRenderResource(GxRenderResource* pRenderResource);
    void initializeSharedContext(u32 bufferCount);
    void releaseSharedContext(void);
 
public:
    GxRenderVertexBuffer*       createVertexBuffer(u32 size, u32 attribute);
    GxRenderIndexBuffer*        createIndexBuffer(u32 size, RENDER_INDEX_TYPE type, u32 attribute);
    GxRenderVertexDeclaration*  createVertexDeclaration(const GxRenderVertexElement* pElements);
    template<typename T> T* createShader(const void* pAssembledCode, u32 assembledCodeSize, u32 constantRegisterParameterCount, u32 usageInputSemantics, u32 constantBufferSize)
    {
        auto* pShader = GX_NEW T;
        if (!pShader)
        {
            GX_ASSERT(false, "シェーダ用のメモリの確保に失敗");
            return nullptr;
        }
        else if (!pShader->initialize(pAssembledCode, assembledCodeSize, constantRegisterParameterCount, usageInputSemantics, constantBufferSize))
        {
            GX_SAFE_RELEASE(pShader);
            return nullptr;
        }
 
        return pShader;
    }
    template<> GxRenderPixelShader* createShader(const void* pAssembledCode, u32 assembledCodeSize, u32 constantRegisterParameterCount, u32 usageInputSemantics, u32 constantBufferSize)
    {
        auto* pShader = GX_NEW GxRenderPixelShader;
        if (!pShader)
        {
            GX_ASSERT(false, "シェーダ用のメモリの確保に失敗");
            return nullptr;
        }
        else if (!pShader->initialize(pAssembledCode, assembledCodeSize, constantRegisterParameterCount, usageInputSemantics, constantBufferSize))
        {
            GX_SAFE_RELEASE(pShader);
            return nullptr;
        }
 
        // 不要な中間バッファを削除
        // 引数 true でシェーダーの保存に必要なデータは ALLOCATOR_DEVELOP に移動
        pShader->releaseDiscardBuffer(true);
 
        return pShader;
    }
 
    GxRenderTexture*            createTexture2D(const GxSize& size, u32 mipLevel, RENDER_FORMAT format, u32 attribute);
    GxRenderTexture*            createTexture3D(const GxSize& size, u32 depth, u32 mipLevel, RENDER_FORMAT format, u32 attribute);
    GxRenderTexture*            createTextureCube(const GxSize& size, u32 mipLevel, RENDER_FORMAT format, u32 attribute);
    GxRenderTexture*            createRenderTarget(const GxSize& size, RENDER_FORMAT format, RENDER_ANTI_ALIASING antiAliasing, u32 attribute);
#if GX_USE_DX11 || GX_USE_DX12
    GxRenderTexture*            createRenderTarget(GxNativeTexture pD3DTexture2D, u32 attribute);
#endif  //GX_USE_DX11 || GX_USE_DX12
#if defined(_PS4) || defined(_PS5)
    GxRenderTexture*            createTextureFmask(const GxRenderTexture* pMultiTexture);
#endif  //_PS4 || _PS5
#if GX_USE_DX11 || GX_USE_DX12
    GX_FORCE_INLINE void setContextFlush(b32 contextFlush) { _enableContextFlush = contextFlush; }
    GX_FORCE_INLINE b32 isEnableContextFlush(void) { return _enableContextFlush; }
    constexpr u32 getDxFeatureLevel(void) const { return _dxFeatureLevel; }
    constexpr f32 getTexcelOffset(void) const { return (_dxFeatureLevel < GX_DIRECTX_VERSION_11_0) ? 0.0f : 0.5f; }
    u32 getShaderModel(void) const;
#endif  // GX_USE_DX11 || GX_USE_DX12
    GX_FORCE_INLINE b32 isEnablePreZSortByDepth(void){ return _enablePreZSortByDepth; }
    GX_FORCE_INLINE GxVector2 getResolutionScaleTextureSSAO(void) const { return _resolutionScaleTexSSAO; }
    GX_FORCE_INLINE void setResolutionScaleTextureSSAO( const GxVector2& scale ) { _resolutionScaleTexSSAO = scale; }
    GX_FORCE_INLINE GxRenderTexture* getBackBufferDepthStencil(void) const
    {
#if defined(_PS5)
        return _sharedContext[_writeBuffer]._pBackBufferDepthStencil;
#else //_PS5
        return _pBackBufferDepthStencil;
#endif // !_PS5
    }
    GxRenderTexture*            createDepthStencil(const GxSize& size, RENDER_FORMAT format, RENDER_ANTI_ALIASING antiAliasing, u32 attribute);
 
#if defined(GX_ENABLE_HDR_MONITOR)
    constexpr GxRenderTexture* getRenderTextureHdrWorkingBuffer(void) { return _pRenderTextureHdrWorkingBuffer; }
#endif  // GX_ENABLE_HDR_MONITOR
 
    GxRenderQuery*              createQuery(RENDER_QUERY_TYPE type);
 
    GX_FORCE_INLINE void setDisableShadowPass(b32 disable){ _disableShadowPass = disable; }
    GX_FORCE_INLINE b32 isDisableShadowPass(void) const { return _disableShadowPass; }
 
    GX_FORCE_INLINE void setDisableOverPaintPass(b32 disable){ _disableOverPaintPass = disable; }
    GX_FORCE_INLINE b32 isDisableOverPaintPass(void) const { return _disableOverPaintPass; }
 
#if GX_ENABLE_OCCLUSION_CULLING
    constexpr GxRenderQuery* getOcclusionQuery(u32 bufferIndex) const { return _sharedContext[bufferIndex]._pOcclusionQuery; }
#endif //GX_ENABLE_OCCLUSION_CULLING
 
    GX_FORCE_INLINE void setDisableProcedualPass(b32 disable){ _disableProcedualPass = disable; }
    GX_FORCE_INLINE b32 isDisableProcedualPass(void) const { return _disableProcedualPass; }
 
    GX_FORCE_INLINE b32 isUseDummyShader(void) const { return _useDummyShader; }
 
#if GX_DEVELOP
    GX_FORCE_INLINE void setEnableWarningShaderCompile(b32 enable){ _enableWarningShaderCompile = enable; }
#endif // GX_DEVELOP
    GX_FORCE_INLINE b32 isEnableWarningShaderCompile(void) const { return _enableWarningShaderCompile; }
 
    GX_FORCE_INLINE b32 isNormalMap16FP() const { return _isNormalMap16FP; }
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
private:
    void                    setRenderStateNoCache(RENDER_STATE renderState, u32 value);
    void                    setDepthTestStateNoCache(GxRenderDepthTestState state);
    void                    setStencilTestStateNoCache(GxRenderStencilTestState state, u32 stencilRef, b32 stencilTwoSideEnable);
    void                    setAlphaTestStateNoCache(GxRenderAlphaTestState state);
    void                    setBlendStateNoCache(GxRenderBlendState state);
    GX_FORCE_INLINE void    setViewportNoCache(const GxViewportData& viewportData);
    void                    setViewportNoCache(const GxRect& rect, f32 nearZ, f32 farZ);
    void                    setScissorRectNoCache(const GxRect& rect);
    void                    setVertexStreamNoCache(u32 slot, const GxVertexStream* pVertexStream);
#if defined(_WINDOWS) || defined(_PS4) || defined(_PS5) || defined(_XBOX_XS)
    void                    setVertexStreamNoCache(u32 slot, const GxVertexStream* pVertexStream, u32 instanceCount);
#endif  // _WINDOWS || _PS4 || _PS5 || _XBOX_XS
    void                    setIndexBufferNoCache(GxRenderIndexBuffer* pIndexBuffer);
    void                    setVertexDeclarationNoCache(GxRenderVertexDeclaration* pVertexDeclaration);
    void                    setShaderNoCache(RENDER_SHADER renderShader, GxRenderShader* pShader);
    void                    setTextureNoCache(RENDER_SHADER renderShader, u32 samplerIndex, GxRenderTexture* pTexture, b32 isUav);
    void                    setSamplerStateNoCache(RENDER_SHADER renderShader, u32 samplerIndex, GxRenderSamplerState state);
    void                    setRenderTargetNoCache(u32 index, GxRenderTexture* pRenderTarget);
    void                    setDepthStencilNoCache(GxRenderTexture* pDepthStencil, b32 readonly = false);
 
private:
    GX_FORCE_INLINE void    setRenderState(RENDER_STATE renderState, u32 value);
    GX_FORCE_INLINE void    setDepthTestState(GxRenderDepthTestState state);
    GX_FORCE_INLINE void    setStencilTestState(GxRenderStencilTestState state, u32 stencilRef, b32 stencilTwoSideEnable);
    GX_FORCE_INLINE void    setAlphaTestState(GxRenderAlphaTestState state);
    GX_FORCE_INLINE void    setBlendState(GxRenderBlendState state);
    GX_FORCE_INLINE void    setViewport(const GxViewportData& viewportData);
    GX_FORCE_INLINE void    setScissorRect(const GxRect& rect);
#if defined(_NX64)
    GX_FORCE_INLINE void    setShaderConstantB(RENDER_SHADER renderShader, u32 startRegister, const b32* pBooleanArray, u32 count, u32 bindLocationIndex);
#else //_NX64
    GX_FORCE_INLINE void    setShaderConstantB(RENDER_SHADER renderShader, u32 startRegister, const b32* pBooleanArray, u32 count);
#endif // !_NX64
#if defined(_NX64)
    GX_FORCE_INLINE void    setShaderConstantI(RENDER_SHADER renderShader, u32 startRegister, const s32* pIntArray, u32 count, u32 bindLocationIndex);
#else //_NX64
    GX_FORCE_INLINE void    setShaderConstantI(RENDER_SHADER renderShader, u32 startRegister, const s32* pIntArray, u32 count);
#endif // !_NX64
#if defined(_NX64)
    GX_FORCE_INLINE void    setShaderConstantF(RENDER_SHADER renderShader, u32 startRegister, const f32* pFloatArray, u32 count, u32 bindLocationIndex);
#else //_NX64
    GX_FORCE_INLINE void    setShaderConstantF(RENDER_SHADER renderShader, u32 startRegister, const f32* pFloatArray, u32 count);
#endif // !_NX64
    GX_FORCE_INLINE void    setVertexStream(u32 slot, const GxVertexStream* pVertexStream);
#if defined(_WINDOWS) || defined(_PS4) || defined(_PS5) || defined(_XBOX_XS)
    GX_FORCE_INLINE void    setVertexStream(u32 slot, const GxVertexStream* pVertexStream, u32 instanceCount);
#endif  // _WINDOWS || _PS4 || _PS5 || _XBOX_XS
    GX_FORCE_INLINE void    setIndexBuffer(GxRenderIndexBuffer* pIndexBuffer);
    GX_FORCE_INLINE void    setVertexDeclaration(GxRenderVertexDeclaration* pVertexDeclaration);
    GX_FORCE_INLINE void    setShader(RENDER_SHADER renderShader, GxRenderShader* pShader);
 
    GX_FORCE_INLINE void    setTexture(RENDER_SHADER renderShader, u32 samplerIndex, GxRenderTexture* pTexture, b32 isUav);
    GX_FORCE_INLINE void    setSamplerState(RENDER_SHADER renderShader, u32 samplerIndex, GxRenderSamplerState state);
 
    GX_FORCE_INLINE void    setRenderTarget(u32 index, GxRenderTexture* pRenderTarget);
    GX_FORCE_INLINE void    setDepthStencil(GxRenderTexture* pDepthStencil, b32 readOnly = false);
 
    void                    invalidateState(void);
 
public:
    void                    storeState(void);
    void                    storeVertexDataState(void);
 
#if defined(_PS4) || defined(_PS5)
    constexpr GxRenderTexture* getDefaultTexture(void) const { return _pDefaultTexture; }
    constexpr GxRenderTexture* getDefaultTextureCube(void) const { return _pDefaultTextureCube; }
#endif  // _PS4 || _PS5
 
private:
#if GX_USE_DX11 || GX_USE_DX12 || defined(_NX64)
    void                    applyState(void);
#endif //GX_USE_DX11 || GX_USE_DX12 || _NX64
#if GX_USE_DX11
    void                    applyState(RENDER_SHADER renderShader);
public:
    ID3D11Buffer*           getVertexShaderConstantBuffer(u32 bufferSize) { return _vertexShaderConstantPool.allocateSharedBuffer(bufferSize); }
    ID3D11Buffer*           getPixelShaderConstantBuffer(u32 bufferSize) { return _pixelShaderConstantPool.allocateSharedBuffer(bufferSize); }
private:
#elif GX_USE_DX12
    void                    applyState(RENDER_SHADER renderShader, u32* pDescriptorCounts, D3D12_GPU_DESCRIPTOR_HANDLE& samplerGpuHandle);
#elif defined(_PS5)
    void                    applyState(u32 vertexCount, RENDER_PRIMITIVE_TYPE primitiveType);
    void                    applyStateShader(RENDER_SHADER renderShader);
#elif defined(_NX64)
    void                    applySurfaceState(void);
    void                    applyDrawState(void);
    b32                     applyShaderState(RENDER_SHADER renderShader);
    void                    swapCommandBufferMemory(u32 index);
    void                    applyDisplayOutputState(void);
#endif // _NX64
 
protected:
    void                    setDefaultState(void);
 
    void                    unsetAllRenderResource(void);
    
    void                    forceDrawState(const GxCommandForceDrawState* pCommand);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
private:
    void                    draw(const GxCommandDraw* pCommand);
    void                    drawIndexed(const GxCommandDrawIndexed* pCommand);
    void                    drawMemory(const GxCommandDrawMemory* pCommand);
    void                    drawIndexedMemory(const GxCommandDrawIndexedMemory* pCommand);
#if GX_ENABLE_COMPUTE_SHADER
    void                    dispatch(const GxCommandDispatch* pCommand);
#endif //GX_ENABLE_COMPUTE_SHADER
    void                    clear(const GxCommandClear* pCommand);
    void                    clearHDR(const GxCommandClearHDR* pCommand);
 
#if GX_ENABLE_HTILE_STENCIL_MASK
    void                    maskHtileStencilRegion(const GxCommandMaskHtileStencilRegion* pCommand);
#endif // GX_ENABLE_HTILE_STENCIL_MASK
 
private:
    void                    copyRenderTargetToTexture(const GxCommandCopyRenderTargetToTexture* pCommand);
    void                    copyDepthStencilToTexture(const GxCommandCopyDepthStencilToTexture* pCommand);
    void                    copyRenderTargetToTextureStretch(const GxCommandCopyRenderTargetToTextureStretch* pCommand);
    void                    copyDepthStencilToTextureStretch(const GxCommandCopyDepthStencilToTextureStretch* pCommand);
    void                    copyRenderTargetToTextureWithMipmap(const GxCommandCopyRenderTargetToTextureWithMipmap* pCommand);
 
#if GX_DEVELOP
    void beginMarker(GX_CSTR name);
    void endMarker(GX_CSTR name);
#endif  // GX_DEVELOP
 
    GX_FORCE_INLINE void    setPredication(const GxCommandSetPredication* pCommand);
    
public:
    void    flushGpuCommandBuffer(void);
    
private:
    void            beginScene(void);
    void            endScene(void);
 
    void            waitVSyncOwn(void);
 
    f32             getFrameRateTargetTime(void);
 
    void            present(void);
 
public:
    void            setAllContextPriority(RENDER_VIEW view, RENDER_SUB_VIEW subView, RENDER_PASS pass, u32 subPriority);
 
    void            begin(void);
    constexpr void  end(void) {}
 
    void            buildCommand(void);
 
    void            sync(void);
#if GX_USE_DX12
#if GX_EDITOR
    void            syncRenderThread(void);
#endif //GX_EDITOR
#if defined(_WINDOWS)
    void            waitForGPU(void);
    void            waitForGPUCopy(void);
#endif //_WINDOWS
#endif //GX_USE_DX12
 
    void            startRender(void);
 
    void            renderBlankScreen(void);
 
    constexpr u32   getContextBufferCount(void) const { return static_cast<u32>(_bufferCount); }
 
private:
    void            executeRender(void);
 
    void*           sendDrawCommandCommonInfo(void* pData);
    void            sendRegister(RENDER_SHADER renderShader, const GxRegisterSet& registerSet);
 
protected:
    void            measureFPS(void);
 
private:
    void                onLostDevice(void);
 
    b32                 onResetDevice(void);
 
    void                onRender(void);
        
    void                registerNotifier(GxRenderNotifier* pNotifier);
    void                unregisterNotifier(GxRenderNotifier* pNotifier);
 
    void                registerNotifier_onRender(GxRenderNotifierForOnRender* pNotifier);
    void                unregisterNotifier_onRender(GxRenderNotifierForOnRender* pNotifier);
 
private:
    GX_HANDLE           registerTexture(GxRenderTexture* pTexture);
    void                unregisterTexture(GxRenderTexture* pTexture);
 
    void    removeCachedVertexDeclaration(GxRenderVertexDeclaration* pDeclaration);
 
    GX_FORCE_INLINE void*       allocatePacketBlock(void);
    GX_FORCE_INLINE void*       allocateCommandBlock(void);
 
public:
    GX_FORCE_INLINE void*       allocateCommandBufferMemory(u32 size);
 
    GX_FORCE_INLINE size_t      getMainMemorySize(void) const;
    GX_FORCE_INLINE size_t      getFreeMainMemorySize(void) const;
 
    GX_FORCE_INLINE size_t      getLocalMemorySize(void) const;
    GX_FORCE_INLINE size_t      getFreeLocalMemorySize(void) const;
 
    GX_FORCE_INLINE size_t      getTotalAllocatedHighLocalMemorySize(void) const;
    GX_FORCE_INLINE size_t      getTotalAllocatedHighMainMemorySize(void) const;
 
#if GX_DEVELOP
    constexpr s32 getVramSizeVertex(void) const { return _vramSizeVertex; }
    constexpr void addVramSizeVertex(s32 size){ _vramSizeVertex += size; }
    constexpr s32 getVramSizeIndex(void) const { return _vramSizeIndex; }
    constexpr void addVramSizeIndex(s32 size){ _vramSizeIndex += size; }
    constexpr s32 getVramSizeRenderTarget(void) const { return _vramSizeRenderTarget; }
    constexpr void addVramSizeRenderTarget(s32 size){ _vramSizeRenderTarget += size; }
    constexpr s32 getVramSizeTexture(void) const { return _vramSizeTexture; }
    constexpr void addVramSizeTexture(s32 size){ _vramSizeTexture += size; }
    constexpr s32 getVramSizeFilter(void) const { return _vramSizeFilter; }
    constexpr void addVramSizeFilter(s32 size){ _vramSizeFilter += size; }
    constexpr s32 getVramSizeOther(void) const { return _vramSizeOther; }
    constexpr void addVramSizeOther(s32 size){ _vramSizeOther += size; }
    constexpr s32 getVramSizeVertexDevelop(void) const { return _vramSizeVertexDevelop; }
    constexpr void addVramSizeVertexDevelop(s32 size){ _vramSizeVertexDevelop += size; }
    constexpr s32 getVramSizeIndexDevelop(void) const { return _vramSizeIndexDevelop; }
    constexpr void addVramSizeIndexDevelop(s32 size){ _vramSizeIndexDevelop += size; }
    constexpr s32 getVramSizeRenderTargetDevelop(void) const { return _vramSizeRenderTargetDevelop; }
    constexpr void addVramSizeRenderTargetDevelop(s32 size){ _vramSizeRenderTargetDevelop += size; }
    constexpr s32 getVramSizeTextureDevelop(void) const { return _vramSizeTextureDevelop; }
    constexpr void addVramSizeTextureDevelop(s32 size){ _vramSizeTextureDevelop += size; }
    constexpr s32 getVramSizeFilterDevelop(void) const { return _vramSizeFilterDevelop; }
    constexpr void addVramSizeFilterDevelop(s32 size){ _vramSizeFilterDevelop += size; }
    constexpr s32 getVramSizeOtherDevelop(void) const { return _vramSizeOtherDevelop; }
    constexpr void addVramSizeOtherDevelop(s32 size){ _vramSizeOtherDevelop += size; }
#endif //GX_DEVELOP
 
#if defined(_PS4) || defined(_PS5) || defined(_NX64)
    GX_FORCE_INLINE void*       allocateLocal(u32 size, u32 alignment);
    GX_FORCE_INLINE void*       allocateMain(u32 size, u32 alignment);
    GX_FORCE_INLINE void        free(void* pAddress);
#endif //_PS4 || _PS5 || _NX64
 
#if defined(_NX64)
    void*                       allocateStorage(u32 size);
    GxNativeMemoryPool*         createMemoryPool(u32 size, MEMORY_POOL_TYPE type, void* pBuffer = nullptr);
    void                        deleteMemoryPool(GxNativeMemoryPool* pMemory);
 
    void                        createBufferFromShaderPool(GxNativeBuffer* pBuffer, u32 size);
    void                        deleteBufferFromShaderPool(u32 offset);
 
    void                        createBufferFromCommonPool(GxNativeTextureBuilder* pBuilder);
    void                        createBufferFromCommonPool(GxNativeBuffer* pBuffer, u32 size);
    void                        deleteBufferFromCommonPool(u32 offset);
 
    void createZCullBuffer(u32 size);
 
    GX_FORCE_INLINE u32         registerTexturePool(GxNativeTexture* pTexture, GxNativeTextureView* pView);
    GX_FORCE_INLINE void        unregisterTexturePool(u32 id);
 
    GX_FORCE_INLINE u32         registerSamplerPool(GxNativeSampler* pSampler);
    GX_FORCE_INLINE u32         registerSamplerPool(GxNativeSamplerBuilder* pBuilder);
    GX_FORCE_INLINE u32         createSampler(GxRenderSamplerState sampler);
    GX_FORCE_INLINE void        unregisterSamplerPool(u32 id);
 
    constexpr u32               getCommandBufferUsedSizeMax(void) const { return _commandBufferUsedMax; }
    constexpr u32               getControlBufferUsedSizeMax(void) const { return _controlBufferUsedMax; }
 
#if GX_DEVELOP
    constexpr GxGpuCounter* getGpuCounter(void) const { return _pGpuCounter; }
#endif // GX_DEVELOP
#endif // _NX64
 
public:
    b32     requestSaveUserScreenshot(void);
    u32*    getUserScreenshotBuffer(GxSize& size);
    void    freeUserScreenshotBuffer(void);
 
#if GX_DEVELOP
public:
    b32                 requestSaveScreenshot(GX_CSTR fileName, b32 useScreenshotNumber = true);
 
    GX_FORCE_INLINE GxColor         getChromaKeyColor(void) const { return _chromaKeyColor; }
    GX_FORCE_INLINE void            setChromaKeyColor(const GxColor color) { _chromaKeyColor = color; }
    GX_FORCE_INLINE b32             isChromaKeyingToAlpha(void) const { return _chromaKeyingToAlpha; }
    GX_FORCE_INLINE void            setChromaKeyingToAlpha(b32 enable) { _chromaKeyingToAlpha = enable; }
 
    constexpr u32                   getHighResolutionScreenshotScaleX(void) const { return _highResolutionScreenshotScaleX; }
    constexpr u32                   getHighResolutionScreenshotScaleY(void) const { return _highResolutionScreenshotScaleY; }
    void                requestSaveHighResolutionScreenshot(void);
    constexpr s32                   isHighResolutionScreenshotCapturing(void) const { return _highResolutionScreenshotPhase >= 0; }
    constexpr u32                   getHighResolutionScreenshotCapturingPhaseX(void) const { return (_highResolutionScreenshotPhase / _bufferCount) % _highResolutionScreenshotScaleX; }
    constexpr u32                   getHighResolutionScreenshotCapturingPhaseY(void) const { return (_highResolutionScreenshotPhase / _bufferCount) / _highResolutionScreenshotScaleX; }
    GX_FORCE_INLINE const GxPerformanceCounterView getPerformanceCounter(RENDER_VIEW index) const { return _performanceCounter[static_cast<s32>(index)]; }
#if defined(_WINDOWS)
    void                requestSaveCubeMapShot(void);
    GX_FORCE_INLINE b32 isCubeMapShotCapturing(void) const { return _cubeMapShotPhase >= 0; }
    constexpr u32       getCubeMapShotCapturingFace(void) const { return (_cubeMapShotPhase / _bufferCount); }
    GX_FORCE_INLINE GxVector3 getCubeMapShotPosition(void) const { return _cubeMapShotPosition; }
#endif  // _WINDOWS
#endif  // GX_DEVELOP
 
private:
    void                buildCommandBlankScreen(void);
    void                buildCommandInner(GxPacket* pPacket[GxThread::HARDWARE_THREAD_MAX]);
 
#if defined(_WINDOWS)
    void                copyTexture(GxNativeTexture* pDstTexture, GxRenderTexture* pSrcTexture);
#endif //_WINDOWS
#if GX_DEVELOP
    void                saveScreenshot(void);
#if defined(_WINDOWS)
    void                saveBmp(GX_CSTR fileName, GxNativeTexture pTexture, s32 width, s32 height);
#endif  // _WINDOWS
#endif  // GX_DEVELOP
 
    void                saveUserScreenshot(void);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
private:
    u32                         _bufferCount;                                   
    GxSharedContext*            _sharedContext;                                 
    GxString                    _deviceName;                                    
    RENDER_FRAME_RATE           _frameRateTarget;                               
    b32                         _forceVBlankWait;                               
    u32                         _frameRateCounter;                              
    GxTimer                     _frameRateTimer;                                
    f32                         _frameRate;                                     
    f32                         _frameRateAverage;                              
    f32                         _frameTime;                                     
    f32                         _frameTimeAverage;                              
    f32                         _frameTimeTotal;                                
    f32                         _frameTimeLog[FRAME_TIME_LOG_COUNT];            
    f32                         _frameTimeLog_I[FRAME_TIME_LOG_COUNT_I];        
    b32                         _frameAverageAvailable;                         
    f32                         _gpuFrameTime;                                  
    u64                         _gpuTimeStampFrequency;                         
    b32                         _disableShadowPass;                             
    b32                         _disableOverPaintPass;                          
    b32                         _disableProcedualPass;                          
    b32                         _useDummyShader;                                
    b32                         _enableWarningShaderCompile;                    
    GxSize                      _outputResolution;                              
    b32                         _isNormalMap16FP;                               
    GxRect                      _safetyArea;                                    
    f32                         _aspectRatio;                                   
    f32                         _gamma;                                         
    GxAllocatorFrame*           _pAllocatorContext;                             
    GxAllocatorFrame*           _pAllocatorExecuteCommand;                      
    GxRenderContext*            _pContext;                                      
    GxRenderNotifier*           _pNotifierTop;                                  
    GxRenderNotifierForOnRender* _pNotifierTopOnRender;                     
    GxCriticalSection           _criticalSectionNotifier;                       
    GxCriticalSection           _criticalSectionNotifierOnRender;               
 
    GxRenderTexture*            _pTextureList[RENDER_TEXTURE_COUNT_MAX];        
    GxCriticalSection           _criticalSectionTexture;                        
 
    GxArray                     _vertexDeclarationArray;                        
    GxArray                     _vertexDeclarationHashArray;                    
    GxCriticalSection           _criticalSectionVertexDeclaration;              
    GxRenderVertexDeclaration*  _pClearHDRVertexDeclaration;                    
    GxResShaderVertex*          _pClearHDRVertexShader;                         
    GxResShaderPixel*           _pClearHDRPixelShader;                          
    GX_HANDLE                   _handleProjectionMatrix2D;                      
    GX_HANDLE                   _handleMipLevel;                                
    GX_HANDLE                   _handleTexture;                                 
 
    GxRenderThread*             _pRenderThread;                                 
    b32                         _useRenderThread;                               
    b32                         _useRenderThreadThisFrame;                      
    u32                         _writeBuffer;                                   
    u32                         _renderBuffer;                                  
    u32                         _commandBufferSize;                             
    u32                         _maxCommandBufferSize;                          
    u32                         _usedCommandBufferSize;                         
    GxRenderResourceRegister*   _pRenderResourceRegister;                       
    b32                         _isFirstFrame;                                  
    u32                         _renderStateValueNow[static_cast<s32>(RENDER_STATE::MAX)];  
    GxRenderDepthTestState      _depthTestStateNow;                             
    GxRenderStencilTestState    _stencilTestStateNow;                           
    u32                         _stencilRefNow;                                 
    b32                         _stencilTwoSideEnableNow;                       
    GxRenderAlphaTestState      _alphaTestStateNow;                             
    GxRenderBlendState          _blendStateNow;                                 
    GxViewportData              _viewportDataNow;                               
    GxRect                      _scissorRectNow;                                
    GxVertexStream              _vertexStreamNow[RENDER_VERTEX_STREAM_COUNT_MAX];   
    GxRenderIndexBuffer*        _pIndexBufferNow;                               
    GxRenderVertexDeclaration*  _pVertexDeclarationNow;                         
    GxRenderShader*             _pShaderNow[static_cast<u32>(RENDER_SHADER::MAX)];  
    u32                         _maxSkinningJointCount;                         
    b32                         _enablePreZSortByDepth;                         
    GxVector2                   _resolutionScaleTexSSAO;                        
    GxRenderTexture*            _pSamplerNow[static_cast<u32>(RENDER_SHADER::MAX)][RENDER_TEXTURE_SAMPLER_COUNT_MAX];               
    GxRenderSamplerState        _samplerStateNow[static_cast<u32>(RENDER_SHADER::MAX)][RENDER_TEXTURE_SAMPLER_COUNT_MAX];           
    GxRenderTexture*            _pSamplerUavNow[static_cast<u32>(RENDER_SHADER::MAX)][RENDER_TEXTURE_SAMPLER_UAV_COUNT_MAX];        
    GxRenderTexture*            _pRenderTargetNow[RENDER_TARGET_COUNT_MAX];     
    GxRenderTexture*            _pDepthStencilNow;                              
    b32                         _isReadOnlyDepthStencilNow;                     
    b32                         _isInFailedPredication;                         
    GxRenderQuery*              _pFlushQuery;                                   
    GxVramAllocator*            _pVramAllocator;                                
public:
    GX_RENDERDEVICE_ERROR_FUNCTION  _pUserErrorFunction;                        
private:
    // Master ビルドスクリーンショット
    GxCriticalSection           _criticalSectionUserScreenshot;                 
    b32                         _userScreenshotRequest;                         
    u32*                        _pUserScreenshotBuffer;                         
    GxSize                      _userScreenshotSize;                            
 
#if GX_DEVELOP
    b32                         _isExecuting;                                   
    GX_CSTR                     _markerStack[RENDER_MARKER_NEST_COUNT];         
    u32                         _markerStackIndex;                              
    GxPerformanceCounterView    _performanceCounter[static_cast<s32>(RENDER_VIEW::MAX)];    
    GxCriticalSection           _criticalSectionScreenshot;                     
    GxColor                     _chromaKeyColor;                                
    b32                         _chromaKeyingToAlpha;                           
    u32                         _highResolutionScreenshotScaleX;                
    u32                         _highResolutionScreenshotScaleY;                
    s32                         _highResolutionScreenshotPhase;                 
    GxScreenshotStateStore      _screenshotStateStore;                          
    s32                         _vramSizeVertex;                                
    s32                         _vramSizeIndex;                                 
    s32                         _vramSizeRenderTarget;                          
    s32                         _vramSizeTexture;                               
    s32                         _vramSizeFilter;                                
    s32                         _vramSizeOther;                                 
    s32                         _vramSizeVertexDevelop;                         
    s32                         _vramSizeIndexDevelop;                          
    s32                         _vramSizeRenderTargetDevelop;                   
    s32                         _vramSizeTextureDevelop;                        
    s32                         _vramSizeFilterDevelop;                         
    s32                         _vramSizeOtherDevelop;                          
    b32                         _enableGpuProfiling;                            
    b32                         _isGpuProfiling;                                
    u32                         _drawCallCount;                                 
#endif //GX_DEVELOP
 
#if defined(GX_ENABLE_HDR_MONITOR)
    GxRenderTexture*            _pRenderTextureHdrWorkingBuffer;                
#endif  // GX_ENABLE_HDR_MONITOR
 
#if defined(_WINDOWS) || defined(_PS4) || defined(_PS5) || defined(_XBOX_XS)
    u32                         _instanceCountNow[RENDER_VERTEX_STREAM_COUNT_MAX];  
    b32                         _legacyDevice;                                  
    GxCaps                      _caps;                                          
    b32                         _onLostDevice;                                  
    u32                         _useTexcoordCount;                              
#endif  // _WINDOWS || _PS4 || _PS5 || _XBOX_XS
 
#if defined(_NX64) || GX_USE_DX11
    GxRenderTexture*            _pBackBuffer;                                   
#endif // _NX64 || GX_USE_DX11
#if defined(_NX64) || GX_USE_DX11 || GX_USE_DX12
    GxRenderTexture*            _pBackBufferDepthStencil;                       
#endif // _NX64 || GX_USE_DX11 || GX_USE_DX12
#if defined(_PS5) || GX_USE_DX12
    GxVector4                   _shaderConstSet[static_cast<u32>(RENDER_SHADER::MAX)][RENDER_SHADER_CONST_MAX]; 
#endif //_PS5 || GX_USE_DX12
 
#if GX_USE_DX11 || GX_USE_DX12
    b32                         _enableContextFlush;                            
    D3D_FEATURE_LEVEL           _dxFeatureLevel;                                
    u32                         _shaderModel;                                   
    GxNativeDevice              _pDevice;                                       
    GxNativeSwapChain*          _pSwapChain;                                    
    IDXGIAdapter*               _pAdapter;                                      
#if GX_EDITOR
    GxArray                     _newSwapChains;                                 
    GxArray                     _swapChains;                                    
#endif //GX_EDITOR
#if GX_DEVELOP
    b32                         _disableSrgbTextureDevelop;                     
#endif // GX_DEVELOP
#endif //GX_USE_DX11 || GX_USE_DX12
 
#if GX_USE_DX11
    GxRenderShaderConstantPool  _vertexShaderConstantPool;                      
    GxRenderShaderConstantPool  _pixelShaderConstantPool;                       
    GxD3D11State                _d3dStateNow;                                   
    GxD3D11State                _d3d11StateSet;                                 
public: // 仮
    GxD3D11SamplerStateTable        _d3d11SamplerStateTable;                    
    GxD3D11RasterizerStateTable     _d3d11RasterizerStateTable;                 
    GxD3D11DepthStencilStateTable   _d3d11DepthStencilStateTable;               
    GxD3D11BlendStateTable          _d3d11BlendStateTable;                      
private:
    ID3D11DeviceContext*        _pD3D11ImmediateContext;                        
    GxCriticalSection           _d3d11ImmediateContextCriticalSection;          
    ID3D11DeviceContext*        _pD3D11DeferredContextAsync;                    
    GxCriticalSection           _d3d11DeferredContextAsyncCriticalSection;      
#endif //GX_USE_DX11
 
#if GX_USE_DX12
    D3D12_GRAPHICS_PIPELINE_STATE_DESC  _d3dStateNow;                           
#if GX_ENABLE_COMPUTE_SHADER
    D3D12_COMPUTE_PIPELINE_STATE_DESC   _d3dComputeStateNow;                    
#endif //GX_ENABLE_COMPUTE_SHADER
    ComPtr<ID3D12GraphicsCommandList>   _pD3D12GraphicsCommandList;             
    ComPtr<ID3D12CommandQueue>          _pD3D12CommandQueue;                    
    ComPtr<ID3D12GraphicsCommandList>   _pD3D12GraphicsCommandListCopy;         
    ComPtr<ID3D12CommandAllocator>      _pD3DCommandAllocatorCopy;              
    GxCriticalSection                   _d3d12GraphicsCommandListCopyCriticalSection;   
#if defined(_WINDOWS)
    ComPtr<ID3D12CommandQueue>          _pD3D12CommandQueueCopy;                
    ComPtr<ID3D12Fence>                 _pD3D12Fence;                           
    ComPtr<ID3D12Fence>                 _pD3D12FenceCopy;                       
    Microsoft::WRL::Wrappers::Event     _fenceEvent;                            
    Microsoft::WRL::Wrappers::Event     _fenceEventCopy;                        
    u64                                 _fenceValueCopy;                        
#endif //_WINDOWS
    ComPtr<ID3D12DescriptorHeap>        _descriptorHeapView;                    
    ComPtr<ID3D12DescriptorHeap>        _descriptorHeapSampler;                 
    ComPtr<ID3D12DescriptorHeap>        _descriptorHeapSamplerSet;              
    u32                                 _descriptorCountView;                   
    u32                                 _descriptorCountSampler;                
    u32                                 _descriptorCountSamplerSet;             
    ComPtr<ID3D12RootSignature>         _pRootSignature;                        
#if GX_ENABLE_COMPUTE_SHADER
    ComPtr<ID3D12RootSignature>         _pRootSignatureCompute;                 
#endif //GX_ENABLE_COMPUTE_SHADER
    GxMap<u64, u32>                     _samplers;                              
    GxMap<u64, u64>                     _samplerSets;                           
    ComPtr<ID3D12PipelineState>         _pPipelineState[PIPELINE_STATE_MAX];    
    GxMap<u64, ComPtr<ID3D12PipelineState>> _pipelineStates;                    
    b32                                 _pipelineStateDirty;                    
    D3D12_FEATURE_DATA_ROOT_SIGNATURE   _featureLevelRootSignature;             
    D3D12_FEATURE_DATA_D3D12_OPTIONS    _featureLevelOptions;                   
    D3D12_FEATURE_DATA_D3D12_OPTIONS1   _featureLevelOptions1;                  
    D3D12_FEATURE_DATA_D3D12_OPTIONS2   _featureLevelOptions2;                  
    D3D12_FEATURE_DATA_D3D12_OPTIONS3   _featureLevelOptions3;                  
    D3D12_FEATURE_DATA_D3D12_OPTIONS4   _featureLevelOptions4;                  
    D3D12_FEATURE_DATA_D3D12_OPTIONS5   _featureLevelOptions5;                  
    D3D12_FEATURE_DATA_D3D12_OPTIONS6   _featureLevelOptions6;                  
    D3D12_FEATURE_DATA_D3D12_OPTIONS7   _featureLevelOptions7;                  
#if GX_DEVELOP
    ComPtr<ID3D12DeviceRemovedExtendedDataSettings> _pDredSettings;             
#endif //GX_DEVELOP
#endif  // GX_USE_DX12
 
#if defined(_PS4) || defined(_PS5)
    GxRenderTexture* _pDefaultTexture;                                          
    GxRenderTexture* _pDefaultTextureCube;                                      
#endif  // _PS4 || _PS5
 
#if defined(_WINDOWS)
    GxSize                      _desktopSize;                                   
    GxSize                      _currentClientSize;                             
    GxSize                      _outputResolutionRequest;                       
    GxSize                      _backBufferResolution;                          
    b32                         _outputResolutionRestoreRequest;                
    b32                         _outputResolutionRestoreReady;                  
    GxCriticalSection           _criticalSectionSetDisplayConfig;               
    b32                         _isFullScreen;                                  
    b32                         _isFullScreenReady;                             
    GxSize                      _fullScreenResolution;                          
    b32                         _useAltEnterKeyFullScreen;                      
    u32                         _refreshRate;                                   
    GxDisplayDeviceInformation  _enumDisplayDeviceInformation[16];              
    GxSize                      _enumDisplayResolution[128];                    
    u32                         _fullScreenScalingMode;                         
    b32                         _enableWindowResizeCheck;                       
#if GX_DEVELOP
    s32                         _cubeMapShotPhase;                              
    GxVector3                   _cubeMapShotPosition;                           
    u32                         _cubeMapShotSize;                               
    b32                         _cubeMapShotGenerateMipMaps;                    
    b32                         _cubeMapShotSaveDds;                            
    b32                         _cubeMapShotSaveBmp;                            
    b32                         _cubeMapConvertOrochi1Format;                   
    GxNativeTexture             _pCapturingCubeMap;                             
    GxUnitCameraBase*           _pCubeMapShotCamera;                            
    GxUnitCameraBase*           _pCubeMapShotOldCamera;                         
#endif //GX_DEVELOP
#elif defined(_XBOX_XS)
    D3D12XBOX_FRAME_PIPELINE_TOKEN  _framePipelineToken;                        
#elif defined(_NX64)
    GxNativeMemoryPool*         _pRegisterMemoryPool;                           
    GxRegisterBlockInformation  _registerBlockInformation[static_cast<u32>(RENDER_SHADER::MAX)][RENDER_UNIFORM_BLOCK_COUNT_MAX];    
    GxNativeBuffer              _buffer[static_cast<u32>(RENDER_SHADER::MAX)][2];       
    GxNativeBuffer*             _pBufferCurrent[static_cast<u32>(RENDER_SHADER::MAX)];  
    u32                         _registerBlockInformationOffset[static_cast<u32>(RENDER_SHADER::MAX)];  
    u32                         _registerBlockInformationCount[static_cast<u32>(RENDER_SHADER::MAX)];   
    GxRenderTexture*            _pDepthStencilSet;                              
    GxRenderTexture*            _pRenderTargetSet[RENDER_TARGET_COUNT_MAX];     
    GxRenderTexture*            _samplerSet[static_cast<u32>(RENDER_SHADER::MAX)][RENDER_TEXTURE_SAMPLER_COUNT_MAX];        
    GxRenderTexture*            _samplerUavSet[static_cast<u32>(RENDER_SHADER::MAX)][RENDER_TEXTURE_SAMPLER_COUNT_MAX];     
    GxRenderSamplerState        _samplerStateSet[static_cast<u32>(RENDER_SHADER::MAX)][RENDER_TEXTURE_SAMPLER_COUNT_MAX];   
    GxRenderShader*             _pShaderSet[static_cast<u32>(RENDER_SHADER::MAX)];  
    GxRenderVertexDeclaration*  _pVertexDeclarationSet;                         
    GxRenderVertexBuffer*       _pVertexBufferSet[RENDER_VERTEX_STREAM_COUNT_MAX];  
    GxNativeBuffer              _zCullBuffer;                                   
    u32                         _zCullBufferSize;                               
    GxRawAllocator*             _pShaderPoolAllocator;                          
    GxRawAllocator*             _pCommonPoolAllocator;                          
    GxNativeMemoryPool*         _pShaderPool;                                   
    GxNativeMemoryPool*         _pCommonPool;                                   
    void*                       _pGraphicsAllocator;                            
    void*                       _pGraphicsAllocatorMemory;                      
    void*                       _pFirmwareMemory;                               
    GxTexturePoolManager*       _pTexturePoolManager;                           
    GxFrameworkManager*         _pFrameworkManager;                             
    void*                       _pQueueMemory;                                  
    GxNativeDevice              _device;                                        
    GxNativeQueue               _queue;                                         
    GxNativeCommandBuffer*      _pCommandBuffer;                                
    GxNativeCommandHandle       _commandHandle;                                 
    GxNativeMemoryPool*         _pCommandBufferPool;                            
    void*                       _pControlBufferPool;                            
    GxNativeSync                _commandBufferSync;                             
    u32                         _nativeCommandBufferSize;                       
    u32                         _commandBufferUsedMax;                          
    u32                         _controlBufferSize;                             
    GxNativeMemoryPool*         _pShaderScratchMemoryPool;                      
    u32                         _shaderScratchMemorySize;                       
    u32                         _shaderScratchMemoryCurrent;                    
    u32                         _uniformBlockBufferSize;                        
    u32                         _controlBufferUsedMax;                          
    u32                         _dirtyState;                                    
 
    GxNativeVertexStreamState   _vertexStreamStateWork[RENDER_VERTEX_STREAM_COUNT_MAX];     
    GxNativeBufferRange         _vertexBufferBindListWork[RENDER_VERTEX_STREAM_COUNT_MAX];  
    GxNativeColorState          _colorStateNow;                                 
    GxNativePolygonState        _polygonStateNow;                               
    GxNativeMultiSampleState    _multisampleStateNow;                           
    GxNativeDepthStencilState   _depthStencilStateNow;                          
 
#if GX_DEVELOP
    GxGpuCounter*               _pGpuCounter;                                   
#endif  // GX_DEVELOP   
#elif defined(_PS4)
#if GX_ENABLE_NEO   
    GX_NEO_RENDER_MODE          _neoRenderMode;                                 
#endif  // GX_ENABLE_NEO
#elif defined(_PS5)
    s32                         _videoHandle;                                   
    u32                         _constBufferSize;                               
#endif //_PS5
 
};
 
//===========================================================================
//===========================================================================
class GxRenderDevice::GxRenderThread : public GxThread
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GX_RTTI_CLASS(GxRenderThread, GxThread)
    // GxClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxRenderThread)
    // new, delete定義
    GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::RENDER)
 
    friend class GxRenderDevice;
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
private:
    GxRenderThread(void);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
protected:
    GX_FORCE_INLINE b32 waitStartEvent(s32 milliSecond = -1) { return _startEvent.waitEvent(milliSecond); }
    GX_FORCE_INLINE b32 setStartEvent(void) { return _startEvent.setEvent(); }
    GX_FORCE_INLINE b32 waitCompleteEvent(s32 milliSecond = -1) { return _completeEvent.waitEvent(milliSecond); }
    GX_FORCE_INLINE b32 setCompleteEvent(void) { return _completeEvent.setEvent(); }
    GX_FORCE_INLINE void setRequestStop(void) { _requestStopFlag = true; }
    GX_FORCE_INLINE b32 isRequestStop(void) const { return _requestStopFlag; }
 
    void    threadMain(void* pArgument) override;
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
protected:
    GxEvent                     _startEvent;                
    GxEvent                     _completeEvent;             
    b32                         _requestStopFlag;           
 
};
 
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxCommandCallback
{
    GxCallback::GxHandlerBase   _handle;    
    void*                       _pSource;   
    void*                       _pArgument; 
};
 
//===========================================================================
//===========================================================================
class GxRenderDevice::GxRenderResourceRegister : public GxClassBase
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GX_RTTI_CLASS(GxRenderResourceRegister, GxClassBase)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxRenderResourceRegister)
    // new, delete定義
    GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::RENDER)
 
    friend class GxRenderDevice;
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
private:
    GxRenderResourceRegister(void);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
private:
    b32         registerRenderResource(GxRenderResource* pRenderResource);
    b32         unregisterRenderResource(GxRenderResource* pRenderResource);
 
    GxRenderResource*   getRegisterRenderResource(u32 index);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    void                getPropertyRenderResource(void* pValue, u32 index);
    u32                 getPropertyRenderResourceCount(void);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
private:
    GxArray             _registerArray;     
    GxCriticalSection   _criticalSection;   
 
};
 
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxCommandInformation
{
    GxRenderDevice::COMMAND_TYPE    _type;  
    u32     _size;                          
};
 
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxPacket
{
    GxPriority::GxPriorityUnion _priority;      
    GxCommandInformation*       _pCommandInfo;  
};
 
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxRegisterInformation
{
    void*           _pBuffer;               
#if GX_USE_OPENGL
    u32             _bindingLocationIndex;  
#endif //GX_USE_OPENGL
    u32             _count;                 
    u32             _start;                 
};
 
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxRegisterSet
{
    GxRenderShader*         _pShader;   
    GxRegisterInformation*  _pRegisterInformation[static_cast<s32>(GxRenderShader::REGISTER_SET_TYPE::MAX)];        
    u8                      _registerInformationCount[static_cast<s32>(GxRenderShader::REGISTER_SET_TYPE::MAX)];    
};
 
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxDrawCommandCommonInformation
{
    GxRenderVertexDeclaration*  _pVertexDeclaration;    
    GxRegisterSet _registerSet[static_cast<u32>(RENDER_SHADER::DRAW_MAX)];  
};
 
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxCommandSetRenderState
{
    RENDER_STATE    _renderState;   
    u32             _value;         
};
 
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxCommandSetDepthTestState
{
    GxRenderDepthTestState  _state; 
};
 
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxCommandSetStencilTestState
{
    GxRenderStencilTestState    _state;                 
    u32                         _stencilRef;            
    b32                         _stencilTwoSideEnable;  
};
 
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxCommandSetAlphaTestState
{
    GxRenderAlphaTestState  _state; 
};
 
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxCommandSetBlendState
{
    GxRenderBlendState  _state; 
};
 
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxCommandSetViewport
{
    GxViewportData  _viewportData;  
};
 
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxCommandSetScissorRect
{
    GxRect          _rect;  
};
 
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxCommandSetRenderTarget
{
    u32                 _index;                 
    GxRenderTexture*    _pRenderTarget;         
    b32                 _forceRenderToTexture;  
};
 
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxCommandSetDepthStencil
{
    GxRenderTexture*    _pDepthStencil;         
    b32                 _readOnly;              
};
 
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxCommandForceDrawState
{
    // メンバなし
};
 
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxCommandForceVertexStreamState
{
    u32 _stream;        
    u32 _stride;        
    u32 _frequency;     
};
 
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxCommandDraw
{
    GxVertexStream          _vertexStream[RENDER_VERTEX_STREAM_COUNT_MAX];  
    RENDER_PRIMITIVE_TYPE   _type;          
    u32                     _startVertex;   
    u32                     _vertexCount;   
};
 
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxCommandDrawIndexed
{
    GxVertexStream          _vertexStream[RENDER_VERTEX_STREAM_COUNT_MAX];  
    GxRenderIndexBuffer*    _pIndexBuffer;      
    RENDER_PRIMITIVE_TYPE   _type;              
    s32                     _baseVertexIndex;   
    u32                     _minIndex;          
    u32                     _vertexCount;       
    u32                     _startIndex;        
    u32                     _indexCount;        
    u32                     _instanceCount;     
    s32*                    _pQueryIndex;       
};
 
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxCommandDrawMemory
{
    RENDER_PRIMITIVE_TYPE   _type;          
    u32                     _vertexCount;   
    const void*             _pVertex;       
    u32                     _vertexStride;  
};
 
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxCommandDrawIndexedMemory
{
    RENDER_PRIMITIVE_TYPE   _type;          
    u32                     _minIndex;      
    u32                     _vertexCount;   
    u32                     _indexCount;    
    const void*             _pVertex;       
    const void*             _pIndex;        
    u32                     _vertexStride;  
    RENDER_INDEX_TYPE       _indexType;     
};
 
#if GX_ENABLE_COMPUTE_SHADER
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxCommandDispatch
{
    GxRegisterSet           _registerSet;           
    u32                     _threadGroupCountX;     
    u32                     _threadGroupCountY;     
    u32                     _threadGroupCountZ;     
};
#endif //GX_ENABLE_COMPUTE_SHADER
 
#if GX_ENABLE_OCCLUSION_CULLING
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxCommandResolveOcclusionQuery
{
    // メンバなし
};
#endif //GX_ENABLE_OCCLUSION_CULLING
 
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxCommandClear
{
    u32             _clearFlags;    
    GxColor         _clearColor;    
    f32             _clearZ;        
    u32             _clearStencil;  
};
 
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxCommandClearHDR
{
    u32             _clearFlags;        
    f32             _clearZ;            
    GxColorHDR      _clearColor;        
    u32             _clearStencil;      
};
 
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxCommandCopyRenderTargetToTexture
{
    u16                 _index;         
    u16                 _dstMipLevel;   
    GxRenderTexture*    _pTexture;      
    const GxRect*       _pSrcRect;      
    GxRect              _srcRect;       
    GxPoint2            _dstPoint;      
};
 
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxCommandCopyDepthStencilToTexture
{
    u16                 _reserve;       
    u16                 _dstMipLevel;   
    GxRenderTexture*    _pTexture;      
    const GxRect*       _pSrcRect;      
    GxRect              _srcRect;       
    GxPoint2            _dstPoint;      
};
 
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxCommandCopyRenderTargetToTextureStretch
{
    u16                 _index;         
    u16                 _dstMipLevel;   
    GxRenderTexture*    _pTexture;      
    const GxRect*       _pSrcRect;      
    const GxRect*       _pDstRect;      
    GxRect              _srcRect;       
    GxRect              _dstRect;       
};
 
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxCommandCopyDepthStencilToTextureStretch
{
    u16                 _reserve;       
    u16                 _dstMipLevel;   
    GxRenderTexture*    _pTexture;      
    const GxRect*       _pSrcRect;      
    const GxRect*       _pDstRect;      
    GxRect              _srcRect;       
    GxRect              _dstRect;       
};
 
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxCommandCopyRenderTargetToTextureWithMipmap
{
    u32                 _index;     
    GxRenderTexture*    _pTexture;  
};
 
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxCommandAssembleFinalVrImage
{
    u32                 _filler;    
};
 
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxCommandBeginMarker
{
    GX_CHAR             _name[RENDER_MARKER_NAME_LENGTH + 1];   
};
 
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxCommandEndMarker
{
    GX_CHAR             _name[RENDER_MARKER_NAME_LENGTH + 1];   
};
 
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxCommandCallbackCopy
{
    GxCallback::GxHandlerBase   _handle;        
    u32                         _argumentSize;  
    u32                         _srcSize;       
};
 
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxCommandSetPredication
{
    void*               _pFlag; 
    u32                 _size;  
    b32                 _value; 
};
 
#if defined(_NX64)
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxCommandSetTiledCacheAction
{
    GxNativeTiledCacheAction    _action;    
};
 
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxCommandSetTiledCacheTileSize
{
    s32                 _width;     
    s32                 _height;    
};
 
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxCommandSaveZCullData
{
    // メンバなし
};
 
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxCommandRestoreZCullData
{
    // メンバなし
};
#endif //_NX64
 
#if GX_ENABLE_HTILE_STENCIL_MASK
//===========================================================================
//===========================================================================
struct GxRenderDevice::GxCommandMaskHtileStencilRegion
{
    GxRenderComputeShader* _pComputeShader; 
    GxRenderTexture* _pDepthStencil;        
    f32 _outTan;                            
    f32 _inTan;                             
    f32 _topTan;                            
    f32 _bottomTan;                         
    f32 _cutOff;                            
    f32 _cutOut;                            
};
#endif // GX_ENABLE_HTILE_STENCIL_MASK
 
// アクセスインターフェース
GX_FORCE_INLINE GxRenderDevice* getGxRenderDevice(void){ return GxRenderDevice::getSingletonPointer(); }
#if GX_USE_DX11
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
template<class STATE, class DESC, typename GxD3D11CreateStateFunction<STATE,DESC>::type CREATE_STATE>
STATE* GxD3D11StateTable<STATE, DESC, CREATE_STATE>::get(const DESC& desc)
{
    const u32 hash = GxMath::getHash32(const_cast<DESC*>(&desc), sizeof(desc));
 
    for(u32 i = 0; i < _table.getCount(); i++)
    {
        auto* pEntry = static_cast<GxD3D11StateEntry*>(_table[i]);
        if( (pEntry->_hash == hash) && (GX_MEMCMP(&pEntry->_desc, &desc, sizeof(desc)) == 0) )
        {
            return pEntry->_pState;
        }
    }
 
    auto* pEntry = static_cast<GxD3D11StateEntry*>(GX_ALLOCATE_MEMORY(getGxAllocatorList(GxAllocatorList::ALLOCATOR_TYPE::RENDER), sizeof(GxD3D11StateEntry)));
    {
        pEntry->_hash = hash;
        pEntry->_desc = desc;
        (getGxRenderDevice()->getDevice()->*CREATE_STATE)(&pEntry->_desc, &pEntry->_pState);
    }
    _table.addBottom(pEntry);
    return pEntry->_pState;
}
#endif //GX_USE_DX11
 
//===========================================================================
//===========================================================================
#if GX_USE_DX11 || GX_USE_DX12
#if defined(_DEBUG)
extern HRESULT __GxCheckDXResult(GX_CSTR file, const s32 sline, GX_CSTR expression, HRESULT result);
#define GX_CHECK_DX_RESULT(expression) __GxCheckDXResult(__FILE__, __LINE__, #expression, (expression))
#else // _DEBUG
#define GX_CHECK_DX_RESULT(expression) (expression)
#endif // !_DEBUG
#endif // GX_USE_DX11 || GX_USE_DX12
 
GX_CORE_NAMESPACE_END()
 
#include "GxRenderDevice.inl"