feat(system): Load Uniscribe at runtime

Author: OmarAglan

Core/Libraries/Source/WWVegas/WWLib/CMakeLists.txt

@@ -162,6 +162,8 @@ if(WIN32)
         rcfile.h
         registry.cpp
         registry.h
+        Usp10Loader.cpp
+        Usp10Loader.h
         verchk.cpp
         verchk.h
         WWCOMUtil.cpp

Core/Libraries/Source/WWVegas/WWLib/Usp10Loader.cpp

@@ -0,0 +1,103 @@
+/*
+**	Command & Conquer Generals Zero Hour(tm)
+**	Copyright 2026 TheSuperHackers
+**
+**	This program is free software: you can redistribute it and/or modify
+**	it under the terms of the GNU General Public License as published by
+**	the Free Software Foundation, either version 3 of the License, or
+**	(at your option) any later version.
+**
+**	This program is distributed in the hope that it will be useful,
+**	but WITHOUT ANY WARRANTY; without even the implied warranty of
+**	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+**	GNU General Public License for more details.
+**
+**	You should have received a copy of the GNU General Public License
+**	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "Usp10Loader.h"
+
+
+CriticalSectionClass Usp10Loader::CriticalSection;
+HMODULE Usp10Loader::Module = HMODULE(nullptr);
+bool Usp10Loader::LoadAttempted = false;
+Usp10Loader::ScriptIsComplex_t Usp10Loader::ScriptIsComplexPtr = nullptr;
+Usp10Loader::ScriptStringAnalyse_t Usp10Loader::ScriptStringAnalysePtr = nullptr;
+Usp10Loader::ScriptStringFree_t Usp10Loader::ScriptStringFreePtr = nullptr;
+Usp10Loader::ScriptString_pSize_t Usp10Loader::ScriptString_pSizePtr = nullptr;
+Usp10Loader::ScriptStringOut_t Usp10Loader::ScriptStringOutPtr = nullptr;
+
+
+bool Usp10Loader::load()
+{
+	CriticalSectionClass::LockClass lock(CriticalSection);
+
+	if (LoadAttempted) {
+		return Module != HMODULE(nullptr);
+	}
+	LoadAttempted = true;
+
+	char dll_path[MAX_PATH];
+	const char dll_name[] = "\\usp10.dll";
+	const UINT path_length = ::GetSystemDirectoryA(dll_path, ARRAY_SIZE(dll_path));
+	if (path_length == 0 || path_length + ARRAY_SIZE(dll_name) > ARRAY_SIZE(dll_path)) {
+		return false;
+	}
+	strcpy(dll_path + path_length, dll_name);
+
+	Module = ::LoadLibraryA(dll_path);
+	if (Module == HMODULE(nullptr)) {
+		return false;
+	}
+
+	ScriptIsComplexPtr = reinterpret_cast<ScriptIsComplex_t>(::GetProcAddress(Module, "ScriptIsComplex"));
+	ScriptStringAnalysePtr = reinterpret_cast<ScriptStringAnalyse_t>(::GetProcAddress(Module, "ScriptStringAnalyse"));
+	ScriptStringFreePtr = reinterpret_cast<ScriptStringFree_t>(::GetProcAddress(Module, "ScriptStringFree"));
+	ScriptString_pSizePtr = reinterpret_cast<ScriptString_pSize_t>(::GetProcAddress(Module, "ScriptString_pSize"));
+	ScriptStringOutPtr = reinterpret_cast<ScriptStringOut_t>(::GetProcAddress(Module, "ScriptStringOut"));
+
+	if (ScriptIsComplexPtr == nullptr || ScriptStringAnalysePtr == nullptr || ScriptStringFreePtr == nullptr ||
+		ScriptString_pSizePtr == nullptr || ScriptStringOutPtr == nullptr)
+	{
+		::FreeLibrary(Module);
+		Module = HMODULE(nullptr);
+		return false;
+	}
+
+	return true;
+}
+
+
+HRESULT Usp10Loader::ScriptIsComplex(const WCHAR *text, int text_length, DWORD flags)
+{
+	return load() ? ScriptIsComplexPtr(text, text_length, flags) : E_FAIL;
+}
+
+
+HRESULT Usp10Loader::ScriptStringAnalyse(HDC dc, const void *text, int text_length, int glyph_count,
+	int charset, DWORD flags, int required_width, ScriptControl *control, ScriptState *state,
+	const int *spacing, ScriptTabDefinition *tabs, const BYTE *character_classes, ScriptStringAnalysis *analysis)
+{
+	return load() ? ScriptStringAnalysePtr(dc, text, text_length, glyph_count, charset, flags, required_width,
+		control, state, spacing, tabs, character_classes, analysis) : E_FAIL;
+}
+
+
+HRESULT Usp10Loader::ScriptStringFree(ScriptStringAnalysis *analysis)
+{
+	return load() ? ScriptStringFreePtr(analysis) : E_FAIL;
+}
+
+
+const SIZE *Usp10Loader::ScriptString_pSize(ScriptStringAnalysis analysis)
+{
+	return load() ? ScriptString_pSizePtr(analysis) : nullptr;
+}
+
+
+HRESULT Usp10Loader::ScriptStringOut(ScriptStringAnalysis analysis, int x, int y, UINT options,
+	const RECT *rect, int minimum_selection, int maximum_selection, BOOL disabled)
+{
+	return load() ? ScriptStringOutPtr(analysis, x, y, options, rect, minimum_selection, maximum_selection, disabled) : E_FAIL;
+}

Core/Libraries/Source/WWVegas/WWLib/Usp10Loader.h

@@ -0,0 +1,73 @@
+/*
+**	Command & Conquer Generals Zero Hour(tm)
+**	Copyright 2026 TheSuperHackers
+**
+**	This program is free software: you can redistribute it and/or modify
+**	it under the terms of the GNU General Public License as published by
+**	the Free Software Foundation, either version 3 of the License, or
+**	(at your option) any later version.
+**
+**	This program is distributed in the hope that it will be useful,
+**	but WITHOUT ANY WARRANTY; without even the implied warranty of
+**	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+**	GNU General Public License for more details.
+**
+**	You should have received a copy of the GNU General Public License
+**	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#include "mutex.h"
+#include "win.h"
+
+
+// This static class loads usp10.dll on first use and keeps it loaded for the process lifetime.
+
+class Usp10Loader
+{
+public:
+
+	typedef void *ScriptStringAnalysis;
+	struct ScriptControl;
+	struct ScriptState;
+	struct ScriptTabDefinition;
+
+	enum
+	{
+		SIC_COMPLEX = 0x00000001,
+		SSA_FALLBACK = 0x00000020,
+		SSA_GLYPHS = 0x00000080,
+		SSA_RTL = 0x00000100,
+	};
+
+	static HRESULT ScriptIsComplex(const WCHAR *text, int text_length, DWORD flags);
+	static HRESULT ScriptStringAnalyse(HDC dc, const void *text, int text_length, int glyph_count,
+		int charset, DWORD flags, int required_width, ScriptControl *control, ScriptState *state,
+		const int *spacing, ScriptTabDefinition *tabs, const BYTE *character_classes,
+		ScriptStringAnalysis *analysis);
+	static HRESULT ScriptStringFree(ScriptStringAnalysis *analysis);
+	static const SIZE *ScriptString_pSize(ScriptStringAnalysis analysis);
+	static HRESULT ScriptStringOut(ScriptStringAnalysis analysis, int x, int y, UINT options,
+		const RECT *rect, int minimum_selection, int maximum_selection, BOOL disabled);
+
+private:
+
+	static bool load();
+
+	typedef HRESULT (WINAPI *ScriptIsComplex_t)(const WCHAR *, int, DWORD);
+	typedef HRESULT (WINAPI *ScriptStringAnalyse_t)(HDC, const void *, int, int, int, DWORD, int,
+		ScriptControl *, ScriptState *, const int *, ScriptTabDefinition *, const BYTE *, ScriptStringAnalysis *);
+	typedef HRESULT (WINAPI *ScriptStringFree_t)(ScriptStringAnalysis *);
+	typedef const SIZE *(WINAPI *ScriptString_pSize_t)(ScriptStringAnalysis);
+	typedef HRESULT (WINAPI *ScriptStringOut_t)(ScriptStringAnalysis, int, int, UINT, const RECT *, int, int, BOOL);
+
+	static CriticalSectionClass CriticalSection;
+	static HMODULE Module;
+	static bool LoadAttempted;
+	static ScriptIsComplex_t ScriptIsComplexPtr;
+	static ScriptStringAnalyse_t ScriptStringAnalysePtr;
+	static ScriptStringFree_t ScriptStringFreePtr;
+	static ScriptString_pSize_t ScriptString_pSizePtr;
+	static ScriptStringOut_t ScriptStringOutPtr;
+};