fixing compilation issues

runtime/Includes/Core/Graphics.h

@@ -5,6 +5,7 @@
 #include <Renderer/Renderer.h>
 #include <Graphics/Scene.h>
 #include <Graphics/Sprite.h>
+#include <Graphics/PutPixelManager.h>
 #include <Renderer/ScenesRenderer.h>
 #include <Maths/Mat4.h>
 
@@ -39,6 +40,7 @@ namespace mlx
 		private:
 			Renderer m_renderer;
 			SceneRenderer m_scene_renderer;
+			PutPixelManager m_put_pixel_manager;
 			std::shared_ptr<Window> p_window;
 			std::unique_ptr<Scene> p_scene;
 

runtime/Includes/Core/Graphics.inl

@@ -7,12 +7,19 @@ namespace mlx
 	{
 		MLX_PROFILE_FUNCTION();
 		p_scene->ResetSprites();
+		m_put_pixel_manager.ResetRenderData();
 		m_current_depth = 0;
 	}
 
 	void GraphicsSupport::PixelPut(int x, int y, std::uint32_t color) noexcept
 	{
 		MLX_PROFILE_FUNCTION();
+		NonOwningPtr<Texture> texture = m_put_pixel_manager.DrawPixel(x, y, m_current_depth, color);
+		if(texture)
+		{
+			Sprite& new_sprite = p_scene->CreateSprite(texture);
+			new_sprite.SetPosition(Vec3f{ 0.0f, 0.0f, static_cast<float>(m_current_depth) });
+		}
 	}
 
 	void GraphicsSupport::StringPut(int x, int y, std::uint32_t color, std::string str)

runtime/Includes/Core/Logs.h

@@ -48,7 +48,7 @@ namespace mlx
 namespace mlx
 {
 	#undef  DebugLog
-	#define DebugLog(...) DebugLog(__LINE__, __FILE__, AK_FUNC_SIG, __VA_ARGS__)
+	#define DebugLog(...) DebugLog(__LINE__, __FILE__, __func__, __VA_ARGS__)
 
 	#undef  Message
 	#define Message(...) Message(__LINE__, __FILE__, __func__, __VA_ARGS__)

runtime/Includes/Core/Memory.h

@@ -1,8 +1,6 @@
 #ifndef __MLX_MEMORY__
 #define __MLX_MEMORY__
 
-#include <Utils/Singleton.h>
-
 namespace mlx
 {
 	class MemManager : public Singleton<MemManager>

runtime/Includes/Core/SDLManager.h

@@ -20,7 +20,7 @@ namespace mlx
 			std::vector<const char*> GetRequiredVulkanInstanceExtentions(Handle window) const noexcept;
 			Vec2ui GetVulkanDrawableSize(Handle window) const noexcept;
 
-			inline void SetEventCallback(func::function<void(mlx_event_type, int, void*)> functor, void* userdata) { f_callback = std::move(functor); p_callback_data = userdata; }
+			inline void SetEventCallback(func::function<void(mlx_event_type, int, int, void*)> functor, void* userdata) { f_callback = std::move(functor); p_callback_data = userdata; }
 
 		private:
 			SDLManager() = default;
@@ -28,7 +28,7 @@ namespace mlx
 
 		private:
 			std::unordered_set<Handle> m_windows_registry;
-			func::function<void(mlx_event_type, int, void*)> f_callback;
+			func::function<void(mlx_event_type, int, int, void*)> f_callback;
 			void* p_callback_data = nullptr;
 			std::int32_t m_x;
 			std::int32_t m_y;

runtime/Includes/Graphics/PutPixelManager.h

@@ -0,0 +1,25 @@
+#ifndef __MLX_PUT_PIXEL_MANAGER__
+#define __MLX_PUT_PIXEL_MANAGER__
+
+#include <Renderer/Image.h>
+
+namespace mlx
+{
+	class PutPixelManager
+	{
+		public:
+			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 z, std::uint32_t color);
+			void ResetRenderData();
+
+			~PutPixelManager();
+
+		private:
+			std::map<std::uint64_t, Texture> m_textures;
+			NonOwningPtr<class Renderer> p_renderer;
+	};
+}
+
+#endif

runtime/Includes/Graphics/Scene.h

@@ -1,6 +1,7 @@
 #ifndef __MLX_SCENE__
 #define __MLX_SCENE__
 
+#include <Renderer/Renderer.h>
 #include <Graphics/Sprite.h>
 #include <Renderer/ViewerData.h>
 

runtime/Includes/Platform/Inputs.h

@@ -17,7 +17,7 @@ namespace mlx
 			};
 
 		public:
