GxRenderDevice.inl

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
#include "GxRenderVertexBuffer.h"
#include "GxRenderIndexBuffer.h"
#include "GxRenderVertexDeclaration.h"
#include "GxRenderVertexShader.h"
#include "GxRenderPixelShader.h"
#include "GxRenderHullShader.h"
#include "GxRenderDomainShader.h"
#include "GxRenderComputeShader.h"
#include "GxRenderTexture.h"
 
GX_CORE_NAMESPACE_BEGIN()
 
//===========================================================================
//===========================================================================
class GxRenderDevice::GxVramAllocator : public GxClassBase, public SingletonBase<GxVramAllocator>
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GX_RTTI_ABSTRACT_CLASS(GxVramAllocator, GxClassBase)
    // ClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxVramAllocator);
    // new, delete定義
    GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::RENDER)
 
    friend class GxRenderDevice;
    static const u32 BLOCK_COUNT_MAX = 102400;          
 
    struct GxBlock
    {
        void*               _pAddress;                      
        size_t              _size;                          
        GxBlock*            _pNext;                         
        GxBlock*            _pPrevious;                     
#if defined(_WINDOWS) || defined(_XBOX_XS)
        void*               _pObject;                       
#endif //_WINDOWS || _XBOX_XS
    };
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GxVramAllocator(void);
 
protected:
    virtual b32 initialize(void* pLocalMemory, size_t localMemorySize, void* pMainMemory, size_t mainMemorySize, u32 maxBlockCount = BLOCK_COUNT_MAX);
 
    virtual void terminate(void);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
#if GX_DEVELOP
public:
    void mapMemoryBlockInfo(void** ppTopLocal, void** ppTopMain, GxBlock** ppAllocatedBlockTop, GxBlock** ppFreeBlockTopLocal, GxBlock** ppFreeBlockTopMain);
 
    void unmapMemoryBlockInfo(void);
 
    b32 isMainMemory(const void* pAddress);
 
protected:
    static GxGuiBase* createGui(GxProperty& property, GxTypedObject* pOwner, const GxRtti& rtti, u32 index);
#endif //GX_DEVELOP
 
public:
    void*                       allocateLocal(u32 size, GxMemory::ALIGNMENT alignment = GxMemory::ALIGNMENT::_16);
    void*                       allocateMain(u32 size, GxMemory::ALIGNMENT alignment = GxMemory::ALIGNMENT::_16);
 
    void                        free(void* pAddress);
 
private:
    void* allocateMemory(u32 size, GxMemory::ALIGNMENT alignment, GxBlock*& pFreeBlockTop);
    void                        freeMemory(GxBlock* pBlock, GxBlock*& pFreeBlockTop);
    void                        pushUnusedBlock(GxBlock* pBlock);
    GxBlock* popUnusedBlock(void);
    void                        connectUsedBlock(GxBlock* pBlock);
    void                        disconnectUsedBlock(GxBlock* pBlock);
    void                        connectBlock(GxBlock* pBlock, GxBlock* pPrevious);
    void                        mergePreviousBlock(GxBlock* pBlock, GxBlock*& pTop);
    void                        mergeNextBlock(GxBlock* pBlock);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_FORCE_INLINE void            getPropertyFreeBlockCount(void* const pValue) { *static_cast<u32*>(pValue) = getFreeMemoryBlockCount(); }
 
    GX_FORCE_INLINE void            getPropertyLocalMemorySize(void* const pValue) { *static_cast<f64*>(pValue) = static_cast<f64>(getLocalMemorySize()) / GxMath::VALUE_1M; }
    GX_FORCE_INLINE void            getPropertyMainMemorySize(void* const pValue) { *static_cast<f64*>(pValue) = static_cast<f64>(getMainMemorySize()) / GxMath::VALUE_1M; }
 
    GX_FORCE_INLINE void            getPropertyUsedLocalMemorySize(void* const pValue) { *static_cast<f64*>(pValue) = static_cast<f64>(getLocalMemorySize() - getFreeLocalMemorySize()) / GxMath::VALUE_1M; }
    GX_FORCE_INLINE void            getPropertyUsedMainMemorySize(void* const pValue) { *static_cast<f64*>(pValue) = static_cast<f64>(getMainMemorySize() - getFreeMainMemorySize()) / GxMath::VALUE_1M; }
 
    GX_FORCE_INLINE void            getPropertyHighLocalMemorySize(void* const pValue) { *static_cast<f64*>(pValue) = static_cast<f64>(getTotalAllocatedHighLocalMemorySize()) / GxMath::VALUE_1M; }
    GX_FORCE_INLINE void            getPropertyHighMainMemorySize(void* const pValue) { *static_cast<f64*>(pValue) = static_cast<f64>(getTotalAllocatedHighMainMemorySize()) / GxMath::VALUE_1M; }
 
    GX_FORCE_INLINE void            getPropertyAllocMaxLocalMemorySize(void* const pValue) { *static_cast<f64*>(pValue) = static_cast<f64>(_localMemoryAllocMaxSize) / GxMath::VALUE_1M; }
    GX_FORCE_INLINE void            getPropertyAllocMaxMainMemorySize(void* const pValue) { *static_cast<f64*>(pValue) = static_cast<f64>(_mainMemoryAllocMaxSize) / GxMath::VALUE_1M; }
 
    GX_FORCE_INLINE void            resetMainDevelopInfo(void) { _pMainMemoryLast = _pMainMemoryTop; _mainMemoryAllocMaxSize = 0; }
    GX_FORCE_INLINE void            resetLocalDevelopInfo(void) { _pLocalMemoryLast = _pLocalMemoryTop; _localMemoryAllocMaxSize = 0; }
 
    GX_FORCE_INLINE size_t      getLocalMemorySize(void) const { return _localMemorySize; }
    GX_FORCE_INLINE size_t      getMainMemorySize(void) const { return _mainMemorySize; }
 
    size_t                      getFreeLocalMemorySize(void);
    size_t                      getFreeMainMemorySize(void);
 
    size_t                      getTotalAllocatedHighLocalMemorySize(void);
    size_t                      getTotalAllocatedHighMainMemorySize(void);
 
    u32                         getFreeMemoryBlockCount(void);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
private:
    u32                 _maxBlockCount;                 
    void*               _pLocalMemoryTop;               
    size_t              _localMemorySize;               
    void*               _pMainMemoryTop;                
    size_t              _mainMemorySize;                
    GxBlock*            _block;                         
    GxBlock*            _pAllocatedBlockTop;            
    GxBlock*            _pFreeBlockTopLocal;            
    GxBlock*            _pFreeBlockTopMain;             
    GxBlock*            _pUnusedBlockTop;               
    GxCriticalSection   _criticalSection;               
    void*               _pLocalMemoryLast;              
    void*               _pMainMemoryLast;               
    size_t              _localMemoryAllocMaxSize;       
    size_t              _mainMemoryAllocMaxSize;        
 
};
 
//===========================================================================
//===========================================================================
class GxRenderDevice::GxRawAllocator : public GxClassBase
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GX_RTTI_CLASS(GxRawAllocator, GxClassBase)
    // ClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxRawAllocator);
    // new, delete定義
    GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::RENDER)
 
    friend class GxRenderDevice;
    static const u32    BLOCK_COUNT_MAX = 102400;           
 
    struct GxBlock
    {
        void*       _pAddress;  
        size_t      _size;      
        GxBlock*    _pNext;     
        GxBlock*    _pPrevious; 
    };
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GxRawAllocator(void);
 
protected:
    b32 initialize(void* pMemory, size_t memorySize, u32 maxBlockCount, void* pUserData = nullptr);
 
    void terminate(void);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
#if GX_DEVELOP
public:
    void mapMemoryBlockInfo(void** ppTopLocal, GxBlock** ppAllocatedBlockTop, GxBlock** ppFreeBlockTopLocal);
 
    void unmapMemoryBlockInfo(void);
#endif //GX_DEVELOP
 
    void* allocate(u32 size, GxMemory::ALIGNMENT alignment = GxMemory::ALIGNMENT::_16);
    void free(void* pAddress);
 
private:
    void* allocateMemory(u32 size, GxMemory::ALIGNMENT alignment, GxBlock*& pFreeBlockTop);
    void freeMemory(GxBlock* pBlock, GxBlock*& pFreeBlockTop);
    void pushUnusedBlock(GxBlock* pBlock);
    GxBlock* popUnusedBlock(void);
    void connectUsedBlock(GxBlock* pBlock);
    void disconnectUsedBlock(GxBlock* pBlock);
    void connectBlock(GxBlock* pBlock, GxBlock* pPrevious);
    void mergePreviousBlock(GxBlock* pBlock, GxBlock*& pTop);
    void mergeNextBlock(GxBlock* pBlock);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_FORCE_INLINE void getPropertyMemorySize(void* const pValue) { *static_cast<u64*>(pValue) = static_cast<u64>(getMemorySize()); }
    GX_FORCE_INLINE void getPropertyUsedMemorySize(void* const pValue) { *static_cast<u64*>(pValue) = static_cast<u64>(getMemorySize() - getFreeMemorySize()); }
    GX_FORCE_INLINE void getPropertyFreeBlockCount(void* const pValue) { *static_cast<u32*>(pValue) = getFreeMemoryBlockCount(); }
    GX_FORCE_INLINE void getPropertyHighMemorySize(void* const pValue) { *static_cast<u64*>(pValue) = static_cast<u64>(getTotalAllocatedHighMemorySize()); }
    GX_FORCE_INLINE void getPropertyAllocMaxMemorySize(void* const pValue) { *static_cast<u64*>(pValue) = static_cast<u64>(_memoryAllocMaxSize); }
    GX_FORCE_INLINE void resetDevelopInfo(void) { _pMemoryLast = _pMemoryTop; _memoryAllocMaxSize = 0; }
 
    GX_FORCE_INLINE size_t getMemorySize(void) const { return _memorySize; }
    GX_FORCE_INLINE void* getUserData(void) const { return _pUserData; }
    size_t getFreeMemorySize(void);
    size_t getTotalAllocatedHighMemorySize(void);
    u32 getFreeMemoryBlockCount(void);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
private:
    u32                 _maxBlockCount;         
    void*               _pMemoryTop;            
    void*               _pUserData;             
    size_t              _memorySize;            
    GxBlock*            _pBlock;                
    GxBlock*            _pAllocatedBlockTop;    
    GxBlock*            _pFreeBlockTop;         
    GxBlock*            _pUnusedBlockTop;       
    GxCriticalSection   _criticalSection;       
    void*               _pMemoryLast;           
    size_t              _memoryAllocMaxSize;    
 
};
 
//---------------------------------------------------------------------------
// ハンドルからテクスチャを取得
//---------------------------------------------------------------------------
GxRenderTexture* GxRenderDevice::getTextureByHandle(GX_HANDLE handle) const
{
    if (handle == GX_INVALID_HANDLE)
    {
        return nullptr;
    }
    else
    {
        if (RENDER_TEXTURE_COUNT_MAX <= handle)
        {
            GX_ERROR(false, "無効なテクスチャハンドルが指定されました");
            return nullptr;
        }
        return _pTextureList[handle];
    }
}
 
//---------------------------------------------------------------------------
// 1メッシュに使用する最大のジョイント数
//---------------------------------------------------------------------------
u32 GxRenderDevice::getMaxSkinningJointCount()
{
    return _maxSkinningJointCount;
}
 
//---------------------------------------------------------------------------
// 描画リソース登録
//---------------------------------------------------------------------------
b32 GxRenderDevice::registerRenderResource(GxRenderResource* pRenderResource)
{
    if (_pRenderResourceRegister)
    {
        return _pRenderResourceRegister->registerRenderResource(pRenderResource);
    }
    return false;
}
 
//---------------------------------------------------------------------------
// 描画リソース解除
//---------------------------------------------------------------------------
b32 GxRenderDevice::unregisterRenderResource(GxRenderResource* pRenderResource)
{
    if (_pRenderResourceRegister)
    {
        return _pRenderResourceRegister->unregisterRenderResource(pRenderResource);
    }
    return false;
}
 
//---------------------------------------------------------------------------
// パケットバッファブロックを確保
//---------------------------------------------------------------------------
void* GxRenderDevice::allocatePacketBlock(void)
{
    return GX_ALLOCATE_MEMORY_TYPE(_pAllocatorContext, static_cast<s32>(GxAllocatorFrame::ALLOCATE_TYPE::HEAD), PACKET_BLOCK_SIZE);
}
 
//---------------------------------------------------------------------------
// コマンドバッファブロックを確保
//---------------------------------------------------------------------------
void* GxRenderDevice::allocateCommandBlock(void)
{
    return GX_ALLOCATE_MEMORY_TYPE(_pAllocatorContext, static_cast<s32>(GxAllocatorFrame::ALLOCATE_TYPE::TAIL), COMMAND_BLOCK_SIZE);
}
 
//---------------------------------------------------------------------------
// コマンドバッファメモリから確保
//---------------------------------------------------------------------------
void* GxRenderDevice::allocateCommandBufferMemory(u32 size)
{
    return GX_ALLOCATE_MEMORY_TYPE(_pAllocatorContext, static_cast<s32>(GxAllocatorFrame::ALLOCATE_TYPE::TAIL), size);
}
 
//---------------------------------------------------------------------------
//  ビューポートの設定
//---------------------------------------------------------------------------
void GxRenderDevice::setViewportNoCache(const GxViewportData& viewportData)
{
    setViewportNoCache(viewportData._rect, viewportData._nearZ, viewportData._farZ);
}
 
//---------------------------------------------------------------------------
//  描画ステートの設定
//---------------------------------------------------------------------------
void GxRenderDevice::setRenderState(RENDER_STATE renderState, u32 value)
{
    GX_ASSERT((0 <= static_cast<s32>(renderState)) && (static_cast<s32>(renderState) < static_cast<s32>(RENDER_STATE::MAX)), "無効な描画ステートを設定しようとしました(renderState:%d value:%d)", renderState, value);
 
    if( _renderStateValueNow[static_cast<s32>(renderState)] != value)
    {
        setRenderStateNoCache(renderState, value);
    }
}
 
//---------------------------------------------------------------------------
//  Zテストステートの設定
//---------------------------------------------------------------------------
void GxRenderDevice::setDepthTestState(GxRenderDepthTestState state)
{
    if( _depthTestStateNow._access32 != state._access32 )
    {
        setDepthTestStateNoCache(state);
    }
}
 
//---------------------------------------------------------------------------
//  ステンシルテストステートの設定
//---------------------------------------------------------------------------
void GxRenderDevice::setStencilTestState(GxRenderStencilTestState state, u32 stencilRef, b32 stencilTwoSideEnable)
{
    if (_stencilTestStateNow._access64 != state._access64 || _stencilRefNow != stencilRef || _stencilTwoSideEnableNow != stencilTwoSideEnable )
    {
        setStencilTestStateNoCache(state, stencilRef, stencilTwoSideEnable);
    }
}
 
//---------------------------------------------------------------------------
//  アルファテストステートの設定
//---------------------------------------------------------------------------
void GxRenderDevice::setAlphaTestState(GxRenderAlphaTestState state)
{
    if( _alphaTestStateNow._access32 != state._access32 )
    {
        setAlphaTestStateNoCache(state);
    }
}
 
//---------------------------------------------------------------------------
//  ブレンドステートの設定
//---------------------------------------------------------------------------
void GxRenderDevice::setBlendState(GxRenderBlendState state)
{
    if( _blendStateNow._access32 != state._access32 )
    {
        setBlendStateNoCache(state);
    }
}
 
//---------------------------------------------------------------------------
//  ビューポートの設定
//---------------------------------------------------------------------------
void GxRenderDevice::setViewport(const GxViewportData& viewportData)
{
    if( (_viewportDataNow._nearZ != viewportData._nearZ) || (_viewportDataNow._farZ != viewportData._farZ) || (_viewportDataNow._rect != viewportData._rect) )
    {
        setViewportNoCache(viewportData);
    }
}
 
//---------------------------------------------------------------------------
//  シザリング矩形の設定
//---------------------------------------------------------------------------
void GxRenderDevice::setScissorRect(const GxRect& rect)
{
    if( _scissorRectNow != rect )
    {
        setScissorRectNoCache(rect);
    }
}
 
//---------------------------------------------------------------------------
//  頂点ストリームの設定
//---------------------------------------------------------------------------
void GxRenderDevice::setVertexStream(u32 slot, const GxVertexStream* pVertexStream)
{
    if( RENDER_VERTEX_STREAM_COUNT_MAX <= slot)
    {
        GX_ERROR(false, "最大ストリーム数を超えるスロットに頂点バッファをセットしようとしました(slot:%d, max:%d)", slot, RENDER_VERTEX_STREAM_COUNT_MAX);
    }
    else
    {
#if defined(_WINDOWS) || defined(_XBOX_XS)
        if ((_vertexStreamNow[slot]._access64 != pVertexStream->_access64) || (_instanceCountNow[slot] != 0))
#else //_WINDOWS || _XBOX_XS
        if ((_vertexStreamNow[slot]._access64 != pVertexStream->_access64))
#endif // !(_WINDOWS || _XBOX_XS)
        {
            setVertexStreamNoCache(slot, pVertexStream);
        }
    }
}
 
