Memoryless tiler

OgreMain/include/OgreDepthBuffer.h

@@ -89,6 +89,11 @@ namespace Ogre
             POOL_NO_DEPTH = 0,
             POOL_MANUAL_USAGE OGRE_DEPRECATED_ENUM_VER( 3 ) = 0,
             POOL_DEFAULT = 1,
+
+            /// The depth buffer doesn't does not have memory backing it.
+            /// It will be created with TextureFlags::TilerMemoryless.
+            POOL_MEMORYLESS = 65533,
+
             /// Deprecated.
             ///
             /// Do NOT use this flag directly. It made sense in Ogre 2.1

OgreMain/include/OgreRenderPassDescriptor.h

@@ -204,6 +204,10 @@ namespace Ogre
 
     protected:
         void         checkRequiresTextureFlipping();
+        void         validateMemorylessTexture( const TextureGpu              *texture,
+                                                const LoadAction::LoadAction   loadAction,
+                                                const StoreAction::StoreAction storeAction,
+                                                const bool                     bIsDepthStencil );
         virtual void colourEntriesModified();
 
     public:

OgreMain/include/OgreTextureGpu.h

@@ -167,7 +167,21 @@ namespace Ogre
             /// frames (e.g. HDR luminance change over time)
             ///
             /// If this flag is present, either RenderToTexture or Uav must be present
-            DiscardableContent  = 1u << 14u
+            DiscardableContent  = 1u << 14u,
+            /// When this flag is present, we can save VRAM by using memoryless storage mode (Metal on
+            /// iOS and Apple Silicon macOS) aka TRANSIENT memory (Vulkan).
+            ///
+            /// With this flag set, the texture will not be backed by memory, it will only ever live in
+            /// cache. Only TBDR GPUs support this. It will be ignored if unsupported.
+            ///
+            /// Many operations are unsupported with TilerMemoryless textures (e.g. copy operations)
+            /// because there is no memory behind them.
+            ///
+            /// An example is a depth or stencil texture thatʼs used only within a render pass
+            /// and isnʼt needed before or after GPU execution.
+            ///
+            /// This flag requires RenderToTexture.
+            TilerMemoryless = 1u << 15u,
             // clang-format on
         };
     }
@@ -649,6 +663,7 @@ namespace Ogre
         bool isManualTexture() const;
         bool isPoolOwner() const;
         bool isDiscardableContent() const;
+        bool isTilerMemoryless() const { return ( mTextureFlags & TextureFlags::TilerMemoryless ) != 0; }
 
         /// OpenGL RenderWindows are a bit specific:
         ///     * Their origins are upside down. Which means we need to flip Y.

OgreMain/include/OgreTextureGpuManager.h

@@ -527,6 +527,7 @@ namespace Ogre
 
         DefaultMipmapGen::DefaultMipmapGen mDefaultMipmapGen;
         DefaultMipmapGen::DefaultMipmapGen mDefaultMipmapGenCubemaps;
+        bool                               mAllowMemoryLess;
         bool                               mShuttingDown;
         std::atomic<bool>                  mUseMultiload;
         ThreadHandlePtr                    mWorkerThread;
@@ -754,6 +755,15 @@ namespace Ogre
         DefaultMipmapGen::DefaultMipmapGen getDefaultMipmapGeneration() const;
         DefaultMipmapGen::DefaultMipmapGen getDefaultMipmapGenerationCubemaps() const;
 
+        /** When false, TextureFlags::TilerMemoryless will be ignored (including implicit MSAA surfaces).
+            Useful if you're rendering a heavy scene and run out of tile memory on mobile / TBDR.
+        @param bAllowMemoryLess
+            True to allow TilerMemoryless. False otherwise.
+            If HW does not support TilerMemoryless, this value will be forced to false.
+        */
+        void setAllowMemoryless( const bool bAllowMemoryLess );
+        bool allowMemoryless() const { return mAllowMemoryLess; }
+
         const ResourceEntryMap &getEntries() const { return mEntries; }
 
         /// Must be called from main thread.

OgreMain/include/OgreWindow.h

@@ -81,6 +81,8 @@ namespace Ogre
 
         void setFinalResolution( uint32 widthPx, uint32 heightPx );
 
+        static bool requestedMemoryless( const NameValuePairList *ogre_nullable miscParams );
+
     public:
         Window( const String &title, uint32 widthPt, uint32 heightPt, bool fullscreenMode );
         virtual ~Window();
@@ -288,7 +290,8 @@ namespace Ogre
         void _setPrimary();
         bool isPrimary() const;
 
-        virtual void _initialize( TextureGpuManager *textureGpuManager ) = 0;
+        virtual void _initialize( TextureGpuManager                     *textureGpuManager,
+                                  const NameValuePairList *ogre_nullable miscParams ) = 0;
 
         /// Overloaded version of getMetrics from RenderTarget, including extra details
         /// specific to windowing systems. Result is in pixels.

OgreMain/src/GLX/OgreConfigDialog.cpp

@@ -94,7 +94,7 @@ namespace Ogre
     {
         /* GUI constants */
         static const int wWidth = 600;   // Width of window
-        static const int wHeight = 380;  // Height of window
+        static const int wHeight = 420;  // Height of window
         static const int col1x = 20;     // Starting x of column 1 (labels)
         static const int col2x = 220;    // Starting x of column 2 (options)
         static const int col1w = 180;    // Width of column 1 (labels)

OgreMain/src/OgreAsyncTextureTicket.cpp

@@ -87,6 +87,8 @@ namespace Ogre
         assert( ( !textureSrc->isMultisample() || !textureSrc->hasMsaaExplicitResolves() ||
                   textureSrc->isOpenGLRenderWindow() ) &&
                 "Cannot download from an explicitly resolved MSAA texture!" );
+        OGRE_ASSERT_LOW( !textureSrc->isTilerMemoryless() &&
+                         "Cannot download from a memoryless texture!" );
     }
     //-----------------------------------------------------------------------------------
     void AsyncTextureTicket::notifyTextureChanged( TextureGpu *texture,

OgreMain/src/OgreRenderPassDescriptor.cpp

@@ -163,6 +163,47 @@ namespace Ogre
             mRequiresTextureFlipping = mColour[0].resolveTexture->requiresTextureFlipping();
     }
     //-----------------------------------------------------------------------------------
