Implement back text rendering (WIP)

include/Nazara/Graphics/GuillotineTextureAtlas.hpp

@@ -0,0 +1,35 @@
+// Copyright (C) 2017 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Graphics module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_GUILLOTINETEXTUREATLAS_HPP
+#define NAZARA_GUILLOTINETEXTUREATLAS_HPP
+
+#include <Nazara/Prerequisites.hpp>
+#include <Nazara/Graphics/Config.hpp>
+#include <Nazara/Utility/GuillotineImageAtlas.hpp>
+
+namespace Nz
+{
+	class RenderDevice;
+
+	class NAZARA_GRAPHICS_API GuillotineTextureAtlas : public GuillotineImageAtlas
+	{
+		public:
+			inline GuillotineTextureAtlas(RenderDevice& renderDevice);
+			~GuillotineTextureAtlas() = default;
+
+			DataStoreFlags GetStorage() const override;
+
+		private:
+			std::shared_ptr<AbstractImage> ResizeImage(const std::shared_ptr<AbstractImage>& oldImage, const Vector2ui& size) const override;
+
+			RenderDevice& m_renderDevice;
+	};
+}
+
+#include <Nazara/Graphics/GuillotineTextureAtlas.inl>
+
+#endif // NAZARA_GUILLOTINETEXTUREATLAS_HPP

include/Nazara/Graphics/GuillotineTextureAtlas.inl

@@ -0,0 +1,16 @@
+// Copyright (C) 2017 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Graphics module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#include <Nazara/Graphics/GuillotineTextureAtlas.hpp>
+#include <Nazara/Graphics/Debug.hpp>
+
+namespace Nz
+{
+	inline GuillotineTextureAtlas::GuillotineTextureAtlas(RenderDevice& renderDevice) :
+	m_renderDevice(renderDevice)
+	{
+	}
+}
+
+#include <Nazara/Graphics/DebugOff.hpp>

include/Nazara/Graphics/TextSprite.hpp

@@ -0,0 +1,103 @@
+// Copyright (C) 2017 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Graphics module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_TEXTSPRITE_HPP
+#define NAZARA_TEXTSPRITE_HPP
+
+#include <Nazara/Prerequisites.hpp>
+#include <Nazara/Graphics/Config.hpp>
+#include <Nazara/Graphics/InstancedRenderable.hpp>
+#include <Nazara/Renderer/RenderPipeline.hpp>
+#include <Nazara/Utility/AbstractAtlas.hpp>
+#include <Nazara/Utility/VertexDeclaration.hpp>
+#include <Nazara/Utility/VertexStruct.hpp>
+#include <array>
+
+namespace Nz
+{
+	class AbstractTextDrawer;
+
+	class NAZARA_GRAPHICS_API TextSprite : public InstancedRenderable
+	{
+		public:
+			TextSprite(std::shared_ptr<Material> material);
+			TextSprite(const TextSprite&) = delete;
+			TextSprite(TextSprite&&) noexcept = default;
+			~TextSprite() = default;
+
+			void BuildElement(std::size_t passIndex, const WorldInstance& worldInstance, std::vector<std::unique_ptr<RenderElement>>& elements) const override;
+
+			inline void Clear();
+
+			const std::shared_ptr<Material>& GetMaterial(std::size_t i) const;
+			std::size_t GetMaterialCount() const;
+
+			inline void SetMaterial(std::shared_ptr<Material> material);
+
+			void Update(const AbstractTextDrawer& drawer, float scale = 1.f);
+
+			TextSprite& operator=(const TextSprite&) = delete;
+			TextSprite& operator=(TextSprite&&) noexcept = default;
+
+		private:
+			void OnAtlasInvalidated(const AbstractAtlas* atlas);
+			void OnAtlasLayerChange(const AbstractAtlas* atlas, AbstractImage* oldLayer, AbstractImage* newLayer);
+
+			struct AtlasSlots
+			{
+				bool used;
+				NazaraSlot(AbstractAtlas, OnAtlasCleared, clearSlot);
+				NazaraSlot(AbstractAtlas, OnAtlasLayerChange, layerChangeSlot);
+				NazaraSlot(AbstractAtlas, OnAtlasRelease, releaseSlot);
+			};
+
+			struct RenderData
+			{
+
+			};
+
+			struct RenderKey
+			{
+				Texture* texture;
+				int renderOrder;
+
+				bool operator==(const RenderKey& rhs) const
+				{
+					return texture == rhs.texture && renderOrder == rhs.renderOrder;
+				}
+
+				bool operator!=(const RenderKey& rhs) const
+				{
+					return !operator==(rhs);
+				}
+			};
+
+			struct HashRenderKey
+			{
+				std::size_t operator()(const RenderKey& key) const
+				{
+					// Since renderOrder will be very small, this will be enough
+					return std::hash<Texture*>()(key.texture) + key.renderOrder;
+				}
+			};
+
+			struct RenderIndices
+			{
+				unsigned int first;
+				unsigned int count;
+			};
+
+			std::unordered_map<const AbstractAtlas*, AtlasSlots> m_atlases;
+			mutable std::unordered_map<RenderKey, RenderIndices, HashRenderKey> m_renderInfos;
+			std::shared_ptr<Material> m_material;
+			std::vector<RenderData> m_data;
+			std::vector<VertexStruct_XYZ_Color_UV> m_vertices;
+	};
+}
+
+#include <Nazara/Graphics/TextSprite.inl>
+
+#endif

