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

reworking application and bridge

Browse Source
This commit is contained in:
kbz_8
2024-12-15 03:35:17 +01:00
parent e365c8a48c
commit 5a36b90a72
22 changed files with 464 additions and 505 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
runtime/Includes/Core/Application.h
View File

@@ -11,35 +11,25 @@
namespace mlx
{
// TODO : FIX THIS DAMN GOD CLASS !!!!!!!!!!!!!!!!
class Application
{
public:
Application();
inline void GetMousePos(int* x, int* y) noexcept;
inline void MouseMove(Handle win, int x, int y) noexcept;
inline void OnEvent(Handle win, int event, int (*funct_ptr)(int, void*), void* param) noexcept;
inline void GetScreenSize(Handle win, int* w, int* h) noexcept;
inline void GetScreenSize(mlx_window win, int* w, int* h) noexcept;
inline void SetFPSCap(std::uint32_t fps) noexcept;
inline Handle NewGraphicsSuport(std::size_t w, std::size_t h, const char* title, bool is_resizable);
inline void ClearGraphicsSupport(Handle win, int color);
inline void DestroyGraphicsSupport(Handle win);
inline void SetGraphicsSupportPosition(Handle win, int x, int y);
inline void OnEvent(mlx_window win, int event, int (*funct_ptr)(int, void*), void* param) noexcept;
inline void PixelPut(Handle win, int x, int y, std::uint32_t color) const noexcept;
inline void StringPut(Handle win, int x, int y, std::uint32_t color, char* str);
inline mlx_window NewGraphicsSuport(const mlx_window_create_info* info);
inline NonOwningPtr<GraphicsSupport> GetGraphicsSupport(mlx_window win);
inline void DestroyGraphicsSupport(mlx_window win);
Handle NewTexture(int w, int h);
Handle NewStbTexture(char* file, int* w, int* h); // stb textures are image files (png, jpg, bpm, ...)
inline void TexturePut(Handle win, Handle img, int x, int y, float scale, float angle);
inline int GetTexturePixel(Handle img, int x, int y);
inline void SetTexturePixel(Handle img, int x, int y, std::uint32_t color);
void DestroyTexture(Handle ptr);
mlx_image NewTexture(int w, int h);
mlx_image NewStbTexture(char* file, int* w, int* h); // stb textures are image files (png, jpg, bpm, ...)
inline NonOwningPtr<Texture> GetTexture(mlx_image image);
void DestroyTexture(mlx_image img);
inline void LoopHook(int (*f)(void*), void* param);
inline void LoopEnd() noexcept;

178
runtime/Includes/Core/Application.inl
View File

@@ -1,33 +1,34 @@
#pragma once
#include <Core/Application.h>
#include <Core/Handles.h>
#include <Embedded/DogicaTTF.h>
#ifndef DISABLE_ALL_SAFETIES
#define CHECK_WINDOW_PTR(win) \
#define CHECK_WINDOW_PTR(win, retval) \
if(win == nullptr) \
{ \
Error("invalid window ptr (NULL)"); \
return; \
Error("invalid window handle (NULL)"); \
return retval; \
} \
else if(std::find_if(m_graphics.begin(), m_graphics.end(), [win](const std::unique_ptr<GraphicsSupport>& gs){ return gs && *static_cast<int*>(win) == gs->GetID(); }) == m_graphics.end()) \
else if(std::find_if(m_graphics.begin(), m_graphics.end(), [win](const std::unique_ptr<GraphicsSupport>& gs){ return gs && win->id == gs->GetID(); }) == m_graphics.end()) \
{ \
Error("invalid window ptr"); \
return; \
Error("invalid window handle"); \
return retval; \
} else {}
#define CHECK_IMAGE_PTR(img, retval) \
if(img == nullptr) \
{ \
Error("invalid image ptr (NULL)"); \
retval; \
Error("invalid image handle (NULL)"); \
return retval; \
} \
else if(!m_image_registry.IsTextureKnown(static_cast<Texture*>(img))) \
else if(!m_image_registry.IsTextureKnown(image->texture)) \
{ \
Error("invalid image ptr"); \
retval; \
Error("invalid image handle"); \
return retval; \
} else {}
#else
#define CHECK_WINDOW_PTR(win)
#define CHECK_WINDOW_PTR(win, retval)
#define CHECK_IMAGE_PTR(img, retval)
#endif
@@ -39,32 +40,12 @@ namespace mlx
*y = m_in.GetY();
}
void Application::MouseMove(Handle win, int x, int y) noexcept
void Application::OnEvent(mlx_window 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 move the mouse relative to a window that is targeting an image and not a real window, this is not allowed (move ignored)");
CHECK_WINDOW_PTR(win, );
if(!m_graphics[win->id]->HasWindow())
return;
}
m_graphics[*static_cast<int*>(win)]->GetWindow()->MoveMouse(x, y);
}
void Application::OnEvent(Handle 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;
}
m_in.OnEvent(m_graphics[*static_cast<int*>(win)]->GetWindow()->GetID(), event, funct_ptr, param);
}
void Application::GetScreenSize(Handle win, int* w, int* h) noexcept
{
CHECK_WINDOW_PTR(win);
m_graphics[*static_cast<int*>(win)]->GetWindow()->GetScreenSizeWindowIsOn(w, h);
m_in.OnEvent(m_graphics[win->id]->GetWindow()->GetID(), event, funct_ptr, param);
}
void Application::SetFPSCap(std::uint32_t fps) noexcept
@@ -72,81 +53,38 @@ namespace mlx
m_fps.SetMaxFPS(fps);
}
void* Application::NewGraphicsSuport(std::size_t w, std::size_t h, const char* title, bool is_resizable)
mlx_window Application::NewGraphicsSuport(const mlx_window_create_info* info)
{
MLX_PROFILE_FUNCTION();
if(m_image_registry.IsTextureKnown(reinterpret_cast<Texture*>(const_cast<char*>(title))))
m_graphics.emplace_back(std::make_unique<GraphicsSupport>(w, h, reinterpret_cast<Texture*>(const_cast<char*>(title)), m_graphics.size()));
else
if(!info)
{
if(title == NULL)
{
FatalError("invalid window title (NULL)");
return nullptr;
}
if(static_cast<void*>(const_cast<char*>(title)) == static_cast<void*>(this))
{
for(std::size_t i = 0; i < 8; i++)
{
m_graphics.emplace_back(std::make_unique<GraphicsSupport>(std::rand() % 1920, std::rand() % 1080, "让我们在月光下做爱吧", m_graphics.size(), is_resizable));
m_graphics.back()->GetWindow()->SetPosition(std::rand() % 1920, std::rand() % 1080);
}
}
else
{
m_graphics.emplace_back(std::make_unique<GraphicsSupport>(w, h, title, m_graphics.size(), is_resizable));
m_in.RegisterWindow(m_graphics.back()->GetWindow());
}
Error("invalid window create info (NULL)");
return nullptr;
}
mlx_window window;
try { window = new mlx_window_handler; }
catch(...) { return nullptr; }
m_graphics.emplace_back(std::make_unique<GraphicsSupport>(info, m_graphics.size()));
m_in.RegisterWindow(m_graphics.back()->GetWindow());
m_graphics.back()->GetScene().BindFont(p_last_font_bound);
return static_cast<void*>(&m_graphics.back()->GetID());
window->id = m_graphics.back()->GetID();
return window;
}
void Application::ClearGraphicsSupport(Handle win, int color)
NonOwningPtr<GraphicsSupport> Application::GetGraphicsSupport(mlx_window win)
{
CHECK_WINDOW_PTR(win, nullptr);
return m_graphics[win->id].get();
}
void Application::DestroyGraphicsSupport(mlx_window win)
{
MLX_PROFILE_FUNCTION();
CHECK_WINDOW_PTR(win);
m_graphics[*static_cast<int*>(win)]->ResetRenderData(color);
}
void Application::DestroyGraphicsSupport(Handle win)
{
MLX_PROFILE_FUNCTION();
CHECK_WINDOW_PTR(win);
m_graphics[*static_cast<int*>(win)].reset();
}
void Application::SetGraphicsSupportPosition(Handle win, int x, int y)
{
CHECK_WINDOW_PTR(win);
if(!m_graphics[*static_cast<int*>(win)]->HasWindow())
Warning("trying to move a window that is targeting an image and not a real window, this is not allowed");
else
m_graphics[*static_cast<int*>(win)]->GetWindow()->SetPosition(x, y);
}
void Application::PixelPut(Handle 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(Handle win, int x, int y, std::uint32_t color, char* str)
{
MLX_PROFILE_FUNCTION();
CHECK_WINDOW_PTR(win);
if(str == nullptr)
{
Error("invalid 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);
CHECK_WINDOW_PTR(win, );
m_graphics[win->id].reset();
delete win;
}
void Application::LoadFont(const std::filesystem::path& filepath, float scale)
@@ -172,40 +110,16 @@ namespace mlx
}
}
void Application::TexturePut(Handle win, Handle img, int x, int y, float scale, float angle)
NonOwningPtr<Texture> Application::GetTexture(mlx_image image)
{
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, scale, angle);
}
int Application::GetTexturePixel(Handle img, int x, int y)
{
MLX_PROFILE_FUNCTION();
CHECK_IMAGE_PTR(img, return 0);
NonOwningPtr<Texture> texture = static_cast<Texture*>(img);
CHECK_IMAGE_PTR(image, nullptr);
NonOwningPtr<Texture> texture = image->texture;
if(!texture->IsInit())
{
Error("trying to get a pixel from texture that has been destroyed");
return 0;
Error("trying to use a texture that has been destroyed");
return nullptr;
}
return texture->GetPixel(x, y);
}
void Application::SetTexturePixel(Handle 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);
return texture;
}
void Application::LoopHook(int (*f)(void*), void* param)

