merge indev to master (#61)

.github/workflows/macos_x86.yml

@@ -29,12 +29,6 @@ jobs:
       uses: actions/checkout@v4
 
     # Install system dependencies
-    - name: Install Vulkan SDK
-      uses: humbletim/install-vulkan-sdk@v1.1.1
-      with:
-        version: 1.3.204.1
-        cache: true
-
     - name: Install Dependancies
       run: |
         brew install SDL2

.github/workflows/windows.yml

@@ -28,13 +28,6 @@ jobs:
     - name: Checkout repository
       uses: actions/checkout@v4
 
-    # Install system dependencies
-    - name: Install Vulkan SDK
-      uses: humbletim/install-vulkan-sdk@v1.1.1
-      with:
-        version: 1.3.204.1
-        cache: true
-
     # Force xmake to a specific folder (for cache)
     - name: Set xmake env
       run: echo "XMAKE_GLOBALDIR=${{ runner.workspace }}/xmake-global" >> $GITHUB_ENV

example/main.c

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/04 17:55:21 by maldavid          #+#    #+#             */
-/*   Updated: 2024/02/24 01:07:56 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/03/25 16:16:07 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -23,6 +23,8 @@ typedef struct
 	void* img;
 } mlx_t;
 
+//void* img = NULL;
+
 int update(void* param)
 {
 	static int i = 0;
@@ -30,7 +32,13 @@ int update(void* param)
 
 	if(i == 200)
 		mlx_clear_window(mlx->mlx, mlx->win);
-	
+/*
+	if(img)
+		mlx_destroy_image(mlx->mlx,img);
+	img = mlx_new_image(mlx->mlx, 800, 800);
+	mlx_set_image_pixel(mlx->mlx, img, 4, 4, 0xFF00FF00);
+	mlx_put_image_to_window(mlx->mlx, mlx->win, img, 0, 0);
+*/
 	if(i >= 250)
 		mlx_set_font_scale(mlx->mlx, mlx->win, "default", 16.f);
 	else
@@ -149,7 +157,11 @@ int main(void)
 	mlx_put_image_to_window(mlx.mlx, mlx.win, mlx.logo_png, 10, 190);
 
 	mlx.img = create_image(&mlx);
-	
+
+
+	mlx_string_put(mlx.mlx, mlx.win, 0, 10, 0xFFFFFF00, "fps:");
+	mlx_string_put(mlx.mlx, mlx.win, 0, 20, 0xFFFFFFFF, "fps:");
+
 	mlx_set_font_scale(mlx.mlx, mlx.win, "font.ttf", 16.f);
 	mlx_string_put(mlx.mlx, mlx.win, 20, 20, 0xFF0020FF, "that text will disappear");
 

src/core/application.cpp

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/04 22:10:52 by maldavid          #+#    #+#             */
-/*   Updated: 2024/02/25 07:52:04 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/04/21 18:13:29 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -50,13 +50,18 @@ namespace mlx::core
 				_loop_hook(_param);
 
 			for(auto& gs : _graphics)
-				gs->render();
+			{
+				if(gs)
+					gs->render();
+			}
 		}
 
 		Render_Core::get().getSingleTimeCmdManager().updateSingleTimesCmdBuffersSubmitState();
 
 		for(auto& gs : _graphics)
 		{
+			if(!gs)
+				continue;
 			for(int i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
 				gs->getRenderer().getCmdBuffer(i).waitForExecution();
 		}
@@ -89,10 +94,9 @@ namespace mlx::core
 			core::error::report(e_kind::error, "invalid image ptr (NULL)");
 			return;
 		}
-		else if(std::find_if(_textures.begin(), _textures.end(), [=](const Texture& texture)
-			{
-				return &texture == ptr;
-			}) == _textures.end())
+
+		auto it = std::find_if(_textures.begin(), _textures.end(), [=](const Texture& texture) { return &texture == ptr; });
+		if(it == _textures.end())
 		{
 			core::error::report(e_kind::error, "invalid image ptr");
 			return;
@@ -102,6 +106,9 @@ namespace mlx::core
 			core::error::report(e_kind::error, "trying to destroy a texture that has already been destroyed");
 		else
 			texture->destroy();
+		for(auto& gs : _graphics)
+			gs->tryEraseTextureFromManager(texture);
+		_textures.erase(it);
 	}
 
 	Application::~Application()

src/core/fps.cpp

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/01/18 14:56:17 by maldavid          #+#    #+#             */
-/*   Updated: 2024/01/18 15:20:03 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/03/25 16:44:15 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -38,7 +38,7 @@ namespace mlx
 			_fps_before += _ns;
 			return true;
 		}
-		std::this_thread::sleep_for(std::chrono::duration<double, std::nano>(_ns));
+		std::this_thread::sleep_for(std::chrono::duration<double, std::nano>(_ns - 1));
 		return false;
 	}
 }

src/core/graphics.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/04/02 14:49:49 by maldavid          #+#    #+#             */
-/*   Updated: 2024/01/11 15:47:05 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/03/24 14:43:09 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -14,7 +14,6 @@
 #define __MLX_GRAPHICS__
 
 #include <memory>
-#include <unordered_set>
 #include <filesystem>
 
 #include <glm/glm.hpp>
@@ -33,7 +32,7 @@
 
 namespace mlx
 {
-	class GraphicsSupport : public non_copyable
+	class GraphicsSupport : public NonCopyable
 	{
 		public:
 			GraphicsSupport(std::size_t w, std::size_t h, Texture* render_target, int id);
@@ -49,6 +48,7 @@ namespace mlx
 			inline void stringPut(int x, int y, std::uint32_t color, std::string str);
 			inline void texturePut(Texture* texture, int x, int y);
 			inline void loadFont(const std::filesystem::path& filepath, float scale);
+			inline void tryEraseTextureFromManager(Texture* texture) noexcept;
 
 			inline bool hasWindow() const noexcept  { return _has_window; }
 

src/core/graphics.inl

@@ -11,7 +11,6 @@
 /* ************************************************************************** */
 
 #include <core/graphics.h>
-#include <iostream>
 
 namespace mlx
 {
@@ -64,4 +63,17 @@ namespace mlx
 		MLX_PROFILE_FUNCTION();
 		_text_manager.loadFont(*_renderer, filepath, scale);
 	}
+
+	void GraphicsSupport::tryEraseTextureFromManager(Texture* texture) noexcept
+	{
+		MLX_PROFILE_FUNCTION();
+		for(auto it = _drawlist.begin(); it != _drawlist.end();)
+		{
+			if(_texture_manager.isTextureKnown(texture))
+				it = _drawlist.erase(it);
+			else
+				++it;
+		}
+		_texture_manager.eraseTextures(texture);
+	}
 }

src/core/profiler.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/01/10 13:35:45 by maldavid          #+#    #+#             */
-/*   Updated: 2024/01/10 18:36:46 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/03/24 14:41:27 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -19,10 +19,10 @@
 #include <string>
 #include <thread>
 #include <mutex>
-#include <sstream>
 #include <fstream>
-#include <iomanip>
 #include <unordered_map>
+#include <sstream>
+#include <iomanip>
 
 namespace mlx
 {
@@ -115,17 +115,17 @@ namespace mlx
 		{
 			ChangeResult<N> result = {};
 
-			std::size_t srcIndex = 0;
-			std::size_t dstIndex = 0;
-			while(srcIndex < N)
+			std::size_t src_index = 0;
+			std::size_t dst_index = 0;
+			while(src_index < N)
 			{
-				std::size_t matchIndex = 0;
-				while(matchIndex < K - 1 && srcIndex + matchIndex < N - 1 && expr[srcIndex + matchIndex] == remove[matchIndex])
-					matchIndex++;
-				if(matchIndex == K - 1)
-					srcIndex += matchIndex;
-				result.data[dstIndex++] = expr[srcIndex] == '"' ? '\'' : expr[srcIndex];
-				srcIndex++;
+				std::size_t match_index = 0;
+				while(match_index < K - 1 && src_index + match_index < N - 1 && expr[src_index + match_index] == remove[match_index])
+					match_index++;
+				if(match_index == K - 1)
+					src_index += match_index;
+				result.data[dst_index++] = expr[src_index] == '"' ? '\'' : expr[src_index];
+				src_index++;
 			}
 			return result;
 		}

src/renderer/buffers/vk_buffer.cpp

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/08 18:55:57 by maldavid          #+#    #+#             */
-/*   Updated: 2024/01/11 05:21:20 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/03/14 17:28:35 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -54,16 +54,11 @@ namespace mlx
 	void Buffer::destroy() noexcept
 	{
 		MLX_PROFILE_FUNCTION();
-		// not creating destroyer in `create` as some image may be copied (and so `this` will be invalid)
-		//CmdResource::setDestroyer([this]()
-		//{
-			if(_is_mapped)
-				unmapMem();
-			if(_buffer != VK_NULL_HANDLE)
-				Render_Core::get().getAllocator().destroyBuffer(_allocation, _buffer);
-			_buffer = VK_NULL_HANDLE;
-		//});
-		//CmdResource::requireDestroy();
+		if(_is_mapped)
+			unmapMem();
+		if(_buffer != VK_NULL_HANDLE)
+			Render_Core::get().getAllocator().destroyBuffer(_allocation, _buffer);
+		_buffer = VK_NULL_HANDLE;
 	}
 
 	void Buffer::createBuffer(VkBufferUsageFlags usage, VmaAllocationCreateInfo info, VkDeviceSize size, [[maybe_unused]] const char* name)

src/renderer/command/vk_cmd_pool.cpp

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/06 18:24:33 by maldavid          #+#    #+#             */
-/*   Updated: 2024/01/03 13:13:25 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/03/14 17:23:20 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -20,7 +20,7 @@ namespace mlx
 		VkCommandPoolCreateInfo poolInfo{};
 		poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
 		poolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
-		poolInfo.queueFamilyIndex = Render_Core::get().getQueue().getFamilies().graphicsFamily.value();
+		poolInfo.queueFamilyIndex = Render_Core::get().getQueue().getFamilies().graphics_family.value();
 
 		VkResult res = vkCreateCommandPool(Render_Core::get().getDevice().get(), &poolInfo, nullptr, &_cmd_pool);
 		if(res != VK_SUCCESS)

src/renderer/core/cmd_resource.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/12/16 20:44:29 by maldavid          #+#    #+#             */
-/*   Updated: 2024/01/11 05:12:42 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/03/14 17:28:08 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -31,31 +31,13 @@ namespace mlx
 		public:
 			CmdResource() : _uuid() {}
 			inline void recordedInCmdBuffer() noexcept { _state = state::in_cmd_buffer; }
-			inline void removedFromCmdBuffer() noexcept
-			{
-				_state = state::out_cmd_buffer;
-				if(_destroy_required && _destroyer)
-				{
-					_destroyer();
-					_destroy_required = false;
-				}
-			}
-			inline void setDestroyer(func::function<void(void)> functor) { _destroyer = functor; }
-			inline void requireDestroy() noexcept
-			{
-				if(_state == state::out_cmd_buffer && _destroyer)
-					_destroyer();
-				else
-					_destroy_required = true;
-			}
+			inline void removedFromCmdBuffer() noexcept { _state = state::out_cmd_buffer; }
 			inline UUID getUUID() const noexcept { return _uuid; }
 			virtual ~CmdResource() = default;
 
 		private:
 			UUID _uuid;
 			state _state = state::out_cmd_buffer;
-			func::function<void(void)> _destroyer;
-			bool _destroy_required = false;
 	};
 }
 

src/renderer/core/memory.cpp

@@ -6,14 +6,13 @@
 /*   By: kbz_8 <kbz_8.dev@akel-engine.com>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/10/20 22:02:37 by kbz_8             #+#    #+#             */
