GxRenderTexture.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_CORE_NAMESPACE_BEGIN()
 
//===========================================================================
//===========================================================================
class GxRenderTexture : public GxRenderResource
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GX_RTTI_CLASS(GxRenderTexture, GxRenderResource)
    // ClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxRenderTexture)
 
    friend class GxRenderDevice;
 
    struct GxMappingInformation
    {
        void*       _pImage;        
        u32         _rowPitch;      
        u32         _lineCount;     
        u32         _size;          
    };
 
    struct GxTextureSize
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
    private:
        GxTextureSize(void);
    public:
        GxTextureSize(RENDER_FORMAT format, const GxSize& resolution, u32 mipmapIndex = 0);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        u32                     _width;                         
        u32                     _height;                        
        u32                     _rowPitch;                      
        u32                     _texelPitch;                    
 
    };
 
#if GX_DEVELOP
    static const GX_FLAG RENDER_ATTRIBUTE_FLAG_LIST[8];
#endif //GX_DEVELOP
 
#if defined(_PS5)
    static constexpr u32 GX_MIPMAP_COUNT_MAX = GxMath::VALUE_16;
#endif //_PS5
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    void cleanup(void) override;
 
protected:
    virtual b32 initialize2D(const GxSize& resolution, u32 mipLevel, RENDER_FORMAT format, u32 attribute);
    virtual b32 initialize3D(const GxSize& resolution, u32 depth, u32 mipLevel, RENDER_FORMAT format, u32 attribute);
    virtual b32 initializeCube(const GxSize& resolution, u32 mipLevel, RENDER_FORMAT format, u32 attribute);
    virtual b32 initializeRenderTarget(const GxSize& resolution, RENDER_FORMAT format, RENDER_ANTI_ALIASING antiAliasing, u32 attribute);
#if GX_USE_DX11 || GX_USE_DX12
    virtual b32 initializeRenderTarget(GxNativeTexture pD3DTexture2D, u32 attribute);
#endif  // GX_USE_DX11 || GX_USE_DX12
#if defined(_PS4) || defined(_PS5)
    virtual b32 initializeFmask(const GxRenderTexture* pMultiSample);
#endif //_PS4 || _PS5
 
    virtual b32 initializeDepthStencil(const GxSize& resolution, RENDER_FORMAT format, RENDER_ANTI_ALIASING antiAliasing, u32 attribute);
 
private:
    virtual b32 initializeInner(void);
 
protected:
    GxRenderTexture(void);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
#if GX_DEVELOP
    static GxGuiBase* createGui(GxProperty& property, GxTypedObject* pOwner, const GxRtti& rtti, u32 index);
 
    GX_FORCE_INLINE GxString getRenderNotifierName(void) const override { GxString string; return string.format("ClassName:%s Name:%s", getRtti().getClassName(), getName()); }
public:
#if defined(_WINDOWS)
    void save(GX_CSTR path);
#endif //_WINDOWS
#endif //GX_DEVELOP
 
public:
    void        onLostDevice(void) override;
 
    b32         onResetDevice(void) override;
 
    void        onRender(void) override {}
 
public:
    virtual b32                     map(u32 arrayIndex, u32 mipLevel, u32 mappingType, GxMappingInformation* pMappingInformation);
    virtual void                    unmap(u32 arrayIndex, u32 mipLevel);
#if GX_USE_DX12
#if GX_EDITOR
    void copyRenderTargetToTexture(void);
#endif //GX_EDITOR
#endif //GX_USE_DX12
#if GX_DEVELOP
    void getThumbnail(void* pBuffer, const GxSize& size, b32 isConstAspectRatio = false);
#endif //GX_DEVELOP
 
#if GX_USE_DX11 || GX_USE_DX12
    virtual b32                     freeze(void);
#endif  // GX_USE_DX11 || GX_USE_DX12
 
protected:
    u32                             getMipSize(u32 mipLevel, u32 originalPitch);
    u32                             getMipPitch(u32 mipLevel, u32 originalPitch);
    static u32                      getMipLine(u32 mipLevel, RENDER_FORMAT format, const GxSize& resolution);
 
#if GX_USE_DX11 || GX_USE_DX12
    void* getMipData(u32 arrayIndex, u32 mipLevel);