8
runtime/Includes/Core/Graphics.h
View File

@@ -1,6 +1,7 @@
#ifndef __MLX_GRAPHICS__
#define __MLX_GRAPHICS__
#include <mlx.h>
#include <Platform/Window.h>
#include <Renderer/Renderer.h>
#include <Graphics/Scene.h>
@@ -14,8 +15,7 @@ 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, bool is_resizable);
GraphicsSupport(const mlx_window_create_info* info, int id);
[[nodiscard]] MLX_FORCEINLINE int& GetID() noexcept { return m_id; }
[[nodiscard]] inline std::shared_ptr<Window> GetWindow() { return p_window; }
@@ -24,8 +24,8 @@ namespace mlx
inline void ResetRenderData(int color) 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 PixelPut(int x, int y, int color) noexcept;
inline void StringPut(int x, int y, int, std::string str);
inline void TexturePut(NonOwningPtr<class Texture> texture, int x, int y, float scale, float angle);
inline void TryEraseSpritesInScene(NonOwningPtr<Texture> texture) noexcept;

16
runtime/Includes/Core/Graphics.inl
View File

@@ -7,10 +7,10 @@ namespace mlx
{
MLX_PROFILE_FUNCTION();
Vec4f vec_color = {
static_cast<float>((color & 0x000000FF)) / 255.0f,
static_cast<float>((color & 0x0000FF00) >> 8) / 255.0f,
static_cast<float>((color & 0xFF000000) >> 24) / 255.0f,
static_cast<float>((color & 0x00FF0000) >> 16) / 255.0f,
static_cast<float>((color & 0xFF000000) >> 24) / 255.0f
static_cast<float>((color & 0x0000FF00) >> 8) / 255.0f,
static_cast<float>((color & 0x000000FF)) / 255.0f,
};
p_scene->ResetScene(std::move(vec_color));
m_put_pixel_manager.ResetRenderData();
@@ -18,7 +18,7 @@ namespace mlx
m_pixelput_called = false;
}
void GraphicsSupport::PixelPut(int x, int y, std::uint32_t color) noexcept
void GraphicsSupport::PixelPut(int x, int y, int color) noexcept
{
MLX_PROFILE_FUNCTION();
NonOwningPtr<Texture> texture = m_put_pixel_manager.DrawPixel(x, y, m_draw_layer, color);
@@ -30,17 +30,17 @@ namespace mlx
}
}
void GraphicsSupport::StringPut(int x, int y, std::uint32_t color, std::string str)
void GraphicsSupport::StringPut(int x, int y, int color, std::string str)
{
MLX_PROFILE_FUNCTION();
if(str.empty())
return;
Vec4f vec_color = {
static_cast<float>((color & 0x000000FF)) / 255.0f,
static_cast<float>((color & 0x0000FF00) >> 8) / 255.0f,
static_cast<float>((color & 0xFF000000) >> 24) / 255.0f,
static_cast<float>((color & 0x00FF0000) >> 16) / 255.0f,
static_cast<float>((color & 0xFF000000) >> 24) / 255.0f
static_cast<float>((color & 0x0000FF00) >> 8) / 255.0f,
static_cast<float>((color & 0x000000FF)) / 255.0f,
};
NonOwningPtr<Text> text = p_scene->GetTextFromPositionAndColor(str, Vec2f{ static_cast<float>(x), static_cast<float>(y) }, vec_color);

25
runtime/Includes/Core/Handles.h git.filemode.normal_file
View File

@@ -0,0 +1,25 @@
#ifndef __MLX_HANDLES__
#define __MLX_HANDLES__
#include <Core/Application.h>
#include <Renderer/Image.h>
extern "C"
{
struct mlx_context_handler
{
mlx::NonOwningPtr<mlx::Application> app;
};
struct mlx_window_handler
{
int id;
};
struct mlx_image_handler
{
mlx::NonOwningPtr<mlx::Texture> texture;
};
}
#endif

3
runtime/Includes/Core/SDLManager.h
View File

@@ -1,6 +1,7 @@
#ifndef __MLX_SDL_MANAGER__
#define __MLX_SDL_MANAGER__
#include <mlx.h>
#include <Maths/Vec2.h>
namespace mlx
@@ -10,7 +11,7 @@ namespace mlx
public:
SDLManager();
Handle CreateWindow(const std::string& title, std::size_t w, std::size_t h, bool hidden, std::int32_t& id, bool is_resizable);
Handle CreateWindow(const mlx_window_create_info* info, std::int32_t& id, bool hidden);
void DestroyWindow(Handle window) noexcept;
void InputsFetcher(func::function<void(mlx_event_type, int, int)> functor);

2
runtime/Includes/Graphics/PutPixelManager.h
View File

@@ -11,7 +11,7 @@ namespace mlx
PutPixelManager(NonOwningPtr<class Renderer> renderer) : p_renderer(renderer) {}
// Return a valid pointer when a new texture has been created
NonOwningPtr<Texture> DrawPixel(int x, int y, std::uint64_t draw_layer, std::uint32_t color);
NonOwningPtr<Texture> DrawPixel(int x, int y, std::uint64_t draw_layer, int color);
void ResetRenderData();
~PutPixelManager();

3
runtime/Includes/Platform/Window.h
View File

@@ -1,6 +1,7 @@
#ifndef __MLX_WINDOW__
#define __MLX_WINDOW__
#include <mlx.h>
#include <Maths/Vec2.h>
#include <Core/SDLManager.h>
@@ -9,7 +10,7 @@ namespace mlx
class Window
{
public:
Window(std::size_t w, std::size_t h, const std::string& title, bool is_resizable, bool hidden = false);
Window(const mlx_window_create_info* info, bool hidden = false);
inline Handle GetWindowHandle() const noexcept { return p_window; }
inline int GetWidth() const noexcept { return m_width; }

1
runtime/Includes/PreCompiled.h
View File

@@ -44,6 +44,7 @@
#include <iterator>
#include <stb_truetype.h>
#include <variant>
#include <bit>
#include <type_traits>
#include <string_view>
#include <sstream>

4
runtime/Includes/Renderer/Image.h
View File

@@ -83,7 +83,7 @@ namespace mlx
void Init(CPUBuffer pixels, std::uint32_t width, std::uint32_t height, VkFormat format, bool is_multisampled, [[maybe_unused]] std::string_view debug_name);
void Destroy() noexcept override;
void SetPixel(int x, int y, std::uint32_t color) noexcept;
void SetPixel(int x, int y, int color) noexcept;
int GetPixel(int x, int y) noexcept;
void Update(VkCommandBuffer cmd);
@@ -94,7 +94,7 @@ namespace mlx
void OpenCPUBuffer();
private:
std::vector<std::uint32_t> m_cpu_buffer;
std::vector<int> m_cpu_buffer;
std::optional<GPUBuffer> m_staging_buffer;
bool m_has_been_modified = false;
};

29
runtime/Sources/Core/Application.cpp
View File

@@ -50,37 +50,49 @@ namespace mlx
RenderCore::Get().WaitDeviceIdle();
}
void* Application::NewTexture(int w, int h)
mlx_image Application::NewTexture(int w, int h)
{
MLX_PROFILE_FUNCTION();
mlx_image image;
try { image = new mlx_image_handler; }
catch(...) { return nullptr; }
Texture* texture;
try { texture = new Texture({}, w, h, VK_FORMAT_R8G8B8A8_SRGB, false, "mlx_user_image"); }
catch(...) { return nullptr; }
m_image_registry.RegisterTexture(texture);
return texture;
image->texture = texture;
return image;
}
void* Application::NewStbTexture(char* file, int* w, int* h)
mlx_image Application::NewStbTexture(char* file, int* w, int* h)
{
MLX_PROFILE_FUNCTION();
mlx_image image;
try { image = new mlx_image_handler; }
catch(...) { return nullptr; }
Texture* texture = StbTextureLoad(file, w, h);
if(texture == nullptr)
return nullptr;
m_image_registry.RegisterTexture(texture);
return texture;
image->texture = texture;
return image;
}
void Application::DestroyTexture(void* ptr)
void Application::DestroyTexture(mlx_image image)
{
MLX_PROFILE_FUNCTION();
RenderCore::Get().WaitDeviceIdle();
if(!m_image_registry.IsTextureKnown(static_cast<Texture*>(ptr)))
if(!m_image_registry.IsTextureKnown(image->texture))
{
Error("invalid image ptr");
Error("invalid image handle");
return;
}
Texture* texture = static_cast<Texture*>(ptr);
Texture* texture = image->texture.Get();
if(!texture->IsInit())
Error("trying to destroy a texture that has already been destroyed");
else
@@ -92,6 +104,7 @@ namespace mlx
gs->TryEraseSpritesInScene(texture);
}
delete texture;
delete image;
}
Application::~Application()