-/*   Updated: 2024/01/18 10:11:02 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/03/14 16:34:53 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #include <mlx_profile.h>
 #include <core/errors.h>
 #include <core/profiler.h>
-#include <cstdio>
 
 #define VMA_STATIC_VULKAN_FUNCTIONS 0
 #define VMA_DYNAMIC_VULKAN_FUNCTIONS 0
@@ -177,7 +176,7 @@ namespace mlx
 		file.close();
 		id++;
 	}
-	
+
 	void GPUallocator::flush(VmaAllocation allocation, VkDeviceSize size, VkDeviceSize offset) noexcept
 	{
 		MLX_PROFILE_FUNCTION();
@@ -187,9 +186,11 @@ namespace mlx
 	void GPUallocator::destroy() noexcept
 	{
 		if(_active_images_allocations != 0)
-			core::error::report(e_kind::error, "Graphics allocator : some user-dependant allocations were not freed before destroying the display (%d active allocations)", _active_images_allocations);
+			core::error::report(e_kind::error, "Graphics allocator : some user-dependant allocations were not freed before destroying the display (%d active allocations). You may have not destroyed all the MLX resources you've created", _active_images_allocations);
 		else if(_active_buffers_allocations != 0)
-			core::error::report(e_kind::error, "Graphics allocator : some MLX-dependant allocations were not freed before destroying the display (%d active allocations), please report, this should not happen", _active_buffers_allocations);
+			core::error::report(e_kind::error, "Graphics allocator : some MLX-dependant allocations were not freed before destroying the display (%d active allocations). This is an error in the MLX, please report this should not happen", _active_buffers_allocations);
+		if(_active_images_allocations < 0 || _active_buffers_allocations < 0)
+			core::error::report(e_kind::warning, "Graphics allocator : the impossible happened, the MLX has freed more allocations than it has made (wtf)");
 		vmaDestroyAllocator(_allocator);
 		_active_buffers_allocations = 0;
 		_active_images_allocations = 0;

src/renderer/core/memory.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/10/20 02:13:03 by maldavid          #+#    #+#             */
-/*   Updated: 2024/01/03 15:25:56 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/03/25 16:01:06 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -44,8 +44,8 @@ namespace mlx
 
 		private:
 			VmaAllocator _allocator;
-			std::uint32_t _active_buffers_allocations = 0;
-			std::uint32_t _active_images_allocations = 0;
+			std::int32_t _active_buffers_allocations = 0;
+			std::int32_t _active_images_allocations = 0;
 	};
 }
 

src/renderer/core/vk_device.cpp

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/08 19:14:29 by maldavid          #+#    #+#             */
-/*   Updated: 2024/01/20 05:34:15 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/03/14 17:23:45 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -17,8 +17,6 @@
 #include <set>
 #include <SDL2/SDL.h>
 #include <SDL2/SDL_vulkan.h>
-#include <iostream>
-#include <algorithm>
 
 namespace mlx
 {
@@ -31,7 +29,7 @@ namespace mlx
 		Queues::QueueFamilyIndices indices = Render_Core::get().getQueue().getFamilies();
 
 		std::vector<VkDeviceQueueCreateInfo> queueCreateInfos;
-		std::set<std::uint32_t> uniqueQueueFamilies = { indices.graphicsFamily.value(), indices.presentFamily.value() };
+		std::set<std::uint32_t> uniqueQueueFamilies = { indices.graphics_family.value(), indices.present_family.value() };
 
 		float queuePriority = 1.0f;
 		for(std::uint32_t queueFamily : uniqueQueueFamilies)
@@ -59,7 +57,7 @@ namespace mlx
 		createInfo.enabledLayerCount = 0;
 
 		VkResult res;
-		if((res = vkCreateDevice(_physicalDevice, &createInfo, nullptr, &_device)) != VK_SUCCESS)
+		if((res = vkCreateDevice(_physical_device, &createInfo, nullptr, &_device)) != VK_SUCCESS)
 			core::error::report(e_kind::fatal_error, "Vulkan : failed to create logcal device, %s", RCore::verbaliseResultVk(res));
 		#ifdef DEBUG
 			core::error::report(e_kind::message, "Vulkan : created new logical device");
@@ -94,16 +92,16 @@ namespace mlx
 		}
 
 		if(devices_score.rbegin()->first > 0)
-			_physicalDevice = devices_score.rbegin()->second;
+			_physical_device = devices_score.rbegin()->second;
 		else
 			core::error::report(e_kind::fatal_error, "Vulkan : failed to find a suitable GPU");
 
 		#ifdef DEBUG
 			VkPhysicalDeviceProperties props;
-			vkGetPhysicalDeviceProperties(_physicalDevice, &props);
+			vkGetPhysicalDeviceProperties(_physical_device, &props);
 			core::error::report(e_kind::message, "Vulkan : picked a physical device, %s", props.deviceName);
 		#endif
-		Render_Core::get().getQueue().findQueueFamilies(_physicalDevice, surface); // update queue indicies to current physical device
+		Render_Core::get().getQueue().findQueueFamilies(_physical_device, surface); // update queue indicies to current physical device
 		vkDestroySurfaceKHR(Render_Core::get().getInstance().get(), surface, nullptr);
 		SDL_DestroyWindow(window);
 	}

src/renderer/core/vk_device.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/08 19:13:42 by maldavid          #+#    #+#             */
-/*   Updated: 2024/01/03 15:26:14 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/03/14 16:59:54 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -15,7 +15,6 @@
 
 #include <mlx_profile.h>
 #include <volk.h>
-#include "vk_queues.h"
 
 namespace mlx
 {
@@ -28,7 +27,7 @@ namespace mlx
 			inline VkDevice& operator()() noexcept { return _device; }
 			inline VkDevice& get() noexcept { return _device; }
 
-			inline VkPhysicalDevice& getPhysicalDevice() noexcept { return _physicalDevice; }
+			inline VkPhysicalDevice& getPhysicalDevice() noexcept { return _physical_device; }
 
 		private:
 			void pickPhysicalDevice();
@@ -36,7 +35,7 @@ namespace mlx
 			int deviceScore(VkPhysicalDevice device, VkSurfaceKHR surface);
 
 		private:
-			VkPhysicalDevice _physicalDevice = VK_NULL_HANDLE;
+			VkPhysicalDevice _physical_device = VK_NULL_HANDLE;
 			VkDevice _device = VK_NULL_HANDLE;
 	};
 }

src/renderer/core/vk_queues.cpp

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/08 19:02:42 by maldavid          #+#    #+#             */
-/*   Updated: 2024/01/10 21:54:54 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/03/14 17:01:10 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -29,13 +29,13 @@ namespace mlx
 		for(const auto& queueFamily : queueFamilies)
 		{
 			if(queueFamily.queueFlags & VK_QUEUE_GRAPHICS_BIT)
-				_families->graphicsFamily = i;
+				_families->graphics_family = i;
 
 			VkBool32 presentSupport = false;
 			vkGetPhysicalDeviceSurfaceSupportKHR(device, i, surface, &presentSupport);
 
 			if(presentSupport)
-				_families->presentFamily = i;
+				_families->present_family = i;
 
 			if(_families->isComplete())
 				return *_families;
@@ -62,8 +62,8 @@ namespace mlx
 			vkDestroySurfaceKHR(Render_Core::get().getInstance().get(), surface, nullptr);
 			SDL_DestroyWindow(window);
 		}
-		vkGetDeviceQueue(Render_Core::get().getDevice().get(), _families->graphicsFamily.value(), 0, &_graphicsQueue);
-		vkGetDeviceQueue(Render_Core::get().getDevice().get(), _families->presentFamily.value(), 0, &_presentQueue);
+		vkGetDeviceQueue(Render_Core::get().getDevice().get(), _families->graphics_family.value(), 0, &_graphics_queue);
+		vkGetDeviceQueue(Render_Core::get().getDevice().get(), _families->present_family.value(), 0, &_present_queue);
 		#ifdef DEBUG
 			core::error::report(e_kind::message, "Vulkan : got graphics and present queues");
 		#endif

src/renderer/core/vk_queues.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/08 19:01:49 by maldavid          #+#    #+#             */
-/*   Updated: 2024/01/08 23:46:23 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/03/14 17:00:48 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -26,18 +26,18 @@ namespace mlx
 		public:
 			struct QueueFamilyIndices
 			{
-				std::optional<std::uint32_t> graphicsFamily;
-				std::optional<std::uint32_t> presentFamily;
+				std::optional<std::uint32_t> graphics_family;
+				std::optional<std::uint32_t> present_family;
 
-				inline bool isComplete() { return graphicsFamily.has_value() && presentFamily.has_value(); }
+				inline bool isComplete() { return graphics_family.has_value() && present_family.has_value(); }
 			};
 
 			QueueFamilyIndices findQueueFamilies(VkPhysicalDevice device, VkSurfaceKHR surface);
 
 			void init();
 
-			inline VkQueue& getGraphic() noexcept { return _graphicsQueue; }
-			inline VkQueue& getPresent() noexcept { return _presentQueue; }
+			inline VkQueue& getGraphic() noexcept { return _graphics_queue; }
+			inline VkQueue& getPresent() noexcept { return _present_queue; }
 			inline QueueFamilyIndices getFamilies() noexcept
 			{
 				if(_families.has_value())
@@ -47,8 +47,8 @@ namespace mlx
 			}
 
 		private:
-			VkQueue _graphicsQueue;
-			VkQueue _presentQueue;
+			VkQueue _graphics_queue;
+			VkQueue _present_queue;
 			std::optional<QueueFamilyIndices> _families;
 	};
 }

src/renderer/core/vk_semaphore.cpp

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/08 19:01:08 by maldavid          #+#    #+#             */
-/*   Updated: 2024/01/10 21:55:12 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/03/14 17:02:36 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -22,8 +22,8 @@ namespace mlx
 		semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
 
 		VkResult res;
-		if(	(res = vkCreateSemaphore(Render_Core::get().getDevice().get(), &semaphoreInfo, nullptr, &_imageAvailableSemaphores)) != VK_SUCCESS ||
-			(res = vkCreateSemaphore(Render_Core::get().getDevice().get(), &semaphoreInfo, nullptr, &_renderFinishedSemaphores)) != VK_SUCCESS)
+		if(	(res = vkCreateSemaphore(Render_Core::get().getDevice().get(), &semaphoreInfo, nullptr, &_image_available_semaphore)) != VK_SUCCESS ||
+			(res = vkCreateSemaphore(Render_Core::get().getDevice().get(), &semaphoreInfo, nullptr, &_render_finished_semaphore)) != VK_SUCCESS)
 			core::error::report(e_kind::fatal_error, "Vulkan : failed to create a synchronization object (semaphore), %s", RCore::verbaliseResultVk(res));
 		#ifdef DEBUG
 			core::error::report(e_kind::message, "Vulkan : created new semaphores");
@@ -32,10 +32,10 @@ namespace mlx
 
 	void Semaphore::destroy() noexcept
 	{
-		vkDestroySemaphore(Render_Core::get().getDevice().get(), _renderFinishedSemaphores, nullptr);
-		_renderFinishedSemaphores = VK_NULL_HANDLE;
-		vkDestroySemaphore(Render_Core::get().getDevice().get(), _imageAvailableSemaphores, nullptr);
-		_imageAvailableSemaphores = VK_NULL_HANDLE;
+		vkDestroySemaphore(Render_Core::get().getDevice().get(), _render_finished_semaphore, nullptr);
+		_render_finished_semaphore = VK_NULL_HANDLE;
+		vkDestroySemaphore(Render_Core::get().getDevice().get(), _image_available_semaphore, nullptr);
+		_image_available_semaphore = VK_NULL_HANDLE;
 		#ifdef DEBUG
 			core::error::report(e_kind::message, "Vulkan : destroyed semaphores");
 		#endif

src/renderer/core/vk_semaphore.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/08 18:59:38 by maldavid          #+#    #+#             */
-/*   Updated: 2024/01/03 15:26:39 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/03/14 17:01:57 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -15,7 +15,6 @@
 
 #include <mlx_profile.h>
 #include <volk.h>
-#include <vector>
 
 namespace mlx
 {
@@ -25,12 +24,12 @@ namespace mlx
 			void init();
 			void destroy() noexcept;
 
-			inline VkSemaphore& getImageSemaphore() noexcept { return _imageAvailableSemaphores; }
-			inline VkSemaphore& getRenderImageSemaphore() noexcept { return _renderFinishedSemaphores; }
+			inline VkSemaphore& getImageSemaphore() noexcept { return _image_available_semaphore; }
+			inline VkSemaphore& getRenderImageSemaphore() noexcept { return _render_finished_semaphore; }
 
 		private:
-			VkSemaphore _imageAvailableSemaphores = VK_NULL_HANDLE;
-			VkSemaphore _renderFinishedSemaphores = VK_NULL_HANDLE;
+			VkSemaphore _image_available_semaphore = VK_NULL_HANDLE;
+			VkSemaphore _render_finished_semaphore = VK_NULL_HANDLE;
 	};
 }
 

src/renderer/core/vk_validation_layers.cpp

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/12/19 14:05:25 by maldavid          #+#    #+#             */
-/*   Updated: 2024/01/10 21:55:54 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/03/14 17:03:24 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -14,7 +14,6 @@
 #include "vulkan/vulkan_core.h"
 
 #include <core/errors.h>
-#include <iostream>
 #include <cstring>
 #include <algorithm>
 
@@ -45,8 +44,8 @@ namespace mlx
 			core::error::report(e_kind::message, "Vulkan : enabled validation layers");
 		#endif
 
-		real_vkSetDebugUtilsObjectNameEXT = (PFN_vkSetDebugUtilsObjectNameEXT)vkGetInstanceProcAddr(Render_Core::get().getInstance().get(), "vkSetDebugUtilsObjectNameEXT");
-		if(!real_vkSetDebugUtilsObjectNameEXT)
+		_vkSetDebugUtilsObjectNameEXT = (PFN_vkSetDebugUtilsObjectNameEXT)vkGetInstanceProcAddr(Render_Core::get().getInstance().get(), "vkSetDebugUtilsObjectNameEXT");
+		if(!_vkSetDebugUtilsObjectNameEXT)
 			core::error::report(e_kind::warning, "Vulkan : failed to set up debug object names, %s", RCore::verbaliseResultVk(VK_ERROR_EXTENSION_NOT_PRESENT));
 		#ifdef DEBUG
 		else
@@ -75,7 +74,7 @@ namespace mlx
 
 	VkResult ValidationLayers::setDebugUtilsObjectNameEXT(VkObjectType object_type, std::uint64_t object_handle, const char* object_name)
 	{
-		if(!real_vkSetDebugUtilsObjectNameEXT)
+		if(!_vkSetDebugUtilsObjectNameEXT)
 			return VK_ERROR_EXTENSION_NOT_PRESENT;
 
 		VkDebugUtilsObjectNameInfoEXT name_info{};
@@ -83,7 +82,7 @@ namespace mlx
 		name_info.objectType = object_type;
 		name_info.objectHandle = object_handle;
 		name_info.pObjectName = object_name;
-		return real_vkSetDebugUtilsObjectNameEXT(Render_Core::get().getDevice().get(), &name_info);
+		return _vkSetDebugUtilsObjectNameEXT(Render_Core::get().getDevice().get(), &name_info);
 	}
 
 	void ValidationLayers::populateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT& createInfo)
@@ -109,7 +108,7 @@ namespace mlx
 	VkResult ValidationLayers::createDebugUtilsMessengerEXT(const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 	{
 		auto func = (PFN_vkCreateDebugUtilsMessengerEXT)vkGetInstanceProcAddr(Render_Core::get().getInstance().get(), "vkCreateDebugUtilsMessengerEXT");
-		return func != nullptr ? func(Render_Core::get().getInstance().get(), pCreateInfo, pAllocator, &_debugMessenger) : VK_ERROR_EXTENSION_NOT_PRESENT;
+		return func != nullptr ? func(Render_Core::get().getInstance().get(), pCreateInfo, pAllocator, &_debug_messenger) : VK_ERROR_EXTENSION_NOT_PRESENT;
 	}
 
 	VKAPI_ATTR VkBool32 VKAPI_CALL ValidationLayers::debugCallback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, [[maybe_unused]] VkDebugUtilsMessageTypeFlagsEXT messageType, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, [[maybe_unused]] void* pUserData)
@@ -125,7 +124,7 @@ namespace mlx
 	{
 		auto func = (PFN_vkDestroyDebugUtilsMessengerEXT)vkGetInstanceProcAddr(Render_Core::get().getInstance().get(), "vkDestroyDebugUtilsMessengerEXT");
 		if(func != nullptr)
-			func(Render_Core::get().getInstance().get(), _debugMessenger, pAllocator);
+			func(Render_Core::get().getInstance().get(), _debug_messenger, pAllocator);
 	}
 
 }

src/renderer/core/vk_validation_layers.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <marvin@42.fr>                    +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/12/19 14:04:25 by maldavid          #+#    #+#             */
-/*   Updated: 2024/01/07 00:21:42 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/03/14 17:02:55 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -39,8 +39,8 @@ namespace mlx
 			void destroyDebugUtilsMessengerEXT(const VkAllocationCallbacks* pAllocator);
 
 		private:
-			VkDebugUtilsMessengerEXT _debugMessenger;
-			PFN_vkSetDebugUtilsObjectNameEXT real_vkSetDebugUtilsObjectNameEXT = nullptr;
+			VkDebugUtilsMessengerEXT _debug_messenger;
+			PFN_vkSetDebugUtilsObjectNameEXT _vkSetDebugUtilsObjectNameEXT = nullptr;
 	};
 }
 

src/renderer/images/texture.cpp

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/03/31 18:03:35 by maldavid          #+#    #+#             */
-/*   Updated: 2024/02/24 03:51:59 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/03/14 19:07:01 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -20,8 +20,6 @@
 #define STB_IMAGE_IMPLEMENTATION
 #include <stb_image.h>
 
-#include <iostream>
-
 #ifdef IMAGE_OPTIMIZED
 	#define TILING VK_IMAGE_TILING_OPTIMAL
 #else

src/renderer/images/texture.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/03/08 02:24:58 by maldavid          #+#    #+#             */
-/*   Updated: 2024/01/11 01:18:25 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/03/14 19:06:07 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -14,15 +14,15 @@
 #define __MLX_TEXTURE__
 
 #include <filesystem>
-#include <memory>
 #include <array>
-#include <functional>
 #include <renderer/images/vk_image.h>
 #include <renderer/descriptors/vk_descriptor_set.h>
 #include <renderer/buffers/vk_ibo.h>
 #include <renderer/buffers/vk_vbo.h>
 #include <mlx_profile.h>
-#include <string>
+#ifdef DEBUG
+	#include <string>
+#endif
 
 namespace mlx
 {

src/renderer/images/texture_atlas.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/04/07 16:36:33 by maldavid          #+#    #+#             */
-/*   Updated: 2024/01/18 02:47:30 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/03/14 19:57:55 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -14,7 +14,6 @@
 #define __MLX_TEXTURE_ATLAS__
 
 #include <renderer/images/texture.h>
-#include <array>
 #include <glm/glm.hpp>
 #include <mlx_profile.h>
 

src/renderer/images/texture_manager.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/01/11 00:56:15 by maldavid          #+#    #+#             */
-/*   Updated: 2024/01/11 01:49:12 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/03/25 13:53:59 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -26,6 +26,7 @@ namespace mlx
 			TextureManager() = default;
 
 			inline void clear() { _texture_descriptors.clear(); }
+
 			inline std::pair<DrawableResource*, bool> registerTexture(Texture* texture, int x, int y)
 			{
 				MLX_PROFILE_FUNCTION();
@@ -33,6 +34,29 @@ namespace mlx
 				return std::make_pair(static_cast<DrawableResource*>(&const_cast<TextureRenderDescriptor&>(*res.first)), res.second);
 			}
 
+			inline bool isTextureKnown(Texture* texture) noexcept
+			{
+				MLX_PROFILE_FUNCTION();
+				for(const auto& desc : _texture_descriptors)
+				{
+					if(desc.texture == texture)
+						return true;
+				}
+				return false;
+			}
+
+			inline void eraseTextures(Texture* texture)
+			{
+				MLX_PROFILE_FUNCTION();
+				for(auto it = _texture_descriptors.begin(); it != _texture_descriptors.end();)
+				{
+					if(it->texture == texture)
+						it = _texture_descriptors.erase(it);
+					else
+						++it;
+				}
+			}
+
 			~TextureManager() = default;
 
 		private:

src/renderer/images/vk_image.cpp

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/01/25 11:59:07 by maldavid          #+#    #+#             */
-/*   Updated: 2024/02/25 08:03:47 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/03/14 17:28:25 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -251,17 +251,12 @@ namespace mlx
 
 	void Image::destroy() noexcept
 	{
-		// not creating destroyer in `create` as some image may be copied (and so `this` will be invalid)
-		//CmdResource::setDestroyer([this]()
-		//{
-			destroySampler();
-			destroyImageView();
+		destroySampler();
+		destroyImageView();
 
-			if(_image != VK_NULL_HANDLE)
-				Render_Core::get().getAllocator().destroyImage(_allocation, _image);
-			_image = VK_NULL_HANDLE;
-		//});
-		//CmdResource::requireDestroy();
+		if(_image != VK_NULL_HANDLE)
+			Render_Core::get().getAllocator().destroyImage(_allocation, _image);
+		_image = VK_NULL_HANDLE;
 	}
 
 	std::uint32_t formatSize(VkFormat format)

src/renderer/pipeline/pipeline.cpp

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/12/18 21:27:38 by maldavid          #+#    #+#             */
-/*   Updated: 2024/01/16 07:45:15 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/03/14 17:05:21 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -286,7 +286,7 @@ namespace mlx
 		pipelineLayoutInfo.pushConstantRangeCount = 1;
 		pipelineLayoutInfo.pPushConstantRanges = &push_constant;
 
-		if(vkCreatePipelineLayout(Render_Core::get().getDevice().get(), &pipelineLayoutInfo, nullptr, &_pipelineLayout) != VK_SUCCESS)
+		if(vkCreatePipelineLayout(Render_Core::get().getDevice().get(), &pipelineLayoutInfo, nullptr, &_pipeline_layout) != VK_SUCCESS)
 			core::error::report(e_kind::fatal_error, "Vulkan : failed to create a graphics pipeline layout");
 
 		VkGraphicsPipelineCreateInfo pipelineInfo{};
@@ -300,12 +300,12 @@ namespace mlx
 		pipelineInfo.pMultisampleState = &multisampling;
 		pipelineInfo.pColorBlendState = &colorBlending;
 		pipelineInfo.pDynamicState = &dynamicStates;
-		pipelineInfo.layout = _pipelineLayout;
+		pipelineInfo.layout = _pipeline_layout;
 		pipelineInfo.renderPass = renderer.getRenderPass().get();
 		pipelineInfo.subpass = 0;
 		pipelineInfo.basePipelineHandle = VK_NULL_HANDLE;
 
-		VkResult res = vkCreateGraphicsPipelines(Render_Core::get().getDevice().get(), VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &_graphicsPipeline);
+		VkResult res = vkCreateGraphicsPipelines(Render_Core::get().getDevice().get(), VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &_graphics_pipeline);
 		if(res != VK_SUCCESS)
 			core::error::report(e_kind::fatal_error, "Vulkan : failed to create a graphics pipeline, %s", RCore::verbaliseResultVk(res));
 #ifdef DEBUG
@@ -318,9 +318,9 @@ namespace mlx
 
 	void GraphicPipeline::destroy() noexcept
 	{
-		vkDestroyPipeline(Render_Core::get().getDevice().get(), _graphicsPipeline, nullptr);
-		vkDestroyPipelineLayout(Render_Core::get().getDevice().get(), _pipelineLayout, nullptr);
-		_graphicsPipeline = VK_NULL_HANDLE;
+		vkDestroyPipeline(Render_Core::get().getDevice().get(), _graphics_pipeline, nullptr);
+		vkDestroyPipelineLayout(Render_Core::get().getDevice().get(), _pipeline_layout, nullptr);
+		_graphics_pipeline = VK_NULL_HANDLE;
 		#ifdef DEBUG
 			core::error::report(e_kind::message, "Vulkan : destroyed a graphics pipeline");
 		#endif

src/renderer/pipeline/pipeline.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/12/18 21:23:52 by maldavid          #+#    #+#             */
-/*   Updated: 2024/01/03 15:28:13 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/03/14 17:04:28 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -25,15 +25,14 @@ namespace mlx
 			void init(class Renderer& renderer);
 			void destroy() noexcept;
 
-			inline void bindPipeline(CmdBuffer& commandBuffer) noexcept { vkCmdBindPipeline(commandBuffer.get(), VK_PIPELINE_BIND_POINT_GRAPHICS, _graphicsPipeline); }
+			inline void bindPipeline(CmdBuffer& command_buffer) noexcept { vkCmdBindPipeline(command_buffer.get(), VK_PIPELINE_BIND_POINT_GRAPHICS, _graphics_pipeline); }
 
-			inline const VkPipeline& getPipeline() const noexcept { return _graphicsPipeline; }
-			inline const VkPipelineLayout& getPipelineLayout() const noexcept { return _pipelineLayout; }
+			inline const VkPipeline& getPipeline() const noexcept { return _graphics_pipeline; }
+			inline const VkPipelineLayout& getPipelineLayout() const noexcept { return _pipeline_layout; }
 
 		private:
-			VkPipeline _graphicsPipeline = VK_NULL_HANDLE;
-			VkPipelineCache _cache = VK_NULL_HANDLE;
-			VkPipelineLayout _pipelineLayout = VK_NULL_HANDLE;
+			VkPipeline _graphics_pipeline = VK_NULL_HANDLE;
+			VkPipelineLayout _pipeline_layout = VK_NULL_HANDLE;
 	};
 }
 

src/renderer/renderer.cpp

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/12/18 17:25:16 by maldavid          #+#    #+#             */
-/*   Updated: 2024/02/25 08:02:05 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/03/14 16:34:43 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -61,7 +61,7 @@ namespace mlx
 
 		_pipeline.init(*this);
 
-		_framebufferResized = false;
+		_framebuffer_resized = false;
 	}
 
 	bool Renderer::beginFrame()
@@ -136,9 +136,9 @@ namespace mlx
 
 			VkResult result = vkQueuePresentKHR(Render_Core::get().getQueue().getPresent(), &presentInfo);
 
-			if(result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_SUBOPTIMAL_KHR || _framebufferResized)
+			if(result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_SUBOPTIMAL_KHR || _framebuffer_resized)
 			{
-				_framebufferResized = false;
+				_framebuffer_resized = false;
 				recreateRenderData();
 			}
 			else if(result != VK_SUCCESS)

src/renderer/renderer.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/12/18 17:14:45 by maldavid          #+#    #+#             */
-/*   Updated: 2024/01/20 08:18:53 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/03/14 16:34:20 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -109,7 +109,7 @@ namespace mlx
 			inline std::uint32_t getActiveImageIndex() noexcept { return _current_frame_index; }
 			inline std::uint32_t getImageIndex() noexcept { return _image_index; }
 
-			constexpr inline void requireFrameBufferResize() noexcept { _framebufferResized = true; }
+			constexpr inline void requireFrameBufferResize() noexcept { _framebuffer_resized = true; }
 
 			~Renderer() = default;
 
@@ -138,7 +138,7 @@ namespace mlx
 
 			std::uint32_t _current_frame_index = 0;
 			std::uint32_t _image_index = 0;
-			bool _framebufferResized = false;
+			bool _framebuffer_resized = false;
 	};
 }
 

src/renderer/renderpass/vk_render_pass.cpp

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/06 18:21:36 by maldavid          #+#    #+#             */
-/*   Updated: 2024/01/16 08:22:39 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/03/14 17:06:01 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -71,7 +71,7 @@ namespace mlx
 		renderPassInfo.dependencyCount = static_cast<std::uint32_t>(subpassesDeps.size());
 		renderPassInfo.pDependencies = subpassesDeps.data();
 
-		VkResult res = vkCreateRenderPass(Render_Core::get().getDevice().get(), &renderPassInfo, nullptr, &_renderPass);
+		VkResult res = vkCreateRenderPass(Render_Core::get().getDevice().get(), &renderPassInfo, nullptr, &_render_pass);
 		if(res != VK_SUCCESS)
 			core::error::report(e_kind::fatal_error, "Vulkan : failed to create render pass, %s", RCore::verbaliseResultVk(res));
 		#ifdef DEBUG
@@ -87,7 +87,7 @@ namespace mlx
 
 		VkRenderPassBeginInfo renderPassInfo{};
 		renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
-		renderPassInfo.renderPass = _renderPass;
+		renderPassInfo.renderPass = _render_pass;
 		renderPassInfo.framebuffer = fb.get();
 		renderPassInfo.renderArea.offset = { 0, 0 };
 		renderPassInfo.renderArea.extent = { fb.getWidth(), fb.getHeight() };
@@ -110,8 +110,8 @@ namespace mlx
 
 	void RenderPass::destroy() noexcept
 	{
-		vkDestroyRenderPass(Render_Core::get().getDevice().get(), _renderPass, nullptr);
-		_renderPass = VK_NULL_HANDLE;
+		vkDestroyRenderPass(Render_Core::get().getDevice().get(), _render_pass, nullptr);
+		_render_pass = VK_NULL_HANDLE;
 		#ifdef DEBUG
 			core::error::report(e_kind::message, "Vulkan : destroyed a renderpass");
 		#endif

src/renderer/renderpass/vk_render_pass.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/06 18:22:00 by maldavid          #+#    #+#             */
-/*   Updated: 2024/01/03 15:28:25 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/03/14 17:05:40 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -27,11 +27,11 @@ namespace mlx
 			void begin(class CmdBuffer& cmd, class FrameBuffer& fb);
 			void end(class CmdBuffer& cmd);
 			
-			inline VkRenderPass& operator()() noexcept { return _renderPass; }
-			inline VkRenderPass& get() noexcept { return _renderPass; }
+			inline VkRenderPass& operator()() noexcept { return _render_pass; }
+			inline VkRenderPass& get() noexcept { return _render_pass; }
 
 		private:
-			VkRenderPass _renderPass = VK_NULL_HANDLE;
+			VkRenderPass _render_pass = VK_NULL_HANDLE;
 			bool _is_running = false;
 	};
 }

src/renderer/swapchain/vk_swapchain.cpp

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/06 18:22:28 by maldavid          #+#    #+#             */
-/*   Updated: 2024/01/03 13:18:25 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/03/14 17:08:19 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -23,18 +23,18 @@ namespace mlx
 		VkDevice device = Render_Core::get().getDevice().get();
 
 		_renderer = renderer;
-		_swapChainSupport = querySwapChainSupport(Render_Core::get().getDevice().getPhysicalDevice());
+		_swapchain_support = querySwapChainSupport(Render_Core::get().getDevice().getPhysicalDevice());
 
-		VkSurfaceFormatKHR surfaceFormat = renderer->getSurface().chooseSwapSurfaceFormat(_swapChainSupport.formats);
-		VkPresentModeKHR presentMode = chooseSwapPresentMode(_swapChainSupport.presentModes);
-		_extent = chooseSwapExtent(_swapChainSupport.capabilities);
+		VkSurfaceFormatKHR surfaceFormat = renderer->getSurface().chooseSwapSurfaceFormat(_swapchain_support.formats);
+		VkPresentModeKHR presentMode = chooseSwapPresentMode(_swapchain_support.present_modes);
+		_extent = chooseSwapExtent(_swapchain_support.capabilities);
 
-		std::uint32_t imageCount = _swapChainSupport.capabilities.minImageCount + 1;
-		if(_swapChainSupport.capabilities.maxImageCount > 0 && imageCount > _swapChainSupport.capabilities.maxImageCount)
-			imageCount = _swapChainSupport.capabilities.maxImageCount;
+		std::uint32_t imageCount = _swapchain_support.capabilities.minImageCount + 1;
+		if(_swapchain_support.capabilities.maxImageCount > 0 && imageCount > _swapchain_support.capabilities.maxImageCount)
+			imageCount = _swapchain_support.capabilities.maxImageCount;
 
 		Queues::QueueFamilyIndices indices = Render_Core::get().getQueue().findQueueFamilies(Render_Core::get().getDevice().getPhysicalDevice(), renderer->getSurface().get());
-		std::uint32_t queueFamilyIndices[] = { indices.graphicsFamily.value(), indices.presentFamily.value() };
+		std::uint32_t queueFamilyIndices[] = { indices.graphics_family.value(), indices.present_family.value() };
 
 		VkSwapchainCreateInfoKHR createInfo{};
 		createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
@@ -45,12 +45,12 @@ namespace mlx
 		createInfo.imageExtent = _extent;
 		createInfo.imageArrayLayers = 1;
 		createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
-		createInfo.preTransform = _swapChainSupport.capabilities.currentTransform;
+		createInfo.preTransform = _swapchain_support.capabilities.currentTransform;
 		createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
 		createInfo.presentMode = presentMode;
 		createInfo.clipped = VK_TRUE;
 		createInfo.oldSwapchain = VK_NULL_HANDLE;
-		if(indices.graphicsFamily != indices.presentFamily)
+		if(indices.graphics_family != indices.present_family)
 		{
 			createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
 			createInfo.queueFamilyIndexCount = 2;
@@ -59,15 +59,15 @@ namespace mlx
 		else
 			createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
 
-		VkResult res = vkCreateSwapchainKHR(device, &createInfo, nullptr, &_swapChain);
+		VkResult res = vkCreateSwapchainKHR(device, &createInfo, nullptr, &_swapchain);
 		if(res != VK_SUCCESS)
 			core::error::report(e_kind::fatal_error, "Vulkan : failed to create the swapchain, %s", RCore::verbaliseResultVk(res));
 
 		std::vector<VkImage> tmp;
-		vkGetSwapchainImagesKHR(device, _swapChain, &imageCount, nullptr);
+		vkGetSwapchainImagesKHR(device, _swapchain, &imageCount, nullptr);
 		_images.resize(imageCount);
 		tmp.resize(imageCount);
-		vkGetSwapchainImagesKHR(device, _swapChain, &imageCount, tmp.data());
+		vkGetSwapchainImagesKHR(device, _swapchain, &imageCount, tmp.data());
 
 		for(std::size_t i = 0; i < imageCount; i++)
 		{
@@ -76,7 +76,7 @@ namespace mlx
 			_images[i].createImageView(VK_IMAGE_VIEW_TYPE_2D, VK_IMAGE_ASPECT_COLOR_BIT);
 		}
 
-		_swapChainImageFormat = surfaceFormat.format;
+		_swapchain_image_format = surfaceFormat.format;
 		#ifdef DEBUG
 			core::error::report(e_kind::message, "Vulkan : created new swapchain");
 		#endif
@@ -104,8 +104,8 @@ namespace mlx
 
 		if(presentModeCount != 0)
 		{
-			details.presentModes.resize(presentModeCount);
-			vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, details.presentModes.data());
+			details.present_modes.resize(presentModeCount);
+			vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, details.present_modes.data());
 		}
 
 		return details;
@@ -141,11 +141,11 @@ namespace mlx
 
 	void SwapChain::destroy() noexcept
 	{
-		if(_swapChain == VK_NULL_HANDLE)
+		if(_swapchain == VK_NULL_HANDLE)
 			return;
 		vkDeviceWaitIdle(Render_Core::get().getDevice().get());
-		vkDestroySwapchainKHR(Render_Core::get().getDevice().get(), _swapChain, nullptr);
-		_swapChain = VK_NULL_HANDLE;
+		vkDestroySwapchainKHR(Render_Core::get().getDevice().get(), _swapchain, nullptr);
+		_swapchain = VK_NULL_HANDLE;
 		for(Image& img : _images)
 			img.destroyImageView();
 	}

src/renderer/swapchain/vk_swapchain.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/06 18:23:27 by maldavid          #+#    #+#             */
-/*   Updated: 2024/01/03 15:28:39 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/03/14 17:06:41 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -31,7 +31,7 @@ namespace mlx
 			{
 				VkSurfaceCapabilitiesKHR capabilities;
 				std::vector<VkSurfaceFormatKHR> formats;
-				std::vector<VkPresentModeKHR> presentModes;
+				std::vector<VkPresentModeKHR> present_modes;
 			};
 
 		public:
@@ -45,21 +45,21 @@ namespace mlx
 			VkExtent2D chooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities);
 			VkPresentModeKHR chooseSwapPresentMode([[maybe_unused]] const std::vector<VkPresentModeKHR> &availablePresentModes);
 
-			inline VkSwapchainKHR get() noexcept { return _swapChain; }
-			inline VkSwapchainKHR operator()() noexcept { return _swapChain; }
+			inline VkSwapchainKHR get() noexcept { return _swapchain; }
+			inline VkSwapchainKHR operator()() noexcept { return _swapchain; }
 			inline std::size_t getImagesNumber() const noexcept { return _images.size(); }
 			inline Image& getImage(std::size_t i) noexcept { return _images[i]; }
-			inline SwapChainSupportDetails getSupport() noexcept { return _swapChainSupport; }
+			inline SwapChainSupportDetails getSupport() noexcept { return _swapchain_support; }
 			inline VkExtent2D getExtent() noexcept { return _extent; }
-			inline VkFormat getImagesFormat() const noexcept { return _swapChainImageFormat; }
+			inline VkFormat getImagesFormat() const noexcept { return _swapchain_image_format; }
 
 			~SwapChain() = default;
 
 		private:
-			SwapChainSupportDetails _swapChainSupport;
-			VkSwapchainKHR _swapChain;
+			SwapChainSupportDetails _swapchain_support;
+			VkSwapchainKHR _swapchain;
 			std::vector<Image> _images;
-			VkFormat _swapChainImageFormat;
+			VkFormat _swapchain_image_format;
 			VkExtent2D _extent;
 			class Renderer* _renderer = nullptr;
 	};

src/renderer/texts/text.cpp

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/01/11 00:11:56 by maldavid          #+#    #+#             */
-/*   Updated: 2024/02/25 09:01:46 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/03/25 16:13:08 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -16,12 +16,13 @@
 
 namespace mlx
 {
-	void Text::init(std::string text, FontID font, std::vector<Vertex> vbo_data, std::vector<std::uint16_t> ibo_data)
+	void Text::init(std::string text, FontID font, std::uint32_t color, std::vector<Vertex> vbo_data, std::vector<std::uint16_t> ibo_data)
 	{
 		MLX_PROFILE_FUNCTION();
 		if(_is_init)
 			return;
 		_text = std::move(text);
+		_color = color;
 		_font = font;
 		#ifdef DEBUG
 			std::string debug_name = _text;

src/renderer/texts/text.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/01/11 00:09:04 by maldavid          #+#    #+#             */
-/*   Updated: 2024/02/25 09:00:26 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/03/25 16:16:48 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -27,12 +27,13 @@ namespace mlx
 		public:
 			Text() = default;
 
-			void init(std::string text, FontID font, std::vector<Vertex> vbo_data, std::vector<std::uint16_t> ibo_data);
+			void init(std::string text, FontID font, std::uint32_t color, std::vector<Vertex> vbo_data, std::vector<std::uint16_t> ibo_data);
 			void bind(class Renderer& renderer) noexcept;
 			inline FontID getFontInUse() const noexcept { return _font; }
 			void updateVertexData(int frame, std::vector<Vertex> vbo_data);
 			inline std::uint32_t getIBOsize() noexcept { return _ibo.getSize(); }
 			inline const std::string& getText() const { return _text; }
+			inline std::uint32_t getColor() const noexcept { return _color; }
 			void destroy() noexcept;
 
 			~Text();
@@ -41,6 +42,7 @@ namespace mlx
 			std::array<D_VBO, MAX_FRAMES_IN_FLIGHT> _vbo;
 			C_IBO _ibo;
 			std::string _text;
+			std::uint32_t _color;
 			FontID _font = nullfont;
 			bool _is_init = false;
 	};	

src/renderer/texts/text_descriptor.cpp

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/01/11 00:23:11 by maldavid          #+#    #+#             */
-/*   Updated: 2024/02/25 07:58:21 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/03/25 16:13:48 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -76,7 +76,7 @@ namespace mlx
 			}
 		}
 		std::shared_ptr<Text> text_data = std::make_shared<Text>();
-		text_data->init(_text, font, std::move(vertexData), std::move(indexData));
+		text_data->init(_text, font, color, std::move(vertexData), std::move(indexData));
 		id = TextLibrary::get().addTextToLibrary(text_data);
 
 		#ifdef DEBUG

src/renderer/texts/text_library.cpp

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/04/10 11:59:57 by maldavid          #+#    #+#             */
-/*   Updated: 2024/02/25 09:29:31 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/03/25 16:17:06 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -22,7 +22,7 @@ namespace mlx
 	std::shared_ptr<Text> TextLibrary::getTextData(TextID id)
 	{
 		MLX_PROFILE_FUNCTION();
-		if(!_cache.count(id) || std::find(_invalid_ids.begin(), _invalid_ids.end(), id) != _invalid_ids.end())
+		if(!_cache.count(id))
 			core::error::report(e_kind::fatal_error, "Text Library : wrong text ID '%d'", id);
 		return _cache[id];
 	}
@@ -32,7 +32,7 @@ namespace mlx
 		MLX_PROFILE_FUNCTION();
 		auto it = std::find_if(_cache.begin(), _cache.end(), [&](const std::pair<TextID, std::shared_ptr<Text>>& v)
 		{
-			return v.second->getText() == text->getText() && std::find(_invalid_ids.begin(), _invalid_ids.end(), v.first) == _invalid_ids.end();
+			return v.second->getText() == text->getText() && v.second->getColor() == text->getColor();
 		});
 		if(it != _cache.end())
 			return it->first;
@@ -44,23 +44,20 @@ namespace mlx
 	void TextLibrary::removeTextFromLibrary(TextID id)
 	{
 		MLX_PROFILE_FUNCTION();
-		if(!_cache.count(id) || std::find(_invalid_ids.begin(), _invalid_ids.end(), id) != _invalid_ids.end())
+		if(!_cache.count(id))
 		{
 			core::error::report(e_kind::warning, "Text Library : trying to remove a text with an unkown or invalid ID '%d'", id);
 			return;
 		}
 		_cache[id]->destroy();
-		_invalid_ids.push_back(id);
+		_cache.erase(id);
 	}
 
 	void TextLibrary::clearLibrary()
 	{
 		MLX_PROFILE_FUNCTION();
 		for(auto& [id, text] : _cache)
-		{
 			text->destroy();
-			_invalid_ids.push_back(id);
-		}
-		// do not `_cache.clear();` as it releases the texts and may not destroy Vertex and Index buffers that are in use by command buffers
+		_cache.clear();
 	}
 }

src/renderer/texts/text_library.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/04/10 11:52:30 by maldavid          #+#    #+#             */
-/*   Updated: 2024/01/16 08:54:15 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/03/25 16:04:47 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -17,7 +17,6 @@
 #include <renderer/buffers/vk_ibo.h>
 #include <unordered_map>
 #include <memory>
-#include <vector>
 #include <cstdint>
 #include <mlx_profile.h>
 #include <renderer/texts/font.h>
@@ -46,7 +45,6 @@ namespace mlx
 
 		private:
 			std::unordered_map<TextID, std::shared_ptr<class Text>> _cache;
-			std::vector<TextID> _invalid_ids;
 			TextID _current_id = 1;
 	};
 }

src/renderer/texts/text_manager.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/04/06 16:24:11 by maldavid          #+#    #+#             */
-/*   Updated: 2024/02/25 07:58:36 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/03/14 17:08:43 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -19,12 +19,10 @@
 #include <stb_truetype.h>
 #include <cstdint>
 #include <unordered_set>
-#include <vector>
 #include <mlx_profile.h>
 #include <renderer/texts/text_descriptor.h>
 #include <renderer/texts/text_library.h>
 #include <renderer/texts/font_library.h>
-#include <memory>
 
 namespace mlx
 {

src/utils/non_copyable.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/08 19:20:13 by maldavid          #+#    #+#             */
-/*   Updated: 2022/10/08 19:21:22 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/03/24 14:42:48 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -15,17 +15,17 @@
 
 namespace mlx
 {
-	class non_copyable
+	class NonCopyable
 	{
 		protected:
-			non_copyable() = default;
-			virtual ~non_copyable() = default;
+			NonCopyable() = default;
+			virtual ~NonCopyable() = default;
 
 		public:
-			non_copyable(const non_copyable&) = delete;
-			non_copyable(non_copyable&&) noexcept = default;
-			non_copyable &operator=(const non_copyable&) = delete;
-			non_copyable &operator=(non_copyable&&) noexcept = default;
+			NonCopyable(const NonCopyable&) = delete;
+			NonCopyable(NonCopyable&&) noexcept = default;
+			NonCopyable &operator=(const NonCopyable&) = delete;
+			NonCopyable &operator=(NonCopyable&&) noexcept = default;
 	};
 
 }

src/utils/singleton.h

@@ -6,7 +6,7 @@
 /*   By: maldavid <kbz_8.dev@akel-engine.com>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/08 19:18:46 by maldavid          #+#    #+#             */
