feat: support localization (#309)

.github/workflows/build.yaml

@@ -18,6 +18,11 @@ jobs:
           with:
             submodules: recursive
 
+        - uses: actions/setup-python@v5
+          with:
+            python-version: "3.13"
+            cache: "pip"
+
         - uses: ilammy/[email protected]
 
         - uses: lukka/[email protected]

.gitignore

@@ -2,6 +2,8 @@ build/
 bin/
 dist/
 .vs*/
+.idea/
 CMakeUserPresets.json
 shadertoolsconfig.json
-.vscode
+.vscode
+fonts/

CMakeLists.txt

@@ -201,7 +201,7 @@ if(AUTO_PLUGIN_DEPLOYMENT)
 			copy_shaders.stamp
 			${DEPLOY_TARGET_HASHES}
 	)
-	
+
 	if(NOT DEFINED ENV{CommunityShadersOutputDir})
 		message("When using AUTO_PLUGIN_DEPLOYMENT option, you need to set environment variable 'CommunityShadersOutputDir'")
 	endif()
@@ -265,3 +265,34 @@ if(AIO_ZIP_TO_DIST)
 		WORKING_DIRECTORY ${AIO_DIR}
 	)
 endif()
+
+# #######################################################################################################################
+# # Generate font subset when translations updated
+# #######################################################################################################################
+
+find_package(Python3 COMPONENTS Interpreter)
+
+if (Python3_Interpreter_FOUND)
+	set(SCRIPT "${CMAKE_SOURCE_DIR}/subset_font.py" CACHE STRING "Path to the Python script")
+	set(ORIGINAL_FONT "https://github.com/adobe-fonts/source-han-sans/raw/release/Variable/OTC/SourceHanSans-VF.ttf.ttc" CACHE STRING "Original font file URL or path")
+	set(SUBSET_FONT "${CMAKE_SOURCE_DIR}/package/Interface/CommunityShaders/Fonts/CommunityShaders.ttf" CACHE STRING "Output subset font file path")
+	set(TRANSLATIONS_DIR "${CMAKE_SOURCE_DIR}/package/Interface/Translations" CACHE STRING "Translations directory")
+
+	file(GLOB_RECURSE TRANSLATIONS CONFIGURE_DEPENDS "${TRANSLATIONS_DIR}/*")
+
+	add_custom_command(
+		OUTPUT "${SUBSET_FONT}"
+		COMMAND Python3::Interpreter "${SCRIPT}"
+		--input "${ORIGINAL_FONT}"
+		--output "${SUBSET_FONT}"
+		--text_dir "${TRANSLATIONS_DIR}"
+		DEPENDS ${TRANSLATIONS}
+		COMMENT "Generating subset font based on updated translations."
+		VERBATIM
+	)
+
+	add_custom_target(GenSubsetFont ALL DEPENDS "${SUBSET_FONT}")
+	add_dependencies(${PROJECT_NAME} GenSubsetFont)
+else()
+	message(WARNING "Python3 not found: Skipping subset font generation logic.")
+endif()

src/Menu.h

@@ -164,7 +164,7 @@ class Menu
 	bool inTestMode = false;       // Whether we're in test mode
 	bool usingTestConfig = false;  // Whether we're using the test config
 
-	std::chrono::steady_clock::time_point lastTestSwitch = high_resolution_clock::now();  // Time of last test switch
+	steady_clock::time_point lastTestSwitch = high_resolution_clock::now();  // Time of last test switch
 
 	Menu() = default;
 	void SetupImGuiStyle() const;

src/Util.h

@@ -5,5 +5,6 @@
 #include "Utils/Game.h"
 #include "Utils/GameSetting.h"
 #include "Utils/Serialize.h"
+#include "Utils/Translate.h"
 #include "Utils/UI.h"
 #include "Utils/WinApi.h"

src/Utils/Translate.cpp

@@ -0,0 +1,17 @@
+#include "Translate.h"
+
+#include "SKSE/Translation.h"
+
+namespace Util
+{
+	std::string Translate(const std::string& key)
+	{
+		std::string buffer;
+
+		if (SKSE::Translation::Translate(key, buffer)) {
+			return buffer;
+		}
+
+		return key;
+	}
+}

src/Utils/Translate.h

@@ -0,0 +1,90 @@
+#pragma once
+
+#include <fmt/core.h>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace Util
+{
+	std::string Translate(const std::string& key);
+
+	struct Translatable
+	{
+		std::string_view key;
+
+		template <typename... Args>
+		std::string operator()(Args&&... args) const
+		{
+			auto [keyArgs, otherArgs] = filterArgs(std::forward<Args>(args)...);
+			std::string preprocessedKey = preprocessKey(key, keyArgs);
+			std::string translatedKey = Translate(preprocessedKey);
+			return formatWithArgs(translatedKey, otherArgs);
+		}
+
+		explicit operator std::string() const noexcept
+		{
+			return Translate(std::string(key));
+		}
+
+	private:
+		template <typename... Args>
+		static std::pair<std::vector<std::string_view>, std::vector<std::string>> filterArgs(Args&&... args)
+		{
+			std::vector<std::string_view> keyArgs;
+			std::vector<std::string> otherArgs;
+
+			auto processArg = [&](auto&& arg) {
+				if constexpr (std::is_convertible_v<decltype(arg), std::string_view>) {
+					if (std::string_view argView(arg); argView.starts_with('$'))
+						keyArgs.emplace_back(argView);
+					else
+						otherArgs.emplace_back(argView);
+				} else {
+					otherArgs.emplace_back(fmt::format("{}", arg));
+				}
+			};
+
+			(processArg(std::forward<Args>(args)), ...);
+			return { std::move(keyArgs), std::move(otherArgs) };
+		}
+
+		static std::string preprocessKey(const std::string_view key, const std::vector<std::string_view>& keyArgs)
+		{
+			std::string result(key);
+			size_t pos = 0;
+
+			for (const auto& arg : keyArgs) {
+				if ((pos = result.find("{}", pos)) != std::string::npos) {
+					result.replace(pos, 2, "{" + std::string(arg) + "}");
+					pos += arg.size() + 2;
+				} else
+					break;
+			}
+
+			return result;
+		}
+
+		static std::string formatWithArgs(const std::string& translation, const std::vector<std::string>& args)
+		{
+			std::vector<fmt::format_context::format_arg> formatArgs;
+			for (const auto& arg : args) {
+				formatArgs.push_back(fmt::detail::make_arg<fmt::format_context>(arg));
+			}
+
+			return vformat(translation, fmt::basic_format_args(formatArgs.data(), static_cast<int>(formatArgs.size())));
+		}
+	};
+}
+
+inline Util::Translatable operator"" _i18n(const char* key, std::size_t) noexcept
+{
+	return Util::Translatable{ std::string_view(key) };
+}
+
+inline const char* operator"" _i18n_cs(const char* key, std::size_t) noexcept
+{
+	thread_local std::string translation;
+	translation = Util::Translate(std::string(key));
+	return translation.c_str();
+}