-			Inputs() = default;
+			Inputs();
 
 			void RegisterWindow(std::shared_ptr<Window> window);
 
@@ -39,7 +39,7 @@ namespace mlx
 
 			~Inputs() = default;
 
-		protected:
+		private:
 			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;

runtime/Sources/Core/Application.cpp

@@ -12,7 +12,11 @@ namespace mlx
 	{
 		EventBus::RegisterListener({[](const EventBase& event)
 		{
-		}, "__Application" });
+			if(event.What() == Event::FatalErrorEventCode)
+			{
+				std::abort();
+			}
+		}, "__MlxApplication" });
 
 		m_fps.Init();
 		SDLManager::Get().Init();

runtime/Sources/Core/Graphics.cpp

@@ -4,6 +4,7 @@
 namespace mlx
 {
 	GraphicsSupport::GraphicsSupport(std::size_t w, std::size_t h, NonOwningPtr<Texture> render_target, int id) :
+		m_put_pixel_manager(&m_renderer),
 		p_window(nullptr),
 		m_width(w),
 		m_height(h),
@@ -11,8 +12,8 @@ namespace mlx
 		m_has_window(false)
 	{
 		MLX_PROFILE_FUNCTION();
-		m_renderer.SetWindow(nullptr);
+		// TODO : re-enable render targets
-		m_renderer.Init(render_target);
+		m_renderer.Init(nullptr);
 		m_scene_renderer.Init();
 
 		SceneDescriptor descriptor{};
@@ -21,6 +22,7 @@ namespace mlx
 	}
 
 	GraphicsSupport::GraphicsSupport(std::size_t w, std::size_t h, std::string title, int id) :
+		m_put_pixel_manager(&m_renderer),
 		p_window(std::make_shared<Window>(w, h, title)),
 		m_width(w),
 		m_height(h),
@@ -28,8 +30,7 @@ namespace mlx
 		m_has_window(true)
 	{
 		MLX_PROFILE_FUNCTION();
-		m_renderer.SetWindow(p_window.get());
+		m_renderer.Init(p_window.get());
-		m_renderer.Init(nullptr);
 		m_scene_renderer.Init();
 
 		SceneDescriptor descriptor{};

runtime/Sources/Core/Logs.cpp

@@ -1,4 +1,5 @@
 #include <PreCompiled.h>
+#include <Core/Enums.h>
 #include <Utils/Ansi.h>
 
 namespace mlx
@@ -7,7 +8,7 @@ namespace mlx
 	{
 		struct FatalErrorEvent : public EventBase
 		{
-			std::uint32_t What() const override { return 167; }
+			Event What() const override { return Event::FatalErrorEventCode; }
 		};
 	}
 
@@ -48,7 +49,7 @@ namespace mlx
 		if(type == LogType::FatalError)
 		{
 			std::cout << Ansi::bg_red << "Fatal Error: emergency exit" << Ansi::bg_def << std::endl;
-			EventBus::Send("__internal_application", Internal::FatalErrorEvent{});
+			EventBus::Send("__MlxApplication", Internal::FatalErrorEvent{});
 		}
 	}
 }

runtime/Sources/Core/Profiler.cpp