-/*   Updated: 2022/10/08 19:22:07 by maldavid         ###   ########.fr       */
+/*   Updated: 2024/03/24 14:42:56 by maldavid         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -18,7 +18,7 @@
 namespace mlx
 {
 	template <typename T>
-	class Singleton : public non_copyable
+	class Singleton : public NonCopyable
 	{
 		public:
 			inline static T& get()

third_party/vulkan/vulkan.cppm

@@ -908,11 +908,11 @@ export namespace VULKAN_HPP_NAMESPACE
   using VULKAN_HPP_NAMESPACE::InvalidVideoStdParametersKHRError;
 #endif /*VULKAN_HPP_NO_EXCEPTIONS*/
 
-  using VULKAN_HPP_NAMESPACE::createResultValueType;
-  using VULKAN_HPP_NAMESPACE::ignore;
-  using VULKAN_HPP_NAMESPACE::resultCheck;
   using VULKAN_HPP_NAMESPACE::ResultValue;
   using VULKAN_HPP_NAMESPACE::ResultValueType;
+  using VULKAN_HPP_NAMESPACE::detail::createResultValueType;
+  using VULKAN_HPP_NAMESPACE::detail::ignore;
+  using VULKAN_HPP_NAMESPACE::detail::resultCheck;
 
   //===========================
   //=== CONSTEXPR CONSTANTs ===
