Renderer: Expose present mode and allow to query/set it

include/Nazara/OpenGLRenderer/OpenGLSwapchain.hpp

@@ -34,13 +34,17 @@ namespace Nz
 			inline GL::Context& GetContext();
 			const OpenGLFramebuffer& GetFramebuffer(std::size_t i) const override;
 			std::size_t GetFramebufferCount() const override;
+			PresentMode GetPresentMode() const override;
 			const OpenGLRenderPass& GetRenderPass() const override;
 			const Vector2ui& GetSize() const override;
+			PresentModeFlags GetSupportedPresentModes() const override;
 
 			void NotifyResize(const Vector2ui& newSize) override;
 
 			void Present();
 
+			void SetPresentMode(PresentMode presentMode) override;
+
 			TransientResources& Transient() override;
 
 		private:
@@ -49,6 +53,8 @@ namespace Nz
 			std::vector<std::unique_ptr<OpenGLRenderImage>> m_renderImage;
 			std::shared_ptr<GL::Context> m_context;
 			OpenGLWindowFramebuffer m_framebuffer;
+			PresentMode m_presentMode;
+			PresentModeFlags m_supportedPresentModes;
 			Vector2ui m_size;
 			bool m_sizeInvalidated;
 	};

include/Nazara/OpenGLRenderer/Wrapper/Context.hpp

@@ -148,8 +148,6 @@ namespace Nz::GL
 
 			inline bool DidLastCallSucceed() const;
 
-			virtual void EnableVerticalSync(bool enabled) = 0;
-
 			inline bool GetBoolean(GLenum name) const;
 			inline bool GetBoolean(GLenum name, GLuint index) const;
 			inline const OpenGLDevice* GetDevice() const;
@@ -159,6 +157,7 @@ namespace Nz::GL
 			template<typename T> T GetInteger(GLenum name) const;
 			template<typename T> T GetInteger(GLenum name, GLuint index) const;
 			inline const ContextParams& GetParams() const;
+			virtual PresentModeFlags GetSupportedPresentModes() const = 0;
 			inline const OpenGLVaoCache& GetVaoCache() const;
 
 			inline bool IsExtensionSupported(Extension extension) const;
@@ -183,6 +182,7 @@ namespace Nz::GL
 			inline void ResetStencilWriteMasks() const;
 
 			void SetCurrentTextureUnit(UInt32 textureUnit) const;
+			virtual void SetPresentMode(PresentMode presentMode) = 0;
 			void SetScissorBox(GLint x, GLint y, GLsizei width, GLsizei height) const;
 			void SetViewport(GLint x, GLint y, GLsizei width, GLsizei height) const;
 

include/Nazara/OpenGLRenderer/Wrapper/EGL/EGLContextBase.hpp

@@ -35,10 +35,12 @@ namespace Nz::GL
 			virtual bool Create(const ContextParams& params, WindowHandle window, const EGLContextBase* shareContext = nullptr);
 			virtual void Destroy();
 
-			void EnableVerticalSync(bool enabled) override;
+			PresentModeFlags GetSupportedPresentModes() const override;
 
 			inline bool HasPlatformExtension(const std::string& str) const;
 
+			void SetPresentMode(PresentMode presentMode) override;
+
 			void SwapBuffers() override;
 
 			EGLContextBase& operator=(const EGLContextBase&) = delete;
@@ -72,6 +74,8 @@ namespace Nz::GL
 
 			std::unordered_set<std::string> m_supportedPlatformExtensions;
 			EGLContext m_handle;
+			EGLint m_maxSwapInterval;
+			EGLint m_minSwapInterval;
 			bool m_ownsDisplay;
 	};
 }

include/Nazara/OpenGLRenderer/Wrapper/EGL/EGLFunctions.hpp

