Refactor the Managed Surfaces to be able to send a stateful ISwapchainResources more easily

Author: devshgraphicsprogramming

examples_tests

@@ -34,6 +34,23 @@ class CSimpleResizeSurface final : public ISimpleManagedSurface
 			return core::smart_refctd_ptr<this_t>(new this_t(std::move(_surface),cb),core::dont_grab);
 		}
 
+		//
+		inline bool init(CThreadSafeQueueAdapter* queue, std::unique_ptr<SwapchainResources>&& scResources, const ISwapchain::SSharedCreationParams& sharedParams={})
+		{
+			if (!scResources || !base_init(queue))
+				return init_fail();
+
+			m_sharedParams = sharedParams;
+			if (!m_sharedParams.deduce(queue->getOriginDevice()->getPhysicalDevice(),getSurface()))
+				return init_fail();
+
+			m_swapchainResources = std::move(scResources);
+			return true;
+		}
+		
+		// Can be public because we don't need to worry about mutexes unlike the Smooth Resize class
+		inline ISwapchainResources* getSwapchainResources() override {return m_swapchainResources.get();}
+
 		// need to see if the swapchain is invalidated (e.g. because we're starting from 0-area old Swapchain) and try to recreate the swapchain
 		inline uint8_t acquireNextImage()
 		{
@@ -56,25 +73,17 @@ class CSimpleResizeSurface final : public ISimpleManagedSurface
 		{
 			becomeIrrecoverable();
 		}
-		inline bool init_impl(const ISwapchain::SSharedCreationParams& sharedParams) override final
-		{
-			m_sharedParams = sharedParams;
-			if (!m_sharedParams.deduce(getAssignedQueue()->getOriginDevice()->getPhysicalDevice(),getSurface()))
-				return false;
-
-			m_swapchainResources = std::make_unique<SwapchainResources>();
-			return getSwapchainResources();
-		}
 
 		//
-		inline ISwapchainResources* getSwapchainResources() override {return m_swapchainResources.get();}
 		inline void becomeIrrecoverable() override {m_swapchainResources = nullptr;}
 
 		//
 		inline bool recreateSwapchain()
 		{
+			assert(m_swapchainResources);
 			// dont assign straight to `m_swapchainResources` because of complex refcounting and cycles
 			core::smart_refctd_ptr<ISwapchain> newSwapchain;
+			// TODO: This block of code could be rolled up into `ISimpleManagedSurface::ISwapchainResources` eventually
 			{
 				auto* surface = getSurface();
 				auto device = const_cast<ILogicalDevice*>(getAssignedQueue()->getOriginDevice());
@@ -114,7 +123,6 @@ class CSimpleResizeSurface final : public ISimpleManagedSurface
 			if (newSwapchain)
 			{
 				m_swapchainResources->invalidate();
-				m_swapchainResources = std::make_unique<SwapchainResources>();
 				return m_swapchainResources->onCreateSwapchain(getAssignedQueue()->getFamilyIndex(),std::move(newSwapchain));
 			}
 			else

include/nbl/video/utilities/CSimpleResizeSurface.h

@@ -26,9 +26,7 @@ class NBL_API2 ISmoothResizeSurface : public ISimpleManagedSurface
 
 			private:
 				friend class ISmoothResizeSurface;
-				// `recreator` owns the `ISurface`, which refcounts the `IWindow` which refcounts the callback, so fumb pointer to avoid cycles 
-				inline void setSwapchainRecreator(ISmoothResizeSurface* recreator) { m_recreator = recreator; }
-
+				// `recreator` owns the `ISurface`, which refcounts the `IWindow` which refcounts the callback, so dumb pointer to avoid cycles 
 				ISmoothResizeSurface* m_recreator = nullptr;
 		};
 
@@ -173,20 +171,21 @@ class NBL_API2 ISmoothResizeSurface : public ISimpleManagedSurface
 		}
 
 	protected:
+		inline void setSwapchainRecreator() {static_cast<ICallback*>(m_cb)->m_recreator=this;}
+
 		using ISimpleManagedSurface::ISimpleManagedSurface;
 		virtual inline ~ISmoothResizeSurface()
 		{
 			// stop any calls into explicit resizes
-			std::unique_lock guard(m_swapchainResourcesMutex);
-			static_cast<ICallback*>(m_cb)->setSwapchainRecreator(nullptr);
+			deinit_impl();
 		}
 
 		//
 		inline void deinit_impl() override final
 		{
 			// stop any calls into explicit resizes
 			std::unique_lock guard(m_swapchainResourcesMutex);
-			static_cast<ICallback*>(m_cb)->setSwapchainRecreator(nullptr);
+			static_cast<ICallback*>(m_cb)->m_recreator = nullptr;
 
 			m_lastPresent.source = {};
 			m_lastPresentSourceImage = nullptr;
@@ -208,38 +207,6 @@ class NBL_API2 ISmoothResizeSurface : public ISimpleManagedSurface
 			m_presentSemaphore = nullptr;
 		}
 
-		//
-		inline bool init_impl(const ISwapchain::SSharedCreationParams& sharedParams) override final
-		{
-			// swapchain callback already deinitialized, so no mutex needed here
-
-			auto queue = getAssignedQueue();
-			auto device = const_cast<ILogicalDevice*>(queue->getOriginDevice());
-
-			m_sharedParams = sharedParams;
-			if (!m_sharedParams.deduce(device->getPhysicalDevice(),getSurface()))
-				return false;
-
-			// want to keep using the same semaphore throughout the lifetime to not run into sync issues
-			if (!m_presentSemaphore)
-			{
-				m_presentSemaphore = device->createSemaphore(0u);
-				if (!m_presentSemaphore)
-					return false;
-			}
-
-			// transient commandbuffer and pool to perform the blits or other copies to SC images
-			auto pool = device->createCommandPool(queue->getFamilyIndex(),IGPUCommandPool::CREATE_FLAGS::RESET_COMMAND_BUFFER_BIT);
-			if (!pool || !pool->createCommandBuffers(IGPUCommandPool::BUFFER_LEVEL::PRIMARY,{m_cmdbufs.data(),getMaxFramesInFlight()}))
-				return false;
-
-			if (!createSwapchainResources())
-				return false;
-			
-			static_cast<ICallback*>(m_cb)->setSwapchainRecreator(this);
-			return true;
-		}
-
 		//
 		inline bool recreateSwapchain(const uint32_t w=0, const uint32_t h=0)
 		{
@@ -285,7 +252,7 @@ class NBL_API2 ISmoothResizeSurface : public ISimpleManagedSurface
 			if (newSwapchain)
 			{
 				swapchainResources->invalidate();
-				return createSwapchainResources()->onCreateSwapchain(getAssignedQueue()->getFamilyIndex(),std::move(newSwapchain));
+				return swapchainResources->onCreateSwapchain(getAssignedQueue()->getFamilyIndex(),std::move(newSwapchain));
 			}
 			else
 			{
@@ -403,18 +370,16 @@ class NBL_API2 ISmoothResizeSurface : public ISimpleManagedSurface
 				return ISimpleManagedSurface::present(imageIx,{waitSemaphores+1,1});
 		}
 
-		// Assume it will execute under a mutex
-		virtual ISwapchainResources* createSwapchainResources() = 0;
-
 		// Because the surface can start minimized (extent={0,0}) we might not be able to create the swapchain right away, so store creation parameters until we can create it.
 		ISwapchain::SSharedCreationParams m_sharedParams = {};
 
-	private:
+	protected:
 		// Have to use a second semaphore to make acquire-present pairs independent of each other, also because there can be no ordering ensured between present->acquire
 		core::smart_refctd_ptr<ISemaphore> m_presentSemaphore;
 		// Command Buffers for blitting/copying the Triple Buffers to Swapchain Images
 		std::array<core::smart_refctd_ptr<IGPUCommandBuffer>,ISwapchain::MaxImages> m_cmdbufs = {};
 
+	private:
 		// used to protect access to swapchain resources during present and recreateExplicit
 		std::mutex m_swapchainResourcesMutex;
 		// Why do we delay the swapchain recreate present until the rendering of the most recent present source is done? Couldn't we present whatever latest Triple Buffer is done?
@@ -451,24 +416,51 @@ class CSmoothResizeSurface final : public ISmoothResizeSurface
 			return core::smart_refctd_ptr<this_t>(new this_t(std::move(_surface),cb),core::dont_grab);
 		}
 
+		//
+		inline bool init(CThreadSafeQueueAdapter* queue, std::unique_ptr<SwapchainResources>&& scResources, const ISwapchain::SSharedCreationParams& sharedParams={})
+		{
+			// swapchain callback already deinitialized, so no mutex needed here
+			if (!scResources || !base_init(queue))
+				return init_fail();
+
+			auto device = const_cast<ILogicalDevice*>(queue->getOriginDevice());
+
+			m_sharedParams = sharedParams;
+			if (!m_sharedParams.deduce(device->getPhysicalDevice(),getSurface()))
+				return init_fail();
+
+			// want to keep using the same semaphore throughout the lifetime to not run into sync issues
+			if (!m_presentSemaphore)
+			{
+				m_presentSemaphore = device->createSemaphore(0u);
+				if (!m_presentSemaphore)
+					return init_fail();
+			}
+
+			// transient commandbuffer and pool to perform the blits or other copies to SC images
+			auto pool = device->createCommandPool(queue->getFamilyIndex(),IGPUCommandPool::CREATE_FLAGS::RESET_COMMAND_BUFFER_BIT);
+			if (!pool || !pool->createCommandBuffers(IGPUCommandPool::BUFFER_LEVEL::PRIMARY,{m_cmdbufs.data(),getMaxFramesInFlight()}))
+				return init_fail();
+
+			m_swapchainResources = std::move(scResources);
+			
+			setSwapchainRecreator();
+			return true;
+		}
+
 	protected:
 		using ISmoothResizeSurface::ISmoothResizeSurface;
 
 		inline bool checkQueueFamilyProps(const IPhysicalDevice::SQueueFamilyProperties& props) const override {return props.queueFlags.hasFlags(SwapchainResources::RequiredQueueFlags);}
 
-		// All of the below are called under a mutex
-		inline ISwapchainResources* createSwapchainResources() override
-		{
-			m_swapchainResources = core::make_smart_refctd_ptr<SwapchainResources>();
-			return m_swapchainResources.get();
-		}
+		// All of the below are called from under a mutex
 		inline ISimpleManagedSurface::ISwapchainResources* getSwapchainResources() override {return m_swapchainResources.get();}
 		inline void becomeIrrecoverable() override {m_swapchainResources = nullptr;}
 
 	private:
 		// As per the above, the swapchain might not be possible to create or recreate right away, so this might be
 		// either nullptr before the first successful acquire or the old to-be-retired swapchain.
-		core::smart_refctd_ptr<SwapchainResources> m_swapchainResources = {};
+		std::unique_ptr<SwapchainResources> m_swapchainResources = {};
 };
 
 }