@@ -2494,10 +2494,18 @@ export namespace VULKAN_HPP_NAMESPACE
   using VULKAN_HPP_NAMESPACE::NVDescriptorPoolOverallocationExtensionName;
   using VULKAN_HPP_NAMESPACE::NVDescriptorPoolOverallocationSpecVersion;
 
+  //=== VK_NV_raw_access_chains ===
+  using VULKAN_HPP_NAMESPACE::NVRawAccessChainsExtensionName;
+  using VULKAN_HPP_NAMESPACE::NVRawAccessChainsSpecVersion;
+
   //=== VK_NV_shader_atomic_float16_vector ===
   using VULKAN_HPP_NAMESPACE::NVShaderAtomicFloat16VectorExtensionName;
   using VULKAN_HPP_NAMESPACE::NVShaderAtomicFloat16VectorSpecVersion;
 
+  //=== VK_NV_ray_tracing_validation ===
+  using VULKAN_HPP_NAMESPACE::NVRayTracingValidationExtensionName;
+  using VULKAN_HPP_NAMESPACE::NVRayTracingValidationSpecVersion;
+
   //========================
   //=== CONSTEXPR VALUEs ===
   //========================
@@ -4335,9 +4343,15 @@ export namespace VULKAN_HPP_NAMESPACE
   //=== VK_NV_descriptor_pool_overallocation ===
   using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV;
 
+  //=== VK_NV_raw_access_chains ===
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV;
+
   //=== VK_NV_shader_atomic_float16_vector ===
   using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV;
 
+  //=== VK_NV_ray_tracing_validation ===
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV;
+
   //===============
   //=== HANDLEs ===
   //===============

third_party/vulkan/vulkan.hpp

@@ -36,11 +36,11 @@
 #  if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNX__ ) || defined( __Fuchsia__ )
 #    include <dlfcn.h>
 #  elif defined( _WIN32 ) && !defined( VULKAN_HPP_NO_WIN32_PROTOTYPES )
-typedef struct HINSTANCE__ * HINSTANCE;
+using HINSTANCE = struct HINSTANCE__ *;
 #    if defined( _WIN64 )
-typedef int64_t( __stdcall * FARPROC )();
+using FARPROC   = int64_t( __stdcall * )();
 #    else
-typedef int( __stdcall * FARPROC )();
+using FARPROC = int( __stdcall * )();
 #    endif
 extern "C" __declspec( dllimport ) HINSTANCE __stdcall LoadLibraryA( char const * lpLibFileName );
 extern "C" __declspec( dllimport ) int __stdcall FreeLibrary( HINSTANCE hLibModule );
@@ -56,7 +56,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
 #  include <span>
 #endif
 
-static_assert( VK_HEADER_VERSION == 278, "Wrong VK_HEADER_VERSION!" );
+static_assert( VK_HEADER_VERSION == 283, "Wrong VK_HEADER_VERSION!" );
 
 // <tuple> includes <sys/sysmacros.h> through some other header
 // this results in major(x) being resolved to gnu_dev_major(x)
@@ -6144,6 +6144,10 @@ namespace VULKAN_HPP_NAMESPACE
   using RemoteAddressNV = void *;
   using SampleMask      = uint32_t;
 
+  template <typename Type, Type value = 0>
+  struct CppType
+  {
+  };
 }  // namespace VULKAN_HPP_NAMESPACE
 
 #include <vulkan/vulkan_enums.hpp>
@@ -6597,11 +6601,6 @@ namespace VULKAN_HPP_NAMESPACE
   }  // namespace detail
 #endif
 
-  template <typename T>
-  void ignore( T const & ) VULKAN_HPP_NOEXCEPT
-  {
-  }
-
   template <typename T>
   struct ResultValue
   {
@@ -6698,9 +6697,9 @@ namespace VULKAN_HPP_NAMESPACE
   struct ResultValueType
   {
 #ifdef VULKAN_HPP_NO_EXCEPTIONS
-    typedef ResultValue<T> type;
+    using type = ResultValue<T>;
 #else
-    typedef T    type;
+    using type = T;
 #endif
   };
 
@@ -6708,71 +6707,82 @@ namespace VULKAN_HPP_NAMESPACE
   struct ResultValueType<void>
   {
 #ifdef VULKAN_HPP_NO_EXCEPTIONS
-    typedef Result type;
+    using type = Result;
 #else
-    typedef void type;
+    using type = void;
 #endif
   };
 
-  VULKAN_HPP_INLINE typename ResultValueType<void>::type createResultValueType( Result result )
+  namespace detail
   {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    return result;
-#else
-    ignore( result );
-#endif
-  }
-
-  template <typename T>
-  VULKAN_HPP_INLINE typename ResultValueType<T>::type createResultValueType( Result result, T & data )
-  {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    return ResultValue<T>( result, data );
-#else
-    ignore( result );
-    return data;
-#endif
-  }
-
-  template <typename T>
-  VULKAN_HPP_INLINE typename ResultValueType<T>::type createResultValueType( Result result, T && data )
-  {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    return ResultValue<T>( result, std::move( data ) );
-#else
-    ignore( result );
-    return std::move( data );
-#endif
-  }
-
-  VULKAN_HPP_INLINE void resultCheck( Result result, char const * message )
-  {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    ignore( result );  // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
-    ignore( message );
-    VULKAN_HPP_ASSERT_ON_RESULT( result == Result::eSuccess );
-#else
-    if ( result != Result::eSuccess )
+    template <typename T>
+    void ignore( T const & ) VULKAN_HPP_NOEXCEPT
     {
-      detail::throwResultException( result, message );
     }
-#endif
-  }
 
-  VULKAN_HPP_INLINE void resultCheck( Result result, char const * message, std::initializer_list<Result> successCodes )
-  {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    ignore( result );  // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
-    ignore( message );
-    ignore( successCodes );  // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
-    VULKAN_HPP_ASSERT_ON_RESULT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() );
-#else
-    if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() )
+    VULKAN_HPP_INLINE typename VULKAN_HPP_NAMESPACE::ResultValueType<void>::type createResultValueType( VULKAN_HPP_NAMESPACE::Result result )
     {
-      detail::throwResultException( result, message );
-    }
+#ifdef VULKAN_HPP_NO_EXCEPTIONS
+      return result;
+#else
+      VULKAN_HPP_NAMESPACE::detail::ignore( result );
 #endif
-  }
+    }
+
+    template <typename T>
+    VULKAN_HPP_INLINE typename VULKAN_HPP_NAMESPACE::ResultValueType<T>::type createResultValueType( VULKAN_HPP_NAMESPACE::Result result, T & data )
+    {
+#ifdef VULKAN_HPP_NO_EXCEPTIONS
+      return ResultValue<T>( result, data );
+#else
+      VULKAN_HPP_NAMESPACE::detail::ignore( result );
+      return data;
+#endif
+    }
+
+    template <typename T>
+    VULKAN_HPP_INLINE typename VULKAN_HPP_NAMESPACE::ResultValueType<T>::type createResultValueType( VULKAN_HPP_NAMESPACE::Result result, T && data )
+    {
+#ifdef VULKAN_HPP_NO_EXCEPTIONS
+      return ResultValue<T>( result, std::move( data ) );
+#else
+      VULKAN_HPP_NAMESPACE::detail::ignore( result );
+      return std::move( data );
+#endif
+    }
+  }  // namespace detail
+
+  namespace detail
+  {
+    VULKAN_HPP_INLINE void resultCheck( Result result, char const * message )
+    {
+#ifdef VULKAN_HPP_NO_EXCEPTIONS
+      VULKAN_HPP_NAMESPACE::detail::ignore( result );  // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
+      VULKAN_HPP_NAMESPACE::detail::ignore( message );
+      VULKAN_HPP_ASSERT_ON_RESULT( result == Result::eSuccess );
+#else
+      if ( result != Result::eSuccess )
+      {
+        VULKAN_HPP_NAMESPACE::detail::throwResultException( result, message );
+      }
+#endif
+    }
+
+    VULKAN_HPP_INLINE void resultCheck( Result result, char const * message, std::initializer_list<Result> successCodes )
+    {
+#ifdef VULKAN_HPP_NO_EXCEPTIONS
+      VULKAN_HPP_NAMESPACE::detail::ignore( result );  // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
+      VULKAN_HPP_NAMESPACE::detail::ignore( message );
+      VULKAN_HPP_NAMESPACE::detail::ignore( successCodes );  // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
+      VULKAN_HPP_ASSERT_ON_RESULT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() );
+#else
+      if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() )
+      {
+        VULKAN_HPP_NAMESPACE::detail::throwResultException( result, message );
+      }
+#endif
+    }
+  }  // namespace detail
 
   //===========================
   //=== CONSTEXPR CONSTANTs ===
@@ -8662,10 +8672,18 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_CONSTEXPR_INLINE auto NVDescriptorPoolOverallocationExtensionName = VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_EXTENSION_NAME;
   VULKAN_HPP_CONSTEXPR_INLINE auto NVDescriptorPoolOverallocationSpecVersion   = VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_SPEC_VERSION;
 
+  //=== VK_NV_raw_access_chains ===
+  VULKAN_HPP_CONSTEXPR_INLINE auto NVRawAccessChainsExtensionName = VK_NV_RAW_ACCESS_CHAINS_EXTENSION_NAME;
+  VULKAN_HPP_CONSTEXPR_INLINE auto NVRawAccessChainsSpecVersion   = VK_NV_RAW_ACCESS_CHAINS_SPEC_VERSION;
+
   //=== VK_NV_shader_atomic_float16_vector ===
   VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderAtomicFloat16VectorExtensionName = VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_EXTENSION_NAME;
   VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderAtomicFloat16VectorSpecVersion   = VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_SPEC_VERSION;
 
+  //=== VK_NV_ray_tracing_validation ===
+  VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingValidationExtensionName = VK_NV_RAY_TRACING_VALIDATION_EXTENSION_NAME;
+  VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingValidationSpecVersion   = VK_NV_RAY_TRACING_VALIDATION_SPEC_VERSION;
+
 }  // namespace VULKAN_HPP_NAMESPACE
 
 // clang-format off
@@ -15150,6 +15168,15 @@ namespace VULKAN_HPP_NAMESPACE
     };
   };
 
+  template <>
+  struct StructExtends<ComputePipelineIndirectBufferInfoNV, ComputePipelineCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
   //=== VK_NV_linear_color_attachment ===
   template <>
   struct StructExtends<PhysicalDeviceLinearColorAttachmentFeaturesNV, PhysicalDeviceFeatures2>
@@ -16588,6 +16615,25 @@ namespace VULKAN_HPP_NAMESPACE
     };
   };
 
+  //=== VK_NV_raw_access_chains ===
+  template <>
+  struct StructExtends<PhysicalDeviceRawAccessChainsFeaturesNV, PhysicalDeviceFeatures2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  template <>
+  struct StructExtends<PhysicalDeviceRawAccessChainsFeaturesNV, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
   //=== VK_NV_shader_atomic_float16_vector ===
   template <>
   struct StructExtends<PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV, PhysicalDeviceFeatures2>
@@ -16607,6 +16653,25 @@ namespace VULKAN_HPP_NAMESPACE
     };
   };
 
+  //=== VK_NV_ray_tracing_validation ===
+  template <>
+  struct StructExtends<PhysicalDeviceRayTracingValidationFeaturesNV, PhysicalDeviceFeatures2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  template <>
+  struct StructExtends<PhysicalDeviceRayTracingValidationFeaturesNV, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
 #endif  // VULKAN_HPP_DISABLE_ENHANCED_MODE
 
 #if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL

third_party/vulkan/vulkan_core.h