include/Nazara/Graphics/TextSprite.inl

@@ -0,0 +1,23 @@
+// Copyright (C) 2017 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Graphics module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#include <Nazara/Graphics/TextSprite.hpp>
+#include <cassert>
+#include <Nazara/Graphics/Debug.hpp>
+
+namespace Nz
+{
+	inline void TextSprite::Clear()
+	{
+		m_atlases.clear();
+		m_vertices.clear();
+	}
+
+	inline void TextSprite::SetMaterial(std::shared_ptr<Material> material)
+	{
+		m_material = std::move(material);
+	}
+}
+
+#include <Nazara/Graphics/DebugOff.hpp>

include/Nazara/Utility/AbstractAtlas.hpp

@@ -12,6 +12,7 @@
 #include <Nazara/Core/SparsePtr.hpp>
 #include <Nazara/Math/Rect.hpp>
 #include <Nazara/Utility/Config.hpp>
+#include <Nazara/Utility/Enums.hpp>
 
 namespace Nz
 {
@@ -30,7 +31,7 @@ namespace Nz
 			virtual void Free(SparsePtr<const Rectui> rects, SparsePtr<unsigned int> layers, unsigned int count) = 0;
 			virtual AbstractImage* GetLayer(unsigned int layerIndex) const = 0;
 			virtual std::size_t GetLayerCount() const = 0;
-			virtual UInt32 GetStorage() const = 0;
+			virtual DataStoreFlags GetStorage() const = 0;
 			virtual bool Insert(const Image& image, Rectui* rect, bool* flipped, unsigned int* layerIndex) = 0;
 
 			AbstractAtlas& operator=(const AbstractAtlas&) = delete;

include/Nazara/Utility/Enums.hpp

@@ -127,6 +127,13 @@ namespace Nz
 		Max = Software
 	};
 
+	template<>
+	struct EnumAsFlags<DataStorage>
+	{
+		static constexpr DataStorage max = DataStorage::Max;
+	};
+
+	using DataStoreFlags = Flags<DataStorage>;
 	constexpr std::size_t DataStorageCount = static_cast<std::size_t>(DataStorage::Max) + 1;
 
 	enum class FaceFilling

include/Nazara/Utility/Font.hpp

@@ -53,7 +53,7 @@ namespace Nz
 			void ClearKerningCache();
 			void ClearSizeInfoCache();
 
-			bool Create(FontData* data);
+			bool Create(std::unique_ptr<FontData> data);
 			void Destroy();
 
 			bool ExtractGlyph(unsigned int characterSize, char32_t character, TextStyleFlags style, float outlineThickness, FontGlyph* glyph) const;
@@ -74,7 +74,7 @@ namespace Nz
 			bool Precache(unsigned int characterSize, TextStyleFlags style, float outlineThickness, char32_t character) const;
 			bool Precache(unsigned int characterSize, TextStyleFlags style, float outlineThickness, const std::string& characterSet) const;
 
-			void SetAtlas(const std::shared_ptr<AbstractAtlas>& atlas);
+			void SetAtlas(std::shared_ptr<AbstractAtlas> atlas);
 			void SetGlyphBorder(unsigned int borderSize);
 			void SetMinimumStepSize(unsigned int minimumStepSize);
 
@@ -90,7 +90,7 @@ namespace Nz
 			static std::shared_ptr<Font> OpenFromMemory(const void* data, std::size_t size, const FontParams& params = FontParams());
 			static std::shared_ptr<Font> OpenFromStream(Stream& stream, const FontParams& params = FontParams());
 
-			static void SetDefaultAtlas(const std::shared_ptr<AbstractAtlas>& atlas);
+			static void SetDefaultAtlas(std::shared_ptr<AbstractAtlas> atlas);
 			static void SetDefaultGlyphBorder(unsigned int borderSize);
 			static void SetDefaultMinimumStepSize(unsigned int minimumStepSize);
 

include/Nazara/Utility/GuillotineImageAtlas.hpp