#if defined(_WINDOWS) || defined(_XBOX_XS)
//---------------------------------------------------------------------------
//  頂点ストリームの設定
//---------------------------------------------------------------------------
void GxRenderDevice::setVertexStream(u32 slot, const GxVertexStream* pVertexStream, u32 instanceCount)
{
    if( RENDER_VERTEX_STREAM_COUNT_MAX <= slot)
    {
        GX_ERROR(false, "最大ストリーム数を超えるスロットに頂点バッファをセットしようとしました(slot:%d, max:%d)", slot, RENDER_VERTEX_STREAM_COUNT_MAX);
    }
    else if( (_vertexStreamNow[slot]._access64 != pVertexStream->_access64) || (_instanceCountNow[slot] != instanceCount) )
    {
        setVertexStreamNoCache(slot, pVertexStream, instanceCount);
    }
}
#endif  // _WINDOWS || _XBOX_XS
 
//---------------------------------------------------------------------------
//  インデックスバッファの設定
//---------------------------------------------------------------------------
void GxRenderDevice::setIndexBuffer(GxRenderIndexBuffer* pIndexBuffer)
{
    if( _pIndexBufferNow != pIndexBuffer )
    {
        setIndexBufferNoCache(pIndexBuffer);
    }
}
 
//---------------------------------------------------------------------------
//  頂点宣言の設定
//---------------------------------------------------------------------------
void GxRenderDevice::setVertexDeclaration(GxRenderVertexDeclaration* pVertexDeclaration)
{
    if( _pVertexDeclarationNow != pVertexDeclaration )
    {
        setVertexDeclarationNoCache(pVertexDeclaration);
    }
}
 
//---------------------------------------------------------------------------
// シェーダの設定
//---------------------------------------------------------------------------
void GxRenderDevice::setShader(RENDER_SHADER renderShader, GxRenderShader* pShader)
{
    if( _pShaderNow[static_cast<u32>(renderShader)] != pShader)
    {
        setShaderNoCache(renderShader, pShader);
    }
}
 
//---------------------------------------------------------------------------
// シェーダ定数の設定
//---------------------------------------------------------------------------
#if defined(_NX64)
void GxRenderDevice::setShaderConstantB(RENDER_SHADER renderShader, u32 startRegister, const b32* pBooleanArray, u32 count, u32 bindLocationIndex)
#else //_NX64
void GxRenderDevice::setShaderConstantB(RENDER_SHADER /*renderShader*/, u32 /*startRegister*/, const b32* pBooleanArray, u32 count)
#endif // !_NX64
{
    if (pBooleanArray && (count != 0))
    {
#if defined(_WINDOWS) || defined(_PS4) || defined(_XBOX_XS)
#if GX_USE_DX11 || GX_USE_DX12
        // TODO: DX11
#else //GX_USE_DX11 || GX_USE_DX12
        _pDirect3DDevice9->SetVertexShaderConstantB(startRegister, reinterpret_cast<const BOOL*>(pBooleanArray), count);
#endif  // !(GX_USE_DX11 || GX_USE_DX12)
#elif defined(_NX64)
        const u32 size = sizeof(b32) * count;
        GX_ASSERT(bindLocationIndex * sizeof(GxVector4) + size <= RENDER_UNIFORM_BLOCK_CONST_MAX, "シェーダの定数ブロック内レジスタ領域が足りません");
        auto* pBuffer = static_cast<GxVector4*>(_registerBlockInformation[static_cast<u32>(renderShader)][startRegister]._pBuffer);
        GX_MEMCPY(pBuffer + bindLocationIndex, pBooleanArray, size);
        _registerBlockInformation[static_cast<u32>(renderShader)][startRegister]._blockSize = GxMath::getMax(_registerBlockInformation[static_cast<u32>(renderShader)][startRegister]._blockSize, bindLocationIndex * static_cast<u32>(sizeof(GxVector4)) + size);
        _registerBlockInformationCount[static_cast<u32>(renderShader)] = GxMath::getMax(_registerBlockInformationCount[static_cast<u32>(renderShader)], startRegister + 1);
#endif //_NX64
    }
}
 
//---------------------------------------------------------------------------
// シェーダ定数の設定
//---------------------------------------------------------------------------
#if defined(_NX64)
void GxRenderDevice::setShaderConstantI(RENDER_SHADER renderShader, u32 startRegister, const s32* pIntArray, u32 count, u32 bindLocationIndex)
#else //_NX64
void GxRenderDevice::setShaderConstantI(RENDER_SHADER /*renderShader*/, u32 /*startRegister*/, const s32* pIntArray, u32 count)
#endif // !_NX64
{
    if (pIntArray && (count != 0))
    {
#if defined(_WINDOWS) || defined(_PS4) || defined(_XBOX_XS)
#if GX_USE_DX11 || GX_USE_DX12
        // TODO: DX11
#else //GX_USE_DX11 || GX_USE_DX12
        _pDirect3DDevice9->SetVertexShaderConstantI(startRegister, reinterpret_cast<const s32*>(pIntArray), count);
#endif  // !(GX_USE_DX11 || GX_USE_DX12)
#elif defined(_NX64)
        const u32 size = sizeof(s32) * count;
        GX_ASSERT(bindLocationIndex * sizeof(GxVector4) + size <= RENDER_UNIFORM_BLOCK_CONST_MAX, "シェーダの定数ブロック内レジスタ領域が足りません");
        auto* pBuffer = static_cast<GxVector4*>(_registerBlockInformation[static_cast<u32>(renderShader)][startRegister]._pBuffer);
        GX_MEMCPY(pBuffer + bindLocationIndex, pIntArray, size);
        _registerBlockInformation[static_cast<u32>(renderShader)][startRegister]._blockSize = GxMath::getMax(_registerBlockInformation[static_cast<u32>(renderShader)][startRegister]._blockSize, bindLocationIndex * static_cast<u32>(sizeof(GxVector4)) + size);
        _registerBlockInformationCount[static_cast<u32>(renderShader)] = GxMath::getMax(_registerBlockInformationCount[static_cast<u32>(renderShader)], startRegister + 1);
#endif //_NX64
    }
}
 
//---------------------------------------------------------------------------
// シェーダ定数の設定
//---------------------------------------------------------------------------
#if defined(_NX64)
void GxRenderDevice::setShaderConstantF(RENDER_SHADER renderShader, u32 startRegister, const f32* pFloatArray, u32 count, u32 bindLocationIndex)
#else //_NX64
void GxRenderDevice::setShaderConstantF(RENDER_SHADER renderShader, u32 startRegister, const f32* pFloatArray, u32 count)
#endif // !_NX64
{
    if( pFloatArray && (count != 0) )
    {
        if( RENDER_SHADER_CONST_MAX < startRegister + count )
        {
            GX_ERROR(false, "サポートするシェーダレジスタ数をオーバーしています。(start:%d count:%d)", startRegister, count);
        }
        else
        {
#if GX_USE_DX11
            if (_pShaderNow[static_cast<u32>(renderShader)])
            {
                _pShaderNow[static_cast<u32>(renderShader)]->writeConstantBuffer(startRegister, pFloatArray, count);
            }
#elif defined(_PS5) || GX_USE_DX12
            GX_MEMCPY(&_shaderConstSet[static_cast<u32>(renderShader)][startRegister], pFloatArray, sizeof(GxVector4) * count);
#elif defined(_NX64)
            const u32 size = sizeof(GxVector4) * count;
            GX_ASSERT(bindLocationIndex * sizeof(GxVector4) + size <= RENDER_UNIFORM_BLOCK_CONST_MAX, "シェーダの定数ブロック内レジスタ領域が足りません");
            auto* pBuffer = static_cast<GxVector4*>(_registerBlockInformation[static_cast<u32>(renderShader)][startRegister]._pBuffer);
            GX_MEMCPY(pBuffer + bindLocationIndex, pFloatArray, size);
            _registerBlockInformation[static_cast<u32>(renderShader)][startRegister]._blockSize = GxMath::getMax(_registerBlockInformation[static_cast<u32>(renderShader)][startRegister]._blockSize, bindLocationIndex * static_cast<u32>(sizeof(GxVector4)) + size);
            _registerBlockInformationCount[static_cast<u32>(renderShader)] = GxMath::getMax(_registerBlockInformationCount[static_cast<u32>(renderShader)], startRegister + 1);
#endif //_NX64
        }
    }
}
 