@@ -69,7 +69,7 @@ extern "C" {
 #define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0
 
 // Version of this file
-#define VK_HEADER_VERSION 278
+#define VK_HEADER_VERSION 283
 
 // Complete version of this file
 #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION)
@@ -1109,7 +1109,9 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT = 1000545007,
     VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT = 1000545008,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV = 1000546000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV = 1000555000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV = 1000563000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV = 1000568000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
     VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
@@ -1674,7 +1676,7 @@ typedef enum VkFormat {
     VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005,
     VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006,
     VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007,
-    VK_FORMAT_R16G16_S10_5_NV = 1000464000,
+    VK_FORMAT_R16G16_SFIXED5_NV = 1000464000,
     VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR = 1000470000,
     VK_FORMAT_A8_UNORM_KHR = 1000470001,
     VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK,
@@ -1731,6 +1733,7 @@ typedef enum VkFormat {
     VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT = VK_FORMAT_G16_B16R16_2PLANE_444_UNORM,
     VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT = VK_FORMAT_A4R4G4B4_UNORM_PACK16,
     VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT = VK_FORMAT_A4B4G4R4_UNORM_PACK16,
+    VK_FORMAT_R16G16_S10_5_NV = VK_FORMAT_R16G16_SFIXED5_NV,
     VK_FORMAT_MAX_ENUM = 0x7FFFFFFF
 } VkFormat;
 
@@ -11107,6 +11110,7 @@ typedef VkFlags64 VkPipelineCreateFlagBits2KHR;
 static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT_KHR = 0x00000001ULL;
 static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT_KHR = 0x00000002ULL;
 static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_DERIVATIVE_BIT_KHR = 0x00000004ULL;
+static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT = 0x400000000ULL;
 static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = 0x00000008ULL;
 static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT_KHR = 0x00000010ULL;
 static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV = 0x00000020ULL;
@@ -11157,12 +11161,8 @@ static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFF
 static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT = 0x00001000ULL;
 static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR = 0x00002000ULL;
 static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR = 0x00004000ULL;
-#ifdef VK_ENABLE_BETA_EXTENSIONS
 static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR = 0x00008000ULL;
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
 static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR = 0x00010000ULL;
-#endif
 static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT_KHR = 0x00020000ULL;
 static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR = 0x00080000ULL;
 static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR = 0x00100000ULL;
@@ -18504,7 +18504,7 @@ VKAPI_ATTR void VKAPI_CALL vkCmdOpticalFlowExecuteNV(
 
 // VK_EXT_legacy_dithering is a preprocessor guard. Do not pass it to API calls.
 #define VK_EXT_legacy_dithering 1
-#define VK_EXT_LEGACY_DITHERING_SPEC_VERSION 1
+#define VK_EXT_LEGACY_DITHERING_SPEC_VERSION 2
 #define VK_EXT_LEGACY_DITHERING_EXTENSION_NAME "VK_EXT_legacy_dithering"
 typedef struct VkPhysicalDeviceLegacyDitheringFeaturesEXT {
     VkStructureType    sType;
@@ -19113,6 +19113,18 @@ typedef struct VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV {
 
 
 
+// VK_NV_raw_access_chains is a preprocessor guard. Do not pass it to API calls.
+#define VK_NV_raw_access_chains 1
+#define VK_NV_RAW_ACCESS_CHAINS_SPEC_VERSION 1
+#define VK_NV_RAW_ACCESS_CHAINS_EXTENSION_NAME "VK_NV_raw_access_chains"
+typedef struct VkPhysicalDeviceRawAccessChainsFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           shaderRawAccessChains;
+} VkPhysicalDeviceRawAccessChainsFeaturesNV;
+
+
+
 // VK_NV_shader_atomic_float16_vector is a preprocessor guard. Do not pass it to API calls.
 #define VK_NV_shader_atomic_float16_vector 1
 #define VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_SPEC_VERSION 1
@@ -19125,6 +19137,18 @@ typedef struct VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV {
 
 
 
+// VK_NV_ray_tracing_validation is a preprocessor guard. Do not pass it to API calls.
+#define VK_NV_ray_tracing_validation 1
+#define VK_NV_RAY_TRACING_VALIDATION_SPEC_VERSION 1
+#define VK_NV_RAY_TRACING_VALIDATION_EXTENSION_NAME "VK_NV_ray_tracing_validation"
+typedef struct VkPhysicalDeviceRayTracingValidationFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           rayTracingValidation;
+} VkPhysicalDeviceRayTracingValidationFeaturesNV;
+
+
+
 // VK_KHR_acceleration_structure is a preprocessor guard. Do not pass it to API calls.
 #define VK_KHR_acceleration_structure 1
 #define VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION 13

third_party/vulkan/vulkan_format_traits.hpp

@@ -362,7 +362,7 @@ namespace VULKAN_HPP_NAMESPACE
       case VULKAN_HPP_NAMESPACE::Format::ePvrtc14BppSrgbBlockIMG: return 8;
       case VULKAN_HPP_NAMESPACE::Format::ePvrtc22BppSrgbBlockIMG: return 8;
       case VULKAN_HPP_NAMESPACE::Format::ePvrtc24BppSrgbBlockIMG: return 8;
-      case VULKAN_HPP_NAMESPACE::Format::eR16G16S105NV: return 4;
+      case VULKAN_HPP_NAMESPACE::Format::eR16G16Sfixed5NV: return 4;
       case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16KHR: return 2;
       case VULKAN_HPP_NAMESPACE::Format::eA8UnormKHR: return 1;
 
@@ -621,7 +621,7 @@ namespace VULKAN_HPP_NAMESPACE
       case VULKAN_HPP_NAMESPACE::Format::ePvrtc14BppSrgbBlockIMG: return "PVRTC1_4BPP";
       case VULKAN_HPP_NAMESPACE::Format::ePvrtc22BppSrgbBlockIMG: return "PVRTC2_2BPP";
       case VULKAN_HPP_NAMESPACE::Format::ePvrtc24BppSrgbBlockIMG: return "PVRTC2_4BPP";
-      case VULKAN_HPP_NAMESPACE::Format::eR16G16S105NV: return "32-bit";
+      case VULKAN_HPP_NAMESPACE::Format::eR16G16Sfixed5NV: return "32-bit";
       case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16KHR: return "16-bit";
       case VULKAN_HPP_NAMESPACE::Format::eA8UnormKHR: return "8-bit alpha";
 
@@ -2005,7 +2005,7 @@ namespace VULKAN_HPP_NAMESPACE
           case 3: return 4;
           default: VULKAN_HPP_ASSERT( false ); return 0;
         }
-      case VULKAN_HPP_NAMESPACE::Format::eR16G16S105NV:
+      case VULKAN_HPP_NAMESPACE::Format::eR16G16Sfixed5NV:
         switch ( component )
         {
           case 0: return 16;
@@ -2283,7 +2283,7 @@ namespace VULKAN_HPP_NAMESPACE
       case VULKAN_HPP_NAMESPACE::Format::ePvrtc14BppSrgbBlockIMG: return 4;
       case VULKAN_HPP_NAMESPACE::Format::ePvrtc22BppSrgbBlockIMG: return 4;
       case VULKAN_HPP_NAMESPACE::Format::ePvrtc24BppSrgbBlockIMG: return 4;
-      case VULKAN_HPP_NAMESPACE::Format::eR16G16S105NV: return 2;
+      case VULKAN_HPP_NAMESPACE::Format::eR16G16Sfixed5NV: return 2;
       case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16KHR: return 4;
       case VULKAN_HPP_NAMESPACE::Format::eA8UnormKHR: return 1;
 
@@ -4299,7 +4299,7 @@ namespace VULKAN_HPP_NAMESPACE
           case 3: return "A";
           default: VULKAN_HPP_ASSERT( false ); return "";
         }
-      case VULKAN_HPP_NAMESPACE::Format::eR16G16S105NV:
+      case VULKAN_HPP_NAMESPACE::Format::eR16G16Sfixed5NV:
         switch ( component )
         {
           case 0: return "R";
@@ -6334,11 +6334,11 @@ namespace VULKAN_HPP_NAMESPACE
           case 3: return "SRGB";
           default: VULKAN_HPP_ASSERT( false ); return "";
         }
-      case VULKAN_HPP_NAMESPACE::Format::eR16G16S105NV:
+      case VULKAN_HPP_NAMESPACE::Format::eR16G16Sfixed5NV:
         switch ( component )
         {
-          case 0: return "SINT";
-          case 1: return "SINT";
+          case 0: return "SFIXED5";
+          case 1: return "SFIXED5";
           default: VULKAN_HPP_ASSERT( false ); return "";
         }
       case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16KHR:
@@ -7657,7 +7657,7 @@ namespace VULKAN_HPP_NAMESPACE
       case VULKAN_HPP_NAMESPACE::Format::ePvrtc14BppSrgbBlockIMG: return 1;
       case VULKAN_HPP_NAMESPACE::Format::ePvrtc22BppSrgbBlockIMG: return 1;
       case VULKAN_HPP_NAMESPACE::Format::ePvrtc24BppSrgbBlockIMG: return 1;
-      case VULKAN_HPP_NAMESPACE::Format::eR16G16S105NV: return 1;
+      case VULKAN_HPP_NAMESPACE::Format::eR16G16Sfixed5NV: return 1;
       case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16KHR: return 1;
       case VULKAN_HPP_NAMESPACE::Format::eA8UnormKHR: return 1;
 

third_party/vulkan/vulkan_hash.hpp

@@ -10653,6 +10653,20 @@ namespace std
     }
   };
 
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV>
+  {
+    std::size_t
+      operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV const & physicalDeviceRawAccessChainsFeaturesNV ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRawAccessChainsFeaturesNV.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRawAccessChainsFeaturesNV.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRawAccessChainsFeaturesNV.shaderRawAccessChains );
+      return seed;
+    }
+  };
+
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayQueryFeaturesKHR>
   {
@@ -10798,6 +10812,20 @@ namespace std
     }
   };
 
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV const & physicalDeviceRayTracingValidationFeaturesNV ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingValidationFeaturesNV.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingValidationFeaturesNV.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingValidationFeaturesNV.rayTracingValidation );
+      return seed;
+    }
+  };
+
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRelaxedLineRasterizationFeaturesIMG>
   {

third_party/vulkan/vulkan_hpp_macros.hpp

@@ -88,10 +88,11 @@
 #endif
 
 // 32-bit vulkan is not typesafe for non-dispatchable handles, so don't allow copy constructors on this platform by default.
-// To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION
+// To enable this feature on 32-bit platforms please #define VULKAN_HPP_TYPESAFE_CONVERSION 1
+// To disable this feature on 64-bit platforms please #define VULKAN_HPP_TYPESAFE_CONVERSION 0
 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
 #  if !defined( VULKAN_HPP_TYPESAFE_CONVERSION )
-#    define VULKAN_HPP_TYPESAFE_CONVERSION
+#    define VULKAN_HPP_TYPESAFE_CONVERSION 1
 #  endif
 #endif
 
@@ -131,7 +132,7 @@
 #  endif
 #endif
 
-#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
+#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
 #  define VULKAN_HPP_TYPESAFE_EXPLICIT
 #else
 #  define VULKAN_HPP_TYPESAFE_EXPLICIT explicit

third_party/vulkan/vulkan_metal.h

@@ -52,28 +52,28 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateMetalSurfaceEXT(
 #define VK_EXT_metal_objects 1
 #ifdef __OBJC__
 @protocol MTLDevice;
-typedef id<MTLDevice> MTLDevice_id;
+typedef __unsafe_unretained id<MTLDevice> MTLDevice_id;
 #else
 typedef void* MTLDevice_id;
 #endif
 
 #ifdef __OBJC__
 @protocol MTLCommandQueue;
-typedef id<MTLCommandQueue> MTLCommandQueue_id;
+typedef __unsafe_unretained id<MTLCommandQueue> MTLCommandQueue_id;
 #else
 typedef void* MTLCommandQueue_id;
 #endif
 
 #ifdef __OBJC__
 @protocol MTLBuffer;
-typedef id<MTLBuffer> MTLBuffer_id;
+typedef __unsafe_unretained id<MTLBuffer> MTLBuffer_id;
 #else
 typedef void* MTLBuffer_id;
 #endif
 
 #ifdef __OBJC__
 @protocol MTLTexture;
-typedef id<MTLTexture> MTLTexture_id;
+typedef __unsafe_unretained id<MTLTexture> MTLTexture_id;
 #else
 typedef void* MTLTexture_id;
 #endif
@@ -81,12 +81,12 @@ typedef void* MTLTexture_id;
 typedef struct __IOSurface* IOSurfaceRef;
 #ifdef __OBJC__
 @protocol MTLSharedEvent;
-typedef id<MTLSharedEvent> MTLSharedEvent_id;
+typedef __unsafe_unretained id<MTLSharedEvent> MTLSharedEvent_id;
 #else
 typedef void* MTLSharedEvent_id;
 #endif
 
-#define VK_EXT_METAL_OBJECTS_SPEC_VERSION 1
+#define VK_EXT_METAL_OBJECTS_SPEC_VERSION 2
 #define VK_EXT_METAL_OBJECTS_EXTENSION_NAME "VK_EXT_metal_objects"
 
 typedef enum VkExportMetalObjectTypeFlagBitsEXT {

third_party/vulkan/vulkan_static_assertions.hpp

@@ -7474,6 +7474,15 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
 VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV>::value,
                           "PhysicalDeviceDescriptorPoolOverallocationFeaturesNV is not nothrow_move_constructible!" );
 
+//=== VK_NV_raw_access_chains ===
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV ) == sizeof( VkPhysicalDeviceRawAccessChainsFeaturesNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV>::value,
+                          "PhysicalDeviceRawAccessChainsFeaturesNV is not nothrow_move_constructible!" );
+
 //=== VK_NV_shader_atomic_float16_vector ===
 
 VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV ) ==
@@ -7484,4 +7493,14 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
 VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV>::value,
                           "PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV is not nothrow_move_constructible!" );
 
+//=== VK_NV_ray_tracing_validation ===
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV ) ==
+                            sizeof( VkPhysicalDeviceRayTracingValidationFeaturesNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV>::value,
+                          "PhysicalDeviceRayTracingValidationFeaturesNV is not nothrow_move_constructible!" );
+
 #endif

third_party/vulkan/vulkan_structs.hpp

