/*
 * This source file is part of MyGUI. For the latest info, see http://mygui.info/
 * Distributed under the MIT License
 * (See accompanying file COPYING.MIT or copy at http://opensource.org/licenses/MIT)
 */

#include "MyGUI_Precompiled.h"
#include "MyGUI_ResourceTrueTypeFont.h"
#include "MyGUI_DataManager.h"
#include "MyGUI_DataStreamHolder.h"
#include "MyGUI_RenderManager.h"
#include "MyGUI_Bitwise.h"

#ifdef MYGUI_USE_FREETYPE

	#include FT_GLYPH_H
	#include FT_TRUETYPE_TABLES_H
	#include FT_BITMAP_H
	#include FT_WINFONTS_H

	#ifdef MYGUI_MSDF_FONTS
		#include "msdfgen/msdfgen.h"
		#include "msdfgen/msdfgen-ext.h"
	#endif

#endif // MYGUI_USE_FREETYPE

namespace MyGUI
{

#ifndef MYGUI_USE_FREETYPE
	ResourceTrueTypeFont::ResourceTrueTypeFont()
	{
	}

	ResourceTrueTypeFont::~ResourceTrueTypeFont()
	{
	}

	void ResourceTrueTypeFont::deserialization(xml::ElementPtr _node, Version _version)
	{
		Base::deserialization(_node, _version);
		MYGUI_LOG(
			Error,
			"ResourceTrueTypeFont: TrueType font '"
				<< getResourceName() << "' disabled. Define MYGUI_USE_FREETYE if you need TrueType fonts.");
	}

	const GlyphInfo* ResourceTrueTypeFont::getGlyphInfo(Char _id) const
	{
		return nullptr;
	}

	ITexture* ResourceTrueTypeFont::getTextureFont() const
	{
		return nullptr;
	}

	int ResourceTrueTypeFont::getDefaultHeight() const
	{
		return 0;
	}

	void ResourceTrueTypeFont::textureInvalidate(ITexture* _texture)
	{
	}

	std::vector<std::pair<Char, Char>> ResourceTrueTypeFont::getCodePointRanges() const
	{
		return std::vector<std::pair<Char, Char>>();
	}

	Char ResourceTrueTypeFont::getSubstituteCodePoint() const
	{
		return Char();
	}

	void ResourceTrueTypeFont::initialise()
	{
	}

	void ResourceTrueTypeFont::setSource(std::string_view _value)
	{
	}

	void ResourceTrueTypeFont::setShader(std::string_view _value)
	{
	}

	void ResourceTrueTypeFont::setSize(float _value)
	{
	}

	void ResourceTrueTypeFont::setResolution(unsigned int _value)
	{
	}

	void ResourceTrueTypeFont::setHinting(std::string_view _value)
	{
	}

	void ResourceTrueTypeFont::setAntialias(bool _value)
	{
	}

	void ResourceTrueTypeFont::setTabWidth(float _value)
	{
	}

	void ResourceTrueTypeFont::setOffsetHeight(int _value)
	{
	}

	void ResourceTrueTypeFont::setSubstituteCode(int _value)
	{
	}

	void ResourceTrueTypeFont::setDistance(int _value)
	{
	}

	void ResourceTrueTypeFont::setMsdfMode(bool _value)
	{
	}

	void ResourceTrueTypeFont::setMsdfRange(int _value)
	{
	}

	void ResourceTrueTypeFont::addCodePointRange(Char _first, Char _second)
	{
	}

	void ResourceTrueTypeFont::removeCodePointRange(Char _first, Char _second)
	{
	}

#else // MYGUI_USE_FREETYPE
	namespace
	{

		template<typename T>
		void setMax(T& _var, const T& _newValue)
		{
			if (_var < _newValue)
				_var = _newValue;
		}

		const std::map<const Char, const uint8> charMask{
			{FontCodeType::Selected, 0x88},
			{FontCodeType::SelectedBack, 0x60},
			{FontCodeType::Cursor, 0xFF},
			{FontCodeType::Tab, 0x00}};
		const uint8 charMaskBlack = 0x00;
		const uint8 charMaskWhite = 0xFF;

		template<bool LAMode>
		struct PixelBase
		{
			static PixelFormat::Enum getFormat()
			{
				if constexpr (LAMode)
					return PixelFormat::L8A8;
				else
					return PixelFormat::R8G8B8A8;
			}

			static size_t getNumBytes()
			{
				if constexpr (LAMode)
					return 2;
				else
					return 4;
			}

		protected:
			// Sets a pixel in _dest as 4 or 2 bytes: L8L8L8A8 if LAMode is false, or L8A8 if LAMode is true.
			// Automatically advances _dest just past the pixel written.
			static void set(uint8*& _dest, uint8 _luminance, uint8 _alpha)
			{
				if constexpr (LAMode)
				{
					*_dest++ = _luminance;
					*_dest++ = _alpha;
				}
				else
				{
					*_dest++ = _luminance;
					*_dest++ = _luminance;
					*_dest++ = _luminance;
					*_dest++ = _alpha;
				}
			}
		};

		template<bool LAMode, bool FromSource = false, bool Antialias = false>
		struct Pixel : PixelBase<LAMode>
		{
			// Sets a pixel in _dest as 4 or 2 bytes: L8L8L8A8 if LAMode is false, or L8A8 if LAMode is true.
			// Sets luminance from _source if both FromSource and Antialias are true; otherwise, uses the specified value.
			// Sets alpha from _source if FromSource is true; otherwise, uses the specified value.
			// Automatically advances _source just past the pixel read if FromSource is true.
			// Automatically advances _dest just past the pixel written.
			static void set(uint8*& _dest, uint8 _luminance, uint8 _alpha, uint8*& _source)
			{
				if constexpr (FromSource)
				{
					(void)_alpha;
					if constexpr (Antialias)
					{
						(void)_luminance;
						// Sets the destination pixel using both the luminance and alpha from the specified source.
						PixelBase<LAMode>::set(_dest, *_source, *_source);
					}
					else
					{
						// Sets the destination pixel using the specified _luminance and alpha from the specified source.
						PixelBase<LAMode>::set(_dest, _luminance, *_source);
					}
					++_source;
				}
				else
				{
					(void)_source;
					// Sets the destination pixel using the specified luminance and alpha. Source is ignored.
					PixelBase<LAMode>::set(_dest, _luminance, _alpha);
				}
			}
		};
	}