@@ -17,6 +17,7 @@ NAZARA_OPENGLRENDERER_EGL_FUNC(eglCreatePbufferSurface, PFNEGLCREATEPBUFFERSURFA
 NAZARA_OPENGLRENDERER_EGL_FUNC(eglCreateWindowSurface, PFNEGLCREATEWINDOWSURFACEPROC)
 NAZARA_OPENGLRENDERER_EGL_FUNC(eglDestroyContext, PFNEGLDESTROYCONTEXTPROC)
 NAZARA_OPENGLRENDERER_EGL_FUNC(eglDestroySurface, PFNEGLDESTROYSURFACEPROC)
+NAZARA_OPENGLRENDERER_EGL_FUNC(eglGetConfigAttrib, PFNEGLGETCONFIGATTRIBPROC)
 NAZARA_OPENGLRENDERER_EGL_FUNC(eglGetDisplay, PFNEGLGETDISPLAYPROC)
 NAZARA_OPENGLRENDERER_EGL_FUNC(eglGetError, PFNEGLGETERRORPROC)
 NAZARA_OPENGLRENDERER_EGL_FUNC(eglGetProcAddress, PFNEGLGETPROCADDRESSPROC)
@@ -24,6 +25,7 @@ NAZARA_OPENGLRENDERER_EGL_FUNC(eglInitialize, PFNEGLINITIALIZEPROC)
 NAZARA_OPENGLRENDERER_EGL_FUNC(eglMakeCurrent, PFNEGLMAKECURRENTPROC)
 NAZARA_OPENGLRENDERER_EGL_FUNC(eglQueryString, PFNEGLQUERYSTRINGPROC)
 NAZARA_OPENGLRENDERER_EGL_FUNC(eglSwapBuffers, PFNEGLSWAPBUFFERSPROC)
+NAZARA_OPENGLRENDERER_EGL_FUNC(eglSwapInterval, PFNEGLSWAPINTERVALPROC)
 NAZARA_OPENGLRENDERER_EGL_FUNC(eglTerminate, PFNEGLTERMINATEPROC)
 
 NAZARA_OPENGLRENDERER_EGL_FUNC_OPT(eglCreatePlatformWindowSurface, PFNEGLCREATEPLATFORMWINDOWSURFACEPROC)

include/Nazara/OpenGLRenderer/Wrapper/WGL/WGLContext.hpp

@@ -34,10 +34,12 @@ namespace Nz::GL
 			bool Create(const WGLContext* baseContext, const ContextParams& params, WindowHandle window, const WGLContext* shareContext = nullptr);
 			void Destroy();
 
-			void EnableVerticalSync(bool enabled) override;
+			PresentModeFlags GetSupportedPresentModes() const override;
 
 			inline bool HasPlatformExtension(const std::string& str) const;
 
+			void SetPresentMode(PresentMode presentMode) override;
+
 			void SwapBuffers() override;
 
 			WGLContext& operator=(const WGLContext&) = delete;

include/Nazara/OpenGLRenderer/Wrapper/WGL/WGLContext.inl

@@ -6,7 +6,7 @@
 
 namespace Nz::GL
 {
-	inline GL::WGLContext::WGLContext(const OpenGLDevice* device, const WGLLoader& loader) :
+	inline WGLContext::WGLContext(const OpenGLDevice* device, const WGLLoader& loader) :
 	Context(device),
 	m_loader(loader),
 	m_handle(nullptr)

include/Nazara/OpenGLRenderer/Wrapper/Web/WebContext.hpp

@@ -33,10 +33,12 @@ namespace Nz::GL
 			virtual bool Create(const ContextParams& params, WindowHandle window, const WebContext* shareContext = nullptr);
 			virtual void Destroy();
 
-			void EnableVerticalSync(bool enabled) override;
+			PresentModeFlags GetSupportedPresentModes() const override;
 
 			inline bool HasPlatformExtension(const std::string& str) const;
 
+			void SetPresentMode(PresentMode presentMode) override;
+
 			void SwapBuffers() override;
 
 			WebContext& operator=(const WebContext&) = delete;

include/Nazara/Renderer/Enums.hpp

@@ -109,6 +109,24 @@ namespace Nz
 
 	using PipelineStageFlags = Flags<PipelineStage>;
 
+	enum class PresentMode
+	{
+		Immediate,
+		Mailbox,
+		RelaxedVerticalSync,
+		VerticalSync,
+
+		Max = VerticalSync
+	};
+
+	template<>
+	struct EnumAsFlags<PresentMode>
+	{
+		static constexpr PresentMode max = PresentMode::Max;
+	};
+
+	using PresentModeFlags = Flags<PresentMode>;
+
 	enum class QueueType
 	{
 		Compute,

include/Nazara/Renderer/Swapchain.hpp

@@ -32,8 +32,13 @@ namespace Nz
 
 			virtual std::shared_ptr<CommandPool> CreateCommandPool(QueueType queueType) = 0;
 
+			virtual PresentMode GetPresentMode() const = 0;
+			virtual PresentModeFlags GetSupportedPresentModes() const = 0;
+
 			virtual void NotifyResize(const Vector2ui& newSize) = 0;
 
+			virtual void SetPresentMode(PresentMode presentMode) = 0;
+
 			virtual TransientResources& Transient() = 0;
 
 		protected:

include/Nazara/Renderer/SwapchainParameters.hpp

@@ -8,6 +8,7 @@
 #define NAZARA_RENDERER_SWAPCHAINPARAMETERS_HPP
 
 #include <NazaraUtils/Prerequisites.hpp>
+#include <Nazara/Renderer/Enums.hpp>
 #include <Nazara/Utility/PixelFormat.hpp>
 #include <vector>
 
@@ -15,8 +16,8 @@ namespace Nz
 {
 	struct SwapchainParameters
 	{
-		std::vector<PixelFormat> depthFormats = {Nz::PixelFormat::Depth24Stencil8, Nz::PixelFormat::Depth32FStencil8, Nz::PixelFormat::Depth16Stencil8, Nz::PixelFormat::Depth32F, Nz::PixelFormat::Depth24}; //< By order of preference
+		std::vector<PixelFormat> depthFormats = { Nz::PixelFormat::Depth24Stencil8, Nz::PixelFormat::Depth32FStencil8, Nz::PixelFormat::Depth16Stencil8, Nz::PixelFormat::Depth32F, Nz::PixelFormat::Depth24 }; //< By order of preference
-		bool verticalSync = false;
+		std::vector<PresentMode> presentMode = { PresentMode::Mailbox, PresentMode::Immediate, PresentMode::RelaxedVerticalSync, PresentMode::VerticalSync }; //< By order of preference
 	};
 }
 

include/Nazara/VulkanRenderer/Utils.hpp

@@ -18,6 +18,7 @@
 namespace Nz
 {
 	inline std::optional<PixelFormat> FromVulkan(VkFormat format);
+	inline std::optional<PresentMode> FromVulkan(VkPresentModeKHR presentMode);
 
 	inline VkAttachmentLoadOp ToVulkan(AttachmentLoadOp loadOp);
 	inline VkAttachmentStoreOp ToVulkan(AttachmentStoreOp storeOp);
@@ -33,6 +34,7 @@ namespace Nz
 	inline VkPipelineStageFlags ToVulkan(PipelineStageFlags pipelineStages);
 	inline VkFormat ToVulkan(PixelFormat pixelFormat);
 	inline VkImageAspectFlags ToVulkan(PixelFormatContent pixelFormatContent);
+	inline VkPresentModeKHR ToVulkan(PresentMode presentMode);
 	inline VkPrimitiveTopology ToVulkan(PrimitiveMode primitiveMode);
 	inline VkCompareOp ToVulkan(RendererComparison comparison);
 	inline VkFilter ToVulkan(SamplerFilter samplerFilter);

include/Nazara/VulkanRenderer/Utils.inl

@@ -32,6 +32,20 @@ namespace Nz
 		return std::nullopt;
 	}
 
+	std::optional<PresentMode> FromVulkan(VkPresentModeKHR presentMode)
+	{
+		switch (presentMode)
+		{
+			case VK_PRESENT_MODE_IMMEDIATE_KHR:    return PresentMode::Immediate;
+			case VK_PRESENT_MODE_MAILBOX_KHR:      return PresentMode::Mailbox;
+			case VK_PRESENT_MODE_FIFO_KHR:         return PresentMode::VerticalSync;
+			case VK_PRESENT_MODE_FIFO_RELAXED_KHR: return PresentMode::RelaxedVerticalSync;
+			default: break;
+		}
+
+		return std::nullopt;
+	}
+
 	inline VkAttachmentLoadOp ToVulkan(AttachmentLoadOp loadOp)
 	{
 		switch (loadOp)
@@ -306,6 +320,20 @@ namespace Nz
 		return VK_IMAGE_ASPECT_COLOR_BIT;
 	}
 
+	VkPresentModeKHR ToVulkan(PresentMode presentMode)
+	{
+		switch (presentMode)
+		{
+			case PresentMode::Immediate:           return VK_PRESENT_MODE_IMMEDIATE_KHR;
+			case PresentMode::Mailbox:             return VK_PRESENT_MODE_MAILBOX_KHR;
+			case PresentMode::RelaxedVerticalSync: return VK_PRESENT_MODE_FIFO_RELAXED_KHR;
+			case PresentMode::VerticalSync:        return VK_PRESENT_MODE_FIFO_KHR;
+		}
+
+		NazaraError("Unhandled PresentMode 0x" + NumberToString(UnderlyingCast(presentMode), 16));
+		return VK_PRESENT_MODE_FIFO_KHR;
+	}
+
 	inline VkPrimitiveTopology ToVulkan(PrimitiveMode primitiveMode)
 	{
 		switch (primitiveMode)
@@ -318,7 +346,7 @@ namespace Nz
 			case PrimitiveMode::TriangleFan:   return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN;
 		}
 
-		NazaraError("Unhandled FaceFilling 0x" + NumberToString(UnderlyingCast(primitiveMode), 16));
+		NazaraError("Unhandled PrimitiveMode 0x" + NumberToString(UnderlyingCast(primitiveMode), 16));
 		return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
 	}
 
@@ -502,3 +530,4 @@ namespace Nz
 }
 
 #include <Nazara/VulkanRenderer/DebugOff.hpp>
+#include "Utils.hpp"

include/Nazara/VulkanRenderer/VulkanSwapchain.hpp

@@ -53,12 +53,16 @@ namespace Nz
 			inline Vk::QueueHandle& GetGraphicsQueue();
 			const VulkanRenderPass& GetRenderPass() const override;
 			const Vector2ui& GetSize() const override;
+			PresentMode GetPresentMode() const override;
+			PresentModeFlags GetSupportedPresentModes() const override;
 			inline const Vk::Swapchain& GetSwapchain() const;
 
 			void NotifyResize(const Vector2ui& newSize) override;
 
 			void Present(UInt32 imageIndex, VkSemaphore waitSemaphore = VK_NULL_HANDLE);
 
+			void SetPresentMode(PresentMode presentMode) override;
+
 			TransientResources& Transient() override;
 
 			VulkanSwapchain& operator=(const VulkanSwapchain&) = delete;
@@ -85,6 +89,8 @@ namespace Nz
 			Vk::QueueHandle m_transferQueue;
 			Vk::Surface m_surface;
 			Vk::Swapchain m_swapchain;
+			PresentMode m_presentMode;
+			PresentModeFlags m_supportedPresentModes;
 			Vector2ui m_swapchainSize;
 			VkFormat m_depthStencilFormat;
 			VkSurfaceFormatKHR m_surfaceFormat;

src/Nazara/OpenGLRenderer/OpenGLSwapchain.cpp

@@ -6,7 +6,6 @@
 #include <Nazara/OpenGLRenderer/OpenGLCommandPool.hpp>
 #include <Nazara/OpenGLRenderer/OpenGLRenderer.hpp>
 #include <Nazara/Renderer/CommandPool.hpp>
-#include <Nazara/Renderer/WindowSwapchain.hpp>
 #include <Nazara/OpenGLRenderer/Debug.hpp>
 
 namespace Nz
@@ -54,6 +53,23 @@ namespace Nz
 		else
 			depthFormat = PixelFormat::Undefined;
 
+		m_supportedPresentModes = m_context->GetSupportedPresentModes();
+
+#ifdef NAZARA_PLATFORM_WEB
+		m_presentMode = PresentMode::Immediate; //< default present mode
+#else
+		m_presentMode = PresentMode::VerticalSync; //< default present mode
+#endif
+
+		for (PresentMode presentMode : parameters.presentMode)
+		{
+			if (m_supportedPresentModes & presentMode)
+			{
+				SetPresentMode(presentMode);
+				break;
+			}
+		}
+
 		std::vector<RenderPass::Attachment> attachments;
 		std::vector<RenderPass::SubpassDescription> subpassDescriptions;
 		std::vector<RenderPass::SubpassDependency> subpassDependencies;
@@ -78,7 +94,7 @@ namespace Nz
 
 	std::shared_ptr<CommandPool> OpenGLSwapchain::CreateCommandPool(QueueType /*queueType*/)
 	{
-		return std::make_unique<OpenGLCommandPool>();
+		return std::make_shared<OpenGLCommandPool>();
 	}
 
 	const OpenGLFramebuffer& OpenGLSwapchain::GetFramebuffer(std::size_t i) const
@@ -98,11 +114,21 @@ namespace Nz
 		return *m_renderPass;
 	}
 
