Graphics: Replace RenderFrame by RenderResources

This changes makes the whole rendering independent from the RenderFrame acquired from the Swapchain. This may allow to do offscreen rendering (= without swapchain), or multi-window rendering in the future
2023-11-21 23:33:18 +01:00 · 2023-11-21 23:33:18 +01:00 · 1e81b38c0f
parent d7d5c09428
commit 1e81b38c0f
66 changed files with 213 additions and 196 deletions
--- a/include/Nazara/Graphics/BakedFrameGraph.hpp
+++ b/include/Nazara/Graphics/BakedFrameGraph.hpp
@ -22,7 +22,7 @@

 namespace Nz
 {
-	class RenderFrame;
+	class RenderResources;

 	class NAZARA_GRAPHICS_API BakedFrameGraph
 	{
@ -34,12 +34,12 @@ namespace Nz
 			BakedFrameGraph(BakedFrameGraph&&) noexcept = default;
 			~BakedFrameGraph() = default;

-			void Execute(RenderFrame& renderFrame);
+			void Execute(RenderResources& renderResources);

 			const std::shared_ptr<Texture>& GetAttachmentTexture(std::size_t attachmentIndex) const;
 			const std::shared_ptr<RenderPass>& GetRenderPass(std::size_t passIndex) const;

-			bool Resize(RenderFrame& renderFrame, std::span<Vector2ui> viewerTargetSizes);
+			bool Resize(RenderResources& renderResources, std::span<Vector2ui> viewerTargetSizes);

 			BakedFrameGraph& operator=(const BakedFrameGraph&) = delete;
 			BakedFrameGraph& operator=(BakedFrameGraph&&) noexcept = default;
--- a/include/Nazara/Graphics/DirectionalLightShadowData.hpp
+++ b/include/Nazara/Graphics/DirectionalLightShadowData.hpp
@ -37,7 +37,7 @@ namespace Nz

 			inline bool IsShadowStabilization() const;

-			void PrepareRendering(RenderFrame& renderFrame, const AbstractViewer* viewer) override;
+			void PrepareRendering(RenderResources& renderResources, const AbstractViewer* viewer) override;

 			void RegisterMaterialInstance(const MaterialInstance& matInstance) override;
 			void RegisterPassInputs(FramePass& pass, const AbstractViewer* viewer) override;
--- a/include/Nazara/Graphics/ElementRenderer.hpp
+++ b/include/Nazara/Graphics/ElementRenderer.hpp
@ -24,7 +24,7 @@ namespace Nz
 {
 	class CommandBufferBuilder;
 	class RenderElement;
-	class RenderFrame;
+	class RenderResources;
 	class Texture;
 	class ViewerInstance;
 	struct ElementRendererData;
@ -40,10 +40,10 @@ namespace Nz
 			virtual RenderElementPoolBase& GetPool() = 0;

 			virtual std::unique_ptr<ElementRendererData> InstanciateData() = 0;
-			virtual void Prepare(const ViewerInstance& viewerInstance, ElementRendererData& rendererData, RenderFrame& currentFrame, std::size_t elementCount, const Pointer<const RenderElement>* elements, SparsePtr<const RenderStates> renderStates);
-			virtual void PrepareEnd(RenderFrame& currentFrame, ElementRendererData& rendererData);
+			virtual void Prepare(const ViewerInstance& viewerInstance, ElementRendererData& rendererData, RenderResources& currentFrame, std::size_t elementCount, const Pointer<const RenderElement>* elements, SparsePtr<const RenderStates> renderStates);
+			virtual void PrepareEnd(RenderResources& currentFrame, ElementRendererData& rendererData);
 			virtual void Render(const ViewerInstance& viewerInstance, ElementRendererData& rendererData, CommandBufferBuilder& commandBuffer, std::size_t elementCount, const Pointer<const RenderElement>* elements) = 0;
-			virtual void Reset(ElementRendererData& rendererData, RenderFrame& currentFrame);
+			virtual void Reset(ElementRendererData& rendererData, RenderResources& renderResources);

 			struct RenderStates
 			{
--- a/include/Nazara/Graphics/ForwardFramePipeline.hpp
+++ b/include/Nazara/Graphics/ForwardFramePipeline.hpp
@ -62,7 +62,7 @@ namespace Nz
 			const LightShadowData* RetrieveLightShadowData(std::size_t lightIndex) const override;
 			const Texture* RetrieveLightShadowmap(std::size_t lightIndex, const AbstractViewer* viewer) const override;

-			void Render(RenderFrame& renderFrame) override;
+			void Render(RenderResources& renderResources) override;

 			void UnregisterLight(std::size_t lightIndex) override;
 			void UnregisterRenderable(std::size_t renderableIndex) override;
@ -176,7 +176,6 @@ namespace Nz
 			MemoryPool<SkeletonInstanceData> m_skeletonInstances;
 			MemoryPool<ViewerData> m_viewerPool;
 			MemoryPool<WorldInstanceData> m_worldInstances;
-			RenderFrame* m_currentRenderFrame;
 			UInt8 m_generationCounter;
 			bool m_rebuildFrameGraph;
 	};
--- a/include/Nazara/Graphics/ForwardPipelinePass.hpp
+++ b/include/Nazara/Graphics/ForwardPipelinePass.hpp
@ -55,12 +55,12 @@ namespace Nz
 			ForwardPipelinePass& operator=(ForwardPipelinePass&&) = delete;

 		private:
-			void OnTransfer(RenderFrame& renderFrame, CommandBufferBuilder& builder) override;
+			void OnTransfer(RenderResources& renderResources, CommandBufferBuilder& builder) override;

 			void PrepareDirectionalLights(void* lightMemory);
 			void PreparePointLights(void* lightMemory);
 			void PrepareSpotLights(void* lightMemory);
-			void PrepareLights(RenderFrame& renderFrame, const Frustumf& frustum, const Bitset<UInt64>& visibleLights);
+			void PrepareLights(RenderResources& renderResources, const Frustumf& frustum, const Bitset<UInt64>& visibleLights);

 			struct MaterialPassEntry
 			{
--- a/include/Nazara/Graphics/FramePass.hpp
+++ b/include/Nazara/Graphics/FramePass.hpp
@ -10,7 +10,6 @@
 #include <NazaraUtils/Prerequisites.hpp>
 #include <Nazara/Core/Color.hpp>
 #include <Nazara/Graphics/Config.hpp>
-#include <Nazara/Graphics/FramePassAttachment.hpp>
 #include <Nazara/Math/Rect.hpp>
 #include <Nazara/Renderer/Enums.hpp>
 #include <functional>
@ -23,7 +22,7 @@ namespace Nz
 	class BakedFrameGraph;
 	class CommandBufferBuilder;
 	class FrameGraph;
-	class RenderFrame;
+	class RenderResources;

 	enum class FramePassExecution
 	{
@ -35,8 +34,8 @@ namespace Nz
 	struct FramePassEnvironment
 	{
 		BakedFrameGraph& frameGraph;
+		RenderResources& renderResources;
 		Recti renderRect;
-		RenderFrame& renderFrame;
 	};

 	class NAZARA_GRAPHICS_API FramePass
--- a/include/Nazara/Graphics/FramePipeline.hpp
+++ b/include/Nazara/Graphics/FramePipeline.hpp
@ -25,7 +25,7 @@ namespace Nz
 	class LightShadowData;
 	class MaterialInstance;
 	class PipelineViewer;
-	class RenderFrame;
+	class RenderResources;

 	class NAZARA_GRAPHICS_API FramePipeline
 	{
@ -54,7 +54,7 @@ namespace Nz
 			virtual const LightShadowData* RetrieveLightShadowData(std::size_t lightIndex) const = 0;
 			virtual const Texture* RetrieveLightShadowmap(std::size_t lightIndex, const AbstractViewer* viewer) const = 0;

-			virtual void Render(RenderFrame& renderFrame) = 0;
+			virtual void Render(RenderResources& renderResources) = 0;

 			virtual void UnregisterLight(std::size_t lightIndex) = 0;
 			virtual void UnregisterRenderable(std::size_t renderableIndex) = 0;
@ -71,7 +71,7 @@ namespace Nz
 			FramePipeline& operator=(const FramePipeline&) = delete;
 			FramePipeline& operator=(FramePipeline&&) = delete;

-			NazaraSignal(OnTransfer, FramePipeline* /*pipeline*/, RenderFrame& /*renderFrame*/, CommandBufferBuilder& /*builder*/);
+			NazaraSignal(OnTransfer, FramePipeline* /*pipeline*/, RenderResources& /*renderResources*/, CommandBufferBuilder& /*builder*/);

 			static constexpr std::size_t NoSkeletonInstance = std::numeric_limits<std::size_t>::max();

--- a/include/Nazara/Graphics/FramePipelinePass.hpp
+++ b/include/Nazara/Graphics/FramePipelinePass.hpp
@ -24,7 +24,7 @@ namespace Nz
 	class FramePipeline;
 	class InstancedRenderable;
 	class MaterialInstance;
-	class RenderFrame;
+	class RenderResources;
 	class SkeletonInstance;
 	class WorldInstance;

@ -60,7 +60,7 @@ namespace Nz
 			{
 				const Bitset<UInt64>* visibleLights;
 				const Frustumf& frustum;
-				RenderFrame& renderFrame;
+				RenderResources& renderResources;
 				const std::vector<VisibleRenderable>& visibleRenderables;
 				std::size_t visibilityHash;
 			};
--- a/include/Nazara/Graphics/LightShadowData.hpp
+++ b/include/Nazara/Graphics/LightShadowData.hpp
@ -17,7 +17,7 @@ namespace Nz
 	class FrameGraph;
 	class FramePass;
 	class MaterialInstance;
-	class RenderFrame;
+	class RenderResources;
 	class Texture;

 	class NAZARA_GRAPHICS_API LightShadowData
@ -30,7 +30,7 @@ namespace Nz

 			inline bool IsPerViewer() const;

-			virtual void PrepareRendering(RenderFrame& renderFrame, [[maybe_unused]] const AbstractViewer* viewer) = 0;
+			virtual void PrepareRendering(RenderResources& renderResources, [[maybe_unused]] const AbstractViewer* viewer) = 0;

 			virtual void RegisterMaterialInstance(const MaterialInstance& matInstance) = 0;
 			virtual void RegisterPassInputs(FramePass& pass, const AbstractViewer* viewer) = 0;
--- a/include/Nazara/Graphics/MaterialInstance.hpp
+++ b/include/Nazara/Graphics/MaterialInstance.hpp
@ -82,7 +82,7 @@ namespace Nz
 			bool HasPass(std::string_view passName) const;
 			inline bool HasPass(std::size_t passIndex) const;

-			void OnTransfer(RenderFrame& renderFrame, CommandBufferBuilder& builder) override;
+			void OnTransfer(RenderResources& renderResources, CommandBufferBuilder& builder) override;

 			inline void SetTextureProperty(std::string_view propertyName, std::shared_ptr<Texture> texture);
 			inline void SetTextureProperty(std::string_view propertyName, std::shared_ptr<Texture> texture, const TextureSamplerInfo& samplerInfo);
--- a/include/Nazara/Graphics/PointLightShadowData.hpp
+++ b/include/Nazara/Graphics/PointLightShadowData.hpp
@ -28,7 +28,7 @@ namespace Nz
 			PointLightShadowData(PointLightShadowData&&) = delete;
 			~PointLightShadowData() = default;

-			void PrepareRendering(RenderFrame& renderFrame, const AbstractViewer* viewer) override;
+			void PrepareRendering(RenderResources& renderResources, const AbstractViewer* viewer) override;

 			void RegisterMaterialInstance(const MaterialInstance& matInstance) override;
 			void RegisterPassInputs(FramePass& pass, const AbstractViewer* viewer) override;
--- a/include/Nazara/Graphics/RenderTarget.hpp
+++ b/include/Nazara/Graphics/RenderTarget.hpp
@ -18,9 +18,9 @@ namespace Nz
 	class CommandBufferBuilder;
 	class Framebuffer;
 	class FrameGraph;
-	class RenderFrame;
 	class RenderPass;
 	class Texture;
+	class RenderResources;

 	class NAZARA_GRAPHICS_API RenderTarget
 	{
@ -29,7 +29,7 @@ namespace Nz
 			virtual ~RenderTarget();

 			virtual void OnBuildGraph(FrameGraph& frameGraph, std::size_t attachmentIndex) const = 0;
-			virtual void OnRenderEnd(RenderFrame& renderFrame, const BakedFrameGraph& frameGraph, std::size_t finalAttachment) const = 0;
+			virtual void OnRenderEnd(RenderResources& resources, const BakedFrameGraph& frameGraph, std::size_t finalAttachment) const = 0;

 			virtual const Vector2ui& GetSize() const = 0;

--- a/include/Nazara/Graphics/RenderTexture.hpp
+++ b/include/Nazara/Graphics/RenderTexture.hpp
@ -25,7 +25,7 @@ namespace Nz
 			~RenderTexture() = default;

 			void OnBuildGraph(FrameGraph& graph, std::size_t attachmentIndex) const override;
-			void OnRenderEnd(RenderFrame& renderFrame, const BakedFrameGraph& frameGraph, std::size_t finalAttachment) const override;
+			void OnRenderEnd(RenderResources& resources, const BakedFrameGraph& frameGraph, std::size_t finalAttachment) const override;

 			const Vector2ui& GetSize() const override;

--- a/include/Nazara/Graphics/RenderTextureBlit.hpp
+++ b/include/Nazara/Graphics/RenderTextureBlit.hpp
@ -27,7 +27,7 @@ namespace Nz
 			~RenderTextureBlit() = default;

 			void OnBuildGraph(FrameGraph& graph, std::size_t attachmentIndex) const override;
-			void OnRenderEnd(RenderFrame& renderFrame, const BakedFrameGraph& frameGraph, std::size_t finalAttachment) const override;
+			void OnRenderEnd(RenderResources& resources, const BakedFrameGraph& frameGraph, std::size_t finalAttachment) const override;

 			const Vector2ui& GetSize() const override;

--- a/include/Nazara/Graphics/RenderWindow.hpp
+++ b/include/Nazara/Graphics/RenderWindow.hpp
@ -26,7 +26,7 @@ namespace Nz
 			~RenderWindow() = default;

 			void OnBuildGraph(FrameGraph& graph, std::size_t attachmentIndex) const override;
-			void OnRenderEnd(RenderFrame& renderFrame, const BakedFrameGraph& frameGraph, std::size_t attachmentId) const override;
+			void OnRenderEnd(RenderResources& renderResources, const BakedFrameGraph& frameGraph, std::size_t attachmentId) const override;

 			const Vector2ui& GetSize() const override;

--- a/include/Nazara/Graphics/SkeletonInstance.hpp
+++ b/include/Nazara/Graphics/SkeletonInstance.hpp
@ -36,7 +36,7 @@ namespace Nz
 			inline const std::shared_ptr<RenderBuffer>& GetSkeletalBuffer() const;
 			inline const std::shared_ptr<const Skeleton>& GetSkeleton() const;

-			void OnTransfer(RenderFrame& renderFrame, CommandBufferBuilder& builder) override;
+			void OnTransfer(RenderResources& renderResources, CommandBufferBuilder& builder) override;

 			SkeletonInstance& operator=(const SkeletonInstance&) = delete;
 			SkeletonInstance& operator=(SkeletonInstance&& skeletonInstance) noexcept;
--- a/include/Nazara/Graphics/SpotLightShadowData.hpp
+++ b/include/Nazara/Graphics/SpotLightShadowData.hpp
@ -28,7 +28,7 @@ namespace Nz

 			inline const ViewerInstance& GetViewerInstance() const;

-			void PrepareRendering(RenderFrame& renderFrame, [[maybe_unused]] const AbstractViewer* viewer) override;
+			void PrepareRendering(RenderResources& renderResources, [[maybe_unused]] const AbstractViewer* viewer) override;

 			void RegisterMaterialInstance(const MaterialInstance& matInstance) override;
 			void RegisterPassInputs(FramePass& pass, const AbstractViewer* viewer) override;
--- a/include/Nazara/Graphics/SpriteChainRenderer.hpp
+++ b/include/Nazara/Graphics/SpriteChainRenderer.hpp
@ -59,10 +59,10 @@ namespace Nz
 			RenderElementPool<RenderSpriteChain>& GetPool() override;

 			std::unique_ptr<ElementRendererData> InstanciateData() override;
-			void Prepare(const ViewerInstance& viewerInstance, ElementRendererData& rendererData, RenderFrame& currentFrame, std::size_t elementCount, const Pointer<const RenderElement>* elements, SparsePtr<const RenderStates> renderStates) override;
-			void PrepareEnd(RenderFrame& currentFrame, ElementRendererData& rendererData) override;
+			void Prepare(const ViewerInstance& viewerInstance, ElementRendererData& rendererData, RenderResources& currentFrame, std::size_t elementCount, const Pointer<const RenderElement>* elements, SparsePtr<const RenderStates> renderStates) override;
+			void PrepareEnd(RenderResources& renderResources, ElementRendererData& rendererData) override;
 			void Render(const ViewerInstance& viewerInstance, ElementRendererData& rendererData, CommandBufferBuilder& commandBuffer, std::size_t elementCount, const Pointer<const RenderElement>* elements) override;
-			void Reset(ElementRendererData& rendererData, RenderFrame& currentFrame) override;
+			void Reset(ElementRendererData& rendererData, RenderResources& currentFrame) override;

 		private:
 			void Flush();
--- a/include/Nazara/Graphics/SubmeshRenderer.hpp
+++ b/include/Nazara/Graphics/SubmeshRenderer.hpp
@ -27,9 +27,9 @@ namespace Nz
 			RenderElementPool<RenderSubmesh>& GetPool() override;

 			std::unique_ptr<ElementRendererData> InstanciateData() override;
-			void Prepare(const ViewerInstance& viewerInstance, ElementRendererData& rendererData, RenderFrame& currentFrame, std::size_t elementCount, const Pointer<const RenderElement>* elements, SparsePtr<const RenderStates> renderStates) override;
+			void Prepare(const ViewerInstance& viewerInstance, ElementRendererData& rendererData, RenderResources& renderResources, std::size_t elementCount, const Pointer<const RenderElement>* elements, SparsePtr<const RenderStates> renderStates) override;
 			void Render(const ViewerInstance& viewerInstance, ElementRendererData& rendererData, CommandBufferBuilder& commandBuffer, std::size_t elementCount, const Pointer<const RenderElement>* elements) override;
-			void Reset(ElementRendererData& rendererData, RenderFrame& currentFrame) override;
+			void Reset(ElementRendererData& rendererData, RenderResources& renderResources) override;

 		private:
 			std::vector<ShaderBinding::Binding> m_bindingCache;
--- a/include/Nazara/Graphics/TransferInterface.hpp
+++ b/include/Nazara/Graphics/TransferInterface.hpp
@ -14,7 +14,7 @@
 namespace Nz
 {
 	class CommandBufferBuilder;
-	class RenderFrame;
+	class RenderResources;

 	class NAZARA_GRAPHICS_API TransferInterface
 	{
@ -24,7 +24,7 @@ namespace Nz
 			TransferInterface(TransferInterface&&) = default;
 			virtual ~TransferInterface();

-			virtual void OnTransfer(RenderFrame& renderFrame, CommandBufferBuilder& builder) = 0;
+			virtual void OnTransfer(RenderResources& renderResources, CommandBufferBuilder& builder) = 0;

 			TransferInterface& operator=(const TransferInterface&) = default;
 			TransferInterface& operator=(TransferInterface&&) = default;
--- a/include/Nazara/Graphics/ViewerInstance.hpp
+++ b/include/Nazara/Graphics/ViewerInstance.hpp
@ -42,7 +42,7 @@ namespace Nz
 			inline std::shared_ptr<RenderBuffer>& GetViewerBuffer();
 			inline const std::shared_ptr<RenderBuffer>& GetViewerBuffer() const;

-			void OnTransfer(RenderFrame& renderFrame, CommandBufferBuilder& builder) override;
+			void OnTransfer(RenderResources& renderResources, CommandBufferBuilder& builder) override;

 			inline void UpdateEyePosition(const Vector3f& eyePosition);
 			inline void UpdateNearFarPlanes(float nearPlane, float farPlane);
--- a/include/Nazara/Graphics/WorldInstance.hpp
+++ b/include/Nazara/Graphics/WorldInstance.hpp
@ -36,7 +36,7 @@ namespace Nz
 			inline const Matrix4f& GetInvWorldMatrix() const;
 			inline const Matrix4f& GetWorldMatrix() const;

-			void OnTransfer(RenderFrame& renderFrame, CommandBufferBuilder& builder) override;
+			void OnTransfer(RenderResources& renderFrame, CommandBufferBuilder& builder) override;

 			inline void UpdateWorldMatrix(const Matrix4f& worldMatrix);
 			inline void UpdateWorldMatrix(const Matrix4f& worldMatrix, const Matrix4f& invWorldMatrix);
--- a/include/Nazara/OpenGLRenderer/OpenGLRenderImage.hpp
+++ b/include/Nazara/OpenGLRenderer/OpenGLRenderImage.hpp
@ -24,15 +24,19 @@ namespace Nz

 			void Execute(const FunctionRef<void(CommandBufferBuilder& builder)>& callback, QueueTypeFlags queueTypeFlags) override;

+			UInt32 GetImageIndex() const override;
 			OpenGLUploadPool& GetUploadPool() override;

 			void Present() override;

+			inline void Reset(UInt32 imageIndex);
+
 			void SubmitCommandBuffer(CommandBuffer* commandBuffer, QueueTypeFlags queueTypeFlags) override;

 		private:
 			OpenGLSwapchain& m_owner;
 			OpenGLUploadPool m_uploadPool;
+			UInt32 m_imageIndex;
 	};
 }

--- a/include/Nazara/OpenGLRenderer/OpenGLRenderImage.inl
+++ b/include/Nazara/OpenGLRenderer/OpenGLRenderImage.inl
@ -6,6 +6,10 @@

 namespace Nz
 {
+	inline void OpenGLRenderImage::Reset(UInt32 imageIndex)
+	{
+		m_imageIndex = imageIndex;
+	}
 }

 #include <Nazara/OpenGLRenderer/DebugOff.hpp>
--- a/include/Nazara/OpenGLRenderer/OpenGLSwapchain.hpp
+++ b/include/Nazara/OpenGLRenderer/OpenGLSwapchain.hpp
@ -33,7 +33,7 @@ namespace Nz

 			inline GL::Context& GetContext();
 			inline OpenGLDevice& GetDevice();
-			const OpenGLFramebuffer& GetFramebuffer(std::size_t i) const override;
+			const OpenGLFramebuffer& GetFramebuffer(std::size_t imageIndex) const override;
 			std::size_t GetFramebufferCount() const override;
 			PresentMode GetPresentMode() const override;
 			const OpenGLRenderPass& GetRenderPass() const override;
@ -46,17 +46,17 @@ namespace Nz

 			void SetPresentMode(PresentMode presentMode) override;

-			TransientResources& Transient() override;
+			RenderResources& GetTransientResources() override;

 		private:
 			std::optional<OpenGLRenderPass> m_renderPass;
-			std::size_t m_currentFrame;
 			std::shared_ptr<GL::Context> m_context;
 			std::vector<std::unique_ptr<OpenGLRenderImage>> m_renderImage;
 			OpenGLDevice& m_device;
 			OpenGLWindowFramebuffer m_framebuffer;
 			PresentMode m_presentMode;
 			PresentModeFlags m_supportedPresentModes;
+			UInt32 m_currentImageIndex;
 			Vector2ui m_size;
 			bool m_sizeInvalidated;
 	};
--- a/include/Nazara/Renderer.hpp
+++ b/include/Nazara/Renderer.hpp
@ -50,6 +50,7 @@
 #include <Nazara/Renderer/RenderPassCache.hpp>
 #include <Nazara/Renderer/RenderPipeline.hpp>
 #include <Nazara/Renderer/RenderPipelineLayout.hpp>
+#include <Nazara/Renderer/RenderResources.hpp>
 #include <Nazara/Renderer/RenderStates.hpp>
 #include <Nazara/Renderer/ShaderBinding.hpp>
 #include <Nazara/Renderer/ShaderModule.hpp>
@ -57,7 +58,6 @@
 #include <Nazara/Renderer/SwapchainParameters.hpp>
 #include <Nazara/Renderer/Texture.hpp>
 #include <Nazara/Renderer/TextureSampler.hpp>
-#include <Nazara/Renderer/TransientResources.hpp>
 #include <Nazara/Renderer/UploadPool.hpp>
 #include <Nazara/Renderer/WindowSwapchain.hpp>

--- a/include/Nazara/Renderer/DebugDrawer.hpp
+++ b/include/Nazara/Renderer/DebugDrawer.hpp
@ -23,10 +23,10 @@ namespace Nz
 {
 	class CommandBufferBuilder;
 	class RenderBuffer;
-	class RenderFrame;
 	class RenderDevice;
 	class RenderPipeline;
 	class RenderPipelineLayout;
+	class RenderResources;
 	class ShaderBinding;
 	class Skeleton;

@ -48,9 +48,9 @@ namespace Nz
 			inline void DrawPoint(const Vector3f& point, const Color& color, float boxSize = 0.01f);
 			void DrawSkeleton(const Skeleton& skeleton, const Color& color);

-			void Prepare(RenderFrame& renderFrame);
+			void Prepare(RenderResources& renderFrame);

-			void Reset(RenderFrame& renderFrame);
+			void Reset(RenderResources& renderFrame);

 			void SetViewerData(const Matrix4f& viewProjMatrix);

--- a/include/Nazara/Renderer/RenderFrame.hpp
+++ b/include/Nazara/Renderer/RenderFrame.hpp
@ -26,16 +26,17 @@ namespace Nz
 	{
 		public:
 			inline explicit RenderFrame();
-			inline explicit RenderFrame(RenderImage* renderImage, bool framebufferInvalidation, const Vector2ui& size, std::size_t framebufferIndex);
+			inline explicit RenderFrame(RenderImage* renderImage, bool framebufferInvalidation, const Vector2ui& size);
 			RenderFrame(const RenderFrame&) = delete;
 			RenderFrame(RenderFrame&&) = delete;
 			~RenderFrame() = default;

 			inline void Execute(const FunctionRef<void(CommandBufferBuilder& builder)>& callback, QueueTypeFlags queueTypeFlags);

-			inline std::size_t GetFramebufferIndex() const;
+			inline std::size_t GetImageIndex() const;
 			const Vector2ui& GetSize() const;
 			inline RenderDevice& GetRenderDevice();
+			inline RenderResources& GetTransientResources();
 			inline UploadPool& GetUploadPool();

 			inline bool IsFramebufferInvalidated() const;
@ -48,12 +49,12 @@ namespace Nz
 			void SubmitCommandBuffer(CommandBuffer* commandBuffer, QueueTypeFlags queueTypeFlags) ;

 			inline explicit operator bool();
+			inline operator RenderResources&();

 			RenderFrame& operator=(const RenderFrame&) = delete;
 			RenderFrame& operator=(RenderFrame&&) = delete;

 		private:
-			std::size_t m_framebufferIndex;
 			RenderImage* m_image;
 			Vector2ui m_size;
 			bool m_framebufferInvalidation;
--- a/include/Nazara/Renderer/RenderFrame.inl
+++ b/include/Nazara/Renderer/RenderFrame.inl
@ -7,12 +7,11 @@
 namespace Nz
 {
 	inline RenderFrame::RenderFrame() :
-	RenderFrame(nullptr, false, Vector2ui::Zero(), 0)
+	RenderFrame(nullptr, false, Vector2ui::Zero())
 	{
 	}

-	inline RenderFrame::RenderFrame(RenderImage* renderImage, bool framebufferInvalidation, const Vector2ui& size, std::size_t framebufferIndex) :
-	m_framebufferIndex(framebufferIndex),
+	inline RenderFrame::RenderFrame(RenderImage* renderImage, bool framebufferInvalidation, const Vector2ui& size) :
 	m_image(renderImage),
 	m_size(size),
 	m_framebufferInvalidation(framebufferInvalidation)
@ -27,9 +26,9 @@ namespace Nz
 		return m_image->Execute(callback, queueTypeFlags);
 	}

-	inline std::size_t RenderFrame::GetFramebufferIndex() const
+	inline std::size_t RenderFrame::GetImageIndex() const
 	{
-		return m_framebufferIndex;
+		return m_image->GetImageIndex();
 	}

 	inline const Vector2ui& RenderFrame::GetSize() const
@ -42,6 +41,11 @@ namespace Nz
 		return m_image->GetRenderDevice();
 	}

+	inline RenderResources& RenderFrame::GetTransientResources()
+	{
+		return *m_image;
+	}
+
 	inline UploadPool& RenderFrame::GetUploadPool()
 	{
 		if NAZARA_UNLIKELY(!m_image)
@ -90,11 +94,15 @@ namespace Nz
 		m_image->SubmitCommandBuffer(commandBuffer, queueTypeFlags);
 	}

-
 	inline RenderFrame::operator bool()
 	{
 		return m_image != nullptr;
 	}
+
+	inline RenderFrame::operator RenderResources&()
+	{
+		return GetTransientResources();
+	}
 }

 #include <Nazara/Renderer/DebugOff.hpp>
--- a/include/Nazara/Renderer/RenderImage.hpp
+++ b/include/Nazara/Renderer/RenderImage.hpp
@ -8,14 +8,14 @@
 #define NAZARA_RENDERER_RENDERIMAGE_HPP

 #include <NazaraUtils/Prerequisites.hpp>
-#include <Nazara/Renderer/TransientResources.hpp>
+#include <Nazara/Renderer/RenderResources.hpp>

 namespace Nz
 {
-	class NAZARA_RENDERER_API RenderImage : public TransientResources
+	class NAZARA_RENDERER_API RenderImage : public RenderResources
 	{
 		public:
-			using TransientResources::TransientResources;
+			using RenderResources::RenderResources;

 			virtual void Present() = 0;
 	};
--- a/include/Nazara/Renderer/TransientResources.hpp
+++ b/include/Nazara/Renderer/TransientResources.hpp
@ -4,8 +4,8 @@

 #pragma once

-#ifndef NAZARA_RENDERER_TRANSIENTRESOURCES_HPP
-#define NAZARA_RENDERER_TRANSIENTRESOURCES_HPP
+#ifndef NAZARA_RENDERER_RENDERRESOURCES_HPP
+#define NAZARA_RENDERER_RENDERRESOURCES_HPP

 #include <NazaraUtils/Prerequisites.hpp>
 #include <Nazara/Renderer/Config.hpp>
@ -22,18 +22,19 @@ namespace Nz
 	class RenderDevice;
 	class UploadPool;

-	class NAZARA_RENDERER_API TransientResources
+	class NAZARA_RENDERER_API RenderResources
 	{
 		public:
 			class Releasable;
 			template<typename T> class ReleasableLambda;

-			virtual ~TransientResources();
+			virtual ~RenderResources();

 			virtual void Execute(const FunctionRef<void(CommandBufferBuilder& builder)>& callback, QueueTypeFlags queueTypeFlags) = 0;

 			inline void FlushReleaseQueue();

+			virtual UInt32 GetImageIndex() const = 0;
 			inline RenderDevice& GetRenderDevice();
 			virtual UploadPool& GetUploadPool() = 0;

@ -44,9 +45,9 @@ namespace Nz
 			virtual void SubmitCommandBuffer(CommandBuffer* commandBuffer, QueueTypeFlags queueTypeFlags) = 0;

 		protected:
-			inline TransientResources(RenderDevice& renderDvice);
-			TransientResources(const TransientResources&) = delete;
-			TransientResources(TransientResources&&) = delete;
+			inline RenderResources(RenderDevice& renderDvice);
+			RenderResources(const RenderResources&) = delete;
+			RenderResources(RenderResources&&) = delete;

 		private:
 			static constexpr std::size_t BlockSize = 4 * 1024 * 1024;
@ -58,7 +59,7 @@ namespace Nz
 			RenderDevice& m_renderDevice;
 	};

-	class NAZARA_RENDERER_API TransientResources::Releasable
+	class NAZARA_RENDERER_API RenderResources::Releasable
 	{
 		public:
 			virtual ~Releasable();
@ -67,7 +68,7 @@ namespace Nz
 	};

 	template<typename T>
-	class TransientResources::ReleasableLambda : public Releasable
+	class RenderResources::ReleasableLambda : public Releasable
 	{
 		public:
 			template<typename U> ReleasableLambda(U&& lambda);
@ -85,6 +86,6 @@ namespace Nz
 	};
 }

-#include <Nazara/Renderer/TransientResources.inl>
+#include <Nazara/Renderer/RenderResources.inl>

-#endif // NAZARA_RENDERER_TRANSIENTRESOURCES_HPP
+#endif // NAZARA_RENDERER_RENDERRESOURCES_HPP
--- a/include/Nazara/Renderer/TransientResources.inl
+++ b/include/Nazara/Renderer/TransientResources.inl
@ -8,12 +8,12 @@

 namespace Nz
 {
-	inline TransientResources::TransientResources(RenderDevice& renderDevice) :
+	inline RenderResources::RenderResources(RenderDevice& renderDevice) :
 	m_renderDevice(renderDevice)
 	{
 	}

-	inline void TransientResources::FlushReleaseQueue()
+	inline void RenderResources::FlushReleaseQueue()
 	{
 		for (Releasable* releasable : m_releaseQueue)
 		{
@ -26,13 +26,13 @@ namespace Nz
 			memoryblock.clear();
 	}

-	inline RenderDevice& TransientResources::GetRenderDevice()
+	inline RenderDevice& RenderResources::GetRenderDevice()
 	{
 		return m_renderDevice;
 	}

 	template<typename T>
-	void TransientResources::PushForRelease(T&& value)
+	void RenderResources::PushForRelease(T&& value)
 	{
 		static_assert(std::is_rvalue_reference_v<decltype(value)>);

@ -40,7 +40,7 @@ namespace Nz
 	}

 	template<typename F>
-	void TransientResources::PushReleaseCallback(F&& callback)
+	void RenderResources::PushReleaseCallback(F&& callback)
 	{
 		using ReleaseFunctor = ReleasableLambda<std::remove_cv_t<std::remove_reference_t<F>>>;

@ -95,13 +95,13 @@ namespace Nz

 	template<typename T>
 	template<typename U>
-	TransientResources::ReleasableLambda<T>::ReleasableLambda(U&& lambda) :
+	RenderResources::ReleasableLambda<T>::ReleasableLambda(U&& lambda) :
 	m_lambda(std::forward<U>(lambda))
 	{
 	}

 	template<typename T>
-	void TransientResources::ReleasableLambda<T>::Release()
+	void RenderResources::ReleasableLambda<T>::Release()
 	{
 		m_lambda();
 	}
--- a/include/Nazara/Renderer/Swapchain.hpp
+++ b/include/Nazara/Renderer/Swapchain.hpp
@ -20,7 +20,7 @@ namespace Nz
 	class CommandPool;
 	class Framebuffer;
 	class RenderDevice;
-	class TransientResources;
+	class RenderResources;

 	class NAZARA_RENDERER_API Swapchain
 	{
@ -38,13 +38,12 @@ namespace Nz
 			virtual const RenderPass& GetRenderPass() const = 0;
 			virtual const Vector2ui& GetSize() const = 0;
 			virtual PresentModeFlags GetSupportedPresentModes() const = 0;
+			virtual RenderResources& GetTransientResources() = 0;

 			virtual void NotifyResize(const Vector2ui& newSize) = 0;

 			virtual void SetPresentMode(PresentMode presentMode) = 0;

-			virtual TransientResources& Transient() = 0;
-
 			NazaraSignal(OnSwapchainResize, Swapchain* /*swapchain*/, const Vector2ui& /*newSize*/);

 		protected:
--- a/include/Nazara/Renderer/WindowSwapchain.hpp
+++ b/include/Nazara/Renderer/WindowSwapchain.hpp
@ -39,8 +39,7 @@ namespace Nz
 			const Vector2ui& GetSize() const;
 			inline Swapchain* GetSwapchain();
 			inline const Swapchain* GetSwapchain() const;
-
-			inline TransientResources& Transient();
+			inline RenderResources& GetTransientResources();

 			WindowSwapchain& operator=(const WindowSwapchain&) = delete;
 			WindowSwapchain& operator=(WindowSwapchain&& windowSwapchain) = delete;
--- a/include/Nazara/Renderer/WindowSwapchain.inl
+++ b/include/Nazara/Renderer/WindowSwapchain.inl
@ -53,9 +53,9 @@ namespace Nz
 		return m_swapchain.get();
 	}

-	inline TransientResources& WindowSwapchain::Transient()
+	inline RenderResources& WindowSwapchain::GetTransientResources()
 	{
-		return m_swapchain->Transient();
+		return m_swapchain->GetTransientResources();
 	}

 	void WindowSwapchain::DisconnectSignals()
--- a/include/Nazara/VulkanRenderer/VulkanRenderImage.hpp
+++ b/include/Nazara/VulkanRenderer/VulkanRenderImage.hpp
@ -31,7 +31,7 @@ namespace Nz

 			inline Vk::Fence& GetInFlightFence();
 			inline Vk::Semaphore& GetImageAvailableSemaphore();
-			inline UInt32 GetImageIndex();
+			UInt32 GetImageIndex() const override;
 			inline Vk::Semaphore& GetRenderFinishedSemaphore();
 			VulkanUploadPool& GetUploadPool() override;

--- a/include/Nazara/VulkanRenderer/VulkanRenderImage.inl
+++ b/include/Nazara/VulkanRenderer/VulkanRenderImage.inl
@ -16,11 +16,6 @@ namespace Nz
 		return m_imageAvailableSemaphore;
 	}

-	inline UInt32 VulkanRenderImage::GetImageIndex()
-	{
-		return m_imageIndex;
-	}
-
 	inline Vk::Semaphore& VulkanRenderImage::GetRenderFinishedSemaphore()
 	{
 		return m_renderFinishedSemaphore;
--- a/include/Nazara/VulkanRenderer/VulkanSwapchain.hpp
+++ b/include/Nazara/VulkanRenderer/VulkanSwapchain.hpp
@ -57,6 +57,7 @@ namespace Nz
 			PresentMode GetPresentMode() const override;
 			PresentModeFlags GetSupportedPresentModes() const override;
 			inline const Vk::Swapchain& GetSwapchain() const;
+			RenderResources& GetTransientResources() override;

 			void NotifyResize(const Vector2ui& newSize) override;

@ -64,8 +65,6 @@ namespace Nz

 			void SetPresentMode(PresentMode presentMode) override;

-			TransientResources& Transient() override;
-
 			VulkanSwapchain& operator=(const VulkanSwapchain&) = delete;
 			VulkanSwapchain& operator=(VulkanSwapchain&&) = delete;

--- a/src/Nazara/Graphics/BakedFrameGraph.cpp
+++ b/src/Nazara/Graphics/BakedFrameGraph.cpp
@ -20,7 +20,7 @@ namespace Nz
 		m_commandPool = renderDevice->InstantiateCommandPool(QueueType::Graphics);
 	}

-	void BakedFrameGraph::Execute(RenderFrame& renderFrame)
+	void BakedFrameGraph::Execute(RenderResources& renderResources)
 	{
 		for (auto& passData : m_passes)
 		{
@ -35,7 +35,7 @@ namespace Nz
 					case FramePassExecution::Skip:
 						if (passData.commandBuffer)
 						{
-							renderFrame.PushForRelease(std::move(passData.commandBuffer));
+							renderResources.PushForRelease(std::move(passData.commandBuffer));
 							passData.commandBuffer.reset();
 						}
 						continue; //< Skip the pass
@ -50,7 +50,7 @@ namespace Nz
 				continue;

 			if (passData.commandBuffer)
-				renderFrame.PushForRelease(std::move(passData.commandBuffer));
+				renderResources.PushForRelease(std::move(passData.commandBuffer));

 			passData.commandBuffer = m_commandPool->BuildCommandBuffer([&](CommandBufferBuilder& builder)
 			{
@ -66,9 +66,9 @@ namespace Nz
 					builder.BeginDebugRegion(passData.name, Color::Green());

 				FramePassEnvironment env{
-					*this,
-					passData.renderRect,
-					renderFrame
+					.frameGraph = *this,
+					.renderResources = renderResources,
+					.renderRect = passData.renderRect
 				};

 				bool first = true;
@ -95,7 +95,7 @@ namespace Nz
 		for (auto& passData : m_passes)
 		{
 			if (passData.commandBuffer)
-				renderFrame.SubmitCommandBuffer(passData.commandBuffer.get(), QueueType::Graphics);
+				renderResources.SubmitCommandBuffer(passData.commandBuffer.get(), QueueType::Graphics);
 		}
 	}

@ -127,7 +127,7 @@ namespace Nz
 		return m_passes[physicalPassIndex].renderPass;
 	}

-	bool BakedFrameGraph::Resize(RenderFrame& renderFrame, std::span<Vector2ui> viewerTargetSizes)
+	bool BakedFrameGraph::Resize(RenderResources& renderResources, std::span<Vector2ui> viewerTargetSizes)
 	{
 		if (std::equal(m_viewerSizes.begin(), m_viewerSizes.end(), viewerTargetSizes.begin(), viewerTargetSizes.end()))
 			return false;
@ -159,10 +159,10 @@ namespace Nz
 		for (auto& passData : m_passes)
 		{
 			if (passData.commandBuffer)
-				renderFrame.PushForRelease(std::move(passData.commandBuffer));
+				renderResources.PushForRelease(std::move(passData.commandBuffer));

 			if (passData.framebuffer)
-				renderFrame.PushForRelease(std::move(passData.framebuffer));
+				renderResources.PushForRelease(std::move(passData.framebuffer));
 		}

 		for (auto& textureData : m_textures)
@ -177,7 +177,7 @@ namespace Nz
 				continue;

 			// Dimensions changed, recreated texture
-			renderFrame.PushForRelease(std::move(textureData.texture));
+			renderResources.PushForRelease(std::move(textureData.texture));
 		}

 		for (auto& textureData : m_textures)
--- a/src/Nazara/Graphics/DebugDrawPipelinePass.cpp
+++ b/src/Nazara/Graphics/DebugDrawPipelinePass.cpp
@ -16,7 +16,7 @@ namespace Nz
 	{
 		DebugDrawer& debugDrawer = m_pipeline.GetDebugDrawer();
 		debugDrawer.SetViewerData(m_viewer->GetViewerInstance().GetViewProjMatrix());
-		debugDrawer.Prepare(frameData.renderFrame);
+		debugDrawer.Prepare(frameData.renderResources);
 	}

 	FramePass& DebugDrawPipelinePass::RegisterToFrameGraph(FrameGraph& frameGraph, const PassInputOuputs& inputOuputs)
--- a/src/Nazara/Graphics/DepthPipelinePass.cpp
+++ b/src/Nazara/Graphics/DepthPipelinePass.cpp
@ -20,7 +20,7 @@ namespace Nz
 	{
 		if (m_lastVisibilityHash != frameData.visibilityHash || m_rebuildElements) //< FIXME
 		{
-			frameData.renderFrame.PushForRelease(std::move(m_renderElements));
+			frameData.renderResources.PushForRelease(std::move(m_renderElements));
 			m_renderElements.clear();

 			for (const auto& renderableData : frameData.visibleRenderables)
@ -67,7 +67,7 @@ namespace Nz
 					m_elementRendererData[elementType] = elementRenderer.InstanciateData();
 				}

-				elementRenderer.Reset(*m_elementRendererData[elementType], frameData.renderFrame);
+				elementRenderer.Reset(*m_elementRendererData[elementType], frameData.renderResources);
 			});

 			const auto& viewerInstance = m_viewer->GetViewerInstance();
@ -78,12 +78,12 @@ namespace Nz
 			{
 				ElementRenderer& elementRenderer = m_elementRegistry.GetElementRenderer(elementType);

-				elementRenderer.Prepare(viewerInstance, *m_elementRendererData[elementType], frameData.renderFrame, elementCount, elements, SparsePtr(&defaultRenderStates, 0));
+				elementRenderer.Prepare(viewerInstance, *m_elementRendererData[elementType], frameData.renderResources, elementCount, elements, SparsePtr(&defaultRenderStates, 0));
 			});

 			m_elementRegistry.ForEachElementRenderer([&](std::size_t elementType, ElementRenderer& elementRenderer)
 			{
-				elementRenderer.PrepareEnd(frameData.renderFrame, *m_elementRendererData[elementType]);
+				elementRenderer.PrepareEnd(frameData.renderResources, *m_elementRendererData[elementType]);
 			});

 			m_rebuildCommandBuffer = true;
--- a/src/Nazara/Graphics/DirectionalLightShadowData.cpp
+++ b/src/Nazara/Graphics/DirectionalLightShadowData.cpp
@ -40,7 +40,7 @@ namespace Nz
 		UpdatePerViewerStatus(true);
 	}

-	void DirectionalLightShadowData::PrepareRendering(RenderFrame& renderFrame, const AbstractViewer* viewer)
+	void DirectionalLightShadowData::PrepareRendering(RenderResources& renderResources, const AbstractViewer* viewer)
 	{
 		assert(viewer);
 		PerViewerData& viewerData = *Retrieve(m_viewerData, viewer);
@ -121,7 +121,7 @@ namespace Nz
 			FramePipelinePass::FrameData passData = {
 				nullptr,
 				frustum,
-				renderFrame,
+				renderResources,
 				visibleRenderables,
 				visibilityHash
 			};
--- a/src/Nazara/Graphics/ElementRenderer.cpp
+++ b/src/Nazara/Graphics/ElementRenderer.cpp
@ -9,15 +9,15 @@ namespace Nz
 {
 	ElementRenderer::~ElementRenderer() = default;

-	void ElementRenderer::Prepare(const ViewerInstance& /*viewerInstance*/, ElementRendererData& /*rendererData*/, RenderFrame& /*currentFrame*/, std::size_t /*elementCount*/, const Pointer<const RenderElement>* /*elements*/, SparsePtr<const RenderStates> /*renderStates*/)
+	void ElementRenderer::Prepare(const ViewerInstance& /*viewerInstance*/, ElementRendererData& /*rendererData*/, RenderResources& /*renderResources*/, std::size_t /*elementCount*/, const Pointer<const RenderElement>* /*elements*/, SparsePtr<const RenderStates> /*renderStates*/)
 	{
 	}

-	void ElementRenderer::PrepareEnd(RenderFrame& /*currentFrame*/, ElementRendererData& /*rendererData*/)
+	void ElementRenderer::PrepareEnd(RenderResources& /*renderResources*/, ElementRendererData& /*rendererData*/)
 	{
 	}

-	void ElementRenderer::Reset(ElementRendererData& /*rendererData*/, RenderFrame& /*currentFrame*/)
+	void ElementRenderer::Reset(ElementRendererData& /*rendererData*/, RenderResources& /*renderResources*/)
 	{
 	}

--- a/src/Nazara/Graphics/ForwardFramePipeline.cpp
+++ b/src/Nazara/Graphics/ForwardFramePipeline.cpp
@ -341,30 +341,28 @@ namespace Nz
 		return lightShadowData->RetrieveLightShadowmap(m_bakedFrameGraph, viewer);
 	}

-	void ForwardFramePipeline::Render(RenderFrame& renderFrame)
+	void ForwardFramePipeline::Render(RenderResources& renderResources)
 	{
-		m_currentRenderFrame = &renderFrame;
-
 		Graphics* graphics = Graphics::Instance();

 		// Destroy instances at the end of the frame
 		for (std::size_t skeletonInstanceIndex : m_removedSkeletonInstances.IterBits())
 		{
-			renderFrame.PushForRelease(std::move(*m_skeletonInstances.RetrieveFromIndex(skeletonInstanceIndex)));
+			renderResources.PushForRelease(std::move(*m_skeletonInstances.RetrieveFromIndex(skeletonInstanceIndex)));
 			m_skeletonInstances.Free(skeletonInstanceIndex);
 		}
 		m_removedSkeletonInstances.Clear();

 		for (std::size_t viewerIndex : m_removedViewerInstances.IterBits())
 		{
-			renderFrame.PushForRelease(std::move(*m_viewerPool.RetrieveFromIndex(viewerIndex)));
+			renderResources.PushForRelease(std::move(*m_viewerPool.RetrieveFromIndex(viewerIndex)));
 			m_viewerPool.Free(viewerIndex);
 		}
 		m_removedViewerInstances.Clear();

 		for (std::size_t worldInstanceIndex : m_removedWorldInstances.IterBits())
 		{
-			renderFrame.PushForRelease(std::move(*m_worldInstances.RetrieveFromIndex(worldInstanceIndex)));
+			renderResources.PushForRelease(std::move(*m_worldInstances.RetrieveFromIndex(worldInstanceIndex)));
 			m_worldInstances.Free(worldInstanceIndex);
 		}
 		m_removedWorldInstances.Clear();
@ -372,7 +370,7 @@ namespace Nz
 		bool frameGraphInvalidated = false;
 		if (m_rebuildFrameGraph)
 		{
-			renderFrame.PushForRelease(std::move(m_bakedFrameGraph));
+			renderResources.PushForRelease(std::move(m_bakedFrameGraph));
 			m_bakedFrameGraph = BuildFrameGraph();
 			frameGraphInvalidated = true;
 		}
@ -384,7 +382,7 @@ namespace Nz
 			viewerSizes.emplace_back(Vector2i(viewport.width, viewport.height));
 		}

-		frameGraphInvalidated |= m_bakedFrameGraph.Resize(renderFrame, viewerSizes);
+		frameGraphInvalidated |= m_bakedFrameGraph.Resize(renderResources, viewerSizes);

 		// Find active lights (i.e. visible in any frustum)
 		m_activeLights.Clear();
@ -420,7 +418,7 @@ namespace Nz
 		{
 			LightData* lightData = m_lightPool.RetrieveFromIndex(i);
 			if (!lightData->shadowData->IsPerViewer())
-				lightData->shadowData->PrepareRendering(renderFrame, nullptr);
+				lightData->shadowData->PrepareRendering(renderResources, nullptr);
 		}

 		// Viewer handling (second pass)
@ -436,7 +434,7 @@ namespace Nz
 			{
 				LightData* lightData = m_lightPool.RetrieveFromIndex(lightIndex);
 				if (lightData->shadowData && lightData->shadowData->IsPerViewer() && (renderMask & lightData->renderMask) != 0)
-					lightData->shadowData->PrepareRendering(renderFrame, viewerData.viewer);
+					lightData->shadowData->PrepareRendering(renderResources, viewerData.viewer);
 			}

 			// Frustum culling
@ -446,7 +444,7 @@ namespace Nz
 			FramePipelinePass::FrameData passData = {
 				&viewerData.frame.visibleLights,
 				viewerData.frame.frustum,
-				renderFrame,
+				renderResources,
 				visibleRenderables,
 				visibilityHash
 			};
@ -464,7 +462,7 @@ namespace Nz
 					continue;

 				if (viewerData.blitShaderBinding)
-					renderFrame.PushForRelease(std::move(viewerData.blitShaderBinding));
+					renderResources.PushForRelease(std::move(viewerData.blitShaderBinding));

 				viewerData.blitShaderBinding = graphics->GetBlitPipelineLayout()->AllocateShaderBinding(0);
 				viewerData.blitShaderBinding->Update({
@ -480,33 +478,33 @@ namespace Nz
 		}

 		// Update UBOs and materials
-		renderFrame.Execute([&](CommandBufferBuilder& builder)
+		renderResources.Execute([&](CommandBufferBuilder& builder)
 		{
 			builder.BeginDebugRegion("CPU to GPU transfers", Color::Yellow());
 			{
 				builder.PreTransferBarrier();

 				for (TransferInterface* transferInterface : m_transferSet)
-					transferInterface->OnTransfer(renderFrame, builder);
+					transferInterface->OnTransfer(renderResources, builder);
 				m_transferSet.clear();

-				OnTransfer(this, renderFrame, builder);
+				OnTransfer(this, renderResources, builder);

 				builder.PostTransferBarrier();
 			}
 			builder.EndDebugRegion();
 		}, QueueType::Transfer);

-		m_bakedFrameGraph.Execute(renderFrame);
+		m_bakedFrameGraph.Execute(renderResources);
 		m_rebuildFrameGraph = false;

 		// Final blit (TODO: Make part of frame graph?)
 		for (auto&& [renderTargetPtr, renderTargetData] : m_renderTargets)
-			renderTargetPtr->OnRenderEnd(renderFrame, m_bakedFrameGraph, renderTargetData.finalAttachment);
+			renderTargetPtr->OnRenderEnd(renderResources, m_bakedFrameGraph, renderTargetData.finalAttachment);

 		// reset at the end instead of the beginning so debug draw can be used before calling this method
 		DebugDrawer& debugDrawer = GetDebugDrawer();
-		debugDrawer.Reset(renderFrame);
+		debugDrawer.Reset(renderResources);
 	}

 	void ForwardFramePipeline::UnregisterLight(std::size_t lightIndex)
--- a/src/Nazara/Graphics/ForwardPipelinePass.cpp
+++ b/src/Nazara/Graphics/ForwardPipelinePass.cpp
@ -50,7 +50,7 @@ namespace Nz

 		if (m_lastVisibilityHash != frameData.visibilityHash || m_rebuildElements) //< FIXME
 		{
-			frameData.renderFrame.PushForRelease(std::move(m_renderElements));
+			frameData.renderResources.PushForRelease(std::move(m_renderElements));
 			m_renderElements.clear();

 			for (const auto& renderableData : frameData.visibleRenderables)
@ -85,7 +85,7 @@ namespace Nz
 			return element->ComputeSortingScore(frameData.frustum, m_renderQueueRegistry);
 		});

-		PrepareLights(frameData.renderFrame, frameData.frustum, *frameData.visibleLights);
+		PrepareLights(frameData.renderResources, frameData.frustum, *frameData.visibleLights);

 		if (m_rebuildElements)
 		{
@ -97,7 +97,7 @@ namespace Nz
 				if (!m_elementRendererData[elementType])
 					m_elementRendererData[elementType] = elementRenderer.InstanciateData();

-				elementRenderer.Reset(*m_elementRendererData[elementType], frameData.renderFrame);
+				elementRenderer.Reset(*m_elementRendererData[elementType], frameData.renderResources);
 			});

 			const auto& viewerInstance = m_viewer->GetViewerInstance();
@ -105,12 +105,12 @@ namespace Nz
 			m_elementRegistry.ProcessRenderQueue(m_renderQueue, [&](std::size_t elementType, const Pointer<const RenderElement>* elements, std::size_t elementCount)
 			{
 				ElementRenderer& elementRenderer = m_elementRegistry.GetElementRenderer(elementType);
-				elementRenderer.Prepare(viewerInstance, *m_elementRendererData[elementType], frameData.renderFrame, elementCount, elements, SparsePtr(&m_renderState, 0));
+				elementRenderer.Prepare(viewerInstance, *m_elementRendererData[elementType], frameData.renderResources, elementCount, elements, SparsePtr(&m_renderState, 0));
 			});

 			m_elementRegistry.ForEachElementRenderer([&](std::size_t elementType, ElementRenderer& elementRenderer)
 			{
-				elementRenderer.PrepareEnd(frameData.renderFrame, *m_elementRendererData[elementType]);
+				elementRenderer.PrepareEnd(frameData.renderResources, *m_elementRendererData[elementType]);
 			});

 			m_rebuildCommandBuffer = true;
@ -202,7 +202,7 @@ namespace Nz
 		}
 	}

-	void ForwardPipelinePass::OnTransfer(RenderFrame& /*renderFrame*/, CommandBufferBuilder& builder)
+	void ForwardPipelinePass::OnTransfer(RenderResources& /*renderFrame*/, CommandBufferBuilder& builder)
 	{
 		assert(m_pendingLightUploadAllocation);
 		builder.CopyBuffer(*m_pendingLightUploadAllocation, RenderBufferView(m_lightDataBuffer.get()));
@ -315,7 +315,7 @@ namespace Nz
 		}
 	}

-	void ForwardPipelinePass::PrepareLights(RenderFrame& renderFrame, const Frustumf& frustum, const Bitset<UInt64>& visibleLights)
+	void ForwardPipelinePass::PrepareLights(RenderResources& renderResources, const Frustumf& frustum, const Bitset<UInt64>& visibleLights)
 	{
 		// Select lights
 		m_directionalLights.clear();
@ -352,7 +352,7 @@ namespace Nz
 			return lhs.contributionScore < rhs.contributionScore;
 		});

-		UploadPool& uploadPool = renderFrame.GetUploadPool();
+		UploadPool& uploadPool = renderResources.GetUploadPool();

 		auto& lightAllocation = uploadPool.Allocate(m_lightDataBuffer->GetSize());
 		PrepareDirectionalLights(lightAllocation.mappedPtr);
--- a/src/Nazara/Graphics/MaterialInstance.cpp
+++ b/src/Nazara/Graphics/MaterialInstance.cpp
@ -224,9 +224,9 @@ namespace Nz
 		return HasPass(passIndex);
 	}

-	void MaterialInstance::OnTransfer(RenderFrame& renderFrame, CommandBufferBuilder& builder)
+	void MaterialInstance::OnTransfer(RenderResources& renderResources, CommandBufferBuilder& builder)
 	{
-		UploadPool& uploadPool = renderFrame.GetUploadPool();
+		UploadPool& uploadPool = renderResources.GetUploadPool();
 		for (UniformBuffer& uniformBuffer : m_uniformBuffers)
 		{
 			if (!uniformBuffer.dataInvalidated)
--- a/src/Nazara/Graphics/PointLightShadowData.cpp
+++ b/src/Nazara/Graphics/PointLightShadowData.cpp
@ -99,7 +99,7 @@ namespace Nz
 		});
 	}

-	void PointLightShadowData::PrepareRendering(RenderFrame& renderFrame, [[maybe_unused]] const AbstractViewer* viewer)
+	void PointLightShadowData::PrepareRendering(RenderResources& renderResources, [[maybe_unused]] const AbstractViewer* viewer)
 	{
 		assert(viewer == nullptr);

@ -115,7 +115,7 @@ namespace Nz
 			FramePipelinePass::FrameData passData = {
 				nullptr,
 				frustum,
-				renderFrame,
+				renderResources,
 				visibleRenderables,
 				visibilityHash
 			};
--- a/src/Nazara/Graphics/PostProcessPipelinePass.cpp
+++ b/src/Nazara/Graphics/PostProcessPipelinePass.cpp
@ -43,7 +43,7 @@ namespace Nz
 		if (m_nextRenderPipeline)
 		{
 			if (m_renderPipeline)
-				frameData.renderFrame.PushForRelease(std::move(m_renderPipeline));
+				frameData.renderResources.PushForRelease(std::move(m_renderPipeline));

 			m_renderPipeline = std::move(m_nextRenderPipeline);
 			m_rebuildFramePass = true;
@ -78,7 +78,7 @@ namespace Nz
 		postProcess.SetCommandCallback([this, inputColorBufferIndex](CommandBufferBuilder& builder, const FramePassEnvironment& env)
 		{
 			if (m_shaderBinding)
-				env.renderFrame.PushForRelease(std::move(m_shaderBinding));
+				env.renderResources.PushForRelease(std::move(m_shaderBinding));

 			auto& samplerCache = Graphics::Instance()->GetSamplerCache();

--- a/src/Nazara/Graphics/RenderTexture.cpp
+++ b/src/Nazara/Graphics/RenderTexture.cpp
@ -20,7 +20,7 @@ namespace Nz
 		graph.BindExternalTexture(attachmentIndex, m_targetTexture);
 	}

-	void RenderTexture::OnRenderEnd(RenderFrame& /*renderFrame*/, const BakedFrameGraph& /*frameGraph*/, std::size_t /*finalAttachment*/) const
+	void RenderTexture::OnRenderEnd(RenderResources& /*renderFrame*/, const BakedFrameGraph& /*frameGraph*/, std::size_t /*finalAttachment*/) const
 	{
 	}

--- a/src/Nazara/Graphics/RenderTextureBlit.cpp
+++ b/src/Nazara/Graphics/RenderTextureBlit.cpp
@ -16,14 +16,14 @@ namespace Nz
 		graph.AddOutput(attachmentIndex);
 	}

-	void RenderTextureBlit::OnRenderEnd(RenderFrame& renderFrame, const BakedFrameGraph& frameGraph, std::size_t finalAttachment) const
+	void RenderTextureBlit::OnRenderEnd(RenderResources& resources, const BakedFrameGraph& frameGraph, std::size_t finalAttachment) const
 	{
 		const std::shared_ptr<Texture>& sourceTexture = frameGraph.GetAttachmentTexture(finalAttachment);

 		Vector2ui sourceTextureSize = Vector2ui(sourceTexture->GetSize());
 		Vector2ui targetTextureSize = Vector2ui(m_targetTexture->GetSize());

-		renderFrame.Execute([&](CommandBufferBuilder& builder)
+		resources.Execute([&](CommandBufferBuilder& builder)
 		{
 			builder.BeginDebugRegion("Blit to texture", Color::Blue());
 			{
--- a/src/Nazara/Graphics/RenderWindow.cpp
+++ b/src/Nazara/Graphics/RenderWindow.cpp
@ -36,19 +36,19 @@ namespace Nz
 		graph.AddOutput(attachmentIndex);
 	}

-	void RenderWindow::OnRenderEnd(RenderFrame& renderFrame, const BakedFrameGraph& frameGraph, std::size_t finalAttachment) const
+	void RenderWindow::OnRenderEnd(RenderResources& renderResources, const BakedFrameGraph& frameGraph, std::size_t finalAttachment) const
 	{
 		const std::shared_ptr<Texture>& texture = frameGraph.GetAttachmentTexture(finalAttachment);

 		Vector2ui textureSize = Vector2ui(texture->GetSize());
 		Boxui blitRegion(0, 0, 0, textureSize.x, textureSize.y, 1);

-		renderFrame.Execute([&](CommandBufferBuilder& builder)
+		renderResources.Execute([&](CommandBufferBuilder& builder)
 		{
 			builder.BeginDebugRegion("Blit to swapchain", Color::Blue());
 			{
 				builder.TextureBarrier(PipelineStage::ColorOutput, PipelineStage::Transfer, MemoryAccess::ColorWrite, MemoryAccess::TransferRead, TextureLayout::ColorOutput, TextureLayout::TransferSource, *texture);
-				builder.BlitTextureToSwapchain(*texture, blitRegion, TextureLayout::TransferSource, *m_swapchain, renderFrame.GetFramebufferIndex());
+				builder.BlitTextureToSwapchain(*texture, blitRegion, TextureLayout::TransferSource, *m_swapchain, renderResources.GetImageIndex());
 			}
 			builder.EndDebugRegion();
 		}, QueueType::Graphics);
--- a/src/Nazara/Graphics/SkeletonInstance.cpp
+++ b/src/Nazara/Graphics/SkeletonInstance.cpp
@ -42,12 +42,12 @@ namespace Nz
 		});
 	}

-	void SkeletonInstance::OnTransfer(RenderFrame& renderFrame, CommandBufferBuilder& builder)
+	void SkeletonInstance::OnTransfer(RenderResources& renderResources, CommandBufferBuilder& builder)
 	{
 		if (!m_dataInvalided)
 			return;

-		auto& allocation = renderFrame.GetUploadPool().Allocate(m_skeletalDataBuffer->GetSize());
+		auto& allocation = renderResources.GetUploadPool().Allocate(m_skeletalDataBuffer->GetSize());
 		Matrix4f* matrices = AccessByOffset<Matrix4f*>(allocation.mappedPtr, PredefinedSkeletalOffsets.jointMatricesOffset);

 		for (std::size_t i = 0; i < m_skeleton->GetJointCount(); ++i)
--- a/src/Nazara/Graphics/SpotLightShadowData.cpp
+++ b/src/Nazara/Graphics/SpotLightShadowData.cpp
@ -61,7 +61,7 @@ namespace Nz
 		});
 	}

-	void SpotLightShadowData::PrepareRendering(RenderFrame& renderFrame, [[maybe_unused]] const AbstractViewer* viewer)
+	void SpotLightShadowData::PrepareRendering(RenderResources& renderResources, [[maybe_unused]] const AbstractViewer* viewer)
 	{
 		assert(viewer == nullptr);

@ -75,7 +75,7 @@ namespace Nz
 		FramePipelinePass::FrameData passData = {
 			nullptr,
 			frustum,
-			renderFrame,
+			renderResources,
 			visibleRenderables,
 			visibilityHash
 		};
--- a/src/Nazara/Graphics/SpriteChainRenderer.cpp
+++ b/src/Nazara/Graphics/SpriteChainRenderer.cpp
@ -56,7 +56,7 @@ namespace Nz
 		return std::make_unique<SpriteChainRendererData>();
 	}

-	void SpriteChainRenderer::Prepare(const ViewerInstance& viewerInstance, ElementRendererData& rendererData, RenderFrame& currentFrame, std::size_t elementCount, const Pointer<const RenderElement>* elements, SparsePtr<const RenderStates> renderStates)
+	void SpriteChainRenderer::Prepare(const ViewerInstance& viewerInstance, ElementRendererData& rendererData, RenderResources& renderResources, std::size_t elementCount, const Pointer<const RenderElement>* elements, SparsePtr<const RenderStates> renderStates)
 	{
 		Graphics* graphics = Graphics::Instance();

@ -132,7 +132,7 @@ namespace Nz
 			{
 				if (!m_pendingData.currentAllocation)
 				{
-					m_pendingData.currentAllocation = &currentFrame.GetUploadPool().Allocate(m_maxVertexBufferSize);
+					m_pendingData.currentAllocation = &renderResources.GetUploadPool().Allocate(m_maxVertexBufferSize);
 					m_pendingData.currentAllocationMemPtr = static_cast<UInt8*>(m_pendingData.currentAllocation->mappedPtr);

 					std::shared_ptr<RenderBuffer> vertexBuffer;
@ -258,13 +258,13 @@ namespace Nz
 		data.drawCallPerElement[firstSpriteChain] = SpriteChainRendererData::DrawCallIndices{ oldDrawCallCount, drawCallCount };
 	}

-	void SpriteChainRenderer::PrepareEnd(RenderFrame& currentFrame, ElementRendererData& /*rendererData*/)
+	void SpriteChainRenderer::PrepareEnd(RenderResources& renderResources, ElementRendererData& /*rendererData*/)
 	{
 		Flush();

 		if (!m_pendingCopies.empty())
 		{
-			currentFrame.Execute([&](CommandBufferBuilder& builder)
+			renderResources.Execute([&](CommandBufferBuilder& builder)
 			{
 				for (auto& copy : m_pendingCopies)
 					builder.CopyBuffer(*copy.allocation, copy.targetBuffer, copy.size);
@ -331,13 +331,13 @@ namespace Nz
 		}
 	}

-	void SpriteChainRenderer::Reset(ElementRendererData& rendererData, RenderFrame& currentFrame)
+	void SpriteChainRenderer::Reset(ElementRendererData& rendererData, RenderResources& renderResources)
 	{
 		auto& data = static_cast<SpriteChainRendererData&>(rendererData);

 		for (auto& vertexBufferPtr : data.vertexBuffers)
 		{
-			currentFrame.PushReleaseCallback([pool = m_vertexBufferPool, vertexBuffer = std::move(vertexBufferPtr)]() mutable
+			renderResources.PushReleaseCallback([pool = m_vertexBufferPool, vertexBuffer = std::move(vertexBufferPtr)]() mutable
 			{
 				pool->vertexBuffers.push_back(std::move(vertexBuffer));
 			});
@ -345,7 +345,7 @@ namespace Nz
 		data.vertexBuffers.clear();

 		for (auto& shaderBinding : data.shaderBindings)
-			currentFrame.PushForRelease(std::move(shaderBinding));
+			renderResources.PushForRelease(std::move(shaderBinding));
 		data.shaderBindings.clear();

 		data.drawCalls.clear();
--- a/src/Nazara/Graphics/SubmeshRenderer.cpp
+++ b/src/Nazara/Graphics/SubmeshRenderer.cpp
@ -24,7 +24,7 @@ namespace Nz
 		return std::make_unique<SubmeshRendererData>();
 	}

-	void SubmeshRenderer::Prepare(const ViewerInstance& viewerInstance, ElementRendererData& rendererData, RenderFrame& /*currentFrame*/, std::size_t elementCount, const Pointer<const RenderElement>* elements, SparsePtr<const RenderStates> renderStates)
+	void SubmeshRenderer::Prepare(const ViewerInstance& viewerInstance, ElementRendererData& rendererData, RenderResources& /*renderResources*/, std::size_t elementCount, const Pointer<const RenderElement>* elements, SparsePtr<const RenderStates> renderStates)
 	{
 		Graphics* graphics = Graphics::Instance();

@ -346,12 +346,12 @@ namespace Nz
 		}
 	}

-	void SubmeshRenderer::Reset(ElementRendererData& rendererData, RenderFrame& currentFrame)
+	void SubmeshRenderer::Reset(ElementRendererData& rendererData, RenderResources& renderResources)
 	{
 		auto& data = static_cast<SubmeshRendererData&>(rendererData);

 		for (auto& shaderBinding : data.shaderBindings)
-			currentFrame.PushForRelease(std::move(shaderBinding));
+			renderResources.PushForRelease(std::move(shaderBinding));
 		data.shaderBindings.clear();

 		data.drawCalls.clear();
--- a/src/Nazara/Graphics/ViewerInstance.cpp
+++ b/src/Nazara/Graphics/ViewerInstance.cpp
@ -31,14 +31,14 @@ namespace Nz
 		m_viewerDataBuffer->UpdateDebugName("Viewer data");
 	}

-	void ViewerInstance::OnTransfer(RenderFrame& renderFrame, CommandBufferBuilder& builder)
+	void ViewerInstance::OnTransfer(RenderResources& renderResources, CommandBufferBuilder& builder)
 	{
 		if (!m_dataInvalidated)
 			return;

 		constexpr auto& viewerDataOffsets = PredefinedViewerOffsets;

-		auto& allocation = renderFrame.GetUploadPool().Allocate(viewerDataOffsets.totalSize);
+		auto& allocation = renderResources.GetUploadPool().Allocate(viewerDataOffsets.totalSize);
 		AccessByOffset<Vector3f&>(allocation.mappedPtr, viewerDataOffsets.eyePositionOffset) = m_eyePosition;
 		AccessByOffset<Vector2f&>(allocation.mappedPtr, viewerDataOffsets.invTargetSizeOffset) = 1.f / m_targetSize;
 		AccessByOffset<Vector2f&>(allocation.mappedPtr, viewerDataOffsets.targetSizeOffset) = m_targetSize;
--- a/src/Nazara/Graphics/WorldInstance.cpp
+++ b/src/Nazara/Graphics/WorldInstance.cpp
@ -25,14 +25,14 @@ namespace Nz
 		m_instanceDataBuffer->UpdateDebugName("Instance data");
 	}

-	void WorldInstance::OnTransfer(RenderFrame& renderFrame, CommandBufferBuilder& builder)
+	void WorldInstance::OnTransfer(RenderResources& renderResources, CommandBufferBuilder& builder)
 	{
 		if (!m_dataInvalided)
 			return;

 		constexpr auto& instanceUboOffsets = PredefinedInstanceOffsets;

-		auto& allocation = renderFrame.GetUploadPool().Allocate(m_instanceDataBuffer->GetSize());
+		auto& allocation = renderResources.GetUploadPool().Allocate(m_instanceDataBuffer->GetSize());
 		AccessByOffset<Matrix4f&>(allocation.mappedPtr, instanceUboOffsets.worldMatrixOffset) = m_worldMatrix;
 		AccessByOffset<Matrix4f&>(allocation.mappedPtr, instanceUboOffsets.invWorldMatrixOffset) = m_invWorldMatrix;

--- a/src/Nazara/OpenGLRenderer/OpenGLRenderImage.cpp
+++ b/src/Nazara/OpenGLRenderer/OpenGLRenderImage.cpp
@ -27,6 +27,11 @@ namespace Nz
 		commandBuffer.Execute();
 	}

+	UInt32 OpenGLRenderImage::GetImageIndex() const
+	{
+		return m_imageIndex;
+	}
+
 	OpenGLUploadPool& OpenGLRenderImage::GetUploadPool()
 	{
 		return m_uploadPool;
--- a/src/Nazara/OpenGLRenderer/OpenGLSwapchain.cpp
+++ b/src/Nazara/OpenGLRenderer/OpenGLSwapchain.cpp
@ -11,9 +11,9 @@
 namespace Nz
 {
 	OpenGLSwapchain::OpenGLSwapchain(OpenGLDevice& device, WindowHandle windowHandle, const Vector2ui& windowSize, const SwapchainParameters& parameters) :
-	m_currentFrame(0),
 	m_device(device),
 	m_framebuffer(*this),
+	m_currentImageIndex(0),
 	m_size(windowSize),
 	m_sizeInvalidated(false)
 	{
@ -90,7 +90,10 @@ namespace Nz
 		bool sizeInvalidated = m_sizeInvalidated;
 		m_sizeInvalidated = false;

-		return RenderFrame(m_renderImage[m_currentFrame].get(), sizeInvalidated, m_size, 0);
+		OpenGLRenderImage& renderImage = *m_renderImage[m_currentImageIndex];
+		renderImage.Reset(m_currentImageIndex);
+
+		return RenderFrame(&renderImage, sizeInvalidated, m_size);
 	}

 	std::shared_ptr<CommandPool> OpenGLSwapchain::CreateCommandPool(QueueType /*queueType*/)
@ -98,10 +101,8 @@ namespace Nz
 		return std::make_shared<OpenGLCommandPool>();
 	}

-	const OpenGLFramebuffer& OpenGLSwapchain::GetFramebuffer(std::size_t i) const
+	const OpenGLFramebuffer& OpenGLSwapchain::GetFramebuffer(std::size_t /*imageIndex*/) const
 	{
-		assert(i == 0);
-		NazaraUnused(i);
 		return m_framebuffer;
 	}

@ -141,7 +142,7 @@ namespace Nz
 	void OpenGLSwapchain::Present()
 	{
 		m_context->SwapBuffers();
-		m_currentFrame = (m_currentFrame + 1) % m_renderImage.size();
+		m_currentImageIndex = (m_currentImageIndex + 1) % m_renderImage.size();
 	}

 	void OpenGLSwapchain::SetPresentMode(PresentMode presentMode)
@ -155,8 +156,8 @@ namespace Nz
 		}
 	}

-	TransientResources& OpenGLSwapchain::Transient()
+	RenderResources& OpenGLSwapchain::GetTransientResources()
 	{
-		return *m_renderImage[m_currentFrame];
+		return *m_renderImage[m_currentImageIndex];
 	}
 }
--- a/src/Nazara/Renderer/DebugDrawer.cpp
+++ b/src/Nazara/Renderer/DebugDrawer.cpp
@ -104,9 +104,9 @@ namespace Nz
 		}
 	}

-	void DebugDrawer::Prepare(RenderFrame& renderFrame)
+	void DebugDrawer::Prepare(RenderResources& renderResources)
 	{
-		UploadPool& uploadPool = renderFrame.GetUploadPool();
+		UploadPool& uploadPool = renderResources.GetUploadPool();

 		if (!m_lineVertices.empty())
 		{
@ -171,7 +171,7 @@ namespace Nz

 		if (m_viewerDataUpdated || !m_pendingUploads.empty())
 		{
-			renderFrame.Execute([&](CommandBufferBuilder& builder)
+			renderResources.Execute([&](CommandBufferBuilder& builder)
 			{
 				builder.BeginDebugRegion("Debug drawer upload", Color::Yellow());
 				{
@ -196,12 +196,12 @@ namespace Nz
 		m_viewerDataUpdated = false;
 	}

-	void DebugDrawer::Reset(RenderFrame& renderFrame)
+	void DebugDrawer::Reset(RenderResources& renderResources)
 	{
 		if (m_currentViewerData.binding)
 		{
 			// keep pipeline layout alive as needs to stay alive until all shader bindings have been freed
-			renderFrame.PushReleaseCallback([pool = m_dataPool, data = std::move(m_currentViewerData), pipelineLayout = m_renderPipelineLayout]() mutable
+			renderResources.PushReleaseCallback([pool = m_dataPool, data = std::move(m_currentViewerData), pipelineLayout = m_renderPipelineLayout]() mutable
 			{
 				pool->viewerData.push_back(std::move(data));
 			});
@ -210,7 +210,7 @@ namespace Nz

 		for (auto& drawCall : m_drawCalls)
 		{
-			renderFrame.PushReleaseCallback([pool = m_dataPool, buffer = std::move(drawCall.vertexBuffer)]() mutable
+			renderResources.PushReleaseCallback([pool = m_dataPool, buffer = std::move(drawCall.vertexBuffer)]() mutable
 			{
 				pool->vertexBuffers.push_back(std::move(buffer));
 			});
--- a/src/Nazara/Renderer/TransientResources.cpp
+++ b/src/Nazara/Renderer/TransientResources.cpp
@ -2,15 +2,15 @@
 // This file is part of the "Nazara Engine - Renderer module"
 // For conditions of distribution and use, see copyright notice in Config.hpp

-#include <Nazara/Renderer/TransientResources.hpp>
+#include <Nazara/Renderer/RenderResources.hpp>
 #include <Nazara/Renderer/Debug.hpp>

 namespace Nz
 {
-	TransientResources::~TransientResources()
+	RenderResources::~RenderResources()
 	{
 		FlushReleaseQueue();
 	}

-	TransientResources::Releasable::~Releasable() = default;
+	RenderResources::Releasable::~Releasable() = default;
 }
--- a/src/Nazara/VulkanRenderer/VulkanRenderImage.cpp
+++ b/src/Nazara/VulkanRenderer/VulkanRenderImage.cpp
@ -53,6 +53,11 @@ namespace Nz
 		SubmitCommandBuffer(commandBuffer, queueTypeFlags);
 	}

+	UInt32 VulkanRenderImage::GetImageIndex() const
+	{
+		return m_imageIndex;
+	}
+
 	VulkanUploadPool& VulkanRenderImage::GetUploadPool()
 	{
 		return m_uploadPool;
--- a/src/Nazara/VulkanRenderer/VulkanSwapchain.cpp
+++ b/src/Nazara/VulkanRenderer/VulkanSwapchain.cpp
@ -246,7 +246,7 @@ namespace Nz

 		currentFrame.Reset(imageIndex);

-		return RenderFrame(&currentFrame, invalidateFramebuffer, m_swapchainSize, imageIndex);
+		return RenderFrame(&currentFrame, invalidateFramebuffer, m_swapchainSize);
 	}

 	std::shared_ptr<CommandPool> VulkanSwapchain::CreateCommandPool(QueueType queueType)
@ -324,6 +324,11 @@ namespace Nz
 		return m_supportedPresentModes;
 	}

+	RenderResources& VulkanSwapchain::GetTransientResources()
+	{
+		return *m_concurrentImageData[m_currentFrame];
+	}
+
 	void VulkanSwapchain::NotifyResize(const Vector2ui& newSize)
 	{
 		OnSwapchainResize(this, newSize);
@ -375,11 +380,6 @@ namespace Nz
 		}
 	}

-	TransientResources& VulkanSwapchain::Transient()
-	{
-		return *m_concurrentImageData[m_currentFrame];
-	}
-
 	bool VulkanSwapchain::SetupDepthBuffer()
 	{
 		VkImageCreateInfo imageCreateInfo = {
--- a/tests/ComputeParticlesTest/main.cpp
+++ b/tests/ComputeParticlesTest/main.cpp
@ -352,7 +352,7 @@ int main()
 				clearValues[1].depth = 1.f;
 				clearValues[1].stencil = 0;

-				builder.BeginRenderPass(windowSwapchain.GetFramebuffer(frame.GetFramebufferIndex()), windowSwapchain.GetRenderPass(), renderRect, { clearValues[0], clearValues[1] });
+				builder.BeginRenderPass(windowSwapchain.GetFramebuffer(frame.GetImageIndex()), windowSwapchain.GetRenderPass(), renderRect, { clearValues[0], clearValues[1] });
 				{
 					builder.SetScissor(Nz::Recti{ 0, 0, int(windowSize.x), int(windowSize.y) });
 					builder.SetViewport(Nz::Recti{ 0, 0, int(windowSize.x), int(windowSize.y) });
@ -665,7 +665,7 @@ std::shared_ptr<Nz::Texture> GenerateSpriteTexture(Nz::RenderDevice& device, std
 		}
 	});

-	swapchain.Transient().Execute([&](Nz::CommandBufferBuilder& builder)
+	swapchain.GetTransientResources().Execute([&](Nz::CommandBufferBuilder& builder)
 	{
 		builder.TextureBarrier(Nz::PipelineStage::BottomOfPipe, Nz::PipelineStage::ComputeShader, {}, Nz::MemoryAccess::ShaderWrite, Nz::TextureLayout::Undefined, Nz::TextureLayout::General, *targetTexture);

--- a/tests/ComputeTest/main.cpp
+++ b/tests/ComputeTest/main.cpp
@ -193,7 +193,7 @@ int main()
 				clearValues[1].depth = 1.f;
 				clearValues[1].stencil = 0;

-				builder.BeginRenderPass(windowRT->GetFramebuffer(frame.GetFramebufferIndex()), windowRT->GetRenderPass(), renderRect, { clearValues[0], clearValues[1] });
+				builder.BeginRenderPass(windowRT->GetFramebuffer(frame.GetImageIndex()), windowRT->GetRenderPass(), renderRect, { clearValues[0], clearValues[1] });
 				{
 					builder.SetScissor(Nz::Recti{ 0, 0, int(windowSize.x), int(windowSize.y) });
 					builder.SetViewport(Nz::Recti{ 0, 0, int(windowSize.x), int(windowSize.y) });
--- a/tests/RenderTest/main.cpp
+++ b/tests/RenderTest/main.cpp
@ -368,7 +368,7 @@ int main()

 			builder.BeginDebugRegion("Main window rendering", Nz::Color::Green());
 			{
-				builder.BeginRenderPass(windowRT->GetFramebuffer(frame.GetFramebufferIndex()), windowRT->GetRenderPass(), renderRect, { clearValues[0], clearValues[1] });
+				builder.BeginRenderPass(windowRT->GetFramebuffer(frame.GetImageIndex()), windowRT->GetRenderPass(), renderRect, { clearValues[0], clearValues[1] });
 				{
 					builder.BindIndexBuffer(*renderBufferIB, Nz::IndexType::U16);
 					builder.BindRenderPipeline(*pipeline);