GxPrimitiveManager.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_CORE_NAMESPACE_BEGIN()
 
class GxPrimitiveContext;
class GxPrimitiveModel;
//===========================================================================
//===========================================================================
class GxPrimitiveManager : public GxClassBase
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS(GxPrimitiveManager, GxClassBase)
    // GxClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxPrimitiveManager)
    // new, delete定義
    GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::RENDER)
 
    friend class GxPrimitiveContext;
 
    struct GxCustomShaderCallbackParam
    {
        GxRenderVertexShader*       _pVertexShader2D;               
        GxRenderVertexShader*       _pVertexShader3D;               
        GxRenderPixelShader*        _pPixelShader;                  
        GxRenderPixelShader*        _pPixelShaderTexture;           
        GxRenderPixelShader*        _pPixelShaderAlphatest;         
        GxRenderPixelShader*        _pPixelShaderTexRefAlphatest;   
#if GX_DEVELOP
        GxRenderPixelShader*        _pPixelShaderTextureGradation;  
#endif //GX_DEVELOP
    };
 
    enum class RENDER_TYPE
    {
        _2D,            
        _3D,            
        _2D_VIRTUAL,    
    };
 
    static constexpr u32    DRAW_LIST_MAX_VERTEX_NUM = GxMath::VALUE_1K;
 
protected:
    enum class COMMAND_TYPE
    {
        NOP,                        
        SET_SCREEN_SIZE,            
        SET_SCISSOR_RECT,           
        SET_RENDER_TARGET,          
        COPY_RENDER_TARGET_TO_TEXTURE,  
        CLEAR,                      
        LINELIST_2D,                
        LINESTRIP_2D,               
        TRIANGLELIST_2D,            
        TRIANGLESTRIP_2D,           
        TRIANGLEFAN_2D,             
        QUADLIST_2D,                
        LINELIST_3D,                
        LINESTRIP_3D,               
        TRIANGLELIST_3D,            
        TRIANGLESTRIP_3D,           
        TRIANGLEFAN_3D,             
        QUADLIST_3D,                
        CUSTOM_2D,                  
        CUSTOM_3D,                  
        MAX,                        
    };
 
    GX_ALIGN16_BEGIN struct GxCommandDraw
    {
        GxPrimitiveMaterial             _material;          
        GxVector3                       _priorityPoint;     
        u32                             _vertexCount;       
        GxPrimitiveVertex*              _pVertex;           
    } GX_ALIGN16_END;
 
    GX_ALIGN16_BEGIN struct GxCommandSetScreenSize
    {
        GxSize                      _size;              
    } GX_ALIGN16_END;
 
    GX_ALIGN16_BEGIN struct GxCommandSetScissor
    {
        GxRect                      _rect;              
    } GX_ALIGN16_END;
 
    GX_ALIGN16_BEGIN struct GxCommandSetRenderTarget
    {
        GxRenderTexture*            _pRenderTarget;     
    } GX_ALIGN16_END;
 
    GX_ALIGN16_BEGIN struct GxCommandCopyRenderTargetToTexture
    {
        u16                 _index;         
        u16                 _dstMipLevel;   
        GxRenderTexture*    _pTexture;      
        const GxRect*       _pSrcRect;      
        GxRect              _srcRect;       
        GxPoint2            _dstPoint;      
    } GX_ALIGN16_END;
 
    GX_ALIGN16_BEGIN struct GxCommandClear
    {
        GxColor             _color;         
    } GX_ALIGN16_END;
 
    GX_ALIGN16_BEGIN struct GxPacket
    {
        GxPrimitiveManager::COMMAND_TYPE _type; 
        u32             _priority;              
        u32             _viewFlag;              
        void*           _pCommand;              
    } GX_ALIGN16_END;
 