@@ -20,7 +20,7 @@ namespace mlx
 
 	void Profiler::AppendProfileData(ProfileResult&& result)
 	{
-		std::lock_guard lock(_mutex);
+		std::lock_guard lock(m_mutex);
 		auto it = m_profile_data.find(result.name);
 		if(it != m_profile_data.end())
 		{

runtime/Sources/Core/SDLManager.cpp

@@ -32,7 +32,7 @@ namespace mlx
 		m_drop_sdl_responsability = SDL_WasInit(SDL_INIT_VIDEO);
 		if(m_drop_sdl_responsability) // is case the mlx is running in a sandbox like MacroUnitTester where SDL is already init
 			return;
-		SDL_SetMemoryFunctions(MemManager::malloc, MemManager::calloc, MemManager::realloc, MemManager::free);
+		SDL_SetMemoryFunctions(MemManager::Get().Malloc, MemManager::Get().Calloc, MemManager::Get().Realloc, MemManager::Get().Free);
 
 		#ifdef FORCE_WAYLAND
 			SDL_SetHint(SDL_HINT_VIDEODRIVER, "wayland,x11");
@@ -43,7 +43,7 @@ namespace mlx
 
 		struct WatcherData
 		{
-			func::function<void(mlx_event_type, int, void*)> callback;
+			func::function<void(mlx_event_type, int, int, void*)> callback;
 			NonOwningPtr<SDLManager> manager;
 			void* userdata;
 		};
@@ -61,38 +61,36 @@ namespace mlx
 			}
 
 			std::uint32_t id = event->window.windowID;
-			if(events_hooks.find(id) == events_hooks.end())
-				continue;
 			switch(event->type) 
 			{
-				case SDL_KEYUP: data->callback(MLX_KEYUP, event->key.keysym.scancode, data->userdata); break;
+				case SDL_KEYUP: data->callback(MLX_KEYUP, id, event->key.keysym.scancode, data->userdata); break;
-				case SDL_KEYDOWN: data->callback(MLX_KEYDOWN, event->key.keysym.scancode, data->userdata); break;
+				case SDL_KEYDOWN: data->callback(MLX_KEYDOWN, id, event->key.keysym.scancode, data->userdata); break;
-				case SDL_MOUSEBUTTONUP: data->callback(MLX_MOUSEUP, event->button.button, data->userdata); break;
+				case SDL_MOUSEBUTTONUP: data->callback(MLX_MOUSEUP, id, event->button.button, data->userdata); break;
-				case SDL_MOUSEBUTTONDOWN: data->callback(MLX_MOUSEDOWN, event->button.button, data->userdata); break;
+				case SDL_MOUSEBUTTONDOWN: data->callback(MLX_MOUSEDOWN, id, event->button.button, data->userdata); break;
 				case SDL_MOUSEWHEEL:
 				{
 					if(event->wheel.y > 0) // scroll up
-						data->callback(MLX_MOUSEWHEEL, 1, data->userdata);
+						data->callback(MLX_MOUSEWHEEL, id, 1, data->userdata);
 					else if(event->wheel.y < 0) // scroll down
-						data->callback(MLX_MOUSEWHEEL, 2, data->userdata);
+						data->callback(MLX_MOUSEWHEEL, id, 2, data->userdata);
 					if(event->wheel.x > 0) // scroll right
-						data->callback(MLX_MOUSEWHEEL, 3, data->userdata);
+						data->callback(MLX_MOUSEWHEEL, id, 3, data->userdata);
 					else if(event->wheel.x < 0) // scroll left
-						data->callback(MLX_MOUSEWHEEL, 4, data->userdata);
+						data->callback(MLX_MOUSEWHEEL, id, 4, data->userdata);
 					break;
 				}
 				case SDL_WINDOWEVENT:
 				{
-					switch(event.window.event)
+					switch(event->window.event)
 					{
-						case SDL_WINDOWEVENT_CLOSE: data->callback(MLX_WINDOW_EVENT, 0, data->userdata); break;
+						case SDL_WINDOWEVENT_CLOSE: data->callback(MLX_WINDOW_EVENT, id, 0, data->userdata); break;
-						case SDL_WINDOWEVENT_MOVED: data->callback(MLX_WINDOW_EVENT, 1, data->userdata); break;
+						case SDL_WINDOWEVENT_MOVED: data->callback(MLX_WINDOW_EVENT, id, 1, data->userdata); break;
-						case SDL_WINDOWEVENT_MINIMIZED: data->callback(MLX_WINDOW_EVENT, 2, data->userdata); break;
+						case SDL_WINDOWEVENT_MINIMIZED: data->callback(MLX_WINDOW_EVENT, id, 2, data->userdata); break;
-						case SDL_WINDOWEVENT_MAXIMIZED: data->callback(MLX_WINDOW_EVENT, 3, data->userdata); break;
+						case SDL_WINDOWEVENT_MAXIMIZED: data->callback(MLX_WINDOW_EVENT, id, 3, data->userdata); break;
-						case SDL_WINDOWEVENT_ENTER: data->callback(MLX_WINDOW_EVENT, 4, data->userdata); break;
+						case SDL_WINDOWEVENT_ENTER: data->callback(MLX_WINDOW_EVENT, id, 4, data->userdata); break;
-						case SDL_WINDOWEVENT_FOCUS_GAINED: data->callback(MLX_WINDOW_EVENT, 5, data->userdata); break;
+						case SDL_WINDOWEVENT_FOCUS_GAINED: data->callback(MLX_WINDOW_EVENT, id, 5, data->userdata); break;
-						case SDL_WINDOWEVENT_LEAVE: data->callback(MLX_WINDOW_EVENT, 6, data->userdata); break;
+						case SDL_WINDOWEVENT_LEAVE: data->callback(MLX_WINDOW_EVENT, id, 6, data->userdata); break;
-						case SDL_WINDOWEVENT_FOCUS_LOST: data->callback(MLX_WINDOW_EVENT, 7, data->userdata); break;
+						case SDL_WINDOWEVENT_FOCUS_LOST: data->callback(MLX_WINDOW_EVENT, id, 7, data->userdata); break;
 
 						default : break;
 					}
@@ -154,14 +152,14 @@ namespace mlx
 
 		if(!SDL_Vulkan_GetInstanceExtensions(static_cast<SDL_Window*>(window), &count, extensions.data()))
 			FatalError("Vulkan : cannot get instance extentions from window : %", SDL_GetError());
-		return extentions;
+		return extensions;
 	}
 
 	Vec2ui SDLManager::GetVulkanDrawableSize(Handle window) const noexcept
 	{
-		Vec2ui extent;
+		Vec2i extent;
-		SDL_Vulkan_GetDrawableSize(window, &extent.x, &extent.y);
+		SDL_Vulkan_GetDrawableSize(static_cast<SDL_Window*>(window), &extent.x, &extent.y);
-		return extent;
+		return Vec2ui{ extent };
 	}
 
 	void SDLManager::Shutdown() noexcept

runtime/Sources/Core/UUID.cpp

@@ -1,4 +1,4 @@
-#include <pre_compiled.h>
+#include <PreCompiled.h>
 
 #include <Core/UUID.h>
 

runtime/Sources/Graphics/PixelPutManager.cpp

@@ -0,0 +1,32 @@
+#include <PreCompiled.h>
+
+#include <Graphics/PutPixelManager.h>
+#include <Renderer/Renderer.h>
+
+namespace mlx
+{
+	NonOwningPtr<Texture> PutPixelManager::DrawPixel(int x, int y, std::uint64_t z, std::uint32_t color)
+	{
+		Verify((bool)p_renderer, "invalid renderer pointer");
+		auto it = m_textures.find(z);
+		if(it == m_textures.end())
+		{
+			VkExtent2D swapchain_extent = kvfGetSwapchainImagesSize(p_renderer->GetSwapchain());
+			Texture& texture = m_textures[z] = Texture({}, swapchain_extent.width, swapchain_extent.height);
+			texture.SetPixel(x, y, color);
+			return &texture;
+		}
+		it->second.SetPixel(x, y, color);
+		return nullptr;
+	}
+
+	void PutPixelManager::ResetRenderData()
+	{
+		m_textures.clear();
+	}
+
+	PutPixelManager::~PutPixelManager()
+	{
+		ResetRenderData();
+	}
+}

runtime/Sources/Graphics/Scene.cpp

@@ -21,20 +21,21 @@ namespace mlx
 
 	NonOwningPtr<Sprite> Scene::GetSpriteFromTextureAndPosition(NonOwningPtr<Texture> texture, const Vec2f& position) const
 	{
-		auto it = std::find_if(m_sprites.begin(), m_sprites.end(), [texture, position](const Sprite& sprite)
+		auto it = std::find_if(m_sprites.begin(), m_sprites.end(), [texture, position](std::shared_ptr<Sprite> sprite)
 		{
-			return sprite.GetPosition().x == position.x && sprite.GetPosition().y == position.y && sprite.GetTexture() == texture;
+			return sprite->GetPosition().x == position.x && sprite->GetPosition().y == position.y && sprite->GetTexture() == texture;
 		});
-		return (it != m_sprites.end() ? &(*it) : nullptr);
+		return (it != m_sprites.end() ? it->get() : nullptr);
 	}
 
 	void Scene::TryEraseSpriteFromTexture(NonOwningPtr<Texture> texture)
 	{
+		auto it = m_sprites.begin();
 		do
 		{
-			auto it = std::find_if(m_sprites.begin(), m_sprites.end(), [texture, position](const Sprite& sprite)
+			it = std::find_if(m_sprites.begin(), m_sprites.end(), [texture](std::shared_ptr<Sprite> sprite)
 			{
-				return sprite.GetPosition().x == position.x && sprite.GetPosition().y == position.y && sprite.GetTexture() == texture;
+				return sprite->GetTexture() == texture;
 			});
 			m_sprites.erase(it);
 		} while(it != m_sprites.end());

runtime/Sources/Platform/Inputs.cpp

@@ -1,7 +1,18 @@
 #include <PreCompiled.h>
 
+#include <mlx.h>
 #include <Platform/Inputs.h>
+#include <Core/SDLManager.h>
 
 namespace mlx
 {
+	Inputs::Inputs()
+	{
+		SDLManager::Get().SetEventCallback([this](mlx_event_type event, int window_id, int code, [[maybe_unused]] void* userdata)
+		{
+			if(m_windows.find(window_id) == m_windows.end())
+				return;
+			m_events_hooks[window_id][event].hook(code, m_events_hooks[window_id][event].param);
+		}, nullptr);
+	}
 }

runtime/Sources/Renderer/Buffer.cpp

@@ -32,7 +32,7 @@ namespace mlx
 		if(!data.Empty())
 		{
 			if(p_map != nullptr)
-				std::memcpy(m_memory.map, data.GetData(), data.GetSize());
+				std::memcpy(p_map, data.GetData(), data.GetSize());
 		}
 		if(type == BufferType::Constant || type == BufferType::LowDynamic)
 			PushToGPU();
@@ -46,7 +46,7 @@ namespace mlx
 		bufferInfo.usage = usage;
 		bufferInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
 
-		m_allocation = RenderCore::Get().GetAllocator().CreateBuffer(&bufferInfo, &info, m_buffer, nullptr);
+		m_allocation = RenderCore::Get().GetAllocator().CreateBuffer(&bufferInfo, &alloc_info, m_buffer, nullptr);
 		if(alloc_info.flags != 0)
 			RenderCore::Get().GetAllocator().MapMemory(m_allocation, &p_map);
 	}
@@ -66,7 +66,7 @@ namespace mlx
 
 		VkCommandBuffer cmd = kvfCreateCommandBuffer(RenderCore::Get().GetDevice());
 		kvfBeginCommandBuffer(cmd, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT);
-		kvfCopyBufferToBuffer(cmd, m_buffer, buffer.Get(), m_memory.size);
+		kvfCopyBufferToBuffer(cmd, m_buffer, buffer.Get(), m_size);
 		kvfEndCommandBuffer(cmd);
 		VkFence fence = kvfCreateFence(RenderCore::Get().GetDevice());
 		kvfSubmitSingleTimeCommandBuffer(RenderCore::Get().GetDevice(), cmd, KVF_GRAPHICS_QUEUE, fence);
@@ -82,7 +82,7 @@ namespace mlx
 
 		GPUBuffer new_buffer;
 		new_buffer.m_usage = (this->m_usage & 0xFFFFFFFC) | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
-		new_buffer.CreateBuffer(m_memory.size, new_buffer.m_usage, alloc_info);
+		new_buffer.CreateBuffer(m_size, new_buffer.m_usage, alloc_info);
 
 		if(new_buffer.CopyFrom(*this))
 			Swap(new_buffer);
@@ -111,9 +111,9 @@ namespace mlx
 
 	void VertexBuffer::SetData(CPUBuffer data)
 	{
-		if(data.GetSize() > m_memory.size)
+		if(data.GetSize() > m_size)
 		{
-			Error("Vulkan : trying to store to much data in a vertex buffer (% bytes in % bytes)", data.GetSize(), m_memory.size);
+			Error("Vulkan : trying to store to much data in a vertex buffer (% bytes in % bytes)", data.GetSize(), m_size);
 			return;
 		}
 		if(data.Empty())
@@ -129,9 +129,9 @@ namespace mlx
 
 	void IndexBuffer::SetData(CPUBuffer data)
 	{
-		if(data.GetSize() > m_memory.size)
+		if(data.GetSize() > m_size)
 		{
-			Error("Vulkan : trying to store to much data in an index buffer (% bytes in % bytes)", data.GetSize(), m_memory.size);
+			Error("Vulkan : trying to store to much data in an index buffer (% bytes in % bytes)", data.GetSize(), m_size);
 			return;
 		}
 		if(data.Empty())

runtime/Sources/Renderer/Descriptor.cpp

@@ -139,7 +139,7 @@ namespace mlx
 		vkUpdateDescriptorSets(RenderCore::Get().GetDevice(), writes.size(), writes.data(), 0, nullptr);
 	}
 
-	void Descriptor::Reallocate() noexcept
+	void DescriptorSet::Reallocate() noexcept
 	{
 		for(std::size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
 			m_set[i] = kvfAllocateDescriptorSet(RenderCore::Get().GetDevice(), m_set_layout);

runtime/Sources/Renderer/RenderPasses/2DPass.cpp

@@ -58,7 +58,7 @@ namespace mlx
 				}
 			}
 		};
-		EventBus::RegisterListener({ functor, "__ScopRender2DPass" });
+		EventBus::RegisterListener({ functor, "__MlxRender2DPass" });
 
 		p_viewer_data_set = std::make_shared<DescriptorSet>(p_vertex_shader->GetShaderLayout().set_layouts[0].second, p_vertex_shader->GetPipelineLayout().set_layouts[0], ShaderType::Vertex);
 		p_texture_set = std::make_shared<DescriptorSet>(p_fragment_shader->GetShaderLayout().set_layouts[0].second, p_fragment_shader->GetPipelineLayout().set_layouts[0], ShaderType::Fragment);

runtime/Sources/Renderer/RenderPasses/FinalPass.cpp

@@ -37,7 +37,7 @@ namespace mlx
 			if(event.What() == Event::DescriptorPoolResetEventCode)
 				p_set->Reallocate();
 		};
-		EventBus::RegisterListener({ functor, "__ScopFinalPass" });
+		EventBus::RegisterListener({ functor, "__MlxFinalPass" });
 
 		p_set = std::make_shared<DescriptorSet>(p_fragment_shader->GetShaderLayout().set_layouts[0].second, p_fragment_shader->GetPipelineLayout().set_layouts[0], ShaderType::Fragment);
 	}

runtime/Sources/Renderer/RenderPasses/Passes.cpp

@@ -24,7 +24,7 @@ namespace mlx
 					m_main_render_texture.Init({}, extent.width, extent.height);
 				}
 			};
-			EventBus::RegisterListener({ functor, "__ScopRenderPasses" });
+			EventBus::RegisterListener({ functor, "__MlxRenderPasses" });
 			auto extent = kvfGetSwapchainImagesSize(renderer.GetSwapchain());
 
 			m_main_render_texture.Init({}, extent.width, extent.height);

runtime/Sources/Renderer/Renderer.cpp

@@ -32,7 +32,7 @@ namespace mlx
 			if(event.What() == Event::ResizeEventCode)
 				this->RequireFramebufferResize();
 		};
-		EventBus::RegisterListener({ functor, "__ScopRenderer" });
+		EventBus::RegisterListener({ functor, "__MlxRenderer" + std::to_string(reinterpret_cast<std::uintptr_t>(this)) });
 
 		p_window = window;