	const int ResourceTrueTypeFont::mDefaultGlyphSpacing = 1;
	const float ResourceTrueTypeFont::mDefaultTabWidth = 8.0f;
	const float ResourceTrueTypeFont::mSelectedWidth = 1.0f;
	const float ResourceTrueTypeFont::mCursorWidth = 2.0f;

	ResourceTrueTypeFont::~ResourceTrueTypeFont()
	{
		if (mTexture != nullptr)
		{
			RenderManager::getInstance().destroyTexture(mTexture);
			mTexture = nullptr;
		}
	}

	void ResourceTrueTypeFont::deserialization(xml::ElementPtr _node, Version _version)
	{
		Base::deserialization(_node, _version);

		xml::ElementEnumerator node = _node->getElementEnumerator();
		while (node.next())
		{
			if (node->getName() == "Property")
			{
				std::string_view key = node->findAttribute("key");
				std::string_view value = node->findAttribute("value");
				if (key == "Source")
					setSource(value);
				else if (key == "Shader")
					setShader(value);
				else if (key == "Size")
					setSize(utility::parseFloat(value));
				else if (key == "Resolution")
					setResolution(utility::parseUInt(value));
				else if (key == "Antialias")
					setAntialias(utility::parseBool(value));
				else if (key == "TabWidth")
					setTabWidth(utility::parseFloat(value));
				else if (key == "OffsetHeight")
					setOffsetHeight(utility::parseInt(value));
				else if (key == "SubstituteCode")
					setSubstituteCode(utility::parseInt(value));
				else if (key == "Distance")
					setDistance(utility::parseInt(value));
				else if (key == "Hinting")
					setHinting(value);
				else if (key == "SpaceWidth")
				{
					mSpaceWidth = utility::parseFloat(value);
					MYGUI_LOG(
						Warning,
						_node->findAttribute("type")
							<< ": Property '" << key << "' in font '" << _node->findAttribute("name")
							<< "' is deprecated; remove it to use automatic calculation.");
				}
				else if (key == "CursorWidth")
				{
					MYGUI_LOG(
						Warning,
						_node->findAttribute("type")
							<< ": Property '" << key << "' in font '" << _node->findAttribute("name")
							<< "' is deprecated; value ignored.");
				}
				else if (key == "MsdfMode")
				{
					setMsdfMode(utility::parseBool(value));
				}
				else if (key == "MsdfRange")
				{
					setMsdfRange(utility::parseInt(value));
				}
			}
			else if (node->getName() == "Codes")
			{
				// Range of inclusions.
				xml::ElementEnumerator range = node->getElementEnumerator();
				while (range.next("Code"))
				{
					std::string range_value;
					if (range->findAttribute("range", range_value))
					{
						std::vector<std::string> parse_range = utility::split(range_value);
						if (!parse_range.empty())
						{
							Char first = utility::parseUInt(parse_range[0]);
							Char last = parse_range.size() > 1 ? utility::parseUInt(parse_range[1]) : first;
							addCodePointRange(first, last);
						}
					}
				}

				// If no code points have been included, include the Unicode Basic Multilingual Plane by default before processing
				//	any exclusions.
				if (mCharMap.empty())
					addCodePointRange(0, 0xFFFF);

				// Range of exclusions.
				range = node->getElementEnumerator();
				while (range.next("Code"))
				{
					std::string range_value;
					if (range->findAttribute("hide", range_value))
					{
						std::vector<std::string> parse_range = utility::split(range_value);
						if (!parse_range.empty())
						{
							Char first = utility::parseUInt(parse_range[0]);
							Char last = parse_range.size() > 1 ? utility::parseUInt(parse_range[1]) : first;
							removeCodePointRange(first, last);
						}
					}
				}
			}
		}

		initialise();
	}

	const GlyphInfo* ResourceTrueTypeFont::getGlyphInfo(Char _id) const
	{
		GlyphMap::const_iterator glyphIter = mGlyphMap.find(_id);

		if (glyphIter != mGlyphMap.end())
		{
			return &glyphIter->second;
		}

		return mSubstituteGlyphInfo;
	}

	ITexture* ResourceTrueTypeFont::getTextureFont() const
	{
		return mTexture;
	}

	int ResourceTrueTypeFont::getDefaultHeight() const
	{
		return mDefaultHeight;
	}

	void ResourceTrueTypeFont::textureInvalidate(ITexture* _texture)
	{
		mGlyphMap.clear();
		initialise();
	}

	std::vector<std::pair<Char, Char>> ResourceTrueTypeFont::getCodePointRanges() const
	{
		std::vector<std::pair<Char, Char>> result;

		if (!mCharMap.empty())
		{
			CharMap::const_iterator iter = mCharMap.begin();
			CharMap::const_iterator endIter = mCharMap.end();

			// Start the first range with the first code point in the map.
			Char rangeBegin = iter->first;
			Char rangeEnd = rangeBegin;

			// Loop over the rest of the map and find the contiguous ranges.
			for (++iter; iter != endIter; ++iter)
			{
				if (iter->first == rangeEnd + 1)
				{
					// Extend the current range.
					++rangeEnd;
				}
				else
				{
					// Found the start of a new range. First, save the current range.
					result.emplace_back(rangeBegin, rangeEnd);

					// Then start the new range.
					rangeBegin = rangeEnd = iter->first;
				}
			}

			// Save the final range.
			result.emplace_back(rangeBegin, rangeEnd);
		}

		return result;
	}

	Char ResourceTrueTypeFont::getSubstituteCodePoint() const
	{
		return mSubstituteCodePoint;
	}

	void ResourceTrueTypeFont::addCodePoint(Char _codePoint)
	{
		mCharMap.insert(CharMap::value_type(_codePoint, 0));
	}

	void ResourceTrueTypeFont::removeCodePoint(Char _codePoint)
	{
		mCharMap.erase(_codePoint);
	}