@@ -27655,7 +27655,11 @@ namespace VULKAN_HPP_NAMESPACE
       : vendorFaultCode( vendorFaultCode_ ), vendorFaultData( vendorFaultData_ )
     {
       VULKAN_HPP_ASSERT( description_.size() < VK_MAX_DESCRIPTION_SIZE );
-      strncpy( description, description_.data(), std::min<size_t>( description_.size(), VK_MAX_DESCRIPTION_SIZE ) );
+#    if defined( WIN32 )
+      strncpy_s( description, VK_MAX_DESCRIPTION_SIZE, description_.data(), description_.size() );
+#    else
+      strncpy( description, description_.data(), std::min<size_t>( VK_MAX_DESCRIPTION_SIZE, description_.size() ) );
+#    endif
     }
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -27679,7 +27683,11 @@ namespace VULKAN_HPP_NAMESPACE
     DeviceFaultVendorInfoEXT & setDescription( std::string const & description_ ) VULKAN_HPP_NOEXCEPT
     {
       VULKAN_HPP_ASSERT( description_.size() < VK_MAX_DESCRIPTION_SIZE );
-      strncpy( description, description_.data(), std::min<size_t>( description_.size(), VK_MAX_DESCRIPTION_SIZE ) );
+#    if defined( WIN32 )
+      strncpy_s( description, VK_MAX_DESCRIPTION_SIZE, description_.data(), description_.size() );
+#    else
+      strncpy( description, description_.data(), std::min<size_t>( VK_MAX_DESCRIPTION_SIZE, description_.size() ) );
+#    endif
       return *this;
     }
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@@ -35660,7 +35668,11 @@ namespace VULKAN_HPP_NAMESPACE
     ExtensionProperties( std::string const & extensionName_, uint32_t specVersion_ = {} ) : specVersion( specVersion_ )
     {
       VULKAN_HPP_ASSERT( extensionName_.size() < VK_MAX_EXTENSION_NAME_SIZE );
-      strncpy( extensionName, extensionName_.data(), std::min<size_t>( extensionName_.size(), VK_MAX_EXTENSION_NAME_SIZE ) );
+#    if defined( WIN32 )
+      strncpy_s( extensionName, VK_MAX_EXTENSION_NAME_SIZE, extensionName_.data(), extensionName_.size() );
+#    else
+      strncpy( extensionName, extensionName_.data(), std::min<size_t>( VK_MAX_EXTENSION_NAME_SIZE, extensionName_.size() ) );
+#    endif
     }
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -49675,9 +49687,18 @@ namespace VULKAN_HPP_NAMESPACE
       : specVersion( specVersion_ ), implementationVersion( implementationVersion_ )
     {
       VULKAN_HPP_ASSERT( layerName_.size() < VK_MAX_EXTENSION_NAME_SIZE );
-      strncpy( layerName, layerName_.data(), std::min<size_t>( layerName_.size(), VK_MAX_EXTENSION_NAME_SIZE ) );
+#    if defined( WIN32 )
+      strncpy_s( layerName, VK_MAX_EXTENSION_NAME_SIZE, layerName_.data(), layerName_.size() );
+#    else
+      strncpy( layerName, layerName_.data(), std::min<size_t>( VK_MAX_EXTENSION_NAME_SIZE, layerName_.size() ) );
+#    endif
+
       VULKAN_HPP_ASSERT( description_.size() < VK_MAX_DESCRIPTION_SIZE );
-      strncpy( description, description_.data(), std::min<size_t>( description_.size(), VK_MAX_DESCRIPTION_SIZE ) );
+#    if defined( WIN32 )
+      strncpy_s( description, VK_MAX_DESCRIPTION_SIZE, description_.data(), description_.size() );
+#    else
+      strncpy( description, description_.data(), std::min<size_t>( VK_MAX_DESCRIPTION_SIZE, description_.size() ) );
+#    endif
     }
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -55149,11 +55170,25 @@ namespace VULKAN_HPP_NAMESPACE
       : pNext( pNext_ ), flags( flags_ )
     {
       VULKAN_HPP_ASSERT( name_.size() < VK_MAX_DESCRIPTION_SIZE );
-      strncpy( name, name_.data(), std::min<size_t>( name_.size(), VK_MAX_DESCRIPTION_SIZE ) );
+#    if defined( WIN32 )
+      strncpy_s( name, VK_MAX_DESCRIPTION_SIZE, name_.data(), name_.size() );
+#    else
+      strncpy( name, name_.data(), std::min<size_t>( VK_MAX_DESCRIPTION_SIZE, name_.size() ) );
+#    endif
+
       VULKAN_HPP_ASSERT( category_.size() < VK_MAX_DESCRIPTION_SIZE );
-      strncpy( category, category_.data(), std::min<size_t>( category_.size(), VK_MAX_DESCRIPTION_SIZE ) );
+#    if defined( WIN32 )
+      strncpy_s( category, VK_MAX_DESCRIPTION_SIZE, category_.data(), category_.size() );
+#    else
+      strncpy( category, category_.data(), std::min<size_t>( VK_MAX_DESCRIPTION_SIZE, category_.size() ) );
+#    endif
+
       VULKAN_HPP_ASSERT( description_.size() < VK_MAX_DESCRIPTION_SIZE );
-      strncpy( description, description_.data(), std::min<size_t>( description_.size(), VK_MAX_DESCRIPTION_SIZE ) );
+#    if defined( WIN32 )
+      strncpy_s( description, VK_MAX_DESCRIPTION_SIZE, description_.data(), description_.size() );
+#    else
+      strncpy( description, description_.data(), std::min<size_t>( VK_MAX_DESCRIPTION_SIZE, description_.size() ) );
+#    endif
     }
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -62636,9 +62671,18 @@ namespace VULKAN_HPP_NAMESPACE
       : pNext( pNext_ ), driverID( driverID_ ), conformanceVersion( conformanceVersion_ )
     {
       VULKAN_HPP_ASSERT( driverName_.size() < VK_MAX_DRIVER_NAME_SIZE );
-      strncpy( driverName, driverName_.data(), std::min<size_t>( driverName_.size(), VK_MAX_DRIVER_NAME_SIZE ) );
+#    if defined( WIN32 )
+      strncpy_s( driverName, VK_MAX_DRIVER_NAME_SIZE, driverName_.data(), driverName_.size() );
+#    else
+      strncpy( driverName, driverName_.data(), std::min<size_t>( VK_MAX_DRIVER_NAME_SIZE, driverName_.size() ) );
+#    endif
+
       VULKAN_HPP_ASSERT( driverInfo_.size() < VK_MAX_DRIVER_INFO_SIZE );
-      strncpy( driverInfo, driverInfo_.data(), std::min<size_t>( driverInfo_.size(), VK_MAX_DRIVER_INFO_SIZE ) );
+#    if defined( WIN32 )
+      strncpy_s( driverInfo, VK_MAX_DRIVER_INFO_SIZE, driverInfo_.data(), driverInfo_.size() );
+#    else
+      strncpy( driverInfo, driverInfo_.data(), std::min<size_t>( VK_MAX_DRIVER_INFO_SIZE, driverInfo_.size() ) );
+#    endif
     }
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -77468,7 +77512,11 @@ namespace VULKAN_HPP_NAMESPACE
       , sparseProperties( sparseProperties_ )
     {
       VULKAN_HPP_ASSERT( deviceName_.size() < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE );
-      strncpy( deviceName, deviceName_.data(), std::min<size_t>( deviceName_.size(), VK_MAX_PHYSICAL_DEVICE_NAME_SIZE ) );
+#    if defined( WIN32 )
+      strncpy_s( deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE, deviceName_.data(), deviceName_.size() );
+#    else
+      strncpy( deviceName, deviceName_.data(), std::min<size_t>( VK_MAX_PHYSICAL_DEVICE_NAME_SIZE, deviceName_.size() ) );
+#    endif
     }
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -77512,7 +77560,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
-    std::strong_ordering operator<=>( PhysicalDeviceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
+    std::partial_ordering operator<=>( PhysicalDeviceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
       if ( auto cmp = apiVersion <=> rhs.apiVersion; cmp != 0 )
         return cmp;
@@ -77525,7 +77573,7 @@ namespace VULKAN_HPP_NAMESPACE
       if ( auto cmp = deviceType <=> rhs.deviceType; cmp != 0 )
         return cmp;
       if ( auto cmp = strcmp( deviceName, rhs.deviceName ); cmp != 0 )
-        return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater;
+        return ( cmp < 0 ) ? std::partial_ordering::less : std::partial_ordering::greater;
       if ( auto cmp = pipelineCacheUUID <=> rhs.pipelineCacheUUID; cmp != 0 )
         return cmp;
       if ( auto cmp = limits <=> rhs.limits; cmp != 0 )
@@ -77533,7 +77581,7 @@ namespace VULKAN_HPP_NAMESPACE
       if ( auto cmp = sparseProperties <=> rhs.sparseProperties; cmp != 0 )
         return cmp;
 
-      return std::strong_ordering::equivalent;
+      return std::partial_ordering::equivalent;
     }
 #endif
 
@@ -78334,6 +78382,104 @@ namespace VULKAN_HPP_NAMESPACE
 
   using PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM = PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT;
 
+  struct PhysicalDeviceRawAccessChainsFeaturesNV
+  {
+    using NativeType = VkPhysicalDeviceRawAccessChainsFeaturesNV;
+
+    static const bool                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::ePhysicalDeviceRawAccessChainsFeaturesNV;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceRawAccessChainsFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 shaderRawAccessChains_ = {},
+                                                                  void *                       pNext_                 = nullptr ) VULKAN_HPP_NOEXCEPT
+      : pNext( pNext_ )
+      , shaderRawAccessChains( shaderRawAccessChains_ )
+    {
+    }
+
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceRawAccessChainsFeaturesNV( PhysicalDeviceRawAccessChainsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    PhysicalDeviceRawAccessChainsFeaturesNV( VkPhysicalDeviceRawAccessChainsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
+      : PhysicalDeviceRawAccessChainsFeaturesNV( *reinterpret_cast<PhysicalDeviceRawAccessChainsFeaturesNV const *>( &rhs ) )
+    {
+    }
+
+    PhysicalDeviceRawAccessChainsFeaturesNV & operator=( PhysicalDeviceRawAccessChainsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+    PhysicalDeviceRawAccessChainsFeaturesNV & operator=( VkPhysicalDeviceRawAccessChainsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV const *>( &rhs );
+      return *this;
+    }
+
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRawAccessChainsFeaturesNV & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRawAccessChainsFeaturesNV &
+      setShaderRawAccessChains( VULKAN_HPP_NAMESPACE::Bool32 shaderRawAccessChains_ ) VULKAN_HPP_NOEXCEPT
+    {
+      shaderRawAccessChains = shaderRawAccessChains_;
+      return *this;
+    }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+    operator VkPhysicalDeviceRawAccessChainsFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceRawAccessChainsFeaturesNV *>( this );
+    }
+
+    operator VkPhysicalDeviceRawAccessChainsFeaturesNV &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPhysicalDeviceRawAccessChainsFeaturesNV *>( this );
+    }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, shaderRawAccessChains );
+    }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( PhysicalDeviceRawAccessChainsFeaturesNV const & ) const = default;
+#else
+    bool operator==( PhysicalDeviceRawAccessChainsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+#  if defined( VULKAN_HPP_USE_REFLECT )
+      return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderRawAccessChains == rhs.shaderRawAccessChains );
+#  endif
+    }
+
+    bool operator!=( PhysicalDeviceRawAccessChainsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+  public:
+    VULKAN_HPP_NAMESPACE::StructureType sType                 = StructureType::ePhysicalDeviceRawAccessChainsFeaturesNV;
+    void *                              pNext                 = {};
+    VULKAN_HPP_NAMESPACE::Bool32        shaderRawAccessChains = {};
+  };
+
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceRawAccessChainsFeaturesNV>
+  {
+    using Type = PhysicalDeviceRawAccessChainsFeaturesNV;
+  };
+
   struct PhysicalDeviceRayQueryFeaturesKHR
   {
     using NativeType = VkPhysicalDeviceRayQueryFeaturesKHR;
@@ -79343,6 +79489,104 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceRayTracingPropertiesNV;
   };
 
+  struct PhysicalDeviceRayTracingValidationFeaturesNV
+  {
+    using NativeType = VkPhysicalDeviceRayTracingValidationFeaturesNV;
+
+    static const bool                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::ePhysicalDeviceRayTracingValidationFeaturesNV;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingValidationFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 rayTracingValidation_ = {},
+                                                                       void *                       pNext_                = nullptr ) VULKAN_HPP_NOEXCEPT
+      : pNext( pNext_ )
+      , rayTracingValidation( rayTracingValidation_ )
+    {
+    }
+
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingValidationFeaturesNV( PhysicalDeviceRayTracingValidationFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    PhysicalDeviceRayTracingValidationFeaturesNV( VkPhysicalDeviceRayTracingValidationFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
+      : PhysicalDeviceRayTracingValidationFeaturesNV( *reinterpret_cast<PhysicalDeviceRayTracingValidationFeaturesNV const *>( &rhs ) )
+    {
+    }
+
+    PhysicalDeviceRayTracingValidationFeaturesNV & operator=( PhysicalDeviceRayTracingValidationFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+    PhysicalDeviceRayTracingValidationFeaturesNV & operator=( VkPhysicalDeviceRayTracingValidationFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV const *>( &rhs );
+      return *this;
+    }
+
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingValidationFeaturesNV & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingValidationFeaturesNV &
+      setRayTracingValidation( VULKAN_HPP_NAMESPACE::Bool32 rayTracingValidation_ ) VULKAN_HPP_NOEXCEPT
+    {
+      rayTracingValidation = rayTracingValidation_;
+      return *this;
+    }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+    operator VkPhysicalDeviceRayTracingValidationFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceRayTracingValidationFeaturesNV *>( this );
+    }
+
+    operator VkPhysicalDeviceRayTracingValidationFeaturesNV &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPhysicalDeviceRayTracingValidationFeaturesNV *>( this );
+    }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, rayTracingValidation );
+    }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( PhysicalDeviceRayTracingValidationFeaturesNV const & ) const = default;
+#else
+    bool operator==( PhysicalDeviceRayTracingValidationFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+#  if defined( VULKAN_HPP_USE_REFLECT )
+      return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayTracingValidation == rhs.rayTracingValidation );
+#  endif
+    }
+
+    bool operator!=( PhysicalDeviceRayTracingValidationFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+  public:
+    VULKAN_HPP_NAMESPACE::StructureType sType                = StructureType::ePhysicalDeviceRayTracingValidationFeaturesNV;
+    void *                              pNext                = {};
+    VULKAN_HPP_NAMESPACE::Bool32        rayTracingValidation = {};
+  };
+
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceRayTracingValidationFeaturesNV>
+  {
+    using Type = PhysicalDeviceRayTracingValidationFeaturesNV;
+  };
+
   struct PhysicalDeviceRelaxedLineRasterizationFeaturesIMG
   {
     using NativeType = VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG;
@@ -86740,13 +86984,32 @@ namespace VULKAN_HPP_NAMESPACE
       : pNext( pNext_ ), purposes( purposes_ )
     {
       VULKAN_HPP_ASSERT( name_.size() < VK_MAX_EXTENSION_NAME_SIZE );
-      strncpy( name, name_.data(), std::min<size_t>( name_.size(), VK_MAX_EXTENSION_NAME_SIZE ) );
+#    if defined( WIN32 )
+      strncpy_s( name, VK_MAX_EXTENSION_NAME_SIZE, name_.data(), name_.size() );
+#    else
+      strncpy( name, name_.data(), std::min<size_t>( VK_MAX_EXTENSION_NAME_SIZE, name_.size() ) );
+#    endif
+
       VULKAN_HPP_ASSERT( version_.size() < VK_MAX_EXTENSION_NAME_SIZE );
-      strncpy( version, version_.data(), std::min<size_t>( version_.size(), VK_MAX_EXTENSION_NAME_SIZE ) );
+#    if defined( WIN32 )
+      strncpy_s( version, VK_MAX_EXTENSION_NAME_SIZE, version_.data(), version_.size() );
+#    else
+      strncpy( version, version_.data(), std::min<size_t>( VK_MAX_EXTENSION_NAME_SIZE, version_.size() ) );
+#    endif
+
       VULKAN_HPP_ASSERT( description_.size() < VK_MAX_DESCRIPTION_SIZE );
-      strncpy( description, description_.data(), std::min<size_t>( description_.size(), VK_MAX_DESCRIPTION_SIZE ) );
+#    if defined( WIN32 )
+      strncpy_s( description, VK_MAX_DESCRIPTION_SIZE, description_.data(), description_.size() );
+#    else
+      strncpy( description, description_.data(), std::min<size_t>( VK_MAX_DESCRIPTION_SIZE, description_.size() ) );
+#    endif
+
       VULKAN_HPP_ASSERT( layer_.size() < VK_MAX_EXTENSION_NAME_SIZE );
-      strncpy( layer, layer_.data(), std::min<size_t>( layer_.size(), VK_MAX_EXTENSION_NAME_SIZE ) );
+#    if defined( WIN32 )
+      strncpy_s( layer, VK_MAX_EXTENSION_NAME_SIZE, layer_.data(), layer_.size() );
+#    else
+      strncpy( layer, layer_.data(), std::min<size_t>( VK_MAX_EXTENSION_NAME_SIZE, layer_.size() ) );
+#    endif
     }
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -89424,9 +89687,18 @@ namespace VULKAN_HPP_NAMESPACE
       , framebufferIntegerColorSampleCounts( framebufferIntegerColorSampleCounts_ )
     {
       VULKAN_HPP_ASSERT( driverName_.size() < VK_MAX_DRIVER_NAME_SIZE );
-      strncpy( driverName, driverName_.data(), std::min<size_t>( driverName_.size(), VK_MAX_DRIVER_NAME_SIZE ) );
+#    if defined( WIN32 )
+      strncpy_s( driverName, VK_MAX_DRIVER_NAME_SIZE, driverName_.data(), driverName_.size() );
+#    else
+      strncpy( driverName, driverName_.data(), std::min<size_t>( VK_MAX_DRIVER_NAME_SIZE, driverName_.size() ) );
+#    endif
+
       VULKAN_HPP_ASSERT( driverInfo_.size() < VK_MAX_DRIVER_INFO_SIZE );
-      strncpy( driverInfo, driverInfo_.data(), std::min<size_t>( driverInfo_.size(), VK_MAX_DRIVER_INFO_SIZE ) );
+#    if defined( WIN32 )
+      strncpy_s( driverInfo, VK_MAX_DRIVER_INFO_SIZE, driverInfo_.data(), driverInfo_.size() );
+#    else
+      strncpy( driverInfo, driverInfo_.data(), std::min<size_t>( VK_MAX_DRIVER_INFO_SIZE, driverInfo_.size() ) );
+#    endif
     }
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -92731,9 +93003,18 @@ namespace VULKAN_HPP_NAMESPACE
       : pNext( pNext_ ), isText( isText_ ), dataSize( data_.size() * sizeof( T ) ), pData( data_.data() )
     {
       VULKAN_HPP_ASSERT( name_.size() < VK_MAX_DESCRIPTION_SIZE );
-      strncpy( name, name_.data(), std::min<size_t>( name_.size(), VK_MAX_DESCRIPTION_SIZE ) );
+#    if defined( WIN32 )
+      strncpy_s( name, VK_MAX_DESCRIPTION_SIZE, name_.data(), name_.size() );
+#    else
+      strncpy( name, name_.data(), std::min<size_t>( VK_MAX_DESCRIPTION_SIZE, name_.size() ) );
+#    endif
+
       VULKAN_HPP_ASSERT( description_.size() < VK_MAX_DESCRIPTION_SIZE );
-      strncpy( description, description_.data(), std::min<size_t>( description_.size(), VK_MAX_DESCRIPTION_SIZE ) );
+#    if defined( WIN32 )
+      strncpy_s( description, VK_MAX_DESCRIPTION_SIZE, description_.data(), description_.size() );
+#    else
+      strncpy( description, description_.data(), std::min<size_t>( VK_MAX_DESCRIPTION_SIZE, description_.size() ) );
+#    endif
     }
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -92860,9 +93141,18 @@ namespace VULKAN_HPP_NAMESPACE
       : pNext( pNext_ ), stages( stages_ ), subgroupSize( subgroupSize_ )
     {
       VULKAN_HPP_ASSERT( name_.size() < VK_MAX_DESCRIPTION_SIZE );
-      strncpy( name, name_.data(), std::min<size_t>( name_.size(), VK_MAX_DESCRIPTION_SIZE ) );
+#    if defined( WIN32 )
+      strncpy_s( name, VK_MAX_DESCRIPTION_SIZE, name_.data(), name_.size() );
+#    else
+      strncpy( name, name_.data(), std::min<size_t>( VK_MAX_DESCRIPTION_SIZE, name_.size() ) );
+#    endif
+
       VULKAN_HPP_ASSERT( description_.size() < VK_MAX_DESCRIPTION_SIZE );
-      strncpy( description, description_.data(), std::min<size_t>( description_.size(), VK_MAX_DESCRIPTION_SIZE ) );
+#    if defined( WIN32 )
+      strncpy_s( description, VK_MAX_DESCRIPTION_SIZE, description_.data(), description_.size() );
+#    else
+      strncpy( description, description_.data(), std::min<size_t>( VK_MAX_DESCRIPTION_SIZE, description_.size() ) );
+#    endif
     }
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -93050,9 +93340,18 @@ namespace VULKAN_HPP_NAMESPACE
       : pNext( pNext_ ), format( format_ ), value( value_ )
     {
       VULKAN_HPP_ASSERT( name_.size() < VK_MAX_DESCRIPTION_SIZE );
-      strncpy( name, name_.data(), std::min<size_t>( name_.size(), VK_MAX_DESCRIPTION_SIZE ) );
+#    if defined( WIN32 )
+      strncpy_s( name, VK_MAX_DESCRIPTION_SIZE, name_.data(), name_.size() );
+#    else
+      strncpy( name, name_.data(), std::min<size_t>( VK_MAX_DESCRIPTION_SIZE, name_.size() ) );
+#    endif
+
       VULKAN_HPP_ASSERT( description_.size() < VK_MAX_DESCRIPTION_SIZE );
-      strncpy( description, description_.data(), std::min<size_t>( description_.size(), VK_MAX_DESCRIPTION_SIZE ) );
+#    if defined( WIN32 )
+      strncpy_s( description, VK_MAX_DESCRIPTION_SIZE, description_.data(), description_.size() );
+#    else
+      strncpy( description, description_.data(), std::min<size_t>( VK_MAX_DESCRIPTION_SIZE, description_.size() ) );
+#    endif
     }
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -104104,7 +104403,11 @@ namespace VULKAN_HPP_NAMESPACE
       : subpassMergeStatus( subpassMergeStatus_ ), postMergeIndex( postMergeIndex_ )
     {
       VULKAN_HPP_ASSERT( description_.size() < VK_MAX_DESCRIPTION_SIZE );
-      strncpy( description, description_.data(), std::min<size_t>( description_.size(), VK_MAX_DESCRIPTION_SIZE ) );
+#    if defined( WIN32 )
+      strncpy_s( description, VK_MAX_DESCRIPTION_SIZE, description_.data(), description_.size() );
+#    else
+      strncpy( description, description_.data(), std::min<size_t>( VK_MAX_DESCRIPTION_SIZE, description_.size() ) );
+#    endif
     }
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 

third_party/vulkan/vulkan_to_string.hpp

@@ -77,14 +77,14 @@ namespace VULKAN_HPP_NAMESPACE
       result += "CositedChromaSamples | ";
     if ( value & FormatFeatureFlagBits::eSampledImageFilterMinmax )
       result += "SampledImageFilterMinmax | ";
+    if ( value & FormatFeatureFlagBits::eSampledImageFilterCubicEXT )
+      result += "SampledImageFilterCubicEXT | ";
     if ( value & FormatFeatureFlagBits::eVideoDecodeOutputKHR )
       result += "VideoDecodeOutputKHR | ";
     if ( value & FormatFeatureFlagBits::eVideoDecodeDpbKHR )
       result += "VideoDecodeDpbKHR | ";
     if ( value & FormatFeatureFlagBits::eAccelerationStructureVertexBufferKHR )
       result += "AccelerationStructureVertexBufferKHR | ";
-    if ( value & FormatFeatureFlagBits::eSampledImageFilterCubicEXT )
-      result += "SampledImageFilterCubicEXT | ";
     if ( value & FormatFeatureFlagBits::eFragmentDensityMapEXT )
       result += "FragmentDensityMapEXT | ";
     if ( value & FormatFeatureFlagBits::eFragmentShadingRateAttachmentKHR )
@@ -175,10 +175,10 @@ namespace VULKAN_HPP_NAMESPACE
       result += "VideoDecodeSrcKHR | ";
     if ( value & ImageUsageFlagBits::eVideoDecodeDpbKHR )
       result += "VideoDecodeDpbKHR | ";
-    if ( value & ImageUsageFlagBits::eFragmentDensityMapEXT )
-      result += "FragmentDensityMapEXT | ";
     if ( value & ImageUsageFlagBits::eFragmentShadingRateAttachmentKHR )
       result += "FragmentShadingRateAttachmentKHR | ";
+    if ( value & ImageUsageFlagBits::eFragmentDensityMapEXT )
+      result += "FragmentDensityMapEXT | ";
     if ( value & ImageUsageFlagBits::eHostTransferEXT )
       result += "HostTransferEXT | ";
     if ( value & ImageUsageFlagBits::eVideoEncodeDstKHR )
@@ -368,16 +368,16 @@ namespace VULKAN_HPP_NAMESPACE
       result += "AccelerationStructureBuildKHR | ";
     if ( value & PipelineStageFlagBits::eRayTracingShaderKHR )
       result += "RayTracingShaderKHR | ";
-    if ( value & PipelineStageFlagBits::eFragmentDensityProcessEXT )
-      result += "FragmentDensityProcessEXT | ";
     if ( value & PipelineStageFlagBits::eFragmentShadingRateAttachmentKHR )
       result += "FragmentShadingRateAttachmentKHR | ";
-    if ( value & PipelineStageFlagBits::eCommandPreprocessNV )
-      result += "CommandPreprocessNV | ";
     if ( value & PipelineStageFlagBits::eTaskShaderEXT )
       result += "TaskShaderEXT | ";
     if ( value & PipelineStageFlagBits::eMeshShaderEXT )
       result += "MeshShaderEXT | ";
+    if ( value & PipelineStageFlagBits::eFragmentDensityProcessEXT )
+      result += "FragmentDensityProcessEXT | ";
+    if ( value & PipelineStageFlagBits::eCommandPreprocessNV )
+      result += "CommandPreprocessNV | ";
 
     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
   }