+	PresentMode OpenGLSwapchain::GetPresentMode() const
+	{
+		return m_presentMode;
+	}
+
 	const Vector2ui& OpenGLSwapchain::GetSize() const
 	{
 		return m_size;
 	}
 
+	PresentModeFlags OpenGLSwapchain::GetSupportedPresentModes() const
+	{
+		return m_supportedPresentModes;
+	}
+
 	void OpenGLSwapchain::NotifyResize(const Vector2ui& newSize)
 	{
 		OnRenderTargetSizeChange(this, newSize);
@@ -117,6 +143,17 @@ namespace Nz
 		m_currentFrame = (m_currentFrame + 1) % m_renderImage.size();
 	}
 
+	void OpenGLSwapchain::SetPresentMode(PresentMode presentMode)
+	{
+		NazaraAssert(m_supportedPresentModes & presentMode, "unsupported present mode");
+
+		if (m_presentMode != presentMode)
+		{
+			m_context->SetPresentMode(presentMode);
+			m_presentMode = presentMode;
+		}
+	}
+
 	TransientResources& OpenGLSwapchain::Transient()
 	{
 		return *m_renderImage[m_currentFrame];

src/Nazara/OpenGLRenderer/Wrapper/Context.cpp

@@ -670,8 +670,6 @@ namespace Nz::GL
 		m_state.renderStates.scissorTest = false;
 		m_state.renderStates.stencilTest = false;
 
-		EnableVerticalSync(false);
-
 		return true;
 	}
 

