Enable multi-language font rendering and Unicode text input

Goal:
Allow players to type and display text in any language supported by
Unicode, including Chinese, Japanese, Korean, Thai, Arabic, Korean, Hindi, and more. This
covers all text surfaces: chat editor, chat messages, signs (in-world
and editor), world name/seed, server address/port fields, and all
Iggy Flash UI text fields.

Multi-language support:
Two complementary rendering systems were added to handle Unicode text
across the entire client:

1. Iggy UI (Flash-based text fields): A new UIUnicodeBitmapFont class
   serves Java Minecraft's glyph page PNGs (glyph_00.png-glyph_FF.png)
   through Iggy's bitmap font provider API. Registered as the global
   fallback font with metrics matching the Mojangles bitmap font for
   correct baseline alignment. When the primary bitmap font lacks a
   glyph, it returns IGGY_GLYPH_INVALID and Iggy seamlessly falls back
   to the unicode bitmap font.

2. Legacy C++ Font renderer (chat editor, in-world signs): Revived the
   commented-out unicode glyph page system in Font.cpp. Characters not
   in the bitmap font texture are rendered from glyph page PNGs loaded
   on demand, with proper texture switching mid-string.

3. ChatScreen input: Removed the restrictive acceptableLetters filter
   so all printable Unicode characters are accepted in chat.

Languages now supported for text input and rendering:
- Japanese (Hiragana, Katakana, Kanji)
- Chinese (Simplified and Traditional)
- Korean (Hangul)
- Thai
- Arabic
- Hindi (Devanagari)
- Russian (Cyrillic) - already worked via bitmap font
- Greek - already worked via bitmap font
- Polish, Czech, Turkish (Extended Latin) - already worked via bitmap font
- Armenian, Georgian, and other scripts covered by glyph pages

Security fixes:
- Fixed memset under-initialization of Font::charWidths (zeroed 460
  bytes instead of 460*sizeof(int)=1840 bytes, leaving entries 115+
  uninitialized) - pre-existing bug
- Added bounds checks to all UIUnicodeBitmapFont callbacks to reject
  glyph IDs outside [0, 65535], preventing OOB array access
- Added bounds check in Font::width() section-sign fallback path to
  prevent OOB read on charWidths[] with high codepoints
- Blocked Unicode bidirectional override characters (U+202A-202E,
  U+2066-2069) in chat input to prevent message spoofing

Memory leak fix:
- Fixed SignTileEntity::load allocating wchar_t[256] with new[] on
  every sign load without freeing. Replaced with stack allocation.

Debug logging:
- Added [SIGN] prefixed logging for sign save/update operations
- Added [CHAT] prefixed logging for chat send/receive operations

Files changed:
- UIUnicodeBitmapFont.h/.cpp (new) - Iggy bitmap font for glyph pages
- UIBitmapFont.cpp - Return IGGY_GLYPH_INVALID for unknown chars
- UIFontData.h/.cpp - Added hasGlyph() method
- UIController.h/.cpp - Load and register unicode bitmap fallback font
- UITTFFont.h/.cpp - Added registerAsDefaultFonts parameter
- Font.h/.cpp - Revived unicode glyph page rendering system
- ChatScreen.cpp - Accept all Unicode input, block bidi overrides
- Gui.cpp - Chat display debug logging
- ClientConnection.cpp - Sign update debug logging
- SignTileEntity.cpp - Sign save logging, memory leak fix

Minecraft.Client/Common/UI/UIBitmapFont.cpp

@@ -141,6 +141,9 @@ S32 UIBitmapFont::GetCodepointGlyph(U32 codepoint)
 	// 4J-JEV: Change "right single quotation marks" to apostrophies.
 	if (codepoint == 0x2019) codepoint = 0x27;
 
+	if (!m_cFontData->hasGlyph(codepoint))
+		return IGGY_GLYPH_INVALID;
+
 	return m_cFontData->getGlyphId(codepoint);
 }
 