@@ -966,10 +966,10 @@ namespace VULKAN_HPP_NAMESPACE
       result += "DescriptorBufferEXT | ";
     if ( value & DescriptorSetLayoutCreateFlagBits::eEmbeddedImmutableSamplersEXT )
       result += "EmbeddedImmutableSamplersEXT | ";
-    if ( value & DescriptorSetLayoutCreateFlagBits::eIndirectBindableNV )
-      result += "IndirectBindableNV | ";
     if ( value & DescriptorSetLayoutCreateFlagBits::eHostOnlyPoolEXT )
       result += "HostOnlyPoolEXT | ";
+    if ( value & DescriptorSetLayoutCreateFlagBits::eIndirectBindableNV )
+      result += "IndirectBindableNV | ";
     if ( value & DescriptorSetLayoutCreateFlagBits::ePerStageNV )
       result += "PerStageNV | ";
 
@@ -1030,10 +1030,10 @@ namespace VULKAN_HPP_NAMESPACE
       result += "AccelerationStructureReadKHR | ";
     if ( value & AccessFlagBits::eAccelerationStructureWriteKHR )
       result += "AccelerationStructureWriteKHR | ";
-    if ( value & AccessFlagBits::eFragmentDensityMapReadEXT )
-      result += "FragmentDensityMapReadEXT | ";
     if ( value & AccessFlagBits::eFragmentShadingRateAttachmentReadKHR )
       result += "FragmentShadingRateAttachmentReadKHR | ";
+    if ( value & AccessFlagBits::eFragmentDensityMapReadEXT )
+      result += "FragmentDensityMapReadEXT | ";
     if ( value & AccessFlagBits::eCommandPreprocessReadNV )
       result += "CommandPreprocessReadNV | ";
     if ( value & AccessFlagBits::eCommandPreprocessWriteNV )
@@ -2915,8 +2915,8 @@ namespace VULKAN_HPP_NAMESPACE
     std::string result;
     if ( value & VideoEncodeCapabilityFlagBitsKHR::ePrecedingExternallyEncodedBytes )
       result += "PrecedingExternallyEncodedBytes | ";
-    if ( value & VideoEncodeCapabilityFlagBitsKHR::eInsufficientstreamBufferRangeDetectionBit )
-      result += "InsufficientstreamBufferRangeDetectionBit | ";
+    if ( value & VideoEncodeCapabilityFlagBitsKHR::eInsufficientBitstreamBufferRangeDetection )
+      result += "InsufficientBitstreamBufferRangeDetection | ";
 
     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
   }
@@ -2927,12 +2927,12 @@ namespace VULKAN_HPP_NAMESPACE
       return "{}";
 
     std::string result;
-    if ( value & VideoEncodeFeedbackFlagBitsKHR::estreamBufferOffsetBit )
-      result += "streamBufferOffsetBit | ";
-    if ( value & VideoEncodeFeedbackFlagBitsKHR::estreamBytesWrittenBit )
-      result += "streamBytesWrittenBit | ";
-    if ( value & VideoEncodeFeedbackFlagBitsKHR::estreamHasOverridesBit )
-      result += "streamHasOverridesBit | ";
+    if ( value & VideoEncodeFeedbackFlagBitsKHR::eBitstreamBufferOffset )
+      result += "BitstreamBufferOffset | ";
+    if ( value & VideoEncodeFeedbackFlagBitsKHR::eBitstreamBytesWritten )
+      result += "BitstreamBytesWritten | ";
+    if ( value & VideoEncodeFeedbackFlagBitsKHR::eBitstreamHasOverrides )
+      result += "BitstreamHasOverrides | ";
 
     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
   }
@@ -3372,6 +3372,8 @@ namespace VULKAN_HPP_NAMESPACE
       result += "AllowDerivatives | ";
     if ( value & PipelineCreateFlagBits2KHR::eDerivative )
       result += "Derivative | ";
+    if ( value & PipelineCreateFlagBits2KHR::eEnableLegacyDitheringEXT )
+      result += "EnableLegacyDitheringEXT | ";
     if ( value & PipelineCreateFlagBits2KHR::eViewIndexFromDeviceIndex )
       result += "ViewIndexFromDeviceIndex | ";
     if ( value & PipelineCreateFlagBits2KHR::eDispatchBase )
@@ -3472,12 +3474,10 @@ namespace VULKAN_HPP_NAMESPACE
       result += "VideoDecodeSrc | ";
     if ( value & BufferUsageFlagBits2KHR::eVideoDecodeDst )
       result += "VideoDecodeDst | ";
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
     if ( value & BufferUsageFlagBits2KHR::eVideoEncodeDst )
       result += "VideoEncodeDst | ";
     if ( value & BufferUsageFlagBits2KHR::eVideoEncodeSrc )
       result += "VideoEncodeSrc | ";
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
     if ( value & BufferUsageFlagBits2KHR::eShaderDeviceAddress )
       result += "ShaderDeviceAddress | ";
     if ( value & BufferUsageFlagBits2KHR::eAccelerationStructureBuildInputReadOnly )
@@ -4093,11 +4093,13 @@ namespace VULKAN_HPP_NAMESPACE
       case StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV: return "PipelineRepresentativeFragmentTestStateCreateInfoNV";
       case StructureType::ePhysicalDeviceImageViewImageFormatInfoEXT: return "PhysicalDeviceImageViewImageFormatInfoEXT";
       case StructureType::eFilterCubicImageViewImageFormatPropertiesEXT: return "FilterCubicImageViewImageFormatPropertiesEXT";
+      case StructureType::eDeviceQueueGlobalPriorityCreateInfoKHR: return "DeviceQueueGlobalPriorityCreateInfoKHR";
       case StructureType::eImportMemoryHostPointerInfoEXT: return "ImportMemoryHostPointerInfoEXT";
       case StructureType::eMemoryHostPointerPropertiesEXT: return "MemoryHostPointerPropertiesEXT";
       case StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT: return "PhysicalDeviceExternalMemoryHostPropertiesEXT";
       case StructureType::ePhysicalDeviceShaderClockFeaturesKHR: return "PhysicalDeviceShaderClockFeaturesKHR";
       case StructureType::ePipelineCompilerControlCreateInfoAMD: return "PipelineCompilerControlCreateInfoAMD";
+      case StructureType::eCalibratedTimestampInfoKHR: return "CalibratedTimestampInfoKHR";
       case StructureType::ePhysicalDeviceShaderCorePropertiesAMD: return "PhysicalDeviceShaderCorePropertiesAMD";
       case StructureType::eVideoDecodeH265CapabilitiesKHR: return "VideoDecodeH265CapabilitiesKHR";
       case StructureType::eVideoDecodeH265SessionParametersCreateInfoKHR: return "VideoDecodeH265SessionParametersCreateInfoKHR";
@@ -4105,17 +4107,19 @@ namespace VULKAN_HPP_NAMESPACE
       case StructureType::eVideoDecodeH265ProfileInfoKHR: return "VideoDecodeH265ProfileInfoKHR";
       case StructureType::eVideoDecodeH265PictureInfoKHR: return "VideoDecodeH265PictureInfoKHR";
       case StructureType::eVideoDecodeH265DpbSlotInfoKHR: return "VideoDecodeH265DpbSlotInfoKHR";
-      case StructureType::eDeviceQueueGlobalPriorityCreateInfoKHR: return "DeviceQueueGlobalPriorityCreateInfoKHR";
       case StructureType::ePhysicalDeviceGlobalPriorityQueryFeaturesKHR: return "PhysicalDeviceGlobalPriorityQueryFeaturesKHR";
       case StructureType::eQueueFamilyGlobalPriorityPropertiesKHR: return "QueueFamilyGlobalPriorityPropertiesKHR";
       case StructureType::eDeviceMemoryOverallocationCreateInfoAMD: return "DeviceMemoryOverallocationCreateInfoAMD";
       case StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT: return "PhysicalDeviceVertexAttributeDivisorPropertiesEXT";
+      case StructureType::ePipelineVertexInputDivisorStateCreateInfoKHR: return "PipelineVertexInputDivisorStateCreateInfoKHR";
+      case StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesKHR: return "PhysicalDeviceVertexAttributeDivisorFeaturesKHR";
 #if defined( VK_USE_PLATFORM_GGP )
       case StructureType::ePresentFrameTokenGGP: return "PresentFrameTokenGGP";
 #endif /*VK_USE_PLATFORM_GGP*/
       case StructureType::ePhysicalDeviceComputeShaderDerivativesFeaturesNV: return "PhysicalDeviceComputeShaderDerivativesFeaturesNV";
       case StructureType::ePhysicalDeviceMeshShaderFeaturesNV: return "PhysicalDeviceMeshShaderFeaturesNV";
       case StructureType::ePhysicalDeviceMeshShaderPropertiesNV: return "PhysicalDeviceMeshShaderPropertiesNV";
+      case StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesKHR: return "PhysicalDeviceFragmentShaderBarycentricFeaturesKHR";
       case StructureType::ePhysicalDeviceShaderImageFootprintFeaturesNV: return "PhysicalDeviceShaderImageFootprintFeaturesNV";
       case StructureType::ePipelineViewportExclusiveScissorStateCreateInfoNV: return "PipelineViewportExclusiveScissorStateCreateInfoNV";
       case StructureType::ePhysicalDeviceExclusiveScissorFeaturesNV: return "PhysicalDeviceExclusiveScissorFeaturesNV";
@@ -4178,7 +4182,11 @@ namespace VULKAN_HPP_NAMESPACE
       case StructureType::eSurfaceFullScreenExclusiveWin32InfoEXT: return "SurfaceFullScreenExclusiveWin32InfoEXT";
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
       case StructureType::eHeadlessSurfaceCreateInfoEXT: return "HeadlessSurfaceCreateInfoEXT";
+      case StructureType::ePhysicalDeviceLineRasterizationFeaturesKHR: return "PhysicalDeviceLineRasterizationFeaturesKHR";
+      case StructureType::ePipelineRasterizationLineStateCreateInfoKHR: return "PipelineRasterizationLineStateCreateInfoKHR";
+      case StructureType::ePhysicalDeviceLineRasterizationPropertiesKHR: return "PhysicalDeviceLineRasterizationPropertiesKHR";
       case StructureType::ePhysicalDeviceShaderAtomicFloatFeaturesEXT: return "PhysicalDeviceShaderAtomicFloatFeaturesEXT";
+      case StructureType::ePhysicalDeviceIndexTypeUint8FeaturesKHR: return "PhysicalDeviceIndexTypeUint8FeaturesKHR";
       case StructureType::ePhysicalDeviceExtendedDynamicStateFeaturesEXT: return "PhysicalDeviceExtendedDynamicStateFeaturesEXT";
       case StructureType::ePhysicalDevicePipelineExecutablePropertiesFeaturesKHR: return "PhysicalDevicePipelineExecutablePropertiesFeaturesKHR";
       case StructureType::ePipelineInfoKHR: return "PipelineInfoKHR";
@@ -4295,7 +4303,6 @@ namespace VULKAN_HPP_NAMESPACE
       case StructureType::ePhysicalDeviceGraphicsPipelineLibraryPropertiesEXT: return "PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT";
       case StructureType::eGraphicsPipelineLibraryCreateInfoEXT: return "GraphicsPipelineLibraryCreateInfoEXT";
       case StructureType::ePhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD: return "PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD";
-      case StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesKHR: return "PhysicalDeviceFragmentShaderBarycentricFeaturesKHR";
       case StructureType::ePhysicalDeviceFragmentShaderBarycentricPropertiesKHR: return "PhysicalDeviceFragmentShaderBarycentricPropertiesKHR";
       case StructureType::ePhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR: return "PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR";
       case StructureType::ePhysicalDeviceFragmentShadingRateEnumsPropertiesNV: return "PhysicalDeviceFragmentShadingRateEnumsPropertiesNV";
@@ -4313,16 +4320,21 @@ namespace VULKAN_HPP_NAMESPACE
       case StructureType::ePhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR: return "PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR";
       case StructureType::ePhysicalDeviceImageCompressionControlFeaturesEXT: return "PhysicalDeviceImageCompressionControlFeaturesEXT";
       case StructureType::eImageCompressionControlEXT: return "ImageCompressionControlEXT";
+      case StructureType::eSubresourceLayout2KHR: return "SubresourceLayout2KHR";
+      case StructureType::eImageSubresource2KHR: return "ImageSubresource2KHR";
       case StructureType::eImageCompressionPropertiesEXT: return "ImageCompressionPropertiesEXT";
       case StructureType::ePhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT: return "PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT";
       case StructureType::ePhysicalDevice4444FormatsFeaturesEXT: return "PhysicalDevice4444FormatsFeaturesEXT";
       case StructureType::ePhysicalDeviceFaultFeaturesEXT: return "PhysicalDeviceFaultFeaturesEXT";
       case StructureType::eDeviceFaultCountsEXT: return "DeviceFaultCountsEXT";
       case StructureType::eDeviceFaultInfoEXT: return "DeviceFaultInfoEXT";
+      case StructureType::ePhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT: return "PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT";
       case StructureType::ePhysicalDeviceRgba10X6FormatsFeaturesEXT: return "PhysicalDeviceRgba10X6FormatsFeaturesEXT";
 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
       case StructureType::eDirectfbSurfaceCreateInfoEXT: return "DirectfbSurfaceCreateInfoEXT";
 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
+      case StructureType::ePhysicalDeviceMutableDescriptorTypeFeaturesEXT: return "PhysicalDeviceMutableDescriptorTypeFeaturesEXT";
+      case StructureType::eMutableDescriptorTypeCreateInfoEXT: return "MutableDescriptorTypeCreateInfoEXT";
       case StructureType::ePhysicalDeviceVertexInputDynamicStateFeaturesEXT: return "PhysicalDeviceVertexInputDynamicStateFeaturesEXT";
       case StructureType::eVertexInputBindingDescription2EXT: return "VertexInputBindingDescription2EXT";
       case StructureType::eVertexInputAttributeDescription2EXT: return "VertexInputAttributeDescription2EXT";
@@ -4446,7 +4458,6 @@ namespace VULKAN_HPP_NAMESPACE
       case StructureType::ePhysicalDeviceShaderModuleIdentifierPropertiesEXT: return "PhysicalDeviceShaderModuleIdentifierPropertiesEXT";
       case StructureType::ePipelineShaderStageModuleIdentifierCreateInfoEXT: return "PipelineShaderStageModuleIdentifierCreateInfoEXT";
       case StructureType::eShaderModuleIdentifierEXT: return "ShaderModuleIdentifierEXT";
-      case StructureType::ePhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT: return "PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT";
       case StructureType::ePhysicalDeviceOpticalFlowFeaturesNV: return "PhysicalDeviceOpticalFlowFeaturesNV";
       case StructureType::ePhysicalDeviceOpticalFlowPropertiesNV: return "PhysicalDeviceOpticalFlowPropertiesNV";
       case StructureType::eOpticalFlowImageFormatInfoNV: return "OpticalFlowImageFormatInfoNV";
