GxSysRenderBase.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_CORE_NAMESPACE_BEGIN()
 
class GxUnitCameraBase;
 
#if !defined(ENABLE_LINEAR_Z)
#define ENABLE_LINEAR_Z 0
#endif // !ENABLE_LINEAR_Z
 
#if !defined(_NX64)
#define USE_MULTISAMPLE_VIEWPORT
#endif // !_NX64
 
#if defined(_PS5)
#define USE_TEMPORARY_RENDER_TARGET 1
#else //_PS5
#define USE_TEMPORARY_RENDER_TARGET 0
#endif // !_PS5
 
//===========================================================================
//===========================================================================
class GxRenderInitialInformation : public GxClassBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS(GxRenderInitialInformation, GxClassBase)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxRenderInitialInformation)
 
    
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GxRenderInitialInformation(void)
    : _defaultViewportResolution(1280, 720)
#if defined(GX_USE_FP16MAP)
    , _defaultViewportFormat(RENDER_FORMAT::R16G16B16A16F)
#else //GX_USE_FP16MAP
    , _defaultViewportFormat(RENDER_FORMAT::R8G8B8A8)
#endif // !GX_USE_FP16MAP
    , _defaultViewportAntiAliasing(RENDER_ANTI_ALIASING::NONE)
    , _defaultViewportRegion(GxRect::ZERO)
    , _virtualResolution(GxSize::ZERO)
    , _shadowMapResolution( GxSize::ZERO )
    , _shadowCullingModeDefault( false )
    , _velocityMapResolution(GxSize::ZERO)
#if defined(_PS4) || defined(_PS5)
    , _useHtileOnShadowBuffer(true)
    , _useHtileOnDepthStencil(true)
#if GX_ENABLE_NEO
    , _useHtileOnDepthStencilNeo(true)
#endif  // GX_ENABLE_NEO
#endif  // _PS4 || _PS5
    {}
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    void loadJson(const GxJson::GxJsonNode& jsonNode);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GxRenderDeviceInitialInformation    _deviceInitialInformation;      
    GxSize                              _defaultViewportResolution;     
    RENDER_FORMAT                       _defaultViewportFormat;         
    RENDER_ANTI_ALIASING                _defaultViewportAntiAliasing;   
    GxRect                              _defaultViewportRegion;         
    GxSize                              _virtualResolution;             
    GxSize                              _shadowMapResolution;           
    b32                                 _shadowCullingModeDefault;      
    GxSize                              _velocityMapResolution;         
 
#if defined(_PS4) || defined(_PS5)
    b32                                 _useHtileOnShadowBuffer;        
    b32                                 _useHtileOnDepthStencil;        
#if GX_ENABLE_NEO
    b32                                 _useHtileOnDepthStencilNeo;     
#endif  // GX_ENABLE_NEO
#endif  // _PS4 || _PS5
 
};
 
//===========================================================================
//===========================================================================
class GxSysRenderBase : public GxSysBase, public SingletonBase<GxSysRenderBase>
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GX_RTTI_ABSTRACT_CLASS(GxSysRenderBase, GxSysBase)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxSysRenderBase)
 
    class GxViewport;
    struct GxVertexData;
 
    static constexpr u32 LIGHTING_TILE_WIDTH    = GxMath::VALUE_128;
    static constexpr u32 LIGHTING_TILE_HEIGHT   = GxMath::VALUE_64;
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GxSysRenderBase(void);
    ~GxSysRenderBase(void) override {}
    b32         initialize(const GxClassBase* pInitialInformation) override;
    void        terminate(void) override;
 
    virtual b32         initializeThreadLocalStorage(u32 workerThreadIndex);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_FORCE_INLINE void            setVirtualResolution(GxSize& size) { _virtualResolution._width = size._width; _virtualResolution._height = size._height; }
    GX_FORCE_INLINE const GxSize&   getVirtualResolution(void) const { return _virtualResolution; }
    GX_FORCE_INLINE const GxSize&   getOutputResolution(void) const { if( getGxRenderDevice() ) { return getGxRenderDevice()->getOutputResolution(); } return GxSize::ZERO; }
    GX_FORCE_INLINE const GxSize&   getDefaultViewportResolution(void) const { return _defaultViewportResolution; }
 
    GX_FORCE_INLINE const GxRect&   getSafetyArea(void) const { if( getGxRenderDevice() ) { return getGxRenderDevice()->getSafetyArea(); } return GxRect::ZERO; }
    GX_FORCE_INLINE const GxRect&   getVirtualSafetyArea(void) const { return _virtualSafetyArea; }
 
    GX_FORCE_INLINE void            setClearColor(const GxColor& color) { _clearColor = color; }
    GX_FORCE_INLINE const GxColor&  getClearColor(void) const { return _clearColor; }
 
    GxViewport*             getViewport(RENDER_VIEW index) const { return _pViewport[static_cast<s32>(index)]; }
    GxViewport*             getDisableViewport(void) const;
    u32                     getViewIndex(GxViewport* pViewport) const;
    u32                     getEnableViewportNum(void);
 
    constexpr GxRenderVertexBuffer* getInstanceVertexBuffer(void) { return _pInstanceVertexBuffer; }
 
    GX_FORCE_INLINE virtual GxResShaderPackage* getModelShaderPackage(void) { return nullptr; }
 