include/nbl/video/utilities/CSmoothResizeSurface.h

@@ -103,19 +103,19 @@ class NBL_API2 ISimpleManagedSurface : public core::IReferenceCounted
 				// NOTE: Current class doesn't trigger it because it knows nothing about how and when to create or recreate a swapchain.
 				inline bool onCreateSwapchain(const uint8_t qFam, core::smart_refctd_ptr<ISwapchain>&& _swapchain)
 				{
-					swapchain = std::move(_swapchain);
-					auto device = const_cast<ILogicalDevice*>(swapchain->getOriginDevice());
+					auto device = const_cast<ILogicalDevice*>(_swapchain->getOriginDevice());
 					// create images
-					for (auto i=0u; i<swapchain->getImageCount(); i++)
+					for (auto i=0u; i<_swapchain->getImageCount(); i++)
 					{
-						images[i] = swapchain->createImage(i);
+						images[i] = _swapchain->createImage(i);
 						if (!images[i])
 						{
 							std::fill_n(images.begin(),i,nullptr);
 							return false;
 						}
 					}
 
+					swapchain = std::move(_swapchain);
 					if (!onCreateSwapchain_impl(qFam))
 					{
 						invalidate();
@@ -167,9 +167,26 @@ class NBL_API2 ISimpleManagedSurface : public core::IReferenceCounted
 			m_acquireSemaphore = 0;
 			m_acquireCount = 0;
 		}
+
+		//
+		inline bool irrecoverable() const {return !const_cast<ISimpleManagedSurface*>(this)->getSwapchainResources();}
+
+		//
+		inline CThreadSafeQueueAdapter* getAssignedQueue() const {return m_queue;}
+
+		// An interesting solution to the "Frames In Flight", our tiny wrapper class will have its own Timeline Semaphore incrementing with each acquire, and thats it.
+		inline uint64_t getAcquireCount() {return m_acquireCount;}
+		inline ISemaphore* getAcquireSemaphore() {return m_acquireSemaphore.get();}
+
+	protected: // some of the methods need to stay protected in this base class because they need to be performed under a Mutex for smooth resize variants
+		inline ISimpleManagedSurface(core::smart_refctd_ptr<ISurface>&& _surface, ICallback* _cb) : m_surface(std::move(_surface)), m_cb(_cb) {}
+		virtual inline ~ISimpleManagedSurface() = default;
+		
+		virtual inline bool checkQueueFamilyProps(const IPhysicalDevice::SQueueFamilyProperties& props) const {return true;}
 
 		// We need to defer the swapchain creation till the Physical Device is chosen and Queues are created together with the Logical Device
-		inline bool init(CThreadSafeQueueAdapter* queue, const ISwapchain::SSharedCreationParams& sharedParams={})
+		// Generally you should have a regular `init` in the final derived class to call this
+		inline bool base_init(CThreadSafeQueueAdapter* queue)
 		{
 			deinit();
 			if (queue)
@@ -191,33 +208,20 @@ class NBL_API2 ISimpleManagedSurface : public core::IReferenceCounted
 					{
 						m_acquireSemaphore = device->createSemaphore(0u);
 						if (m_acquireSemaphore)
-						{
-							if (init_impl(sharedParams))
-								return true;
-						}
+							return true;
 					}
 				}
 			}