	void ResourceTrueTypeFont::addCodePointRange(Char _first, Char _second)
	{
		CharMap::iterator positionHint = mCharMap.lower_bound(_first);

		if (positionHint != mCharMap.begin())
			--positionHint;

		for (Char i = _first; i <= _second; ++i)
			positionHint = mCharMap.insert(positionHint, CharMap::value_type(i, 0));
	}

	void ResourceTrueTypeFont::removeCodePointRange(Char _first, Char _second)
	{
		mCharMap.erase(mCharMap.lower_bound(_first), mCharMap.upper_bound(_second));
	}

	void ResourceTrueTypeFont::clearCodePoints()
	{
		mCharMap.clear();
	}

	void ResourceTrueTypeFont::initialise()
	{
		if (mGlyphSpacing == -1)
			mGlyphSpacing = mDefaultGlyphSpacing;

		// If L8A8 (2 bytes per pixel) is supported, use it; otherwise, use R8G8B8A8 (4 bytes per pixel) as L8L8L8A8.
		bool laMode = MyGUI::RenderManager::getInstance().isFormatSupported(
			Pixel<true>::getFormat(),
			TextureUsage::Static | TextureUsage::Write);
		if (mMsdfMode)
			laMode = false;

		// Select and call an appropriate initialisation method. By making this decision up front, we avoid having to branch on
		// these variables many thousands of times inside tight nested loops later. From this point on, the various function
		// templates ensure that all the necessary branching is done purely at compile time for all combinations.
		if (laMode)
		{
			if (mAntialias)
				ResourceTrueTypeFont::initialiseFreeType<true, true>();
			else
				ResourceTrueTypeFont::initialiseFreeType<true, false>();
		}
		else
		{
			if (mAntialias)
				ResourceTrueTypeFont::initialiseFreeType<false, true>();
			else
				ResourceTrueTypeFont::initialiseFreeType<false, false>();
		}
	}

