From 1b918517392e691fa985cf1c635c55bf8b99a8c5 Mon Sep 17 00:00:00 2001 From: light7734 Date: Wed, 3 Dec 2025 21:26:09 +0330 Subject: [PATCH] wip: fix renderer --- .clang-tidy | 248 ++++++++++++++++++ .../_tests/{buffer.test.cpp => buffer.cpp} | 45 ++-- .../{debugger.test.cpp => debugger.cpp} | 0 .../_tests/{device.test.cpp => device.cpp} | 0 .../{instance.test.cpp => instance.cpp} | 0 .../_tests/{pass.test.cpp => pass.cpp} | 0 .../{renderer.test.cpp => renderer.cpp} | 0 .../_tests/{surface.test.cpp => surface.cpp} | 0 .../_tests/{system.test.cpp => system.cpp} | 0 modules/renderer/{ => _tests}/utils.cppm | 79 +++--- modules/renderer/factory.cppm | 13 +- modules/renderer/vk/api_wrapper.cppm | 209 ++++++++++----- modules/renderer/vk/debugger.cppm | 1 - modules/renderer/vk/device.cppm | 5 +- 14 files changed, 480 insertions(+), 120 deletions(-) rename modules/renderer/_tests/{buffer.test.cpp => buffer.cpp} (62%) rename modules/renderer/_tests/{debugger.test.cpp => debugger.cpp} (100%) rename modules/renderer/_tests/{device.test.cpp => device.cpp} (100%) rename modules/renderer/_tests/{instance.test.cpp => instance.cpp} (100%) rename modules/renderer/_tests/{pass.test.cpp => pass.cpp} (100%) rename modules/renderer/_tests/{renderer.test.cpp => renderer.cpp} (100%) rename modules/renderer/_tests/{surface.test.cpp => surface.cpp} (100%) rename modules/renderer/_tests/{system.test.cpp => system.cpp} (100%) rename modules/renderer/{ => _tests}/utils.cppm (69%) diff --git a/.clang-tidy b/.clang-tidy index e69de29..52d762a 100644 --- a/.clang-tidy +++ b/.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, +" diff --git a/modules/renderer/_tests/buffer.test.cpp b/modules/renderer/_tests/buffer.cpp similarity index 62% rename from modules/renderer/_tests/buffer.test.cpp rename to modules/renderer/_tests/buffer.cpp index b7a53cc..a0c1602 100644 --- a/modules/renderer/_tests/buffer.test.cpp +++ b/modules/renderer/_tests/buffer.cpp @@ -1,21 +1,21 @@ -#include -#include +import renderer.frontend; +import renderer.test_utils; -using ::lt::renderer::IBuffer; -using enum ::lt::renderer::IMessenger::MessageSeverity; +using enum ::lt::renderer::IDebugger::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 { - .usage = static_cast(idx), + lt::renderer::IBuffer::CreateInfo { + .usage = static_cast(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 { - .usage = IBuffer::Usage::vertex, + auto info = lt::renderer::IBuffer::CreateInfo { + .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 { - .usage = IBuffer::Usage::staging, + lt::renderer::IBuffer::CreateInfo { + .usage = staging, .size = size, .debug_name = "", } diff --git a/modules/renderer/_tests/debugger.test.cpp b/modules/renderer/_tests/debugger.cpp similarity index 100% rename from modules/renderer/_tests/debugger.test.cpp rename to modules/renderer/_tests/debugger.cpp diff --git a/modules/renderer/_tests/device.test.cpp b/modules/renderer/_tests/device.cpp similarity index 100% rename from modules/renderer/_tests/device.test.cpp rename to modules/renderer/_tests/device.cpp diff --git a/modules/renderer/_tests/instance.test.cpp b/modules/renderer/_tests/instance.cpp similarity index 100% rename from modules/renderer/_tests/instance.test.cpp rename to modules/renderer/_tests/instance.cpp diff --git a/modules/renderer/_tests/pass.test.cpp b/modules/renderer/_tests/pass.cpp similarity index 100% rename from modules/renderer/_tests/pass.test.cpp rename to modules/renderer/_tests/pass.cpp diff --git a/modules/renderer/_tests/renderer.test.cpp b/modules/renderer/_tests/renderer.cpp similarity index 100% rename from modules/renderer/_tests/renderer.test.cpp rename to modules/renderer/_tests/renderer.cpp diff --git a/modules/renderer/_tests/surface.test.cpp b/modules/renderer/_tests/surface.cpp similarity index 100% rename from modules/renderer/_tests/surface.test.cpp rename to modules/renderer/_tests/surface.cpp diff --git a/modules/renderer/_tests/system.test.cpp b/modules/renderer/_tests/system.cpp similarity index 100% rename from modules/renderer/_tests/system.test.cpp rename to modules/renderer/_tests/system.cpp diff --git a/modules/renderer/utils.cppm b/modules/renderer/_tests/utils.cppm similarity index 69% rename from modules/renderer/utils.cppm rename to modules/renderer/_tests/utils.cppm index 0cad1f4..7113d55 100644 --- a/modules/renderer/utils.cppm +++ b/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::IMessenger::MessageType type, - const lt::renderer::IMessenger::MessageData &data, + lt::renderer::IDebugger::MessageSeverity severity, + lt::renderer::IDebugger::MessageType type, + 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, - .types= lt::renderer::IMessenger::MessageType::all, + .severities = lt::renderer::IDebugger::MessageSeverity::all, + .types= lt::renderer::IDebugger::MessageType::all, .callback = noop_messenger_callback, .user_data = {}, } @@ -105,14 +114,14 @@ public: } private: - lt::memory::Scope m_surface { lt::renderer::ISurface::create( + lt::memory::Scope 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 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( - lt::renderer::IMessenger ::MessageSeverity severity - ) const -> uint32_t + [[nodiscard]] auto has_any_messages_of(lt::renderer::IDebugger ::MessageSeverity severity) const + -> std::uint32_t { return m_user_data->m_severity_counter.contains(severity); } private: static void messenger_callback( - lt::renderer::IMessenger::MessageSeverity severity, - lt::renderer::IMessenger::MessageType type, - const lt::renderer::IMessenger::MessageData &data, + lt::renderer::IDebugger::MessageSeverity severity, + lt::renderer::IDebugger::MessageType type, + 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 m_severity_counter; + std::unordered_map + m_severity_counter; bool m_has_any_messages {}; }; lt::memory::Scope m_user_data = lt::memory::create_scope(); - lt::memory::Scope m_messenger = lt::renderer::IMessenger::create( + lt::memory::Scope m_messenger = lt::renderer::create_debugger( constants::api, - lt::renderer::IInstance::get(constants::api), - lt::renderer::IMessenger ::CreateInfo { - .severities = lt::renderer::IMessenger ::MessageSeverity::all, - .types = lt::renderer::IMessenger ::MessageType::all, + lt::renderer::get_instance(constants::api), + lt::renderer::IDebugger ::CreateInfo { + .severities = lt::renderer::IDebugger::MessageSeverity::all, + .types = lt::renderer::IDebugger::MessageType::all, .callback = &messenger_callback, .user_data = m_user_data.get(), } ); lt::memory::Scope m_device { - lt::renderer::IDevice::create(constants::api, gpu(), surface()) + lt::renderer::create_device(constants::api, gpu(), surface()) }; lt::memory::Scope 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( - lt::renderer::IMessenger ::MessageSeverity severity - ) const -> uint32_t + [[nodiscard]] auto has_any_messages_of(lt::renderer::IDebugger ::MessageSeverity severity) const + -> std::uint32_t { return m_user_data->m_severity_counter.contains(severity); } private: static void messenger_callback( - lt::renderer::IMessenger::MessageSeverity severity, - lt::renderer::IMessenger::MessageType type, - const lt::renderer::IMessenger::MessageData &data, + lt::renderer::IDebugger::MessageSeverity severity, + lt::renderer::IDebugger::MessageType type, + const lt::renderer::IDebugger::MessageData &data, std::any &user_data ) { @@ -246,7 +254,8 @@ private: struct UserData { - std::unordered_map m_severity_counter; + std::unordered_map + 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 { - .severities = lt::renderer::IMessenger ::MessageSeverity::all, - .types = lt::renderer::IMessenger ::MessageType::all, + .debug_callback_info = lt::renderer::IDebugger ::CreateInfo { + .severities = lt::renderer::IDebugger ::MessageSeverity::all, + .types = lt::renderer::IDebugger ::MessageType::all, .callback = &messenger_callback, .user_data = m_user_data.get(), } diff --git a/modules/renderer/factory.cppm b/modules/renderer/factory.cppm index f2d05ad..569c186 100644 --- a/modules/renderer/factory.cppm +++ b/modules/renderer/factory.cppm @@ -51,6 +51,13 @@ export namespace lt::renderer { std::uint32_t max_frames_in_flight ) -> memory::Scope; +[[nodiscard]] auto create_buffer( + Api target_api, + IDevice *device, + IGpu *gpu, + const IBuffer::CreateInfo &info +) -> memory::Scope; + } // 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 { @@ -134,8 +141,8 @@ namespace lt::renderer { [[nodiscard]] auto create_buffer( Api target_api, - class IDevice *device, - class IGpu *gpu, + IDevice *device, + IGpu *gpu, const IBuffer::CreateInfo &info ) -> memory::Scope { diff --git a/modules/renderer/vk/api_wrapper.cppm b/modules/renderer/vk/api_wrapper.cppm index 1e3db76..049efcf 100644 --- a/modules/renderer/vk/api_wrapper.cppm +++ b/modules/renderer/vk/api_wrapper.cppm @@ -43,6 +43,7 @@ import math.vec3; import math.vec2; import debug.assertions; import std; +import logger; template 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) - const; + void free_descriptor_set( + VkDescriptorPool descriptor_pool, + VkDescriptorSet descriptor_set + ) const; /** destroy functions */ void destroy_swapchain(VkSwapchainKHR swapchain) const; @@ -2542,6 +2550,10 @@ public: private: memory::NullOnMove 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 {}; auto layer_names = std::vector {}; auto extension_names = std::vector {}; + 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 { - .pLayerName = layer.name.c_str(), - .pSettingName = setting.name.c_str(), - .type = std::visit(layer_setting_type_visitor, setting.values), - .valueCount = 1u, - .pValues = std::visit(layer_setting_value_visitor, setting.values), - }); + const auto *values = (void *) { nullptr }; + + if (setting.values.index() == 0) + { + values = std::bit_cast(std::get<0>(setting.values).data()); + } + else if (setting.values.index() == 1) + { + values = std::bit_cast(&std::get<1>(setting.values)); + } + else if (setting.values.index() == 2) + { + values = std::bit_cast(&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(layer_settings.size()), @@ -2953,10 +2998,17 @@ Instance::Instance(CreateInfo info) .flags = {}, .enabledLayerCount = static_cast(info.layers.size()), .ppEnabledLayerNames = layer_names.data(), - .enabledExtensionCount = static_cast(info.extensions.size()), + .enabledExtensionCount = static_cast(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_uniform_texel_buffer_array_dynamic_indexing = features.shaderUniformTexelBufferArrayDynamicIndexing, - .shader_storage_texel_buffer_array_dynamic_indexing = features.shaderStorageTexelBufferArrayDynamicIndexing, - .shader_uniform_buffer_array_non_uniform_indexing = features.shaderUniformBufferArrayNonUniformIndexing, - .shader_sampled_image_array_non_uniform_indexing = features.shaderSampledImageArrayNonUniformIndexing, - .shader_storage_buffer_array_non_uniform_indexing = features.shaderStorageBufferArrayNonUniformIndexing, - .shader_storage_image_array_non_uniform_indexing = features.shaderStorageImageArrayNonUniformIndexing, - .shader_input_attachment_array_non_uniform_indexing = features.shaderInputAttachmentArrayNonUniformIndexing, - .shader_uniform_texel_buffer_array_non_uniform_indexing = features.shaderUniformTexelBufferArrayNonUniformIndexing, - .shader_storage_texel_buffer_array_non_uniform_indexing = features.shaderStorageTexelBufferArrayNonUniformIndexing, - .descriptor_binding_uniform_buffer_update_after_bind = features.descriptorBindingUniformBufferUpdateAfterBind, - .descriptor_binding_sampled_image_update_after_bind = features.descriptorBindingSampledImageUpdateAfterBind, - .descriptor_binding_storage_image_update_after_bind = features.descriptorBindingStorageImageUpdateAfterBind, - .descriptor_binding_storage_buffer_update_after_bind = features.descriptorBindingStorageBufferUpdateAfterBind, - .descriptor_binding_uniform_texel_buffer_update_after_bind = features.descriptorBindingUniformTexelBufferUpdateAfterBind, - .descriptor_binding_storage_texel_buffer_update_after_bind = features.descriptorBindingStorageTexelBufferUpdateAfterBind, - .descriptor_binding_update_unused_while_pending = features.descriptorBindingUpdateUnusedWhilePending, - .descriptor_binding_partially_bound = features.descriptorBindingPartiallyBound, - .descriptor_binding_variable_descriptor_count = features.descriptorBindingVariableDescriptorCount, - .runtime_descriptor_array = features.runtimeDescriptorArray, + .shader_input_attachment_array_dynamic_indexing =false, + .shader_uniform_texel_buffer_array_dynamic_indexing =false, + .shader_storage_texel_buffer_array_dynamic_indexing =false, + .shader_uniform_buffer_array_non_uniform_indexing =false, + .shader_sampled_image_array_non_uniform_indexing =false, + .shader_storage_buffer_array_non_uniform_indexing =false, + .shader_storage_image_array_non_uniform_indexing =false, + .shader_input_attachment_array_non_uniform_indexing =false, + .shader_uniform_texel_buffer_array_non_uniform_indexing =false, + .shader_storage_texel_buffer_array_non_uniform_indexing =false, + .descriptor_binding_uniform_buffer_update_after_bind =false, + .descriptor_binding_sampled_image_update_after_bind =false, + .descriptor_binding_storage_image_update_after_bind =false, + .descriptor_binding_storage_buffer_update_after_bind =false, + .descriptor_binding_uniform_texel_buffer_update_after_bind =false, + .descriptor_binding_storage_texel_buffer_update_after_bind =false, + .descriptor_binding_update_unused_while_pending =false, + .descriptor_binding_partially_bound =false, + .descriptor_binding_variable_descriptor_count =false, + .runtime_descriptor_array =false, // clang-format on }; } @@ -3413,10 +3466,12 @@ Surface::~Surface() auto formats = std::vector {}; for (auto &vk_format : vk_formats) { - formats.emplace_back(Surface::Format { - .format = static_cast(vk_format.format), - .color_space = static_cast(vk_format.colorSpace), - }); + formats.emplace_back( + Surface::Format { + .format = static_cast(vk_format.format), + .color_space = static_cast(vk_format.colorSpace), + } + ); } return formats; @@ -3473,15 +3528,17 @@ Device::Device(const Gpu &gpu, CreateInfo info) auto vk_queue_infos = std::vector {}; for (auto queue_family : info.queue_indices) { - vk_queue_infos.emplace_back(VkDeviceQueueCreateInfo { - .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, - .queueFamilyIndex = queue_family, - .queueCount = 1u, - .pQueuePriorities = &priorities, - }); + vk_queue_infos.emplace_back( + VkDeviceQueueCreateInfo { + .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, + .queueFamilyIndex = queue_family, + .queueCount = 1u, + .pQueuePriorities = &priorities, + } + ); } - auto vk_extension_names = std::vector(info.extensions.size()); + auto vk_extension_names = std::vector {}; 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_descriptor_indexing_features.pNext; + *last_p_next = &vk_dynamic_rendering_features; + // 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.pNext; + // *last_p_next = &vk_descriptor_indexing_features; + // 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(vk_queue_infos.size()), .pQueueCreateInfos = vk_queue_infos.data(), .enabledExtensionCount = static_cast(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) - const +void Device::free_descriptor_set( + 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 {}; for (auto &[shader, stage] : info.shaders) { - shader_stages.emplace_back(VkPipelineShaderStageCreateInfo { - .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, - .stage = static_cast(stage), - .module = shader.get_vk_handle(), - .pName = "main", - }); + shader_stages.emplace_back( + VkPipelineShaderStageCreateInfo { + .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, + .stage = static_cast(stage), + .module = shader.get_vk_handle(), + .pName = "main", + } + ); } auto dynamic_states = std::array { @@ -4258,7 +4323,8 @@ Pipeline::Pipeline(Device &device, PipelineLayout &layout, CreateInfo info) .colorAttachmentCount = static_cast(color_attachment_formats.size()), .pColorAttachmentFormats = std::bit_cast(color_attachment_formats.data()), .depthAttachmentFormat = info.attachment_state.depth_attachment ? - static_cast(*info.attachment_state.depth_attachment + static_cast( + *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(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)); } diff --git a/modules/renderer/vk/debugger.cppm b/modules/renderer/vk/debugger.cppm index 52f0503..f95c8a0 100644 --- a/modules/renderer/vk/debugger.cppm +++ b/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, diff --git a/modules/renderer/vk/device.cppm b/modules/renderer/vk/device.cppm index 58c99a4..0c0cc44 100644 --- a/modules/renderer/vk/device.cppm +++ b/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(),