working on texts and fonts

runtime/Sources/Graphics/Font.cpp

@@ -10,8 +10,6 @@
 
 namespace mlx
 {
-	constexpr const int RANGE = 1024;
-
 	void Font::BuildFont()
 	{
 		MLX_PROFILE_FUNCTION();
@@ -21,7 +19,7 @@ namespace mlx
 			std::ifstream file(std::get<std::filesystem::path>(m_build_data), std::ios::binary);
 			if(!file.is_open())
 			{
-				Error("Font : cannot open font file, %", m_name);
+				Error("Font: cannot open font file, %", m_name);
 				return;
 			}
 			std::ifstream::pos_type file_size = std::filesystem::file_size(std::get<std::filesystem::path>(m_build_data));
@@ -56,6 +54,8 @@ namespace mlx
 		#else
 			m_atlas.Init(vulkan_bitmap, RANGE, RANGE, VK_FORMAT_R8G8B8A8_SRGB, false, {});
 		#endif
+
+		DebugLog("Font: loaded %", m_name);
 	}
 
 	void Font::Destroy()

runtime/Sources/Graphics/Scene.cpp

@@ -1,3 +1,4 @@
+#include "Graphics/Enums.h"
 #include <PreCompiled.h>
 #include <Graphics/Scene.h>
 #include <Renderer/Renderer.h>
@@ -10,64 +11,117 @@ namespace mlx
 		MLX_PROFILE_FUNCTION();
 		Verify((bool)texture, "Scene: invalid texture (internal mlx issue, please report to devs)");
 
-		#pragma omp parallel for
-		for(auto& sprite : m_sprites)
+		for(auto& drawable : m_drawables)
 		{
-			if(texture->GetWidth() == sprite->GetTexture()->GetWidth() && texture->GetHeight() == sprite->GetTexture()->GetHeight())
+			if(!drawable || drawable->GetType() != DrawableType::Sprite)
+				continue;
+			if(texture->GetWidth() == static_cast<Sprite*>(drawable.get())->GetTexture()->GetWidth() && texture->GetHeight() == static_cast<Sprite*>(drawable.get())->GetTexture()->GetHeight())
 			{
-				std::shared_ptr<Sprite> new_sprite = std::make_shared<Sprite>(sprite->GetMesh(), texture);
-				m_sprites.push_back(new_sprite);
+				std::shared_ptr<Sprite> new_sprite = std::make_shared<Sprite>(drawable->GetMesh(), texture);
+				m_drawables.push_back(new_sprite);
 				return *new_sprite;
 			}
 		}
 
 		std::shared_ptr<Sprite> sprite = std::make_shared<Sprite>(texture);
-		m_sprites.push_back(sprite);
+		m_drawables.push_back(sprite);
 		return *sprite;
 	}
 
 	NonOwningPtr<Sprite> Scene::GetSpriteFromTextureAndPosition(NonOwningPtr<Texture> texture, const Vec2f& position) const
 	{
 		MLX_PROFILE_FUNCTION();
-		auto it = std::find_if(m_sprites.begin(), m_sprites.end(), [&texture, &position](std::shared_ptr<Sprite> sprite)
+		auto it = std::find_if(m_drawables.begin(), m_drawables.end(), [&texture, &position](std::shared_ptr<Drawable> drawable)
 		{
-			return sprite->GetTexture() == texture && sprite->GetPosition().x == position.x && sprite->GetPosition().y == position.y;
+			if(!drawable || drawable->GetType() != DrawableType::Sprite)
+				return false;
+			return static_cast<Sprite*>(drawable.get())->GetTexture() == texture && drawable->GetPosition() == position;
 		});
-		return (it != m_sprites.end() ? it->get() : nullptr);
-	}
-
-	void Scene::BringToFront(NonOwningPtr<Sprite> sprite)
-	{
-		MLX_PROFILE_FUNCTION();
-		auto it = std::find_if(m_sprites.begin(), m_sprites.end(), [&sprite](std::shared_ptr<Sprite> sprite_ptr)
-		{
-			return sprite_ptr.get() == sprite.Get();
-		});
-		if(it == m_sprites.end())
-			return;
-		std::rotate(it, it + 1, m_sprites.end());
+		return static_cast<Sprite*>(it != m_drawables.end() ? it->get() : nullptr);
 	}
 
 	void Scene::TryEraseSpriteFromTexture(NonOwningPtr<Texture> texture)
 	{
 		MLX_PROFILE_FUNCTION();
-		auto it = m_sprites.begin();
+		auto it = m_drawables.begin();
 		do
 		{
-			it = std::find_if(m_sprites.begin(), m_sprites.end(), [&texture](std::shared_ptr<Sprite> sprite)
+			it = std::find_if(m_drawables.begin(), m_drawables.end(), [&texture](std::shared_ptr<Drawable> drawable)
 			{
-				return sprite->GetTexture() == texture;
+				if(!drawable || drawable->GetType() != DrawableType::Sprite)
+					return false;
+				return static_cast<Sprite*>(drawable.get())->GetTexture() == texture;
 			});
-			if(it != m_sprites.end())
-				m_sprites.erase(it);
-		} while(it != m_sprites.end());
+			if(it != m_drawables.end())
+				m_drawables.erase(it);
+		} while(it != m_drawables.end());
 	}
-	
+
 	bool Scene::IsTextureAtGivenDrawLayer(NonOwningPtr<Texture> texture, std::uint64_t draw_layer) const
 	{
 		MLX_PROFILE_FUNCTION();
-		if(draw_layer >= m_sprites.size())
+		if(draw_layer >= m_drawables.size())
 			return false;
-		return m_sprites[draw_layer]->GetTexture() == texture;
+		if(!m_drawables[draw_layer] || m_drawables[draw_layer]->GetType() != DrawableType::Sprite)
+			return false;
+		return static_cast<Sprite*>(m_drawables[draw_layer].get())->GetTexture() == texture;
+	}
+
+	Text& Scene::CreateText(const std::string& text) noexcept
+	{
+		MLX_PROFILE_FUNCTION();
+
+		Assert((bool)p_bound_font, "no font bound");
+
+		for(auto& drawable : m_drawables)
+		{
+			if(!drawable || drawable->GetType() != DrawableType::Text)
+				continue;
+			if(text == static_cast<Text*>(drawable.get())->GetText() && p_bound_font == static_cast<Text*>(drawable.get())->GetFont())
+			{
+				std::shared_ptr<Text> new_text = std::make_shared<Text>(text, p_bound_font, drawable->GetMesh());
+				m_drawables.push_back(new_text);
+				return *new_text;
+			}
+		}
+
+		std::shared_ptr<Text> new_text = std::make_shared<Text>(text, p_bound_font);
+		m_drawables.push_back(new_text);
+		return *new_text;
+	}
+
+	NonOwningPtr<Text> Scene::GetTextFromPositionAndColor(const std::string& text, const Vec2f& position, const Vec4f& color) const
+	{
+		MLX_PROFILE_FUNCTION();
+		auto it = std::find_if(m_drawables.begin(), m_drawables.end(), [&text, &position, &color](std::shared_ptr<Drawable> drawable)
+		{
+			if(!drawable || drawable->GetType() != DrawableType::Text)
+				return false;
+			return static_cast<Text*>(drawable.get())->GetText() == text && drawable->GetPosition() == position && drawable->GetColor() == color;
+		});
+		return static_cast<Text*>(it != m_drawables.end() ? it->get() : nullptr);
+	}
+
+	bool Scene::IsTextAtGivenDrawLayer(const std::string& text, std::uint64_t draw_layer) const
+	{
+		MLX_PROFILE_FUNCTION();
+		if(draw_layer >= m_drawables.size())
+			return false;
+		if(!m_drawables[draw_layer] || m_drawables[draw_layer]->GetType() != DrawableType::Text)
+			return false;
+		Text* ptr = static_cast<Text*>(m_drawables[draw_layer].get());
+		return ptr->GetText() == text && ptr->GetFont() == p_bound_font;
+	}
+
+	void Scene::BringToFront(NonOwningPtr<Drawable> drawable)
+	{
+		MLX_PROFILE_FUNCTION();
+		auto it = std::find_if(m_drawables.begin(), m_drawables.end(), [&drawable](std::shared_ptr<Drawable> drawable_ptr)
+		{
+			return drawable_ptr.get() == drawable.Get();
+		});
+		if(it == m_drawables.end())
+			return;
+		std::rotate(it, it + 1, m_drawables.end());
 	}
 }

runtime/Sources/Graphics/Sprite.cpp

@@ -37,7 +37,7 @@ namespace mlx
 		return mesh;
 	}
 
-	Sprite::Sprite(NonOwningPtr<Texture> texture)
+	Sprite::Sprite(NonOwningPtr<Texture> texture) : Drawable(DrawableType::Sprite)
 	{
 		MLX_PROFILE_FUNCTION();
 		Verify((bool)texture, "Sprite: invalid texture (internal mlx issue, please report to devs)");
@@ -45,7 +45,7 @@ namespace mlx
 		p_texture = texture;
 	}
 
-	Sprite::Sprite(std::shared_ptr<Mesh> mesh, NonOwningPtr<Texture> texture)
+	Sprite::Sprite(std::shared_ptr<Mesh> mesh, NonOwningPtr<Texture> texture) : Drawable(DrawableType::Sprite)
 	{
 		MLX_PROFILE_FUNCTION();
 		Verify((bool)texture, "Sprite: invalid texture (internal mlx issue, please report to devs)");

runtime/Sources/Graphics/Text.cpp

@@ -0,0 +1,61 @@
+#include <PreCompiled.h>
+
+#include <Graphics/Text.h>
+
+#define STB_RECT_PACK_IMPLEMENTATION
+#include <stb_rect_pack.h>
+
+namespace mlx
+{
+	Text::Text(const std::string& text, std::shared_ptr<Font> font) : Drawable(DrawableType::Text)
+	{
+		MLX_PROFILE_FUNCTION();
+
+		Assert(font != nullptr, "invalid font");
+
+		std::vector<Vertex> vertex_data;
+		std::vector<std::uint32_t> index_data;
+
+		float stb_x = 0.0f;
+		float stb_y = 0.0f;
+
+		for(char c : text)
+		{
+			if(c < 32)
+				continue;
+
+			stbtt_aligned_quad q;
+			stbtt_GetPackedQuad(font->GetCharData().data(), RANGE, RANGE, c - 32, &stb_x, &stb_y, &q, 1);
+
+			std::size_t index = vertex_data.size();
+
+			vertex_data.emplace_back(Vec4f{ q.x0, q.y0, 0.0f, 0.0f }, Vec2f{ q.s0, q.t0 });
+			vertex_data.emplace_back(Vec4f{ q.x1, q.y0, 0.0f, 0.0f }, Vec2f{ q.s1, q.t0 });
+			vertex_data.emplace_back(Vec4f{ q.x1, q.y1, 0.0f, 0.0f }, Vec2f{ q.s1, q.t1 });
+			vertex_data.emplace_back(Vec4f{ q.x0, q.y1, 0.0f, 0.0f }, Vec2f{ q.s0, q.t1 });
+
+			index_data.emplace_back(index + 0);
+			index_data.emplace_back(index + 1);
+			index_data.emplace_back(index + 2);
+			index_data.emplace_back(index + 2);
+			index_data.emplace_back(index + 3);
+			index_data.emplace_back(index + 0);
+		}
+
+		std::shared_ptr<Mesh> mesh = std::make_shared<Mesh>();
+		mesh->AddSubMesh({ std::move(vertex_data), std::move(index_data) });
+		Init(text, font, mesh);
+	}
+
+	void Text::Init(const std::string& text, std::shared_ptr<Font> font, std::shared_ptr<Mesh> mesh)
+	{
+		MLX_PROFILE_FUNCTION();
+
+		Assert(font != nullptr, "invalid font");
+		Assert(mesh != nullptr, "invalid mesh");
+
+		p_mesh = mesh;
+		p_font = font;
+		m_text = text;
+	}
+}