@@ -4465,8 +4476,6 @@ namespace VULKAN_HPP_NAMESPACE
       case StructureType::ePhysicalDeviceMaintenance5PropertiesKHR: return "PhysicalDeviceMaintenance5PropertiesKHR";
       case StructureType::eRenderingAreaInfoKHR: return "RenderingAreaInfoKHR";
       case StructureType::eDeviceImageSubresourceInfoKHR: return "DeviceImageSubresourceInfoKHR";
-      case StructureType::eSubresourceLayout2KHR: return "SubresourceLayout2KHR";
-      case StructureType::eImageSubresource2KHR: return "ImageSubresource2KHR";
       case StructureType::ePipelineCreateFlags2CreateInfoKHR: return "PipelineCreateFlags2CreateInfoKHR";
       case StructureType::eBufferUsageFlags2CreateInfoKHR: return "BufferUsageFlags2CreateInfoKHR";
       case StructureType::ePhysicalDeviceRayTracingPositionFetchFeaturesKHR: return "PhysicalDeviceRayTracingPositionFetchFeaturesKHR";
@@ -4482,8 +4491,6 @@ namespace VULKAN_HPP_NAMESPACE
       case StructureType::ePhysicalDeviceRayTracingInvocationReorderPropertiesNV: return "PhysicalDeviceRayTracingInvocationReorderPropertiesNV";
       case StructureType::ePhysicalDeviceExtendedSparseAddressSpaceFeaturesNV: return "PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV";
       case StructureType::ePhysicalDeviceExtendedSparseAddressSpacePropertiesNV: return "PhysicalDeviceExtendedSparseAddressSpacePropertiesNV";
-      case StructureType::ePhysicalDeviceMutableDescriptorTypeFeaturesEXT: return "PhysicalDeviceMutableDescriptorTypeFeaturesEXT";
-      case StructureType::eMutableDescriptorTypeCreateInfoEXT: return "MutableDescriptorTypeCreateInfoEXT";
       case StructureType::eLayerSettingsCreateInfoEXT: return "LayerSettingsCreateInfoEXT";
       case StructureType::ePhysicalDeviceShaderCoreBuiltinsFeaturesARM: return "PhysicalDeviceShaderCoreBuiltinsFeaturesARM";
       case StructureType::ePhysicalDeviceShaderCoreBuiltinsPropertiesARM: return "PhysicalDeviceShaderCoreBuiltinsPropertiesARM";
@@ -4522,8 +4529,6 @@ namespace VULKAN_HPP_NAMESPACE
       case StructureType::ePhysicalDeviceCubicClampFeaturesQCOM: return "PhysicalDeviceCubicClampFeaturesQCOM";
       case StructureType::ePhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT: return "PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT";
       case StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesKHR: return "PhysicalDeviceVertexAttributeDivisorPropertiesKHR";
-      case StructureType::ePipelineVertexInputDivisorStateCreateInfoKHR: return "PipelineVertexInputDivisorStateCreateInfoKHR";
-      case StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesKHR: return "PhysicalDeviceVertexAttributeDivisorFeaturesKHR";
       case StructureType::ePhysicalDeviceShaderFloatControls2FeaturesKHR: return "PhysicalDeviceShaderFloatControls2FeaturesKHR";
 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
       case StructureType::eScreenBufferPropertiesQNX: return "ScreenBufferPropertiesQNX";
@@ -4533,11 +4538,6 @@ namespace VULKAN_HPP_NAMESPACE
       case StructureType::ePhysicalDeviceExternalMemoryScreenBufferFeaturesQNX: return "PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX";
 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
       case StructureType::ePhysicalDeviceLayeredDriverPropertiesMSFT: return "PhysicalDeviceLayeredDriverPropertiesMSFT";
-      case StructureType::ePhysicalDeviceIndexTypeUint8FeaturesKHR: return "PhysicalDeviceIndexTypeUint8FeaturesKHR";
-      case StructureType::ePhysicalDeviceLineRasterizationFeaturesKHR: return "PhysicalDeviceLineRasterizationFeaturesKHR";
-      case StructureType::ePipelineRasterizationLineStateCreateInfoKHR: return "PipelineRasterizationLineStateCreateInfoKHR";
-      case StructureType::ePhysicalDeviceLineRasterizationPropertiesKHR: return "PhysicalDeviceLineRasterizationPropertiesKHR";
-      case StructureType::eCalibratedTimestampInfoKHR: return "CalibratedTimestampInfoKHR";
       case StructureType::ePhysicalDeviceShaderExpectAssumeFeaturesKHR: return "PhysicalDeviceShaderExpectAssumeFeaturesKHR";
       case StructureType::ePhysicalDeviceMaintenance6FeaturesKHR: return "PhysicalDeviceMaintenance6FeaturesKHR";
       case StructureType::ePhysicalDeviceMaintenance6PropertiesKHR: return "PhysicalDeviceMaintenance6PropertiesKHR";
@@ -4549,7 +4549,9 @@ namespace VULKAN_HPP_NAMESPACE
       case StructureType::eSetDescriptorBufferOffsetsInfoEXT: return "SetDescriptorBufferOffsetsInfoEXT";
       case StructureType::eBindDescriptorBufferEmbeddedSamplersInfoEXT: return "BindDescriptorBufferEmbeddedSamplersInfoEXT";
       case StructureType::ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV: return "PhysicalDeviceDescriptorPoolOverallocationFeaturesNV";
+      case StructureType::ePhysicalDeviceRawAccessChainsFeaturesNV: return "PhysicalDeviceRawAccessChainsFeaturesNV";
       case StructureType::ePhysicalDeviceShaderAtomicFloat16VectorFeaturesNV: return "PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV";
+      case StructureType::ePhysicalDeviceRayTracingValidationFeaturesNV: return "PhysicalDeviceRayTracingValidationFeaturesNV";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -4892,7 +4894,7 @@ namespace VULKAN_HPP_NAMESPACE
       case Format::ePvrtc14BppSrgbBlockIMG: return "Pvrtc14BppSrgbBlockIMG";
       case Format::ePvrtc22BppSrgbBlockIMG: return "Pvrtc22BppSrgbBlockIMG";
       case Format::ePvrtc24BppSrgbBlockIMG: return "Pvrtc24BppSrgbBlockIMG";
-      case Format::eR16G16S105NV: return "R16G16S105NV";
+      case Format::eR16G16Sfixed5NV: return "R16G16Sfixed5NV";
       case Format::eA1B5G5R5UnormPack16KHR: return "A1B5G5R5UnormPack16KHR";
       case Format::eA8UnormKHR: return "A8UnormKHR";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
@@ -4927,10 +4929,10 @@ namespace VULKAN_HPP_NAMESPACE
       case FormatFeatureFlagBits::eDisjoint: return "Disjoint";
       case FormatFeatureFlagBits::eCositedChromaSamples: return "CositedChromaSamples";
       case FormatFeatureFlagBits::eSampledImageFilterMinmax: return "SampledImageFilterMinmax";
+      case FormatFeatureFlagBits::eSampledImageFilterCubicEXT: return "SampledImageFilterCubicEXT";
       case FormatFeatureFlagBits::eVideoDecodeOutputKHR: return "VideoDecodeOutputKHR";
       case FormatFeatureFlagBits::eVideoDecodeDpbKHR: return "VideoDecodeDpbKHR";
       case FormatFeatureFlagBits::eAccelerationStructureVertexBufferKHR: return "AccelerationStructureVertexBufferKHR";
-      case FormatFeatureFlagBits::eSampledImageFilterCubicEXT: return "SampledImageFilterCubicEXT";
       case FormatFeatureFlagBits::eFragmentDensityMapEXT: return "FragmentDensityMapEXT";
       case FormatFeatureFlagBits::eFragmentShadingRateAttachmentKHR: return "FragmentShadingRateAttachmentKHR";
       case FormatFeatureFlagBits::eVideoEncodeInputKHR: return "VideoEncodeInputKHR";
@@ -5004,8 +5006,8 @@ namespace VULKAN_HPP_NAMESPACE
       case ImageUsageFlagBits::eVideoDecodeDstKHR: return "VideoDecodeDstKHR";
       case ImageUsageFlagBits::eVideoDecodeSrcKHR: return "VideoDecodeSrcKHR";
       case ImageUsageFlagBits::eVideoDecodeDpbKHR: return "VideoDecodeDpbKHR";
-      case ImageUsageFlagBits::eFragmentDensityMapEXT: return "FragmentDensityMapEXT";
       case ImageUsageFlagBits::eFragmentShadingRateAttachmentKHR: return "FragmentShadingRateAttachmentKHR";
+      case ImageUsageFlagBits::eFragmentDensityMapEXT: return "FragmentDensityMapEXT";
       case ImageUsageFlagBits::eHostTransferEXT: return "HostTransferEXT";
       case ImageUsageFlagBits::eVideoEncodeDstKHR: return "VideoEncodeDstKHR";
       case ImageUsageFlagBits::eVideoEncodeSrcKHR: return "VideoEncodeSrcKHR";
@@ -5160,11 +5162,11 @@ namespace VULKAN_HPP_NAMESPACE
       case PipelineStageFlagBits::eConditionalRenderingEXT: return "ConditionalRenderingEXT";
       case PipelineStageFlagBits::eAccelerationStructureBuildKHR: return "AccelerationStructureBuildKHR";
       case PipelineStageFlagBits::eRayTracingShaderKHR: return "RayTracingShaderKHR";
-      case PipelineStageFlagBits::eFragmentDensityProcessEXT: return "FragmentDensityProcessEXT";
       case PipelineStageFlagBits::eFragmentShadingRateAttachmentKHR: return "FragmentShadingRateAttachmentKHR";
-      case PipelineStageFlagBits::eCommandPreprocessNV: return "CommandPreprocessNV";
       case PipelineStageFlagBits::eTaskShaderEXT: return "TaskShaderEXT";
       case PipelineStageFlagBits::eMeshShaderEXT: return "MeshShaderEXT";
+      case PipelineStageFlagBits::eFragmentDensityProcessEXT: return "FragmentDensityProcessEXT";
+      case PipelineStageFlagBits::eCommandPreprocessNV: return "CommandPreprocessNV";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -5398,8 +5400,8 @@ namespace VULKAN_HPP_NAMESPACE
       case ImageLayout::eVideoDecodeSrcKHR: return "VideoDecodeSrcKHR";
       case ImageLayout::eVideoDecodeDpbKHR: return "VideoDecodeDpbKHR";
       case ImageLayout::eSharedPresentKHR: return "SharedPresentKHR";
-      case ImageLayout::eFragmentDensityMapOptimalEXT: return "FragmentDensityMapOptimalEXT";
       case ImageLayout::eFragmentShadingRateAttachmentOptimalKHR: return "FragmentShadingRateAttachmentOptimalKHR";
+      case ImageLayout::eFragmentDensityMapOptimalEXT: return "FragmentDensityMapOptimalEXT";
       case ImageLayout::eRenderingLocalReadKHR: return "RenderingLocalReadKHR";
       case ImageLayout::eVideoEncodeDstKHR: return "VideoEncodeDstKHR";
       case ImageLayout::eVideoEncodeSrcKHR: return "VideoEncodeSrcKHR";
@@ -5629,6 +5631,7 @@ namespace VULKAN_HPP_NAMESPACE
       case DynamicState::eExclusiveScissorEnableNV: return "ExclusiveScissorEnableNV";
       case DynamicState::eExclusiveScissorNV: return "ExclusiveScissorNV";
       case DynamicState::eFragmentShadingRateKHR: return "FragmentShadingRateKHR";
+      case DynamicState::eLineStippleKHR: return "LineStippleKHR";
       case DynamicState::eVertexInputEXT: return "VertexInputEXT";
       case DynamicState::ePatchControlPointsEXT: return "PatchControlPointsEXT";
       case DynamicState::eLogicOpEXT: return "LogicOpEXT";
@@ -5665,7 +5668,6 @@ namespace VULKAN_HPP_NAMESPACE
       case DynamicState::eRepresentativeFragmentTestEnableNV: return "RepresentativeFragmentTestEnableNV";
       case DynamicState::eCoverageReductionModeNV: return "CoverageReductionModeNV";
       case DynamicState::eAttachmentFeedbackLoopEnableEXT: return "AttachmentFeedbackLoopEnableEXT";
-      case DynamicState::eLineStippleKHR: return "LineStippleKHR";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -5985,8 +5987,8 @@ namespace VULKAN_HPP_NAMESPACE
       case DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR: return "PushDescriptorKHR";
       case DescriptorSetLayoutCreateFlagBits::eDescriptorBufferEXT: return "DescriptorBufferEXT";
       case DescriptorSetLayoutCreateFlagBits::eEmbeddedImmutableSamplersEXT: return "EmbeddedImmutableSamplersEXT";
-      case DescriptorSetLayoutCreateFlagBits::eIndirectBindableNV: return "IndirectBindableNV";
       case DescriptorSetLayoutCreateFlagBits::eHostOnlyPoolEXT: return "HostOnlyPoolEXT";
+      case DescriptorSetLayoutCreateFlagBits::eIndirectBindableNV: return "IndirectBindableNV";
       case DescriptorSetLayoutCreateFlagBits::ePerStageNV: return "PerStageNV";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
@@ -6010,9 +6012,9 @@ namespace VULKAN_HPP_NAMESPACE
       case DescriptorType::eInlineUniformBlock: return "InlineUniformBlock";
       case DescriptorType::eAccelerationStructureKHR: return "AccelerationStructureKHR";
       case DescriptorType::eAccelerationStructureNV: return "AccelerationStructureNV";
+      case DescriptorType::eMutableEXT: return "MutableEXT";
       case DescriptorType::eSampleWeightImageQCOM: return "SampleWeightImageQCOM";
       case DescriptorType::eBlockMatchImageQCOM: return "BlockMatchImageQCOM";
-      case DescriptorType::eMutableEXT: return "MutableEXT";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -6051,8 +6053,8 @@ namespace VULKAN_HPP_NAMESPACE
       case AccessFlagBits::eColorAttachmentReadNoncoherentEXT: return "ColorAttachmentReadNoncoherentEXT";
       case AccessFlagBits::eAccelerationStructureReadKHR: return "AccelerationStructureReadKHR";
       case AccessFlagBits::eAccelerationStructureWriteKHR: return "AccelerationStructureWriteKHR";
-      case AccessFlagBits::eFragmentDensityMapReadEXT: return "FragmentDensityMapReadEXT";
       case AccessFlagBits::eFragmentShadingRateAttachmentReadKHR: return "FragmentShadingRateAttachmentReadKHR";
+      case AccessFlagBits::eFragmentDensityMapReadEXT: return "FragmentDensityMapReadEXT";
       case AccessFlagBits::eCommandPreprocessReadNV: return "CommandPreprocessReadNV";
       case AccessFlagBits::eCommandPreprocessWriteNV: return "CommandPreprocessWriteNV";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
@@ -8247,7 +8249,7 @@ namespace VULKAN_HPP_NAMESPACE
     switch ( value )
     {
       case VideoEncodeCapabilityFlagBitsKHR::ePrecedingExternallyEncodedBytes: return "PrecedingExternallyEncodedBytes";
-      case VideoEncodeCapabilityFlagBitsKHR::eInsufficientstreamBufferRangeDetectionBit: return "InsufficientstreamBufferRangeDetectionBit";
+      case VideoEncodeCapabilityFlagBitsKHR::eInsufficientBitstreamBufferRangeDetection: return "InsufficientBitstreamBufferRangeDetection";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -8256,9 +8258,9 @@ namespace VULKAN_HPP_NAMESPACE
   {
     switch ( value )
     {
-      case VideoEncodeFeedbackFlagBitsKHR::estreamBufferOffsetBit: return "streamBufferOffsetBit";
-      case VideoEncodeFeedbackFlagBitsKHR::estreamBytesWrittenBit: return "streamBytesWrittenBit";
-      case VideoEncodeFeedbackFlagBitsKHR::estreamHasOverridesBit: return "streamHasOverridesBit";
+      case VideoEncodeFeedbackFlagBitsKHR::eBitstreamBufferOffset: return "BitstreamBufferOffset";
+      case VideoEncodeFeedbackFlagBitsKHR::eBitstreamBytesWritten: return "BitstreamBytesWritten";
+      case VideoEncodeFeedbackFlagBitsKHR::eBitstreamHasOverrides: return "BitstreamHasOverrides";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -8813,6 +8815,7 @@ namespace VULKAN_HPP_NAMESPACE
       case PipelineCreateFlagBits2KHR::eDisableOptimization: return "DisableOptimization";
       case PipelineCreateFlagBits2KHR::eAllowDerivatives: return "AllowDerivatives";
       case PipelineCreateFlagBits2KHR::eDerivative: return "Derivative";
+      case PipelineCreateFlagBits2KHR::eEnableLegacyDitheringEXT: return "EnableLegacyDitheringEXT";
       case PipelineCreateFlagBits2KHR::eViewIndexFromDeviceIndex: return "ViewIndexFromDeviceIndex";
       case PipelineCreateFlagBits2KHR::eDispatchBase: return "DispatchBase";
       case PipelineCreateFlagBits2KHR::eDeferCompileNV: return "DeferCompileNV";
@@ -8867,10 +8870,8 @@ namespace VULKAN_HPP_NAMESPACE
       case BufferUsageFlagBits2KHR::eTransformFeedbackCounterBufferEXT: return "TransformFeedbackCounterBufferEXT";
       case BufferUsageFlagBits2KHR::eVideoDecodeSrc: return "VideoDecodeSrc";
       case BufferUsageFlagBits2KHR::eVideoDecodeDst: return "VideoDecodeDst";
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
       case BufferUsageFlagBits2KHR::eVideoEncodeDst: return "VideoEncodeDst";
       case BufferUsageFlagBits2KHR::eVideoEncodeSrc: return "VideoEncodeSrc";
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
       case BufferUsageFlagBits2KHR::eShaderDeviceAddress: return "ShaderDeviceAddress";
       case BufferUsageFlagBits2KHR::eAccelerationStructureBuildInputReadOnly: return "AccelerationStructureBuildInputReadOnly";
       case BufferUsageFlagBits2KHR::eAccelerationStructureStorage: return "AccelerationStructureStorage";