@@ -33,7 +33,7 @@ namespace Nz
 			GuillotineBinPack::GuillotineSplitHeuristic GetRectSplitHeuristic() const;
 			AbstractImage* GetLayer(unsigned int layerIndex) const override;
 			std::size_t GetLayerCount() const override;
-			UInt32 GetStorage() const override;
+			DataStoreFlags GetStorage() const override;
 
 			bool Insert(const Image& image, Rectui* rect, bool* flipped, unsigned int* layerIndex) override;
 
@@ -46,7 +46,7 @@ namespace Nz
 		protected:
 			struct Layer;
 
-			virtual AbstractImage* ResizeImage(AbstractImage* oldImage, const Vector2ui& size) const;
+			virtual std::shared_ptr<AbstractImage> ResizeImage(const std::shared_ptr<AbstractImage>& oldImage, const Vector2ui& size) const;
 			bool ResizeLayer(Layer& layer, const Vector2ui& size);
 
 			struct QueuedGlyph
@@ -59,7 +59,7 @@ namespace Nz
 			struct Layer
 			{
 				std::vector<QueuedGlyph> queuedGlyphs;
-				std::unique_ptr<AbstractImage> image;
+				std::shared_ptr<AbstractImage> image;
 				GuillotineBinPack binPack;
 				unsigned int freedRectangles = 0;
 			};

include/Nazara/Utility/Image.hpp

@@ -70,18 +70,18 @@ namespace Nz
 			bool FlipVertically();
 
 			const UInt8* GetConstPixels(unsigned int x = 0, unsigned int y = 0, unsigned int z = 0, UInt8 level = 0) const;
-			unsigned int GetDepth(UInt8 level = 0) const override;
+			unsigned int GetDepth(UInt8 level = 0) const;
 			PixelFormat GetFormat() const override;
-			unsigned int GetHeight(UInt8 level = 0) const override;
+			unsigned int GetHeight(UInt8 level = 0) const;
 			UInt8 GetLevelCount() const override;
-			UInt8 GetMaxLevel() const override;
+			UInt8 GetMaxLevel() const;
-			std::size_t GetMemoryUsage() const override;
+			std::size_t GetMemoryUsage() const;
-			std::size_t GetMemoryUsage(UInt8 level) const override;
+			std::size_t GetMemoryUsage(UInt8 level) const;
 			Color GetPixelColor(unsigned int x, unsigned int y = 0, unsigned int z = 0) const;
 			UInt8* GetPixels(unsigned int x = 0, unsigned int y = 0, unsigned int z = 0, UInt8 level = 0);
 			Vector3ui GetSize(UInt8 level = 0) const override;
 			ImageType GetType() const override;
-			unsigned int GetWidth(UInt8 level = 0) const override;
+			unsigned int GetWidth(UInt8 level = 0) const;
 
 			bool HasAlpha() const;
 
@@ -101,9 +101,8 @@ namespace Nz
 			void SetLevelCount(UInt8 levelCount);
 			bool SetPixelColor(const Color& color, unsigned int x, unsigned int y = 0, unsigned int z = 0);
 
-			bool Update(const UInt8* pixels, unsigned int srcWidth = 0, unsigned int srcHeight = 0, UInt8 level = 0) override;
+			using AbstractImage::Update;
-			bool Update(const UInt8* pixels, const Boxui& box, unsigned int srcWidth = 0, unsigned int srcHeight = 0, UInt8 level = 0) override;
+			bool Update(const void* pixels, const Boxui& box, unsigned int srcWidth = 0, unsigned int srcHeight = 0, UInt8 level = 0) override;
-			bool Update(const UInt8* pixels, const Rectui& rect, unsigned int z = 0, unsigned int srcWidth = 0, unsigned int srcHeight = 0, UInt8 level = 0) override;
 
 			Image& operator=(const Image& image);
 			inline Image& operator=(Image&& image) noexcept;

src/Nazara/Graphics/Graphics.cpp

@@ -4,8 +4,10 @@
 
 #include <Nazara/Graphics/Graphics.hpp>
 #include <Nazara/Core/ECS.hpp>
+#include <Nazara/Graphics/GuillotineTextureAtlas.hpp>
 #include <Nazara/Graphics/MaterialPipeline.hpp>
 #include <Nazara/Graphics/PredefinedShaderStructs.hpp>
+#include <Nazara/Utility/Font.hpp>
 #include <stdexcept>
 #include <Nazara/Graphics/Debug.hpp>
 
@@ -77,10 +79,37 @@ namespace Nz
 		BuildBlitPipeline();
 		RegisterMaterialPasses();
 		SelectDepthStencilFormats();
+
+		Font::SetDefaultAtlas(std::make_shared<GuillotineTextureAtlas>(*m_renderDevice));
 	}
 
 	Graphics::~Graphics()
 	{
+		// Free of atlas if it is ours
+		std::shared_ptr<AbstractAtlas> defaultAtlas = Font::GetDefaultAtlas();
+		if (defaultAtlas && defaultAtlas->GetStorage() == DataStorage::Hardware)
+		{
+			Font::SetDefaultAtlas(nullptr);
+
+			// The default police can make live one hardware atlas after the free of a module (which could be problematic)
+			// So, if the default police use a hardware atlas, we stole it.
+			// I don't like this solution, but I don't have any better
+			if (!defaultAtlas.unique())
+			{
+				// Still at least one police use the atlas
+				const std::shared_ptr<Font>& defaultFont = Font::GetDefault();
+				defaultFont->SetAtlas(nullptr);
+
+				if (!defaultAtlas.unique())
+				{
+					// Still not the only one to own it ? Then crap.
+					NazaraWarning("Default font atlas uses hardware storage and is still used");
+				}
+			}
+		}
+
+		defaultAtlas.reset();
+
 		MaterialPipeline::Uninitialize();
 		m_renderPassCache.reset();
 		m_samplerCache.reset();
@@ -159,7 +188,7 @@ namespace Nz
 		{
 			Nz::TextureInfo texInfo;
 			texInfo.width = texInfo.height = texInfo.depth = texInfo.mipmapLevel = 1;
-			texInfo.pixelFormat = PixelFormat::BGRA8;
+			texInfo.pixelFormat = PixelFormat::L8;
 			texInfo.type = ImageType::E2D;
 
 			std::array<UInt8, 4> texData = { 0xFF, 0xFF, 0xFF, 0xFF };

src/Nazara/Graphics/GuillotineTextureAtlas.cpp

@@ -0,0 +1,72 @@
+// Copyright (C) 2017 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Graphics module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#include <Nazara/Graphics/GuillotineTextureAtlas.hpp>
+#include <Nazara/Renderer/RenderDevice.hpp>
+#include <Nazara/Renderer/Texture.hpp>
+#include <Nazara/Graphics/Debug.hpp>
+
+namespace Nz
+{
+	/*!
+	* \ingroup graphics
+	* \class Nz::GuillotineTextureAtlas
+	* \brief Graphics class that represents an atlas texture for guillotine
+	*/
+
+	/*!
+	* \brief Gets the underlying data storage
+	* \return Value of the enumeration of the underlying data storage
+	*/
+	DataStoreFlags GuillotineTextureAtlas::GetStorage() const
+	{
+		return DataStorage::Hardware;
+	}
+
+	/*!
+	* \brief Resizes the image
+	* \return Updated texture
+	*
+	* \param oldImage Old image to resize
+	* \param size New image size
+	*
+	* \remark Produces a NazaraError if resize failed
+	*/
+
+	std::shared_ptr<AbstractImage> GuillotineTextureAtlas::ResizeImage(const std::shared_ptr<AbstractImage>& oldImage, const Vector2ui& size) const
+	{
+		TextureInfo textureInfo;
+		textureInfo.width = size.x;
+		textureInfo.height = size.y;
+		textureInfo.pixelFormat = PixelFormat::A8;
+		textureInfo.type = ImageType::E2D;
+		
+		std::shared_ptr<Texture> newTexture = m_renderDevice.InstantiateTexture(textureInfo);
+		if (!newTexture)
+			return nullptr;
+
+		if (oldImage)
+		{
+			return nullptr;
+			/*const Texture& oldTexture = static_cast<const Texture&>(*oldImage);
+
+			// Copy of old data
+			///TODO: Copy from texture to texture
+			Image image;
+			if (!oldTexture->Download(&image))
+			{
+				NazaraError("Failed to download old texture");
+				return nullptr;
+			}
+
+			if (!newTexture->Update(&image, Rectui(0, 0, image.GetWidth(), image.GetHeight())))
+			{
+				NazaraError("Failed to update texture");
+				return nullptr;
+			}*/
+		}
+
+		return newTexture;
+	}
+}

src/Nazara/Graphics/TextSprite.cpp

@@ -0,0 +1,279 @@
+// Copyright (C) 2017 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Graphics module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#include <Nazara/Graphics/TextSprite.hpp>
+#include <Nazara/Core/CallOnExit.hpp>
+#include <Nazara/Graphics/Material.hpp>
+#include <Nazara/Graphics/RenderSpriteChain.hpp>
+#include <Nazara/Graphics/WorldInstance.hpp>
+#include <Nazara/Utility/AbstractTextDrawer.hpp>
+#include <Nazara/Graphics/Debug.hpp>
+
+namespace Nz
+{
+	TextSprite::TextSprite(std::shared_ptr<Material> material) :
+	InstancedRenderable(Nz::Boxf(-10000.f, -10000.f, -10000.f, 20000.f, 20000.f, 20000.f)),
+	m_material(std::move(material))
+	{
+	}
+
+	void TextSprite::BuildElement(std::size_t passIndex, const WorldInstance& worldInstance, std::vector<std::unique_ptr<RenderElement>>& elements) const
+	{
+		MaterialPass* materialPass = m_material->GetPass(passIndex);
+		if (!materialPass)
+			return;
+
+		const std::shared_ptr<VertexDeclaration>& vertexDeclaration = VertexDeclaration::Get(VertexLayout::XYZ_Color_UV);
+
+		std::vector<RenderPipelineInfo::VertexBufferData> vertexBufferData = {
+			{
+				{
+					0,
+					vertexDeclaration
+				}
+			}
+		};
+		const auto& renderPipeline = materialPass->GetPipeline()->GetRenderPipeline(vertexBufferData);
+
+		for (auto& pair : m_renderInfos)
+		{
+			const RenderKey& key = pair.first;
+			RenderIndices& indices = pair.second;
+
+			if (indices.count > 0)
+				elements.emplace_back(std::make_unique<RenderSpriteChain>(0, renderPipeline, vertexDeclaration, key.texture->shared_from_this(), indices.count, &m_vertices[indices.first * 4], materialPass->GetShaderBinding(), worldInstance.GetShaderBinding()));
+		}
+	}
+
+	const std::shared_ptr<Material>& TextSprite::GetMaterial(std::size_t i) const
+	{
+		assert(i == 0);
+		NazaraUnused(i);
+
+		return m_material;
+	}
+
+	std::size_t TextSprite::GetMaterialCount() const
+	{
+		return 1;
+	}
+
+	void TextSprite::Update(const AbstractTextDrawer& drawer, float scale)
+	{
+		CallOnExit clearOnFail([this]()
+		{
+			Clear();
+		});
+
+		// Mark every atlas as unused...
+		for (auto& pair : m_atlases)
+			pair.second.used = false;
+
+		// ... until they are marked as used by the drawer
+		std::size_t fontCount = drawer.GetFontCount();
+		for (std::size_t i = 0; i < fontCount; ++i)
+		{
+			Font& font = *drawer.GetFont(i);
+			const AbstractAtlas* atlas = font.GetAtlas().get();
+			NazaraAssert(atlas->GetStorage() == DataStorage::Hardware, "Font uses a non-hardware atlas which cannot be used by text sprites");
+
+			auto it = m_atlases.find(atlas);
+			if (it == m_atlases.end())
+			{
+				it = m_atlases.emplace(std::make_pair(atlas, AtlasSlots())).first;
+				AtlasSlots& atlasSlots = it->second;
+
+				atlasSlots.clearSlot.Connect(atlas->OnAtlasCleared, this, &TextSprite::OnAtlasInvalidated);
+				atlasSlots.layerChangeSlot.Connect(atlas->OnAtlasLayerChange, this, &TextSprite::OnAtlasLayerChange);
+				atlasSlots.releaseSlot.Connect(atlas->OnAtlasRelease, this, &TextSprite::OnAtlasInvalidated);
+			}
+
+			it->second.used = true;
+		}
+
+		// Remove unused atlas slots
+		auto atlasIt = m_atlases.begin();
+		while (atlasIt != m_atlases.end())
+		{
+			if (!atlasIt->second.used)
+				m_atlases.erase(atlasIt++);
+			else
+				++atlasIt;
+		}
+
+		std::size_t glyphCount = drawer.GetGlyphCount();
+
+		// Reset glyph count for every texture to zero
+		for (auto& pair : m_renderInfos)
+			pair.second.count = 0;
+
+		// Count glyph count for each texture
+		RenderKey lastRenderKey{ nullptr, 0 };
+		unsigned int* count = nullptr;
+
+		// Iterate over visible (non-space) glyphs
+		std::size_t visibleGlyphCount = 0;
+		for (std::size_t i = 0; i < glyphCount; ++i)
+		{
+			const AbstractTextDrawer::Glyph& glyph = drawer.GetGlyph(i);
+			if (!glyph.atlas)
+				continue;
+
+			Texture* texture = static_cast<Texture*>(glyph.atlas);
+			RenderKey renderKey{ texture, glyph.renderOrder };
+			if (lastRenderKey != renderKey)
+			{
+				auto it = m_renderInfos.find(renderKey);
+				if (it == m_renderInfos.end())
+					it = m_renderInfos.insert(std::make_pair(renderKey, RenderIndices{ 0U, 0U })).first;
+
+				count = &it->second.count;
+				lastRenderKey = renderKey;
+			}
+
+			(*count)++;
+			visibleGlyphCount++;
+		}
+
+		m_vertices.resize(visibleGlyphCount * 4);
+
+		// Attributes indices and reinitialize glyph count to zero to use it as a counter in the next loop
+		// This is because the 1st glyph can use texture A, the 2nd glyph can use texture B and the 3th glyph C can use texture A again
+		// so we need a counter to know where to write informations
+		// also remove unused render infos
+		unsigned int index = 0;
+		auto infoIt = m_renderInfos.begin();
+		while (infoIt != m_renderInfos.end())
+		{
+			RenderIndices& indices = infoIt->second;
+			if (indices.count == 0)
+				infoIt = m_renderInfos.erase(infoIt); //< No glyph uses this texture, remove from indices
+			else
+			{
+				indices.first = index;
+
+				index += indices.count;
+				indices.count = 0;
+				++infoIt;
+			}
+		}
+
+		Rectf bounds = drawer.GetBounds();
+
+		lastRenderKey = { nullptr, 0 };
+		RenderIndices* indices = nullptr;
+		for (unsigned int i = 0; i < glyphCount; ++i)
+		{
+			const AbstractTextDrawer::Glyph& glyph = drawer.GetGlyph(i);
+			if (!glyph.atlas)
+				continue;
+
+			Texture* texture = static_cast<Texture*>(glyph.atlas);
+			RenderKey renderKey{ texture, glyph.renderOrder };
+			if (lastRenderKey != renderKey)
+			{
+				indices = &m_renderInfos[renderKey]; //< We changed texture, adjust the pointer
+				lastRenderKey = renderKey;
+			}
+
+			// First, compute the uv coordinates from our atlas rect
+			Vector2ui size(texture->GetSize());
+			float invWidth = 1.f / size.x;
+			float invHeight = 1.f / size.y;
+
+			Rectf uvRect(glyph.atlasRect);
+			uvRect.x *= invWidth;
+			uvRect.y *= invHeight;
+			uvRect.width *= invWidth;
+			uvRect.height *= invHeight;
+
+			// Our glyph may be flipped in the atlas, to render it correctly we need to change the uv coordinates accordingly
+			const RectCorner normalCorners[4] = { RectCorner::LeftTop, RectCorner::RightTop, RectCorner::LeftBottom, RectCorner::RightBottom };
+			const RectCorner flippedCorners[4] = { RectCorner::LeftBottom, RectCorner::LeftTop, RectCorner::RightBottom, RectCorner::RightTop };
+
+			// Set the position, color and UV of our vertices
+			for (unsigned int j = 0; j < 4; ++j)
+			{
+				// Remember that indices->count is a counter here, not a count value
+				std::size_t offset = (indices->first + indices->count) * 4 + j;
+				m_vertices[offset].color = glyph.color;
+				m_vertices[offset].position = glyph.corners[j];
+				m_vertices[offset].position.y = bounds.height - m_vertices[offset].position.y;
+				m_vertices[offset].position *= scale;
+				m_vertices[offset].uv.Set(uvRect.GetCorner((glyph.flipped) ? flippedCorners[j] : normalCorners[j]));
+			}
+
+			// Increment the counter, go to next glyph
+			indices->count++;
+		}
+
+		/*m_localBounds = drawer.GetBounds();
+
+		InvalidateBoundingVolume();
+		InvalidateInstanceData(0);*/
+
+		clearOnFail.Reset();
+	}
+
+	/*!
+	* \brief Handle the invalidation of an atlas
+	*
+	* \param atlas Atlas being invalidated
+	*/
+	void TextSprite::OnAtlasInvalidated(const AbstractAtlas* atlas)
+	{
+		assert(m_atlases.find(atlas) != m_atlases.end());
+
+		NazaraWarning("TextSprite " + PointerToString(this) + " has been cleared because atlas " + PointerToString(atlas) + " has been invalidated (cleared or released)");
+		Clear();
+	}
+
+	/*!
+	* \brief Handle the size change of an atlas layer
+	*
+	* \param atlas Atlas being invalidated
+	* \param oldLayer Pointer to the previous layer
+	* \param newLayer Pointer to the new layer
+	*/
+	void TextSprite::OnAtlasLayerChange(const AbstractAtlas* atlas, AbstractImage* oldLayer, AbstractImage* newLayer)
+	{
+		NazaraUnused(atlas);
+
+		assert(m_atlases.find(atlas) != m_atlases.end());
+
+		if (!oldLayer)
+			return;
+
+		assert(newLayer);
+
+		// The texture of an atlas have just been recreated (size change)
+		// we have to adjust the coordinates of the texture and the rendering texture
+		Texture* oldTexture = static_cast<Texture*>(oldLayer);
+		Texture* newTexture = static_cast<Texture*>(newLayer);
+
+		Vector2ui oldSize(oldTexture->GetSize());
+		Vector2ui newSize(newTexture->GetSize());
+		Vector2f scale = Vector2f(oldSize) / Vector2f(newSize); // ratio of the old one to the new one
+
+		// It is possible we actually use that texture multiple times, check them all
+		for (auto it = m_renderInfos.begin(); it != m_renderInfos.end(); ++it)
+		{
+			const RenderKey& renderKey = it->first;
+			const RenderIndices& indices = it->second;
+
+			// Adjust texture coordinates by size ratio
+			SparsePtr<Vector2f> texCoordPtr(&m_vertices[indices.first].uv, sizeof(VertexStruct_XY_Color_UV));
+			for (unsigned int i = 0; i < indices.count; ++i)
+			{
+				for (unsigned int j = 0; j < 4; ++j)
+					m_vertices[i * 4 + j].uv *= scale;
+			}
+
+			// Erase and re-insert with the new texture handle
+			m_renderInfos.erase(it);
+			m_renderInfos.insert(std::make_pair(RenderKey{ newTexture, renderKey.renderOrder }, indices));
+			it = m_renderInfos.begin(); //< std::unordered_map::insert may invalidate all iterators, start from the beginning...
+		}
+	}
+}

src/Nazara/Utility/Font.cpp

@@ -37,7 +37,7 @@ namespace Nz
 		OnFontRelease(this);
 
 		Destroy();
-		SetAtlas(nullptr); // On libère l'atlas proprement
+		SetAtlas({}); // On libère l'atlas proprement
 	}
 
 	void Font::ClearGlyphCache()
@@ -81,19 +81,12 @@ namespace Nz
 		OnFontSizeInfoCacheCleared(this);
 	}
 
-	bool Font::Create(FontData* data)
+	bool Font::Create(std::unique_ptr<FontData> data)
 	{
+		NazaraAssert(data, "invalid font data");
+
 		Destroy();
-
+		m_data = std::move(data);
-		#if NAZARA_UTILITY_SAFE
-		if (!data)
-		{
-			NazaraError("Invalid font data");
-			return false;
-		}
-		#endif
-
-		m_data.reset(data);
 		return true;
 	}
 
@@ -230,7 +223,7 @@ namespace Nz
 			else
 			{
 				NazaraWarning("Failed to extract space character from font, using half the character size");
-				sizeInfo.spaceAdvance = characterSize/2;
+				sizeInfo.spaceAdvance = characterSize / 2;
 			}
 
 			it = m_sizeInfoCache.insert(std::make_pair(characterSize, sizeInfo)).first;
@@ -281,13 +274,13 @@ namespace Nz
 		return true;
 	}
 
-	void Font::SetAtlas(const std::shared_ptr<AbstractAtlas>& atlas)
+	void Font::SetAtlas(std::shared_ptr<AbstractAtlas> atlas)
 	{
 		if (m_atlas != atlas)
 		{
 			ClearGlyphCache();
 
-			m_atlas = atlas;
+			m_atlas = std::move(atlas);
 			if (m_atlas)
 			{
 				m_atlasClearedSlot.Connect(m_atlas->OnAtlasCleared, this, &Font::OnAtlasCleared);
@@ -380,9 +373,9 @@ namespace Nz
 		return utility->GetFontLoader().LoadFromStream(stream, params);
 	}
 
-	void Font::SetDefaultAtlas(const std::shared_ptr<AbstractAtlas>& atlas)
+	void Font::SetDefaultAtlas(std::shared_ptr<AbstractAtlas> atlas)
 	{
-		s_defaultAtlas = atlas;
+		s_defaultAtlas = std::move(atlas);
 	}
 
 	void Font::SetDefaultGlyphBorder(unsigned int borderSize)
@@ -392,13 +385,7 @@ namespace Nz
 
 	void Font::SetDefaultMinimumStepSize(unsigned int minimumStepSize)
 	{
-		#if NAZARA_UTILITY_SAFE
+		NazaraAssert(minimumStepSize, "minimum step size cannot be zero as it implies a division by zero");
-		if (minimumStepSize == 0)
-		{
-			NazaraError("Minimum step size cannot be zero as it implies division by zero");
-			return;
-		}
-		#endif
 
 		s_defaultMinimumStepSize = minimumStepSize;
 	}

src/Nazara/Utility/Formats/FreeTypeLoader.cpp

@@ -26,8 +26,8 @@ namespace Nz
 	{
 		class FreeTypeLibrary;
 
-		FT_Library s_library;
+		FT_Library s_library = nullptr;
-		FT_Stroker s_stroker;
+		FT_Stroker s_stroker = nullptr;
 		std::shared_ptr<FreeTypeLibrary> s_libraryOwner;
 		constexpr float s_scaleFactor = 1 << 6;
 		constexpr float s_invScaleFactor = 1.f / s_scaleFactor;
@@ -427,20 +427,17 @@ namespace Nz
 			}
 
 			std::shared_ptr<Font> font = std::make_shared<Font>();
-			if (font->Create(face.get()))
+			if (!font->Create(std::move(face)))
-			{
-				face.release();
-				return font;
-			}
-			else
 				return nullptr;
+
+			return font;
 		}
 
 		std::shared_ptr<Font> LoadMemory(const void* data, std::size_t size, const FontParams& parameters)
 		{
 			NazaraUnused(parameters);
 
-			std::unique_ptr<FreeTypeStream> face(new FreeTypeStream);
+			std::unique_ptr<FreeTypeStream> face = std::make_unique<FreeTypeStream>();
 			face->SetMemory(data, size);
 
 			if (!face->Open())
@@ -450,13 +447,10 @@ namespace Nz
 			}
 
 			std::shared_ptr<Font> font = std::make_shared<Font>();
-			if (font->Create(face.get()))
+			if (!font->Create(std::move(face)))
-			{
-				face.release();
-				return font;
-			}
-			else
 				return nullptr;
+
+			return font;
 		}
 
 		std::shared_ptr<Font> LoadStream(Stream& stream, const FontParams& parameters)
@@ -473,13 +467,10 @@ namespace Nz
 			}
 
 			std::shared_ptr<Font> font = std::make_shared<Font>();
-			if (font->Create(face.get()))
+			if (!font->Create(std::move(face)))
-			{
-				face.release();
-				return font;
-			}
-			else
 				return nullptr;
+
+			return font;
 		}
 	}
 

src/Nazara/Utility/GuillotineImageAtlas.cpp

@@ -73,9 +73,9 @@ namespace Nz
 		return m_layers.size();
 	}
 
-	UInt32 GuillotineImageAtlas::GetStorage() const
+	DataStoreFlags GuillotineImageAtlas::GetStorage() const
 	{
-		return static_cast<UInt32>(DataStorage::Software);
+		return DataStorage::Software;
 	}
 
 	bool GuillotineImageAtlas::Insert(const Image& image, Rectui* rect, bool* flipped, unsigned int* layerIndex)
@@ -159,30 +159,23 @@ namespace Nz
 		m_rectSplitHeuristic = heuristic;
 	}
 
-	AbstractImage* GuillotineImageAtlas::ResizeImage(AbstractImage* oldImage, const Vector2ui& size) const
+	std::shared_ptr<AbstractImage> GuillotineImageAtlas::ResizeImage(const std::shared_ptr<AbstractImage>& oldImage, const Vector2ui& size) const
 	{
-		std::unique_ptr<Image> newImage(new Image(ImageType::E2D, PixelFormat::A8, size.x, size.y));
+		std::shared_ptr<Image> newImage = std::make_shared<Image>(ImageType::E2D, PixelFormat::A8, size.x, size.y);
 		if (oldImage)
-		{
 			newImage->Copy(static_cast<Image&>(*oldImage), Rectui(size), Vector2ui(0, 0)); // Copie des anciennes données
-		}
 
-		return newImage.release();
+		return newImage;
 	}
 
 	bool GuillotineImageAtlas::ResizeLayer(Layer& layer, const Vector2ui& size)
 	{
-		AbstractImage* oldLayer = layer.image.get();
+		std::shared_ptr<AbstractImage> newImage = ResizeImage(layer.image, size);
-
-		std::unique_ptr<AbstractImage> newImage(ResizeImage(layer.image.get(), size));
 		if (!newImage)
 			return false; // Nous n'avons pas pu allouer
 
-		if (newImage.get() == oldLayer) // Le layer a été agrandi dans le même objet, pas de souci
+		if (newImage == layer.image) // Le layer a été agrandi dans le même objet, pas de souci
-		{
-			newImage.release(); // On possède déjà un unique_ptr sur cette ressource
 			return true;
-		}
 
 		// On indique à ceux que ça intéresse qu'on a changé de pointeur
 		// (chose très importante pour ceux qui le stockent)

xmake.lua

@@ -103,7 +103,8 @@ set_xmakever("2.5.6")
 
 add_repositories("local-repo xmake-repo")
 
-add_requires("chipmunk2d", "dr_wav", "entt", "freetype", "libflac", "libsdl", "minimp3", "stb")
+add_requires("chipmunk2d", "dr_wav", "entt", "libflac", "libsdl", "minimp3", "stb")
+add_requires("freetype", { configs = { bzip2 = true, png = true, woff2 = true, zlib = true, debug = is_mode("debug") } })
 add_requires("libvorbis", { configs = { with_vorbisenc = false } })
 add_requires("openal-soft", { configs = { shared = true }})
 add_requires("newtondynamics", { debug = is_plat("windows") and is_mode("debug") }) -- Newton doesn't like compiling in Debug on Linux