+    void RenderPassDescriptor::validateMemorylessTexture( const TextureGpu *texture,
+                                                          const LoadAction::LoadAction loadAction,
+                                                          const StoreAction::StoreAction storeAction,
+                                                          const bool bIsDepthStencil )
+    {
+        if( !texture->isTilerMemoryless() )
+            return;
+
+        if( loadAction != LoadAction::Clear && loadAction != LoadAction::DontCare &&
+            loadAction != LoadAction::ClearOnTilers )
+        {
+            OGRE_EXCEPT( Exception::ERR_INVALIDPARAMS,
+                         "Texture '" + texture->getNameStr() +
+                             "' is TilerMemoryless. For load actions it can only use clear, "
+                             "dont_care or clear_on_tilers.",
+                         "RenderPassDescriptor::validateMemorylessTexture" );
+        }
+
+        if( !texture->isMultisample() || bIsDepthStencil )
+        {
+            if( storeAction != StoreAction::DontCare )
+            {
+                OGRE_EXCEPT( Exception::ERR_INVALIDPARAMS,
+                             "Texture '" + texture->getNameStr() +
+                                 "' is TilerMemoryless. For store actions it can only use dont_care.",
+                             "RenderPassDescriptor::validateMemorylessTexture" );
+            }
+        }
+        else
+        {
+            if( storeAction != StoreAction::DontCare && storeAction != StoreAction::MultisampleResolve )
+            {
+                OGRE_EXCEPT( Exception::ERR_INVALIDPARAMS,
+                             "MSAA Texture '" + texture->getNameStr() +
+                                 "' is TilerMemoryless. For store actions it can only use dont_care "
+                                 "or resolve.",
+                             "RenderPassDescriptor::validateMemorylessTexture" );
+            }
+        }
+    }
+    //-----------------------------------------------------------------------------------
     void RenderPassDescriptor::colourEntriesModified()
     {
         mNumColourEntries = 0;
@@ -176,6 +217,9 @@ namespace Ogre
         {
             const RenderPassColourTarget &colourEntry = mColour[mNumColourEntries];
 
+            validateMemorylessTexture( colourEntry.texture, colourEntry.loadAction,
+                                       colourEntry.storeAction, false );
+
             if( colourEntry.texture->isRenderWindowSpecific() )
             {
                 RenderPassColourTarget &colourEntryRW = mColour[mNumColourEntries];
@@ -208,6 +252,14 @@ namespace Ogre
                                  "RenderPassDescriptor::colourEntriesModified" );
                 }
 
+                if( colourEntry.resolveTexture->isTilerMemoryless() )
+                {
+                    OGRE_EXCEPT( Exception::ERR_INVALIDPARAMS,
+                                 "Resolving to Texture '" + colourEntry.resolveTexture->getNameStr() +
+                                     "' which is memoryless!",
+                                 "RenderPassDescriptor::colourEntriesModified" );
+                }
+
                 if( colourEntry.texture != colourEntry.resolveTexture &&
                     !colourEntry.texture->hasMsaaExplicitResolves() )
                 {
@@ -305,6 +357,8 @@ namespace Ogre
                                  "RenderPassDescriptor::entriesModified" );
                 }
             }
+
+            validateMemorylessTexture( mDepth.texture, mDepth.loadAction, mDepth.storeAction, true );
         }
 
         if( mStencil.texture && mStencil.texture != mDepth.texture )
@@ -323,6 +377,9 @@ namespace Ogre
                                  "RenderPassDescriptor::entriesModified" );
                 }
             }
+
+            validateMemorylessTexture( mStencil.texture, mStencil.loadAction, mStencil.storeAction,
+                                       true );
         }
 
         checkRequiresTextureFlipping();

OgreMain/src/OgreRenderSystem.cpp

@@ -675,6 +675,9 @@ namespace Ogre
         if( !preferDepthTexture )
             textureFlags |= TextureFlags::NotTexture | TextureFlags::DiscardableContent;
 
+        if( colourTexture->getDepthBufferPoolId() == DepthBuffer::POOL_MEMORYLESS )
+            textureFlags |= TextureFlags::TilerMemoryless;
+
         char tmpBuffer[64];
         LwString depthBufferName( LwString::FromEmptyPointer( tmpBuffer, sizeof( tmpBuffer ) ) );
         depthBufferName.a( "DepthBuffer_", Id::generateNewId<TextureGpu>() );

OgreMain/src/OgreStagingTexture.cpp

@@ -135,6 +135,14 @@ namespace Ogre
                 "Did you modify it? Did it get corrupted?" );
         assert( ( !cpuSrcBox || srcBox.equalSize( *cpuSrcBox ) ) && "Src & cpuSrcBox must be equal" );
 