src/Nazara/OpenGLRenderer/Wrapper/EGL/EGLContextBase.cpp

@@ -87,9 +87,33 @@ namespace Nz::GL
 		}
 	}
 
-	void EGLContextBase::EnableVerticalSync(bool enabled)
+	PresentModeFlags EGLContextBase::GetSupportedPresentModes() const
 	{
-		// TODO
+		PresentModeFlags supportedModes;
+		if (m_maxSwapInterval >= 1)
+			supportedModes |= PresentMode::VerticalSync;
+
+		if (m_minSwapInterval <= 0)
+			supportedModes |= PresentMode::Immediate;
+
+		if (m_minSwapInterval <= -1)
+			supportedModes |= PresentMode::RelaxedVerticalSync;
+
+		return supportedModes;
+	}
+
+	void EGLContextBase::SetPresentMode(PresentMode presentMode)
+	{
+		int interval = 0;
+		switch (presentMode)
+		{
+			case PresentMode::Immediate:           interval = 0;  break;
+			case PresentMode::RelaxedVerticalSync: interval = -1; break;
+			case PresentMode::VerticalSync:        interval = 1;  break;
+			default: return; // TODO: Unreachable
+		}
+
+		m_loader.eglSwapInterval(m_display, interval);
 	}
 
 	void EGLContextBase::SwapBuffers()