//---------------------------------------------------------------------------
//  テクスチャの設定
//---------------------------------------------------------------------------
void GxRenderDevice::setTexture(RENDER_SHADER renderShader, u32 samplerIndex, GxRenderTexture* pTexture, b32 isUav)
{
    if( RENDER_TEXTURE_SAMPLER_COUNT_MAX <= samplerIndex)
    {
        GX_ERROR(false, "最大サンプラ数を超えるサンプラにテクスチャをセットしようとしました(samplerIndex:%d, max:%d)", samplerIndex, RENDER_TEXTURE_SAMPLER_COUNT_MAX);
    }
    else
    {
        if (isUav)
        {
            if (_pSamplerUavNow[static_cast<u32>(renderShader)][samplerIndex] != pTexture)
            {
                setTextureNoCache(renderShader, samplerIndex, pTexture, true);
            }
        }
        else
        {
            if (_pSamplerNow[static_cast<u32>(renderShader)][samplerIndex] != pTexture)
            {
                setTextureNoCache(renderShader, samplerIndex, pTexture, false);
            }
        }
    }
}
 
//---------------------------------------------------------------------------
//  テクスチャサンプラの設定
//---------------------------------------------------------------------------
void GxRenderDevice::setSamplerState(RENDER_SHADER renderShader, u32 samplerIndex, GxRenderSamplerState state)
{
    if( RENDER_TEXTURE_SAMPLER_COUNT_MAX <= samplerIndex)
    {
        GX_ERROR(false, "最大サンプラ数を超えるサンプラにテクスチャをセットしようとしました(samplerIndex:%d, max:%d)", samplerIndex, RENDER_TEXTURE_SAMPLER_COUNT_MAX);
    }
    else
    {
        if (_samplerStateNow[static_cast<u32>(renderShader)][samplerIndex]._access32 != state._access32)
        {
            setSamplerStateNoCache(renderShader, samplerIndex, state);
        }
    }
}
 
//---------------------------------------------------------------------------
//  レンダーターゲットの設定
//---------------------------------------------------------------------------
void GxRenderDevice::setRenderTarget(u32 index, GxRenderTexture* pRenderTarget)
{
    GX_ASSERT(index<RENDER_TARGET_COUNT_MAX || !pRenderTarget, "サポート外のレンダーターゲットが指定されました(index:%d)", index);
 
    if( _pRenderTargetNow[index] != pRenderTarget )
    {
        setRenderTargetNoCache(index, pRenderTarget);
    }
}
 
//---------------------------------------------------------------------------
//  深度ステンシルの設定
//---------------------------------------------------------------------------
void GxRenderDevice::setDepthStencil(GxRenderTexture* pDepthStencil, b32 readOnly)
{
    if( _pDepthStencilNow != pDepthStencil || _isReadOnlyDepthStencilNow != readOnly)
    {
        setDepthStencilNoCache(pDepthStencil,readOnly);
    }
}
 
//---------------------------------------------------------------------------
//  プレディケーションの設定
//---------------------------------------------------------------------------
void GxRenderDevice::setPredication(const GxCommandSetPredication* pCommand)
{
    if( pCommand->_pFlag == nullptr )
    {
        _isInFailedPredication = false;
    }
    else
    {
        b32 value = false;
        {
            for(u32 i = 0; i < pCommand->_size; i++)
            {
                if( static_cast<const u8*>(pCommand->_pFlag)[i] )
                {
                    value = true;
                    break;
                }
            }
        }
        _isInFailedPredication = (value != pCommand->_value);
    }
}
 
//---------------------------------------------------------------------------
// メインメモリサイズ取得
//---------------------------------------------------------------------------
size_t GxRenderDevice::getMainMemorySize(void) const
{
    GX_ASSERT(_pVramAllocator, "VRAMアロケータが初期化されていません");
    return _pVramAllocator->getMainMemorySize(); 
}
 
//---------------------------------------------------------------------------
// 空きメインメモリサイズ取得
//---------------------------------------------------------------------------
size_t GxRenderDevice::getFreeMainMemorySize(void) const
{
    GX_ASSERT(_pVramAllocator, "VRAMアロケータが初期化されていません");
    return _pVramAllocator->getFreeMainMemorySize(); 
}
 