+        if( dstTexture->isTilerMemoryless() )
+        {
+            OGRE_EXCEPT(
+                Exception::ERR_INVALIDPARAMS,
+                "Cannot upload to texture '" + dstTexture->getNameStr() + "' because it's memoryless.",
+                "StagingTexture::upload" );
+        }
+
         if( dstTexture->isMultisample() )
         {
             OGRE_EXCEPT(

OgreMain/src/OgreTextureGpu.cpp

@@ -30,6 +30,7 @@ THE SOFTWARE.
 
 #include "OgreTextureGpu.h"
 
+#include "OgreDepthBuffer.h"
 #include "OgreException.h"
 #include "OgreLogManager.h"
 #include "OgreLwString.h"
@@ -668,6 +669,8 @@ namespace Ogre
         assert( this != dst || !srcBox.overlaps( dstBox ) );
         assert( srcMipLevel < this->getNumMipmaps() && dstMipLevel < dst->getNumMipmaps() );
         OGRE_ASSERT_LOW( ( this->getOrientationMode() & 0x01 ) == ( dst->getOrientationMode() & 0x01 ) );
+        OGRE_ASSERT_LOW( !this->isTilerMemoryless() );
+        OGRE_ASSERT_LOW( !dst->isTilerMemoryless() );
     }
     //-----------------------------------------------------------------------------------
     void TextureGpu::_setDepthBufferDefaults( uint16 depthBufferPoolId, bool preferDepthTexture,
@@ -912,6 +915,8 @@ namespace Ogre
         if( this->getInternalWidth() == colourTarget->getInternalWidth() &&
             this->getInternalHeight() == colourTarget->getInternalHeight() &&
             this->getSampleDescription() == colourTarget->getSampleDescription() &&
+            this->isTilerMemoryless() ==
+                ( colourTarget->getDepthBufferPoolId() == DepthBuffer::POOL_MEMORYLESS ) &&
             this->isRenderWindowSpecific() == colourTarget->isRenderWindowSpecific() )
         {
             return true;

OgreMain/src/OgreTextureGpuManager.cpp

@@ -100,6 +100,7 @@ namespace Ogre
     TextureGpuManager::TextureGpuManager( VaoManager *vaoManager, RenderSystem *renderSystem ) :
         mDefaultMipmapGen( DefaultMipmapGen::HwMode ),
         mDefaultMipmapGenCubemaps( DefaultMipmapGen::SwMode ),
+        mAllowMemoryLess( false ),
         mShuttingDown( false ),
         mUseMultiload( false ),
         mTryLockMutexFailureCount( 0u ),
@@ -2093,6 +2094,23 @@ namespace Ogre
         return mDefaultMipmapGenCubemaps;
     }
     //-----------------------------------------------------------------------------------
+    void TextureGpuManager::setAllowMemoryless( const bool bAllowMemoryLess )
+    {
+        if( !mRenderSystem->getCapabilities()->hasCapability( RSC_IS_TILER ) )
+        {
+            mAllowMemoryLess = false;
+            LogManager::getSingleton().logMessage(
+                "Device is NOT tiler. TilerMemoryless flag will be ignored." );
+        }
+        else
+        {
+            mAllowMemoryLess = bAllowMemoryLess;
+            LogManager::getSingleton().logMessage(
+                String( "Device IS tiler. TilerMemoryless flag will be: " ) +
+                ( bAllowMemoryLess ? "allowed." : "ignored" ) );
+        }
+    }
+    //-----------------------------------------------------------------------------------
     void TextureGpuManager::_reserveSlotForTexture( TextureGpu *texture )
     {
         bool matchFound = false;

OgreMain/src/OgreWindow.cpp

@@ -31,6 +31,7 @@ THE SOFTWARE.
 #include "OgreWindow.h"
 
 #include "OgreException.h"
+#include "OgreStringConverter.h"
 
 namespace Ogre
 {
@@ -71,6 +72,20 @@ namespace Ogre
         if( mStencilBuffer )
             mStencilBuffer->setResolution( widthPx, heightPx, 1u );
     }
+    //-------------------------------------------------------------------------
+    bool Window::requestedMemoryless( const NameValuePairList *ogre_nullable miscParams )
+    {
+        if( !miscParams )
+            return false;
+
+        NameValuePairList::const_iterator opt;
+        NameValuePairList::const_iterator end = miscParams->end();
+
+        opt = miscParams->find( "memoryless_depth_buffer" );
+        if( opt != end )
+            return StringConverter::parseBool( opt->second );
+        return false;
+    }
     //-----------------------------------------------------------------------------------
     void Window::setTitle( const String &title ) { mTitle = title; }
     //-----------------------------------------------------------------------------------

RenderSystems/Direct3D11/include/OgreD3D11Window.h

@@ -123,7 +123,8 @@ namespace Ogre
                                    D3D11RenderSystem *renderSystem );
         ~D3D11WindowSwapChainBased() override;
 
-        void _initialize( TextureGpuManager *textureGpuManager ) override;
+        void _initialize( TextureGpuManager                     *textureGpuManager,
+                          const NameValuePairList *ogre_nullable miscParams ) override;
         void destroy() override;
 
         /// @copydoc Window::setFsaa

RenderSystems/Direct3D11/include/Windowing/WIN32/OgreD3D11WindowHwnd.h

@@ -73,7 +73,8 @@ namespace Ogre
                          D3D11Device &device, D3D11RenderSystem *renderSystem );
         ~D3D11WindowHwnd() override;
 
-        void _initialize( TextureGpuManager *textureGpuManager ) override;
+        void _initialize( TextureGpuManager                     *textureGpuManager,
+                          const NameValuePairList *ogre_nullable miscParams ) override;
         void destroy() override;
 
         void reposition( int32 left, int32 top ) override;

RenderSystems/Direct3D11/src/OgreD3D11RenderSystem.cpp

@@ -1029,7 +1029,7 @@ namespace Ogre
             mSecondaryWindows.push_back( win );
         }
 