@@ -247,6 +271,9 @@ namespace Nz::GL
 			return false;
 		}
 
+		m_loader.eglGetConfigAttrib(m_display, config, EGL_MAX_SWAP_INTERVAL, &m_maxSwapInterval);
+		m_loader.eglGetConfigAttrib(m_display, config, EGL_MIN_SWAP_INTERVAL, &m_minSwapInterval);
+
 		LoadEGLExt();
 
 		return true;

src/Nazara/OpenGLRenderer/Wrapper/WGL/WGLContext.cpp

@@ -73,15 +73,34 @@ namespace Nz::GL
 		}
 	}
 
-	void WGLContext::EnableVerticalSync(bool enabled)
+	PresentModeFlags WGLContext::GetSupportedPresentModes() const
 	{
+		PresentModeFlags supportedModes = PresentMode::Immediate;
 		if (wglSwapIntervalEXT)
 		{
-			if (!SetCurrentContext(this))
+			supportedModes |= PresentMode::VerticalSync;
-				return;
+			if (HasPlatformExtension("WGL_EXT_swap_control_tear"))
-
+				supportedModes |= PresentMode::RelaxedVerticalSync;
-			wglSwapIntervalEXT(enabled);
 		}
+
+		return supportedModes;
+	}
+
+	void WGLContext::SetPresentMode(PresentMode presentMode)
+	{
+		if (!SetCurrentContext(this))
+			return;
+
+		int interval = 0;
+		switch (presentMode)
+		{
+			case PresentMode::Immediate:           interval = 0;  break;
+			case PresentMode::RelaxedVerticalSync: interval = -1; break; //< WGL_EXT_swap_control_tear
+			case PresentMode::VerticalSync:        interval = 1;  break;
+			default: return; // TODO: Unreachable
+		}
+
+		wglSwapIntervalEXT(interval);
 	}
 
 	void WGLContext::SwapBuffers()