#if GX_EDITOR
    GX_FORCE_INLINE b32 isEnableBakeLightProbe(void) { return _enableBakeLightProbe; }
    GX_FORCE_INLINE void setEnableBakeLightProbe(b32 enableBakeLightProbe) { _enableBakeLightProbe = enableBakeLightProbe; }
#endif //GX_EDITOR
 
    GX_FORCE_INLINE b32 isFrustumCulling(void) const { return _isFrustumCulling; }
    GX_FORCE_INLINE void setFrustumCulling(b32 enable) { _isFrustumCulling = enable; }
#if GX_ENABLE_OCCLUSION_CULLING
    GX_FORCE_INLINE b32 isOcclusionCulling(void) const { return _isOcclusionCulling; }
    GX_FORCE_INLINE void setOcclusionCulling(b32 enable) { _isOcclusionCulling = enable; }
#endif //GX_ENABLE_OCCLUSION_CULLING
#if GX_DEVELOP
    GX_FORCE_INLINE b32 isCullingLock(void) const { return _cullingLock; }
    GX_FORCE_INLINE void setCullingLock(b32 enable) { _cullingLock = enable; }
#endif //GX_DEVELOP
 
    GX_FORCE_INLINE b32         isShadowCullingModeDefault(void) const { return _shadowCullingModeDefault; }
    GX_FORCE_INLINE void        setShadowCullingModeDefaul(b32 enable){ _shadowCullingModeDefault = enable; }
 
#if defined(_PS4) || defined(_PS5)
    GX_FORCE_INLINE b32 isUseHtileOnDepthStencil(void) const { return _useHtileOnDepthStencil; }
#if GX_ENABLE_NEO
    GX_FORCE_INLINE b32 isUseHtileOnDepthStencilNeo(void) const { return _useHtileOnDepthStencilNeo; }
#endif  // GX_ENABLE_NEO
#if GX_ENABLE_HTILE_STENCIL_MASK
    GX_FORCE_INLINE b32         isHtileStencilMaskEnable(void) const { return _htileStencilMaskEnable; }
    GX_FORCE_INLINE void        setHtileStencilMaskEnable(b32 enable) { _htileStencilMaskEnable = enable; }
    GX_FORCE_INLINE void        setHtileStencilMaskParams(u32 viewIndex, f32 outAngle, f32 inAngle, f32 topAngle, f32 bottomAngle, f32 cutOff, f32 cutOut)
    {
        _htileStencilMaskParams[viewIndex][0] = outAngle;
        _htileStencilMaskParams[viewIndex][1] = inAngle;
        _htileStencilMaskParams[viewIndex][2] = topAngle;
        _htileStencilMaskParams[viewIndex][3] = bottomAngle;
        _htileStencilMaskParams[viewIndex][4] = cutOff;
        _htileStencilMaskParams[viewIndex][5] = cutOut;
    }
    GX_FORCE_INLINE const f32* getHtileStencilMaskParams(u32 viewIndex) const { return _htileStencilMaskParams[viewIndex]; }