+			return init_fail();
+		}
+
+		// just a simple convenience wrapper
+		inline bool init_fail()
+		{
 			deinit();
 			return false;
 		}
 
-		//
-		inline bool irrecoverable() const {return !const_cast<ISimpleManagedSurface*>(this)->getSwapchainResources();}
-
-		//
-		inline CThreadSafeQueueAdapter* getAssignedQueue() const {return m_queue;}
-
-		// An interesting solution to the "Frames In Flight", our tiny wrapper class will have its own Timeline Semaphore incrementing with each acquire, and thats it.
-		inline uint64_t getAcquireCount() {return m_acquireCount;}
-		inline ISemaphore* getAcquireSemaphore() {return m_acquireSemaphore.get();}
-
-	protected: // some of the methods need to stay protected in this base class because they need to be performed under a Mutex for smooth resize variants
-		inline ISimpleManagedSurface(core::smart_refctd_ptr<ISurface>&& _surface, ICallback* _cb) : m_surface(std::move(_surface)), m_cb(_cb) {}
-		virtual inline ~ISimpleManagedSurface() = default;
-		
-		virtual inline bool checkQueueFamilyProps(const IPhysicalDevice::SQueueFamilyProperties& props) const {return true;}
-
 		// RETURNS: `ISwapchain::MaxImages` on failure, otherwise its the acquired image's index.
 		inline uint8_t acquireNextImage()
 		{
@@ -305,9 +309,6 @@ class NBL_API2 ISimpleManagedSurface : public core::IReferenceCounted
 		//
 		virtual void deinit_impl() = 0;
 
-		// Generally used to check that per-swapchain resources can be created (including the swapchain itself)
-		virtual bool init_impl(const ISwapchain::SSharedCreationParams& sharedParams) = 0;
-
 		//
 		ICallback* const m_cb = nullptr;