@@ -253,19 +256,6 @@ rrbool UIBitmapFont::GetGlyphBitmap(S32 glyph,F32 pixel_scale,IggyBitmapCharacte
 	while ( (0.5f + glyphScale) * truePixelScale < pixel_scale)
 		glyphScale++;
 
-	// Debug: log each unique (font, pixel_scale) pair
-	{
-		static std::unordered_set<int> s_loggedScaleKeys;
-		// Encode font pointer + quantized scale into a key to log each combo once
-		int scaleKey = (int)(pixel_scale * 100.0f) ^ (int)(uintptr_t)m_cFontData;
-		if (s_loggedScaleKeys.find(scaleKey) == s_loggedScaleKeys.end() && s_loggedScaleKeys.size() < 50) {
-			s_loggedScaleKeys.insert(scaleKey);
-			float tps = truePixelScale;
-			app.DebugPrintf("[FONT-DBG] GetGlyphBitmap: font=%s glyph=%d pixel_scale=%.3f truePixelScale=%.1f glyphScale=%.0f\n",
-				m_cFontData->getFontName().c_str(), glyph, pixel_scale, tps, glyphScale);
-		}
-	}
-
 	// 4J-JEV: Debug code to check which font sizes are being used.
 #if (!defined _CONTENT_PACKAGE) && (VERBOSE_FONT_OUTPUT > 0)
 

Minecraft.Client/Common/UI/UIController.cpp

@@ -13,6 +13,7 @@
 #include "..\..\EnderDragonRenderer.h"
 #include "..\..\MultiPlayerLocalPlayer.h"
 #include "UIFontData.h"
+#include "UIUnicodeBitmapFont.h"
 #include "UISplitScreenHelpers.h"
 #ifdef _WINDOWS64
 #include "..\..\Windows64\KeyboardMouseInput.h"
@@ -193,6 +194,7 @@ UIController::UIController()
 	m_mcTTFFont = nullptr;
 	m_moj7 = nullptr;
 	m_moj11 = nullptr;
+	m_unicodeBitmapFont = nullptr;
 
 	// 4J-JEV: It's important that these remain the same, unless updateCurrentLanguage is going to be called.
 	m_eCurrentFont = m_eTargetFont = eFont_NotLoaded;
@@ -307,6 +309,14 @@ void UIController::postInit()
 	IggySetAS3ExternalFunctionCallbackUTF16 ( &UIController::ExternalFunctionCallback, this );
 	IggySetTextureSubstitutionCallbacks ( &UIController::TextureSubstitutionCreateCallback , &UIController::TextureSubstitutionDestroyCallback, this );
 
+	// Load a unicode bitmap font as Iggy's global fallback for characters not
+	// covered by the Mojangles bitmap font (CJK, Thai, Arabic, Korean, etc.).
+	// Uses the same glyph page PNGs as the legacy Font class, with matching
+	// Mojangles metrics for correct vertical alignment.
+	m_unicodeBitmapFont = new UIUnicodeBitmapFont("Mojangles_Unicode_Bitmap", SFontData::Mojangles_7);
+	m_unicodeBitmapFont->registerFont();
+	IggyFontSetFallbackFontUTF8("Mojangles_Unicode_Bitmap", -1, IGGY_FONTFLAG_none);
+
 	SetupFont();
 	//
 	loadSkins();

Minecraft.Client/Common/UI/UIController.h

@@ -7,6 +7,7 @@ using namespace std;
 
 class UIAbstractBitmapFont;
 class UIBitmapFont;
+class UIUnicodeBitmapFont;
 class UITTFFont;
 class UIComponent_DebugUIConsole;
 class UIComponent_DebugUIMarketingGuide;
@@ -63,6 +64,7 @@ private:
 	UIAbstractBitmapFont *m_mcBitmapFont;
 	UITTFFont *m_mcTTFFont;
 	UIBitmapFont *m_moj7, *m_moj11;
+	UIUnicodeBitmapFont *m_unicodeBitmapFont;
 
 	std::mt19937 m_randomGenerator;
 	std::uniform_real_distribution<float> m_randomDistribution;

Minecraft.Client/Common/UI/UIFontData.cpp

@@ -335,6 +335,11 @@ bool CFontData::unicodeIsWhitespace(unsigned int unicode)
 	return false;
 }
 