src/Nazara/OpenGLRenderer/Wrapper/Web/WebContext.cpp

@@ -64,9 +64,15 @@ namespace Nz::GL
 		}
 	}
 
-	void WebContext::EnableVerticalSync(bool /*enabled*/)
+	PresentModeFlags WebContext::GetSupportedPresentModes() const
 	{
-		// TODO
+		// WebGL does not support disabling V-Sync
+		return PresentMode::VerticalSync;
+	}
+
+	void WebContext::SetPresentMode(PresentMode /*presentMode*/)
+	{
+		// Nothing to do
 	}
 
 	void WebContext::SwapBuffers()

src/Nazara/VulkanRenderer/VulkanSwapchain.cpp

@@ -151,6 +151,27 @@ namespace Nz
 				throw std::runtime_error("failed to find a support depth-stencil format");
 		}
 
+		std::vector<VkPresentModeKHR> presentModes;
+		if (!m_surface.GetPresentModes(physDeviceInfo.physDevice, &presentModes))
+			throw std::runtime_error("failed to query supported present modes");
+
+		m_supportedPresentModes.Clear();
+		for (VkPresentModeKHR vkPresentMode : presentModes)
+		{
+			if (auto presentModeOpt = FromVulkan(vkPresentMode))
+				m_supportedPresentModes |= *presentModeOpt;
+		}
+
+		m_presentMode = PresentMode::VerticalSync; //< guaranteed to be supported
+		for (PresentMode presentMode : parameters.presentMode)
+		{
+			if (m_supportedPresentModes & presentMode)
+			{
+				m_presentMode = presentMode;
+				break;
+			}
+		}
+
 		if (!SetupRenderPass())
 			throw std::runtime_error("failed to create renderpass");
 
@@ -292,6 +313,16 @@ namespace Nz
 		return m_swapchainSize;
 	}
 
+	PresentMode VulkanSwapchain::GetPresentMode() const
+	{
+		return m_presentMode;
+	}
+
+	PresentModeFlags VulkanSwapchain::GetSupportedPresentModes() const
+	{
+		return m_supportedPresentModes;
+	}
+
 	void VulkanSwapchain::NotifyResize(const Vector2ui& newSize)
 	{
 		OnRenderTargetSizeChange(this, newSize);
@@ -332,6 +363,17 @@ namespace Nz
 		}
 	}
 
+	void VulkanSwapchain::SetPresentMode(PresentMode presentMode)
+	{
+		NazaraAssert(m_supportedPresentModes & presentMode, "unsupported present mode");
+
+		if (m_presentMode != presentMode)
+		{
+			m_presentMode = presentMode;
+			m_shouldRecreateSwapchain = true;
+		}
+	}
+
 	TransientResources& VulkanSwapchain::Transient()
 	{
 		return *m_concurrentImageData[m_currentFrame];
@@ -566,26 +608,6 @@ namespace Nz
 		else
 			extent = surfaceCapabilities.currentExtent;
 
-		std::vector<VkPresentModeKHR> presentModes;
-		if (!m_surface.GetPresentModes(deviceInfo.physDevice, &presentModes))
-		{
-			NazaraError("Failed to query supported present modes");
-			return false;
-		}
-
-		VkPresentModeKHR swapchainPresentMode = VK_PRESENT_MODE_FIFO_KHR;
-		for (VkPresentModeKHR presentMode : presentModes)
-		{
-			if (presentMode == VK_PRESENT_MODE_MAILBOX_KHR)
-			{
-				swapchainPresentMode = VK_PRESENT_MODE_MAILBOX_KHR;
-				break;
-			}
-
-			if (presentMode == VK_PRESENT_MODE_IMMEDIATE_KHR)
-				swapchainPresentMode = VK_PRESENT_MODE_IMMEDIATE_KHR;
-		}
-
 		VkCompositeAlphaFlagBitsKHR compositeAlpha;
 		if (surfaceCapabilities.supportedCompositeAlpha & VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR)
 			compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
@@ -610,7 +632,7 @@ namespace Nz
 			0, nullptr,
 			surfaceCapabilities.currentTransform,
 			compositeAlpha,
-			swapchainPresentMode,
+			ToVulkan(m_presentMode),
 			VK_TRUE,
 			m_swapchain
 		};

