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

adding graphics support class, refactoring the code

Browse Source
This commit is contained in:
kbz_8
2023-04-02 17:37:38 +02:00
parent 534bea942c
commit 7a5e280322
14 changed files with 318 additions and 148 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
src/core/application.cpp
View File

@@ -6,7 +6,7 @@
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/04 22:10:52 by maldavid #+# #+# */
/* Updated: 2023/04/01 16:03:45 by maldavid ### ########.fr */
/* Updated: 2023/04/02 15:11:53 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
@@ -21,32 +21,26 @@ namespace mlx::core
while(_in.is_running())
{
_in.update();
for(auto win : _wins)
win->beginFrame();
for(auto& gs : _graphics)
gs->beginRender();
if(_loop_hook)
_loop_hook(_param);
for(auto win : _wins)
win->endFrame();
for(auto& gs : _graphics)
gs->endRender();
}
}
void* Application::new_stb_texture(char* file, int* w, int* h)
void* Application::newStbTexture(char* file, int* w, int* h)
{
std::shared_ptr<Texture> texture = std::make_shared<Texture>(stb_texture_load(file, w, h));
std::shared_ptr<Texture> texture = std::make_shared<Texture>(stbTextureLoad(file, w, h));
TextureID id = _texture_lib.addTextureToLibrary(texture);
_texture_ids.push_back(id);
return &_texture_ids.back();
}
void Application::texture_put(void* win, void* img, int x, int y)
{
std::shared_ptr<Texture> texture = _texture_lib.getTexture(*static_cast<TextureID*>(img));
_wins[*static_cast<int*>(win)]->texture_put(texture, x, y);
}
void Application::destroy_texture(void* ptr)
void Application::destroyTexture(void* ptr)
{
vkDeviceWaitIdle(Render_Core::get().getDevice().get());
TextureID id = *static_cast<TextureID*>(ptr);

47
src/core/application.h
View File

@@ -6,7 +6,7 @@
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/04 21:49:46 by maldavid #+# #+# */
/* Updated: 2023/04/01 17:26:10 by maldavid ### ########.fr */
/* Updated: 2023/04/02 15:38:47 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
@@ -18,10 +18,10 @@
#include <utility>
#include <functional>
#include "errors.h"
#include <core/errors.h>
#include <core/graphics.h>
#include <platform/inputs.h>
#include <platform/window.h>
#include <renderer/texture_library.h>
@@ -32,37 +32,22 @@ namespace mlx::core
public:
Application() : _in() {}
inline void* new_window(std::size_t w, std::size_t h, std::string title)
{
_wins.emplace_back(std::make_shared<MLX_Window>(w, h, std::move(title), _wins.size()));
return static_cast<void*>(&_wins.back()->get_id());
}
inline void getMousePos(int* x, int* y) noexcept;
inline void mouseMove(void* win_ptr, int x, int y) noexcept;
inline void get_mouse_pos(int* x, int* y) noexcept
{
*x = _in.getX();
*y = _in.getY();
}
inline void* newGraphicsSuport(std::size_t w, std::size_t h, std::string title);
inline void clearGraphicsSupport(void* win_ptr);
inline void destroyGraphicsSupport(void* win_ptr);
inline void mouse_move(void* win_ptr, int x, int y) noexcept
{
SDL_WarpMouseInWindow(_wins[*static_cast<int*>(win_ptr)]->getNativeWindow(), x, y);
SDL_PumpEvents();
SDL_FlushEvent(SDL_MOUSEMOTION);
}
inline void pixelPut(void* win_ptr, int x, int y, int color) const noexcept;
inline void loop_hook(int (*f)(void*), void* param) { _loop_hook = f; _param = param; }
inline void loop_end() noexcept { _in.finish(); }
void* newStbTexture(char* file, int* w, int* h); // stb textures are format managed by stb image (png, jpg, bpm, ...)
inline void texturePut(void* win_ptr, void* img, int x, int y);
void destroyTexture(void* ptr);
inline void pixel_put(void* win_ptr, int x, int y, int color) const noexcept { _wins[*static_cast<int*>(win_ptr)]->pixel_put(x, y, color); }
void* new_stb_texture(char* file, int* w, int* h); // stb textures are format managed by stb image (png, jpg, bpm, ...)
void texture_put(void* win, void* img, int x, int y);
void destroy_texture(void* ptr);
inline void loopHook(int (*f)(void*), void* param);
inline void loopEnd() noexcept;
inline void clear_window(void* win_ptr) { _wins[*static_cast<int*>(win_ptr)]->clear(); }
inline void destroy_window(void* win_ptr) { _wins[*static_cast<int*>(win_ptr)].reset(); }
void run() noexcept;
~Application() = default;
@@ -71,11 +56,13 @@ namespace mlx::core
Input _in;
TextureLibrary _texture_lib;
std::vector<TextureID> _texture_ids;
std::vector<std::shared_ptr<MLX_Window>> _wins;
std::vector<std::unique_ptr<GraphicsSupport>> _graphics;
std::function<int(void*)> _loop_hook;
void* _param = nullptr;
bool _is_loop_running = false;
};
}
#include <core/application.inl>
#endif // __MLX_APPLICATION__

67
src/core/application.inl git.filemode.normal_file
View File

@@ -0,0 +1,67 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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>
namespace mlx::core
{
void Application::getMousePos(int* x, int* y) noexcept
{
*x = _in.getX();
*y = _in.getY();
}
void Application::mouseMove(void* win_ptr, int x, int y) noexcept
{
SDL_WarpMouseInWindow(_graphics[*static_cast<int*>(win_ptr)]->getWindow()->getNativeWindow(), x, y);
SDL_PumpEvents();
SDL_FlushEvent(SDL_MOUSEMOTION);
}
void* Application::newGraphicsSuport(std::size_t w, std::size_t h, std::string title)
{
_graphics.emplace_back(std::make_unique<GraphicsSupport>(w, h, std::move(title), _graphics.size()));
return static_cast<void*>(&_graphics.back()->getID());
}
void Application::clearGraphicsSupport(void* win_ptr)
{
_graphics[*static_cast<int*>(win_ptr)]->clearRenderData();
}
void Application::destroyGraphicsSupport(void* win_ptr)
{
_graphics[*static_cast<int*>(win_ptr)].reset();
}
void Application::pixelPut(void* win_ptr, int x, int y, int color) const noexcept
{
_graphics[*static_cast<int*>(win_ptr)]->pixelPut(x, y, color);
}
void Application::texturePut(void* win_ptr, void* img, int x, int y)
{
std::shared_ptr<Texture> texture = _texture_lib.getTexture(*static_cast<TextureID*>(img));
_graphics[*static_cast<int*>(win_ptr)]->texturePut(texture, x, y);
}
void Application::loopHook(int (*f)(void*), void* param)
{
_loop_hook = f;
_param = param;
}
void Application::loopEnd() noexcept
{
_in.finish();
}
}

24
src/core/bridge.cpp
View File

@@ -6,7 +6,7 @@
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/04 17:35:20 by maldavid #+# #+# */
/* Updated: 2023/04/01 17:48:21 by maldavid ### ########.fr */
/* Updated: 2023/04/02 15:10:44 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
@@ -25,12 +25,12 @@ extern "C"
void* mlx_new_window(void* mlx, int w, int h, const char* title)
{
return static_cast<mlx::core::Application*>(mlx)->new_window(w, h, title);
return static_cast<mlx::core::Application*>(mlx)->newGraphicsSuport(w, h, title);
}
int mlx_loop_hook(void* mlx, int (*f)(void*), void* param)
{
static_cast<mlx::core::Application*>(mlx)->loop_hook(f, param);
static_cast<mlx::core::Application*>(mlx)->loopHook(f, param);
return 0;
}
@@ -42,7 +42,7 @@ extern "C"
int mlx_loop_end(void* mlx)
{
static_cast<mlx::core::Application*>(mlx)->loop_end();
static_cast<mlx::core::Application*>(mlx)->loopEnd();
return 0;
}
@@ -58,48 +58,48 @@ extern "C"
int mlx_mouse_move(void* mlx, void* win_ptr, int x, int y)
{
static_cast<mlx::core::Application*>(mlx)->mouse_move(win_ptr, x, y);
static_cast<mlx::core::Application*>(mlx)->mouseMove(win_ptr, x, y);
return 0;
}
int mlx_mouse_get_pos(void* mlx, int* x, int* y)
{
static_cast<mlx::core::Application*>(mlx)->get_mouse_pos(x, y);
static_cast<mlx::core::Application*>(mlx)->getMousePos(x, y);
return 0;
}
int mlx_put_image_to_window(void* mlx_ptr, void* win_ptr, void* img_ptr, int x, int y)
{
static_cast<mlx::core::Application*>(mlx_ptr)->texture_put(win_ptr, img_ptr, x, y);
static_cast<mlx::core::Application*>(mlx_ptr)->texturePut(win_ptr, img_ptr, x, y);
return 0;
}
int mlx_destroy_image(void* mlx_ptr, void* img_ptr)
{
static_cast<mlx::core::Application*>(mlx_ptr)->destroy_texture(img_ptr);
static_cast<mlx::core::Application*>(mlx_ptr)->destroyTexture(img_ptr);
return 0;
}
void* mlx_png_file_to_image(void* mlx_ptr, char* filename, int* width, int* height)
{
return static_cast<mlx::core::Application*>(mlx_ptr)->new_stb_texture(filename, width, height);
return static_cast<mlx::core::Application*>(mlx_ptr)->newStbTexture(filename, width, height);
}
int mlx_pixel_put(void* mlx, void* win_ptr, int x, int y, int color)
{
static_cast<mlx::core::Application*>(mlx)->pixel_put(win_ptr, x, y, color);
static_cast<mlx::core::Application*>(mlx)->pixelPut(win_ptr, x, y, color);
return 0;
}
int mlx_clear_window(void* mlx_ptr, void* win_ptr)
{
static_cast<mlx::core::Application*>(mlx_ptr)->clear_window(win_ptr);
static_cast<mlx::core::Application*>(mlx_ptr)->clearGraphicsSupport(win_ptr);
return 0;
}
int mlx_destroy_window(void* mlx, void* win_ptr)
{
static_cast<mlx::core::Application*>(mlx)->destroy_window(win_ptr);
static_cast<mlx::core::Application*>(mlx)->destroyGraphicsSupport(win_ptr);
return 0;
}

64
src/core/graphics.cpp git.filemode.normal_file
View File

@@ -0,0 +1,64 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* graphics.cpp :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/04/02 15:13:55 by maldavid #+# #+# */
/* Updated: 2023/04/02 17:33:47 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#include <core/graphics.h>
namespace mlx
{
GraphicsSupport::GraphicsSupport(std::size_t w, std::size_t h, std::string title, int id) :
_window(std::make_shared<MLX_Window>(w, h, std::move(title))),
_renderer(std::make_unique<Renderer>()),
_id(id)
{
_renderer->setWindow(_window.get());
_renderer->init();
_pixel_put_pipeline.init(w, h, *_renderer);
}
void GraphicsSupport::endRender() noexcept
{
auto cmd_buff = _renderer->getActiveCmdBuffer().get();
std::vector<VkDescriptorSet> sets;
sets.push_back(_renderer->getVertDescriptorSet().get());
for(auto& data : _textures_to_render)
{
if(data.texture->getSet() == VK_NULL_HANDLE)
data.texture->setDescriptor(_renderer->getFragDescriptorSet().duplicate());
if(!data.texture->hasBeenUpdated())
data.texture->updateSet(0);
sets.push_back(data.texture->getSet());
vkCmdBindDescriptorSets(cmd_buff, VK_PIPELINE_BIND_POINT_GRAPHICS, _renderer->getPipeline().getPipelineLayout(), 0, sets.size(), sets.data(), 0, nullptr);
data.texture->render(*_renderer, data.x, data.y);
sets.pop_back();
}
_pixel_put_pipeline.present();
sets.push_back(_pixel_put_pipeline.getDescriptorSet());
vkCmdBindDescriptorSets(cmd_buff, VK_PIPELINE_BIND_POINT_GRAPHICS, _renderer->getPipeline().getPipelineLayout(), 0, sets.size(), sets.data(), 0, nullptr);
_pixel_put_pipeline.render(*_renderer);
_renderer->endFrame();
for(auto& data : _textures_to_render)
data.texture->resetUpdate();
}
GraphicsSupport::~GraphicsSupport()
{
vkDeviceWaitIdle(Render_Core::get().getDevice().get());
_pixel_put_pipeline.destroy();
_renderer->destroy();
}
}

59
src/core/graphics.h git.filemode.normal_file
View File

@@ -0,0 +1,59 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* graphics.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/04/02 14:49:49 by maldavid #+# #+# */
/* Updated: 2023/04/02 15:36:49 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_GRAPHICS__
#define __MLX_GRAPHICS__
#include <memory>
#include <unordered_set>
#include <glm/glm.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <platform/window.h>
#include <renderer/renderer.h>
#include <utils/non_copyable.h>
#include <renderer/images/texture.h>
namespace mlx
{
class GraphicsSupport : public non_copyable
{
public:
GraphicsSupport(std::size_t w, std::size_t h, std::string title, int id);
inline int& getID() noexcept;
inline std::shared_ptr<MLX_Window> getWindow();
inline void beginRender() noexcept;
inline void clearRenderData() noexcept;
inline void pixelPut(int x, int y, int color) noexcept;
inline void texturePut(std::shared_ptr<Texture> texture, int x, int y);
void endRender() noexcept;
~GraphicsSupport();
private:
std::unordered_set<TextureRenderData> _textures_to_render;
glm::mat4 _proj = glm::mat4(1.0);
std::shared_ptr<MLX_Window> _window;
PixelPutPipeline _pixel_put_pipeline;
std::unique_ptr<Renderer> _renderer;
int _id;
};
}
#include <core/graphics.inl>
#endif

43
src/core/graphics.inl git.filemode.normal_file
View File

@@ -0,0 +1,43 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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 _id; }
std::shared_ptr<MLX_Window> GraphicsSupport::getWindow() { return _window; }
void GraphicsSupport::beginRender() noexcept
{
if(!_renderer->beginFrame())
return;
_proj = glm::ortho<float>(0, _window->getWidth(), 0, _window->getHeight());
_renderer->getUniformBuffer()->setData(sizeof(_proj), &_proj);
}
void GraphicsSupport::clearRenderData() noexcept
{
_textures_to_render.clear();
_pixel_put_pipeline.clear();
}
void GraphicsSupport::pixelPut(int x, int y, int color) noexcept
{
_pixel_put_pipeline.setPixel(x, y, color);
}
void GraphicsSupport::texturePut(std::shared_ptr<Texture> texture, int x, int y)
{
_textures_to_render.emplace(texture, x, y);
}
}