wip: fix renderer

.clang-tidy

@@ -0,0 +1,248 @@
+---
+Checks: "-*,
+
+performance-unnecessary-value-param,
+performance-unnecessary-copy-initialization,
+performance-type-promotion-in-math-fn,
+performance-trivially-destructible,
+performance-noexcept-swap,
+performance-noexcept-move-constructor,
+performance-noexcept-destructor,
+performance-no-int-to-ptr,
+performance-no-automatic-move,
+performance-move-constructor-init,
+performance-move-const-arg,
+performance-inefficient-vector-operation,
+performance-inefficient-string-concatenation,
+performance-inefficient-algorithm,
+performance-implicit-conversion-in-loop,
+performance-for-range-copy,
+performance-faster-string-find,
+performance-enum-size,
+performance-avoid-endl,
+
+readability-avoid-const-params-in-decls,
+readability-avoid-nested-conditional-operator,
+readability-avoid-return-with-void-value,
+readability-avoid-unconditional-preprocessor-if,
+readability-braces-around-statements,
+readability-const-return-type,
+readability-container-contains,
+readability-container-data-pointdr,
+readability-container-size-empty,
+readability-delete-null-pointer,
+readability-duplicate-include,
+readability-else-after-return,
+readability-inconsistent-declaration-parameter-name,
+readability-isolate-declaration,
+readability-make-member-function-const,
+readability-misleading-indentation,
+readability-misplaced-array-index,
+readability-named-parameter,
+readability-non-const-parameter,
+readability-qualified-auto,
+readability-redundant-access-specifiers,
+readability-redundant-casting,
+readability-redundant-control-flow,
+readability-redundant-declaration,
+readability-redundant-function-ptr-dereference,
+readability-redundant-inline-specifier,
+readability-redundant-member-init,
+readability-redundant-preprocessor,
+readability-redundant-smartptr-get,
+readability-redundant-string-cstr,
+readability-reference-to-constructed-temporary,
+readability-simplify-boolean-expr,
+readability-simplify-subscript-expr,
+readability-static-accessed-through-instance,
+readability-static-definition-in-anonymous-namespace,
+readability-string-compare,
+readability-suspicious-call-argument,
+readability-uniqueptr-delete-release,
+readability-use-anyofallof
+readability-use-std-min-max,
+readability-function-cognitive-complexity
+readability-function-size
+readability-identifier-naming
+readability-identifier-length
+readability-magic-numbers
+
+modernize-avoid-bind,
+modernize-avoid-c-arrays,
+modernize-concat-nested-namespaces,
+modernize-deprecated-headers,
+modernize-deprecated-ios-base-aliases,
+modernize-loop-convert,
+modernize-macro-to-enum,
+modernize-make-shared,
+modernize-make-unique,
+modernize-pass-by-value,
+modernize-raw-string-literal,
+modernize-redundant-void-arg,
+modernize-replace-auto-ptr,
+modernize-replace-disallow-copy-and-assign-macro,
+modernize-replace-random-shuffle,
+modernize-return-braced-init-list,
+modernize-shrink-to-fit,
+modernize-type-traits,
+modernize-unary-static-assert,
+modernize-use-auto,
+modernize-use-bool-literals,
+modernize-use-constraints,
+modernize-use-default-member-init,
+modernize-use-designated-initializers,
+modernize-use-emplace,
+modernize-use-equals-default,
+modernize-use-equals-delete,
+modernize-use-nodiscard,
+modernize-use-noexcept,
+modernize-use-nullptr,
+modernize-use-override,
+modernize-use-starts-ends-with,
+modernize-use-std-numbers,
+modernize-use-std-print,
+modernize-use-transparent-functors,
+modernize-use-uncaught-exceptions,
+modernize-use-using
+modernize-min-max-use-initializer-list,
+
+cppcoreguidelines-avoid-capturing-lambda-coroutines,
+cppcoreguidelines-avoid-const-or-ref-data-members,
+cppcoreguidelines-avoid-do-while,
+cppcoreguidelines-avoid-goto,
+cppcoreguidelines-avoid-non-const-global-variables,
+cppcoreguidelines-avoid-reference-coroutine-parameters,
+cppcoreguidelines-init-variables,
+cppcoreguidelines-interfaces-global-init,
+cppcoreguidelines-macro-usage,
+cppcoreguidelines-misleading-capture-default-by-value,
+cppcoreguidelines-missing-std-forward,
+cppcoreguidelines-narrowing-conversions,
+cppcoreguidelines-no-malloc,
+cppcoreguidelines-no-suspend-with-lock,
+cppcoreguidelines-owning-memory,
+cppcoreguidelines-prefer-member-initializer,
+cppcoreguidelines-pro-bounds-array-to-pointer-decay,
+cppcoreguidelines-pro-bounds-pointer-arithmetic,
+cppcoreguidelines-pro-type-const-cast,
+cppcoreguidelines-pro-type-cstyle-cast,
+cppcoreguidelines-pro-type-member-init,
+cppcoreguidelines-pro-type-reinterpret-cast,
+cppcoreguidelines-pro-type-static-cast-downcast,
+cppcoreguidelines-pro-type-vararg,
+cppcoreguidelines-rvalue-reference-param-not-moved,
+cppcoreguidelines-slicing,
+cppcoreguidelines-special-member-functions,
+cppcoreguidelines-virtual-class-destructor,
+
+bugprone-argument-comment,
+bugprone-assert-side-effect,
+bugprone-assignment-in-if-condition,
+bugprone-bad-signal-to-kill-thread,
+bugprone-bool-pointer-implicit-conversion,
+bugprone-branch-clone,
+bugprone-casting-through-void,
+bugprone-chained-comparison,
+bugprone-compare-pointer-to-member-virtual-function,
+bugprone-copy-constructor-init,
+bugprone-crtp-constructor-accessibility,
+bugprone-dangling-handle,
+bugprone-empty-catch,
+bugprone-exception-escape,
+bugprone-fold-init-type,
+bugprone-forward-declaration-namespace,
+bugprone-forwarding-reference-overload,
+bugprone-implicit-widening-of-multiplication-result,
+bugprone-inaccurate-erase,
+bugprone-inc-dec-in-conditions,
+bugprone-incorrect-enable-if,
+bugprone-incorrect-roundings,
+bugprone-infinite-loop,
+bugprone-integer-division,
+bugprone-lambda-function-name,
+bugprone-macro-parentheses,
+bugprone-macro-repeated-side-effects,
+bugprone-misplaced-operator-in-strlen-in-alloc,
+bugprone-misplaced-pointer-arithmetic-in-alloc,
+bugprone-misplaced-widening-cast,
+bugprone-move-forwarding-reference,
+bugprone-multi-level-implicit-pointer-conversion,
+bugprone-multiple-new-in-one-expression,
+bugprone-multiple-statement-macro,
+bugprone-no-escape,
+bugprone-non-zero-enum-to-bool-conversion,
+bugprone-not-null-terminated-result,
+bugprone-optional-value-conversion,
+bugprone-parent-virtual-call,
+bugprone-posix-return,
+bugprone-redundant-branch-condition,
+bugprone-reserved-identifier,
+bugprone-return-const-ref-from-parameter,
+bugprone-shared-ptr-array-mismatch,
+bugprone-signal-handler,
+bugprone-signed-char-misuse,
+bugprone-sizeof-container,
+bugprone-sizeof-expression,
+bugprone-spuriously-wake-up-functions,
+bugprone-standalone-empty,
+bugprone-string-constructor,
+bugprone-string-integer-assignment,
+bugprone-string-literal-with-embedded-nul,
+bugprone-stringview-nullptr,
+bugprone-suspicious-enum-usage,
+bugprone-suspicious-include,
+bugprone-suspicious-memory-comparison,
+bugprone-suspicious-memset-usage,
+bugprone-suspicious-missing-comma,
+bugprone-suspicious-realloc-usage,
+bugprone-suspicious-semicolon,
+bugprone-suspicious-string-compare,
+bugprone-suspicious-stringview-data-usage,
+bugprone-swapped-arguments,
+bugprone-switch-missing-default-case,
+bugprone-terminating-continue,
+bugprone-throw-keyword-missing,
+bugprone-too-small-loop-variable,
+bugprone-unchecked-optional-access,
+bugprone-undefined-memory-manipulation,
+bugprone-undelegated-constructor,
+bugprone-unhandled-exception-at-new,
+bugprone-unhandled-self-assignment,
+bugprone-unique-ptr-array-mismatch,
+bugprone-unsafe-functions,
+bugprone-unused-local-non-trivial-variable,
+bugprone-unused-raii,
+bugprone-unused-return-value,
+bugprone-use-after-move,
+bugprone-virtual-near-miss,
+
+concurrency-mt-unsafe,
+concurrency-thread-canceltype-asynchronous,
+
+misc-use-anonymous-namespace,
+misc-unused-using-decls,
+misc-unused-parameters,
+misc-unused-alias-decls,
+misc-uniqueptr-reset-release,
+misc-unconventional-assign-operator,
+misc-throw-by-value-catch-by-reference,
+misc-static-assert,
+misc-redundant-expression,
+misc-non-private-member-variables-in-classes,
+misc-non-copyable-objects,
+misc-no-recursion,
+misc-new-delete-overloads,
+misc-misplaced-const,
+misc-misleading-identifier,
+misc-misleading-bidirectional,
+misc-header-include-cycle,
+misc-definitions-in-headers,
+misc-coroutine-hostile-raii,
+misc-const-correctness,
+
+hicpp-signed-bitwise,
+hicpp-no-assembler,
+hicpp-multiway-paths-covered,
+hicpp-ignored-remove-result,
+hicpp-exception-baseclass,
+"

