light7734/light
light7734/light
1
1
Fork 0
Code Issues 21 Pull requests 3 Projects 1 Releases Packages Wiki Activity

wip: convert from include style to module import style :D
Some checks reported errors
continuous-integration/drone/push Build was killed
Details

Browse source
This commit is contained in:
light7734 2025-11-14 16:04:37 +03:30
parent 018d19335d
commit a2efc487c4
Signed by: light7734
GPG key ID: 8C30176798F1A6BA
33 changed files with 654 additions and 984 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

248
.clang-tidy
View file

@ -1,248 +0,0 @@
---
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,
"

5
.clangd
View file

@ -1,5 +0,0 @@
CompileFlags:
DriverMode: cl
Add:
- /EHsc
- /std:c++latest

17
.cmake-format Normal file
View file

@ -0,0 +1,17 @@
# How wide to allow formatted cmake files
line_width: 80
# How many spaces to tab for indent
tab_size: 4
dangle_parens: true
# Additional FLAGS and KWARGS for custom commands
additional_commands:
foo:
flags: [BAR, BAZ]
kwargs:
HEADERS : '*'
SOURCES : '*'
DEPENDS : '*'

8
CMakeLists.txt
View file

@ -1,4 +1,10 @@
cmake_minimum_required(VERSION 3.14)
set(CMAKE_CXX_STANDARD 23)
set(CMAKE_EPXORT_COMPILE_COMMANDS TRUE)
set(CMAKE_EXPERIMENTAL_CXX_IMPORT_STD "d0edc3af-4c50-42ea-a356-e2862fe7a444")
set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
set(CMAKE_CXX_MODULE_STD 1)
cmake_minimum_required(VERSION 4.1)
project(Light)
include(${CMAKE_CURRENT_SOURCE_DIR}/tools/cmake/functions.cmake)

14
CONTRIBUTING.md
View file

@ -1,14 +0,0 @@
# How to contribute to Light Engine
Thanks for putting in the time to contribute to this project <3
## Coding conventions
For the time being, don't worry too much about the conventions...
Try to read other parts of the code and you'll get the hang of it
I have to learn clang-format, then everyone contributing can use it to format their code
###### happy coding-

36
data/test_assets/sprite.vert Normal file
View file

@ -0,0 +1,36 @@
#version 450 core
layout(push_constant) uniform pc
{
mat4 view_projection;
};
struct VertexData
{
vec3 position;
vec3 color;
};
// readonly SSBO containing the vertex data
layout(set = 0, binding = 0, std430) readonly buffer vertex_data {
VertexData data[];
};
vec3 position(int idx)
{
return data[idx].position;
}
vec3 color(int idx)
{
return data[idx].color;
}
layout(location = 0) out vec3 out_frag_color;
void main()
{
gl_Position = view_projection * vec4(position(gl_VertexIndex), 1.0);
out_frag_color = color(gl_VertexIndex);
}

BIN
data/test_assets/sprite.vert.asset Normal file
View file

Binary file not shown.

3
data/test_assets/triangle.vert
View file

@ -1,7 +1,7 @@
#version 450 core
layout(push_constant ) uniform pc {
mat4 view_projection;
mat4 view_projection;
};
vec3 positions[3] = vec3[](
@ -23,4 +23,3 @@ void main()
gl_Position = view_projection * vec4(positions[gl_VertexIndex], 1.0);
out_frag_color = colors[gl_VertexIndex];
}

1
docs/.gitignore vendored
View file

@ -2,4 +2,3 @@ _build/
generated/
html/
xml/

24
modules/CMakeLists.txt
View file