	template<bool LAMode, bool Antialias>
	void ResourceTrueTypeFont::initialiseFreeType()
	{
		//-------------------------------------------------------------------//
		// Initialise FreeType and load the font.
		//-------------------------------------------------------------------//

		FT_Library ftLibrary;

		if (FT_Init_FreeType(&ftLibrary) != 0)
			MYGUI_EXCEPT("ResourceTrueTypeFont: Could not init the FreeType library!");

		uint8* fontBuffer = nullptr;

		FT_Face ftFace = loadFace(ftLibrary, fontBuffer);

		if (ftFace == nullptr)
		{
			MYGUI_LOG(Error, "ResourceTrueTypeFont: Could not load the font '" << getResourceName() << "'!");
			FT_Done_FreeType(ftLibrary);
			return;
		}

	#ifdef MYGUI_MSDF_FONTS
		msdfgen::FontHandle* msdfFont = nullptr;

		if (mMsdfMode)
		{
			msdfFont = msdfgen::adoptFreetypeFont(ftFace);
		}
	#endif

		//-------------------------------------------------------------------//
		// Calculate the font metrics.
		//-------------------------------------------------------------------//

		// The font's overall ascent and descent are defined in three different places in a TrueType font, and with different
		// values in each place. The most reliable source for these metrics is usually the "usWinAscent" and "usWinDescent" pair of
		// values in the OS/2 header; however, some fonts contain inaccurate data there. To be safe, we use the highest of the set
		// of values contained in the face metrics and the two sets of values contained in the OS/2 header.
		int fontAscent = ftFace->size->metrics.ascender >> 6;
		int fontDescent = -ftFace->size->metrics.descender >> 6;

		TT_OS2* os2 = (TT_OS2*)FT_Get_Sfnt_Table(ftFace, ft_sfnt_os2);

		if (os2 != nullptr)
		{
			setMax(fontAscent, os2->usWinAscent * ftFace->size->metrics.y_ppem / ftFace->units_per_EM);
			setMax(fontDescent, os2->usWinDescent * ftFace->size->metrics.y_ppem / ftFace->units_per_EM);

			setMax(fontAscent, os2->sTypoAscender * ftFace->size->metrics.y_ppem / ftFace->units_per_EM);
			setMax(fontDescent, -os2->sTypoDescender * ftFace->size->metrics.y_ppem / ftFace->units_per_EM);
		}

		// The nominal font height is calculated as the sum of its ascent and descent as specified by the font designer. Previously
		// it was defined by MyGUI in terms of the maximum ascent and descent of the glyphs currently in use, but this caused the
		// font's line spacing to change whenever glyphs were added to or removed from the font definition. Doing it this way
		// instead prevents a lot of layout problems, and it is also more typographically correct and more aesthetically pleasing.
		mDefaultHeight = fontAscent + fontDescent;

		// Set the load flags based on the specified type of hinting.
		FT_Int32 ftLoadFlags = FT_LOAD_DEFAULT;

		switch (mHinting)
		{
		case HintingForceAuto: ftLoadFlags = FT_LOAD_FORCE_AUTOHINT; break;
		case HintingDisableAuto: ftLoadFlags = FT_LOAD_NO_AUTOHINT; break;
		case HintingDisableAll:
			// When hinting is completely disabled, glyphs must always be rendered -- even during layout calculations -- due to
			// discrepancies between the glyph metrics and the actual rendered bitmap metrics.
			ftLoadFlags = FT_LOAD_NO_HINTING | FT_LOAD_RENDER;
			break;
		case HintingUseNative: ftLoadFlags = FT_LOAD_DEFAULT; break;
		}

		//-------------------------------------------------------------------//
		// Create the glyphs and calculate their metrics.
		//-------------------------------------------------------------------//

		GlyphHeightMap glyphHeightMap;
		int texWidth = 0;

		// Before creating the glyphs, add the "Space" code point to force that glyph to be created. For historical reasons, MyGUI
		// users are accustomed to omitting this code point in their font definitions.
		addCodePoint(FontCodeType::Space);

		// Create the standard glyphs.
		for (CharMap::iterator iter = mCharMap.begin(); iter != mCharMap.end();)
		{
			const Char& codePoint = iter->first;
			FT_UInt glyphIndex = FT_Get_Char_Index(ftFace, codePoint);

			if (!mMsdfMode)
				texWidth += createFaceGlyph(glyphIndex, codePoint, fontAscent, ftFace, ftLoadFlags, glyphHeightMap);
	#ifdef MYGUI_MSDF_FONTS
			else
				texWidth += createMsdfFaceGlyph(codePoint, fontAscent, msdfFont, glyphHeightMap);
	#endif

			// If the newly created glyph is the "Not Defined" glyph, it means that the code point is not supported by the font.
			// Remove it from the character map so that we can provide our own substitute instead of letting FreeType do it.
			if (iter->second != 0)
				++iter;
			else
				mCharMap.erase(iter++);
		}

		// Do some special handling for the "Space" and "Tab" glyphs.
		GlyphMap::iterator spaceGlyphIter = mGlyphMap.find(FontCodeType::Space);

		if (spaceGlyphIter != mGlyphMap.end())
		{
			// Adjust the width of the "Space" glyph if it has been customized.
			if (mSpaceWidth != 0.0f)
			{
				texWidth += (int)std::ceil(mSpaceWidth) - (int)std::ceil(spaceGlyphIter->second.width);
				spaceGlyphIter->second.width = mSpaceWidth;
				spaceGlyphIter->second.advance = mSpaceWidth;
			}

			// If the width of the "Tab" glyph hasn't been customized, make it eight spaces wide.
			if (mTabWidth == 0.0f)
				mTabWidth = mDefaultTabWidth * spaceGlyphIter->second.advance;
		}

		// Create the special glyphs. They must be created after the standard glyphs so that they take precedence in case of a
		// collision. To make sure that the indices of the special glyphs don't collide with any glyph indices in the font, we must
		// use glyph indices higher than the highest glyph index in the font.
		FT_UInt nextGlyphIndex = (FT_UInt)ftFace->num_glyphs;

		float height = (float)mDefaultHeight;

		texWidth += createGlyph(
			nextGlyphIndex++,
			GlyphInfo(static_cast<Char>(FontCodeType::Tab), 0.0f, 0.0f, mTabWidth, 0.0f, 0.0f),
			glyphHeightMap);
		texWidth += createGlyph(
			nextGlyphIndex++,
			GlyphInfo(static_cast<Char>(FontCodeType::Selected), mSelectedWidth, height, 0.0f, 0.0f, 0.0f),
			glyphHeightMap);
		texWidth += createGlyph(
			nextGlyphIndex++,
			GlyphInfo(static_cast<Char>(FontCodeType::SelectedBack), mSelectedWidth, height, 0.0f, 0.0f, 0.0f),
			glyphHeightMap);
		texWidth += createGlyph(
			nextGlyphIndex++,
			GlyphInfo(static_cast<Char>(FontCodeType::Cursor), mCursorWidth, height, 0.0f, 0.0f, 0.0f),
			glyphHeightMap);

		// If a substitute code point has been specified, check to make sure that it exists in the character map. If it doesn't,
		// revert to the default "Not Defined" code point. This is not a real code point but rather an invalid Unicode value that
		// is guaranteed to cause the "Not Defined" special glyph to be created.
		if (mSubstituteCodePoint != FontCodeType::NotDefined && mCharMap.find(mSubstituteCodePoint) == mCharMap.end())
			mSubstituteCodePoint = static_cast<Char>(FontCodeType::NotDefined);

		// Create the "Not Defined" code point (and its corresponding glyph) if it's in use as the substitute code point.
		if (mSubstituteCodePoint == FontCodeType::NotDefined)
		{
			if (!mMsdfMode)
				texWidth += createFaceGlyph(
					0,
					static_cast<Char>(FontCodeType::NotDefined),
					fontAscent,
					ftFace,
					ftLoadFlags,
					glyphHeightMap);
	#ifdef MYGUI_MSDF_FONTS
			else
				texWidth += createMsdfFaceGlyph(
					static_cast<Char>(FontCodeType::NotDefined),
					fontAscent,
					msdfFont,
					glyphHeightMap);
	#endif
		}

		// Cache a pointer to the substitute glyph info for fast lookup.
		mSubstituteGlyphInfo = &mGlyphMap.find(mSubstituteCodePoint)->second;

		// Calculate the average height of all of the glyphs that are in use. This value will be used for estimating how large the
		// texture needs to be.
		double averageGlyphHeight = 0.0;

		for (const auto& heightItem : glyphHeightMap)
			averageGlyphHeight += heightItem.first * heightItem.second.size();

		averageGlyphHeight /= mGlyphMap.size();

		//-------------------------------------------------------------------//
		// Calculate the final texture size.
		//-------------------------------------------------------------------//

		// Round the current texture width and height up to the nearest powers of two.
		texWidth = Bitwise::firstPO2From(texWidth);
		int texHeight = Bitwise::firstPO2From((int)ceil(averageGlyphHeight) + mGlyphSpacing);

		// At this point, the texture is only one glyph high and is probably very wide. For efficiency reasons, we need to make the
		// texture as square as possible. If the texture cannot be made perfectly square, make it taller than it is wide, because
		// the height may decrease in the final layout due to height packing.
		while (texWidth > texHeight)
		{
			texWidth /= 2;
			texHeight *= 2;
		}

		// Calculate the final layout of all of the glyphs in the texture, packing them tightly by first arranging them by height.
		// We assume that the texture width is fixed but that the texture height can be adjusted up or down depending on how much
		// space is actually needed.
		// In most cases, the final texture will end up square or almost square. In some rare cases, however, we can end up with a
		// texture that's more than twice as high as it is wide; when this happens, we double the width and try again.
		do
		{
			if (texHeight > texWidth * 2)
				texWidth *= 2;

			int texX = mGlyphSpacing;
			int texY = mGlyphSpacing;

			for (const auto& heightItem : glyphHeightMap)
			{
				for (const auto& [key, info] : heightItem.second)
				{
					int glyphWidth = (int)std::ceil(info->width);
					int glyphHeight = (int)std::ceil(info->height);

					autoWrapGlyphPos(glyphWidth, texWidth, glyphHeight, texX, texY);

					if (glyphWidth > 0)
						texX += mGlyphSpacing + glyphWidth;
				}
			}

			texHeight = Bitwise::firstPO2From(texY + glyphHeightMap.rbegin()->first);
		} while (texHeight > texWidth * 2);

		//-------------------------------------------------------------------//
		// Create the texture and render the glyphs onto it.
		//-------------------------------------------------------------------//

		if (mTexture)
		{
			RenderManager::getInstance().destroyTexture(mTexture);
			mTexture = nullptr;
		}

		mTexture = RenderManager::getInstance().createTexture(MyGUI::utility::toString((size_t)this, "_TrueTypeFont"));

		mTexture
			->createManual(texWidth, texHeight, TextureUsage::Static | TextureUsage::Write, Pixel<LAMode>::getFormat());
		mTexture->setInvalidateListener(this);

		if (!mShader.empty())
			mTexture->setShader(mShader);

		uint8* texBuffer = static_cast<uint8*>(mTexture->lock(TextureUsage::Write));

		if (texBuffer != nullptr)
		{
			// Make the texture background transparent white (or black for msdf mode).
			for (uint8 *dest = texBuffer, *endDest = dest + texWidth * texHeight * Pixel<LAMode>::getNumBytes();
				 dest != endDest;)
				Pixel<LAMode, false, false>::set(dest, mMsdfMode ? charMaskBlack : charMaskWhite, charMaskBlack, dest);

			if (!mMsdfMode)
				renderGlyphs<LAMode, Antialias>(
					glyphHeightMap,
					ftLibrary,
					ftFace,
					ftLoadFlags,
					texBuffer,
					texWidth,
					texHeight);
	#ifdef MYGUI_MSDF_FONTS
			else
				renderMsdfGlyphs(glyphHeightMap, msdfFont, texBuffer, texWidth, texHeight);
	#endif

			mTexture->unlock();

			MYGUI_LOG(
				Info,
				"ResourceTrueTypeFont: Font '"
					<< getResourceName() << "' using texture size " << texWidth << " x " << texHeight << ".");
			MYGUI_LOG(
				Info,
				"ResourceTrueTypeFont: Font '"
					<< getResourceName() << "' using real height " << mDefaultHeight << " pixels.");
		}
		else
		{
			MYGUI_LOG(Error, "ResourceTrueTypeFont: Error locking texture; pointer is nullptr.");
		}

	#ifdef MYGUI_MSDF_FONTS
		if (mMsdfMode)
		{
			msdfgen::destroyFont(msdfFont);
		}
	#endif

		FT_Done_Face(ftFace);
		FT_Done_FreeType(ftLibrary);

		delete[] fontBuffer;
	}