modules/renderer/_tests/buffer.cpp

@@ -1,21 +1,21 @@
-#include <renderer/frontend/data/buffer.hpp>
+import renderer.frontend;
-#include <renderer/test/utils.hpp>
+import renderer.test_utils;
 
-using ::lt::renderer::IBuffer;
+using enum ::lt::renderer::IDebugger::MessageSeverity;
-using enum ::lt::renderer::IMessenger::MessageSeverity;
+using enum ::lt::renderer::IBuffer::Usage;
 
 Suite raii = "buffer_raii"_suite = [] {
 	Case { "happy path won't throw" } = [] {
 		auto fixture = FixtureDeviceSwapchain {};
 
-		for (auto idx = 0; idx <= std::to_underlying(IBuffer::Usage::staging); ++idx)
+		for (auto idx = 0; idx <= std::to_underlying(staging); ++idx)
 		{
-			ignore = IBuffer::create(
+			ignore = lt::renderer::create_buffer(
 			    lt::renderer::Api::vulkan,
 			    fixture.device(),
 			    fixture.gpu(),
-			    IBuffer::CreateInfo {
+			    lt::renderer::IBuffer::CreateInfo {
-			        .usage = static_cast<IBuffer::Usage>(idx),
+			        .usage = static_cast<lt::renderer::IBuffer::Usage>(idx),
 			        .size = 1000u,
 			        .debug_name = "",
 			    }
@@ -29,23 +29,28 @@ Suite raii = "buffer_raii"_suite = [] {
 	Case { "unhappy path throws" } = [] {
 		auto fixture = FixtureDeviceSwapchain {};
 
-		auto info = IBuffer::CreateInfo {
+		auto info = lt::renderer::IBuffer::CreateInfo {
-			.usage = IBuffer::Usage::vertex,
+			.usage = vertex,
 			.size = 10000u,
 			.debug_name = "",
 		};
 
 		expect_throw([&] {
-			ignore = IBuffer::create(lt::renderer::Api::vulkan, nullptr, fixture.gpu(), info);
+			ignore = lt::renderer::create_buffer(
+			    lt::renderer::Api::vulkan,
+			    nullptr,
+			    fixture.gpu(),
+			    info
+			);
 		});
 
 		expect_throw([&] {
-			ignore = IBuffer::create(lt::renderer::Api::vulkan, fixture.device(), nullptr, info);
+			ignore = lt::renderer::create_buffer(lt::renderer::Api::vulkan, fixture.device(), nullptr, info);
 		});
 
 		expect_throw([&, info] mutable {
 			info.size = 0;
-			ignore = IBuffer::create(
+			ignore = lt::renderer::create_buffer(
 			    lt::renderer::Api::vulkan,
 			    fixture.device(),
 			    fixture.gpu(),
@@ -54,7 +59,7 @@ Suite raii = "buffer_raii"_suite = [] {
 		});
 
 		expect_throw([&] {
-			ignore = IBuffer::create(
+			ignore = lt::renderer::create_buffer(
 			    lt::renderer::Api::direct_x,
 			    fixture.device(),
 			    fixture.gpu(),
@@ -63,7 +68,7 @@ Suite raii = "buffer_raii"_suite = [] {
 		});
 
 		expect_throw([&] {
-			ignore = IBuffer::create(
+			ignore = lt::renderer::create_buffer(
 			    lt::renderer::Api::metal,
 			    fixture.device(),
 			    fixture.gpu(),
@@ -72,7 +77,7 @@ Suite raii = "buffer_raii"_suite = [] {
 		});
 
 		expect_throw([&] {
-			ignore = IBuffer::create(
+			ignore = lt::renderer::create_buffer(
 			    lt::renderer::Api::none,
 			    fixture.device(),
 			    fixture.gpu(),
@@ -81,7 +86,7 @@ Suite raii = "buffer_raii"_suite = [] {
 		});
 
 		/** Make sure the default-case was OK */
-		ignore = IBuffer::create(lt::renderer::Api::vulkan, fixture.device(), fixture.gpu(), info);
+		ignore = lt::renderer::create_buffer(lt::renderer::Api::vulkan, fixture.device(), fixture.gpu(), info);
 
 		expect_false(fixture.has_any_messages_of(error));
 		expect_false(fixture.has_any_messages_of(warning));
@@ -94,12 +99,12 @@ Suite mapping = "buffer_mapping"_suite = [] {
 
 		constexpr auto size = 1000u;
 
-		auto buffer = IBuffer::create(
+		auto buffer = lt::renderer::create_buffer(
 		    lt::renderer::Api::vulkan,
 		    fixture.device(),
 		    fixture.gpu(),
-		    IBuffer::CreateInfo {
+		    lt::renderer::IBuffer::CreateInfo {
-		        .usage = IBuffer::Usage::staging,
+		        .usage = staging,
 		        .size = size,
 		        .debug_name = "",
 		    }

modules/renderer/_tests/utils.cppm

@@ -2,16 +2,25 @@ export module renderer.test_utils;
 
 export import logger;
 export import surface.system;
+export import ecs.registry;
+export import renderer.factory;
 export import test.test;
 export import test.expects;
 export import memory.reference;
 export import renderer.frontend;
+export import renderer.system;
+export import math.vec2;
+export import math.vec3;
+export import math.vec4;
+export import math.mat4;
+export import std;
 
 export using ::lt::test::Case;
 export using ::lt::test::expect_eq;
 export using ::lt::test::expect_false;
 export using ::lt::test::expect_not_nullptr;
 export using ::lt::test::expect_throw;
+export using ::lt::test::operator""_suite;
 export using ::lt::test::expect_true;
 export using ::lt::test::Suite;
 export using ::std::ignore;
@@ -20,15 +29,15 @@ export namespace constants {
 
 constexpr auto api = lt::renderer::Api::vulkan;
 constexpr auto resolution = lt::math::uvec2 { 800u, 600u };
-constexpr auto frames_in_flight = uint32_t { 3u };
+constexpr auto frames_in_flight = std::uint32_t { 3u };
 
 } // namespace constants
 
 
 void noop_messenger_callback(
-    lt::renderer::IMessenger::MessageSeverity severity,
+    lt::renderer::IDebugger::MessageSeverity severity,
-    lt::renderer::IMessenger::MessageType type,
+    lt::renderer::IDebugger::MessageType type,
-    const lt::renderer::IMessenger::MessageData &data,
+    const lt::renderer::IDebugger::MessageData &data,
     std::any &user_data
 )
 {
@@ -58,8 +67,8 @@ public:
                 .registry = registry(),
 		        .surface_entity = surface_entity(),
                 .debug_callback_info = {
-                    .severities = lt::renderer::IMessenger::MessageSeverity::all,
+                    .severities = lt::renderer::IDebugger::MessageSeverity::all,
-                    .types= lt::renderer::IMessenger::MessageType::all,
+                    .types= lt::renderer::IDebugger::MessageType::all,
                     .callback = noop_messenger_callback,
                     .user_data = {},
                 }
@@ -105,14 +114,14 @@ public:
 	}
 
 private:
-	lt::memory::Scope<lt::renderer::ISurface> m_surface { lt::renderer::ISurface::create(
+	lt::memory::Scope<lt::renderer::ISurface> m_surface { lt::renderer::create_surface(
 		constants::api,
-		lt::renderer::IInstance::get(constants::api),
+		lt::renderer::get_instance(constants::api),
 		surface_entity()
 	) };
 
 	lt::memory::Scope<lt::renderer::IGpu> m_gpu {
-		lt::renderer::IGpu::create(constants::api, lt::renderer::IInstance::get(constants::api))
+		lt::renderer::create_gpu(constants::api, lt::renderer::get_instance(constants::api))
 	};
 };
 
@@ -134,7 +143,7 @@ public:
 	void recreate_swapchain()
 	{
 		m_swapchain.reset();
-		m_swapchain = lt::renderer::ISwapchain::create(
+		m_swapchain = lt::renderer::create_swapchain(
 		    constants::api,
 		    surface(),
 		    gpu(),
@@ -147,24 +156,23 @@ public:
 		return m_user_data->m_has_any_messages;
 	}
 
-	[[nodiscard]] auto has_any_messages_of(
+	[[nodiscard]] auto has_any_messages_of(lt::renderer::IDebugger ::MessageSeverity severity) const
-	    lt::renderer::IMessenger ::MessageSeverity severity
+	    -> std::uint32_t
-	) const -> uint32_t
 	{
 		return m_user_data->m_severity_counter.contains(severity);
 	}
 
 private:
 	static void messenger_callback(
-	    lt::renderer::IMessenger::MessageSeverity severity,
+	    lt::renderer::IDebugger::MessageSeverity severity,
-	    lt::renderer::IMessenger::MessageType type,
+	    lt::renderer::IDebugger::MessageType type,
-	    const lt::renderer::IMessenger::MessageData &data,
+	    const lt::renderer::IDebugger::MessageData &data,
 	    std::any &user_data
 	)
 	{
 		// I know this makes the tests too verbose...
 		// but makes it easier to figure out what the problem is when things fail on ci
-		lt::log::trace("vulkan: {}", data.message);
+		lt::log::error("vulkan: {}", data.message);
 		std::ignore = data;
 		std::ignore = type;
 
@@ -175,30 +183,31 @@ private:
 
 	struct UserData
 	{
-		std::unordered_map<lt::renderer::IMessenger::MessageSeverity, uint32_t> m_severity_counter;
+		std::unordered_map<lt::renderer::IDebugger::MessageSeverity, std::uint32_t>
+		    m_severity_counter;
 
 		bool m_has_any_messages {};
 	};
 
 	lt::memory::Scope<UserData> m_user_data = lt::memory::create_scope<UserData>();
 
-	lt::memory::Scope<lt::renderer::IMessenger> m_messenger = lt::renderer::IMessenger::create(
+	lt::memory::Scope<lt::renderer::IDebugger> m_messenger = lt::renderer::create_debugger(
 	    constants::api,
-	    lt::renderer::IInstance::get(constants::api),
+	    lt::renderer::get_instance(constants::api),
-	    lt::renderer::IMessenger ::CreateInfo {
+	    lt::renderer::IDebugger ::CreateInfo {
-	        .severities = lt::renderer::IMessenger ::MessageSeverity::all,
+	        .severities = lt::renderer::IDebugger::MessageSeverity::all,
-	        .types = lt::renderer::IMessenger ::MessageType::all,
+	        .types = lt::renderer::IDebugger::MessageType::all,
 	        .callback = &messenger_callback,
 	        .user_data = m_user_data.get(),
 	    }
 	);
 
 	lt::memory::Scope<lt::renderer::IDevice> m_device {
-		lt::renderer::IDevice::create(constants::api, gpu(), surface())
+		lt::renderer::create_device(constants::api, gpu(), surface())
 	};
 
 	lt::memory::Scope<lt::renderer::ISwapchain> m_swapchain {
-		lt::renderer::ISwapchain::create(constants::api, surface(), gpu(), m_device.get())
+		lt::renderer::create_swapchain(constants::api, surface(), gpu(), m_device.get())
 	};
 };
 
@@ -217,18 +226,17 @@ public:
 		return m_user_data->m_has_any_messages;
 	}
 
-	[[nodiscard]] auto has_any_messages_of(
+	[[nodiscard]] auto has_any_messages_of(lt::renderer::IDebugger ::MessageSeverity severity) const
-	    lt::renderer::IMessenger ::MessageSeverity severity
+	    -> std::uint32_t
-	) const -> uint32_t
 	{
 		return m_user_data->m_severity_counter.contains(severity);
 	}
 
 private:
 	static void messenger_callback(
-	    lt::renderer::IMessenger::MessageSeverity severity,
+	    lt::renderer::IDebugger::MessageSeverity severity,
-	    lt::renderer::IMessenger::MessageType type,
+	    lt::renderer::IDebugger::MessageType type,
-	    const lt::renderer::IMessenger::MessageData &data,
+	    const lt::renderer::IDebugger::MessageData &data,
 	    std::any &user_data
 	)
 	{
@@ -246,7 +254,8 @@ private:
 
 	struct UserData
 	{
-		std::unordered_map<lt::renderer::IMessenger::MessageSeverity, uint32_t> m_severity_counter;
+		std::unordered_map<lt::renderer::IDebugger::MessageSeverity, std::uint32_t>
+		    m_severity_counter;
 
 		bool m_has_any_messages {};
 	};
@@ -260,9 +269,9 @@ private:
         },
 		.registry = registry(),
 		.surface_entity = surface_entity(),
-        .debug_callback_info = lt::renderer::IMessenger ::CreateInfo {
+        .debug_callback_info = lt::renderer::IDebugger ::CreateInfo {
-		        .severities = lt::renderer::IMessenger ::MessageSeverity::all,
+		        .severities = lt::renderer::IDebugger ::MessageSeverity::all,
-		        .types = lt::renderer::IMessenger ::MessageType::all,
+		        .types = lt::renderer::IDebugger ::MessageType::all,
 		        .callback = &messenger_callback,
 		        .user_data = m_user_data.get(),
         }

modules/renderer/factory.cppm

@@ -51,6 +51,13 @@ export namespace lt::renderer {
     std::uint32_t max_frames_in_flight
 ) -> memory::Scope<IRenderer>;
 
+[[nodiscard]] auto create_buffer(
+    Api target_api,
+    IDevice *device,
+    IGpu *gpu,
+    const IBuffer::CreateInfo &info
+) -> memory::Scope<IBuffer>;
+
 } // namespace lt::renderer
 
 module :private;
@@ -71,7 +78,7 @@ namespace lt::renderer {
 
 [[nodiscard]] auto create_surface(
     Api target_api,
-    class IInstance *instance,
+    IInstance *instance,
     const lt::ecs::Entity &surface_entity
 ) -> memory::Scope<ISurface>
 {
@@ -134,8 +141,8 @@ namespace lt::renderer {
 
 [[nodiscard]] auto create_buffer(
     Api target_api,
-    class IDevice *device,
+    IDevice *device,
-    class IGpu *gpu,
+    IGpu *gpu,
     const IBuffer::CreateInfo &info
 ) -> memory::Scope<IBuffer>
 {

modules/renderer/vk/api_wrapper.cppm

@@ -43,6 +43,7 @@ import math.vec3;
 import math.vec2;
 import debug.assertions;
 import std;
+import logger;
 
 template<class... Ts>
 struct overloads: Ts...
@@ -81,6 +82,9 @@ constexpr auto validation = "VK_LAYER_KHRONOS_validation";
 namespace instance_extension_names {
 
 constexpr auto debug_utils = VK_EXT_DEBUG_UTILS_EXTENSION_NAME;
+constexpr auto physical_device_properties_2
+    = VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME;
+
 constexpr auto surface = VK_KHR_SURFACE_EXTENSION_NAME;
 #if defined(LIGHT_PLATFORM_LINUX)
 constexpr auto platform_surface = VK_KHR_XLIB_SURFACE_EXTENSION_NAME;
@@ -90,8 +94,6 @@ constexpr auto platform_surface = VK_KHR_WIN32_SURFACE_EXTENSION_NAME;
 #else
 	#error "Unsupported platform"
 #endif
-constexpr auto physical_device_properties_2
-    = VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME;
 
 } // namespace instance_extension_names
 
@@ -100,6 +102,10 @@ namespace device_extension_names {
 constexpr auto swapchain = VK_KHR_SWAPCHAIN_EXTENSION_NAME;
 constexpr auto dynamic_rendering = VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME;
 constexpr auto descriptor_indexing = VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME;
+constexpr auto depth_stencil_resolve = VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME;
+constexpr auto maintenance_3 = VK_KHR_MAINTENANCE3_EXTENSION_NAME;
+constexpr auto create_renderpass2=  VK_KHR_CREATE_RENDERPASS2_EXTENSION_NAME
+
 
 }; // namespace device_extension_names
 
@@ -1278,8 +1284,10 @@ public:
 	/** de-allocation functions */
 	void free_memory(VkDeviceMemory memory) const;
 
-	void free_descriptor_set(VkDescriptorPool descriptor_pool, VkDescriptorSet descriptor_set)
+	void free_descriptor_set(
-	    const;
+	    VkDescriptorPool descriptor_pool,
+	    VkDescriptorSet descriptor_set
+	) const;
 
 	/** destroy functions */
 	void destroy_swapchain(VkSwapchainKHR swapchain) const;
@@ -2542,6 +2550,10 @@ public:
 private:
 	memory::NullOnMove<VkInstance> m_instance {};
 
+	Callback m_user_callback;
+
+	void *m_user_data {};
+
 	VkDebugUtilsMessengerEXT m_messenger {};
 };
 
@@ -2925,22 +2937,55 @@ Instance::Instance(CreateInfo info)
 	auto layer_settings = std::vector<VkLayerSettingEXT> {};
 	auto layer_names = std::vector<const char *> {};
 	auto extension_names = std::vector<const char *> {};
+	for (auto &extension : info.extensions)
+	{
+		extension_names.emplace_back(extension.c_str());
+	}
 
 	for (const auto &layer : info.layers)
 	{
 		layer_names.emplace_back(layer.name.c_str());
 		for (const auto &setting : layer.settings)
 		{
-			layer_settings.emplace_back(VkLayerSettingEXT {
+			const auto *values = (void *) { nullptr };
-			    .pLayerName = layer.name.c_str(),
+
-			    .pSettingName = setting.name.c_str(),
+			if (setting.values.index() == 0)
-			    .type = std::visit(layer_setting_type_visitor, setting.values),
+			{
-			    .valueCount = 1u,
+				values = std::bit_cast<const void *>(std::get<0>(setting.values).data());
-			    .pValues = std::visit(layer_setting_value_visitor, setting.values),
+			}
-			});
+			else if (setting.values.index() == 1)
+			{
+				values = std::bit_cast<const void *>(&std::get<1>(setting.values));
+			}
+			else if (setting.values.index() == 2)
+			{
+				values = std::bit_cast<const void *>(&std::get<2>(setting.values));
+			}
+
+			debug::ensure(values, "Failed to get variant from setting.values");
+
+			layer_settings.emplace_back(
+			    VkLayerSettingEXT {
+			        .pLayerName = layer.name.c_str(),
+			        .pSettingName = setting.name.c_str(),
+			        .type = std::visit(layer_setting_type_visitor, setting.values),
+			        .valueCount = 1u,
+			        .pValues = values,
+			    }
+			);
 		}
 	}
 
+	log::debug("Settings size: {}", layer_settings.size());
+	log::debug("Settings:");
+	for (auto &setting : layer_settings)
+	{
+		log::debug("\tpValues: {}", (std::size_t)setting.pValues);
+		log::debug("\tname: {}", setting.pSettingName);
+		log::debug("\tlayer name: {}", setting.pLayerName);
+		log::debug("\ttype: {}", std::to_underlying(setting.type));
+		log::debug("\tvalue count: {}", setting.valueCount);
+	}
 	const auto layer_settings_create_info = VkLayerSettingsCreateInfoEXT {
 		.sType = VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT,
 		.settingCount = static_cast<uint32_t>(layer_settings.size()),
@@ -2953,10 +2998,17 @@ Instance::Instance(CreateInfo info)
 		.flags = {},
 		.enabledLayerCount = static_cast<uint32_t>(info.layers.size()),
 		.ppEnabledLayerNames = layer_names.data(),
-		.enabledExtensionCount = static_cast<uint32_t>(info.extensions.size()),
+		.enabledExtensionCount = static_cast<uint32_t>(extension_names.size()),
 		.ppEnabledExtensionNames = extension_names.data(),
 	};
 
+	log::debug("Extension names:");
+	for (auto &extension_name : extension_names)
+	{
+		log::debug("\t{}", extension_name);
+	}
+
+	log::debug("Create instance: {}", (std::size_t)(api::create_instance));
 	vkc(api::create_instance(&vk_info, nullptr, &m_instance));
 	debug::ensure(m_instance, "Failed to create vulkan instance");
 }
@@ -3096,6 +3148,7 @@ Surface::~Surface()
 	};
 
 	api::get_physical_device_features(m_physical_device, &features_2);
+	log::debug("Dynamic rendering features: {}", features.dynamicRendering);
 	return DynamicRenderingFeatures {
 		.enabled = !!features.dynamicRendering,
 	};
@@ -3116,26 +3169,26 @@ Surface::~Surface()
 	api::get_physical_device_features(m_physical_device, &features_2);
 	return DescriptorIndexingFeatures {
 		// clang-format off
-		.shader_input_attachment_array_dynamic_indexing = features.shaderInputAttachmentArrayDynamicIndexing,
+		.shader_input_attachment_array_dynamic_indexing =false,
-		.shader_uniform_texel_buffer_array_dynamic_indexing = features.shaderUniformTexelBufferArrayDynamicIndexing,
+		.shader_uniform_texel_buffer_array_dynamic_indexing =false,
-		.shader_storage_texel_buffer_array_dynamic_indexing = features.shaderStorageTexelBufferArrayDynamicIndexing,
+		.shader_storage_texel_buffer_array_dynamic_indexing =false,
-		.shader_uniform_buffer_array_non_uniform_indexing = features.shaderUniformBufferArrayNonUniformIndexing,
+		.shader_uniform_buffer_array_non_uniform_indexing =false,
-		.shader_sampled_image_array_non_uniform_indexing = features.shaderSampledImageArrayNonUniformIndexing,
+		.shader_sampled_image_array_non_uniform_indexing =false,
-		.shader_storage_buffer_array_non_uniform_indexing = features.shaderStorageBufferArrayNonUniformIndexing,
+		.shader_storage_buffer_array_non_uniform_indexing =false,
-		.shader_storage_image_array_non_uniform_indexing = features.shaderStorageImageArrayNonUniformIndexing,
+		.shader_storage_image_array_non_uniform_indexing =false,
-		.shader_input_attachment_array_non_uniform_indexing = features.shaderInputAttachmentArrayNonUniformIndexing,
+		.shader_input_attachment_array_non_uniform_indexing =false,
-		.shader_uniform_texel_buffer_array_non_uniform_indexing = features.shaderUniformTexelBufferArrayNonUniformIndexing,
+		.shader_uniform_texel_buffer_array_non_uniform_indexing =false,
-		.shader_storage_texel_buffer_array_non_uniform_indexing = features.shaderStorageTexelBufferArrayNonUniformIndexing,
+		.shader_storage_texel_buffer_array_non_uniform_indexing =false,
-		.descriptor_binding_uniform_buffer_update_after_bind = features.descriptorBindingUniformBufferUpdateAfterBind,
+		.descriptor_binding_uniform_buffer_update_after_bind =false,
-		.descriptor_binding_sampled_image_update_after_bind = features.descriptorBindingSampledImageUpdateAfterBind,
+		.descriptor_binding_sampled_image_update_after_bind =false,
-		.descriptor_binding_storage_image_update_after_bind = features.descriptorBindingStorageImageUpdateAfterBind,
+		.descriptor_binding_storage_image_update_after_bind =false,
-		.descriptor_binding_storage_buffer_update_after_bind = features.descriptorBindingStorageBufferUpdateAfterBind,
+		.descriptor_binding_storage_buffer_update_after_bind =false,
-		.descriptor_binding_uniform_texel_buffer_update_after_bind = features.descriptorBindingUniformTexelBufferUpdateAfterBind,
+		.descriptor_binding_uniform_texel_buffer_update_after_bind =false,
-		.descriptor_binding_storage_texel_buffer_update_after_bind = features.descriptorBindingStorageTexelBufferUpdateAfterBind,
+		.descriptor_binding_storage_texel_buffer_update_after_bind =false,
-		.descriptor_binding_update_unused_while_pending = features.descriptorBindingUpdateUnusedWhilePending,
+		.descriptor_binding_update_unused_while_pending =false,
-		.descriptor_binding_partially_bound = features.descriptorBindingPartiallyBound, 
+		.descriptor_binding_partially_bound =false, 
-        .descriptor_binding_variable_descriptor_count = features.descriptorBindingVariableDescriptorCount,
+        .descriptor_binding_variable_descriptor_count =false,
-        .runtime_descriptor_array = features.runtimeDescriptorArray,
+        .runtime_descriptor_array =false,
 		// clang-format on
 	};
 }
@@ -3413,10 +3466,12 @@ Surface::~Surface()
 	auto formats = std::vector<Surface::Format> {};
 	for (auto &vk_format : vk_formats)
 	{
-		formats.emplace_back(Surface::Format {
+		formats.emplace_back(
-		    .format = static_cast<Format>(vk_format.format),
+		    Surface::Format {
-		    .color_space = static_cast<ColorSpace>(vk_format.colorSpace),
+		        .format = static_cast<Format>(vk_format.format),
-		});
+		        .color_space = static_cast<ColorSpace>(vk_format.colorSpace),
+		    }
+		);
 	}
 
 	return formats;
@@ -3473,15 +3528,17 @@ Device::Device(const Gpu &gpu, CreateInfo info)
 	auto vk_queue_infos = std::vector<VkDeviceQueueCreateInfo> {};
 	for (auto queue_family : info.queue_indices)
 	{
-		vk_queue_infos.emplace_back(VkDeviceQueueCreateInfo {
+		vk_queue_infos.emplace_back(
-		    .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
+		    VkDeviceQueueCreateInfo {
-		    .queueFamilyIndex = queue_family,
+		        .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
-		    .queueCount = 1u,
+		        .queueFamilyIndex = queue_family,
-		    .pQueuePriorities = &priorities,
+		        .queueCount = 1u,
-		});
+		        .pQueuePriorities = &priorities,
+		    }
+		);
 	}
 
-	auto vk_extension_names = std::vector<const char *>(info.extensions.size());
+	auto vk_extension_names = std::vector<const char *> {};
 	for (const auto &extension : info.extensions)
 	{
 		vk_extension_names.emplace_back(extension.c_str());
@@ -3562,11 +3619,12 @@ Device::Device(const Gpu &gpu, CreateInfo info)
 		vk_dynamic_rendering_features = VkPhysicalDeviceDynamicRenderingFeatures {
 			.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES,
 			.pNext = {},
-			.dynamicRendering = (*info.dynamic_rendering_features).enabled,
+			.dynamicRendering = true,
 		};
+		log::debug("Dynamic rendering: {}", vk_dynamic_rendering_features.dynamicRendering);
 
-		*last_p_next = &vk_descriptor_indexing_features;
+		*last_p_next = &vk_dynamic_rendering_features;
-		last_p_next = &vk_descriptor_indexing_features.pNext;
+		// last_p_next = &vk_dynamic_rendering_features.pNext;
 	}
 
 	if (info.descriptor_indexing_features)
@@ -3599,18 +3657,22 @@ Device::Device(const Gpu &gpu, CreateInfo info)
 			// clang-format on
 		};
 
-		*last_p_next = &vk_descriptor_indexing_features;
+		// *last_p_next = &vk_descriptor_indexing_features;
-		last_p_next = &vk_descriptor_indexing_features.pNext;
+		// last_p_next = &vk_descriptor_indexing_features.pNext;
+	}
+	for (auto name : vk_extension_names)
+	{
+		log::debug("Extension name: {}", name);
 	}
 
 	auto vk_info = VkDeviceCreateInfo {
 		.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
-		.pNext = &vk_features_2,
+		.pNext = &vk_dynamic_rendering_features,
 		.queueCreateInfoCount = static_cast<uint32_t>(vk_queue_infos.size()),
 		.pQueueCreateInfos = vk_queue_infos.data(),
 		.enabledExtensionCount = static_cast<uint32_t>(vk_extension_names.size()),
 		.ppEnabledExtensionNames = vk_extension_names.data(),
-		.pEnabledFeatures = nullptr, // replaced with VkPhysicalDeviceFeatures2
+		.pEnabledFeatures = &vk_features_2.features, // replaced with VkPhysicalDeviceFeatures2
 	};
 
 	vkc(api::create_device(gpu.m_physical_device, &vk_info, nullptr, &m_device));
@@ -3871,8 +3933,10 @@ void Device::free_memory(VkDeviceMemory memory) const
 	api::free_memory(m_device, memory, nullptr);
 }
 
-void Device::free_descriptor_set(VkDescriptorPool descriptor_pool, VkDescriptorSet descriptor_set)
+void Device::free_descriptor_set(
-    const
+    VkDescriptorPool descriptor_pool,
+    VkDescriptorSet descriptor_set
+) const
 {
 	vkc(api::free_descriptor_sets(m_device, descriptor_pool, 1, &descriptor_set));
 }
@@ -4164,18 +4228,19 @@ void Memory::unmap()
 
 Pipeline::Pipeline(Device &device, PipelineLayout &layout, CreateInfo info)
     : m_device(device.m_device.get())
-    , m_pipeline()
 
 {
 	auto shader_stages = std::vector<VkPipelineShaderStageCreateInfo> {};
 	for (auto &[shader, stage] : info.shaders)
 	{
-		shader_stages.emplace_back(VkPipelineShaderStageCreateInfo {
+		shader_stages.emplace_back(
-		    .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
+		    VkPipelineShaderStageCreateInfo {
-		    .stage = static_cast<VkShaderStageFlagBits>(stage),
+		        .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
-		    .module = shader.get_vk_handle(),
+		        .stage = static_cast<VkShaderStageFlagBits>(stage),
-		    .pName = "main",
+		        .module = shader.get_vk_handle(),
-		});
+		        .pName = "main",
+		    }
+		);
 	}
 
 	auto dynamic_states = std::array<VkDynamicState, 2> {
@@ -4258,7 +4323,8 @@ Pipeline::Pipeline(Device &device, PipelineLayout &layout, CreateInfo info)
 		.colorAttachmentCount = static_cast<uint32_t>(color_attachment_formats.size()),
 		.pColorAttachmentFormats = std::bit_cast<VkFormat *>(color_attachment_formats.data()),
 		.depthAttachmentFormat = info.attachment_state.depth_attachment ?
-		                             static_cast<VkFormat>(*info.attachment_state.depth_attachment
+		                             static_cast<VkFormat>(
+		                                 *info.attachment_state.depth_attachment
 		                             ) :
 		                             VK_FORMAT_UNDEFINED,
 
@@ -4298,10 +4364,33 @@ Pipeline::~Pipeline()
 
 Messenger::Messenger(Instance &instance, CreateInfo info): m_instance(instance.get_vk_handle())
 {
+	constexpr auto native_callback = [](VkDebugUtilsMessageSeverityFlagBitsEXT severity,
+	                                    VkDebugUtilsMessageTypeFlagsEXT types,
+	                                    const VkDebugUtilsMessengerCallbackDataEXT *data,
+	                                    void *user_data) {
+		auto *messenger = std::bit_cast<Messenger *>(user_data);
+		messenger->m_user_callback(
+		    severity,
+		    types,
+		    { .message = data->pMessage },
+		    messenger->m_user_data
+		);
+
+		return VK_FALSE;
+	};
+
+	m_user_callback = std::move(info.user_callback);
+	m_user_data = info.user_data;
 	auto vk_info = VkDebugUtilsMessengerCreateInfoEXT {
+		.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT,
+		.messageSeverity = info.enabled_severities,
+		.messageType = info.enabled_types,
+		.pfnUserCallback = native_callback,
+		.pUserData = this,
 
 	};
 
+	log::debug("Creating debug messenger....");
 	vkc(api::create_debug_messenger(m_instance, &vk_info, nullptr, &m_messenger));
 }
 

modules/renderer/vk/debugger.cppm

@@ -14,7 +14,6 @@ export class Debugger: public IDebugger
 public:
 	Debugger(IInstance *instance, CreateInfo info);
 
-
 private:
 	static void native_callback(
 	    vk::Flags severity,

modules/renderer/vk/device.cppm

@@ -101,9 +101,12 @@ void Device::initialize_logical_device()
                 vk::device_extension_names::swapchain,
                 vk::device_extension_names::dynamic_rendering,
                 vk::device_extension_names::descriptor_indexing,
+                vk::device_extension_names::depth_stencil_resolve,
+                vk::device_extension_names::maintenance_3,
+                vk::device_extension_names::create_renderpass2,
             },
 
-            .features = m_gpu->vk().get_features(),
+            .features = {},
 
             .dynamic_rendering_features = m_gpu->vk().get_supported_dynamic_rendering_features(),