-        win->_initialize( mTextureGpuManager );
+        win->_initialize( mTextureGpuManager, miscParams );
 
         return win;
     }

RenderSystems/Direct3D11/src/OgreD3D11Window.cpp

@@ -171,7 +171,8 @@ namespace Ogre
         return mUseFlipMode ? 2 : mRenderSystem->getVaoManager()->getDynamicBufferMultiplier() - 1u;
     }
     //-----------------------------------------------------------------------------------
-    void D3D11WindowSwapChainBased::_initialize( TextureGpuManager *textureGpuManager )
+    void D3D11WindowSwapChainBased::_initialize( TextureGpuManager *textureGpuManager,
+                                                 const NameValuePairList * )
     {
         _createSwapChain();
 

RenderSystems/Direct3D11/src/Windowing/WIN32/OgreD3D11WindowHwnd.cpp

@@ -470,9 +470,10 @@ namespace Ogre
         setHidden( mHidden );
     }
     //-----------------------------------------------------------------------------------
-    void D3D11WindowHwnd::_initialize( TextureGpuManager *textureGpuManager )
+    void D3D11WindowHwnd::_initialize( TextureGpuManager *textureGpuManager,
+                                       const NameValuePairList *miscParams )
     {
-        D3D11WindowSwapChainBased::_initialize( textureGpuManager );
+        D3D11WindowSwapChainBased::_initialize( textureGpuManager, miscParams );
 
         IDXGIFactory1 *dxgiFactory1 = mDevice.GetDXGIFactory();
         dxgiFactory1->MakeWindowAssociation( mHwnd,

RenderSystems/GL3Plus/include/windowing/GLX/OgreGLXWindow.h

@@ -36,6 +36,8 @@ THE SOFTWARE.
 
 namespace Ogre
 {
+    OGRE_ASSUME_NONNULL_BEGIN
+
     class _OgrePrivate GLXWindow final : public Window
     {
     protected:
@@ -60,7 +62,8 @@ namespace Ogre
                    GLXGLSupport *glsupport );
         ~GLXWindow() override;
 
-        void _initialize( TextureGpuManager *textureManager ) override;
+        void _initialize( TextureGpuManager                     *textureManager,
+                          const NameValuePairList *ogre_nullable miscParams ) override;
 
         void setVSync( bool vSync, uint32 vSyncInterval ) override;
         void reposition( int32 left, int32 top ) override;
@@ -108,6 +111,8 @@ namespace Ogre
 
         bool requiresTextureFlipping() const { return false; }
     };
+
+    OGRE_ASSUME_NONNULL_END
 }  // namespace Ogre
 
 #endif