	FT_Face ResourceTrueTypeFont::loadFace(const FT_Library& _ftLibrary, uint8*& _fontBuffer)
	{
		FT_Face result = nullptr;

		// Load the font file.
		IDataStream* datastream = DataManager::getInstance().getData(mSource);

		if (datastream == nullptr)
			return result;

		size_t fontBufferSize = datastream->size();
		_fontBuffer = new uint8[fontBufferSize];
		datastream->read(_fontBuffer, fontBufferSize);

		DataManager::getInstance().freeData(datastream);
		datastream = nullptr;

		// Determine how many faces the font contains.
		if (FT_New_Memory_Face(_ftLibrary, _fontBuffer, (FT_Long)fontBufferSize, -1, &result) != 0)
			MYGUI_EXCEPT("ResourceTrueTypeFont: Could not load the font '" << getResourceName() << "'!");

		FT_Long numFaces = result->num_faces;
		FT_Long faceIndex = 0;

		// Load the first face.
		if (FT_New_Memory_Face(_ftLibrary, _fontBuffer, (FT_Long)fontBufferSize, faceIndex, &result) != 0)
			MYGUI_EXCEPT("ResourceTrueTypeFont: Could not load the font '" << getResourceName() << "'!");

		if (result->face_flags & FT_FACE_FLAG_SCALABLE)
		{
			// The font is scalable, so set the font size by first converting the requested size to FreeType's 26.6 fixed-point
			// format.
			FT_F26Dot6 ftSize = (FT_F26Dot6)(mSize * (1 << 6));

			if (FT_Set_Char_Size(result, ftSize, 0, mResolution, mResolution) != 0)
				MYGUI_EXCEPT("ResourceTrueTypeFont: Could not set the font size for '" << getResourceName() << "'!");

			// If no code points have been specified, use the Unicode Basic Multilingual Plane by default.
			if (mCharMap.empty())
				addCodePointRange(0, 0xFFFF);
		}
		else
		{
			// The font isn't scalable, so try to load it as a Windows FNT/FON file.
			FT_WinFNT_HeaderRec fnt;

			// Enumerate all of the faces in the font and select the smallest one that's at least as large as the requested size
			// (after adjusting for resolution). If none of the faces are large enough, use the largest one.
			std::map<float, FT_Long> faceSizes;

			do
			{
				if (FT_Get_WinFNT_Header(result, &fnt) != 0)
					MYGUI_EXCEPT("ResourceTrueTypeFont: Could not load the font '" << getResourceName() << "'!");

				faceSizes.insert(
					std::make_pair((float)fnt.nominal_point_size * fnt.vertical_resolution / mResolution, faceIndex));

				FT_Done_Face(result);

				if (++faceIndex < numFaces)
					if (FT_New_Memory_Face(_ftLibrary, _fontBuffer, (FT_Long)fontBufferSize, faceIndex, &result) != 0)
						MYGUI_EXCEPT("ResourceTrueTypeFont: Could not load the font '" << getResourceName() << "'!");
			} while (faceIndex < numFaces);

			std::map<float, FT_Long>::const_iterator iter = faceSizes.lower_bound(mSize);

			faceIndex = (iter != faceSizes.end()) ? iter->second : faceSizes.rbegin()->second;

			if (FT_New_Memory_Face(_ftLibrary, _fontBuffer, (FT_Long)fontBufferSize, faceIndex, &result) != 0)
				MYGUI_EXCEPT("ResourceTrueTypeFont: Could not load the font '" << getResourceName() << "'!");

			// Select the first bitmap strike available in the selected face. This needs to be done explicitly even though Windows
			// FNT/FON files contain only one bitmap strike per face.
			if (FT_Select_Size(result, 0) != 0)
				MYGUI_EXCEPT("ResourceTrueTypeFont: Could not set the font size for '" << getResourceName() << "'!");

			// Windows FNT/FON files do not support Unicode, so restrict the code-point range to either ISO-8859-1 or ASCII,
			// depending on the font's encoding.
			if (mCharMap.empty())
			{
				// No code points have been specified, so add the printable ASCII range by default.
				addCodePointRange(0x20, 0x7E);

				// Additionally, if the font's character set is CP-1252, add the range of non-ASCII 8-bit code points that are
				// common between CP-1252 and ISO-8859-1; i.e., everything but 0x80 through 0x9F.
				if (fnt.charset == FT_WinFNT_ID_CP1252)
					addCodePointRange(0xA0, 0xFF);
			}
			else
			{
				// Some code points have been specified, so remove anything in the non-printable ASCII range as well as anything
				// over 8 bits.
				removeCodePointRange(0, 0x1F);
				removeCodePointRange(0x100, std::numeric_limits<Char>::max());

				// Additionally, remove non-ASCII 8-bit code points (plus ASCII DEL, 0x7F). If the font's character set is CP-1252,
				// remove only the code points that differ between CP-1252 and ISO-8859-1; otherwise, remove all of them.
				if (fnt.charset == FT_WinFNT_ID_CP1252)
					removeCodePointRange(0x7F, 0x9F);
				else
					removeCodePointRange(0x7F, 0xFF);
			}
		}

		return result;
	}

	void ResourceTrueTypeFont::autoWrapGlyphPos(int _glyphWidth, int _texWidth, int _lineHeight, int& _texX, int& _texY)
		const
	{
		if (_glyphWidth > 0 && _texX + mGlyphSpacing + _glyphWidth > _texWidth)
		{
			_texX = mGlyphSpacing;
			_texY += mGlyphSpacing + _lineHeight;
		}
	}

	GlyphInfo ResourceTrueTypeFont::createFaceGlyphInfo(Char _codePoint, int _fontAscent, FT_GlyphSlot _glyph) const
	{
		float bearingX = _glyph->metrics.horiBearingX / 64.0f;

		// The following calculations aren't currently needed but are kept here for future use.
		// float ascent = _glyph->metrics.horiBearingY / 64.0f;
		// float descent = (_glyph->metrics.height / 64.0f) - ascent;

		return {
			_codePoint,
			std::max((float)_glyph->bitmap.width, _glyph->metrics.width / 64.0f),
			std::max((float)_glyph->bitmap.rows, _glyph->metrics.height / 64.0f),
			(_glyph->advance.x / 64.0f) - bearingX,
			bearingX,
			std::floor(_fontAscent - (_glyph->metrics.horiBearingY / 64.0f) - mOffsetHeight)};
	}

	int ResourceTrueTypeFont::createGlyph(
		FT_UInt _glyphIndex,
		const GlyphInfo& _glyphInfo,
		GlyphHeightMap& _glyphHeightMap)
	{
		int width = (int)std::ceil(_glyphInfo.width);
		int height = (int)std::ceil(_glyphInfo.height);

		mCharMap[_glyphInfo.codePoint] = _glyphIndex;
		GlyphInfo& info = mGlyphMap.insert(GlyphMap::value_type(_glyphInfo.codePoint, _glyphInfo)).first->second;
		_glyphHeightMap[height].insert(std::make_pair(_glyphIndex, &info));

		return (width > 0) ? mGlyphSpacing + width : 0;
	}

	int ResourceTrueTypeFont::createFaceGlyph(
		FT_UInt _glyphIndex,
		Char _codePoint,
		int _fontAscent,
		const FT_Face& _ftFace,
		FT_Int32 _ftLoadFlags,
		GlyphHeightMap& _glyphHeightMap)
	{
		if (mGlyphMap.find(_codePoint) == mGlyphMap.end())
		{
			if (FT_Load_Glyph(_ftFace, _glyphIndex, _ftLoadFlags) == 0)
				return createGlyph(
					_glyphIndex,
					createFaceGlyphInfo(_codePoint, _fontAscent, _ftFace->glyph),
					_glyphHeightMap);
			MYGUI_LOG(
				Warning,
				"ResourceTrueTypeFont: Cannot load glyph "
					<< _glyphIndex << " for character " << _codePoint << " in font '" << getResourceName() << "'.");
		}
		else
		{
			mCharMap[_codePoint] = _glyphIndex;
		}

		return 0;
	}

	template<bool LAMode, bool Antialias>
	void ResourceTrueTypeFont::renderGlyphs(
		const GlyphHeightMap& _glyphHeightMap,
		const FT_Library& _ftLibrary,
		const FT_Face& _ftFace,
		FT_Int32 _ftLoadFlags,
		uint8* _texBuffer,
		int _texWidth,
		int _texHeight)
	{
		FT_Bitmap ftBitmap;
		FT_Bitmap_New(&ftBitmap);

		int texX = mGlyphSpacing;
		int texY = mGlyphSpacing;

		for (const auto& sameHeightGlyphs : _glyphHeightMap)
		{
			int glyphHeight = sameHeightGlyphs.first;
			for (const auto& glyph : sameHeightGlyphs.second)
			{
				GlyphInfo& info = *glyph.second;

				switch (info.codePoint)
				{
				case FontCodeType::Selected:
				case FontCodeType::SelectedBack:
				{
					renderGlyph<LAMode, false, false>(
						info,
						charMaskWhite,
						charMaskBlack,
						charMask.find(info.codePoint)->second,
						glyphHeight,
						_texBuffer,
						_texWidth,
						_texHeight,
						texX,
						texY);

					// Manually adjust the glyph's width to zero. This prevents artifacts from appearing at the seams when
					// rendering multi-character selections.
					GlyphMap::iterator glyphIter = mGlyphMap.find(info.codePoint);
					if (glyphIter != mGlyphMap.end())
					{
						glyphIter->second.width = 0.0f;
						glyphIter->second.uvRect.right = glyphIter->second.uvRect.left;
					}
				}
				break;

				case FontCodeType::Cursor:
				case FontCodeType::Tab:
					renderGlyph<LAMode, false, false>(
						info,
						charMaskWhite,
						charMaskBlack,
						charMask.find(info.codePoint)->second,
						glyphHeight,
						_texBuffer,
						_texWidth,
						_texHeight,
						texX,
						texY);
					break;

				default:
					if (FT_Load_Glyph(_ftFace, glyph.first, _ftLoadFlags | FT_LOAD_RENDER) == 0)
					{
						if (_ftFace->glyph->bitmap.buffer != nullptr)
						{
							uint8* glyphBuffer = nullptr;

							switch (_ftFace->glyph->bitmap.pixel_mode)
							{
							case FT_PIXEL_MODE_GRAY: glyphBuffer = _ftFace->glyph->bitmap.buffer; break;

							case FT_PIXEL_MODE_MONO:
								// Convert the monochrome bitmap to 8-bit before rendering it.
								if (FT_Bitmap_Convert(_ftLibrary, &_ftFace->glyph->bitmap, &ftBitmap, 1) == 0)
								{
									// Go through the bitmap and convert all of the nonzero values to 0xFF (white).
									for (uint8 *p = ftBitmap.buffer, *endP = p + ftBitmap.width * ftBitmap.rows;
										 p != endP;
										 ++p)
										*p = *p ? 0xFF : 0;

									glyphBuffer = ftBitmap.buffer;
								}
								break;
							}

							if (glyphBuffer != nullptr)
								renderGlyph<LAMode, true, Antialias>(
									info,
									charMaskWhite,
									charMaskWhite,
									charMaskWhite,
									glyphHeight,
									_texBuffer,
									_texWidth,
									_texHeight,
									texX,
									texY,
									glyphBuffer);
						}
					}
					else
					{
						MYGUI_LOG(
							Warning,
							"ResourceTrueTypeFont: Cannot render glyph "
								<< glyph.first << " for character " << info.codePoint << " in font '"
								<< getResourceName() << "'.");
					}
					break;
				}
			}
		}

		FT_Bitmap_Done(_ftLibrary, &ftBitmap);
	}

	template<bool LAMode, bool UseBuffer, bool Antialias>
	void ResourceTrueTypeFont::renderGlyph(
		GlyphInfo& _info,
		uint8 _luminance0,
		uint8 _luminance1,
		uint8 _alpha,
		int _lineHeight,
		uint8* _texBuffer,
		int _texWidth,
		int _texHeight,
		int& _texX,
		int& _texY,
		uint8* _glyphBuffer)
	{
		int width = (int)std::ceil(_info.width);
		int height = (int)std::ceil(_info.height);

		autoWrapGlyphPos(width, _texWidth, _lineHeight, _texX, _texY);

		uint8* dest = _texBuffer + (_texY * _texWidth + _texX) * Pixel<LAMode>::getNumBytes();

		// Calculate how much to advance the destination pointer after each row to get to the start of the next row.
		ptrdiff_t destNextRow = (_texWidth - width) * Pixel<LAMode>::getNumBytes();

		if (!mMsdfMode || !UseBuffer)
		{
			for (int j = height; j > 0; --j)
			{
				int i;
				for (i = width; i > 1; i -= 2)
				{
					Pixel<LAMode, UseBuffer, Antialias>::set(dest, _luminance0, _alpha, _glyphBuffer);
					Pixel<LAMode, UseBuffer, Antialias>::set(dest, _luminance1, _alpha, _glyphBuffer);
				}

				if (i > 0)
					Pixel<LAMode, UseBuffer, Antialias>::set(dest, _luminance0, _alpha, _glyphBuffer);

				dest += destNextRow;
			}
		}
		else
		{
			for (int y = 0; y < height; ++y)
			{
				for (int x = 0; x < width; ++x)
				{
					for (int i = 0; i < 3; ++i)
					{
						*dest++ = *_glyphBuffer++;
					}
					*dest++ = 255;
				}

				dest += destNextRow;
			}
		}

		// Calculate and store the glyph's UV coordinates within the texture.
		_info.uvRect.left = (float)_texX / _texWidth; // u1
		_info.uvRect.top = (float)_texY / _texHeight; // v1
		_info.uvRect.right = (float)(_texX + _info.width) / _texWidth; // u2
		_info.uvRect.bottom = (float)(_texY + _info.height) / _texHeight; // v2

		if (width > 0)
			_texX += mGlyphSpacing + width;
	}

	#ifdef MYGUI_MSDF_FONTS
	GlyphInfo ResourceTrueTypeFont::createMsdfFaceGlyphInfo(
		Char _codePoint,
		const msdfgen::Shape& _shape,
		double _advance,
		int _fontAscent)
	{
		msdfgen::Shape::Bounds bounds = _shape.getBounds();
		double range = mMsdfRange / 2.0;
		if (_shape.contours.empty())
		{
			bounds = {0, 0, 0, 0};
			range = 0;
		}

		double bearingX = bounds.l;

		return GlyphInfo(
			_codePoint,
			bounds.r - bounds.l + 2 * range,
			bounds.t - bounds.b + 2 * range,
			_advance - bearingX + range,
			bearingX - range,
			std::floor(_fontAscent - bounds.t - mOffsetHeight - range));
	}

	int ResourceTrueTypeFont::createMsdfGlyph(const GlyphInfo& _glyphInfo, GlyphHeightMap& _glyphHeightMap)
	{
		int width = (int)std::ceil(_glyphInfo.width);
		int height = (int)std::ceil(_glyphInfo.height);

		mCharMap[_glyphInfo.codePoint] = _glyphInfo.codePoint;
		GlyphInfo& info = mGlyphMap.insert(GlyphMap::value_type(_glyphInfo.codePoint, _glyphInfo)).first->second;
		_glyphHeightMap[height].insert(std::make_pair(_glyphInfo.codePoint, &info));

		return (width > 0) ? mGlyphSpacing + width : 0;
	}

	int ResourceTrueTypeFont::createMsdfFaceGlyph(
		Char _codePoint,
		int _fontAscent,
		msdfgen::FontHandle* _fontHandle,
		GlyphHeightMap& _glyphHeightMap)
	{
		if (mGlyphMap.find(_codePoint) == mGlyphMap.end())
		{
			msdfgen::Shape shape;
			double advance;
			if (msdfgen::loadGlyph(shape, _fontHandle, _codePoint, &advance))
				createMsdfGlyph(createMsdfFaceGlyphInfo(_codePoint, shape, advance, _fontAscent), _glyphHeightMap);
			else
				MYGUI_LOG(
					Warning,
					"ResourceTrueTypeFont: Cannot load msdf glyph for character "
						<< _codePoint << " in font '" << getResourceName() << "'.");
		}
		else
		{
			mCharMap[_codePoint] = _codePoint;
		}

		return 0;
	}