#endif // GX_ENABLE_HTILE_STENCIL_MASK
#endif  // _PS4 || _PS5
 
    RENDER_VIEW getViewportFromScreen( const GxPoint2& screenPosition );
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    void update(void) override;
    virtual void render(void);
 
    const GxPoint2 transformWorldToScreen( const GxVector3& worldPosition, const RENDER_VIEW viewport, const GxSize* pResolution = nullptr );
    // スクリーン座標GxVector3版をご利用ください
    b32 transformWorldToScreen( const GxVector3& worldPosition, GxPoint2& screenPosition, const RENDER_VIEW viewport );
    b32 transformWorldToScreen( const GxVector3& worldPosition, GxVector3& screenPosition, const RENDER_VIEW viewport );
 
    const GxVector2 transformWorldToVirtual( const GxVector3& worldPosition, const RENDER_VIEW viewport );
 
    b32 transformScreenToRay( const GxPoint2& screenPosition, GxVector3& rayStart, GxVector3& rayEnd, const GxSize* pResolution = nullptr );
    b32 transformScreenToRay( const GxPoint2& screenPosition, GxVector3& rayStart, GxVector3& rayEnd, const RENDER_VIEW viewport, const GxSize* pResolution = nullptr );
 
    static void getPositionFromVirtual(const GxVector2& virtualPosition, GxPoint2& outputPosition, const GxSize* pOutputResolution);
    static void getPositionToVirtual(const GxPoint2& inputPosition, GxVector2& virtualPosition, const GxSize* pInputResolution);
    static void getPositionVirtualToOutput(const GxVector2& virtualPosition, GxPoint2& outputPosition);
    static void getPositionOutputToVirtual(const GxPoint2& outputPosition, GxVector2& virtualPosition);
    static void getRectFromVirtual(const GxRectF& baseRect, GxRect& dstRect, const GxSize* pOutputResolution);
    static void getRectToVirtual(const GxRect& baseRect, GxRectF& dstRect, const GxSize* pInputResolution);
    static void getRectVirtualToOutput(const GxRectF& baseRect, GxRect& dstRect);
    static void getRectOutputToVirtual(const GxRect& baseRect, GxRectF& dstRect);
 
    static GxPoint2 getPositionViewPortToOutput(const GxPoint2& viewportPosition,const RENDER_VIEW viewportNo);
 
    static GxPoint2 getPositionOutputToViewPort(const GxPoint2& outputResolution,const RENDER_VIEW viewportNo);
 
    void copyTextureToBackbuffer(GxRenderTexture* pDst, GxRenderTexture* pSrc, b32 isRight);
 
#if defined(_PS4)
#if GX_ENABLE_NEO
    s32                         enablePrimIdMapCallback(void* pSource, void* pArgument);
    s32                         disablePrimIdMapCallback(void* pSource, void* pArgument);
 
    s32                         enableNeoRenderModeGradientAdjustCallback(void* pSource, void* pArgument);
    s32                         disableNeoRenderModeGradientAdjustCallback(void* pSource, void* pArgument);
    s32                         enableNeoRenderModeAaSampleLocationCallback(void* pSource, void* pArgument);
    s32                         disableNeoRenderModeAaSampleLocationCallback(void* pSource, void* pArgument);
    s32                         enableNeoRenderModeAaSettingCallback(void* pSource, void* pArgument);
    s32                         disableNeoRenderModeAaSettingCallback(void* pSource, void* pArgument);
 
    s32                         setRenderTargetsForPrimIdGeometryCallback(void* pSource, void* pArgument);
#endif  // GX_ENABLE_NEO
#endif  // _PS4
 
    constexpr void setClearTexture(GxRenderTexture* pClearRenderTexture) { _pClearRenderTexture = pClearRenderTexture; };
    constexpr GxRenderTexture* getClearTexture(void) { return _pClearRenderTexture; };
 
protected:
    void drawClearTexture(GxViewport* pViewport);
 
protected:
    virtual void                renderUnit(void);
 
    void                        copyViewport(void);
#if defined(_PS4)
#if GX_ENABLE_NEO
    void                        resolveViewportByNeoRenderMode(void);
 
    s32                         resolveNeoRenderModeCallback(void* pSource, void* pArgument);