@ -4,7 +4,6 @@ add_library_module(
INTERFACES
test.cppm
expects.cppm
PRIVATE_INTERFACES
registry.cppm
SOURCES
entrypoint.cpp
@ -151,7 +150,9 @@ add_library_module(
renderer
INTERFACES
data.cppm
system.cppm
frontends.cppm
components.cppm
factory.cppm
vk/api_wrapper.cppm
vk/device.cppm
@ -161,6 +162,8 @@ add_library_module(
vk/swapchain.cppm
vk/buffer.cppm
vk/pass.cppm
vk/renderer.cppm
vk/debugger.cppm
DEPENDENCIES
app
ecs
@ -173,4 +176,21 @@ add_library_module(
surface
)
# add_subdirectory(./mirror)
add_library_module(
NAME
libmirror
ROOT_DIR
${CMAKE_CURRENT_SOURCE_DIR}/mirror
INTERFACES
system.cppm
DEPENDENCIES
app
time
input
surface
renderer
camera
)
# add_executable_module(mirror entrypoint/mirror.cpp)
# target_link_libraries(mirror PRIVATE libmirror input)

162
modules/asset_parser/text.cppm
View file

@ -1,162 +0,0 @@
#include <asset_parser/assets/text.hpp>
namespace Assets {
/* static */ void TextAsset::pack(const PackageData &data, const std::filesystem::path &out_path)
{
const auto &[metadata, text_metadata, text] = data;
auto stream = std::ofstream { out_path, std::ios::binary | std::ios::trunc };
if (!stream.is_open())
{
throw std::runtime_error {
std::format("Failed to open ofstream for packing Text at: {}", out_path.string())
};
}
stream.seekp(0);
// NOLINTBEGIN(cppcoreguidelines-pro-type-cstyle-cast)
stream.write((char *)&current_version, sizeof(current_version));
stream.write((char *)&metadata, sizeof(metadata));
stream.write((char *)&text_metadata, sizeof(text_metadata));
constexpr auto number_of_blobs = uint32_t { 1 };
stream.write((char *)&number_of_blobs, sizeof(number_of_blobs));
auto textblob_metadata = BlobMetadata {
.tag = BlobMetadata::Tag::text,
.offset = static_cast<size_t>(stream.tellp()) + sizeof(BlobMetadata),
.compression_type = CompressionType::None,
.compressed_size = text.size(),
.uncompressed_size = text.size(),
};
stream.write((char *)&textblob_metadata, sizeof(textblob_metadata));
stream.write((char *)text.data(), static_cast<long>(text.size()));
// NOLINTEND(cppcoreguidelines-pro-type-cstyle-cast)
}
TextAsset::TextAsset(const std::filesystem::path &path)
{
m_stream = std::ifstream { path, std::ios::binary };
if (!m_stream.is_open())
{
throw std::runtime_error {
std::format("Failed to open ifstream for loading Text asset at: {}", path.string())
};
}
// NOLINTBEGIN(cppcoreguidelines-pro-type-cstyle-cast)
m_stream.read((char *)&version, sizeof(version));
m_stream.read((char *)&m_asset_metadata, sizeof(m_asset_metadata));
m_stream.read((char *)&m_metadata, sizeof(m_metadata));
auto num_blobs = uint32_t {};
m_stream.read((char *)&num_blobs, sizeof(num_blobs));
if (num_blobs != 1)
{
throw std::runtime_error {
std::format("Failed to load Text asset: invalid number of blobs: {}", num_blobs)
};
}
m_stream.read((char *)&m_text_blob_metadata, sizeof(m_text_blob_metadata));
if (m_text_blob_metadata.tag != BlobMetadata::Tag::text)
{
throw std::runtime_error {
std::format(
"Failed to load Text asset: invalid blob tag, expected {}, got {}",
std::to_underlying(BlobMetadata::Tag::text),
std::to_underlying(m_text_blob_metadata.tag)
),
};
}
// NOLINTEND(cppcoreguidelines-pro-type-cstyle-cast)
}
void TextAsset::unpack_blob(
BlobMetadata::Tag tag,
std::byte *destination,
size_t destination_capacity
) const
{
if (tag != BlobMetadata::Tag::text)
{
throw std::runtime_error {
std::format("Invalid tag for unpack_blob of TextAsset: {}", std::to_underlying(tag))
};
}
m_stream.seekg(static_cast<long>(m_text_blob_metadata.offset));
switch (m_text_blob_metadata.compression_type)
{
case Assets::CompressionType::None:
if (m_text_blob_metadata.uncompressed_size != m_text_blob_metadata.compressed_size)
{
throw std::runtime_error(
"Failed to unpack blob from TextAsset: "
"compressed/uncompressed size mismatch for no compression "
"type"
);
}
if (m_text_blob_metadata.uncompressed_size > destination_capacity)
{
throw std::runtime_error(
"Failed to unpack blob from TextAsset: "
"uncompressed_size > destination_capacity, unpacking "
"would result in segfault"
);
}
if (!m_stream.is_open())
{
throw std::runtime_error(
"Failed to unpack blob from TextAsset: ifstream is "
"closed"
);
}
m_stream.read(
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-cstyle-cast)
(char *)destination,
static_cast<long>(m_text_blob_metadata.uncompressed_size)
);
return;
default:
throw std::runtime_error(
std::format(
"Failed to unpack blob from TextAsset: unsupported "
"compression type: {}",
std::to_underlying(m_text_blob_metadata.compression_type)
)
);
}
}
[[nodiscard]] auto TextAsset::get_asset_metadata() const -> const Asset::Metadata &
{
return m_asset_metadata;
}
[[nodiscard]] auto TextAsset::get_metadata() const -> const Metadata &
{
return m_metadata;
}
[[nodiscard]] auto TextAsset::get_blob_metadata(BlobMetadata::Tag tag) const -> const BlobMetadata &
{
if (tag != BlobMetadata::Tag::text)
{
throw std::runtime_error { std::format(
"Invalid tag for get_blob_metadata of TextAsset: {}",
std::to_underlying(tag)
) };
}
return m_text_blob_metadata;
}
} // namespace Assets

2
modules/input/system.cppm
View file

@ -12,7 +12,7 @@ import std;
namespace lt::input {
class System: public app::ISystem
export class System: public app::ISystem
{
public:
System(memory::Ref<ecs::Registry> registry);

2
modules/math/algebra.cppm
View file

@ -2,7 +2,7 @@ export module math.algebra;
import math.mat4;
import std;
namespace lt::math {
export namespace lt::math {
/**
* let...

2
modules/math/trig.cppm
View file

@ -1,6 +1,6 @@
export module math.trig;
namespace lt::math {
export namespace lt::math {
[[nodiscard]] constexpr auto radians(float degrees) -> float
{

2
modules/memory/null_on_move.cppm
View file

@ -7,7 +7,7 @@ namespace lt::memory {
/** Holds an `Underlying_T`, assigns it to `null_value` when this object is moved.
*
* @note For avoiding the need to explicitly implement the move constructor for objects that hold
* Vulkan objects. But may serve other purposes, hence why I kept the implementation generic.
* Vulkan handles. But may serve other purposes, hence why I kept the implementation generic.
*/
export template<typename Underlying_T, Underlying_T null_value = nullptr>
class NullOnMove

83
modules/mirror/entrypoint.cpp → modules/mirror/system.cppm
View file

@ -1,30 +1,35 @@
#include <X11/keysym.h>
#include <app/application.hpp>
#include <app/entrypoint.hpp>
#include <app/system.hpp>
#include <camera/components.hpp>
#include <ecs/entity.hpp>
#include <input/components.hpp>
#include <input/system.hpp>
#include <math/components/transform.hpp>
#include <math/trig.hpp>
#include <math/vec2.hpp>
#include <memory/reference.hpp>
#include <memory/scope.hpp>
#include <renderer/components/messenger.hpp>
#include <renderer/components/sprite.hpp>
#include <renderer/system.hpp>
#include <surface/events/keyboard.hpp>
#include <surface/events/surface.hpp>
#include <surface/system.hpp>
#include <time/timer.hpp>
export module mirror.system;
import math.vec3;
import camera.components;
import surface.requests;
import logger;
import surface.system;
import math.vec2;
import math.vec4;
import math.trig;
import input.codes;
import input.events;
import input.system;
import math.components;
import memory.reference;
import memory.scope;
import renderer.components;
import renderer.system;
import renderer.frontend;
import surface.events;
import time;
import app;
import app.system;
import ecs.entity;
import ecs.registry;
import std;
namespace lt {
void renderer_callback(
renderer::IMessenger::MessageSeverity message_severity,
renderer::IMessenger::MessageType message_type,
renderer::IMessenger::MessageData data,
renderer::IDebugger::MessageSeverity message_severity,
renderer::IDebugger::MessageType message_type,
renderer::IDebugger::MessageData data,
std::any &user_data
)
{
@ -40,8 +45,8 @@ class MirrorSystem: public lt::app::ISystem
public:
MirrorSystem(
memory::Ref<ecs::Registry> registry,
lt::input::InputAction::Key quit_action_key,
std::array<lt::input::InputAction::Key, 4> debug_action_keys
std::size_t quit_action_key,
std::array<std::size_t, 4ul> debug_action_keys
)
: m_registry(std::move(registry))
, m_quit_action_key(quit_action_key)
@ -70,7 +75,6 @@ public:
const auto &[x, y] = surface.get_position();
const auto &[width, height] = surface.get_resolution();
if (input.get_action(m_quit_action_key).state == State::active)
{
should_quit = true;
@ -124,10 +128,9 @@ public:
private:
memory::Ref<ecs::Registry> m_registry;
std::size_t m_quit_action_key;
lt::input::InputAction::Key m_quit_action_key;
std::array<lt::input::InputAction::Key, 4> m_debug_action_keys {};
std::array<std::size_t, 4ul> m_debug_action_keys {};
app::TickResult m_last_tick_result {};
};
@ -176,36 +179,36 @@ public:
auto quit_action_key = input.add_action(
input::InputAction {
.name = "quit",
.trigger = input::Trigger { .mapped_keycode = XK_q },
.trigger = input::Trigger { .mapped_keycode = Key::Q },
}
);
auto debug_action_keys = std::array<lt::input::InputAction::Key, 4> {};
auto debug_action_keys = std::array<std::size_t, 4ul> {};
debug_action_keys[0] = input.add_action(
input::InputAction {
.name = "debug_1",
.trigger = input::Trigger { .mapped_keycode = XK_1 },
.trigger = input::Trigger { .mapped_keycode = Key::D1 },
}
);
debug_action_keys[1] = input.add_action(
input::InputAction {
.name = "debug_2",
.trigger = input::Trigger { .mapped_keycode = XK_2 },
.trigger = input::Trigger { .mapped_keycode = Key::D2 },
}
);
debug_action_keys[2] = input.add_action(
input::InputAction {
.name = "debug_3",
.trigger = input::Trigger { .mapped_keycode = XK_3 },
.trigger = input::Trigger { .mapped_keycode = Key::D3 },
}
);
debug_action_keys[3] = input.add_action(
input::InputAction {
.name = "debug_4",
.trigger = input::Trigger { .mapped_keycode = XK_4 },
.trigger = input::Trigger { .mapped_keycode = Key::D4 },
}
);
@ -222,9 +225,9 @@ public:
.config = { .target_api = renderer::Api::vulkan, .max_frames_in_flight = 3u },
.registry = m_editor_registry,
.surface_entity = entity,
.debug_callback_info = renderer::IMessenger::CreateInfo {
.severities = renderer::IMessenger::MessageSeverity::all,
.types = renderer::IMessenger::MessageType::all,
.debug_callback_info = renderer::IDebugger::CreateInfo {
.severities = renderer::IDebugger::MessageSeverity::all,
.types = renderer::IDebugger::MessageType::all,
.callback = &renderer_callback,
.user_data = this,
} });
@ -233,7 +236,9 @@ public:
m_editor_registry->add(
m_sprite_id,
renderer::components::Sprite { .color = lt::math::vec3 { 1.0f, 0.0f, 0.0f } }
renderer::components::Sprite {
.color = lt::math::vec3 { 1.0f, 0.0f, 0.0f },
}
);
m_editor_registry->add(
m_sprite_id,

43
modules/renderer/factory.cppm
View file

@ -1,15 +1,15 @@
export module renderer.factory;
import renderer.frontend;
import assets.shader;
import renderer.backend.vk.device;
import renderer.vk.device;
import renderer.vk.pass;
import renderer.backend.vk.instance;
import renderer.backend.vk.swapchain;
import renderer.vk.renderer;
import renderer.backend.vk.buffer;
import renderer.backend.vk.gpu;
import renderer.backend.vk.surface;
import renderer.vk.instance;
import renderer.vk.swapchain;
import renderer.vk.renderer;
import renderer.vk.buffer;
import renderer.vk.gpu;
import renderer.vk.debugger;
import renderer.vk.surface;
import memory.scope;
import debug.assertions;
import ecs.entity;
@ -19,14 +19,20 @@ export namespace lt::renderer {
[[nodiscard]] auto get_instance(Api target_api) -> IInstance *;
[[nodiscard]] auto create_debugger(Api target_api, IInstance *instance, IDebugger::CreateInfo info)
-> memory::Scope<IDebugger>;
[[nodiscard]] auto create_surface(
Api target_api,
IInstance *instance,
const ecs::Entity &surface_entity
);
) -> memory::Scope<ISurface>;
[[nodiscard]] auto create_gpu(Api target_api, IInstance *instance) -> memory::Scope<IGpu>;
[[nodiscard]] auto create_device(Api target_api, IGpu *gpu, ISurface *surface)
-> memory::Scope<IDevice>;
[[nodiscard]] auto create_swapchain(Api target_api, ISurface *surface, IGpu *gpu, IDevice *device)
-> memory::Scope<ISwapchain>;
@ -43,7 +49,7 @@ export namespace lt::renderer {
IDevice *device,
ISwapchain *swapchain,
std::uint32_t max_frames_in_flight
) -> memory::Scope<IRenderer>
) -> memory::Scope<IRenderer>;
} // namespace lt::renderer
@ -192,25 +198,24 @@ using namespace lt::renderer;
}
}
[[nodiscard]] /* static */ auto IDebugger::create(
Api target_api,
IInstance *instance,
CreateInfo info
) -> memory::Scope<IDebugger>
[[nodiscard]] auto create_debugger(Api target_api, IInstance *instance, IDebugger::CreateInfo info)
-> memory::Scope<IDebugger>
{
debug::ensure(
info.severities != MessageSeverity::none,
"Failed to create vk::Messenger: severities == none"
info.severities != IDebugger::MessageSeverity::none,
"Failed to create renderer::IDebugger: severities == none"
);
debug::ensure(info.types != MessageType::none, "Failed to create vk::Messenger: types == none");
debug::ensure(
info.types != IDebugger::MessageType::none,
"Failed to create renderer::IDebugger: types == none"
);
debug::ensure(info.callback, "Failed to create vk::Messenger: null callback");
switch (target_api)
{
case Api::vulkan: return memory::create_scope<vk::Messenger>(instance, std::move(info));
case Api::vulkan: return memory::create_scope<vkb::Debugger>(instance, std::move(info));
case Api::none:
case Api::metal:
case Api::direct_x: throw std::runtime_error { "Invalid API" };

181
modules/renderer/frontends.cppm
View file

@ -1,6 +1,7 @@
export module renderer.frontend;
import renderer.data;
import renderer.components;
import bitwise;
import math.components;
import assets.shader;
import ecs.entity;
@ -22,18 +23,9 @@ enum class Api : std::uint8_t
class IInstance
{
public:
// [[nodiscard]] static auto get(Api target_api) -> IInstance *;
IInstance() = default;
virtual ~IInstance() = default;
IInstance(IInstance &&) = default;
IInstance(const IInstance &) = delete;
auto operator=(IInstance &&) -> IInstance & = default;
auto operator=(const IInstance &) -> IInstance & = delete;
};
class IGpu
@ -42,14 +34,6 @@ public:
IGpu() = default;
virtual ~IGpu() = default;
IGpu(IGpu &&) = default;
IGpu(const IGpu &) = delete;
auto operator=(IGpu &&) -> IGpu & = default;
auto operator=(const IGpu &) -> IGpu & = delete;
};
class IDevice
@ -58,14 +42,6 @@ public:
IDevice() = default;
virtual ~IDevice() = default;
IDevice(IDevice &&) = default;
IDevice(const IDevice &) = delete;
auto operator=(IDevice &&) -> IDevice & = default;
auto operator=(const IDevice &) -> IDevice & = delete;
};
class ISurface
@ -75,14 +51,6 @@ public:
virtual ~ISurface() = default;
ISurface(ISurface &&) = default;
ISurface(const ISurface &) = delete;
auto operator=(ISurface &&) -> ISurface & = default;
auto operator=(const ISurface &) -> ISurface & = delete;
[[nodiscard]] virtual auto get_framebuffer_size() const -> math::uvec2 = 0;
};
@ -92,14 +60,6 @@ public:
ISwapchain() = default;
virtual ~ISwapchain() = default;
ISwapchain(ISwapchain &&) = default;
ISwapchain(const ISwapchain &) = delete;
auto operator=(ISwapchain &&) -> ISwapchain & = default;
auto operator=(const ISwapchain &) -> ISwapchain & = delete;
};
class IBuffer
@ -136,14 +96,6 @@ public:
virtual ~IBuffer() = default;
IBuffer(IBuffer &&) = default;
IBuffer(const IBuffer &) = delete;
auto operator=(IBuffer &&) -> IBuffer & = default;
auto operator=(const IBuffer &) -> IBuffer & = delete;
[[nodiscard]] virtual auto map() -> std::span<std::byte> = 0;
virtual void unmap() = 0;
@ -159,14 +111,6 @@ public:
IPass() = default;
virtual ~IPass() = default;
IPass(IPass &&) = default;
IPass(const IPass &) = delete;
auto operator=(IPass &&) -> IPass & = default;
auto operator=(const IPass &) -> IPass & = delete;
};
class IRenderer
@ -187,14 +131,6 @@ public:
virtual ~IRenderer() = default;
IRenderer(IRenderer &&) = default;
IRenderer(const IRenderer &) = delete;
auto operator=(IRenderer &&) -> IRenderer & = default;
auto operator=(const IRenderer &) -> IRenderer & = delete;
virtual auto frame(std::uint32_t frame_idx, std::function<void()> submit_scene) -> Result = 0;
virtual void replace_swapchain(class ISwapchain *swapchain) = 0;
@ -207,68 +143,57 @@ public:
) = 0;
};
// class IDebugger
// {
// public:
// enum class MessageSeverity : std::uint8_t
// {
// none = 0u,
//
// verbose = bitwise::bit(0u),
// info = bitwise::bit(1u),
// warning = bitwise::bit(2u),
// error = bitwise::bit(3u),
//
// all = verbose | info | warning | error,
// };
//
// enum class MessageType : std::uint8_t
// {
// none = 0u,
// general = bitwise::bit(0u),
// validation = bitwise::bit(1u),
// performance = bitwise::bit(2u),
//
// all = general | validation | performance,
// };
//
// struct MessageData
// {
// std::string message;
// };
//
// using Callback_T = std::function<void(
// MessageSeverity message_severity,
// MessageType message_type,
// const MessageData &data,
// std::any &user_data
// )>;
//
// struct CreateInfo
// {
// MessageSeverity severities;
//
// MessageType types;
//
// Callback_T callback;
//
// std::any user_data;
// };
//
// [[nodiscard]] static auto create(Api target_api, class IInstance *instance, CreateInfo info)
// -> memory::Scope<IDebugger>;
//
// IDebugger() = default;
//
// virtual ~IDebugger() = default;
//
// IDebugger(IDebugger &&) = default;
//
// IDebugger(const IDebugger &) = delete;
//
// auto operator=(IDebugger &&) -> IDebugger & = default;
//
// auto operator=(const IDebugger &) -> IDebugger & = delete;
// };
class IDebugger
{
public:
enum class MessageSeverity : std::uint8_t
{
none = 0u,
verbose = bitwise::bit(0u),
info = bitwise::bit(1u),
warning = bitwise::bit(2u),
error = bitwise::bit(3u),
all = verbose | info | warning | error,
};
enum class MessageType : std::uint8_t
{
none = 0u,
general = bitwise::bit(0u),
validation = bitwise::bit(1u),
performance = bitwise::bit(2u),
all = general | validation | performance,
};
struct MessageData
{
std::string message;
};
using Callback_T = std::function<void(
MessageSeverity message_severity,
MessageType message_type,
const MessageData &data,
std::any &user_data
)>;
struct CreateInfo
{
MessageSeverity severities;
MessageType types;
Callback_T callback;
std::any user_data;
};
IDebugger() = default;
virtual ~IDebugger() = default;
};
} // namespace lt::renderer