//---------------------------------------------------------------------------
// ローカルメモリサイズ取得
//---------------------------------------------------------------------------
size_t GxRenderDevice::getLocalMemorySize(void) const
{
    GX_ASSERT(_pVramAllocator, "VRAMアロケータが初期化されていません");
    return _pVramAllocator->getLocalMemorySize();
}
 
//---------------------------------------------------------------------------
// 空きローカルメモリサイズ取得
//---------------------------------------------------------------------------
size_t GxRenderDevice::getFreeLocalMemorySize(void) const
{
    GX_ASSERT(_pVramAllocator, "VRAMアロケータが初期化されていません");
    return _pVramAllocator->getFreeLocalMemorySize(); 
}
 
//---------------------------------------------------------------------------
// 最大到達ローカルメモリサイズ取得
//---------------------------------------------------------------------------
size_t GxRenderDevice::getTotalAllocatedHighLocalMemorySize(void) const
{
    GX_ASSERT(_pVramAllocator, "VRAMアロケータが初期化されていません");
    return _pVramAllocator->getTotalAllocatedHighLocalMemorySize(); 
}
 
//---------------------------------------------------------------------------
// 最大到達メインメモリサイズ取得
//---------------------------------------------------------------------------
size_t GxRenderDevice::getTotalAllocatedHighMainMemorySize(void) const
{
    GX_ASSERT(_pVramAllocator, "VRAMアロケータが初期化されていません");
    return _pVramAllocator->getTotalAllocatedHighMainMemorySize(); 
}
 
#if defined(_PS4) || defined(_PS5) || defined(_NX64)
//---------------------------------------------------------------------------
// ローカルメモリ確保
//---------------------------------------------------------------------------
void* GxRenderDevice::allocateLocal(u32 size, u32 alignment)
{
    GX_ASSERT(_pVramAllocator, "VRAMアロケータが初期化されていません");
 
    return _pVramAllocator->allocateLocal(size, static_cast<GxMemory::ALIGNMENT>(alignment));
}
 
//---------------------------------------------------------------------------
// メインメモリ確保
//---------------------------------------------------------------------------
void* GxRenderDevice::allocateMain(u32 size, u32 alignment)
{
    GX_ASSERT(_pVramAllocator, "VRAMアロケータが初期化されていません");
 
    return _pVramAllocator->allocateMain(size, static_cast<GxMemory::ALIGNMENT>(alignment));
}
 
//---------------------------------------------------------------------------
// メモリ解放
//---------------------------------------------------------------------------
void GxRenderDevice::free(void* pAddress)
{
    GX_ASSERT(_pVramAllocator, "VRAMアロケータが初期化されていません");
 
    _pVramAllocator->free(pAddress);
}
#endif //_PS4 || _PS5 || _NX64
 
#if defined(_NX64)
//---------------------------------------------------------------------------
// TexturePoolに登録
//---------------------------------------------------------------------------
u32 GxRenderDevice::registerTexturePool(GxNativeTexture* pTexture, GxNativeTextureView* pView)
{
    return _pTexturePoolManager->registerTexture(pTexture, pView);
}
 
//---------------------------------------------------------------------------
// TexturePoolに登録解除
//---------------------------------------------------------------------------
void GxRenderDevice::unregisterTexturePool(u32 id)
{
    _pTexturePoolManager->unregisterTexture(id);
}
 
//---------------------------------------------------------------------------
// SamplerPoolに登録
//---------------------------------------------------------------------------
u32 GxRenderDevice::registerSamplerPool(GxNativeSampler* pSampler)
{
    return _pTexturePoolManager->registerSampler(pSampler);
}
 
//---------------------------------------------------------------------------
// SamplerPoolに登録
//---------------------------------------------------------------------------
u32 GxRenderDevice::registerSamplerPool(GxNativeSamplerBuilder* pBuilder)
{
    return _pTexturePoolManager->registerSampler(pBuilder);
}
 
//---------------------------------------------------------------------------
// サンプラを作成
//---------------------------------------------------------------------------
u32 GxRenderDevice::createSampler(GxRenderSamplerState sampler)
{
    return _pTexturePoolManager->createSampler(sampler);
}
 
//---------------------------------------------------------------------------
// SamplerPoolから登録を解除
//---------------------------------------------------------------------------
void GxRenderDevice::unregisterSamplerPool(u32 id)
{
    _pTexturePoolManager->unregisterSampler(id);
}
 
#endif // _NX64
 
GX_CORE_NAMESPACE_END()