#endif  // GX_ENABLE_NEO
#endif  // _PS4
    virtual GxRenderTexture*    getViewportRenderTarget(RENDER_VIEW viewport);
 
    GX_FORCE_INLINE GxRenderContext* getRenderContext(u32 workerThreadIndex) { return &getGxRenderDevice()->_pContext[workerThreadIndex]; }
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
private:
    GxSize                          _virtualResolution;             
    GxRect                          _virtualSafetyArea;             
    GxSize                          _defaultViewportResolution;     
    GxColor                         _clearColor;                    
    GxViewport*                     _pViewport[static_cast<s32>(RENDER_VIEW::MAX)]; 
    GxRenderVertexDeclaration*      _pRenderDeclaration;            
    GxRenderVertexBuffer*           _pRenderVertexBuffer;           
    GxRenderIndexBuffer*            _pRenderIndexBuffer;            
    GxRenderVertexBuffer*           _pInstanceVertexBuffer;         
    GxResShaderPackage*             _pShaderPackage;                
    GxShaderPackage::GxShaderCode*  _pShaderCode;                   
    GX_HANDLE                       _handleProjectionMatrix2D;      
    GX_HANDLE                       _handleOutputGamma;             
    GX_HANDLE                       _handleTexture;                 
#if GX_USE_HLSL
    GX_HANDLE                       _handleNoFilterSamplerState;    
#endif  // GX_USE_HLSL
 
#if GX_EDITOR
    b32                             _enableBakeLightProbe;          
#endif //GX_EDITOR
 
    b32                             _isFrustumCulling;              
#if GX_ENABLE_OCCLUSION_CULLING
    b32                             _isOcclusionCulling;            
#endif //GX_ENABLE_OCCLUSION_CULLING
#if GX_DEVELOP
    b32                             _cullingLock;                   
#endif //GX_DEVELOP
    b32                             _shadowCullingModeDefault;      
 
#if defined(_PS4) || defined(_PS5)
    b32                             _useHtileOnDepthStencil;        
#if GX_ENABLE_NEO
    b32                             _useHtileOnDepthStencilNeo;     
#endif  // GX_ENABLE_NEO
#if GX_ENABLE_HTILE_STENCIL_MASK
    b32                             _htileStencilMaskEnable;        
    f32                             _htileStencilMaskParams[static_cast<s32>(RENDER_VIEW::MAX)][6]; 
#endif // GX_ENABLE_HTILE_STENCIL_MASK
#endif  // _PS4 || _PS5
    GxRenderTexture*                _pClearRenderTexture;           
 
};
 
