kbz_8/MacroLibX
1
0
Fork 0
mirror of https://github.com/seekrs/MacroLibX.git synced 2026-01-11 14:43:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

begenning the refactor

Browse Source
This commit is contained in:
kbz_8
2024-03-27 23:03:54 +01:00
parent e5ff232065
commit 6bbf1e196d
131 changed files with 2135 additions and 1192 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
Makefile
View File

@@ -6,22 +6,23 @@
# By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ # # By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ #
# +#+#+#+#+#+ +#+ # # +#+#+#+#+#+ +#+ #
# Created: 2022/10/04 16:43:41 by maldavid #+# #+# # # Created: 2022/10/04 16:43:41 by maldavid #+# #+# #
# Updated: 2024/03/25 18:57:44 by maldavid ### ########.fr # # Updated: 2024/03/27 21:30:44 by maldavid ### ########.fr #
# # # #
# **************************************************************************** # # **************************************************************************** #
NAME = libmlx.so NAME = libmlx.so
SRCS = $(wildcard $(addsuffix /*.cpp, ./src/core)) SRCS = $(wildcard $(addsuffix /*.cpp, ./runtime/Sources/Core))
SRCS += $(wildcard $(addsuffix /*.cpp, ./src/platform)) SRCS += $(wildcard $(addsuffix /*.cpp, ./runtime/Sources/Platform))
SRCS += $(wildcard $(addsuffix /*.cpp, ./src/renderer)) SRCS += $(wildcard $(addsuffix /*.cpp, ./runtime/Sources/Renderer))
SRCS += $(wildcard $(addsuffix /*.cpp, ./src/renderer/**)) SRCS += $(wildcard $(addsuffix /*.cpp, ./runtime/Sources/Renderer/**))
SRCS += $(wildcard $(addsuffix /*.cpp, ./runtime/Sources/Drivers/**))
OBJ_DIR = objs/makefile OBJ_DIR = objs/makefile
OBJS = $(addprefix $(OBJ_DIR)/, $(SRCS:.cpp=.o)) OBJS = $(addprefix $(OBJ_DIR)/, $(SRCS:.cpp=.o))
PCH = ./src/pre_compiled.h PCH = ./runtime/Includes/PreCompiled.h
GCH = ./src/pre_compiled.h.gch GCH = ./runtime/Includes/PreCompiled.h.gch
OS = $(shell uname -s) OS = $(shell uname -s)
DEBUG ?= false DEBUG ?= false
@@ -30,13 +31,14 @@ IMAGES_OPTIMIZED ?= true
FORCE_INTEGRATED_GPU ?= false FORCE_INTEGRATED_GPU ?= false
GRAPHICS_MEMORY_DUMP ?= false GRAPHICS_MEMORY_DUMP ?= false
PROFILER ?= false PROFILER ?= false
LEGACY ?= false
MODE = "release" MODE = "release"
CXX = clang++ CXX = clang++
CXXFLAGS = -std=c++17 -O3 -fPIC -Wall -Wextra -Wno-deprecated -DSDL_MAIN_HANDLED CXXFLAGS = -std=c++17 -O3 -fPIC -Wall -Wextra -Wno-deprecated -DSDL_MAIN_HANDLED
INCLUDES = -I./includes -I./src -I./third_party INCLUDES = -I./includes -I./runtime/Includes -I./third_party
LDLIBS = LDLIBS =
@@ -71,6 +73,10 @@ ifeq ($(PROFILER), true)
CXXFLAGS += -D PROFILER CXXFLAGS += -D PROFILER
endif endif
ifeq ($(LEGACY), true)
CXXFLAGS += -D LEGACY
endif
RM = rm -rf RM = rm -rf
$(OBJ_DIR)/%.o: %.cpp $(GCH) $(OBJ_DIR)/%.o: %.cpp $(GCH)

12
includes/mlx_profile.h
View File

@@ -6,7 +6,7 @@
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */ /* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2023/11/10 08:49:17 by maldavid #+# #+# */ /* Created: 2023/11/10 08:49:17 by maldavid #+# #+# */
/* Updated: 2024/01/03 15:33:35 by maldavid ### ########.fr */ /* Updated: 2024/03/27 18:25:59 by maldavid ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@@ -138,6 +138,16 @@
#endif #endif
#endif #endif
#if !defined(MLX_FORCEINLINE)
#if defined(MLX_COMPILER_CLANG) || defined(MLX_COMPILER_GCC)
#define MLX_FORCEINLINE __attribute__((always_inline)) inline
#elif defined(MLX_COMPILER_MSVC)
#define MLX_FORCEINLINE __forceinline
#else
#define MLX_FORCEINLINE inline
#endif
#endif
// Checking common assumptions // Checking common assumptions
#ifdef __cplusplus #ifdef __cplusplus
#include <climits> #include <climits>

71
runtime/Includes/Core/Application.h git.filemode.normal_file
View File

@@ -0,0 +1,71 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* Application.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/04 21:49:46 by maldavid #+# #+# */
/* Updated: 2024/03/27 21:00:53 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_APPLICATION__
#define __MLX_APPLICATION__
#include <Core/Graphics.h>
#include <Platform/Inputs.h>
#include <Core/Fps.h>
namespace mlx
{
class Application
{
public:
Application();
inline void GetMousePos(int* x, int* y) noexcept;
inline void MouseMove(void* win, int x, int y) noexcept;
inline void OnEvent(void* win, int event, int (*funct_ptr)(int, void*), void* param) noexcept;
inline void GetScreenSize(void* win, int* w, int* h) noexcept;
inline void SetFPSCap(std::uint32_t fps) noexcept;
inline void* NewGraphicsSuport(std::size_t w, std::size_t h, const char* title);
inline void ClearGraphicsSupport(void* win);
inline void DestroyGraphicsSupport(void* win);
inline void PixelPut(void* win, int x, int y, std::uint32_t color) const noexcept;
inline void StringPut(void* win, int x, int y, std::uint32_t color, char* str);
void* NewTexture(int w, int h);
void* NewStbTexture(char* file, int* w, int* h); // stb textures are image files (png, jpg, bpm, ...)
inline void TexturePut(void* win, void* img, int x, int y);
inline int GetTexturePixel(void* img, int x, int y);
inline void SetTexturePixel(void* img, int x, int y, std::uint32_t color);
void DestroyTexture(void* ptr);
inline void LoopHook(int (*f)(void*), void* param);
inline void LoopEnd() noexcept;
inline void LoadFont(void* win, const std::filesystem::path& filepath, float scale);
void Run() noexcept;
~Application();
private:
FpsManager m_fps;
std::list<Texture> m_textures;
std::vector<std::unique_ptr<GraphicsSupport>> m_graphics;
std::function<int(void*)> f_loop_hook;
std::unique_ptr<Input> p_in;
void* p_param = nullptr;
};
}
#include <core/application.inl>
#endif // __MLX_APPLICATION__

196
runtime/Includes/Core/Application.inl git.filemode.normal_file
View File

@@ -0,0 +1,196 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* application.inl :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/04 21:49:46 by maldavid #+# #+# */
/* Updated: 2023/04/02 14:56:27 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#include <Core/Application.h>
#define CHECK_WINDOW_PTR(win) \
if(win == nullptr) \
{ \
Error("invalid window ptr (NULL)"); \
return; \
} \
else if(*static_cast<int*>(win) < 0 || *static_cast<int*>(win) > static_cast<int>(_graphics.size()))\
{ \
Error("invalid window ptr"); \
return; \
} else {}
#define CHECK_IMAGE_PTR(img, retval) \
if(img == nullptr) \
{ \
Error("invalid image ptr (NULL)"); \
retval; \
} \
else if(std::find_if(_textures.begin(), _textures.end(), [=](const Texture& texture) \
{ \
return &texture == img; \
}) == _textures.end()) \
{ \
Error(e_kind::error, "invalid image ptr"); \
retval; \
} else {}
namespace mlx
{
void Application::GetMousePos(int* x, int* y) noexcept
{
*x = p_in->GetX();
*y = p_in->GetY();
}
void Application::MouseMove(void* win, int x, int y) noexcept
{
CHECK_WINDOW_PTR(win);
if(!m_graphics[*static_cast<int*>(win)]->HasWindow())
{
Warning("trying to move the mouse relative to a window that is targeting an image and not a real window, this is not allowed (move ignored)");
return;
}
}
void Application::OnEvent(void* win, int event, int (*funct_ptr)(int, void*), void* param) noexcept
{
CHECK_WINDOW_PTR(win);
if(!m_graphics[*static_cast<int*>(win)]->HasWindow())
{
Warning("trying to add event hook for a window that is targeting an image and not a real window, this is not allowed (hook ignored)");
return;
}
p_in->OnEvent(m_graphics[*static_cast<int*>(win)]->GetWindow()->GetID(), event, funct_ptr, param);
}
void Application::GetScreenSize(void* win, int* w, int* h) noexcept
{
CHECK_WINDOW_PTR(win);
*w = 0;
*h = 0;
}
void Application::SetFPSCap(std::uint32_t fps) noexcept
{
m_fps.SetMaxFPS(fps);
}
void* Application::NewGraphicsSuport(std::size_t w, std::size_t h, const char* title)
{
MLX_PROFILE_FUNCTION();
auto it = std::find_if(m_textures.begin(), m_textures.end(), [=](const Texture& texture)
{
return &texture == reinterpret_cast<Texture*>(const_cast<char*>(title));
});
if(it != _textures.end())
m_graphics.emplace_back(std::make_unique<GraphicsSupport>(w, h, reinterpret_cast<Texture*>(const_cast<char*>(title)), m_graphics.size()));
else
{
if(title == NULL)
{
FatalError("invalid window title (NULL)");
return nullptr;
}
m_graphics.emplace_back(std::make_unique<GraphicsSupport>(w, h, title, m_graphics.size()));
p_in->RegisterWindow(m_graphics.back()->GetWindow());
}
return static_cast<void*>(&m_graphics.back()->GetID());
}
void Application::ClearGraphicsSupport(void* win)
{
MLX_PROFILE_FUNCTION();
CHECK_WINDOW_PTR(win);
m_graphics[*static_cast<int*>(win)]->ClearRenderData();
}
void Application::DestroyGraphicsSupport(void* win)
{
MLX_PROFILE_FUNCTION();
CHECK_WINDOW_PTR(win);
m_graphics[*static_cast<int*>(win)].reset();
}
void Application::PixelPut(void* win, int x, int y, std::uint32_t color) const noexcept
{
MLX_PROFILE_FUNCTION();
CHECK_WINDOW_PTR(win);
m_graphics[*static_cast<int*>(win)]->PixelPut(x, y, color);
}
void Application::StringPut(void* win, int x, int y, std::uint32_t color, char* str)
{
MLX_PROFILE_FUNCTION();
CHECK_WINDOW_PTR(win);
if(str == nullptr)
{
Error("wrong text (NULL)");
return;
}
if(std::strlen(str) == 0)
{
Warning("trying to put an empty text");
return;
}
m_graphics[*static_cast<int*>(win)]->StringPut(x, y, color, str);
}
void Application::LoadFont(void* win, const std::filesystem::path& filepath, float scale)
{
MLX_PROFILE_FUNCTION();
CHECK_WINDOW_PTR(win);
m_graphics[*static_cast<int*>(win)]->LoadFont(filepath, scale);
}
void Application::TexturePut(void* win, void* img, int x, int y)
{
MLX_PROFILE_FUNCTION();
CHECK_WINDOW_PTR(win);
CHECK_IMAGE_PTR(img, return);
NonOwningPtr<Texture> texture = static_cast<Texture*>(img);
if(!texture->IsInit())
Error("trying to put a texture that has been destroyed");
else
m_graphics[*static_cast<int*>(win)]->TexturePut(texture, x, y);
}
int Application::GetTexturePixel(void* img, int x, int y)
{
MLX_PROFILE_FUNCTION();
CHECK_IMAGE_PTR(img, return 0);
NonOwningPtr<Texture> texture = static_cast<Texture*>(img);
if(!texture->IsInit())
{
Error("trying to get a pixel from texture that has been destroyed");
return 0;
}
return texture->GetPixel(x, y);
}
void Application::setTexturePixel(void* img, int x, int y, std::uint32_t color)
{
MLX_PROFILE_FUNCTION();
CHECK_IMAGE_PTR(img, return);
NonOwningPtr<Texture> texture = static_cast<Texture*>(img);
if(!texture->IsInit())
Error("trying to set a pixel on texture that has been destroyed");
else
texture->SetPixel(x, y, color);
}
void Application::LoopHook(int (*f)(void*), void* param)
{
f_loop_hook = f;
p_param = param;
}
void Application::LoopEnd() noexcept
{
p_in->Finish();
}
}

33
runtime/Includes/Core/Enums.h git.filemode.normal_file
View File

@@ -0,0 +1,33 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* Enums.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/03/27 17:15:24 by maldavid #+# #+# */
/* Updated: 2024/03/27 17:16:03 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_CORE_ENUMS__
#define __MLX_CORE_ENUMS__
#include <cstddef>
namespace mlx
{
enum class LogType
{
Message = 0,
Warning,
Error,
FatalError,
EndEnum
};
constexpr std::size_t LogTypeCount = static_cast<std::size_t>(LogType::EndEnum) + 1;
}
#endif

27
src/core/errors.h → runtime/Includes/Core/EventBase.h
View File

@@ -1,29 +1,24 @@
/* ************************************************************************** */ /* ************************************************************************** */
/* */ /* */
/* ::: :::::::: */ /* ::: :::::::: */
/* errors.h :+: :+: :+: */ /* EventBase.h :+: :+: :+: */
/* +:+ +:+ +:+ */ /* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */ /* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/04 17:42:32 by maldavid #+# #+# */ /* Created: 2024/03/27 17:27:22 by maldavid #+# #+# */
/* Updated: 2024/03/25 19:13:19 by maldavid ### ########.fr */ /* Updated: 2024/03/27 17:31:16 by maldavid ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#ifndef __MLX_ERRORS__ #ifndef __MLX_BASE_EVENT__
#define __MLX_ERRORS__ #define __MLX_BASE_EVENT__
enum class e_kind namespace mlx
{ {
message, struct EventBase
warning, {
error, virtual std::uint32_t What() const = 0;
fatal_error };
};
namespace mlx::core::error
{
void report(e_kind kind, std::string msg, ...);
} }
#endif // __MLX_ERRORS__ #endif

35
runtime/Includes/Core/EventBus.h git.filemode.normal_file
View File

@@ -0,0 +1,35 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* EventBus.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/03/27 17:30:36 by maldavid #+# #+# */
/* Updated: 2024/03/27 17:31:41 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_EVENT_BUS__
#define __MLX_EVENT_BUS__
#include <Core/EventBase.h>
#include <Core/EventListener.h>
namespace mlx
{
class EventBus
{
public:
EventBus() = delete;
static void Send(const std::string& listener_name, const EventBase& event);
static void SendBroadcast(const EventBase& event);
inline static void RegisterListener(const EventListener& listener) { s_listeners.push_back(listener); }
~EventBus() = delete;
private:
inline static std::vector<EventListener> s_listeners;
};
}
#endif

37
runtime/Includes/Core/EventListener.h git.filemode.normal_file
View File

@@ -0,0 +1,37 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* EventListener.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/03/27 17:28:17 by maldavid #+# #+# */
/* Updated: 2024/03/27 17:37:53 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_EVENT_LISTENER__
#define __MLX_EVENT_LISTENER__
#include <Core/EventBase.h>
namespace mlx
{
class EventListener
{
public:
EventListener() = delete;
EventListener(func::function<void(const EventBase&)> functor, std::string name);
inline const std::string& GetName() const { return m_name; }
inline void Call(const EventBase& event) const noexcept { m_listen_functor(event); }
~EventListener() = default;
private:
func::function<void(const EventBase&)> m_listen_functor;
std::string m_name;
};
}
#endif

33
runtime/Includes/Core/Format.h git.filemode.normal_file
View File

@@ -0,0 +1,33 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* Format.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/03/27 17:11:09 by maldavid #+# #+# */
/* Updated: 2024/03/27 17:12:03 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_FORMAT__
#define __MLX_FORMAT__
#include <type_traits>
#include <string_view>
namespace mlx
{
template<typename T, typename = void>
struct IsOstreamable : std::false_type {};
template<typename T>
struct IsOstreamable<T, std::void_t<decltype(std::declval<std::ostream>() << std::declval<T>())>> : std::true_type {};
template<typename... Args, std::enable_if_t<std::conjunction_v<IsOstreamable<Args>...>, int> = 0>
auto Format(std::string_view format, const Args&... args);
}
#include <Core/Format.inl>
#endif

146
runtime/Includes/Core/Format.inl git.filemode.normal_file
View File

@@ -0,0 +1,146 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* Format.inl :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/03/27 17:11:09 by maldavid #+# #+# */
/* Updated: 2024/03/27 17:12:03 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#include <Core/Format.h>
#include <sstream>
#include <ostream>
namespace mlx
{
namespace Internal
{
template<typename It>
void Format(std::stringstream& ss, It first, It last)
{
for(auto it = first; it != last; ++it)
{
switch(*it)
{
case '%':
throw std::invalid_argument{"too few arguments"};
case '/':
++it;
if(it == last)
throw std::invalid_argument{"stray '/'"};
[[fallthrough]];
default: ss << *it;
}
}
}
template<typename It, typename T, typename... Args>
void Format(std::stringstream& ss, It first, It last, const T& arg, const Args&... args)
{
for(auto it = first; it != last; ++it)
{
switch(*it)
{
case '%':
ss << arg;
return Format(ss, ++it, last, args...);
case '/':
++it;
if(it == last)
throw std::invalid_argument{"stray '/'"};
[[fallthrough]];
default: ss << *it;
}
}
throw std::invalid_argument{"too many arguments"};
}
template<typename It>
void Format(std::ostream& os, It first, It last)
{
for(auto it = first; it != last; ++it)
{
switch(*it)
{
case '%':
throw std::invalid_argument{"too few arguments"};
case '/':
++it;
if(it == last)
throw std::invalid_argument{"stray '/'"};
[[fallthrough]];
default: os << *it;
}
}
}
template<typename It, typename T, typename... Args>
void Format(std::ostream& os, It first, It last, const T& arg, const Args&... args)
{
for(auto it = first; it != last; ++it)
{
switch(*it)
{
case '%':
os << arg;
return Format(os, ++it, last, args...);
case '/':
++it;
if(it == last)
throw std::invalid_argument{"stray '/'"};
[[fallthrough]];
default: os << *it;
}
}
throw std::invalid_argument{"too many arguments"};
}
template<typename... Args>
struct Formatter
{
std::string_view format;
std::tuple<const Args&...> args;
};
template<typename... Args, std::size_t... Is>
void FormatHelper(std::stringstream& ss, const Formatter<Args...>& formatter, std::index_sequence<Is...>)
{
Format(ss, formatter.format.begin(), formatter.format.end(),
std::get<Is>(formatter.args)...);
}
template<typename... Args>
std::stringstream& operator<<(std::stringstream& ss, const Formatter<Args...>& printer)
{
FormatHelper(ss, printer, std::index_sequence_for<Args...>{});
return ss;
}
template<typename... Args, std::size_t... Is>
void FormatHelper(std::ostream& os, const Formatter<Args...>& formatter, std::index_sequence<Is...>)
{
Format(os, formatter.format.begin(), formatter.format.end(),
std::get<Is>(formatter.args)...);
}
template<typename... Args>
std::ostream& operator<<(std::ostream& os, const Formatter<Args...>& printer)
{
FormatHelper(os, printer, std::index_sequence_for<Args...>{});
return os;
}
}
template<typename... Args, std::enable_if_t<std::conjunction_v<IsOstreamable<Args>...>, int>>
auto Format(std::string_view format, const Args&... args)
{
return Internal::Formatter<Args...>{format, std::forward_as_tuple(args...)};
}
}

22
src/core/fps.h → runtime/Includes/Core/Fps.h
View File

@@ -1,12 +1,12 @@
/* ************************************************************************** */ /* ************************************************************************** */
/* */ /* */
/* ::: :::::::: */ /* ::: :::::::: */
/* fps.h :+: :+: :+: */ /* Fps.h :+: :+: :+: */
/* +:+ +:+ +:+ */ /* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */ /* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/01/18 14:53:30 by maldavid #+# #+# */ /* Created: 2024/01/18 14:53:30 by maldavid #+# #+# */
/* Updated: 2024/03/25 22:58:32 by maldavid ### ########.fr */ /* Updated: 2024/03/27 20:52:06 by maldavid ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@@ -20,19 +20,19 @@ namespace mlx
public: public:
FpsManager() = default; FpsManager() = default;
void init(); void Init();
bool update(); bool Update();
inline void setMaxFPS(std::uint32_t fps) noexcept { _max_fps = fps; _ns = 1000000000.0 / fps; } inline void SetMaxFPS(std::uint32_t fps) noexcept { m_max_fps = fps; m_ns = 1000000000.0 / fps; }
~FpsManager() = default; ~FpsManager() = default;
private: private:
double _ns = 1000000000.0 / 1'337'000.0; double m_ns = 1000000000.0 / 1'337'000.0;
std::int64_t _fps_before = 0; std::int64_t m_fps_before = 0;
std::int64_t _fps_now = 0; std::int64_t m_fps_now = 0;
std::int64_t _timer = 0; std::int64_t m_timer = 0;
std::uint32_t _max_fps = 1'337'000; std::uint32_t m_max_fps = 1'337'000;
std::uint32_t _fps_elapsed_time = 0; std::uint32_t m_fps_elapsed_time = 0;
}; };
} }

75
runtime/Includes/Core/Graphics.h git.filemode.normal_file
View File

@@ -0,0 +1,75 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* Graphics.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/04/02 14:49:49 by maldavid #+# #+# */
/* Updated: 2024/03/27 21:16:11 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_GRAPHICS__
#define __MLX_GRAPHICS__
#include <Platform/Window.h>
#include <Renderer/Renderer.h>
#include <Renderer/PixelPut.h>
#include <Renderer/Core/DrawableResource.h>
#include <Renderer/Images/TextureManager.h>
#include <Renderer/Texts/TextManager.h>
#include <Utils/NonCopyable.h>
#include <Renderer/Images/Texture.h>
namespace mlx
{
class GraphicsSupport : public NonCopyable
{
public:
GraphicsSupport(std::size_t w, std::size_t h, NonOwningPtr<Texture> render_target, int id);
GraphicsSupport(std::size_t w, std::size_t h, std::string title, int id);
inline int& GetID() noexcept;
inline std::shared_ptr<Window> GetWindow();
void Render() noexcept;
inline void ClearRenderData() noexcept;
inline void PixelPut(int x, int y, std::uint32_t color) noexcept;
inline void StringPut(int x, int y, std::uint32_t color, std::string str);
inline void TexturePut(NonOwningPtr<class Texture> texture, int x, int y);
inline void LoadFont(const std::filesystem::path& filepath, float scale);
inline void TryEraseTextureFromManager(NonOwningPtr<Texture> texture) noexcept;
inline bool HasWindow() const noexcept { return _has_window; }
inline Renderer& GetRenderer() { return *_renderer; }
~GraphicsSupport();
private:
PixelPutPipeline m_pixel_put_pipeline;
std::vector<NonOwningPtr<DrawableResource>> m_drawlist;
TextManager m_text_manager;
TextureManager m_texture_manager;
glm::mat4 m_proj = glm::mat4(1.0);
std::shared_ptr<Window> p_window;
std::unique_ptr<Renderer> p_renderer;
std::size_t m_width = 0;
std::size_t m_height = 0;
int m_id;
bool m_has_window;
};
}
#include <core/graphics.inl>
#endif

79
runtime/Includes/Core/Graphics.inl git.filemode.normal_file
View File

@@ -0,0 +1,79 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* graphics.inl :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/04/02 15:13:55 by maldavid #+# #+# */
/* Updated: 2023/04/02 15:26:16 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#include <Core/Graphics.h>
namespace mlx
{
int& GraphicsSupport::GetID() noexcept { return m_id; }
std::shared_ptr<Window> GraphicsSupport::GetWindow() { return p_window; }
void GraphicsSupport::ClearRenderData() noexcept
{
MLX_PROFILE_FUNCTION();
m_drawlist.clear();
m_pixel_put_pipeline.Clear();
m_text_manager.Clear();
m_texture_manager.Clear();
}
void GraphicsSupport::PixelPut(int x, int y, std::uint32_t color) noexcept
{
MLX_PROFILE_FUNCTION();
m_pixel_put_pipeline.SetPixel(x, y, color);
}
void GraphicsSupport::StringPut(int x, int y, std::uint32_t color, std::string str)
{
MLX_PROFILE_FUNCTION();
std::pair<NonOwningPtr<DrawableResource>, bool> res = m_text_manager.RegisterText(x, y, color, str);
if(!res.second) // if this is not a completly new text draw
{
auto it = std::find(m_drawlist.begin(), m_drawlist.end(), res.first);
if(it != m_drawlist.end())
m_drawlist.erase(it);
}
m_drawlist.push_back(res.first);
}
void GraphicsSupport::TexturePut(NonOwningPtr<Texture> texture, int x, int y)
{
MLX_PROFILE_FUNCTION();
auto res = m_texture_manager.RegisterTexture(texture, x, y);
if(!res.second) // if this is not a completly new texture draw
{
auto it = std::find(m_drawlist.begin(), m_drawlist.end(), res.first);
if(it != m_drawlist.end())
m_drawlist.erase(it);
}
m_drawlist.push_back(res.first);
}
void GraphicsSupport::LoadFont(const std::filesystem::path& filepath, float scale)
{
MLX_PROFILE_FUNCTION();
m_text_manager.LoadFont(*_renderer, filepath, scale);
}
void GraphicsSupport::TryEraseTextureFromManager(NonOwningPtr<Texture> texture) noexcept
{
MLX_PROFILE_FUNCTION();
for(auto it = m_drawlist.begin(); it != m_drawlist.end();)
{
if(m_texture_manager.IsTextureKnown(texture))
it = m_drawlist.erase(it);
else
++it;
}
m_texture_manager.EraseTextures(texture);
}
}

84
runtime/Includes/Core/Logs.h git.filemode.normal_file
View File

@@ -0,0 +1,84 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* Logs.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/03/27 17:14:10 by maldavid #+# #+# */
/* Updated: 2024/03/27 17:19:23 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_LOGS__
#define __MLX_LOGS__
#include <Core/Enums.h>
namespace mlx
{
template<typename... Args>
void DebugLog(unsigned int line, std::string_view file, std::string_view function, std::string message, const Args&... args);
template<typename... Args>
void Error(unsigned int line, std::string_view file, std::string_view function, std::string message, const Args&... args);
template<typename... Args>
void Warning(unsigned int line, std::string_view file, std::string_view function, std::string message, const Args&... args);
template<typename... Args>
void Message(unsigned int line, std::string_view file, std::string_view function, std::string message, const Args&... args);
template<typename... Args>
void FatalError(unsigned int line, std::string_view file, std::string_view function, std::string message, const Args&... args);
template<typename... Args>
void Verify(bool cond, unsigned int line, std::string_view file, std::string_view function, std::string message, const Args&... args);
class Logs
{
public:
Logs() = delete;
static void Report(LogType type, std::string message);
static void Report(LogType type, unsigned int line, std::string_view file, std::string_view function, std::string message);
~Logs() = delete;
};
#if defined(DEBUG)
template<typename... Args>
void Assert(bool cond, unsigned int line, std::string_view file, std::string_view function, std::string message, const Args&... args);
#else
template<typename... Args>
void Assert(bool cond, unsigned int line, std::string_view file, std::string_view function, std::string message, const Args&... args) {}
#endif
}
#include <Core/Logs.inl>
namespace mlx
{
#undef DebugLog
#define DebugLog(...) DebugLog(__LINE__, __FILE__, AK_FUNC_SIG, __VA_ARGS__)
#undef Message
#define Message(...) Message(__LINE__, __FILE__, __func__, __VA_ARGS__)
#undef Warning
#define Warning(...) Warning(__LINE__, __FILE__, __func__, __VA_ARGS__)
#undef Error
#define Error(...) Error(__LINE__, __FILE__, __func__, __VA_ARGS__)
#undef FatalError
#define FatalError(...) FatalError(__LINE__, __FILE__, __func__, __VA_ARGS__)
#undef Verify
#define Verify(cond, ...) Verify(cond, __LINE__, __FILE__, __func__, __VA_ARGS__)
#undef Assert
#define Assert(cond, ...) Assert(cond, __LINE__, __FILE__, __func__, __VA_ARGS__)
}
#endif

135
runtime/Includes/Core/Logs.inl git.filemode.normal_file
View File

@@ -0,0 +1,135 @@
/* **************************************************************************** */
/* */
/* ::: :::::::: */
/* Logs.inl :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/03/27 17:19:47 by maldavid #+# #+# */
/* Updated: 2024/03/27 17:19:47 by maldavid ### ########.fr */
/* */
/* **************************************************************************** */
#include <Core/Logs.h>
#include <Core/Format.h>
namespace mlx
{
template<typename... Args>
void DebugLog(unsigned int line, std::string_view file, std::string_view function, std::string message, const Args&... args)
{
using namespace std::literals;
try
{
std::stringstream ss;
ss << Format(message, args...);
Logs::Report(LogType::Debug, line, file, function, ss.str());
}
catch(const std::exception& e)
{
Logs::Report(LogType::Error, "formatter exception catched in the log printer : "s + e.what());
}
}
template<typename... Args>
void Error(unsigned int line, std::string_view file, std::string_view function, std::string message, const Args&... args)
{
using namespace std::literals;
try
{
std::stringstream ss;
ss << Format(message, args...);
Logs::Report(LogType::Error, line, file, function, ss.str());
}
catch(const std::exception& e)
{
Logs::Report(LogType::Error, "formatter exception catched in the log printer : "s + e.what());
}
}
template<typename... Args>
void Warning(unsigned int line, std::string_view file, std::string_view function, std::string message, const Args&... args)
{
using namespace std::literals;
try
{
std::stringstream ss;
ss << Format(message, args...);
Logs::Report(LogType::Warning, line, file, function, ss.str());
}
catch(const std::exception& e)
{
Logs::Report(LogType::Error, "formatter exception catched in the log printer : "s + e.what());
}
}
template<typename... Args>
void Message(unsigned int line, std::string_view file, std::string_view function, std::string message, const Args&... args)
{
using namespace std::literals;
try
{
std::stringstream ss;
ss << Format(message, args...);
Logs::Report(LogType::Message, line, file, function, ss.str());
}
catch(const std::exception& e)
{
Logs::Report(LogType::Error, "formatter exception catched in the log printer : "s + e.what());
}
}
template<typename... Args>
void FatalError(unsigned int line, std::string_view file, std::string_view function, std::string message, const Args&... args)
{
using namespace std::literals;
try
{
std::stringstream ss;
ss << Format(message, args...);
Logs::Report(LogType::FatalError, line, file, function, ss.str());
}
catch(const std::exception& e)
{
Logs::Report(LogType::Error, "formatter exception catched in the log printer : "s + e.what());
}
}
template<typename... Args>
void Verify(bool cond, unsigned int line, std::string_view file, std::string_view function, std::string message, const Args&... args)
{
using namespace std::literals;
if(cond)
return;
try
{
std::stringstream ss;
ss << Format("Verification failed : %", message, args...);
Logs::Report(LogType::FatalError, line, file, function, ss.str());
}
catch(const std::exception& e)
{
Logs::Report(LogType::Error, "formatter exception catched in the log printer : "s + e.what());
}
}
#if defined(DEBUG)
template<typename... Args>
void Assert(bool cond, unsigned int line, std::string_view file, std::string_view function, std::string message, const Args&... args)
{
using namespace std::literals;
if(cond)
return;
try
{
std::stringstream ss;
ss << Format("Assertion failed : %", message, args...);
Logs::Report(LogType::FatalError, line, file, function, ss.str());
}
catch(const std::exception& e)
{
Logs::Report(LogType::Error, "formatter exception catched in the log printer : "s + e.what());
}
}
#endif
}

16
src/core/memory.h → runtime/Includes/Core/Memory.h
View File

@@ -1,19 +1,19 @@
/* ************************************************************************** */ /* ************************************************************************** */
/* */ /* */
/* ::: :::::::: */ /* ::: :::::::: */
/* memory.h :+: :+: :+: */ /* Memory.h :+: :+: :+: */
/* +:+ +:+ +:+ */ /* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */ /* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2023/12/07 16:31:51 by kbz_8 #+# #+# */ /* Created: 2023/12/07 16:31:51 by kbz_8 #+# #+# */
/* Updated: 2024/03/25 19:13:05 by maldavid ### ########.fr */ /* Updated: 2024/03/27 21:16:44 by maldavid ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#ifndef __MLX_MEMORY__ #ifndef __MLX_MEMORY__
#define __MLX_MEMORY__ #define __MLX_MEMORY__
#include <utils/singleton.h> #include <Utils/Singleton.h>
namespace mlx namespace mlx
{ {
@@ -22,17 +22,17 @@ namespace mlx
friend class Singleton<MemManager>; friend class Singleton<MemManager>;
public: public:
static void* malloc(std::size_t size); static void* Malloc(std::size_t size);
static void* calloc(std::size_t n, std::size_t size); static void* Calloc(std::size_t n, std::size_t size);
static void* realloc(void* ptr, std::size_t size); static void* Realloc(void* ptr, std::size_t size);
static void free(void* ptr); static void Free(void* ptr);
private: private:
MemManager() = default; MemManager() = default;
~MemManager(); ~MemManager();
private: private:
inline static std::list<void*> _blocks; inline static std::list<void*> s_blocks;
}; };
} }

64
src/core/profiler.h → runtime/Includes/Core/Profiler.h
View File

@@ -1,19 +1,19 @@
/* ************************************************************************** */ /* ************************************************************************** */
/* */ /* */
/* ::: :::::::: */ /* ::: :::::::: */
/* profiler.h :+: :+: :+: */ /* Profiler.h :+: :+: :+: */
/* +:+ +:+ +:+ */ /* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */ /* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/01/10 13:35:45 by maldavid #+# #+# */ /* Created: 2024/01/10 13:35:45 by maldavid #+# #+# */
/* Updated: 2024/03/25 19:12:57 by maldavid ### ########.fr */ /* Updated: 2024/03/27 21:19:01 by maldavid ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#ifndef __MLX_PROFILER__ #ifndef __MLX_PROFILER__
#define __MLX_PROFILER__ #define __MLX_PROFILER__
#include <utils/singleton.h> #include <Utils/Singleton.h>
namespace mlx namespace mlx
{ {
@@ -34,63 +34,63 @@ namespace mlx
Profiler(const Profiler&) = delete; Profiler(const Profiler&) = delete;
Profiler(Profiler&&) = delete; Profiler(Profiler&&) = delete;
void appendProfileData(ProfileResult&& result); void AppendProfileData(ProfileResult&& result);
private: private:
Profiler() { beginRuntimeSession(); } Profiler() { BeginRuntimeSession(); }
~Profiler(); ~Profiler();
void beginRuntimeSession(); void BeginRuntimeSession();
void writeProfile(const ProfileResult& result); void WriteProfile(const ProfileResult& result);
void endRuntimeSession(); void EndRuntimeSession();
inline void writeHeader() inline void WriteHeader()
{ {
_output_stream << "{\"profileData\":[{}"; m_output_stream << "{\"profileData\":[{}";
_output_stream.flush(); m_output_stream.flush();
} }
inline void writeFooter() inline void WriteFooter()
{ {
_output_stream << "]}"; m_output_stream << "]}";
_output_stream.flush(); m_output_stream.flush();
} }
private: private:
std::unordered_map<std::string, std::pair<std::size_t, ProfileResult>> _profile_data; std::unordered_map<std::string, std::pair<std::size_t, ProfileResult>> m_profile_data;
std::ofstream _output_stream; std::ofstream m_output_stream;
std::mutex _mutex; std::mutex m_mutex;
bool _runtime_session_began = false; bool m_runtime_session_began = false;
}; };
class ProfilerTimer class ProfilerTimer
{ {
public: public:
ProfilerTimer(const char* name) : _name(name) ProfilerTimer(const char* name) : m_name(name)
{ {
_start_timepoint = std::chrono::steady_clock::now(); m_start_timepoint = std::chrono::steady_clock::now();
} }
inline void stop() inline void Stop()
{ {
auto end_timepoint = std::chrono::steady_clock::now(); auto end_timepoint = std::chrono::steady_clock::now();
auto high_res_start = FloatingPointMilliseconds{ _start_timepoint.time_since_epoch() }; auto high_res_start = FloatingPointMilliseconds{ m_start_timepoint.time_since_epoch() };
auto elapsed_time = std::chrono::time_point_cast<std::chrono::milliseconds>(end_timepoint).time_since_epoch() - std::chrono::time_point_cast<std::chrono::milliseconds>(_start_timepoint).time_since_epoch(); auto elapsed_time = std::chrono::time_point_cast<std::chrono::milliseconds>(end_timepoint).time_since_epoch() - std::chrono::time_point_cast<std::chrono::milliseconds>(m_start_timepoint).time_since_epoch();
Profiler::get().appendProfileData({ _name, elapsed_time, std::this_thread::get_id() }); Profiler::get().appendProfileData({ m_name, elapsed_time, std::this_thread::get_id() });
_stopped = true; m_stopped = true;
} }
~ProfilerTimer() ~ProfilerTimer()
{ {
if(!_stopped) if(!m_stopped)
stop(); stop();
} }
private: private:
std::chrono::time_point<std::chrono::steady_clock> _start_timepoint; std::chrono::time_point<std::chrono::steady_clock> m_start_timepoint;
const char* _name; const char* m_name;
bool _stopped = false; bool m_stopped = false;
}; };
namespace ProfilerUtils namespace ProfilerUtils
@@ -102,7 +102,7 @@ namespace mlx
}; };
template <std::size_t N, std::size_t K> template <std::size_t N, std::size_t K>
constexpr auto cleanupOutputString(const char(&expr)[N], const char(&remove)[K]) constexpr auto CleanupOutputString(const char(&expr)[N], const char(&remove)[K])
{ {
ChangeResult<N> result = {}; ChangeResult<N> result = {};
@@ -124,8 +124,8 @@ namespace mlx
} }
#ifdef PROFILER #ifdef PROFILER
#define MLX_PROFILE_SCOPE_LINE2(name, line) constexpr auto fixedName##line = ::mlx::ProfilerUtils::cleanupOutputString(name, "__cdecl ");\ #define MLX_PROFILE_SCOPE_LINE2(name, line) constexpr auto fixed_name_##line = ::mlx::ProfilerUtils::CleanupOutputString(name, "__cdecl ");\
::mlx::ProfilerTimer timer##line(fixedName##line.data) ::mlx::ProfilerTimer timer##line(fixed_name_##line.data)
#define MLX_PROFILE_SCOPE_LINE(name, line) MLX_PROFILE_SCOPE_LINE2(name, line) #define MLX_PROFILE_SCOPE_LINE(name, line) MLX_PROFILE_SCOPE_LINE2(name, line)
#define MLX_PROFILE_SCOPE(name) MLX_PROFILE_SCOPE_LINE(name, __LINE__) #define MLX_PROFILE_SCOPE(name) MLX_PROFILE_SCOPE_LINE(name, __LINE__)
#define MLX_PROFILE_FUNCTION() MLX_PROFILE_SCOPE(MLX_FUNC_SIG) #define MLX_PROFILE_FUNCTION() MLX_PROFILE_SCOPE(MLX_FUNC_SIG)

6
src/core/UUID.h → runtime/Includes/Core/UUID.h
View File

@@ -6,7 +6,7 @@
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */ /* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/01/06 11:13:23 by maldavid #+# #+# */ /* Created: 2024/01/06 11:13:23 by maldavid #+# #+# */
/* Updated: 2024/03/25 19:12:53 by maldavid ### ########.fr */ /* Updated: 2024/03/27 21:19:18 by maldavid ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@@ -21,10 +21,10 @@ namespace mlx
UUID(); UUID();
UUID(std::uint64_t uuid); UUID(std::uint64_t uuid);
inline operator std::uint64_t() const { return _uuid; } inline operator std::uint64_t() const { return m_uuid; }
private: private:
std::uint64_t _uuid; std::uint64_t m_uuid;
}; };
} }

44
runtime/Includes/Drivers/GLFW/GLFWInputs.h git.filemode.normal_file
View File

@@ -0,0 +1,44 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* GLFWInputs.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/03/27 18:32:29 by maldavid #+# #+# */
/* Updated: 2024/03/27 18:37:58 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_GLFW_INPUTS__
#define __MLX_GLFW_INPUTS__
#include <Platform/Inputs.h>
namespace mlx
{
class GLFWInputs : public Inputs
{
public:
GLFWInputs() = default;
void Update() override noexcept;
void RegisterWindow(std::shared_ptr<Window> window) override;
inline std::int32_t GetX() override const noexcept { return m_x; }
inline std::int32_t GetY() override const noexcept { return m_y; }
inline std::int32_t GetXRel() override const noexcept { return m_x_rel; }
inline std::int32_t GetYRel() override const noexcept { return m_y_rel; }
~GLFWInputs() override = default;
private:
std::int32_t m_x = 0;
std::int32_t m_y = 0;
std::int32_t m_x_rel = 0;
std::int32_t m_y_rel = 0;
};
}
#endif

62
runtime/Includes/Platform/Inputs.h git.filemode.normal_file
View File

@@ -0,0 +1,62 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* Inputs.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/05 16:27:35 by maldavid #+# #+# */
/* Updated: 2024/03/27 18:36:21 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_INPUTS__
#define __MLX_INPUTS__
#include <mlx_profile.h>
#include <Platform/Window.h>
namespace mlx
{
class Inputs
{
public:
struct Hook
{
func::function<int(int, void*)> hook;
void* param = nullptr;
};
public:
Inputs() = default;
virtual void Update() noexcept = 0;
virtual void RegisterWindow(std::shared_ptr<Window> window) = 0;
virtual std::int32_t GetX() const noexcept = 0;
virtual std::int32_t GetY() const noexcept = 0;
virtual std::int32_t GetXRel() const noexcept = 0;
virtual std::int32_t GetYRel() const noexcept = 0;
inline bool IsMouseMoving() const noexcept { return GetXRel() || GetYRel(); }
MLX_FORCEINLINE bool IsRunning() const noexcept { return m_run; }
MLX_FORCEINLINE constexpr void Finish() noexcept { m_run = false; }
MLX_FORCEINLINE constexpr void Run() noexcept { m_run = true; }
inline void OnEvent(std::uint32_t id, int event, int (*funct_ptr)(int, void*), void* param) noexcept
{
m_events_hooks[id][event].hook = funct_ptr;
m_events_hooks[id][event].param = param;
}
virtual ~Inputs() = default;
protected:
std::unordered_map<std::uint32_t, std::shared_ptr<Window>> m_windows;
std::unordered_map<std::uint32_t, std::array<Hook, 6>> m_events_hooks;
bool m_run = false;
};
}
#endif

28
src/platform/window.h → runtime/Includes/Platform/Window.h
View File

@@ -1,12 +1,12 @@
/* ************************************************************************** */ /* ************************************************************************** */
/* */ /* */
/* ::: :::::::: */ /* ::: :::::::: */
/* window.h :+: :+: :+: */ /* Window.h :+: :+: :+: */
/* +:+ +:+ +:+ */ /* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */ /* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/04 21:53:12 by maldavid #+# #+# */ /* Created: 2022/10/04 21:53:12 by maldavid #+# #+# */
/* Updated: 2024/03/26 23:03:50 by maldavid ### ########.fr */ /* Updated: 2024/03/27 21:58:18 by maldavid ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@@ -15,26 +15,30 @@
namespace mlx namespace mlx
{ {
#ifdef LEGACY
using WindowHandle = SDL_Window;
#else
using WindowHandle = GLFWwindow;
#endif
class Window class Window
{ {
public: public:
Window(std::size_t w, std::size_t h, const std::string& title); Window(std::size_t w, std::size_t h, const std::string& title);
inline GLFWwindow* getNativeWindow() const noexcept { return _win; } inline NonOwningPtr<WindowHandle> GetWindowHandle() const noexcept = 0;
inline int getWidth() const noexcept { return _width; } inline int GetWidth() const noexcept { return m_width; }
inline int getHeight() const noexcept { return _height; } inline int GetHeight() const noexcept { return m_height; }
inline std::uint32_t getID() const noexcept { return _id; } inline std::uint32_t GetID() const noexcept { return m_id; }
void destroy() noexcept; void Destroy() noexcept;
~Window() = default; ~Window() = default;
private: private:
GLFWimage _icon; std::uint32_t m_id = -1;
GLFWwindow* _win = nullptr; int m_width = 0;
int _width = 0; int m_height = 0;
int _height = 0;
std::uint32_t _id = -1;
}; };
} }

18
src/pre_compiled.h → runtime/Includes/PreCompiled.h
View File

@@ -1,12 +1,12 @@
/* ************************************************************************** */ /* ************************************************************************** */
/* */ /* */
/* ::: :::::::: */ /* ::: :::::::: */
/* pre_compiled.h :+: :+: :+: */ /* PreCompiled.h :+: :+: :+: */
/* +:+ +:+ +:+ */ /* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */ /* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/03/25 17:37:23 by maldavid #+# #+# */ /* Created: 2024/03/25 17:37:23 by maldavid #+# #+# */
/* Updated: 2024/03/27 00:39:13 by maldavid ### ########.fr */ /* Updated: 2024/03/27 21:33:47 by maldavid ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@@ -22,7 +22,14 @@
#include <cstdarg> #include <cstdarg>
#include <iostream> #include <iostream>
#include <volk.h> #include <volk.h>
#include <GLFW/glfw3.h>
#ifdef LEGACY
#include <SDL2/SDL.h>
#include <SDL2/SDL_vulkan.h>
#else
#include <GLFW/glfw3.h>
#endif
#include <functional> #include <functional>
#include <memory> #include <memory>
#include <list> #include <list>
@@ -74,4 +81,9 @@
#undef Window #undef Window
#include <Core/Logs.h>
#include <EventBus.h>
#include <Core/Profiler.h>
#include <?Utils/NonOwningPtr.h>
#endif #endif

66
runtime/Includes/Renderer/Buffers/Buffer.h git.filemode.normal_file
View File

@@ -0,0 +1,66 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* Buffer.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/06 23:18:52 by maldavid #+# #+# */
/* Updated: 2024/03/27 22:09:07 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_VK_BUFFER__
#define __MLX_VK_BUFFER__
#include <Renderer/Enums.h>
#include <Renderer/Core/RenderCore.h>
#include <Renderer/Command/CommandResource.h>
namespace mlx
{
class Buffer : public CommandResource
{
public:
Buffer() = default;
void Create(BufferType type, VkDeviceSize size, VkBufferUsageFlags usage, const char* name, const void* data = nullptr);
void Destroy() noexcept;
inline void MapMem(void** data) noexcept { Render_Core::get().getAllocator().mapMemory(m_allocation, data); m_is_mapped = true; }
inline bool IsMapped() const noexcept { return m_is_mapped; }
inline void UnmapMem() noexcept { Render_Core::get().getAllocator().unmapMemory(m_allocation); m_is_mapped = false; }
void Flush(VkDeviceSize size = VK_WHOLE_SIZE, VkDeviceSize offset = 0);
bool CopyFromBuffer(const Buffer& buffer) noexcept;
inline VkBuffer& operator()() noexcept { return m_buffer; }
inline VkBuffer& Get() noexcept { return m_buffer; }
inline VkDeviceSize GetSize() const noexcept { return m_size; }
inline VkDeviceSize GetOffset() const noexcept { return m_offset; }
~Buffer() = default;
protected:
void PushToGPU() noexcept;
void Swap(Buffer& buffer) noexcept;
protected:
VmaAllocation m_allocation;
VkBuffer m_buffer = VK_NULL_HANDLE;
VkDeviceSize m_offset = 0;
VkDeviceSize m_size = 0;
private:
void CreateBuffer(VkBufferUsageFlags usage, VmaAllocationCreateInfo info, VkDeviceSize size, const char* name);
private:
#ifdef DEBUG
std::string m_name;
#endif
VkBufferUsageFlags m_usage = 0;
bool m_is_mapped = false;
};
}
#endif

12
src/renderer/buffers/vk_ibo.h → runtime/Includes/Renderer/Buffers/IndexBuffer.h
View File

@@ -1,28 +1,28 @@
/* ************************************************************************** */ /* ************************************************************************** */
/* */ /* */
/* ::: :::::::: */ /* ::: :::::::: */
/* vk_ibo.h :+: :+: :+: */ /* IndexBuffer.h :+: :+: :+: */
/* +:+ +:+ +:+ */ /* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */ /* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2023/01/25 15:05:05 by maldavid #+# #+# */ /* Created: 2023/01/25 15:05:05 by maldavid #+# #+# */
/* Updated: 2024/03/25 19:12:35 by maldavid ### ########.fr */ /* Updated: 2024/03/27 22:11:57 by maldavid ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#ifndef __VK_IBO__ #ifndef __VK_IBO__
#define __VK_IBO__ #define __VK_IBO__
#include "vk_buffer.h" #include <Renderer/Buffer/Buffer.h>
#include <renderer/renderer.h> #include <Renderer/Renderer.h>
namespace mlx namespace mlx
{ {
class C_IBO : public Buffer class C_IBO : public Buffer
{ {
public: public:
inline void create(std::uint32_t size, const std::uint16_t* data, const char* name) { Buffer::create(Buffer::kind::constant, size, VK_BUFFER_USAGE_INDEX_BUFFER_BIT, name, data); } inline void Create(std::uint32_t size, const std::uint16_t* data, const char* name) { Buffer::Create(BufferType::Constant, size, VK_BUFFER_USAGE_INDEX_BUFFER_BIT, name, data); }
inline void bind(Renderer& renderer) noexcept { renderer.getActiveCmdBuffer().bindIndexBuffer(*this); } inline void Bind(Renderer& renderer) noexcept { renderer.GetActiveCmdBuffer().BindIndexBuffer(*this); }
}; };
} }

50
runtime/Includes/Renderer/Buffers/UniformBuffer.h git.filemode.normal_file
View File

@@ -0,0 +1,50 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* UniformBuffer.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/06 18:45:29 by maldavid #+# #+# */
/* Updated: 2024/03/27 22:15:23 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_VK_UBO__
#define __MLX_VK_UBO__
#include <Renderer/Buffer/Buffer.h>
namespace mlx
{
class UniformBuffer
{
public:
UniformBuffer() = default;
void Create(NonOwningPtr<class Renderer> renderer, std::uint32_t size, const char* name);
void Destroy() noexcept;
void SetData(std::uint32_t size, const void* data);
VkDeviceSize GetSize() noexcept;
VkDeviceSize GetOffset() noexcept;
VkDeviceMemory GetDeviceMemory() noexcept;
VkBuffer& operator()() noexcept;
VkBuffer& Get() noexcept;
inline VkDeviceSize GetSize(int i) noexcept { return m_buffers[i].getSize(); }
inline VkDeviceSize GetOffset(int i) noexcept { return m_buffers[i].getOffset(); }
inline VkBuffer& operator()(int i) noexcept { return m_buffers[i].get(); }
inline VkBuffer& Get(int i) noexcept { return m_buffers[i].get(); }
~UniformBuffer() = default;
private:
std::array<Buffer, MAX_FRAMES_IN_FLIGHT> m_buffers;
std::array<void*, MAX_FRAMES_IN_FLIGHT> m_maps;
NonOwningPtr<class Renderer> m_renderer;
};
}
#endif // __MLX_VK_UBO__

46
runtime/Includes/Renderer/Buffers/VertexBuffer.h git.filemode.normal_file
View File

@@ -0,0 +1,46 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* VertexBuffer.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/06 18:27:38 by maldavid #+# #+# */
/* Updated: 2024/03/27 22:18:23 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_VK_VBO__
#define __MLX_VK_VBO__
#include <Renderer/Enums.h>
#include <Renderer/Buffer/Buffer.h>
#include <Renderer/Renderer.h>
namespace mlx
{
class VertexBuffer : public Buffer
{
public:
inline void Create(std::uint32_t size, const void* data, const char* name) { Buffer::Create(BufferType::HighDynamic, size, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, name, data); }
void SetData(std::uint32_t size, const void* data);
inline void Bind(Renderer& renderer) noexcept { renderer.GetActiveCmdBuffer().BindVertexBuffer(*this); }
};
class DeviceVertexBuffer : public Buffer
{
public:
inline void create(std::uint32_t size, const void* data, const char* name) { Buffer::Create(BufferType::LowDynamic, size, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, name, data); }
void SetData(std::uint32_t size, const void* data);
inline void Bind(Renderer& renderer) noexcept { renderer.GetActiveCmdBuffer().BindVertexBuffer(*this); }
};
class ConstantVertexBuffer : public Buffer
{
public:
inline void Create(std::uint32_t size, const void* data, const char* name) { Buffer::Create(BufferType::Constant, size, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, name, data); }
inline void Bind(Renderer& renderer) noexcept { renderer.GetActiveCmdBuffer().BindVertexBuffer(*this); }
};
}
#endif // __MLX_VK_VBO__

70
runtime/Includes/Renderer/Command/CommandBuffer.h git.filemode.normal_file
View File

@@ -0,0 +1,70 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* CommandBuffer.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/06 18:25:42 by maldavid #+# #+# */
/* Updated: 2024/03/27 22:44:58 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_VK_CMD_BUFFER__
#define __MLX_VK_CMD_BUFFER__
#include <Renderer/Core/Fence.h>
#include <Renderer/Enums.h>
namespace mlx
{
class Buffer;
class Image;
class CommandBuffer
{
public:
void Init(CommandBufferType type, NonOwningPtr<class CommandManager> manager);
void Init(CommandBufferType type, NonOwningPtr<class CommandPool> pool);
void Destroy() noexcept;
void BeginRecord(VkCommandBufferUsageFlags usage = 0);
void Submit(class Semaphore* semaphores) noexcept;
void SubmitIdle(bool shouldWaitForExecution = true) noexcept; // TODO : handle `shouldWaitForExecution` as false by default (needs to modify CmdResources lifetimes to do so)
void UpdateSubmitState() noexcept;
inline void WaitForExecution() noexcept { m_fence.wait(); UpdateSubmitState(); m_state = CommandBufferState::Ready; }
inline void Reset() noexcept { vkResetCommandBuffer(m_cmd_buffer, 0); }
void EndRecord();
void BindVertexBuffer(Buffer& buffer) noexcept;
void BindIndexBuffer(Buffer& buffer) noexcept;
void CopyBuffer(Buffer& dst, Buffer& src) noexcept;
void CopyBufferToImage(Buffer& buffer, Image& image) noexcept;
void CopyImagetoBuffer(Image& image, Buffer& buffer) noexcept;
void TransitionImageLayout(Image& image, VkImageLayout new_layout) noexcept;
inline bool IsInit() const noexcept { return m_state != CommandBufferState::Uninit; }
inline bool IsReadyToBeUsed() const noexcept { return m_state == CommandBufferState::Ready; }
inline bool IsRecording() const noexcept { return m_state == CommandBufferState::Recording; }
inline bool HasBeenSubmitted() const noexcept { return m_state == CommandBufferState::Submitted; }
inline CommandBufferState GetCurrentState() const noexcept { return m_state; }
inline VkCommandBuffer& operator()() noexcept { return m_cmd_buffer; }
inline VkCommandBuffer& Get() noexcept { return m_cmd_buffer; }
inline Fence& GetFence() noexcept { return m_fence; }
private:
void PreTransferBarrier() noexcept;
void PostTransferBarrier() noexcept;
private:
std::vector<class CmdResource*> m_cmd_resources;
Fence m_fence;
VkCommandBuffer m_cmd_buffer = VK_NULL_HANDLE;
NonOwningPtr<class CmdPool> m_pool;
CommandBufferState m_state = CommandBufferState::Uninit;
CommandBufferType m_type;
};
}
#endif // __MLX_VK_CMD_BUFFER__

32
src/renderer/command/cmd_manager.h → runtime/Includes/Renderer/Command/CommandManager.h
View File

@@ -1,42 +1,42 @@
/* ************************************************************************** */ /* ************************************************************************** */
/* */ /* */
/* ::: :::::::: */ /* ::: :::::::: */
/* cmd_manager.h :+: :+: :+: */ /* CommandManager.h :+: :+: :+: */
/* +:+ +:+ +:+ */ /* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */ /* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2023/04/02 17:48:52 by maldavid #+# #+# */ /* Created: 2023/04/02 17:48:52 by maldavid #+# #+# */
/* Updated: 2024/03/25 19:12:23 by maldavid ### ########.fr */ /* Updated: 2024/03/27 22:20:53 by maldavid ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#ifndef __MLX_COMMAND_MANAGER__ #ifndef __MLX_COMMAND_MANAGER__
#define __MLX_COMMAND_MANAGER__ #define __MLX_COMMAND_MANAGER__
#include <renderer/core/render_core.h> #include <Renderer/Core/RenderCore.h>
#include <renderer/command/vk_cmd_pool.h> #include <Renderer/Command/CommandPool.h>
#include <renderer/command/vk_cmd_buffer.h> #include <Renderer/Command/CommandBuffer.h>
namespace mlx namespace mlx
{ {
class CmdManager class CommandManager
{ {
public: public:
CmdManager() = default; CommandManager() = default;
void init() noexcept; void Init() noexcept;
void beginRecord(int active_image_index); void BeginRecord(int active_image_index);
void endRecord(int active_image_index); void EndRecord(int active_image_index);
void destroy() noexcept; void Destroy() noexcept;
inline CmdPool& getCmdPool() noexcept { return _cmd_pool; } inline CommandPool& GetCmdPool() noexcept { return m_cmd_pool; }
inline CmdBuffer& getCmdBuffer(int i) noexcept { return _cmd_buffers[i]; } inline CommandBuffer& GetCmdBuffer(int i) noexcept { return m_cmd_buffers[i]; }
~CmdManager() = default; ~CommandManager() = default;
private: private:
std::array<CmdBuffer, MAX_FRAMES_IN_FLIGHT> _cmd_buffers; std::array<CommandBuffer, MAX_FRAMES_IN_FLIGHT> m_cmd_buffers;
CmdPool _cmd_pool; CommandPool m_cmd_pool;
}; };
} }

20
src/renderer/command/vk_cmd_pool.h → runtime/Includes/Renderer/Command/CommandPool.h
View File

@@ -1,12 +1,12 @@
/* ************************************************************************** */ /* ************************************************************************** */
/* */ /* */
/* ::: :::::::: */ /* ::: :::::::: */
/* vk_cmd_pool.h :+: :+: :+: */ /* CommandPool.h :+: :+: :+: */
/* +:+ +:+ +:+ */ /* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */ /* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/06 18:24:12 by maldavid #+# #+# */ /* Created: 2022/10/06 18:24:12 by maldavid #+# #+# */
/* Updated: 2024/03/25 19:12:14 by maldavid ### ########.fr */ /* Updated: 2024/03/27 22:33:15 by maldavid ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@@ -15,17 +15,21 @@
namespace mlx namespace mlx
{ {
class CmdPool class CommandPool
{ {
public: public:
void init(); CommandPool() = default;
void destroy() noexcept;
inline VkCommandPool& operator()() noexcept { return _cmd_pool; } void Init();
inline VkCommandPool& get() noexcept { return _cmd_pool; } void Destroy() noexcept;
inline VkCommandPool& operator()() noexcept { return m_cmd_pool; }
inline VkCommandPool& Get() noexcept { return m_cmd_pool; }
~CommandPool() = default;
private: private:
VkCommandPool _cmd_pool = VK_NULL_HANDLE; VkCommandPool m_cmd_pool = VK_NULL_HANDLE;
}; };
} }

29
src/renderer/core/cmd_resource.h → runtime/Includes/Renderer/Command/CommandResource.h
View File

@@ -1,42 +1,37 @@
/* ************************************************************************** */ /* ************************************************************************** */
/* */ /* */
/* ::: :::::::: */ /* ::: :::::::: */
/* cmd_resource.h :+: :+: :+: */ /* CommandResource.h :+: :+: :+: */
/* +:+ +:+ +:+ */ /* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */ /* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2023/12/16 20:44:29 by maldavid #+# #+# */ /* Created: 2023/12/16 20:44:29 by maldavid #+# #+# */
/* Updated: 2024/03/25 19:12:08 by maldavid ### ########.fr */ /* Updated: 2024/03/27 22:37:06 by maldavid ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#ifndef __MLX_COMMAND_RESOURCE__ #ifndef __MLX_COMMAND_RESOURCE__
#define __MLX_COMMAND_RESOURCE__ #define __MLX_COMMAND_RESOURCE__
#include <core/UUID.h> #include <Renderer/Enums.h>
#include <Core/UUID.h>
namespace mlx namespace mlx
{ {
class CmdResource class CommandResource
{ {
friend class SingleTimeCmdManager; friend class SingleTimeCmdManager;
public:
enum class state
{
in_cmd_buffer = 0,
out_cmd_buffer,
};
public: public:
CmdResource() : _uuid() {} CommandResource() : m_uuid() {}
inline void recordedInCmdBuffer() noexcept { _state = state::in_cmd_buffer; } inline void RecordedInCmdBuffer() noexcept { m_state = CommandResourceState::Held; }
inline void removedFromCmdBuffer() noexcept { _state = state::out_cmd_buffer; } inline void RemovedFromCmdBuffer() noexcept { m_state = CommandResourceState::Free; }
inline UUID getUUID() const noexcept { return _uuid; } inline UUID GetUUID() const noexcept { return m_uuid; }
virtual ~CmdResource() = default; virtual ~CommandResource() = default;
private: private:
UUID _uuid; UUID m_uuid;
state _state = state::out_cmd_buffer; CommandResourceState m_state = CommandResourceState::Free;
}; };
} }

28
src/renderer/command/single_time_cmd_manager.h → runtime/Includes/Renderer/Command/SingleTimeCmdManager.h
View File

@@ -1,48 +1,48 @@
/* ************************************************************************** */ /* ************************************************************************** */
/* */ /* */
/* ::: :::::::: */ /* ::: :::::::: */
/* single_time_cmd_manager.h :+: :+: :+: */ /* SingleTimeCmdManager.h :+: :+: :+: */
/* +:+ +:+ +:+ */ /* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */ /* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2023/12/15 18:25:57 by maldavid #+# #+# */ /* Created: 2023/12/15 18:25:57 by maldavid #+# #+# */
/* Updated: 2024/03/25 19:12:20 by maldavid ### ########.fr */ /* Updated: 2024/03/27 22:46:48 by maldavid ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#ifndef __MLX_SINGLE_TIME_CMD_MANAGER__ #ifndef __MLX_SINGLE_TIME_CMD_MANAGER__
#define __MLX_SINGLE_TIME_CMD_MANAGER__ #define __MLX_SINGLE_TIME_CMD_MANAGER__
#include <renderer/command/vk_cmd_buffer.h> #include <Renderer/Command/CommandBuffer.h>
#include <renderer/command/vk_cmd_pool.h> #include <Renderer/Command/CommandPool.h>
namespace mlx namespace mlx
{ {
class CmdBuffer; class CommandBuffer;
class SingleTimeCmdManager class SingleTimeCmdManager
{ {
friend class Render_Core; friend class RenderCore;
public: public:
SingleTimeCmdManager() = default; SingleTimeCmdManager() = default;
void init() noexcept; void Init() noexcept;
void destroy() noexcept; void Destroy() noexcept;
void updateSingleTimesCmdBuffersSubmitState() noexcept; void UpdateSingleTimesCmdBuffersSubmitState() noexcept;
void waitForAllExecutions() noexcept; void WaitForAllExecutions() noexcept;
inline CmdPool& getCmdPool() noexcept { return _pool; } inline CommandPool& GetCmdPool() noexcept { return m_pool; }
CmdBuffer& getCmdBuffer() noexcept; CommanddBuffer& GetCmdBuffer() noexcept;
~SingleTimeCmdManager() = default; ~SingleTimeCmdManager() = default;
inline static constexpr const std::uint8_t BASE_POOL_SIZE = 16; inline static constexpr const std::uint8_t BASE_POOL_SIZE = 16;
private: private:
std::vector<CmdBuffer> _buffers; std::vector<CommanddBuffer> m_buffers;
CmdPool _pool; CommanddPool m_pool;
}; };
} }

24
src/renderer/core/vk_device.h → runtime/Includes/Renderer/Core/Device.h
View File

@@ -1,12 +1,12 @@
/* ************************************************************************** */ /* ************************************************************************** */
/* */ /* */
/* ::: :::::::: */ /* ::: :::::::: */
/* vk_device.h :+: :+: :+: */ /* Device.h :+: :+: :+: */
/* +:+ +:+ +:+ */ /* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */ /* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/08 19:13:42 by maldavid #+# #+# */ /* Created: 2022/10/08 19:13:42 by maldavid #+# #+# */
/* Updated: 2024/03/25 22:31:46 by maldavid ### ########.fr */ /* Updated: 2024/03/27 22:47:21 by maldavid ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@@ -18,22 +18,22 @@ namespace mlx
class Device class Device
{ {
public: public:
void init(); void Init();
void destroy() noexcept; void Destroy() noexcept;
inline VkDevice& operator()() noexcept { return _device; } inline VkDevice& operator()() noexcept { return m_device; }
inline VkDevice& get() noexcept { return _device; } inline VkDevice& Get() noexcept { return m_device; }
inline VkPhysicalDevice& getPhysicalDevice() noexcept { return _physical_device; } inline VkPhysicalDevice& GetPhysicalDevice() noexcept { return m_physical_device; }
private: private:
void pickPhysicalDevice(); void PickPhysicalDevice();
bool checkDeviceExtensionSupport(VkPhysicalDevice device); bool CheckDeviceExtensionSupport(VkPhysicalDevice device);
int deviceScore(VkPhysicalDevice device); int DeviceScore(VkPhysicalDevice device);
private: private:
VkPhysicalDevice _physical_device = VK_NULL_HANDLE; VkPhysicalDevice m_physical_device = VK_NULL_HANDLE;
VkDevice _device = VK_NULL_HANDLE; VkDevice m_device = VK_NULL_HANDLE;
}; };
} }

8
src/renderer/core/drawable_resource.h → runtime/Includes/Renderer/Core/DrawableResource.h
View File

@@ -1,12 +1,12 @@
/* ************************************************************************** */ /* ************************************************************************** */
/* */ /* */
/* ::: :::::::: */ /* ::: :::::::: */
/* drawable_resource.h :+: :+: :+: */ /* DrawableResource.h :+: :+: :+: */
/* +:+ +:+ +:+ */ /* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */ /* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/01/10 21:00:37 by maldavid #+# #+# */ /* Created: 2024/01/10 21:00:37 by maldavid #+# #+# */
/* Updated: 2024/03/25 19:12:05 by maldavid ### ########.fr */ /* Updated: 2024/03/27 22:47:32 by maldavid ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@@ -19,8 +19,8 @@ namespace mlx
{ {
public: public:
DrawableResource() = default; DrawableResource() = default;
virtual void render(std::array<VkDescriptorSet, 2>& sets, class Renderer& renderer) = 0; virtual void Render(std::array<VkDescriptorSet, 2>& sets, class Renderer& renderer) = 0;
virtual void resetUpdate() {} virtual void ResetUpdate() {}
virtual ~DrawableResource() = default; virtual ~DrawableResource() = default;
}; };
} }

20
src/renderer/core/vk_fence.h → runtime/Includes/Renderer/Core/Fence.h
View File

@@ -1,12 +1,12 @@
/* ************************************************************************** */ /* ************************************************************************** */
/* */ /* */
/* ::: :::::::: */ /* ::: :::::::: */
/* vk_fence.h :+: :+: :+: */ /* Fence.h :+: :+: :+: */
/* +:+ +:+ +:+ */ /* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */ /* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2023/04/02 17:52:09 by maldavid #+# #+# */ /* Created: 2023/04/02 17:52:09 by maldavid #+# #+# */
/* Updated: 2024/03/25 19:11:53 by maldavid ### ########.fr */ /* Updated: 2024/03/27 22:48:31 by maldavid ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@@ -20,20 +20,20 @@ namespace mlx
public: public:
Fence() = default; Fence() = default;
void init(); void Init();
inline VkFence& get() noexcept { return _fence; } inline VkFence& Get() noexcept { return m_fence; }
void wait() noexcept; void Wait() noexcept;
void reset() noexcept; void Reset() noexcept;
bool isReady() const noexcept; bool IsReady() const noexcept;
inline void waitAndReset() noexcept { wait(); reset(); } MLX_FORCEINLINE void WaitAndReset() noexcept { Wait(); Reset(); }
void destroy() noexcept; void Destroy() noexcept;
~Fence() = default; ~Fence() = default;
private: private:
VkFence _fence = VK_NULL_HANDLE; VkFence m_fence = VK_NULL_HANDLE;
}; };
} }

18
src/renderer/core/vk_instance.h → runtime/Includes/Renderer/Core/Instance.h
View File

@@ -1,12 +1,12 @@
/* ************************************************************************** */ /* ************************************************************************** */
/* */ /* */
/* ::: :::::::: */ /* ::: :::::::: */
/* vk_instance.h :+: :+: :+: */ /* Instance.h :+: :+: :+: */
/* +:+ +:+ +:+ */ /* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */ /* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/08 19:03:04 by maldavid #+# #+# */ /* Created: 2022/10/08 19:03:04 by maldavid #+# #+# */
/* Updated: 2024/03/25 19:11:50 by maldavid ### ########.fr */ /* Updated: 2024/03/27 22:48:55 by maldavid ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@@ -18,15 +18,17 @@ namespace mlx
class Instance class Instance
{ {
public: public:
void init(); void Init();
void destroy() noexcept; void Destroy() noexcept;
inline VkInstance& operator()() noexcept { return _instance; } inline VkInstance& operator()() noexcept { return m_instance; }
inline VkInstance& get() noexcept { return _instance; } inline VkInstance& Get() noexcept { return m_instance; }
private: private:
std::vector<const char*> getRequiredExtensions(); std::vector<const char*> GetRequiredExtensions();
VkInstance _instance = VK_NULL_HANDLE;
private:
VkInstance m_instance = VK_NULL_HANDLE;
}; };
} }

30
src/renderer/core/memory.h → runtime/Includes/Renderer/Core/Memory.h
View File

@@ -1,12 +1,12 @@
/* ************************************************************************** */ /* ************************************************************************** */
/* */ /* */
/* ::: :::::::: */ /* ::: :::::::: */
/* memory.h :+: :+: :+: */ /* Memory.h :+: :+: :+: */
/* +:+ +:+ +:+ */ /* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */ /* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/20 02:13:03 by maldavid #+# #+# */ /* Created: 2023/10/20 02:13:03 by maldavid #+# #+# */
/* Updated: 2024/03/25 19:12:02 by maldavid ### ########.fr */ /* Updated: 2024/03/27 22:49:57 by maldavid ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@@ -20,28 +20,28 @@ namespace mlx
public: public:
GPUallocator() = default; GPUallocator() = default;
void init() noexcept; void Init() noexcept;
void destroy() noexcept; void Destroy() noexcept;
VmaAllocation createBuffer(const VkBufferCreateInfo* binfo, const VmaAllocationCreateInfo* vinfo, VkBuffer& buffer, const char* name = nullptr) noexcept; VmaAllocation CreateBuffer(const VkBufferCreateInfo* binfo, const VmaAllocationCreateInfo* vinfo, VkBuffer& buffer, const char* name = nullptr) noexcept;
void destroyBuffer(VmaAllocation allocation, VkBuffer buffer) noexcept; void DestroyBuffer(VmaAllocation allocation, VkBuffer buffer) noexcept;
VmaAllocation createImage(const VkImageCreateInfo* iminfo, const VmaAllocationCreateInfo* vinfo, VkImage& image, const char* name = nullptr) noexcept; VmaAllocation CreateImage(const VkImageCreateInfo* iminfo, const VmaAllocationCreateInfo* vinfo, VkImage& image, const char* name = nullptr) noexcept;
void destroyImage(VmaAllocation allocation, VkImage image) noexcept; void DestroyImage(VmaAllocation allocation, VkImage image) noexcept;
void mapMemory(VmaAllocation allocation, void** data) noexcept; void MapMemory(VmaAllocation allocation, void** data) noexcept;
void unmapMemory(VmaAllocation allocation) noexcept; void UnmapMemory(VmaAllocation allocation) noexcept;
void dumpMemoryToJson(); void DumpMemoryToJson();
void flush(VmaAllocation allocation, VkDeviceSize size, VkDeviceSize offset) noexcept; void Flush(VmaAllocation allocation, VkDeviceSize size, VkDeviceSize offset) noexcept;
~GPUallocator() = default; ~GPUallocator() = default;
private: private:
VmaAllocator _allocator; VmaAllocator m_allocator;
std::int32_t _active_buffers_allocations = 0; std::int32_t m_active_buffers_allocations = 0;
std::int32_t _active_images_allocations = 0; std::int32_t m_active_images_allocations = 0;
}; };
} }

29
src/renderer/core/vk_queues.h → runtime/Includes/Renderer/Core/Queues.h
View File

@@ -1,20 +1,18 @@
/* ************************************************************************** */ /* ************************************************************************** */
/* */ /* */
/* ::: :::::::: */ /* ::: :::::::: */
/* vk_queues.h :+: :+: :+: */ /* Queues.h :+: :+: :+: */
/* +:+ +:+ +:+ */ /* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */ /* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/08 19:01:49 by maldavid #+# #+# */ /* Created: 2022/10/08 19:01:49 by maldavid #+# #+# */
/* Updated: 2024/03/25 22:29:26 by maldavid ### ########.fr */ /* Updated: 2024/03/27 22:50:52 by maldavid ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#ifndef __MLX_VK_QUEUES__ #ifndef __MLX_VK_QUEUES__
#define __MLX_VK_QUEUES__ #define __MLX_VK_QUEUES__
#include <core/errors.h>
namespace mlx namespace mlx
{ {
class Queues class Queues
@@ -28,24 +26,25 @@ namespace mlx
inline bool isComplete() { return graphics_family.has_value() && present_family.has_value(); } inline bool isComplete() { return graphics_family.has_value() && present_family.has_value(); }
}; };
QueueFamilyIndices findQueueFamilies(VkPhysicalDevice device); public:
QueueFamilyIndices FindQueueFamilies(VkPhysicalDevice device);
void init(); void Init();
inline VkQueue& getGraphic() noexcept { return _graphics_queue; } inline VkQueue& GetGraphic() noexcept { return _graphics_queue; }
inline VkQueue& getPresent() noexcept { return _present_queue; } inline VkQueue& GetPresent() noexcept { return _present_queue; }
inline QueueFamilyIndices getFamilies() noexcept inline QueueFamilyIndices GetFamilies() noexcept
{ {
if(_families.has_value()) if(m_families.has_value())
return *_families; return *m_families;
core::error::report(e_kind::fatal_error, "Vulkan : cannot get queue families, not init"); FatalError("Vulkan : cannot get queue families, not init");
return {}; // just to avoid warnings return {}; // just to avoid warnings
} }
private: private:
VkQueue _graphics_queue; VkQueue m_graphics_queue;
VkQueue _present_queue; VkQueue m_present_queue;
std::optional<QueueFamilyIndices> _families; std::optional<QueueFamilyIndices> m_families;
}; };
} }

78
runtime/Includes/Renderer/Core/RenderCore.h git.filemode.normal_file
View File

@@ -0,0 +1,78 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* RenderCore.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/08 19:16:32 by maldavid #+# #+# */
/* Updated: 2024/03/27 22:55:43 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_RENDER_CORE__
#define __MLX_RENDER_CORE__
#include <Renderer/Command/SingleTimeCmdManager.h>
#include <Renderer/Descriptors/DescriptorPoolManager.h>
#include <Renderer/Descriptors/DescriptorPool.h>
#include <Renderer/Core/Queues.h>
#include <Renderer/Core/Device.h>
#include <Renderer/Core/Instance.h>
#include <Renderer/Core/ValidationLayers.h>
#include <Renderer/Core/memory.h>
#include <Utils/Singleton.h>
namespace mlx
{
const char* VerbaliseVkResult(VkResult result);
VkPipelineStageFlags AccessFlagsToPipelineStage(VkAccessFlags access_flags, VkPipelineStageFlags stage_flags);
#ifdef DEBUG
constexpr const bool enable_validation_layers = true;
#else
constexpr const bool enable_validation_layers = false;
#endif
const std::vector<const char*> validation_layers = { "VK_LAYER_KHRONOS_validation" };
constexpr const int MAX_FRAMES_IN_FLIGHT = 3;
constexpr const int MAX_SETS_PER_POOL = 512;
constexpr const int NUMBER_OF_UNIFORM_BUFFERS = 1; // change this if for wathever reason more than one uniform buffer is needed
class RenderCore : public Singleton<RenderCore>
{
friend class Singleton<RenderCore>;
public:
void Init();
void Destroy();
inline bool IsInit() const noexcept { return m_is_init; }
inline Instance& GetInstance() noexcept { return m_instance; }
inline Device& GetDevice() noexcept { return m_device; }
inline Queues& GetQueue() noexcept { return m_queues; }
inline GPUallocator& GetAllocator() noexcept { return m_allocator; }
inline ValidationLayers& GetLayers() noexcept { return m_layers; }
inline CommandBuffer& GetSingleTimeCmdBuffer() noexcept { return m_cmd_manager.GetCmdBuffer(); }
inline SingleTimeCmdManager& GetSingleTimeCmdManager() noexcept { return m_cmd_manager; }
inline DescriptorPool& GetDescriptorPool() { return m_pool_manager.GetAvailablePool(); }
private:
RenderCore() = default;
~RenderCore() = default;
private:
ValidationLayers m_layers;
SingleTimeCmdManager m_cmd_manager;
Queues m_queues;
DescriptorPoolManager m_pool_manager;
Device m_device;
Instance m_instance;
GPUallocator m_allocator;
bool m_is_init = false;
};
}
#endif // __MLX_RENDER_CORE__

14
src/renderer/core/vk_semaphore.h → runtime/Includes/Renderer/Core/Semaphore.h
View File

@@ -1,12 +1,12 @@
/* ************************************************************************** */ /* ************************************************************************** */
/* */ /* */
/* ::: :::::::: */ /* ::: :::::::: */
/* vk_semaphore.h :+: :+: :+: */ /* Semaphore.h :+: :+: :+: */
/* +:+ +:+ +:+ */ /* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */ /* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/08 18:59:38 by maldavid #+# #+# */ /* Created: 2022/10/08 18:59:38 by maldavid #+# #+# */
/* Updated: 2024/03/25 19:11:43 by maldavid ### ########.fr */ /* Updated: 2024/03/27 22:56:51 by maldavid ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@@ -18,15 +18,13 @@ namespace mlx
class Semaphore class Semaphore
{ {
public: public:
void init(); void Init();
void destroy() noexcept; void Destroy() noexcept;
inline VkSemaphore& getImageSemaphore() noexcept { return _image_available_semaphore; } inline VkSemaphore& Get() noexcept { return m_semaphore; }
inline VkSemaphore& getRenderImageSemaphore() noexcept { return _render_finished_semaphore; }
private: private:
VkSemaphore _image_available_semaphore = VK_NULL_HANDLE; VkSemaphore m_semaphore = VK_NULL_HANDLE;
VkSemaphore _render_finished_semaphore = VK_NULL_HANDLE;
}; };
} }

16
src/renderer/core/vk_surface.h → runtime/Includes/Renderer/Core/Surface.h
View File

@@ -1,12 +1,12 @@
/* ************************************************************************** */ /* ************************************************************************** */
/* */ /* */
/* ::: :::::::: */ /* ::: :::::::: */
/* vk_surface.h :+: :+: :+: */ /* Surface.h :+: :+: :+: */
/* +:+ +:+ +:+ */ /* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */ /* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/08 18:57:55 by maldavid #+# #+# */ /* Created: 2022/10/08 18:57:55 by maldavid #+# #+# */
/* Updated: 2024/03/25 19:10:59 by maldavid ### ########.fr */ /* Updated: 2024/03/27 22:58:15 by maldavid ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@@ -18,16 +18,16 @@ namespace mlx
class Surface class Surface
{ {
public: public:
void create(class Renderer& renderer); void Create(class Renderer& renderer);
void destroy() noexcept; void Destroy() noexcept;
VkSurfaceFormatKHR chooseSwapSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& availableFormats); VkSurfaceFormatKHR ChooseSwapSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& available_formats);
inline VkSurfaceKHR& operator()() noexcept { return _surface; } inline VkSurfaceKHR& operator()() noexcept { return m_surface; }
inline VkSurfaceKHR& get() noexcept { return _surface; } inline VkSurfaceKHR& Get() noexcept { return m_surface; }
private: private:
VkSurfaceKHR _surface = VK_NULL_HANDLE; VkSurfaceKHR m_surface = VK_NULL_HANDLE;
}; };
} }

24
src/renderer/core/vk_validation_layers.h → runtime/Includes/Renderer/Core/ValidationLayers.h
View File

@@ -1,12 +1,12 @@
/* ************************************************************************** */ /* ************************************************************************** */
/* */ /* */
/* ::: :::::::: */ /* ::: :::::::: */
/* vk_validation_layers.h :+: :+: :+: */ /* ValidationLayers.h :+: :+: :+: */
/* +:+ +:+ +:+ */ /* +:+ +:+ +:+ */
/* By: maldavid <marvin@42.fr> +#+ +:+ +#+ */ /* By: maldavid <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/19 14:04:25 by maldavid #+# #+# */ /* Created: 2022/12/19 14:04:25 by maldavid #+# #+# */
/* Updated: 2024/03/25 19:00:00 by maldavid ### ########.fr */ /* Updated: 2024/03/27 22:59:00 by maldavid ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@@ -20,24 +20,24 @@ namespace mlx
public: public:
ValidationLayers() = default; ValidationLayers() = default;
void init(); void Init();
void destroy(); void Destroy();
bool checkValidationLayerSupport(); bool CheckValidationLayerSupport();
void populateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT& createInfo); void PopulateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT& create_info);
VkResult setDebugUtilsObjectNameEXT(VkObjectType object_type, std::uint64_t object_handle, const char* object_name); VkResult SetDebugUtilsObjectNameEXT(VkObjectType object_type, std::uint64_t object_handle, const char* object_name);
~ValidationLayers() = default; ~ValidationLayers() = default;
private: private:
VkResult createDebugUtilsMessengerEXT(const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator); VkResult CreateDebugUtilsMessengerEXT(const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator);
static VKAPI_ATTR VkBool32 VKAPI_CALL debugCallback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageType, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, void* pUserData); static VKAPI_ATTR VkBool32 VKAPI_CALL DebugCallback(VkDebugUtilsMessageSeverityFlagBitsEXT message_severity, VkDebugUtilsMessageTypeFlagsEXT message_type, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, void* pUserData);
void destroyDebugUtilsMessengerEXT(const VkAllocationCallbacks* pAllocator); void DestroyDebugUtilsMessengerEXT(const VkAllocationCallbacks* pAllocator);
private: private:
VkDebugUtilsMessengerEXT _debug_messenger; VkDebugUtilsMessengerEXT m_debug_messenger;
PFN_vkSetDebugUtilsObjectNameEXT _vkSetDebugUtilsObjectNameEXT = nullptr; PFN_vkSetDebugUtilsObjectNameEXT f_vkSetDebugUtilsObjectNameEXT = nullptr;
}; };
} }

22
src/renderer/descriptors/vk_descriptor_pool.h → runtime/Includes/Renderer/Descriptors/DescriptorPool.h
View File

@@ -1,12 +1,12 @@
/* ************************************************************************** */ /* ************************************************************************** */
/* */ /* */
/* ::: :::::::: */ /* ::: :::::::: */
/* vk_descriptor_pool.h :+: :+: :+: */ /* DescriptorPool.h :+: :+: :+: */
/* +:+ +:+ +:+ */ /* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */ /* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2023/01/23 18:32:43 by maldavid #+# #+# */ /* Created: 2023/01/23 18:32:43 by maldavid #+# #+# */
/* Updated: 2024/03/25 19:10:09 by maldavid ### ########.fr */ /* Updated: 2024/03/27 23:00:29 by maldavid ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@@ -20,21 +20,21 @@ namespace mlx
public: public:
DescriptorPool() = default; DescriptorPool() = default;
void init(std::size_t n, VkDescriptorPoolSize* size); void Init(std::size_t n, NonOwningPtr<VkDescriptorPoolSize> size);
void freeDescriptor(const class DescriptorSet& set); void FreeDescriptor(const class DescriptorSet& set);
void destroy() noexcept; void Destroy() noexcept;
inline VkDescriptorPool& operator()() noexcept { return _pool; } inline VkDescriptorPool& operator()() noexcept { return m_pool; }
inline VkDescriptorPool& get() noexcept { return _pool; } inline VkDescriptorPool& Get() noexcept { return m_pool; }
inline std::size_t getNumberOfSetsAllocated() const noexcept { return _allocated_sets; } inline std::size_t GetNumberOfSetsAllocated() const noexcept { return m_allocated_sets; }
inline bool isInit() const noexcept { return _pool != VK_NULL_HANDLE; } inline bool IsInit() const noexcept { return m_pool != VK_NULL_HANDLE; }
~DescriptorPool() = default; ~DescriptorPool() = default;
private: private:
VkDescriptorPool _pool = VK_NULL_HANDLE; VkDescriptorPool m_pool = VK_NULL_HANDLE;
std::size_t _allocated_sets = 0; std::size_t m_allocated_sets = 0;
}; };
} }

12
src/renderer/descriptors/descriptor_pool_manager.h → runtime/Includes/Renderer/Descriptors/DescriptorPoolManager.h
View File

@@ -1,19 +1,19 @@
/* ************************************************************************** */ /* ************************************************************************** */
/* */ /* */
/* ::: :::::::: */ /* ::: :::::::: */
/* descriptor_pool_manager.h :+: :+: :+: */ /* DescriptorPoolManager.h :+: :+: :+: */
/* +:+ +:+ +:+ */ /* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */ /* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/01/20 06:26:26 by maldavid #+# #+# */ /* Created: 2024/01/20 06:26:26 by maldavid #+# #+# */
/* Updated: 2024/03/25 19:10:12 by maldavid ### ########.fr */ /* Updated: 2024/03/27 23:00:56 by maldavid ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#ifndef __MLX_DESCRIPTOR_POOL_MANAGER__ #ifndef __MLX_DESCRIPTOR_POOL_MANAGER__
#define __MLX_DESCRIPTOR_POOL_MANAGER__ #define __MLX_DESCRIPTOR_POOL_MANAGER__
#include <renderer/descriptors/vk_descriptor_pool.h> #include <Renderer/Descriptors/DescriptorPool.h>
namespace mlx namespace mlx
{ {
@@ -22,13 +22,13 @@ namespace mlx
public: public:
DescriptorPoolManager() = default; DescriptorPoolManager() = default;
DescriptorPool& getAvailablePool(); // assumes the pool is for only one set allocation, may cause some issues if this is for more than one DescriptorPool& GetAvailablePool(); // assumes the pool is for only one set allocation, may cause some issues if this is for more than one
void destroyAllPools(); void DestroyAllPools();
~DescriptorPoolManager() = default; ~DescriptorPoolManager() = default;
private: private:
std::list<DescriptorPool> _pools; std::list<DescriptorPool> m_pools;
}; };
} }

30
src/renderer/descriptors/vk_descriptor_set.h → runtime/Includes/Renderer/Descriptors/DescriptorSet.h
View File

@@ -1,19 +1,19 @@
/* ************************************************************************** */ /* ************************************************************************** */
/* */ /* */
/* ::: :::::::: */ /* ::: :::::::: */
/* vk_descriptor_set.h :+: :+: :+: */ /* DescriptorSet.h :+: :+: :+: */
/* +:+ +:+ +:+ */ /* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */ /* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2023/01/23 18:39:36 by maldavid #+# #+# */ /* Created: 2023/01/23 18:39:36 by maldavid #+# #+# */
/* Updated: 2024/03/25 19:10:06 by maldavid ### ########.fr */ /* Updated: 2024/03/27 23:02:38 by maldavid ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#ifndef __VK_DESCRIPTOR_SET__ #ifndef __VK_DESCRIPTOR_SET__
#define __VK_DESCRIPTOR_SET__ #define __VK_DESCRIPTOR_SET__
#include <renderer/core/render_core.h> #include <Renderer/Core/RenderCore.h>
namespace mlx namespace mlx
{ {
@@ -22,29 +22,29 @@ namespace mlx
public: public:
DescriptorSet() = default; DescriptorSet() = default;
void init(class Renderer* renderer, class DescriptorPool* pool, class DescriptorSetLayout* layout); void Init(class Renderer* renderer, class DescriptorPool* pool, class DescriptorSetLayout* layout);
void writeDescriptor(int binding, class UBO* ubo) const noexcept; void WriteDescriptor(int binding, NonOwningPtr<class UniformBuffer> ubo) const noexcept;
void writeDescriptor(int binding, const class Image& image) const noexcept; void WriteDescriptor(int binding, const class Image& image) const noexcept;
inline bool isInit() const noexcept { return _pool != nullptr && _renderer != nullptr; } inline bool IsInit() const noexcept { return m_pool != nullptr && m_renderer != nullptr; }
DescriptorSet duplicate(); DescriptorSet Duplicate();
VkDescriptorSet& operator()() noexcept; VkDescriptorSet& operator()() noexcept;
VkDescriptorSet& get() noexcept; VkDescriptorSet& Get() noexcept;
inline const std::array<VkDescriptorSet, MAX_FRAMES_IN_FLIGHT>& getAllFramesDescriptorSets() const { return _desc_set; } inline const std::array<VkDescriptorSet, MAX_FRAMES_IN_FLIGHT>& GetAllFramesDescriptorSets() const { return m_desc_set; }
void destroy() noexcept; void Destroy() noexcept;
~DescriptorSet() = default; ~DescriptorSet() = default;
private: private:
std::array<VkDescriptorSet, MAX_FRAMES_IN_FLIGHT> _desc_set; std::array<VkDescriptorSet, MAX_FRAMES_IN_FLIGHT> m_desc_set;
class DescriptorPool* _pool = nullptr; NonOwningPtr<class DescriptorPool> p_pool;
class DescriptorSetLayout* _layout = nullptr; NonOwningPtr<class DescriptorSetLayout> p_layout;
class Renderer* _renderer = nullptr; NonOwningPtr<class Renderer> p_renderer;
}; };
} }

18
src/renderer/descriptors/vk_descriptor_set_layout.h → runtime/Includes/Renderer/Descriptors/DescriptorSetLayout.h
View File

@@ -1,12 +1,12 @@
/* ************************************************************************** */ /* ************************************************************************** */
/* */ /* */
/* ::: :::::::: */ /* ::: :::::::: */
/* vk_descriptor_set_layout.h :+: :+: :+: */ /* DescriptorSetLayout.h :+: :+: :+: */
/* +:+ +:+ +:+ */ /* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */ /* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2023/01/23 18:36:22 by maldavid #+# #+# */ /* Created: 2023/01/23 18:36:22 by maldavid #+# #+# */
/* Updated: 2024/03/25 19:10:03 by maldavid ### ########.fr */ /* Updated: 2024/03/27 23:03:04 by maldavid ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@@ -20,18 +20,18 @@ namespace mlx
public: public:
DescriptorSetLayout() = default; DescriptorSetLayout() = default;
void init(std::vector<std::pair<int, VkDescriptorType>> binds, VkShaderStageFlagBits stage); void Init(std::vector<std::pair<int, VkDescriptorType>> binds, VkShaderStageFlagBits stage);
void destroy() noexcept; void Destroy() noexcept;
inline VkDescriptorSetLayout& operator()() noexcept { return _layout; } inline VkDescriptorSetLayout& operator()() noexcept { return m_layout; }
inline VkDescriptorSetLayout& get() noexcept { return _layout; } inline VkDescriptorSetLayout& Get() noexcept { return m_layout; }
inline const std::vector<std::pair<int, VkDescriptorType>>& getBindings() const noexcept { return _bindings; } inline const std::vector<std::pair<int, VkDescriptorType>>& GetBindings() const noexcept { return m_bindings; }
~DescriptorSetLayout() = default; ~DescriptorSetLayout() = default;
private: private:
VkDescriptorSetLayout _layout = VK_NULL_HANDLE; std::vector<std::pair<int, VkDescriptorType>> m_bindings;
std::vector<std::pair<int, VkDescriptorType>> _bindings; VkDescriptorSetLayout m_layout = VK_NULL_HANDLE;
}; };
} }

59
runtime/Includes/Renderer/Enums.h git.filemode.normal_file
View File

@@ -0,0 +1,59 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* Enums.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/03/27 22:02:58 by maldavid #+# #+# */
/* Updated: 2024/03/27 22:39:31 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_RENDERER_ENUMS__
#define __MLX_RENDERER_ENUMS__
namespace mlx
{
enum class BufferType
{
Constant = 0,
HighDynamic, // typically stored in RAM
LowDynamic, // typically stored in VRAM
EndEnum
};
constexpr std::size_t BufferTypeCount = static_cast<std::size_t>(BufferType::EndEnum);
enum class CommandResourceState
{
Held = 0,
Free,
EndEnum
};
constexpr std::size_t CommandResourceStateCount = static_cast<std::size_t>(CommandResourceState::EndEnum);
enum class CommandBufferState
{
Uninit = 0, // buffer not initialized or destroyed
Ready, // buffer ready to be used after having been submitted
Idle, // buffer has recorded informations but has not been submitted
Recording, // buffer is currently recording
Submitted, // buffer has been submitted
EndEnum
};
constexpr std::size_t CommandBufferStateCount = static_cast<std::size_t>(CommandBufferState::EndEnum);
enum class CommandBufferType
{
SingleTime = 0,
LongTime,
EndEnum
};
constexpr std::size_t CommandBufferTypeCount = static_cast<std::size_t>(CommandBufferType::EndEnum);
}
#endif

0
src/renderer/images/vk_image.h → runtime/Includes/Renderer/Images/Image.h
View File

0
src/renderer/images/texture.h → runtime/Includes/Renderer/Images/Texture.h
View File

0
src/renderer/images/texture_atlas.h → runtime/Includes/Renderer/Images/TextureAtlas.h
View File

0
src/renderer/images/texture_descriptor.h → runtime/Includes/Renderer/Images/TextureDescriptor.h
View File

0
src/renderer/images/texture_manager.h → runtime/Includes/Renderer/Images/TextureManager.h
View File

0
src/renderer/pipeline/pipeline.h → runtime/Includes/Renderer/Pipelines/Pipeline.h
View File

0
src/renderer/pixel_put.h → runtime/Includes/Renderer/PixelPut.h
View File

0
src/renderer/renderer.h → runtime/Includes/Renderer/Renderer.h
View File

0
src/renderer/renderpass/vk_framebuffer.h → runtime/Includes/Renderer/Renderpass/FrameBuffer.h
View File

0
src/renderer/renderpass/vk_render_pass.h → runtime/Includes/Renderer/Renderpass/RenderPass.h
View File

0
src/renderer/swapchain/vk_swapchain.h → runtime/Includes/Renderer/Renderpass/Swapchain.h
View File

0
src/renderer/texts/font.h → runtime/Includes/Renderer/Texts/Font.h
View File

0
src/renderer/texts/font_library.h → runtime/Includes/Renderer/Texts/FontLibrary.h
View File

0
src/renderer/texts/text.h → runtime/Includes/Renderer/Texts/Text.h
View File

0
src/renderer/texts/text_descriptor.h → runtime/Includes/Renderer/Texts/TextDescriptor.h
View File

0
src/renderer/texts/text_library.h → runtime/Includes/Renderer/Texts/TextLibrary.h
View File

0
src/renderer/texts/text_manager.h → runtime/Includes/Renderer/Texts/TextManager.h
View File

56
runtime/Includes/Utils/Ansi.h git.filemode.normal_file
View File

@@ -0,0 +1,56 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* Ansi.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/03/27 17:22:41 by maldavid #+# #+# */
/* Updated: 2024/03/27 17:23:34 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_ANSI__
#define __MLX_ANSI__
#include <ostream>
#include <cstdint>
namespace mlx
{
enum class Ansi : std::uint32_t
{
red = 31,
green = 32,
blue = 34,
def = 0,
black = 30,
yellow = 33,
magenta = 35,
cyan = 36,
white = 37,
bg_red = 41,
bg_green = 42,
bg_blue = 44,
bg_def = 0,
bg_black = 40,
bg_yellow = 43,
bg_magenta = 45,
bg_cyan = 46,
bg_white = 47,
reset = 0,
bold = 1,
underline = 4,
inverse = 7,
bold_off = 21,
underline_off = 24,
inverse_off = 27
};
inline std::ostream& operator<<(std::ostream& os, Ansi ansi)
{
return os << "\033[1;" << std::to_string(static_cast<std::uint32_t>(ansi)) << "m";
}
}
#endif

13
src/utils/combine_hash.h → runtime/Includes/Utils/CombineHash.h
View File

@@ -1,31 +1,28 @@
/* ************************************************************************** */ /* ************************************************************************** */
/* */ /* */
/* ::: :::::::: */ /* ::: :::::::: */
/* combine_hash.h :+: :+: :+: */ /* CombineHash.h :+: :+: :+: */
/* +:+ +:+ +:+ */ /* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */ /* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2023/12/14 16:16:06 by maldavid #+# #+# */ /* Created: 2023/12/14 16:16:06 by maldavid #+# #+# */
/* Updated: 2024/03/25 19:06:37 by maldavid ### ########.fr */ /* Updated: 2024/03/27 21:59:30 by maldavid ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#ifndef __MLX_HASH__ #ifndef __MLX_HASH__
#define __MLX_HASH__ #define __MLX_HASH__
#include <cstddef>
#include <functional>
namespace mlx namespace mlx
{ {
inline void hashCombine([[maybe_unused]] std::size_t& seed) noexcept {} inline void HashCombine([[maybe_unused]] std::size_t& seed) noexcept {}
template <typename T, typename... Rest> template <typename T, typename... Rest>
inline void hashCombine(std::size_t& seed, const T& v, Rest... rest) inline void HashCombine(std::size_t& seed, const T& v, Rest... rest)
{ {
std::hash<T> hasher; std::hash<T> hasher;
seed ^= hasher(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2); seed ^= hasher(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
hashCombine(seed, rest...); HashCombine(seed, rest...);
} }
} }

69
runtime/Includes/Utils/ConstMap.h git.filemode.normal_file
View File

@@ -0,0 +1,69 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ConstMap.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/03/27 15:26:39 by maldavid #+# #+# */
/* Updated: 2024/03/27 21:59:35 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_CONST_MAP__
#define __MLX_CONST_MAP__
namespace mlx
{
template<typename Key, typename Value>
class ConstMap
{
public:
using ValueType = std::pair<Key, Value>;
using ContainerType = std::vector<ValueType>;
using iterator = typename ContainerType::const_iterator;
using const_iterator = iterator;
public:
ConstMap(std::initializer_list<ValueType> init) : m_container(init)
{
std::sort(m_container.begin(), m_container.end());
}
ConstMap(ContainerType container) : m_container(std::move(container))
{
std::sort(m_container.begin(), m_container.end());
}
inline const_iterator begin() const { return m_container.begin(); }
inline const_iterator end() const { return m_container.end(); }
template<typename K>
inline const_iterator Find(const K& key) const
{
const_iterator it = std::lower_bound(begin(), end(), key,
[](const ValueType& p, const K& key)
{
return p.first < key;
}
);
return it != end() && it->first == key ? it : end();
}
template<typename K>
inline bool Has(const K& key) const
{
return Find(key) != end();
}
inline std::size_t Size() const { return m_container.size(); }
~ConstMap() = default;
private:
ContainerType m_container;
};
}
#endif

6
src/utils/dogica_ttf.h → runtime/Includes/Utils/DogicaTTF.h
View File

@@ -1,20 +1,18 @@
/* ************************************************************************** */ /* ************************************************************************** */
/* */ /* */
/* ::: :::::::: */ /* ::: :::::::: */
/* dogica_ttf.h :+: :+: :+: */ /* DogicaTTF.h :+: :+: :+: */
/* +:+ +:+ +:+ */ /* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */ /* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2023/04/11 16:20:25 by maldavid #+# #+# */ /* Created: 2023/04/11 16:20:25 by maldavid #+# #+# */
/* Updated: 2024/03/25 19:05:36 by maldavid ### ########.fr */ /* Updated: 2024/03/27 21:59:40 by maldavid ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#ifndef __MLX_DOGICA_TTF__ #ifndef __MLX_DOGICA_TTF__
#define __MLX_DOGICA_TTF__ #define __MLX_DOGICA_TTF__
#include <vector>
constexpr const unsigned int dogica_ttf_len = 33860; constexpr const unsigned int dogica_ttf_len = 33860;
static const std::vector<unsigned char> dogica_ttf = { static const std::vector<unsigned char> dogica_ttf = {

6
src/utils/icon_mlx.h → runtime/Includes/Utils/IconMlx.h
View File

@@ -1,20 +1,18 @@
/* ************************************************************************** */ /* ************************************************************************** */
/* */ /* */
/* ::: :::::::: */ /* ::: :::::::: */
/* icon_mlx.h :+: :+: :+: */ /* IconMlx.h :+: :+: :+: */
/* +:+ +:+ +:+ */ /* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */ /* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2023/11/25 11:23:16 by maldavid #+# #+# */ /* Created: 2023/11/25 11:23:16 by maldavid #+# #+# */
/* Updated: 2024/03/25 19:05:28 by maldavid ### ########.fr */ /* Updated: 2024/03/27 21:59:45 by maldavid ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#ifndef __ICON_MLX__ #ifndef __ICON_MLX__
#define __ICON_MLX__ #define __ICON_MLX__
#include <cstdint>
constexpr const int logo_mlx_height = 125; constexpr const int logo_mlx_height = 125;
constexpr const int logo_mlx_width = 125; constexpr const int logo_mlx_width = 125;
constexpr const int logo_mlx_size = logo_mlx_height * logo_mlx_width * 4; constexpr const int logo_mlx_size = logo_mlx_height * logo_mlx_width * 4;

0
src/utils/non_copyable.h → runtime/Includes/Utils/NonCopyable.h
View File

45
runtime/Includes/Utils/NonOwningPtr.h git.filemode.normal_file
View File

@@ -0,0 +1,45 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* NonOwningPtr.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/03/27 21:03:37 by maldavid #+# #+# */
/* Updated: 2024/03/27 21:05:05 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_NON_OWNING_PTR__
#define __MLX_NON_OWNING_PTR__
namespace mlx
{
template<typename T>
class NonOwningPtr
{
public:
NonOwningPtr(T* ptr = nullptr);
NonOwningPtr(const NonOwningPtr&) = default;
NonOwningPtr(NonOwningPtr&& ptr) noexcept;
NonOwningPtr& operator=(T* ptr);
NonOwningPtr& operator=(const NonOwningPtr&) = default;
NonOwningPtr& operator=(NonOwningPtr&& ptr) noexcept;
inline operator bool() const noexcept;
inline T* Get() const noexcept;
inline T* operator->() const noexcept;
inline T& operator*() const noexcept;
~NonOwningPtr() = default;
private:
T* p_ptr = nullptr;
};
}
#include <Utils/NonOwningPtr.inl>
#endif

62
runtime/Includes/Utils/NonOwningPtr.inl git.filemode.normal_file
View File

@@ -0,0 +1,62 @@
/* **************************************************************************** */
/* */
/* ::: :::::::: */
/* NonOwningPtr.inl :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/03/27 21:04:00 by maldavid #+# #+# */
/* Updated: 2024/03/27 21:04:00 by maldavid ### ########.fr */
/* */
/* **************************************************************************** */
#include <Utils/NonOwningPtr.h>
namespace mlx
{
template<typename T>
NonOwningPtr<T>::NonOwningPtr(T* ptr) : p_ptr(ptr) {}
template<typename T>
NonOwningPtr<T>::NonOwningPtr(NonOwningPtr<T>&& ptr) noexcept : p_ptr(ptr.p_ptr)
{
ptr.p_ptr = nullptr;
}
template<typename T>
NonOwningPtr<T>& NonOwningPtr<T>::operator=(T* ptr)
{
p_ptr = ptr;
}
template<typename T>
NonOwningPtr<T>& NonOwningPtr<T>::operator=(NonOwningPtr&& ptr) noexcept
{
p_ptr = ptr.p_ptr;
ptr.p_ptr = nullptr;
}
template<typename T>
NonOwningPtr<T>::operator bool() const noexcept
{
return p_ptr != nullptr;
}
template<typename T>
T* NonOwningPtr<T>::Get() const noexcept
{
return p_ptr;
}
template<typename T>
T* NonOwningPtr<T>::operator->() const noexcept
{
return p_ptr;
}
template<typename T>
T& NonOwningPtr<T>::operator*() const noexcept
{
return *p_ptr;
}
}

8
src/utils/singleton.h → runtime/Includes/Utils/Singleton.h
View File

@@ -1,19 +1,19 @@
/* ************************************************************************** */ /* ************************************************************************** */
/* */ /* */
/* ::: :::::::: */ /* ::: :::::::: */
/* singleton.h :+: :+: :+: */ /* Singleton.h :+: :+: :+: */
/* +:+ +:+ +:+ */ /* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */ /* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/08 19:18:46 by maldavid #+# #+# */ /* Created: 2022/10/08 19:18:46 by maldavid #+# #+# */
/* Updated: 2024/03/24 14:42:56 by maldavid ### ########.fr */ /* Updated: 2024/03/27 18:20:11 by maldavid ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#ifndef __MLX_SINGLETON__ #ifndef __MLX_SINGLETON__
#define __MLX_SINGLETON__ #define __MLX_SINGLETON__
#include "non_copyable.h" #include <Utils/NonCopyable.h>
namespace mlx namespace mlx
{ {
@@ -21,7 +21,7 @@ namespace mlx
class Singleton : public NonCopyable class Singleton : public NonCopyable
{ {
public: public:
inline static T& get() inline static T& Get()
{ {
static T instance; static T instance;
return instance; return instance;

14
src/core/application.cpp → runtime/Sources/Core/Application.cpp
View File

@@ -1,18 +1,18 @@
/* ************************************************************************** */ /* ************************************************************************** */
/* */ /* */
/* ::: :::::::: */ /* ::: :::::::: */
/* application.cpp :+: :+: :+: */ /* Application.cpp :+: :+: :+: */
/* +:+ +:+ +:+ */ /* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */ /* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/04 22:10:52 by maldavid #+# #+# */ /* Created: 2022/10/04 22:10:52 by maldavid #+# #+# */
/* Updated: 2024/03/25 22:16:24 by maldavid ### ########.fr */ /* Updated: 2024/03/27 17:43:18 by maldavid ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include <pre_compiled.h> #include <PreCompiled.h>
#include "application.h" #include <Core/Application.h>
#include <renderer/texts/text_library.h> #include <renderer/texts/text_library.h>
#include <renderer/texts/font_library.h> #include <renderer/texts/font_library.h>
#include <renderer/images/texture.h> #include <renderer/images/texture.h>
@@ -20,11 +20,17 @@
#include <core/errors.h> #include <core/errors.h>
#include <mlx_profile.h> #include <mlx_profile.h>
#include <core/memory.h> #include <core/memory.h>
#include <Core/EventBus.h>
namespace mlx::core namespace mlx::core
{ {
Application::Application() : _fps(), _in(std::make_unique<Input>()) Application::Application() : _fps(), _in(std::make_unique<Input>())
{ {
EventBus::RegisterListener({[](const EventBase& event)
{
}, "__internal_application" });
_fps.init(); _fps.init();
glfwSetErrorCallback([]([[maybe_unused]] int code, const char* desc) glfwSetErrorCallback([]([[maybe_unused]] int code, const char* desc)
{ {

0
src/core/bridge.cpp → runtime/Sources/Core/Bridge.cpp
View File

37
runtime/Sources/Core/EventBus.cpp git.filemode.normal_file
View File

@@ -0,0 +1,37 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* EventBus.cpp :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/03/27 17:36:05 by maldavid #+# #+# */
/* Updated: 2024/03/27 17:37:01 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#include <PreCompiled.h>
#include <Core/EventBus.h>
#include <Core/Logs.h>
namespace mlx
{
void EventBus::Send(const std::string& listener_name, const EventBase& event)
{
for(const EventListener& listener : s_listeners)
{
if(listener.GetName() == listener_name)
{
listener.Call(event);
return;
}
}
Warning("Event Bus : listener not found, '%'", listener_name);
}
void EventBus::SendBroadcast(const EventBase& event)
{
for(const EventListener& listener : s_listeners)
listener.Call(event);
}
}

21
runtime/Sources/Core/EventListener.cpp git.filemode.normal_file
View File

@@ -0,0 +1,21 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* EventListener.cpp :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/03/27 17:37:09 by maldavid #+# #+# */
/* Updated: 2024/03/27 17:37:38 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#include <PreCompiled.h>
#include <Core/EventListener.h>
namespace mlx
{
EventListener::EventListener(func::function<void(const EventBase&)> functor, std::string name)
: m_listen_functor(std::move(functor)), m_name(std::move(name))
{}
}

33
src/core/fps.cpp → runtime/Sources/Core/Fps.cpp
View File

@@ -1,43 +1,42 @@
/* ************************************************************************** */ /* ************************************************************************** */
/* */ /* */
/* ::: :::::::: */ /* ::: :::::::: */
/* fps.cpp :+: :+: :+: */ /* Fps.cpp :+: :+: :+: */
/* +:+ +:+ +:+ */ /* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */ /* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/01/18 14:56:17 by maldavid #+# #+# */ /* Created: 2024/01/18 14:56:17 by maldavid #+# #+# */
/* Updated: 2024/03/25 22:59:13 by maldavid ### ########.fr */ /* Updated: 2024/03/27 20:53:11 by maldavid ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include <pre_compiled.h> #include <PreCompiled.h>
#include <Core/Fps.h>
#include <core/fps.h>
namespace mlx namespace mlx
{ {
void FpsManager::init() void FpsManager::Init()
{ {
_timer = static_cast<std::uint64_t>(std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count()); m_timer = static_cast<std::uint64_t>(std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count());
_fps_before = _timer; m_fps_before = m_timer;
_fps_now = _timer; m_fps_now = m_timer;
} }
bool FpsManager::update() bool FpsManager::Update()
{ {
using namespace std::chrono_literals; using namespace std::chrono_literals;
_fps_now = static_cast<std::uint64_t>(std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count()); m_fps_now = static_cast<std::uint64_t>(std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count());
if(std::chrono::duration<std::uint64_t>{_fps_now - _timer} >= 1s) if(std::chrono::duration<std::uint64_t>{m_fps_now - m_timer} >= 1s)
_timer += _fps_now; m_timer += m_fps_now;
_fps_elapsed_time = _fps_now - _fps_before; m_fps_elapsed_time = m_fps_now - m_fps_before;
if(_fps_elapsed_time >= _ns) if(m_fps_elapsed_time >= m_ns)
{ {
_fps_before += _ns; m_fps_before += m_ns;
return true; return true;
} }
std::this_thread::sleep_for(std::chrono::duration<double, std::nano>(_ns - 1)); std::this_thread::sleep_for(std::chrono::duration<double, std::nano>(m_ns - 1));
return false; return false;
} }
} }

0
src/core/graphics.cpp → runtime/Sources/Core/Graphics.cpp
View File

68
runtime/Sources/Core/Logs.cpp git.filemode.normal_file
View File

@@ -0,0 +1,68 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* Logs.cpp :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/03/27 17:20:55 by maldavid #+# #+# */
/* Updated: 2024/03/27 17:26:59 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#include <Core/Logs.h>
#include <Utils/Ansi.h>
#include <Core/EventBase.h>
#include <Core/EventBus.h>
namespace mlx
{
namespace Internal
{
struct FatalErrorEvent : public EventBase
{
std::uint32_t What() const override { return 167; }
};
}
void Logs::Report(LogType type, std::string message)
{
Report(type, 0, {}, {}, std::move(message));
}
void Logs::Report(LogType type, unsigned int line, std::string_view file, std::string_view function, std::string message)
{
using namespace std::literals;
#ifndef DEBUG
if(type == LogType::Debug)
return;
#endif
std::string code_infos;
if((type == LogType::Error || type == LogType::FatalError) && !file.empty() && !function.empty())
{
code_infos += "{in file '"s;
code_infos += file;
code_infos += "', line "s + std::to_string(line) + ", in function '"s;
code_infos += function;
code_infos += "'} "s;
}
switch(type)
{
case LogType::Debug: std::cout << Ansi::blue << "[Akel Debug] " << Ansi::def << code_infos << message << '\n'; break;
case LogType::Message: std::cout << Ansi::blue << "[Akel Message] " << Ansi::def << code_infos << message << '\n'; break;
case LogType::Warning: std::cout << Ansi::magenta << "[Akel Warning] " << Ansi::def << code_infos << message << '\n'; break;
case LogType::Error: std::cerr << Ansi::red << "[Akel Error] " << Ansi::def << code_infos << message << '\n'; break;
case LogType::FatalError: std::cerr << Ansi::red << "[Akel Fatal Error] " << Ansi::def << code_infos << message << '\n'; break;
default: break;
}
if(type == LogType::FatalError)
{
std::cout << Ansi::bg_red << "Fatal Error: emergency exit" << Ansi::bg_def << std::endl;
EventBus::Send("__internal_application", Internal::FatalErrorEvent{});
}
}
}

0
src/core/memory.cpp → runtime/Sources/Core/Memory.cpp
View File

0
src/core/profiler.cpp → runtime/Sources/Core/Profiler.cpp
View File

0
src/core/UUID.cpp → runtime/Sources/Core/UUID.cpp
View File

22
runtime/Sources/Drivers/GLFW/GLFWInputs.cpp git.filemode.normal_file
View File

@@ -0,0 +1,22 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* GLFWInputs.cpp :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/03/27 18:39:32 by maldavid #+# #+# */
/* Updated: 2024/03/27 18:42:18 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#include <PreCompiled.h>
#include <Drivers/GLFW/GLFWInputs.h>
namespace mlx
{
void GLFWInputs::Update() noexcept
{
glfwPollEvents();
}
}

6
src/platform/inputs.cpp → runtime/Sources/Platform/Inputs.cpp
View File

@@ -6,7 +6,7 @@
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */ /* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/05 16:30:19 by maldavid #+# #+# */ /* Created: 2022/10/05 16:30:19 by maldavid #+# #+# */
/* Updated: 2024/03/25 23:13:16 by maldavid ### ########.fr */ /* Updated: 2024/03/27 15:50:07 by maldavid ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@@ -24,9 +24,11 @@ namespace mlx
_xRel = 0; _xRel = 0;
_yRel = 0; _yRel = 0;
glfwPollEvents();
static int i = 0; static int i = 0;
i++; i++;
if(i >= 150) if(i >= 500)
{ {
auto& hooks = _events_hooks[0]; auto& hooks = _events_hooks[0];
auto& win_hook = hooks[MLX_WINDOW_EVENT]; auto& win_hook = hooks[MLX_WINDOW_EVENT];

0
src/platform/window.cpp → runtime/Sources/Platform/Window.cpp
View File

0
src/renderer/buffers/vk_buffer.cpp → runtime/Sources/Renderer/Buffers/Buffer.cpp
View File

0
src/renderer/buffers/vk_ubo.cpp → runtime/Sources/Renderer/Buffers/UniformBuffer.cpp
View File

0
src/renderer/buffers/vk_vbo.cpp → runtime/Sources/Renderer/Buffers/VertexBuffer.cpp
View File

0
src/renderer/command/vk_cmd_buffer.cpp → runtime/Sources/Renderer/Command/CommandBuffer.cpp
View File

0
src/renderer/command/cmd_manager.cpp → runtime/Sources/Renderer/Command/CommandManager.cpp
View File

0
src/renderer/command/vk_cmd_pool.cpp → runtime/Sources/Renderer/Command/CommandPool.cpp
View File

0
src/renderer/command/single_time_cmd_manager.cpp → runtime/Sources/Renderer/Command/SingleTimeCommandManager.cpp
View File

0
src/renderer/core/vk_device.cpp → runtime/Sources/Renderer/Core/Device.cpp
View File

0
src/renderer/core/vk_fence.cpp → runtime/Sources/Renderer/Core/Fence.cpp
View File

0
src/renderer/core/vk_instance.cpp → runtime/Sources/Renderer/Core/Instance.cpp
View File

0
src/renderer/core/memory.cpp → runtime/Sources/Renderer/Core/Memory.cpp
View File

0
src/renderer/core/vk_queues.cpp → runtime/Sources/Renderer/Core/Queues.cpp
View File

0
src/renderer/core/render_core.cpp → runtime/Sources/Renderer/Core/RenderCore.cpp
View File

0
src/renderer/core/vk_semaphore.cpp → runtime/Sources/Renderer/Core/Semaphore.cpp
View File

0
src/renderer/core/vk_surface.cpp → runtime/Sources/Renderer/Core/Surface.cpp
View File

Some files were not shown because too many files have changed in this diff Show More