#endif  // GX_USE_DX11 || GX_USE_DX12
 
    u8                              convertMsaaToSampleCount(RENDER_ANTI_ALIASING antiAliasing);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    constexpr RENDER_TEXTURE_TYPE   getType(void) const { return _type; }
    constexpr RENDER_FORMAT         getFormat(void) const { return _format; }
    constexpr RENDER_ANTI_ALIASING  getAntiAliasing(void) const { return _antiAliasing; }
    GX_FORCE_INLINE const GxSize&   getResolution(void) const { return _resolution; }
    constexpr u32                   getDepth(void) const { return _type == RENDER_TEXTURE_TYPE::_3D ? _depthOrArrayCount : 1; }
    constexpr u32                   getArrayCount(void) const { return _type == RENDER_TEXTURE_TYPE::_3D ? 1 : _depthOrArrayCount; }
    constexpr u32                   getMipLevel(void) const { return _mipLevel; }
    constexpr u32                   getAttribute(void) const { return _attribute; }
    constexpr GX_HANDLE             getHandle(void) const { return _handle; }
 
    void                            setName(GX_CSTR name);
    constexpr GX_CSTR               getName(void) const { return _name.getString(); }
 
    static u32                      getBitPerPixel(RENDER_FORMAT format);
    static u32                      getPitch(RENDER_FORMAT format, u32 width);
 
#if defined(_PS5)
    GX_FORCE_INLINE GxNativeTexture* getTexture(void) { return &_texture; }
#elif defined(_NX64)
    GX_FORCE_INLINE GxNativeTexture* getTexture(void) const { return _pTexture; }
#else //_NX64
    GX_FORCE_INLINE GxNativeTexture getTexture(void) const { return _pTexture; }
#endif // !_NX64
 
#if GX_USE_DX11 || GX_USE_DX12
    static RENDER_FORMAT getFormat(GxNativeRenderFormat nativeFormat);
#endif //GX_USE_DX11 || GX_USE_DX12
    static GxNativeRenderFormat getNativeFormat(RENDER_FORMAT format, u32 attribute);
 
#if GX_USE_DX11 || GX_USE_DX12
#if GX_USE_DX11
    static D3D_SRV_DIMENSION        getSRVDimension(RENDER_TEXTURE_TYPE type);
    static D3D11_UAV_DIMENSION      getUAVDimension(RENDER_TEXTURE_TYPE type);
#endif //GX_USE_DX11
 
    GxNativeRenderTarget getRenderTarget(void) const { return _pRenderTarget; }
    GxNativeDepthStencil getDepthStencil(void) const { return _pDepthStencil; }
#if GX_USE_DX11
    ID3D11ShaderResourceView* getD3D11ShaderResourceView(void) const { return _pD3D11ShaderResourceView; }
    ID3D11UnorderedAccessView* getD3D11UnorderedAccessView(void) const { return _pD3D11UnorderedAccessView; }
    GxNativeDepthStencil getD3D11ReadOnlyDepthStencilView(void) const { return _pReadOnlyDepthStencilView; }
#elif GX_USE_DX12
    GX_FORCE_INLINE D3D12_CPU_DESCRIPTOR_HANDLE getD3D12RenderTargetDescriptorHandle(void) const { return _pD3D12DescriptorHeapRtv->GetCPUDescriptorHandleForHeapStart(); }
    GX_FORCE_INLINE D3D12_CPU_DESCRIPTOR_HANDLE getD3D12DepthStencilDescriptorHandle(void) const { return _pD3D12DescriptorHeapDsv->GetCPUDescriptorHandleForHeapStart(); }
    constexpr u32 getDescriptorHeapIndexSrv(void) const { return _descriptorHeapIndexSrv; }
    constexpr u32 getDescriptorHeapIndexUav(void) const { return _descriptorHeapIndexUav; }
    GX_FORCE_INLINE b32 isD3DResourceStates(D3D12_RESOURCE_STATES states) const { return _d3dResourceStates == states || (_d3dResourceStates & states) > 0; }
    constexpr D3D12_RESOURCE_STATES getD3DResourceStates(void) const { return _d3dResourceStates; }
    constexpr void setD3DResourceStates(D3D12_RESOURCE_STATES states) { _d3dResourceStates = states; }
#endif //GX_USE_DX12
#elif defined(_NX64)
    constexpr u32                   getTextureID(void) const { return _textureId; }
    void                            setTexture(GxNativeTexture* pTexture, const GxSize* pOverrideResolution = nullptr);
    static GxNativeTextureTarget    getTextureTarget(RENDER_TEXTURE_TYPE format, u32 attribute, RENDER_ANTI_ALIASING antiAliasing);
    static b32                      getSwizzle(RENDER_FORMAT format, GxNativeTextureSwizzle& red, GxNativeTextureSwizzle& green, GxNativeTextureSwizzle& blue, GxNativeTextureSwizzle& alpha);
    static u32                      getAntiAliasSamples(RENDER_ANTI_ALIASING antiAliasing);
#endif // _NX64
 
#if GX_DEVELOP
    const GxColorHDR                getTexel( GxPoint2 position, u32 mipLevel, u32 arrayIndex = 0 );
private:
    const GxColorHDR                getTexelTile( u32 width, const u8* pImage, u32 positionX, u32 positionY ) const;
    const GxColorHDR                getTexelDXT1( u32 width, const u8* pImage, u32 positionX, u32 positionY ) const;
    const GxColorHDR                getTexelDXT3( u32 width, const u8* pImage, u32 positionX, u32 positionY ) const;
    const GxColorHDR                getTexelDXT5( u32 width, const u8* pImage, u32 positionX, u32 positionY ) const;
    const GxColor                   getDecompressColor( const u16 color ) const;
    const GxColorHDR                getCalculateColorDXT( GxColor color0, GxColor color1, u8 alpha, u8 positionCode ) const;
#endif //GX_DEVELOP
    
    //-------------------------------------------------------------
    //-------------------------------------------------------------
private:
    RENDER_TEXTURE_TYPE             _type;                          
    RENDER_FORMAT                   _format;                        
    RENDER_ANTI_ALIASING            _antiAliasing;                  
    GxSize                          _resolution;                    
    u32                             _depthOrArrayCount;             
    u32                             _mipLevel;                      
    u32                             _attribute;                     
    GX_HANDLE                       _handle;                        
    GxString                        _name;                          
    b32                             _isTextureSurface;              
    u32                             _mappingType;                   
 
#if defined(_PS5)
    GxNativeTexture                 _texture;                       
#elif defined(_NX64)
    GxNativeTexture*                _pTexture;                      
#else //_NX64
    GxNativeTexture                 _pTexture;                      
#endif // !_NX64
#if GX_USE_DX11 || GX_USE_DX12
    GxNativeRenderTarget            _pRenderTarget;                 
    GxNativeDepthStencil            _pDepthStencil;                 
#elif defined(_PS5)
    GxNativeRenderTarget            _renderTarget;                  
    GxNativeDepthStencil            _depthStencil;                  
#endif //_PS5
#if GX_USE_DX11 || GX_USE_DX12
    GxNativeTexture                 _pTextureMap;                   
    void*                           _pTextureData;                  
#if GX_USE_DX11
    ID3D11ShaderResourceView*       _pD3D11ShaderResourceView;      
    ID3D11UnorderedAccessView*      _pD3D11UnorderedAccessView;     
    GxNativeDepthStencil            _pReadOnlyDepthStencilView;     
#elif GX_USE_DX12
    ComPtr<ID3D12DescriptorHeap>    _pD3D12DescriptorHeapRtv;       
    ComPtr<ID3D12DescriptorHeap>    _pD3D12DescriptorHeapDsv;       
    u32                             _descriptorHeapIndexSrv;        
    u32                             _descriptorHeapIndexUav;        
    u32                             _rtvDescriptorSize;             
    D3D12_RESOURCE_STATES           _d3dResourceStates;             
#endif  // GX_USE_DX12
#elif defined(_PS5)
    u32                             _sliceSize;                     
    GxSize                          _mipSizes[GX_MIPMAP_COUNT_MAX]; 
    u32                             _mipOffsets[GX_MIPMAP_COUNT_MAX];   
#elif defined(_NX64)
    s32                             _textureId;                     
    void*                           _pMappedRawData;                
#endif  // _NX64
 
#if GX_DEVELOP
    u32                             _vramAllocateSize;              
#endif //GX_DEVELOP
};
 
GX_CORE_NAMESPACE_END()