	void ResourceTrueTypeFont::renderMsdfGlyphs(
		const GlyphHeightMap& _glyphHeightMap,
		msdfgen::FontHandle* _fontHandle,
		uint8* _texBuffer,
		int _texWidth,
		int _texHeight)
	{
		int texX = mGlyphSpacing, texY = mGlyphSpacing;

		for (const auto& sameHeightGlyphs : _glyphHeightMap)
		{
			int glyphHeight = sameHeightGlyphs.first;
			for (const auto& glyph : sameHeightGlyphs.second)
			{
				GlyphInfo& info = *glyph.second;

				switch (info.codePoint)
				{
				case FontCodeType::Selected:
				case FontCodeType::SelectedBack:
				{
					renderGlyph<false, false, false>(
						info,
						charMaskWhite,
						charMaskBlack,
						charMask.find(info.codePoint)->second,
						glyphHeight,
						_texBuffer,
						_texWidth,
						_texHeight,
						texX,
						texY);

					// Manually adjust the glyph's width to zero. This prevents artifacts from appearing at the seams when
					// rendering multi-character selections.
					GlyphMap::iterator glyphIter = mGlyphMap.find(info.codePoint);
					if (glyphIter != mGlyphMap.end())
					{
						glyphIter->second.width = 0.0f;
						glyphIter->second.uvRect.right = glyphIter->second.uvRect.left;
					}
				}
				break;

				case FontCodeType::Cursor:
				case FontCodeType::Tab:
					renderGlyph<false, false, false>(
						info,
						charMaskWhite,
						charMaskBlack,
						charMask.find(info.codePoint)->second,
						glyphHeight,
						_texBuffer,
						_texWidth,
						_texHeight,
						texX,
						texY);
					break;

				default:
					msdfgen::Shape shape;
					if (loadGlyph(shape, _fontHandle, info.codePoint))
					{
						msdfgen::Shape::Bounds bounds = shape.getBounds();
						double range = mMsdfRange / 2.0;
						if (shape.contours.empty())
						{
							bounds = {0, 0, 0, 0};
							range = 0;
						}

						shape.normalize();
						edgeColoringSimple(shape, 3.0);

						msdfgen::Bitmap<float, 3> msdf(
							std::ceil(bounds.r - bounds.l + 2 * range),
							std::ceil(bounds.t - bounds.b + 2 * range));
						msdfgen::generateMSDF(
							msdf,
							shape,
							mMsdfRange,
							1,
							msdfgen::Vector2(-bounds.l + range, -bounds.b + range));
						//							double error = msdfgen::estimateSDFError(
						//								msdfgen::BitmapConstRef<float, 3>{(float*)msdf, msdf.width(), msdf.height()},
						//								shape,
						//								1,
						//								msdfgen::Vector2(-bounds.l + range, -bounds.b + range),
						//								33);
						//							if (100000 * error > 1)
						//								MYGUI_LOG(Warning, "Error for '" << char(info.codePoint) << "' is :" << (int) 100000 * error);

						uint8* glyphBuffer = new uint8[msdf.width() * msdf.height() * 3];
						uint8* glyphBufferPointer = glyphBuffer;
						for (int y = 0; y < msdf.height(); ++y)
						{
							for (int x = 0; x < msdf.width(); ++x)
							{
								for (int i = 0; i < 3; ++i)
								{
									// upside-down and RGB->BGR
									*glyphBufferPointer++ =
										msdfgen::pixelFloatToByte(msdf(x, msdf.height() - y - 1)[2 - i]);
								}
							}
						}

						renderGlyph<false, true, false>(
							info,
							charMaskWhite,
							charMaskWhite,
							charMaskWhite,
							glyphHeight,
							_texBuffer,
							_texWidth,
							_texHeight,
							texX,
							texY,
							glyphBuffer);
						delete[] glyphBuffer;
					}
					else
					{
						MYGUI_LOG(
							Warning,
							"ResourceTrueTypeFont: Cannot render glyph for character "
								<< info.codePoint << " in font '" << getResourceName() << "'.");
					}
					break;
				}
			}
		}
	}
	#endif

	void ResourceTrueTypeFont::setSource(std::string_view _value)
	{
		mSource = _value;
	}

	void ResourceTrueTypeFont::setShader(std::string_view _value)
	{
		mShader = _value;
	}

	void ResourceTrueTypeFont::setSize(float _value)
	{
		mSize = _value;
	}

	void ResourceTrueTypeFont::setResolution(unsigned int _value)
	{
		mResolution = _value;
	}

	void ResourceTrueTypeFont::setHinting(std::string_view _value)
	{
		if (_value == "use_native")
			mHinting = HintingUseNative;
		else if (_value == "force_auto")
			mHinting = HintingForceAuto;
		else if (_value == "disable_auto")
			mHinting = HintingDisableAuto;
		else if (_value == "disable_all")
			mHinting = HintingDisableAll;
		else
			mHinting = HintingUseNative;
	}

	void ResourceTrueTypeFont::setAntialias(bool _value)
	{
		mAntialias = _value;
	}

	void ResourceTrueTypeFont::setTabWidth(float _value)
	{
		mTabWidth = _value;
	}

	void ResourceTrueTypeFont::setOffsetHeight(int _value)
	{
		mOffsetHeight = _value;
	}

	void ResourceTrueTypeFont::setSubstituteCode(int _value)
	{
		mSubstituteCodePoint = _value;
	}

	void ResourceTrueTypeFont::setDistance(int _value)
	{
		mGlyphSpacing = _value;
	}

	void ResourceTrueTypeFont::setMsdfMode(bool _value)
	{
	#ifndef MYGUI_MSDF_FONTS
		if (_value)
			MYGUI_LOG(
				Error,
				"MsdfMode flag ignored Define MYGUI_MSDF_FONTS if you need msdf fonts, msdf mode ignored.");
	#else
		mMsdfMode = _value;
	#endif
	}

	void ResourceTrueTypeFont::setMsdfRange(int _value)
	{
		mMsdfRange = _value;
	}

#endif // MYGUI_USE_FREETYPE

} // namespace MyGUI