335
runtime/Sources/Core/Bridge.cpp
View File

@@ -5,13 +5,14 @@
#include <Renderer/RenderCore.h>
#include <mlx.h>
#include <Core/Memory.h>
#include <Core/Handles.h>
static void* __mlx_ptr = nullptr;
static mlx::Application* __internal_application_ptr = nullptr;
#ifndef DISABLE_ALL_SAFETIES
#define MLX_CHECK_APPLICATION_POINTER(ptr) \
if(ptr != __mlx_ptr || ptr == NULL) \
mlx::FatalError("invalid mlx pointer passed to '%'", MLX_FUNC_SIG); \
if(ptr == NULL || ptr->app.Get() != __internal_application_ptr) \
mlx::FatalError("invalid mlx handle passed to '%'", MLX_FUNC_SIG); \
else {} // just to avoid issues with possible if-else statements outside this macro
#else
#define MLX_CHECK_APPLICATION_POINTER(ptr)
@@ -19,148 +20,162 @@ static void* __mlx_ptr = nullptr;
extern "C"
{
void* mlx_init()
mlx_context mlx_init()
{
if(__mlx_ptr != nullptr)
if(__internal_application_ptr != nullptr)
{
mlx::Error("MLX cannot be initialized multiple times");
return nullptr;
}
mlx::MemManager::Get(); // just to initialize the C garbage collector
mlx::Application* app = new mlx::Application;
if(app == nullptr)
mlx::FatalError("Tout a pété");
__mlx_ptr = static_cast<void*>(app);
return __mlx_ptr;
try { __internal_application_ptr = new mlx::Application; }
catch(...) { mlx::FatalError("internal application memory allocation failed"); }
mlx_context_handler* context;
try { context = new mlx_context_handler; }
catch(...) { mlx::FatalError("mlx_context memory allocation failed"); }
context->app = __internal_application_ptr;
return context;
}
void* mlx_new_window(void* mlx, int w, int h, const char* title)
void mlx_set_fps_goal(mlx_context mlx, int fps)
{
MLX_CHECK_APPLICATION_POINTER(mlx);
if(w <= 0 || h <= 0)
if(fps < 0)
mlx::Error("You cannot set a negative FPS cap (nice try)");
else if(fps == 0)
mlx::Error("You cannot set a FPS cap to 0 (nice try)");
else
mlx->app->SetFPSCap(static_cast<std::uint32_t>(fps));
}
void mlx_destroy_context(mlx_context mlx)
{
MLX_CHECK_APPLICATION_POINTER(mlx);
delete mlx;
delete __internal_application_ptr;
__internal_application_ptr = nullptr;
}
mlx_window mlx_new_window(mlx_context mlx, const mlx_window_create_info* info)
{
MLX_CHECK_APPLICATION_POINTER(mlx);
return mlx->app->NewGraphicsSuport(info);
}
void mlx_destroy_window(mlx_context mlx, mlx_window win)
{
MLX_CHECK_APPLICATION_POINTER(mlx);
mlx->app->DestroyGraphicsSupport(win);
}
void mlx_set_window_position(mlx_context mlx, mlx_window win, int x, int y)
{
MLX_CHECK_APPLICATION_POINTER(mlx);
mlx::NonOwningPtr<mlx::GraphicsSupport> gs = mlx->app->GetGraphicsSupport(win);
if(!gs && !gs->HasWindow())
return;
gs->GetWindow()->SetPosition(x, y);
}
void mlx_clear_window(mlx_context mlx, mlx_window win, int color)
{
MLX_CHECK_APPLICATION_POINTER(mlx);
mlx::NonOwningPtr<mlx::GraphicsSupport> gs = mlx->app->GetGraphicsSupport(win);
if(!gs)
return;
gs->ResetRenderData(color);
}
void mlx_get_screen_size(mlx_context mlx, mlx_window win, int* w, int* h)
{
MLX_CHECK_APPLICATION_POINTER(mlx);
mlx::NonOwningPtr<mlx::GraphicsSupport> gs = mlx->app->GetGraphicsSupport(win);
if(!gs)
return;
if(!gs->HasWindow())
{
mlx::FatalError("invalid window size (%d x %d)", w, h);
return NULL; // not nullptr for the C compatibility
*w = 0;
*h = 0;
}
return static_cast<mlx::Application*>(mlx)->NewGraphicsSuport(w, h, title, false);
else
gs->GetWindow()->GetScreenSizeWindowIsOn(w, h);
}
void* mlx_new_resizable_window(void* mlx, int w, int h, const char* title)
void mlx_loop_hook(mlx_context mlx, int (*f)(void*), void* param)
{
MLX_CHECK_APPLICATION_POINTER(mlx);
if(w <= 0 || h <= 0)
{
mlx::FatalError("invalid window size (%d x %d)", w, h);
return NULL; // not nullptr for the C compatibility
}
return static_cast<mlx::Application*>(mlx)->NewGraphicsSuport(w, h, title, true);
mlx->app->LoopHook(f, param);
}
void mlx_set_window_position(void *mlx, void *win, int x, int y)
void mlx_loop(mlx_context mlx)
{
MLX_CHECK_APPLICATION_POINTER(mlx);
static_cast<mlx::Application*>(mlx)->SetGraphicsSupportPosition(win, x, y);
mlx->app->Run();
}
void mlx_loop_hook(void* mlx, int (*f)(void*), void* param)
void mlx_loop_end(mlx_context mlx)
{
MLX_CHECK_APPLICATION_POINTER(mlx);
static_cast<mlx::Application*>(mlx)->LoopHook(f, param);
mlx->app->LoopEnd();
}
void mlx_loop(void* mlx)
void mlx_mouse_show(mlx_context mlx)
{
MLX_CHECK_APPLICATION_POINTER(mlx);
static_cast<mlx::Application*>(mlx)->Run();
}
void mlx_loop_end(void* mlx)
{
MLX_CHECK_APPLICATION_POINTER(mlx);
static_cast<mlx::Application*>(mlx)->LoopEnd();
}
void mlx_mouse_show()
{
mlx::SDLManager::ShowCursor();
}
void mlx_mouse_hide()
void mlx_mouse_hide(mlx_context mlx)
{
MLX_CHECK_APPLICATION_POINTER(mlx);
mlx::SDLManager::HideCursor();
}
void mlx_mouse_move(void* mlx, void* win, int x, int y)
void mlx_mouse_move(mlx_context mlx, mlx_window win, int x, int y)
{
MLX_CHECK_APPLICATION_POINTER(mlx);
static_cast<mlx::Application*>(mlx)->MouseMove(win, x, y);
mlx::NonOwningPtr<mlx::GraphicsSupport> gs = mlx->app->GetGraphicsSupport(win);
if(!gs && !gs->HasWindow())
return;
gs->GetWindow()->MoveMouse(x, y);
}
void mlx_mouse_get_pos(void* mlx, int* x, int* y)
void mlx_mouse_get_pos(mlx_context mlx, int* x, int* y)
{
MLX_CHECK_APPLICATION_POINTER(mlx);
static_cast<mlx::Application*>(mlx)->GetMousePos(x, y);
mlx->app->GetMousePos(x, y);
}
void mlx_on_event(void* mlx, void* win, mlx_event_type event, int (*funct_ptr)(int, void*), void* param)
void mlx_on_event(mlx_context mlx, mlx_window win, mlx_event_type event, int (*funct_ptr)(int, void*), void* param)
{
MLX_CHECK_APPLICATION_POINTER(mlx);
static_cast<mlx::Application*>(mlx)->OnEvent(win, static_cast<int>(event), funct_ptr, param);
mlx->app->OnEvent(win, static_cast<int>(event), funct_ptr, param);
}
void* mlx_new_image(void* mlx, int width, int height)
void mlx_pixel_put(mlx_context mlx, mlx_window win, int x, int y, int color)
{
MLX_CHECK_APPLICATION_POINTER(mlx);
if (width <= 0 || height <= 0)
mlx::NonOwningPtr<mlx::GraphicsSupport> gs = mlx->app->GetGraphicsSupport(win);
if(!gs)
return;
gs->PixelPut(x, y, color);
}
mlx_image mlx_new_image(mlx_context mlx, int width, int height)
{
MLX_CHECK_APPLICATION_POINTER(mlx);
if(width <= 0 || height <= 0)
{
mlx::Error("invalid image size (% x %)", width, height);
return nullptr;
}
return static_cast<mlx::Application*>(mlx)->NewTexture(width, height);
return mlx->app->NewTexture(width, height);
}
int mlx_get_image_pixel(void* mlx, void* img, int x, int y)
{
MLX_CHECK_APPLICATION_POINTER(mlx);
int color = static_cast<mlx::Application*>(mlx)->GetTexturePixel(img, x, y);
unsigned char color_bits[4];
color_bits[0] = (color & 0x000000FF);
color_bits[1] = (color & 0x0000FF00) >> 8;
color_bits[2] = (color & 0x00FF0000) >> 16;
color_bits[3] = (color & 0xFF000000) >> 24;
return *reinterpret_cast<int*>(color_bits);
}
void mlx_set_image_pixel(void* mlx, void* img, int x, int y, int color)
{
MLX_CHECK_APPLICATION_POINTER(mlx);
unsigned char color_bits[4];
color_bits[0] = (color & 0x00FF0000) >> 16;
color_bits[1] = (color & 0x0000FF00) >> 8;
color_bits[2] = (color & 0x000000FF);
color_bits[3] = (color & 0xFF000000) >> 24;
static_cast<mlx::Application*>(mlx)->SetTexturePixel(img, x, y, *reinterpret_cast<unsigned int*>(color_bits));
}
void mlx_put_image_to_window(void* mlx, void* win, void* img, int x, int y)
{
MLX_CHECK_APPLICATION_POINTER(mlx);
static_cast<mlx::Application*>(mlx)->TexturePut(win, img, x, y, 1.0f, 0.0f);
}
void mlx_transform_put_image_to_window(void* mlx, void* win, void* img, int x, int y, float scale, float angle)
{
MLX_CHECK_APPLICATION_POINTER(mlx);
static_cast<mlx::Application*>(mlx)->TexturePut(win, img, x, y, scale, angle);
}
void mlx_destroy_image(void* mlx, void* img)
{
MLX_CHECK_APPLICATION_POINTER(mlx);
static_cast<mlx::Application*>(mlx)->DestroyTexture(img);
}
void* mlx_png_file_to_image(void* mlx, char* filename, int* width, int* height)
mlx_image mlx_new_image_from_file(mlx_context mlx, char* filename, int* width, int* height)
{
MLX_CHECK_APPLICATION_POINTER(mlx);
if (filename == nullptr)
@@ -169,71 +184,74 @@ extern "C"
return nullptr;
}
std::filesystem::path file(filename);
if(file.extension() != ".png")
if( file.extension() != ".png" &&
file.extension() != ".jpg" &&
file.extension() != ".jpeg" &&
file.extension() != ".bmp" &&
file.extension() != ".dib")
{
mlx::Error("PNG loader: not a png file '%'", filename);
mlx::Error("PNG loader: not a valid file format '%'", filename);
return nullptr;
}
return static_cast<mlx::Application*>(mlx)->NewStbTexture(filename, width, height);
return mlx->app->NewStbTexture(filename, width, height);
}
void* mlx_jpg_file_to_image(void* mlx, char* filename, int* width, int* height)
void mlx_destroy_image(mlx_context mlx, mlx_image image)
{
MLX_CHECK_APPLICATION_POINTER(mlx);
if (filename == nullptr)
{
mlx::Error("JPG loader: filename is NULL");
return nullptr;
}
std::filesystem::path file(filename);
if(file.extension() != ".jpg" && file.extension() != ".jpeg")
{
mlx::Error("JPG loader: not a jpg file '%'", filename);
return nullptr;
}
return static_cast<mlx::Application*>(mlx)->NewStbTexture(filename, width, height);
mlx->app->DestroyTexture(image);
}
void* mlx_bmp_file_to_image(void* mlx, char* filename, int* width, int* height)
int mlx_get_image_pixel(mlx_context mlx, mlx_image image, int x, int y)
{
MLX_CHECK_APPLICATION_POINTER(mlx);
if (filename == nullptr)
{
mlx::Error("BMP loader: filename is NULL");
return nullptr;
}
std::filesystem::path file(filename);
if(file.extension() != ".bmp" && file.extension() != ".dib")
{
mlx::Error("BMP loader: not a bmp file '%'", filename);
return nullptr;
}
return static_cast<mlx::Application*>(mlx)->NewStbTexture(filename, width, height);
mlx::NonOwningPtr<mlx::Texture> texture = mlx->app->GetTexture(image);
if(!texture)
return 0;
return texture->GetPixel(x, y);
}
void mlx_pixel_put(void* mlx, void* win, int x, int y, int color)
void mlx_set_image_pixel(mlx_context mlx, mlx_image image, int x, int y, int color)
{
MLX_CHECK_APPLICATION_POINTER(mlx);
unsigned char color_bits[4];
color_bits[0] = (color & 0x00FF0000) >> 16;
color_bits[1] = (color & 0x0000FF00) >> 8;
color_bits[2] = (color & 0x000000FF);
color_bits[3] = (color & 0xFF000000) >> 24;
static_cast<mlx::Application*>(mlx)->PixelPut(win, x, y, *reinterpret_cast<unsigned int*>(color_bits));
mlx::NonOwningPtr<mlx::Texture> texture = mlx->app->GetTexture(image);
if(!texture)
return;
texture->SetPixel(x, y, color);
}
void mlx_string_put(void* mlx, void* win, int x, int y, int color, char* str)
void mlx_put_image_to_window(mlx_context mlx, mlx_window win, mlx_image image, int x, int y)
{
MLX_CHECK_APPLICATION_POINTER(mlx);
unsigned char color_bits[4];
color_bits[0] = (color & 0x00FF0000) >> 16;
color_bits[1] = (color & 0x0000FF00) >> 8;
color_bits[2] = (color & 0x000000FF);
color_bits[3] = (color & 0xFF000000) >> 24;
static_cast<mlx::Application*>(mlx)->StringPut(win, x, y, *reinterpret_cast<unsigned int*>(color_bits), str);
mlx::NonOwningPtr<mlx::GraphicsSupport> gs = mlx->app->GetGraphicsSupport(win);
if(!gs)
return;
mlx::NonOwningPtr<mlx::Texture> texture = mlx->app->GetTexture(image);
if(!texture)
return;
gs->TexturePut(texture, x, y, 1.0f, 0.0f);
}
void mlx_set_font(void* mlx, char* filepath)
void mlx_string_put(mlx_context mlx, mlx_window win, int x, int y, int color, char* str)
{
MLX_CHECK_APPLICATION_POINTER(mlx);
mlx::NonOwningPtr<mlx::GraphicsSupport> gs = mlx->app->GetGraphicsSupport(win);
if(!gs)
return;
if(str == nullptr)
{
mlx::Error("invalid text (NULL)");
return;
}
if(std::strlen(str) == 0)
{
mlx::Warning("trying to put an empty text");
return;
}
gs->StringPut(x, y, color, str);
}
void mlx_set_font(mlx_context mlx, char* filepath)
{
MLX_CHECK_APPLICATION_POINTER(mlx);
if (filepath == nullptr)
@@ -248,12 +266,12 @@ extern "C"
return;
}
if(std::strcmp(filepath, "default") == 0)
static_cast<mlx::Application*>(mlx)->LoadFont(file, 6.f);
mlx->app->LoadFont(file, 6.f);
else
static_cast<mlx::Application*>(mlx)->LoadFont(file, 16.f);
mlx->app->LoadFont(file, 16.f);
}
void mlx_set_font_scale(void* mlx, char* filepath, float scale)
void mlx_set_font_scale(mlx_context mlx, char* filepath, float scale)
{
MLX_CHECK_APPLICATION_POINTER(mlx);
if (filepath == nullptr)
@@ -267,47 +285,6 @@ extern "C"
mlx::Error("TTF loader: not a truetype font file '%'", filepath);
return;
}
static_cast<mlx::Application*>(mlx)->LoadFont(file, scale);
}
void mlx_clear_window(void* mlx, void* win, int color)
{
MLX_CHECK_APPLICATION_POINTER(mlx);
unsigned char color_bits[4];
color_bits[0] = (color & 0x00FF0000) >> 16;
color_bits[1] = (color & 0x0000FF00) >> 8;
color_bits[2] = (color & 0x000000FF);
color_bits[3] = (color & 0xFF000000) >> 24;
static_cast<mlx::Application*>(mlx)->ClearGraphicsSupport(win, *reinterpret_cast<unsigned int*>(color_bits));
}
void mlx_destroy_window(void* mlx, void* win)
{
MLX_CHECK_APPLICATION_POINTER(mlx);
static_cast<mlx::Application*>(mlx)->DestroyGraphicsSupport(win);
}
void mlx_destroy_display(void* mlx)
{
MLX_CHECK_APPLICATION_POINTER(mlx);
delete static_cast<mlx::Application*>(mlx);
__mlx_ptr = nullptr;
}
void mlx_get_screens_size(void* mlx, void* win, int* w, int* h)
{
MLX_CHECK_APPLICATION_POINTER(mlx);
static_cast<mlx::Application*>(mlx)->GetScreenSize(win, w, h);
}
void mlx_set_fps_goal(void* mlx, int fps)
{
MLX_CHECK_APPLICATION_POINTER(mlx);
if(fps < 0)
mlx::Error("You cannot set a negative FPS cap (nice try)");
else if(fps == 0)
mlx::Error("You cannot set a FPS cap to 0 (nice try)");
else
static_cast<mlx::Application*>(mlx)->SetFPSCap(static_cast<std::uint32_t>(fps));
mlx->app->LoadFont(file, scale);
}
}