private:
    static constexpr u32            PACKET_BLOCK_SIZE = sizeof(GxPacket) * GxMath::VALUE_256;
    static constexpr u32            COMMAND_BLOCK_SIZE = sizeof(GxCommandDraw) * GxMath::VALUE_256;
    static constexpr u32            VERTEX_BLOCK_SIZE = sizeof(GxPrimitiveVertex) * DRAW_LIST_MAX_VERTEX_NUM;
    static constexpr u32            BUFFER_COUNT = RENDER_BUFFER_COUNT_MAX;
    static const GxMatrix44Gpu  REMAP_MATRIX_INSTANCE[14];
    static const GxMatrix44Gpu* REMAP_MATRIX_TABLE[static_cast<s32>(PRIMITIVE_TEXTURE_REMAP_ALPHA::MAX)][static_cast<s32>(PRIMITIVE_TEXTURE_REMAP_COLOR::MAX)];
    static const GxVector4      REMAP_VECTOR_INSTANCE[6];
    static const GxVector4* REMAP_VECTOR_TABLE[static_cast<s32>(PRIMITIVE_TEXTURE_REMAP_ALPHA::MAX)][static_cast<s32>(PRIMITIVE_TEXTURE_REMAP_COLOR::MAX)];
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GxPrimitiveManager(void);
 
    virtual b32         initialize(GxAllocator* pAllocator, u32 commandBufferSize, u32 vertexBufferSize, u32 indexBufferSize, RENDER_TYPE type, u32 maxProjection2DId, b32 use32bitIndex = false);
 
    void                terminate(void);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
#if GX_DEVELOP
    static GxGuiBase* createGui(GxProperty& property, GxTypedObject* pOwner, const GxRtti& rtti, u32 index);
#endif //GX_DEVELOP
 
public:
    void        begin(void);
 
    constexpr void end(void) {}
 
    void        beginRender(b32 isSort);
 
    void        render(GxRect* pRect = nullptr);
 
    void        endRender(void);
 
private:
    u32         buildCommand(b32 isSort, GxPacket** ppPacket);
 
    void        setMaterial(const GxPrimitiveMaterial& material);
 
    void        resetPrimitiveRenderState(GxRenderContext* pRenderContext, const GxRect& rect, s32 stateMask = 0xffffffff);
 
private:
    GX_FORCE_INLINE GxPacket* allocatePacketBlock(void);
    GX_FORCE_INLINE void* allocateCommandBlock(void);
    GX_FORCE_INLINE GxPrimitiveVertex* allocateVertexBlock(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxPrimitiveContext*     getContext(u32 index);
 
    static void             setCustomShaderCallback(const GxCallback::GxHandlerBase& handler);
 
    GX_FORCE_INLINE b32 isRenderType(RENDER_TYPE type) const { return _renderType == type; }
 
    // projId は 1 以上
    void setProjectionMatrix2D(u32 projectionId, const GxMatrix44& matrix);
    // projId は 0 (スクリーンスペース) も指定可能
    const GxMatrix44& getProjectionMatrix2D(u32 projectionId) const;
    u32 allocateProjectionMatrix2DId(void);
    void freeProjectionMatrix2DId(u32 projectionId);
    GX_FORCE_INLINE const GxPoint2& getOutputOffset2D(void) const { return _outputOffset2D; }
    GX_FORCE_INLINE void setOutputOffset2D(const GxPoint2& offset) { _outputOffset2D = offset; }
    constexpr void setDefaultRenderTarget(GxRenderTexture* pRenderTarget, GxRenderTexture* pDepth) { _pDefaultRenderTarget = pRenderTarget; _pDefaultDepthStencil = pDepth; }
 
#if GX_DEVELOP
    constexpr u32 getMaxCommandBufferSize(void) const { return _maxCommandBufferSize; }
    constexpr u32 getUsedCommandBufferSize(void) const { return _usedCommandBufferSize; }
    constexpr u32 getMaxVertexBufferSize(void) const { return _maxVertexBufferSize; }
    constexpr u32 getUsedVertexBufferSize(void) const { return _usedVertexBufferSize; }
    constexpr u32 getMaxIndexBufferSize(void) const { return _maxIndexBufferSize; }
    constexpr u32 getUsedIndexBufferSize(void) const { return _usedIndexBufferSize; }
#endif //GX_DEVELOP
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
private:    
    RENDER_TYPE                 _renderType;            
    GxPrimitiveContext*         _pContext;              
 
    GxAllocatorFrame*           _pAllocatorCommand;     
    GxAllocatorFrame*           _pAllocatorVertex;      
 
    GxRenderTexture*            _pDefaultRenderTarget;  
    GxRenderTexture*            _pDefaultDepthStencil;  
 
    GxRenderVertexDeclaration*  _pRenderDeclaration;    
    GxRenderVertexBuffer*       _pRenderVertexBuffer[BUFFER_COUNT]; 
    GxRenderIndexBuffer*        _pRenderIndexBuffer[BUFFER_COUNT];  
 
    GxResShaderVertex*          _pResVertexShader2D;            
    GxResShaderVertex*          _pResVertexShader3D;            
    GxResShaderPixel*           _pResPixelShader;               
    GxResShaderPixel*           _pResPixelShaderTexture;        
    GxResShaderPixel*           _pResPixelShaderAlphatest;      
    GxResShaderPixel*           _pResPixelShaderTexRefAlphatest;    
    GxRenderVertexShader*       _pVertexShader2D;               
    GxRenderVertexShader*       _pVertexShader3D;               
    GxRenderPixelShader*        _pPixelShader;                  
    GxRenderPixelShader*        _pPixelShaderTexture;           
    GxRenderPixelShader*        _pPixelShaderAlphatest;         
    GxRenderPixelShader*        _pPixelShaderTexRefAlphatest;   
    GxMatrix44*                 _pProjectionMatrix2DBuffer;     
    u8*                         _pProjectionMatrix2DIdBuffer;   
    GxCriticalSection           _csProjectionMatrix2DIdBuffer;  
 
    GX_HANDLE                   _hProjectionMatrix2D;           
    GX_HANDLE                   _hProjectionMatrix3D;           
 
    GX_HANDLE                   _hRemapMatrix;                  
    GX_HANDLE                   _hRemapVector;                  
    GX_HANDLE                   _hTexture;                      
    GX_HANDLE                   _hAlphaRefValue;                
    GX_HANDLE                   _hPrimitiveModelColor;          
    GX_HANDLE                   _hPrimitiveModelMatrix2D;       
    GX_HANDLE                   _hPrimitiveModelUVOffset;       
    GX_HANDLE                   _hPrimitiveModelModifier;       
#if defined(_PS4) || defined(_PS5)
    GX_HANDLE                   _hScissorRect;                  
#endif  // _PS4 || _PS5
 
#if GX_DEVELOP
    GxResShaderPixel*           _pResPixelShaderTextureGradation;   
    GxRenderPixelShader*        _pPixelShaderTextureGradation;      
    GX_HANDLE                   _hGradationParam;               
#endif //GX_DEVELOP
 
    void*                       _pCommandBuffer;                
    
    GxVector3                   _lightVector;                   
 
    u32                         _currentBuffer;                 
 
    u32                         _commandBufferSize;             
    u32                         _vertexBufferSize;              
    u32                         _indexBufferSize;               
    
    u32                         _maxCommandBufferSize;          
    u32                         _maxVertexBufferSize;           
    u32                         _maxIndexBufferSize;            
    u32                         _usedCommandBufferSize;         
    u32                         _usedVertexBufferSize;          
    u32                         _usedIndexBufferSize;           
    u32                         _maxProjectionMatrix2DIdCount;  
    GxPoint2                    _outputOffset2D;                
    f32                         _texcelOffset;                  
    static GxCallback::GxHandlerBase    _customShaderCallback;  
 
    void*                       _currentIndexBufferRaw;         
    GxPacket*                   _pPacket;                       
    u32                         _packetCount;                   
 
};
 
GX_CORE_NAMESPACE_END()
 
#include "GxPrimitiveManager.inl"