tests/PresentModeTest/main.cpp

@@ -0,0 +1,186 @@
+#include <Nazara/Core.hpp>
+#include <Nazara/Platform.hpp>
+#include <Nazara/Graphics.hpp>
+#include <Nazara/Renderer.hpp>
+#include <Nazara/Utility.hpp>
+#include <chrono>
+#include <iostream>
+#include <thread>
+
+int main()
+{
+	Nz::Renderer::Config rendererConfig;
+#ifndef NAZARA_PLATFORM_WEB
+	std::cout << "Run using Vulkan? (y/n)" << std::endl;
+	if (std::getchar() == 'y')
+		rendererConfig.preferredAPI = Nz::RenderAPI::Vulkan;
+	else
+		rendererConfig.preferredAPI = Nz::RenderAPI::OpenGL;
+#endif
+
+	Nz::Application<Nz::Graphics> app(rendererConfig);
+
+	auto& windowing = app.AddComponent<Nz::AppWindowingComponent>();
+
+	auto& ecs = app.AddComponent<Nz::AppEntitySystemComponent>();
+
+	auto& world = ecs.AddWorld<Nz::EnttWorld>();
+	Nz::RenderSystem& renderSystem = world.AddSystem<Nz::RenderSystem>();
+
+	std::string windowTitle = "Physics 2D";
+	Nz::Window& window = windowing.CreateWindow(Nz::VideoMode(1920, 1080, 32), windowTitle);
+	Nz::WindowSwapchain& windowSwapchain = renderSystem.CreateSwapchain(window);
+	Nz::Swapchain& swapchain = windowSwapchain.GetSwapchain();
+
+	Nz::Vector2ui windowSize = window.GetSize();
+
+	entt::handle viewer = world.CreateEntity();
+	{
+		viewer.emplace<Nz::NodeComponent>();
+		viewer.emplace<Nz::CameraComponent>(&windowSwapchain, Nz::ProjectionType::Orthographic);
+	}
+
+	// Turn present mode flags into vector for easier processing
+	Nz::FixedVector<Nz::PresentMode, Nz::EnumValueCount_v<Nz::PresentMode>> supportedPresentModes;
+	for (Nz::PresentMode presentMode : swapchain.GetSupportedPresentModes())
+		supportedPresentModes.push_back(presentMode);
+
+	auto presentFlagIt = std::find(supportedPresentModes.begin(), supportedPresentModes.end(), swapchain.GetPresentMode());
+
+	bool limitFps = false;
+
+	std::shared_ptr<Nz::TextSprite> presentModeText = std::make_shared<Nz::TextSprite>();
+	auto UpdatePresentModeText = [&]
+	{
+		Nz::RichTextDrawer textDrawer;
+		textDrawer.SetDefaultStyle(Nz::TextStyle::Bold);
+		textDrawer.AppendText("Supported present modes:\n");
+		textDrawer.SetDefaultStyle(Nz::TextStyle_Regular);
+		textDrawer.AppendText("Use +/- to switch present mode (and * to limit FPS to 50)\n");
+
+		for (Nz::PresentMode presentMode : supportedPresentModes)
+		{
+			textDrawer.AppendText("- ");
+
+			if (presentMode == swapchain.GetPresentMode())
+				textDrawer.SetDefaultColor(Nz::Color::Yellow());
+			else
+				textDrawer.SetDefaultColor(Nz::Color::White());
+
+			switch (presentMode)
+			{
+				case Nz::PresentMode::Immediate:           textDrawer.AppendText("Immediate\n"); break;
+				case Nz::PresentMode::Mailbox:             textDrawer.AppendText("Mailbox\n"); break;
+				case Nz::PresentMode::RelaxedVerticalSync: textDrawer.AppendText("RelaxedVerticalSync\n"); break;
+				case Nz::PresentMode::VerticalSync:        textDrawer.AppendText("VerticalSync\n"); break;
+			}
+		}
+
+		textDrawer.SetDefaultColor(Nz::Color::White());
+		textDrawer.AppendText("Use * to limit FPS to 50\n");
+		if (limitFps)
+		{
+			textDrawer.SetDefaultColor(Nz::Color::Red());
+			textDrawer.AppendText("FPS limited to 50\n");
+		}
+		else
+			textDrawer.AppendText("Unlimited FPS\n");
+
+		presentModeText->Update(textDrawer);
+	};
+
+	UpdatePresentModeText();
+
+	entt::handle textEntity = world.CreateEntity();
+	{
+		textEntity.emplace<Nz::NodeComponent>();
+		textEntity.emplace<Nz::GraphicsComponent>(presentModeText);
+	}
+
+	entt::handle spriteEntity = world.CreateEntity();
+	{
+		std::shared_ptr<Nz::Sprite> sprite = std::make_shared<Nz::Sprite>(Nz::MaterialInstance::GetDefault(Nz::MaterialType::Basic));
+		sprite->SetSize({ 128.f, 128.f });
+
+		spriteEntity.emplace<Nz::NodeComponent>();
+		spriteEntity.emplace<Nz::GraphicsComponent>(sprite);
+	}
+
+	Nz::WindowEventHandler& eventHandler = window.GetEventHandler();
+	eventHandler.OnKeyPressed.Connect([&](const Nz::WindowEventHandler*, const Nz::WindowEvent::KeyEvent& event)
+	{
+		if (event.virtualKey == Nz::Keyboard::VKey::Add)
+		{
+			++presentFlagIt;
+			if (presentFlagIt == supportedPresentModes.end())
+				presentFlagIt = supportedPresentModes.begin();
+
+			swapchain.SetPresentMode(*presentFlagIt);
+			UpdatePresentModeText();
+		}
+		else if (event.virtualKey == Nz::Keyboard::VKey::Subtract)
+		{
+			if (presentFlagIt == supportedPresentModes.begin())
+				presentFlagIt = supportedPresentModes.end();
+
+			--presentFlagIt;
+
+			swapchain.SetPresentMode(*presentFlagIt);
+			UpdatePresentModeText();
+		}
+		else if (event.virtualKey == Nz::Keyboard::VKey::Multiply)
+		{
+			limitFps = !limitFps;
+			UpdatePresentModeText();
+		}
+	});
+
+	Nz::Time accumulatorTime = Nz::Time::Zero();
+	constexpr Nz::Time timeToMove = Nz::Time::Second();
+
+	Nz::HighPrecisionClock fpsLimitClock;
+	Nz::MillisecondClock fpsClock;
+	unsigned int fps = 0;
+	bool forward = true;
+	app.AddUpdaterFunc([&](Nz::Time elapsedTime)
+	{
+		// Move sprite
+		if (forward)
+		{
+			accumulatorTime += elapsedTime;
+			if (accumulatorTime >= timeToMove)
+				forward = false;
+		}
+		else
+		{
+			accumulatorTime -= elapsedTime;
+			if (accumulatorTime <= Nz::Time::Zero())
+				forward = true;
+		}
+
+		float delta = (accumulatorTime.AsSeconds() / timeToMove.AsSeconds());
+
+		spriteEntity.get<Nz::NodeComponent>().SetPosition(Nz::Lerp(0.f, windowSize.x - 128.f, delta * delta * (3.f - 2.f * delta)), windowSize.y / 2.f - 128.f / 2.f, 0.f);
+
+		// Limit FPS
+		if (limitFps)
+		{
+			Nz::Time remainingTime = Nz::Time::TickDuration(50) - fpsLimitClock.GetElapsedTime();
+			if (remainingTime > Nz::Time::Zero())
+				std::this_thread::sleep_for(remainingTime.AsDuration<std::chrono::milliseconds>());
+
+			fpsLimitClock.Restart();
+		}
+
+		// FPS update
+		fps++;
+
+		if (fpsClock.RestartIfOver(Nz::Time::Second()))
+		{
+			window.SetTitle(windowTitle + " - " + Nz::NumberToString(fps) + " FPS");
+			fps = 0;
+		}
+	});
+
+	return app.Run();
+}

tests/PresentModeTest/xmake.lua

@@ -0,0 +1,5 @@
+target("PresentModeTest")
+	add_deps("NazaraGraphics")
+	add_packages("entt")
+	add_defines("NAZARA_ENTT")
+	add_files("main.cpp")