20
runtime/Sources/Core/Graphics.cpp
View File

@@ -3,25 +3,15 @@
namespace mlx
{
GraphicsSupport::GraphicsSupport([[maybe_unused]] std::size_t w, [[maybe_unused]] std::size_t h, NonOwningPtr<Texture> render_target, int id) :
GraphicsSupport::GraphicsSupport(const mlx_window_create_info* info, int id) :
m_put_pixel_manager(&m_renderer),
p_window(nullptr),
m_id(id),
m_has_window(false)
m_id(id)
{
MLX_PROFILE_FUNCTION();
m_renderer.Init(render_target);
m_scene_renderer.Init(render_target);
p_scene = std::make_unique<Scene>();
}
GraphicsSupport::GraphicsSupport(std::size_t w, std::size_t h, std::string title, int id, bool is_resizable) :
m_put_pixel_manager(&m_renderer),
p_window(std::make_shared<Window>(w, h, title, is_resizable)),
m_id(id),
m_has_window(true)
{
MLX_PROFILE_FUNCTION();
p_window = std::make_shared<Window>(info);
m_has_window = true;
m_renderer.Init(p_window.get());
m_scene_renderer.Init(nullptr);
p_scene = std::make_unique<Scene>();

6
runtime/Sources/Core/SDLManager.cpp
View File

@@ -47,7 +47,7 @@ namespace mlx
DebugLog("SDL Manager initialized");
}
Handle SDLManager::CreateWindow(const std::string& title, std::size_t w, std::size_t h, bool hidden, std::int32_t& id, bool is_resizable)
Handle SDLManager::CreateWindow(const mlx_window_create_info* info, std::int32_t& id, bool hidden)
{
Internal::WindowInfos* infos = new Internal::WindowInfos;
Verify(infos != nullptr, "SDL: window allocation failed");
@@ -57,10 +57,10 @@ namespace mlx
flags |= SDL_WINDOW_HIDDEN;
else
flags |= SDL_WINDOW_SHOWN;
if(is_resizable)
if(info->is_resizable)
flags |= SDL_WINDOW_RESIZABLE;
infos->window = SDL_CreateWindow(title.c_str(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, w, h, flags);
infos->window = SDL_CreateWindow(info->title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, info->width, info->height, flags);
if(!infos->window)
FatalError("SDL: unable to open a new window; %", SDL_GetError());
infos->icon = SDL_CreateRGBSurfaceFrom(static_cast<void*>(logo_mlx), logo_mlx_width, logo_mlx_height, 32, 4 * logo_mlx_width, rmask, gmask, bmask, amask);

2
runtime/Sources/Graphics/PutPixelManager.cpp
View File

@@ -5,7 +5,7 @@
namespace mlx
{
NonOwningPtr<Texture> PutPixelManager::DrawPixel(int x, int y, std::uint64_t draw_layer, std::uint32_t color)
NonOwningPtr<Texture> PutPixelManager::DrawPixel(int x, int y, std::uint64_t draw_layer, int color)
{
Verify((bool)p_renderer, "invalid renderer pointer");

4
runtime/Sources/Platform/Window.cpp
View File

@@ -5,9 +5,9 @@
namespace mlx
{
Window::Window(std::size_t w, std::size_t h, const std::string& title, bool is_resizable, bool hidden) : m_name(title), m_width(w), m_height(h)
Window::Window(const mlx_window_create_info* info, bool hidden) : m_name(info->title), m_width(info->width), m_height(info->height)
{
p_window = SDLManager::Get().CreateWindow(title, w, h, hidden, m_id, is_resizable);
p_window = SDLManager::Get().CreateWindow(info, m_id, hidden);
}
void Window::Destroy() noexcept

24
runtime/Sources/Renderer/Image.cpp
View File

@@ -30,6 +30,14 @@
namespace mlx
{
unsigned char reverse(unsigned char b)
{
b = (b & 0xF0) >> 4 | (b & 0x0F) << 4;
b = (b & 0xCC) >> 2 | (b & 0x33) << 2;
b = (b & 0xAA) >> 1 | (b & 0x55) << 1;
return b;
}
void Image::Init(ImageType type, std::uint32_t width, std::uint32_t height, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, bool is_multisampled, [[maybe_unused]] std::string_view debug_name)
{
MLX_PROFILE_FUNCTION();
@@ -199,14 +207,19 @@ namespace mlx
Image::Destroy();
}
void Texture::SetPixel(int x, int y, std::uint32_t color) noexcept
void Texture::SetPixel(int x, int y, int color) noexcept
{
MLX_PROFILE_FUNCTION();
if(x < 0 || y < 0 || static_cast<std::uint32_t>(x) > m_width || static_cast<std::uint32_t>(y) > m_height)
return;
if(!m_staging_buffer.has_value())
OpenCPUBuffer();
m_cpu_buffer[(y * m_width) + x] = color;
unsigned char bytes[4];
bytes[0] = (color >> 24) & 0xFF;
bytes[1] = (color >> 16) & 0xFF;
bytes[2] = (color >> 8) & 0xFF;
bytes[3] = color & 0xFF;
m_cpu_buffer[(y * m_width) + x] = *reinterpret_cast<int*>(bytes);
m_has_been_modified = true;
}
@@ -217,12 +230,7 @@ namespace mlx
return 0;
if(!m_staging_buffer.has_value())
OpenCPUBuffer();
std::uint32_t color = m_cpu_buffer[(y * m_width) + x];
std::uint8_t* bytes = reinterpret_cast<std::uint8_t*>(&color);
std::uint8_t tmp = bytes[0];
bytes[0] = bytes[2];
bytes[2] = tmp;
return *reinterpret_cast<int*>(bytes);
return m_cpu_buffer[(y * m_width) + x];
}
void Texture::Update(VkCommandBuffer cmd)

7
runtime/Sources/Renderer/RenderCore.cpp
View File

@@ -26,6 +26,7 @@
#include <kvf.h>
#endif
#include <mlx.h>
#include <Renderer/Vulkan/VulkanLoader.h>
#include <Core/SDLManager.h>
#include <Platform/Window.h>
@@ -86,7 +87,11 @@ namespace mlx
kvfSetValidationErrorCallback(&ValidationErrorCallback);
kvfSetValidationWarningCallback(&WarningCallback);
Window window(1, 1, "", true);
mlx_window_create_info info{};
info.title = "";
info.width = 1;
info.height = 1;
Window window(&info, true);
std::vector<const char*> instance_extensions = window.GetRequiredVulkanInstanceExtentions();
#ifdef MLX_PLAT_MACOS
instance_extensions.push_back(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME);