feat(vulkan): gfxrenderer picks the opengl 4.6 or the vulkan 1.4 renderer (B1-B3)

rendering/vulkan14/vulkan14swapchain.h

@@ -0,0 +1,122 @@
+/*
+This Source Code Form is subject to the
+terms of the Mozilla Public License, v.
+2.0. If a copy of the MPL was not
+distributed with this file, You can
+obtain one at
+http://mozilla.org/MPL/2.0/.
+*/
+
+// a window the renderer shows images in: its surface and swapchain, made anew when the window changes size, when the driver
+// says the swapchain is out of date, and when vsync or gfx.shadergamma change. a minimized window (0x0) is skipped until
+// it comes back
+
+#pragma once
+
+#include "rendering/vulkan14/vulkan14common.h"
+
+namespace vk14
+{
+
+class instance;
+class device;
+
+class swapchain
+{
+  public:
+	enum class acquire_result
+	{
+		ready, // an image to draw into, its acquire semaphore will be signalled
+		skipped, // nothing to draw this frame (minimized, or made anew)
+		failed // the device is gone
+	};
+
+	swapchain() = default;
+	swapchain(swapchain const &) = delete;
+	swapchain &operator=(swapchain const &) = delete;
+	~swapchain();
+
+	// the surface of the window and, when the window isn't minimized, the swapchain. Frames: frames in flight
+	bool create(instance const &Instance, device const &Device, GLFWwindow *Window, std::string const &Name, std::uint32_t const Frames, std::string &Reason);
+	void destroy();
+
+	// the image of the frame Frame (index of the frame in flight)
+	acquire_result acquire(std::uint32_t const Frame);
+	// the image acquired, from undefined to cleared with Colour (linear) and ready to be shown
+	void record_clear(VkCommandBuffer Commands, glm::vec4 const &Colour) const;
+	// the semaphore signalled when the image of the frame Frame is acquired
+	VkSemaphore acquire_semaphore(std::uint32_t const Frame) const
+	{
+		return m_acquiresemaphores[Frame];
+	}
+	// the semaphore the presentation of the acquired image waits for
+	VkSemaphore present_semaphore() const
+	{
+		return m_presentsemaphores[m_image];
+	}
+	VkSwapchainKHR handle() const
+	{
+		return m_swapchain;
+	}
+	std::uint32_t image_index() const
+	{
+		return m_image;
+	}
+	// the result of the presentation of the image: out of date or suboptimal makes the swapchain anew before the next image
+	void presented(VkResult const Result);
+
+	GLFWwindow *window() const
+	{
+		return m_window;
+	}
+	VkExtent2D extent() const
+	{
+		return m_extent;
+	}
+	VkFormat format() const
+	{
+		return m_format;
+	}
+	VkPresentModeKHR present_mode() const
+	{
+		return m_presentmode;
+	}
+	bool srgb() const
+	{
+		return m_srgb;
+	}
+
+  private:
+	// false only when the device is gone or the surface is lost; a minimized window gives true with no swapchain
+	bool build(std::string &Reason);
+	void release_images();
+	// whether the swapchain has to be made anew before the next image
+	bool outdated() const;
+
+	instance const *m_instance{nullptr};
+	device const *m_device{nullptr};
+	GLFWwindow *m_window{nullptr};
+	std::string m_name;
+	VkSurfaceKHR m_surface{VK_NULL_HANDLE};
+	VkSwapchainKHR m_swapchain{VK_NULL_HANDLE};
+	VkFormat m_format{VK_FORMAT_UNDEFINED};
+	VkColorSpaceKHR m_colorspace{VK_COLOR_SPACE_SRGB_NONLINEAR_KHR};
+	VkPresentModeKHR m_presentmode{VK_PRESENT_MODE_FIFO_KHR};
+	VkExtent2D m_extent{0, 0};
+	// the size of the window the swapchain was made for; the swapchain itself may be clamped to the limits of the surface
+	glm::ivec2 m_framebuffer{0, 0};
+	// the settings the swapchain was made for
+	bool m_vsync{false};
+	bool m_srgb{false};
+	bool m_rebuild{false};
+
+	std::vector<VkImage> m_images;
+	std::vector<VkImageView> m_views;
+	// one per image: a semaphore given to the presentation can be reused only once the image comes back
+	std::vector<VkSemaphore> m_presentsemaphores;
+	// one per frame in flight: free again once the frame which waited for it is done
+	std::vector<VkSemaphore> m_acquiresemaphores;
+	std::uint32_t m_image{0};
+};
+
+} // namespace vk14