//===========================================================================
//===========================================================================
class GxSysRenderBase::GxViewport : public GxClassBase
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GX_RTTI_CLASS(GxSysRenderBase::GxViewport, GxClassBase)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxViewport)
    // new, delete定義
    GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::RENDER)
 
    friend class GxSysRenderBase;
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
protected:
    GxViewport(void);
 
    GX_FORCE_INLINE virtual b32 initialize(void) { return true; }
    virtual void terminate(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    virtual void update(void);
 
protected:
    b32                                     updateRenderTarget(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_FORCE_INLINE b32                     getEnable(void) const { return _enable; }
    GX_FORCE_INLINE void                    setEnable(b32 enable) { _enable = enable; }
    GX_FORCE_INLINE b32                     isRenderDisplay(void) const { return _isRenderDisplay; }
    GX_FORCE_INLINE void                    setRenderDisplay(b32 enable) { _isRenderDisplay = enable; }
    GX_FORCE_INLINE b32                     isOffScreen(void) const { return _isOffScreen; }
    GX_FORCE_INLINE void                    setOffScreen(b32 enable) { _isOffScreen = enable; }
    constexpr GxUnitCameraBase*             getCamera(void) const { return _pCamera; }
    constexpr void                          setCamera(GxUnitCameraBase* pCamera) { _pCamera = pCamera; }
    GX_FORCE_INLINE const GxSize&           getResolution(void) const { return _resolution; }
    void                                    setResolution(const GxSize& resolution);
    constexpr RENDER_FORMAT                 getFormat(void) const { return _format; }
    GX_FORCE_INLINE void                    setFormat(RENDER_FORMAT format) { _format = format; _isChanged = true; }
    constexpr RENDER_ANTI_ALIASING          getAntiAliasing(void) const { return _antiAliasing; }
    GX_FORCE_INLINE void                    setAntiAliasing(RENDER_ANTI_ALIASING antiAliasing) { _antiAliasing = antiAliasing; _isChanged = true; }
    GX_FORCE_INLINE const GxRect&           getRegion(void) const { return _region; }
    GX_FORCE_INLINE void                    setRegion(const GxRect& region) { _region = region; }
    GX_FORCE_INLINE void                    setSize(const GxSize& size) { _region._right = _region._left + size._width; _region._bottom = _region._top + size._height; }
 
    constexpr GxRenderTexture*              getRenderTarget(void) const { return  _pRenderTarget; }
    void                                    setRenderTarget(GxRenderTexture* pTexture);
    constexpr GxRenderTexture*              getDepthStencil(void) const { return _pDepthStencil; }
    constexpr GxRenderTexture*              getShadowMap(void) const { return _pTexShadow; }
    constexpr GxRenderTexture*              getSSAOMap(void) const { return _pTexSSAO; }
    constexpr GxRenderTexture*              getSSAOHorizontalBlurredMap(void) const { return _pTexSSAOHorizontalBlurred; }
    constexpr GxRenderTexture*              getNormalMap(void) const { return _pTexNormal; }
    constexpr GxRenderTexture*              getDiffuseMap(void) const { return _pTexDiffuse; }
    constexpr GxRenderTexture*              getSpecularMap(void) const { return _pTexSpecular; }
    constexpr GxRenderTexture*              getFogColorMap(void) const { return _pTexFogColor; }
    constexpr GxRenderTexture*              getLightProbeMap(void) const { return _pTexLightProbeMap; }
    void                                    setLightProbeMapResolution(const GxSize& resolution);
    void                                    setLightProbeResolution(u32 x, u32 y, u32 z);
    constexpr GxRenderTexture*              getLightProbe(u32 shIndex, u32 colorIndex) const { return _pTexLightProbe[shIndex][colorIndex]; }
    constexpr GxRenderTexture*              getMetallicRoughnessMap(void) const { return _pTexMetallicRoughness; }
#if USE_TEMPORARY_RENDER_TARGET
    constexpr GxRenderTexture*              getTemporaryMap(void) const { return _pTexTemporary; }
#endif //USE_TEMPORARY_RENDER_TARGET
    constexpr GxRenderTexture*              getVelocityMap(void) const { return _pTexVelocity; }
    constexpr GxRenderTexture*              getVelocityDepthStencilMap(void) const { return _pTexVelocityDepthStencil; }
    const GxSize&                           getVelocityMapResolution(void) const { return _velocityMapResolution; }
    void                                    setVelocityMapResolution(const GxSize& resolution){ _velocityMapResolution = resolution; }
 
#if ENABLE_LINEAR_Z
    constexpr GxRenderTexture*              getLinearZMap(void) const { return _pTexLinearZ; }
#endif  // ENABLE_LINEAR_Z
    constexpr GxRenderTexture*              getEffectZMap(void) const { return _pTexEffectZ; }
    constexpr GxRenderTexture*              getSemiTransparenceMap(void) const { return _pTexSemiTransparence; }
    
#if defined(USE_MULTISAMPLE_VIEWPORT)
    constexpr GxRenderTexture*              getMultiSample(void) const { return _pTexMultiSample; }
    constexpr GxRenderTexture*              getMultiSampleDepthStencil(void) const { return _pTexMultiSampleDepthStencil; }
#endif // USE_MULTISAMPLE_VIEWPORT
 
    constexpr GxRenderVertexDeclaration*    getLightingVertexDeclaration(void) const { return _pLightingVertexDeclaration; }
    constexpr GxRenderVertexBuffer*         getLightingVertexBuffer(void) const { return _pLightingVertexBuffer; }
    constexpr GxRenderIndexBuffer*          getLightingIndexBuffer(void) const { return _pLightingIndexBuffer; }
 
    b32                                     isRenderReady(void);
 
    void                                    clearRenderTarget(RENDER_SUB_VIEW subView, RENDER_PASS pass, u32 subPriority = 0);
 
    constexpr void                          setIndex(u32 index){ _viewportIndex = index; }
    constexpr u32                           getIndex(void){ return _viewportIndex; }
 
#if defined(_PS4) || defined(_PS5)
    constexpr GxRenderTexture*              getFmask(void) const { return _pTexFmask; }
#if GX_ENABLE_NEO
    constexpr GxRenderTexture*              getPrimIdMap(void) const { return _pTexPrimId; }
 
    constexpr GxRenderTexture*              getAfterResolveRenderTarget(void) const { return _pTexAfterResolveRenderTarget; }
 
    constexpr GxRenderTexture*              getDepthStencilNeo(void) const { return _pDepthStencilNeo; }
 
    void                                    notifyNeoRenderModeChanged(void);
#endif  // GX_ENABLE_NEO
#endif  // _PS4 || _PS5
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
private:
    b32                     _enable;            
    b32                     _isRenderDisplay;   
    b32                     _isChanged;         
    b32                     _isOffScreen;       
    u32                     _viewportIndex;     
    GxUnitCameraBase*       _pCamera;           
    GxSize                  _resolution;        
    RENDER_FORMAT           _format;            
    RENDER_ANTI_ALIASING    _antiAliasing;      
    GxRect                  _region;            
 
    GxRenderTexture*        _pRenderTarget;     
    GxRenderTexture*        _pDepthStencil;     
    GxRenderTexture*        _pTexShadow;        
    GxRenderTexture*        _pTexSSAO;                      
    GxRenderTexture*        _pTexSSAOHorizontalBlurred;     
    GxRenderTexture*        _pTexNormal;                    
    GxRenderTexture*        _pTexDiffuse;                   
    GxRenderTexture*        _pTexSpecular;                  
    GxRenderTexture*        _pTexFogColor;                  
    GxRenderTexture*        _pTexLightProbeMap;             
    GxRenderTexture*        _pTexLightProbe[3][3];          
    GxSize                  _lightProbeMapResolution;       
    u32                     _lightProbeResolution[static_cast<u32>(AXIS::MAX)]; 
    GxRenderTexture*        _pTexMetallicRoughness;         
#if USE_TEMPORARY_RENDER_TARGET
    GxRenderTexture*        _pTexTemporary;                 
#endif //USE_TEMPORARY_RENDER_TARGET
    GxRenderTexture*        _pTexVelocity;                  
    GxRenderTexture*        _pTexVelocityDepthStencil;      
    GxSize                  _velocityMapResolution;         
 
#if ENABLE_LINEAR_Z
    GxRenderTexture*        _pTexLinearZ;                   
#endif  // ENABLE_LINEAR_Z
    GxRenderTexture*        _pTexEffectZ;                   
    GxRenderTexture*        _pTexSemiTransparence;          
 
#if defined(USE_MULTISAMPLE_VIEWPORT)
    GxRenderTexture*        _pTexMultiSample;               
    GxRenderTexture*        _pTexMultiSampleDepthStencil;   
#endif // USE_MULTISAMPLE_VIEWPORT
 
#if defined(_PS4) || defined(_PS5)
    GxRenderTexture*        _pTexFmask;                     
#endif  //_PS4 || _PS5
 
    GxRenderVertexDeclaration*  _pLightingVertexDeclaration;
    GxRenderVertexBuffer*       _pLightingVertexBuffer;     
    GxRenderIndexBuffer*        _pLightingIndexBuffer;      
 
#if defined(_PS4)
#if GX_ENABLE_NEO
    GxRenderTexture*        _pTexPrimId;                    
 
    GxRenderTexture*        _pTexAfterResolveRenderTarget;  
 
    GxRenderTexture*        _pDepthStencilNeo;              
#endif  // GX_ENABLE_NEO
#endif  // _PS4
 
};
 
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
struct GxSysRenderBase::GxVertexData
{
    GxFloat3        _position;      
    GxFloat2        _texCoord;      
};
 
// アクセスインターフェース
GX_FORCE_INLINE GxSysRenderBase* getGxSysRenderBase(void) { return GxSysRenderBase::getSingletonPointer(); }
 
GX_CORE_NAMESPACE_END()