94
modules/renderer/system.cppm
View file

@ -1,12 +1,22 @@
#pragma once
#include <app/system.hpp>
#include <ecs/entity.hpp>
#include <ecs/registry.hpp>
#include <memory/reference.hpp>
#include <memory/scope.hpp>
#include <renderer/api.hpp>
#include <renderer/frontend/messenger.hpp>
export module renderer.system;
import logger;
import debug.assertions;
import math.mat4;
import renderer.factory;
import app.system;
import surface.events;
import ecs.entity;
import ecs.registry;
import memory.reference;
import memory.scope;
import renderer.frontend;
import camera.components;
import surface.system;
import renderer.components;
import math.components;
import math.algebra;
import math.trig;
import std;
namespace lt::renderer {
@ -16,11 +26,8 @@ namespace lt::renderer {
* - Creating a rendering backend context (vk/dx/mt)
* - Connecting the context to the physical devices (select gpu, create surface, logical device)
* - Rendering the scene represented in registry via lt::renderer::components.
*
* @todo(Light): Add DirectX12 support
* @todo(Light): Add Metal support
*/
class System: public app::ISystem
export class System: public app::ISystem
{
public:
/** config.max_frames_in_flight should not be higher than this value. */
@ -33,7 +40,7 @@ public:
{
Api target_api;
uint32_t max_frames_in_flight;
std::uint32_t max_frames_in_flight;
};
struct CreateInfo
@ -44,7 +51,7 @@ public:
ecs::Entity surface_entity;
IMessenger::CreateInfo debug_callback_info;
IDebugger::CreateInfo debug_callback_info;
};
System(CreateInfo info);
@ -83,25 +90,25 @@ private:
ecs::Entity m_surface_entity;
memory::Scope<class IMessenger> m_messenger;
memory::Scope<IDebugger> m_messenger;
class IInstance *m_instance;
IInstance *m_instance;
memory::Scope<class ISurface> m_surface;
memory::Scope<ISurface> m_surface;
memory::Scope<class IGpu> m_gpu;
memory::Scope<IGpu> m_gpu;
memory::Scope<class IDevice> m_device;
memory::Scope<IDevice> m_device;
memory::Scope<class ISwapchain> m_swapchain;
memory::Scope<ISwapchain> m_swapchain;
memory::Scope<class IRenderer> m_renderer;
memory::Scope<IRenderer> m_renderer;
app::TickResult m_last_tick_result {};
uint32_t m_frame_idx {};
std::uint32_t m_frame_idx {};
uint32_t m_max_frames_in_flight {};
std::uint32_t m_max_frames_in_flight {};
};
} // namespace lt::renderer
@ -109,31 +116,15 @@ private:
module :private;
using namespace lt::renderer;
#include <camera/components.hpp>
#include <math/algebra.hpp>
#include <math/components/transform.hpp>
#include <renderer/components/messenger.hpp>
#include <renderer/components/sprite.hpp>
#include <renderer/frontend/context/device.hpp>
#include <renderer/frontend/context/gpu.hpp>
#include <renderer/frontend/context/instance.hpp>
#include <renderer/frontend/context/surface.hpp>
#include <renderer/frontend/context/swapchain.hpp>
#include <renderer/frontend/messenger.hpp>
#include <renderer/frontend/renderer/pass.hpp>
#include <renderer/frontend/renderer/renderer.hpp>
#include <renderer/system.hpp>
#include <surface/components.hpp>
System::System(CreateInfo info)
: m_surface_entity(info.surface_entity)
, m_api(info.config.target_api)
, m_registry(std::move(info.registry))
, m_instance(IInstance::get(m_api))
, m_instance(get_instance(m_api))
, m_max_frames_in_flight(info.config.max_frames_in_flight)
{
ensure(m_registry, "Failed to initialize renderer::System: null registry");
ensure(
debug::ensure(m_registry, "Failed to initialize renderer::System: null registry");
debug::ensure(
std::clamp(
info.config.max_frames_in_flight,
frames_in_flight_lower_limit,
@ -146,12 +137,13 @@ System::System(CreateInfo info)
frames_in_flight_upper_limit
);
m_messenger = IMessenger::create(m_api, m_instance, info.debug_callback_info);
m_surface = ISurface::create(m_api, m_instance, m_surface_entity);
m_gpu = IGpu::create(m_api, m_instance);
m_device = IDevice::create(m_api, m_gpu.get(), m_surface.get());
m_swapchain = ISwapchain::create(m_api, m_surface.get(), m_gpu.get(), m_device.get());
m_renderer = { IRenderer::create(
m_messenger = create_debugger(m_api, m_instance, info.debug_callback_info);
m_surface = create_surface(m_api, m_instance, m_surface_entity);
m_gpu = create_gpu(m_api, m_instance);
m_device = create_device(m_api, m_gpu.get(), m_surface.get());
m_swapchain = create_swapchain(m_api, m_surface.get(), m_gpu.get(), m_device.get());
m_renderer = { create_renderer(
m_api,
m_gpu.get(),
m_device.get(),
@ -191,7 +183,7 @@ void System::handle_surface_resized_events()
if (std::holds_alternative<surface::ResizedEvent>(event))
{
m_swapchain.reset();
m_swapchain = ISwapchain::create(m_api, m_surface.get(), m_gpu.get(), m_device.get());
m_swapchain = create_swapchain(m_api, m_surface.get(), m_gpu.get(), m_device.get());
m_renderer->replace_swapchain(m_swapchain.get());
// No need to process multiple resize events
@ -230,6 +222,6 @@ void System::recreate_swapchain()
{
log::trace("Re-creating swapchaain");
m_swapchain.reset();
m_swapchain = ISwapchain::create(m_api, m_surface.get(), m_gpu.get(), m_device.get());
m_swapchain = create_swapchain(m_api, m_surface.get(), m_gpu.get(), m_device.get());
m_renderer->replace_swapchain(m_swapchain.get());
}

76
modules/renderer/vk/api_wrapper.cppm
View file

@ -20,7 +20,7 @@ module;
#include <dlfcn.h>
#endif
export module renderer.backend.vk.library_wrapper;
export module renderer.vk.api_wrapper;
import memory.null_on_move;
import math.vec3;
import math.vec2;
@ -670,6 +670,7 @@ class Instance
public:
friend class Surface;
friend class Gpu;
friend class Messenger;
struct Layer
{
@ -717,6 +718,11 @@ public:
}
private:
[[nodiscard]] auto get_vk_handle() -> VkInstance
{
return m_instance;
}
memory::NullOnMove<VkInstance> m_instance {};
};
@ -2393,6 +2399,60 @@ private:
VkDeviceMemory m_memory {};
};
class Messenger
{
public:
enum SeverityFlagBits : std::underlying_type_t<VkDebugUtilsMessageSeverityFlagBitsEXT>
{
verbose = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT,
info = VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT,
warning = VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT,
error = VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT,
};
enum TypeFlagBits : std::underlying_type_t<VkDebugUtilsMessageTypeFlagBitsEXT>
{
general = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT,
validation = VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT,
performance = VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT,
binding = VK_DEBUG_UTILS_MESSAGE_TYPE_DEVICE_ADDRESS_BINDING_BIT_EXT,
};
struct MessageData
{
std::string message;
};
using Callback = std::function<void(Flags, Flags, MessageData, void *)>;
struct CreateInfo
{
Callback user_callback;
void *user_data;
Flags enabled_types;
Flags enabled_severities;
};
Messenger() = default;
Messenger(Instance &instance, CreateInfo info);
~Messenger();
Messenger(Messenger &&) = default;
Messenger(const Messenger &) = delete;
auto operator=(Messenger &&) -> Messenger & = default;
auto operator=(const Messenger &) -> Messenger & = delete;
private:
memory::NullOnMove<VkInstance> m_instance {};
VkDebugUtilsMessengerEXT m_messenger {};
};
} // namespace lt::renderer::vk
@ -4106,6 +4166,20 @@ Pipeline::~Pipeline()
{
}
Messenger::Messenger(Instance &instance, CreateInfo info): m_instance(instance.get_vk_handle())
{
auto vk_info = VkDebugUtilsMessengerCreateInfoEXT {
};
vkc(api::create_debug_messenger(m_instance, &vk_info, nullptr, &m_messenger));
}
Messenger::~Messenger()
{
api::destroy_debug_messenger(m_instance, m_messenger, nullptr);
}
[[nodiscard]]
auto enumerate_instance_extension_properties() -> std::vector<VkExtensionProperties>
{

8
modules/renderer/vk/buffer.cppm
View file

@ -1,7 +1,7 @@
export module renderer.backend.vk.buffer;
import renderer.backend.vk.device;
import renderer.backend.vk.gpu;
import renderer.backend.vk.library_wrapper;
export module renderer.vk.buffer;
import renderer.vk.device;
import renderer.vk.gpu;
import renderer.vk.api_wrapper;
import renderer.frontend;
import std;

316
modules/renderer/vk/debugger.cppm
View file

@ -1,40 +1,29 @@
export module renderer.backends.vk.messenger;
export module renderer.vk.debugger;
import renderer.vk.instance;
import renderer.frontend;
import renderer.vk.api_wrapper;
import memory.null_on_move;
import renderer.backends.vk.instance;
import renderer.backends.vk.raii;
import renderer.backends.vk.library;
import debug.assertions;
import logger;
import std;
namespace lt::renderer::vkb {
namespace lt::renderer::vk {
class Messenger: public IMessenger
export class Debugger: public IDebugger
{
public:
Messenger(IInstance *instance, CreateInfo info);
Debugger(IInstance *instance, CreateInfo info);
private:
static auto native_callback(
VkDebugUtilsMessageSeverityFlagBitsEXT severity,
VkDebugUtilsMessageTypeFlagsEXT type,
const VkDebugUtilsMessengerCallbackDataEXT *callback_data,
void *vulkan_user_data
) -> VkBool32;
static void native_callback(
vk::Flags severity,
vk::Flags types,
vk::Messenger::MessageData data,
void *user_data
);
[[nodiscard]] static auto to_native_severity(MessageSeverity severity)
-> VkDebugUtilsMessageSeverityFlagsEXT;
[[nodiscard]] static auto from_native_severity(VkDebugUtilsMessageSeverityFlagsEXT severity)
-> MessageSeverity;
[[nodiscard]] static auto to_native_type(MessageType type) -> VkDebugUtilsMessageTypeFlagsEXT;
[[nodiscard]] static auto from_native_type(VkDebugUtilsMessageTypeFlagsEXT type) -> MessageType;
class Instance *m_instance {};
raii::DebugMessenger m_debug_messenger;
vk::Messenger m_messenger;
MessageSeverity m_severities {};
@ -45,48 +34,137 @@ private:
std::any m_user_data;
};
} // namespace lt::renderer::vk
} // namespace lt::renderer::vkb
module :private;
using namespace lt::renderer::vk;
using namespace lt::renderer;
using namespace lt::renderer::vkb;
import logger;
Messenger::Messenger(IInstance *instance, CreateInfo info)
: m_instance(static_cast<Instance *>(instance))
, m_user_data(std::move(info.user_data))
, m_user_callback(std::move(info.callback))
, m_debug_messenger(
m_instance,
VkDebugUtilsMessengerCreateInfoEXT {
.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT,
.messageSeverity = to_native_severity(info.severities),
.messageType = to_native_type(info.types),
.pfnUserCallback = &native_callback,
.pUserData = this,
}
)
[[nodiscard]] auto to_native_severity(IDebugger::MessageSeverity severity) -> vk::Flags
{
const auto value = std::to_underlying(severity);
auto flags = vk::Flags {};
using enum IDebugger::MessageSeverity;
using NativeSeverity = vk::Messenger::SeverityFlagBits;
if (value & std::to_underlying(error))
{
flags |= NativeSeverity::error;
}
if (value & std::to_underlying(warning))
{
flags |= NativeSeverity::warning;
}
if (value & std::to_underlying(info))
{
flags |= NativeSeverity::info;
}
if (value & std::to_underlying(verbose))
{
flags |= NativeSeverity::verbose;
}
return flags;
}
/*static*/ auto Messenger::native_callback(
VkDebugUtilsMessageSeverityFlagBitsEXT severity,
VkDebugUtilsMessageTypeFlagsEXT type,
const VkDebugUtilsMessengerCallbackDataEXT *callback_data,
void *vulkan_user_data
) -> VkBool32
[[nodiscard]] /* static */ auto to_native_type(IDebugger::MessageType type) -> vk::Flags
{
const auto value = std::to_underlying(type);
auto flags = vk::Flags {};
using enum IDebugger::MessageType;
using NativeType = vk::Messenger::TypeFlagBits;
if (value & std::to_underlying(general))
{
flags |= NativeType::general;
}
if (value & std::to_underlying(validation))
{
flags |= NativeType::validation;
}
if (value & std::to_underlying(performance))
{
flags |= NativeType::performance;
}
return flags;
}
[[nodiscard]] auto from_native_type(vk::Flags type) -> IDebugger::MessageType
{
auto flags = std::underlying_type_t<IDebugger::MessageType> {};
using enum IDebugger::MessageType;
using NativeType = vk::Messenger::TypeFlagBits;
if (type & NativeType::general)
{
flags |= std::to_underlying(general);
}
if (type & NativeType::validation)
{
flags |= std::to_underlying(validation);
}
if (type & NativeType::performance)
{
flags |= std::to_underlying(performance);
}
return static_cast<IDebugger::MessageType>(flags);
}
[[nodiscard]] auto from_native_severity(vk::Flags severity) -> IDebugger::MessageSeverity
{
auto flags = std::underlying_type_t<IDebugger::MessageSeverity> {};
using enum IDebugger::MessageSeverity;
using NativeSeverity = vk::Messenger::SeverityFlagBits;
if (severity & NativeSeverity::error)
{
flags |= std::to_underlying(error);
}
if (severity & NativeSeverity::warning)
{
flags |= std::to_underlying(warning);
}
if (severity & NativeSeverity::info)
{
flags |= std::to_underlying(info);
}
if (severity & NativeSeverity::verbose)
{
flags |= std::to_underlying(verbose);
}
return static_cast<IDebugger::MessageSeverity>(flags);
}
void Debugger::native_callback(
vk::Flags severity,
vk::Flags types,
vk::Messenger::MessageData data,
void *user_data
)
{
try
{
ensure(vulkan_user_data, "Null vulkan_user_data received in messenger callback");
debug::ensure(user_data, "Null vulkan_user_data received in messenger callback");
auto *messenger = std::bit_cast<vk::Messenger *>(vulkan_user_data);
auto *messenger = std::bit_cast<Debugger *>(user_data);
messenger->m_user_callback(
from_native_severity(severity),
from_native_type(type),
from_native_type(types),
{
.message = callback_data->pMessage,
.message = data.message,
},
messenger->m_user_data
);
@ -96,119 +174,19 @@ Messenger::Messenger(IInstance *instance, CreateInfo info)
log::error("Uncaught exception in messenger callback:");
log::error("\twhat: {}", exp.what());
}
return VK_FALSE;
}
[[nodiscard]] /*static*/ auto Messenger::to_native_severity(MessageSeverity severity)
-> VkDebugUtilsMessageSeverityFlagsEXT
Debugger::Debugger(IInstance *instance, CreateInfo info)
: m_user_data(std::move(info.user_data))
, m_user_callback(std::move(info.callback))
, m_messenger(
static_cast<Instance *>(instance)->vk(),
vk::Messenger::CreateInfo {
.user_callback = &native_callback,
.user_data = this,
.enabled_types = to_native_type(info.types),
.enabled_severities = to_native_severity(info.severities),
}
)
{
using enum MessageSeverity;
const auto value = std::to_underlying(severity);
auto flags = VkDebugUtilsMessageSeverityFlagsEXT {};
if (value & std::to_underlying(error))
{
flags |= VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
}
if (value & std::to_underlying(warning))
{
flags |= VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT;
}
if (value & std::to_underlying(info))
{
flags |= VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT;
}
if (value & std::to_underlying(verbose))
{
flags |= VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT;
}
return flags;
}
[[nodiscard]] /*static*/ auto Messenger::from_native_severity(
VkDebugUtilsMessageSeverityFlagsEXT severity
) -> MessageSeverity
{
using enum MessageSeverity;
auto flags = std::underlying_type_t<MessageSeverity> {};
if (severity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT)
{
flags |= std::to_underlying(error);
}
if (severity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT)
{
flags |= std::to_underlying(warning);
}
if (severity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT)
{
flags |= std::to_underlying(info);
}
if (severity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT)
{
flags |= std::to_underlying(verbose);
}
return static_cast<MessageSeverity>(flags);
}
[[nodiscard]] /*static*/ auto Messenger::to_native_type(MessageType type)
-> VkDebugUtilsMessageTypeFlagsEXT
{
using enum MessageType;
const auto value = std::to_underlying(type);
auto flags = VkDebugUtilsMessageTypeFlagsEXT {};
if (value & std::to_underlying(general))
{
flags |= VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT;
}
if (value & std::to_underlying(validation))
{
flags |= VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT;
}
if (value & std::to_underlying(performance))
{
flags |= VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT;
}
return flags;
}
[[nodiscard]] /* static */ auto Messenger::from_native_type(VkDebugUtilsMessageTypeFlagsEXT type)
-> MessageType
{
using enum MessageType;
auto flags = std::underlying_type_t<MessageType> {};
if (type & VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT)
{
flags |= std::to_underlying(general);
}
if (type & VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT)
{
flags |= std::to_underlying(validation);
}
if (type & VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT)
{
flags |= std::to_underlying(general);
}
return static_cast<MessageType>(flags);
}

10
modules/renderer/vk/device.cppm
View file

@ -1,12 +1,12 @@
export module renderer.backend.vk.device;
export module renderer.vk.device;
import memory.null_on_move;
import logger;
import debug.assertions;
import renderer.backend.vk.instance;
import renderer.vk.instance;
import renderer.frontend;
import renderer.backend.vk.library_wrapper;
import renderer.backend.vk.gpu;
import renderer.backend.vk.surface;
import renderer.vk.api_wrapper;
import renderer.vk.gpu;
import renderer.vk.surface;
import std;

6
modules/renderer/vk/gpu.cppm
View file

@ -1,8 +1,8 @@
export module renderer.backend.vk.gpu;
import renderer.backend.vk.library_wrapper;
export module renderer.vk.gpu;
import renderer.vk.api_wrapper;
import debug.assertions;
import renderer.frontend;
import renderer.backend.vk.instance;
import renderer.vk.instance;
import memory.null_on_move;
import std;

5
modules/renderer/vk/instance.cppm
View file

@ -1,8 +1,7 @@
export module renderer.backend.vk.instance;
export module renderer.vk.instance;
import debug.assertions;
import renderer.frontend;
import renderer.backend.vk.library_wrapper;
// import renderer.backend.vk.library_loader;
import renderer.vk.api_wrapper;
import std;
namespace lt::renderer::vkb {

6
modules/renderer/vk/pass.cppm
View file

@ -1,8 +1,8 @@
export module renderer.vk.pass;
import renderer.data;
import renderer.backend.vk.library_wrapper;
import renderer.backend.vk.device;
import renderer.backend.vk.swapchain;
import renderer.vk.api_wrapper;
import renderer.vk.device;
import renderer.vk.swapchain;
import assets.shader;
import assets.metadata;
import memory.null_on_move;

10
modules/renderer/vk/renderer.cppm
View file

@ -1,15 +1,15 @@
export module renderer.vk.renderer;
import assets.shader;
import debug.assertions;
import renderer.backend.vk.library_wrapper;
import renderer.vk.api_wrapper;
import memory.reference;
import memory.null_on_move;
import renderer.backend.vk.device;
import renderer.vk.device;
import math.vec2;
import math.components;
import renderer.backend.vk.swapchain;
import renderer.vk.swapchain;
import renderer.components;
import renderer.backend.vk.buffer;
import renderer.vk.buffer;
import renderer.vk.pass;
import renderer.data;
import renderer.frontend;
@ -49,7 +49,7 @@ private:
std::uint32_t m_max_frames_in_flight {};
memory::NullOnMove<Device *> m_device {};
Device * m_device {};
Swapchain *m_swapchain {};

6
modules/renderer/vk/surface.cppm
View file

@ -1,4 +1,4 @@
export module renderer.backend.vk.surface;
export module renderer.vk.surface;
import debug.assertions;
import ecs.entity;
import ecs.registry;
@ -6,8 +6,8 @@ import memory.null_on_move;
import math.vec2;
import surface.system;
import renderer.frontend;
import renderer.backend.vk.instance;
import renderer.backend.vk.library_wrapper;
import renderer.vk.instance;
import renderer.vk.api_wrapper;
namespace lt::renderer::vkb {

12
modules/renderer/vk/swapchain.cppm
View file

@ -1,9 +1,9 @@
export module renderer.backend.vk.swapchain;
import renderer.backend.vk.library_wrapper;
import renderer.backend.vk.surface;
import renderer.backend.vk.device;
import renderer.backend.vk.instance;
import renderer.backend.vk.gpu;
export module renderer.vk.swapchain;
import renderer.vk.api_wrapper;
import renderer.vk.surface;
import renderer.vk.device;
import renderer.vk.instance;
import renderer.vk.gpu;
import renderer.frontend;
import math.vec2;
import memory.null_on_move;

2
modules/time/timer.cppm
View file

@ -23,7 +23,7 @@ private:
Timepoint m_start;
};
} // namespace lt
} // namespace lt::time
module :private;
using namespace lt::time;

100
tools/ci/amd64/Dockerfile
View file

@ -310,6 +310,14 @@ export CXXFLAGS="\
-D CMAKE_INSTALL_PREFIX=/opt/llvm-msan \
&& ninja -C $build_path install
# Cache debuginfo symbols downloaded when running valgrind
RUN \
git clone https://git.light7734.com/light7734/light.git --depth=1 \
&& cd ./light/tools/ci/amd64/gcc/ \
&& ./valgrind.sh
# && cmake \
# -G Ninja \
# -S $llvm/llvm \
@ -335,52 +343,52 @@ export CXXFLAGS="\
# \
# && ninja -C $build_clang
RUN \
cd /mesa \
&& export CXX='clang++' \
&& export CC='clang' \
&& export CFLAGS="-fsanitize=memory -fsanitize-memory-track-origins -fno-omit-frame-pointer -g" \
&& export CXXFLAGS="-fsanitize=memory -fsanitize-memory-track-origins -fno-omit-frame-pointer -g -nostdinc++ -isystem /libcxx_msan/include/c++/v1/" \
&& export LDFLAGS="-fsanitize=memory -fsanitize-memory-track-origins -g -L/libcxx_msan/lib -Wl,-rpath,/libcxx_msan/lib -L/msan/lib -Wl,-rpath,/msan/lib -lc++ -lc++abi" \
&& export PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:$PATH" \
&& meson setup ./ _build \
-D build-tests=false \
-D enable-glcpp-tests=false \
-D build-radv-tests=false \
-D build-aco-tests=false \
-D install-intel-gpu-tests=false \
-D gallium-mediafoundation-test=false \
-D android-libbacktrace=disabled \
-D split-debug=disabled \
-D b_ndebug=true \
-D b_lto=false \
-D egl=enabled \
-D gallium-drivers=r300,r600,radeonsi,nouveau,virgl,svga,softpipe,llvmpipe,i915,iris,crocus,zink \
-D gallium-extra-hud=true \
-D gallium-rusticl=true \
-D gallium-va=enabled \
-D gbm=enabled \
-D gles1=disabled \
-D gles2=enabled \
-D glvnd=enabled \
-D glx=dri \
-D libunwind=enabled \
-D llvm=enabled \
-D lmsensors=disabled \
-D microsoft-clc=disabled \
-D platforms=x11,wayland \
-D valgrind=disabled \
-D video-codecs=all \
-D vulkan-drivers=amd,intel,intel_hasvk,swrast,virtio,nouveau \
-D vulkan-layers=device-select,intel-nullhw,overlay \
-D tools='' \
-D zstd=enabled \
-D buildtype=plain \
-D prefix=/usr \
-D sysconfdir=/etc \
--wrap-mode=nofallback \
--force-fallback-for=syn,paste,rustc-hash \
&& ninja -C _build
# RUN \
# cd /mesa \
# && export CXX='clang++' \
# && export CC='clang' \
# && export CFLAGS="-fsanitize=memory -fsanitize-memory-track-origins -fno-omit-frame-pointer -g" \
# && export CXXFLAGS="-fsanitize=memory -fsanitize-memory-track-origins -fno-omit-frame-pointer -g -nostdinc++ -isystem /libcxx_msan/include/c++/v1/" \
# && export LDFLAGS="-fsanitize=memory -fsanitize-memory-track-origins -g -L/libcxx_msan/lib -Wl,-rpath,/libcxx_msan/lib -L/msan/lib -Wl,-rpath,/msan/lib -lc++ -lc++abi" \
# && export PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:$PATH" \
# && meson setup ./ _build \
# -D build-tests=false \
# -D enable-glcpp-tests=false \
# -D build-radv-tests=false \
# -D build-aco-tests=false \
# -D install-intel-gpu-tests=false \
# -D gallium-mediafoundation-test=false \
# -D android-libbacktrace=disabled \
# -D split-debug=disabled \
# -D b_ndebug=true \
# -D b_lto=false \
# -D egl=enabled \
# -D gallium-drivers=r300,r600,radeonsi,nouveau,virgl,svga,softpipe,llvmpipe,i915,iris,crocus,zink \
# -D gallium-extra-hud=true \
# -D gallium-rusticl=true \
# -D gallium-va=enabled \
# -D gbm=enabled \
# -D gles1=disabled \
# -D gles2=enabled \
# -D glvnd=enabled \
# -D glx=dri \
# -D libunwind=enabled \
# -D llvm=enabled \
# -D lmsensors=disabled \
# -D microsoft-clc=disabled \
# -D platforms=x11,wayland \
# -D valgrind=disabled \
# -D video-codecs=all \
# -D vulkan-drivers=amd,intel,intel_hasvk,swrast,virtio,nouveau \
# -D vulkan-layers=device-select,intel-nullhw,overlay \
# -D tools='' \
# -D zstd=enabled \
# -D buildtype=plain \
# -D prefix=/usr \
# -D sysconfdir=/etc \
# --wrap-mode=nofallback \
# --force-fallback-for=syn,paste,rustc-hash \
# && ninja -C _build
# RUN cd mesa/ \
# && source '/1.4.328.1/setup-env.sh' \

132
tools/cmake/functions.cmake
View file

@ -1,39 +1,55 @@
function(add_library_module libname)
set(PUBLIC_INCLUDE_DIR "${CMAKE_CURRENT_BINARY_DIR}/public_includes")
file(MAKE_DIRECTORY "${PUBLIC_INCLUDE_DIR}")
file(CREATE_LINK "${CMAKE_CURRENT_SOURCE_DIR}/public/"
"${PUBLIC_INCLUDE_DIR}/${libname}" SYMBOLIC)
function(add_library_module)
cmake_parse_arguments(
ARGS
""
"NAME"
"INTERFACES;ROOT_DIR;PRIVATE_INTERFACES;SOURCES;DEPENDENCIES;PRIVATE_DEPENDENCIES"
${ARGN}
)
if("${ARGN}" STREQUAL "") # Header only library
message("Adding INTERFACE library ${libname}")
add_library(${libname} INTERFACE)
target_include_directories(${libname} INTERFACE ${PUBLIC_INCLUDE_DIR})
target_link_libraries(${libname} INTERFACE std)
else() # Compiled library
set(source_files)
set(source_directory "${CMAKE_CURRENT_SOURCE_DIR}/private")
foreach(source_file ${ARGN})
list(APPEND source_files "${source_directory}/${source_file}")
endforeach()
message("Adding library ${libname} with source files: ${source_files}")
add_library(${libname} ${source_files})
set(PRIVATE_INCLUDE_DIR "${CMAKE_CURRENT_BINARY_DIR}/private_includes")
file(MAKE_DIRECTORY "${PRIVATE_INCLUDE_DIR}")
file(CREATE_LINK "${CMAKE_CURRENT_SOURCE_DIR}/private/"
"${PRIVATE_INCLUDE_DIR}/${libname}" SYMBOLIC)
target_include_directories(
${libname}
PUBLIC ${PUBLIC_INCLUDE_DIR}
PRIVATE ${PRIVATE_INCLUDE_DIR})
target_link_libraries(${libname} PUBLIC std)
if(NOT ARGS_NAME)
message(FATAL_ERROR "You must provide a name")
endif()
add_library(${ARGS_NAME})
set(module_directory "${CMAKE_CURRENT_SOURCE_DIR}/${ARGS_NAME}")
if(ARGS_ROOT_DIR)
set(module_directory "${ARGS_ROOT_DIR}")
endif()
if(ARGS_SOURCES)
set(files)
foreach(file ${ARGS_SOURCES})
list(APPEND files "${module_directory}/${file}")
endforeach()
target_sources(${ARGS_NAME} PRIVATE ${files})
endif()
if(ARGS_INTERFACES)
set(files)
foreach(file ${ARGS_INTERFACES})
list(APPEND files "${module_directory}/${file}")
endforeach()
target_sources(
${ARGS_NAME} PUBLIC FILE_SET public_cxx_modules TYPE CXX_MODULES
FILES ${files}
)
endif()
if(ARGS_PRIVATE_INTERFACES)
set(files)
foreach(file ${ARGS_PRIVATE_INTERFACES})
list(APPEND files "${module_directory}/${file}")
endforeach()
target_sources(
${ARGS_NAME} PRIVATE FILE_SET private_cxx_modules TYPE CXX_MODULES
FILES ${files}
)
endif()
target_link_libraries(${ARGS_NAME} PUBLIC ${ARGS_DEPENDENCIES})
target_link_libraries(${ARGS_NAME} PRIVATE ${ARGS_PRIVATE_DEPENDENCIES})
endfunction()
function(add_executable_module exename)
@ -48,22 +64,28 @@ function(add_executable_module exename)
set(PUBLIC_INCLUDE_DIR "${CMAKE_CURRENT_BINARY_DIR}/public_includes")
file(MAKE_DIRECTORY "${PUBLIC_INCLUDE_DIR}")
file(CREATE_LINK "${CMAKE_CURRENT_SOURCE_DIR}/public/"
"${PUBLIC_INCLUDE_DIR}/${exename}" SYMBOLIC)
"${PUBLIC_INCLUDE_DIR}/${exename}" SYMBOLIC
)
set(PRIVATE_INCLUDE_DIR "${CMAKE_CURRENT_BINARY_DIR}/private_includes")
file(MAKE_DIRECTORY "${PRIVATE_INCLUDE_DIR}")
file(CREATE_LINK "${CMAKE_CURRENT_SOURCE_DIR}/private/"
"${PRIVATE_INCLUDE_DIR}${exename}" SYMBOLIC)
"${PRIVATE_INCLUDE_DIR}${exename}" SYMBOLIC
)
add_executable(${exename} ${source_files})
target_link_libraries(${exename} PRIVATE std)
target_include_directories(${exename} PRIVATE ${PUBLIC_INCLUDE_DIR}
${PRIVATE_INCLUDE_DIR})
endfunction()
function(add_test_module target_lib_name)
if(NOT ${ENABLE_UNIT_TESTS})
# if(NOT ${ENABLE_UNIT_TESTS}) return() endif()
add_executable(${target_lib_name}_tests ${ARGN})
target_link_libraries(
${target_lib_name}_tests
PRIVATE ${target_lib_name}
#
test
)
return()
endif()
set(source_files)
set(source_directory "${CMAKE_CURRENT_SOURCE_DIR}/private")
@ -78,19 +100,23 @@ function(add_test_module target_lib_name)
set(PUBLIC_INCLUDE_DIR "${CMAKE_CURRENT_BINARY_DIR}/public_includes")
file(MAKE_DIRECTORY "${PUBLIC_INCLUDE_DIR}")
file(CREATE_LINK "${CMAKE_CURRENT_SOURCE_DIR}/public/"
"${PUBLIC_INCLUDE_DIR}/${target_lib_name}" SYMBOLIC)
"${PUBLIC_INCLUDE_DIR}/${target_lib_name}" SYMBOLIC
)
set(PRIVATE_INCLUDE_DIR "${CMAKE_CURRENT_BINARY_DIR}/private_includes")
file(MAKE_DIRECTORY "${PRIVATE_INCLUDE_DIR}")
file(CREATE_LINK "${CMAKE_CURRENT_SOURCE_DIR}/private/"
"${PRIVATE_INCLUDE_DIR}/${target_lib_name}" SYMBOLIC)
"${PRIVATE_INCLUDE_DIR}/${target_lib_name}" SYMBOLIC
)
add_executable(${target_lib_name}_tests ${source_files})
target_link_libraries(${target_lib_name}_tests PRIVATE ${target_lib_name}
std test)
target_link_libraries(
${target_lib_name}_tests PRIVATE ${target_lib_name} std test
)
target_include_directories(
${target_lib_name}_tests
PRIVATE ${PUBLIC_INCLUDE_DIR}
PRIVATE ${PRIVATE_INCLUDE_DIR})
PRIVATE ${PRIVATE_INCLUDE_DIR}
)
endfunction()
function(add_fuzz_module target_lib_name)
@ -111,21 +137,25 @@ function(add_fuzz_module target_lib_name)
set(PUBLIC_INCLUDE_DIR "${CMAKE_CURRENT_BINARY_DIR}/public_includes")
file(MAKE_DIRECTORY "${PUBLIC_INCLUDE_DIR}")
file(CREATE_LINK "${CMAKE_CURRENT_SOURCE_DIR}/public/"
"${PUBLIC_INCLUDE_DIR}/${target_lib_name}" SYMBOLIC)
"${PUBLIC_INCLUDE_DIR}/${target_lib_name}" SYMBOLIC
)
set(PRIVATE_INCLUDE_DIR "${CMAKE_CURRENT_BINARY_DIR}/private_includes")
file(MAKE_DIRECTORY "${PRIVATE_INCLUDE_DIR}")
file(CREATE_LINK "${CMAKE_CURRENT_SOURCE_DIR}/private/"
"${PRIVATE_INCLUDE_DIR}/${target_lib_name}" SYMBOLIC)
"${PRIVATE_INCLUDE_DIR}/${target_lib_name}" SYMBOLIC
)
add_executable(${target_lib_name}_fuzz ${source_files})
target_link_libraries(${target_lib_name}_fuzz PRIVATE ${target_lib_name}
std fuzz_test)
target_link_libraries(
${target_lib_name}_fuzz PRIVATE ${target_lib_name} std fuzz_test
)
target_link_options(${target_lib_name}_fuzz PRIVATE -fsanitize=fuzzer)
target_compile_options(${target_lib_name}_fuzz PRIVATE -fsanitize=fuzzer)
target_include_directories(
${target_lib_name}_fuzz
PRIVATE ${PUBLIC_INCLUDE_DIR}
PRIVATE ${PRIVATE_INCLUDE_DIR})
PRIVATE ${PRIVATE_INCLUDE_DIR}
)
endfunction()
function(add_option option help)

