Proposal ITextEngine abstraction + optional FontStashSharp backend

[xcasadio]

Hi! Before opening a PR I'd like to get your feedback on the approach.

What is ITextEngine?

Currently all text measurement and rendering in MGUI is hard-coded against MonoGame's SpriteFont (via FontManager / FontSet). The idea is to introduce a small interface that abstracts the three operations the UI needs from a font backend:

ResolvedFont ResolveFont(FontSpec spec);           // family + size + style → opaque handle
Vector2      MeasureText(ResolvedFont, string);    // layout
void         DrawText(SpriteBatch, ResolvedFont, string, ...); // rendering

MGDesktop would gain a TextEngine property defaulting to a SpriteFontTextEngine that wraps the existing FontManager — zero breaking change, all existing behavior remains bit-for-bit identical. Individual elements can override it via TextEngineOverride.

SpriteFont vs FontStashSharp

MonoGame SpriteFont

• Pre-baked at build time via the Content Pipeline (.spritefont → .xnb)
• One texture atlas per size, every size must be declared upfront
• Limited to characters declared in the .spritefont file
• Not possible to add characters or sizes after build
• Built into MonoGame, no extra package

FontStashSharp

• Runtime-loaded from any .ttf / .otf file
• Any size on demand; glyphs are rasterized and cached at runtime
• Full Unicode range; missing glyphs fall back automatically
• Fully dynamic; new fonts can be loaded at runtime
• Separate NuGet: [FontStashSharp]

Scope of the PR

• ITextEngine interface + ResolvedFont / FontSpec types → MGUI.Shared
• SpriteFontTextEngine (wraps existing FontManager) → MGUI.Shared, default implementation, no behavior change
• FontStashSharpTextEngine → new optional project MGUI.FontStashSharp, never referenced by MGUI.Core, so projects that don't need it carry zero extra dependency

Would you be open to this? Happy to discuss scope or adjust the approach if needed.

[Videogamers0]

Off the top of my head, all of the text drawing is funneled through a couple functions in MGUI.Shared.Rendering.DrawTransaction (DrawText and DrawSpriteFontText both call SpriteBatch.DrawString), so that's probably easy enough to abstract out. But measuring text is a bit messier. I think that's done in DrawTransaction mostly but also in implementations of MGUI.Core.UI.Text.ITextMeasurer interface. MGTextBlock (which implements ITextMeasurer) has some strange logic for it:

MGUI/MGUI.Core/UI/MGTextBlock.cs

Lines 593 to 653 in 882ce4d

	public Vector2 MeasureText(string Text, bool IsBold, bool IsItalic, bool IgnoreFirstGlyphNegativeLeftSideBearing)
	{
	if (string.IsNullOrEmpty(Text))
	return Vector2.Zero;
	SpriteFont SF = GetFont(IsBold, IsItalic, out Dictionary<char, SpriteFont.Glyph> Glyphs);
	#if true
	// Referenced SpriteFont.MeasureString source code from:
	// https://github.com/MonoGame/MonoGame/blob/develop/MonoGame.Framework/Graphics/SpriteFont.cs
	float Width = 0;
	float Height = SF.LineSpacing;
	float CurrentXOffset = 0;
	#pragma warning disable CS0219 // Variable is assigned but its value is never used
	bool IsFirstCharacter = true;
	#pragma warning restore CS0219 // Variable is assigned but its value is never used
	if (SF.Spacing != 0)
	throw new NotImplementedException($"{nameof(MGTextBlock)}.{nameof(MeasureText)} currently does not handle {nameof(SpriteFont)}s with a non-zero Spacing.");
	foreach (char c in Text)
	{
	if (!Glyphs.TryGetValue(c, out SpriteFont.Glyph Glyph))
	Glyph = Glyphs[SF.DefaultCharacter.Value];
	#if NEVER
	if (IsFirstCharacter)
	IsFirstCharacter = false;
	else
	CurrentXOffset += SF.Spacing;
	if (IgnoreFirstGlyphNegativeLeftSideBearing)
	{
	CurrentXOffset += Math.Max(Glyph.LeftSideBearing, 0);
	IgnoreFirstGlyphNegativeLeftSideBearing = false;
	}
	else
	CurrentXOffset += Glyph.LeftSideBearing;
	CurrentXOffset += Glyph.Width;
	Width = Math.Max(Width, CurrentXOffset + Math.Max(Glyph.RightSideBearing, 0));
	CurrentXOffset += Glyph.RightSideBearing;
	Height = Math.Max(Height, Glyph.Cropping.Height);
	#else
	//TODO figure out why MonoGame's SpriteFont.cs uses Math.Max when adding the left/right bearings, then fix this logic accordingly
	CurrentXOffset += Glyph.WidthIncludingBearings;
	Width += Glyph.WidthIncludingBearings;
	Height = Math.Max(Height, Glyph.Cropping.Height);
	#endif
	}
	return new Vector2(Width, FontHeight) * FontScale;
	#else
	// The problem with this logic is that it doesn't always result in the same total width when measuring a string versus measuring the sum of its substrings
	// EX: [Measure("HelloWorld").Width] isn't always equivalent to [Measure("Hello").Width + Measure("World").Width]
	// Which can cause a ton of issues in MGTextLine.ParseRuns(...)
	return new Vector2(SF.MeasureString(Text).X, FontHeight) * FontScale;
	#endif
	}

I ran into issues where measuring a set of substrings and summing up their measurements wasn't always giving the same width as measuring the whole string at once. That difference caused problems with my text-wrapping logic and logic for parsing text runs out of text with inline formatting. So if you had text like "Hello [color=Red]World", splitting it up into "Hello " and "World" and measuring them both and adding the widths together could give a different resulting than just measuring "Hello World"

[xcasadio]

Thank you for the remark. I’ll consider it and fix this behavior