+bool CFontData::hasGlyph(unsigned int unicodepoint)
+{
+	return m_unicodeMap.find(unicodepoint) != m_unicodeMap.end();
+}
+
 void CFontData::moveCursor(unsigned char *&cursor, unsigned int dx, unsigned int dy)
 {
 	cursor += (dy * m_sFontData->m_uiGlyphMapX) + dx;

Minecraft.Client/Common/UI/UIFontData.h

@@ -125,6 +125,9 @@ public:
 	// Returns true if this unicodepoint is whitespace
 	bool				unicodeIsWhitespace(unsigned int unicodepoint);
 
+	// Returns true if this unicodepoint exists in the font's glyph map.
+	bool				hasGlyph(unsigned int unicodepoint);
+
 private:
 
 	// Move a pointer in an image dx pixels right and dy pixels down, wrap around in either dimension leads to unknown behaviour.

Minecraft.Client/Common/UI/UITTFFont.cpp

@@ -4,7 +4,7 @@
 #include "..\..\..\Minecraft.World\File.h"
 #include "UITTFFont.h"
 
-UITTFFont::UITTFFont(const string &name, const string &path, S32 fallbackCharacter) 
+UITTFFont::UITTFFont(const string &name, const string &path, S32 fallbackCharacter, bool registerAsDefaultFonts)
 	: m_strFontName(name)
 {
 	app.DebugPrintf("UITTFFont opening %s\n",path.c_str());
@@ -41,9 +41,12 @@ UITTFFont::UITTFFont(const string &name, const string &path, S32 fallbackCharact
 
 		IggyFontInstallTruetypeFallbackCodepointUTF8( m_strFontName.c_str(), -1, IGGY_FONTFLAG_none, fallbackCharacter );
 
-		// 4J Stu - These are so we can use the default flash controls
-		IggyFontInstallTruetypeUTF8 ( (void *)pbData, IGGY_TTC_INDEX_none, "Times New Roman", -1, IGGY_FONTFLAG_none );
-		IggyFontInstallTruetypeUTF8 ( (void *)pbData, IGGY_TTC_INDEX_none, "Arial", -1, IGGY_FONTFLAG_none );
+		if (registerAsDefaultFonts)
+		{
+			// 4J Stu - These are so we can use the default flash controls
+			IggyFontInstallTruetypeUTF8 ( (void *)pbData, IGGY_TTC_INDEX_none, "Times New Roman", -1, IGGY_FONTFLAG_none );
+			IggyFontInstallTruetypeUTF8 ( (void *)pbData, IGGY_TTC_INDEX_none, "Arial", -1, IGGY_FONTFLAG_none );
+		}
 	}
 }
 

Minecraft.Client/Common/UI/UITTFFont.h

@@ -9,7 +9,7 @@ private:
 	//DWORD dwDataSize;
 
 public:
-	UITTFFont(const string &name, const string &path, S32 fallbackCharacter);
+	UITTFFont(const string &name, const string &path, S32 fallbackCharacter, bool registerAsDefaultFonts = true);
 	~UITTFFont();
 
 	string getFontName();

Minecraft.Client/Common/UI/UIUnicodeBitmapFont.cpp

@@ -0,0 +1,164 @@
+#include "stdafx.h"
+#include "BufferedImage.h"
+#include "UIFontData.h"
+#include "UIUnicodeBitmapFont.h"
+
+UIUnicodeBitmapFont::UIUnicodeBitmapFont(const string &fontname, SFontData &referenceFontData)
+	: UIAbstractBitmapFont(fontname)
+{
+	m_numGlyphs = 65536;
+	m_referenceFontData = &referenceFontData;
+	memset(m_glyphPages, 0, sizeof(m_glyphPages));
+	memset(m_unicodeWidth, 0, sizeof(m_unicodeWidth));
+
+	FILE *f = nullptr;
+	fopen_s(&f, "Common/res/1_2_2/font/glyph_sizes.bin", "rb");
+	if (f)
+	{
+		fread(m_unicodeWidth, 1, 65536, f);
+		fclose(f);
+	}
+}
+
+UIUnicodeBitmapFont::~UIUnicodeBitmapFont()
+{
+	for (int i = 0; i < 256; i++)
+		delete[] m_glyphPages[i];
+}
+
+void UIUnicodeBitmapFont::loadGlyphPage(int page)
+{
+	wchar_t fileName[64];
+	swprintf(fileName, 64, L"/1_2_2/font/glyph_%02X.png", page);
+	BufferedImage bimg(fileName);
+	int *rawData = bimg.getData();
+	if (!rawData) return;
+
+	int size = 256 * 256;
+	m_glyphPages[page] = new unsigned char[size];
+	for (int i = 0; i < size; i++)
+		m_glyphPages[page][i] = (rawData[i] & 0xFF000000) >> 24;
+}
+
+IggyFontMetrics *UIUnicodeBitmapFont::GetFontMetrics(IggyFontMetrics *metrics)
+{
+	metrics->ascent = m_referenceFontData->m_fAscent;
+	metrics->descent = m_referenceFontData->m_fDescent;
+	metrics->average_glyph_width_for_tab_stops = 8.0f;
+	metrics->largest_glyph_bbox_y1 = metrics->descent;
+	return metrics;
+}
+
+S32 UIUnicodeBitmapFont::GetCodepointGlyph(U32 codepoint)
+{
+	if (codepoint < 65536 && m_unicodeWidth[codepoint] != 0)
+		return (S32)codepoint;
+	return IGGY_GLYPH_INVALID;
+}
+
+IggyGlyphMetrics *UIUnicodeBitmapFont::GetGlyphMetrics(S32 glyph, IggyGlyphMetrics *metrics)
+{
+	if (glyph < 0 || glyph >= 65536) { metrics->x0 = metrics->x1 = metrics->advance = metrics->y0 = metrics->y1 = 0; return metrics; }
+	int left = m_unicodeWidth[glyph] >> 4;
+	int right = (m_unicodeWidth[glyph] & 0xF) + 1;
+	float pixelWidth = (right - left) / 2.0f + 1.0f;
+	float advance = pixelWidth * m_referenceFontData->m_fAdvPerPixel;
+
+	metrics->x0 = 0.0f;
+	metrics->x1 = advance;
+	metrics->advance = advance;
+	metrics->y0 = 0.0f;
+	metrics->y1 = 1.0f;
+	return metrics;
+}
+
+rrbool UIUnicodeBitmapFont::IsGlyphEmpty(S32 glyph)
+{
+	if (glyph < 0 || glyph >= 65536) return true;
+	return m_unicodeWidth[glyph] == 0;
+}
+
+F32 UIUnicodeBitmapFont::GetKerningForGlyphPair(S32 first_glyph, S32 second_glyph)
+{
+	return 0.0f;
+}
+
+rrbool UIUnicodeBitmapFont::CanProvideBitmap(S32 glyph, F32 pixel_scale)
+{
+	return glyph >= 0 && glyph < 65536;
+}
+
+rrbool UIUnicodeBitmapFont::GetGlyphBitmap(S32 glyph, F32 pixel_scale, IggyBitmapCharacter *bitmap)
+{
+	if (glyph < 0 || glyph >= 65536) return false;
+	int page = glyph / 256;
+	if (!m_glyphPages[page])
+	{
+		loadGlyphPage(page);
+		if (!m_glyphPages[page]) return false;
+	}
+
+	int cx = (glyph % 16) * 16;
+	int cy = ((glyph & 0xFF) / 16) * 16;
+
+	bitmap->pixels_one_per_byte = m_glyphPages[page] + (cy * 256) + cx;
+	bitmap->width_in_pixels = 16;
+	bitmap->height_in_pixels = 16;
+	bitmap->stride_in_bytes = 256;
+
+	bitmap->top_left_x = 0;
+	bitmap->top_left_y = -static_cast<S32>(16) * m_referenceFontData->m_fAscent;
+
+	bitmap->oversample = 0;
+
+	// Scale parameters: match UIBitmapFont's approach.
+	// truePixelScale = the pixel_scale at which 1 glyph pixel = 1 screen pixel.
+	// For 16px glyphs displayed at the same visual size as Mojangles_7 (8px glyphs with advPerPixel 1/10):
+	// The reference truePixelScale for Mojangles_7 is 1.0f/m_fAdvPerPixel = 10.0f
+	// Since our glyphs are 16px (2x the Mojangles 8px), our truePixelScale is 20.0f
+	float truePixelScale = 2.0f / m_referenceFontData->m_fAdvPerPixel;
+
+#ifdef _WINDOWS64
+	bitmap->pixel_scale_correct = truePixelScale;
+	if (pixel_scale < truePixelScale)
+	{
+		bitmap->pixel_scale_min = 0.0f;
+		bitmap->pixel_scale_max = truePixelScale;
+		bitmap->point_sample = false;
+	}
+	else
+	{
+		bitmap->pixel_scale_min = truePixelScale;
+		bitmap->pixel_scale_max = 99.0f;
+		bitmap->point_sample = true;
+	}
+#else
+	float glyphScale = 1.0f;
+	while ((0.5f + glyphScale) * truePixelScale < pixel_scale)
+		glyphScale++;
+
+	if (glyphScale <= 1 && pixel_scale < truePixelScale)
+	{
+		bitmap->pixel_scale_correct = truePixelScale;
+		bitmap->pixel_scale_min = 0.0f;
+		bitmap->pixel_scale_max = truePixelScale * 1.001f;
+		bitmap->point_sample = false;
+	}
+	else
+	{
+		float actualScale = pixel_scale / glyphScale;
+		bitmap->pixel_scale_correct = actualScale;
+		bitmap->pixel_scale_min = truePixelScale;
+		bitmap->pixel_scale_max = 99.0f;
+		bitmap->point_sample = true;
+	}
+#endif
+
+	bitmap->user_context_for_free = nullptr;
+	return true;
+}
+
+void UIUnicodeBitmapFont::FreeGlyphBitmap(S32 glyph, F32 pixel_scale, IggyBitmapCharacter *bitmap)
+{
+	// Pixel data lives in m_glyphPages -- nothing to free.
+}

Minecraft.Client/Common/UI/UIUnicodeBitmapFont.h

@@ -0,0 +1,27 @@
+#pragma once
+#include "UIBitmapFont.h"
+
+struct SFontData;
+
+class UIUnicodeBitmapFont : public UIAbstractBitmapFont
+{
+private:
+	unsigned char m_unicodeWidth[65536];
+	unsigned char* m_glyphPages[256];
+	SFontData* m_referenceFontData;
+
+	void loadGlyphPage(int page);
+
+public:
+	UIUnicodeBitmapFont(const string &fontname, SFontData &referenceFontData);
+	~UIUnicodeBitmapFont();
+
+	virtual IggyFontMetrics *GetFontMetrics(IggyFontMetrics *metrics);
+	virtual S32 GetCodepointGlyph(U32 codepoint);
+	virtual IggyGlyphMetrics *GetGlyphMetrics(S32 glyph, IggyGlyphMetrics *metrics);
+	virtual rrbool IsGlyphEmpty(S32 glyph);
+	virtual F32 GetKerningForGlyphPair(S32 first_glyph, S32 second_glyph);
+	virtual rrbool CanProvideBitmap(S32 glyph, F32 pixel_scale);
+	virtual rrbool GetGlyphBitmap(S32 glyph, F32 pixel_scale, IggyBitmapCharacter *bitmap);
+	virtual void FreeGlyphBitmap(S32 glyph, F32 pixel_scale, IggyBitmapCharacter *bitmap);
+};