src/XSEPlugin.cpp

@@ -125,6 +125,8 @@ void MessageHandler(SKSE::MessagingInterface::Message* message)
 					shaderCache.WriteDiskCacheInfo();
 				}
 
+				SKSE::Translation::ParseTranslation("CommunityShaders");
+
 				if (!REL::Module::IsVR()) {
 					RE::GetINISetting("bEnableImprovedSnow:Display")->data.b = false;
 					RE::GetINISetting("bIBLFEnable:Display")->data.b = false;

subset_font.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+import argparse
+import subprocess
+import sys
+from pathlib import Path
+from urllib.parse import urlparse
+from urllib.request import urlretrieve
+
+try:
+    from fontTools import subset
+except ImportError:
+    print("fonttools not found. Installing via pip...")
+    subprocess.check_call([sys.executable, "-m", "pip", "install", "fonttools"])
+    from fontTools import subset
+
+def parse_arguments():
+    parser = argparse.ArgumentParser(
+        description="Automate collecting unique characters and generate font subset."
+    )
+    parser.add_argument(
+        "--input",
+        type=str,
+        default="https://github.com/adobe-fonts/source-han-sans/raw/release/Variable/OTC/SourceHanSans-VF.ttf.ttc",
+        help="Path or URL to the original font file (e.g., C:/Windows/Fonts/msyh.ttc)."
+    )
+    parser.add_argument(
+        "--output",
+        type=str,
+        default="package/Interface/CommunityShaders/Fonts/CommunityShaders.ttf",
+        help="Path for the output subset font file (e.g., SubsetFont.ttf)."
+    )
+    parser.add_argument(
+        "--text_dir",
+        type=str,
+        default="package/Interface/Translations",
+        help="Directory to scan for translated files."
+    )
+    parser.add_argument(
+        "--font_number",
+        type=int,
+        default=0,
+        help="Font number of the font file (default: 0)."
+    )
+    return parser.parse_args()
+
+def is_url(path):
+    try:
+        result = urlparse(path)
+        return all([result.scheme, result.netloc])
+    except ValueError:
+        return False
+
+def get_cache_dir():
+    cache_path = Path.cwd() / "fonts"
+    cache_path.mkdir(parents=True, exist_ok=True)
+    return cache_path
+
+def download_font(url):
+    download_path = get_cache_dir() / Path(url).name
+    if not download_path.is_file():
+        print(f"Downloading font from '{url}' to '{download_path}'...")
+        try:
+            urlretrieve(url, download_path)
+        except Exception as e:
+            sys.exit(f"Error downloading font: {e}")
+    return str(download_path)
+
+def collect_unique_chars(input_dir, extension=".txt"):
+    unique_chars = set()
+    for file in Path(input_dir).rglob(f"*{extension}"):
+        try:
+            with file.open('r', encoding='utf-16-le', errors='ignore') as f:
+                unique_chars.update(c for c in f.read() if c.isprintable())
+        except Exception as e:
+            print(f"Error reading '{file}': {e}", file=sys.stderr)
+    return unique_chars
+
+def subset_font(original_path, subset_path, text, font_number):
+    try:
+        options = subset.Options(font_number = font_number)
+        subsetter = subset.Subsetter(options=options)
+        subsetter.populate(text=text)
+
+        with subset.load_font(str(original_path), options) as font:
+            subsetter.subset(font)
+            subset.save_font(font, str(subset_path), options)
+        print(f"Subset font saved to '{subset_path}'.")
+    except Exception as e:
+        sys.exit(f"Error during font subsetting: {e}")
+
+def main():
+    args = parse_arguments()
+
+    original_font = download_font(args.input) if is_url(args.input) else args.input
+    if not Path(original_font).is_file():
+        sys.exit(f"Error: Font file '{original_font}' does not exist.")
+
+    unique_chars = collect_unique_chars(args.text_dir)
+    if not unique_chars:
+        sys.exit("No characters found. Exiting.")
+
+    basic_latin = {chr(c) for c in range(0x0020, 0x0100)}
+    combined_chars = unique_chars | basic_latin
+
+    print(f"Total characters to include in subset: {len(combined_chars)}.")
+
+    subset_font(original_font, args.output, ''.join(combined_chars), args.font_number)
+
+if __name__ == "__main__":
+    main()