GxRenderContext.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_CORE_NAMESPACE_BEGIN()
 
class GxRenderVertexBuffer;
class GxRenderIndexBuffer;
class GxRenderVertexDeclaration;
class GxRenderVertexShader;
class GxRenderPixelShader;
class GxRenderTexture;
struct GxRenderVertexElement;
 
//===========================================================================
//===========================================================================
class GxRenderContext : public GxClassBase
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GX_RTTI_CLASS(GxRenderContext, GxClassBase)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxRenderContext)
    // new, delete定義
    GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::RENDER)
 
    friend class GxSysRenderBase;
    friend class GxRenderDevice;
 
private:
    enum class PARAMETER_TYPE
    {
        TEXTURE,            
        VECTOR,             
        VECTOR_ARRAY,       
        MATRIX,             
        MATRIX_ARRAY,       
        BOOLEAN,            
        INT4,               
        MAX,                
    };
 
    struct GxParameter
    {
        PARAMETER_TYPE  _type;      
        u32             _size;      
        void*           _pBuffer;   
    };
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GxRenderContext(void);
 
protected:
    b32 initialize(void);
 
    void terminate(void);
 
    b32 initializeThreadLocalStorage(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
#if defined(GX_THREAD_LOCAL_STORAGE)
    GX_FORCE_INLINE static GxRenderContext* getContext(void) { return _pContext; }
#else //GX_THREAD_LOCAL_STORAGE
    GX_FORCE_INLINE static GxRenderContext* getContext(void) { return _pContext[GxThread::getCurrentThread()->getIndex()]; }
#endif // !GX_THREAD_LOCAL_STORAGE
    constexpr u32 getPacketCount(void) const { return _packetCount; }
 
    GX_FORCE_INLINE void            setView(RENDER_VIEW view);
    constexpr RENDER_VIEW           getView(void) const { return static_cast<RENDER_VIEW>(_priority._view); }
 
    GX_FORCE_INLINE void            setSubView(RENDER_SUB_VIEW subView);
    constexpr RENDER_SUB_VIEW       getSubView(void) const { return static_cast<RENDER_SUB_VIEW>(_priority._subView); }
 
    GX_FORCE_INLINE void            setPass(RENDER_PASS pass);
    constexpr RENDER_PASS           getPass(void) const { return static_cast<RENDER_PASS>(_priority._pass); }
 
    GX_FORCE_INLINE void            setSubPriority(u32 subPriority);
    GX_FORCE_INLINE void            setSubPriorityF32(f32 subPriority);
    constexpr u32                   getSubPriority(void) const { return _priority._subPriority; }
 
    void                    setRenderState(RENDER_STATE renderState, u32 value);
    void                    setDepthTestState(GxRenderDepthTestState state);
    void                    setStencilTestState(GxRenderStencilTestState state, u32 stencilRef, b32 stencilTwoSideEnable);
    void                    setAlphaTestState(GxRenderAlphaTestState state);
    void                    setBlendState(GxRenderBlendState state);
    void                    setViewport(const GxRect& rect, f32 nearZ, f32 farZ);
    void                    setScissorRect(const GxRect& rect);
    void                    setTexture(GX_HANDLE handle, GxRenderTexture* pTexture);
    void                    setSamplerState(GX_HANDLE handle, GxRenderSamplerState state);
    void                    setVector(GX_HANDLE handle, const GxVector4& vector);
    GxVector4*              setVectorArray(GX_HANDLE handle, u32 count);
    void                    setMatrix44(GX_HANDLE handle, const GxMatrix44Gpu& matrix);
    void                    setMatrixAffine(GX_HANDLE handle, const GxMatrixAffineGpu& matrix);
    GxMatrix44Gpu*          setMatrix44Array(GX_HANDLE handle, u32 count);
    GxMatrixAffineGpu*      setMatrixAffineArray(GX_HANDLE handle, u32 count);
    void                    setBoolean(GX_HANDLE handle, b32 boolean);
    void                    setInt4(GX_HANDLE handle, const s32 int4[4]);
    GX_FORCE_INLINE void    setVertexStream(u32 slot, GxRenderVertexBuffer* pVertexBuffer, u32 offset, u32 stride, RENDER_STREAM_FREQUENCY_TYPE frequencyType = RENDER_STREAM_FREQUENCY_TYPE::INDEXED);
    GX_FORCE_INLINE void    setIndexBuffer(GxRenderIndexBuffer* pIndexBuffer);
    GX_FORCE_INLINE void    setVertexDeclaration(GxRenderVertexDeclaration* pVertexDeclaration);
 
    GX_FORCE_INLINE void    setShader(RENDER_SHADER renderShader, GxRenderShader* pShader);
 
    void                    setRenderTarget(u32 index, GxRenderTexture* pRenderTarget, b32 forceRenderToTexture = false);
    void                    setDepthStencil(GxRenderTexture* pDepthStencil, b32 readOnly = false);
    
    void                    forceDrawState(void);
 
    void            setCallback(GxCallback::GxHandlerBase handle, void* pSource, void* pArgument);
    void            setCallback(GxCallback::GxHandlerBase handle, void* pSource, u32 srcSize, void* pArgument, u32 argumentSize);
    void            setCallbackAsync(GxCallback::GxHandlerBase handle, void* pSource, void* pArgument);
 
    void            setPredication(void* pFlag, u32 size, b32 value);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    void            draw(RENDER_PRIMITIVE_TYPE type, u32 startVertex, u32 vertexCount);
    void            drawIndexed(RENDER_PRIMITIVE_TYPE type, s32 baseVertexIndex, u32 minIndex, u32 vertexCount, u32 startIndex, u32 indexCount, u32 instanceCount = 0, s32* pQueryIndex = nullptr);
    void            drawMemory(RENDER_PRIMITIVE_TYPE type, u32 vertexCount, const void* pVertex, u32 vertexStride);
    void            drawIndexedMemory(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
    void            dispatch(u32 threadGroupCountX, u32 threadGroupCountY, u32 threadGroupCountZ);
#endif //GX_ENABLE_COMPUTE_SHADER
#if GX_ENABLE_OCCLUSION_CULLING
    void resolveOcclusionQuery(void);
#endif //GX_ENABLE_OCCLUSION_CULLING
 
    void            clear(u32 clearFlags, const GxColor clearColor, f32 clearZ, u32 clearStencil);
    void            clearHDR(u32 clearFlags, const GxColorHDR& clearColor, f32 clearZ, u32 clearStencil);
 
#if GX_ENABLE_HTILE_STENCIL_MASK
    void            maskHtileStencilRegion(GxRenderComputeShader* pComputeShader, GxRenderTexture* pDepthStencil, f32 outTan, f32 inTan, f32 topTan, f32 bottomTan, f32 cutOff, f32 cutOut);
#endif // GX_ENABLE_HTILE_STENCIL_MASK
 
    void            copyRenderTargetToTexture(u32 index = 0, GxRenderTexture* pTexture = nullptr, u32 dstMipLevel = 0, const GxRect* pSrcRect = nullptr, const GxPoint2* pDstPoint = nullptr);
    void            copyDepthStencilToTexture(GxRenderTexture* pTexture = nullptr, u32 dstMipLevel = 0, const GxRect* pSrcRect = nullptr, const GxPoint2* pDstPoint = nullptr);
    void            copyRenderTargetToTextureStretch(u32 index = 0, GxRenderTexture* pTexture = nullptr, u32 dstMipLevel = 0, const GxRect* pSrcRect = nullptr, const GxRect* pDstRect = nullptr);
    void            copyDepthStencilToTextureStretch(GxRenderTexture* pTexture = nullptr, u32 dstMipLevel=0, const GxRect* pSrcRect = nullptr, const GxRect* pDstRect = nullptr);
    void            copyRenderTargetToTextureWithMipmap(u32 index = 0, GxRenderTexture* pTexture = nullptr);
 
    void assembleFinalVrImage(void* pPacket, u32 packetSize);
 
    GX_FORCE_INLINE void doNotSkipThisFrame(void) { _doNotSkipThisFrame = true; }
    GX_FORCE_INLINE b32 canNotSkipThisFrame(void) const { return _doNotSkipThisFrame; }
 
#if defined(_NX64)
    void setTiledCacheAction(GxNativeTiledCacheAction action);
    void setTiledCacheTileSize(s32 width, s32 height);
 
    void saveZCullData(void);
    void restoreZCullData(void);
#endif //_NX64
 
#if GX_DEVELOP
    void            beginMarker(GX_CSTR name);
    void            endMarker(GX_CSTR name);
#else //GX_DEVELOP
    constexpr void beginMarker(GX_CSTR /*name*/) {}
    constexpr void endMarker(GX_CSTR /*name*/) {}
#endif  // !GX_DEVELOP
 
    void            flushGpuCommandBuffer(void);
 
private:
    void                        reset(void);
 
    GX_FORCE_INLINE void*       setParameter(GxParameter& parameter, PARAMETER_TYPE type, u32 size);
    GX_FORCE_INLINE void        sendPacket(void* pCommand);
    void*                       sendDrawCommandCommonInfo(void* pData);
    void                        sendRegister(RENDER_SHADER renderShader, GxRenderDevice::GxRegisterSet* pRegisterSet);
    void                        sendRegisterSetBool(GxRenderShader* pShader, GxRenderDevice::GxRegisterInformation* pInformation);
    void                        sendRegisterSetInt4(GxRenderShader* pShader, GxRenderDevice::GxRegisterInformation* pInformation);
    void                        sendRegisterSetGxFloat4(GxRenderShader* pShader, GxRenderDevice::GxRegisterInformation* pInformation);
    void                        sendRegisterSetSampler(GxRenderShader* pShader, GxRenderDevice::GxRegisterInformation* pInformation);
 
    GX_FORCE_INLINE void*       allocCommand(GxRenderDevice::COMMAND_TYPE type, u32 size);
    GX_FORCE_INLINE void*       allocParameter(u32 size);
    GX_FORCE_INLINE GxRenderDevice::GxRegisterInformation*  allocRegisterInfo(u32 count);
 
    void                        buildPacket(void* pPacketBuffer);
    void                        mergeSort(GxRenderDevice::GxPacket* pDst, GxRenderDevice::GxPacket* pSrc, s32 left, s32 right);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
private:    
    u32                         _packetCount;       
 
    GxRenderDevice::GxPacket*   _pPacketTop;        
    GxRenderDevice::GxPacket*   _pPacketBlock;      
    u32                         _packetCountBlock;  
 
    void*                       _pCommandBlock;     
    u32                         _commandSizeBlock;  
 
    GxRenderDevice::GxDrawCommandCommonInformation  _drawCommandCommonInfo;                     
    GxRenderDevice::GxVertexStream              _vertexStream[RENDER_VERTEX_STREAM_COUNT_MAX];  
    GxRenderIndexBuffer*        _pIndexBuffer;      
#if GX_ENABLE_COMPUTE_SHADER
    GxRenderShader*             _pComputeShader;    
#endif //GX_ENABLE_COMPUTE_SHADER
    GxParameter*                _pParameter;        
 
    GxRenderDevice::GxPriority::GxPriorityUnion _priority;  
 
    b32                         _doNotSkipThisFrame;        
 
#if defined(GX_THREAD_LOCAL_STORAGE)
    static GX_THREAD_LOCAL_STORAGE GxRenderContext* _pContext;      
#else //GX_THREAD_LOCAL_STORAGE
    static GxRenderContext* _pContext[GxThread::THREAD_MAX];        
#endif // !GX_THREAD_LOCAL_STORAGE
#if GX_DEVELOP
    GxRenderDevice::GxPerformanceCounterView    _performanceCounter[static_cast<s32>(RENDER_VIEW::MAX)];    
    GxRenderDevice::GxPerformanceCounter*       _pPerformanceCounter;                                       
#endif  // GX_DEVELOP
 
};
 
// アクセスインターフェース
GX_FORCE_INLINE GxRenderContext* getGxRenderContext(void) { return GxRenderContext::getContext(); }
 
GX_CORE_NAMESPACE_END()
 
#include "GxRenderContext.inl"