20
tools/cmake/options.cmake
View file

@ -1,13 +1,17 @@
add_option(ENABLE_UNIT_TESTS "Enables the building of the unit test modules")
add_option(ENABLE_FUZZ_TESTS "Enables the building of the fuzz test modules")
add_option(ENABLE_STATIC_ANALYSIS
"Makes the clang-tidy checks mandatory for compilation")
add_option(ENABLE_LLVM_COVERAGE
"Enables the code coverage instrumentation for clang")
add_option(
ENABLE_STATIC_ANALYSIS
"Makes the clang-tidy checks mandatory for compilation"
)
add_option(
ENABLE_LLVM_COVERAGE "Enables the code coverage instrumentation for clang"
)
if(ENABLE_STATIC_ANALYSIS)
set(CMAKE_CXX_CLANG_TIDY
"clang-tidy;--warnings-as-errors=*;--allow-no-checks")
"clang-tidy;--warnings-as-errors=*;--allow-no-checks"
)
endif()
if(ENABLE_LLVM_COVERAGE)
@ -15,7 +19,8 @@ if(ENABLE_LLVM_COVERAGE)
if(NOT "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
message(
FATAL_ERROR "ENABLE_LLVM_COVERAGE only supports the clang compiler")
FATAL_ERROR "ENABLE_LLVM_COVERAGE only supports the clang compiler"
)
endif()
# Check for libc++
@ -28,7 +33,8 @@ if(ENABLE_LLVM_COVERAGE)
#error Not using libc++
#endif
"
USING_LIBCXX)
USING_LIBCXX
)
if(NOT USING_LIBCXX)
message(
FATAL_ERROR