Free, open-source 3D sculpting for Linux, macOS and Windows: dense meshes, remeshing, painting, built-in AI (image/text to 3D), Send to Unreal, game-ready LODs, Gaussian splats and OpenUSD.
C++ 3d3d-sculptingcppdear-imguidigital-sculptingfbxgame-developmentgaussian-splattinggltfimage-to-3dmcpopenglopenusdsculptingtext-to-3dunreal-engine
Reapply "Typed CJK, Japanese, Korean and emoji names draw with the OS fonts instead of "?" (re-land of 2cd26a36, taken out of 0.11.10 in fa774d60)"
islandmedb9977452e0b9
diff --git a/CMakeLists.txt b/CMakeLists.txtindex a97cbc20..2ab07ec5 100644--- a/CMakeLists.txt+++ b/CMakeLists.txt@@ -400,6 +400,7 @@ if(SCULPTFORGE_BUILD_APP)src/app/UiTest.cppsrc/app/UiServe.cppsrc/app/Ui.cpp+ src/app/UserGlyphs.cppsrc/app/Shell.cppsrc/app/Palettes.cppsrc/app/Theme.cppdiff --git a/changes/fix-cjk-user-text-font.md b/changes/fix-cjk-user-text-font.mdnew file mode 100644index 00000000..4cd4e75f--- /dev/null+++ b/changes/fix-cjk-user-text-font.md@@ -0,0 +1,21 @@+---+whats_new: Names you type in Chinese, Japanese or Korean (Parts, folders, layers, brush sets, files, Library items) draw with your system's fonts instead of **?**, in any interface language.+fixed: Text people type (Part, folder, layer and brush-set names, file names, Library items, pasted text) with a+ character outside the bundled fonts drew as "?": the Chinese fonts carry only the interface's own characters.+ Such a character is now taken from the system's fonts the first time it is drawn (Windows: Microsoft YaHei,+ JhengHei, Yu Gothic, Malgun Gothic; macOS: PingFang, Hiragino, Apple SD Gothic Neo; Linux: fontconfig, e.g. Noto+ Sans CJK), including characters past U+FFFF such as 𠀋. Nothing is loaded while no such text is shown, and the+ interface uses about 15 MB less memory (the fonts are no longer copied per size). Shortened names (the title bar)+ no longer end in a broken character when cut in Chinese.+testers:+ - Windows, English interface: rename a Part to 鬱龘𠀋 (or any Japanese / Korean name): it draws, no "?"; same at 150% / 200% UI scale.+ - Windows, Preferences > Interface > 简体中文: the same name still draws; the menus look as before.+ - Linux with noto-fonts-cjk: the same.+---+Mechanism: cmake/Dependencies.cmake builds imgui_draw.cpp from a copy whose ImFont::FindGlyph calls a hook on a+missing glyph and AddFont no longer copies caller-owned font data per size (fails the configure if a new ImGui+changes either); IMGUI_USE_WCHAR32 for characters past the BMP;+src/app/UserGlyphs.cpp looks them up between frames and the atlas is rebuilt with them merged.+Test: tests/ui/user_text_glyphs.sfui (glyphs_missing / glyphs_merged; test font tests/data/fonts/cjk-fallback-test.otf).+Measured (laptop, load ~4, offscreen UI test, 5 runs): no CJK text 0.31 s / 170 MB vs main 0.32 s / 185 MB; with a+CJK name and the system's Noto Sans CJK (19 MB) +19 MB and ~0.2 s once, at the first such frame.diff --git a/cmake/Dependencies.cmake b/cmake/Dependencies.cmakeindex fbd8af2e..1baabf47 100644--- a/cmake/Dependencies.cmake+++ b/cmake/Dependencies.cmake@@ -34,9 +34,54 @@ endif()sf_fetch_declare(imgui DOWNLOAD_EXTRACT_TIMESTAMP TRUE)FetchContent_MakeAvailable(imgui)+# imgui_draw.cpp is built from a copy with two changes for text people type (src/app/UserGlyphs.cpp), which falls back+# to the system's fonts: ImFont::FindGlyph reports a missing glyph (GImFontMissingGlyph), and AddFont keeps a font+# passed with FontDataOwnedByAtlas = false where it is instead of copying it per font size (1.91.9 copies: a 19 MB+# system font merged into nine sizes cost 190 MB; every font the app adds stays alive while the atlas does). The+# fetched or packaged sources are left as they are; an ImGui whose code differs stops the configure here.+file(READ ${imgui_SOURCE_DIR}/imgui_draw.cpp SF_IMGUI_DRAW)+function(sf_imgui_patch from to)+ string(FIND "${SF_IMGUI_DRAW}" "${from}" at)+ if(at EQUAL -1)+ message(FATAL_ERROR "imgui_draw.cpp changed; update its patches in cmake/Dependencies.cmake:\n${from}")+ endif()+ string(REPLACE "${from}" "${to}" patched "${SF_IMGUI_DRAW}")+ set(SF_IMGUI_DRAW "${patched}" PARENT_SCOPE)+endfunction()+sf_imgui_patch("ImFontGlyph* ImFont::FindGlyph(ImWchar c)+{+ if (c >= (size_t)IndexLookup.Size)+ return FallbackGlyph;+ const ImU16 i = IndexLookup.Data[c];+ if (i == (ImU16)-1)+ return FallbackGlyph;+ return &Glyphs.Data[i];+}" "void (*GImFontMissingGlyph)(ImFont* font, ImWchar c) = NULL; // SculptForge (cmake/Dependencies.cmake)+ImFontGlyph* ImFont::FindGlyph(ImWchar c)+{+ const ImU16 i = c < (size_t)IndexLookup.Size ? IndexLookup.Data[c] : (ImU16)-1;+ if (i == (ImU16)-1)+ {+ if (GImFontMissingGlyph)+ GImFontMissingGlyph(this, c);+ return FallbackGlyph;+ }+ return &Glyphs.Data[i];+}")+sf_imgui_patch(" if (!new_font_cfg.FontDataOwnedByAtlas)+ {+ new_font_cfg.FontData = IM_ALLOC(new_font_cfg.FontDataSize);+ new_font_cfg.FontDataOwnedByAtlas = true;+ memcpy(new_font_cfg.FontData, font_cfg->FontData, (size_t)new_font_cfg.FontDataSize);+ }+" " // SculptForge: FontDataOwnedByAtlas = false data is the caller's, alive while the atlas is (no copy).+")+file(WRITE ${CMAKE_BINARY_DIR}/imgui_hooked/imgui_draw.cpp.new "${SF_IMGUI_DRAW}")+configure_file(${CMAKE_BINARY_DIR}/imgui_hooked/imgui_draw.cpp.new ${CMAKE_BINARY_DIR}/imgui_hooked/imgui_draw.cpp COPYONLY)+add_library(imgui STATIC${imgui_SOURCE_DIR}/imgui.cpp- ${imgui_SOURCE_DIR}/imgui_draw.cpp+ ${CMAKE_BINARY_DIR}/imgui_hooked/imgui_draw.cpp${imgui_SOURCE_DIR}/imgui_tables.cpp${imgui_SOURCE_DIR}/imgui_widgets.cpp${imgui_SOURCE_DIR}/backends/imgui_impl_sdl3.cpp@@ -44,4 +89,6 @@ add_library(imgui STATICtarget_include_directories(imgui PUBLIC ${imgui_SOURCE_DIR} ${imgui_SOURCE_DIR}/backends)# Item hooks used by the scripted demo recorder (src/app/Demo.cpp); inert unless enabled at runtime.target_compile_definitions(imgui PUBLIC IMGUI_ENABLE_TEST_ENGINE)+# Characters past U+FFFF (CJK Extension B and up, e.g. 𠀋 in a Part's name) as themselves, not U+FFFD.+target_compile_definitions(imgui PUBLIC IMGUI_USE_WCHAR32)target_link_libraries(imgui PUBLIC SDL3::SDL3 ${CMAKE_DL_LIBS})diff --git a/src/app/App.cpp b/src/app/App.cppindex ae831a00..765f9f38 100644--- a/src/app/App.cpp+++ b/src/app/App.cpp@@ -29,6 +29,7 @@#include "app/Shell.h"#include "app/Theme.h"#include "app/Ui.h"+#include "app/UserGlyphs.h"#include "app/UiServe.h"#include "app/UserData.h"@@ -509,7 +510,7 @@ int App::runUiTest(int w, int h, int fps) {const bool tracing = perftrace::on();if (tracing) tracePhase[0] = tracePhase[1] = tracePhase[2] = double(SDL_GetTicksNS()) * 1e-6;Demo::beginFrame();- if (uiScaleDirty_) applyUiScale(); // (Preferences, a display-scale change: #87)+ if (uiScaleDirty_ || glyphs::pending()) applyUiScale(); // (Preferences, a display-scale change: #87; typed text's glyphs)lap(frameMs[0]);ImGui_ImplOpenGL3_NewFrame();ImGui_ImplSDL3_NewFrame();@@ -527,6 +528,8 @@ int App::runUiTest(int w, int h, int fps) {ImGui::LogFinish();if (video) demo_->drawOverlay(); // the pointer (and the script's fades), as a demo recording draws themImGui::Render();+ glyphs::endFrame();+ if (glyphs::pending()) redrawIn(0.0); // (the next frame draws them)lap(frameMs[2]);if (tracing) tracePhase[3] = double(SDL_GetTicksNS()) * 1e-6;updateMouseCursor();@@ -724,7 +727,7 @@ int App::runRecording() {updateCameraAspect();Demo::beginFrame();- if (uiScaleDirty_) applyUiScale(); // (Preferences, a display-scale change: #87)+ if (uiScaleDirty_ || glyphs::pending()) applyUiScale(); // (Preferences, a display-scale change: #87; typed text's glyphs)ImGui_ImplOpenGL3_NewFrame();ImGui_ImplSDL3_NewFrame();keepImGuiOnPen();@@ -736,6 +739,8 @@ int App::runRecording() {drawUi();demo_->drawOverlay();ImGui::Render();+ glyphs::endFrame();+ if (glyphs::pending()) redrawIn(0.0); // (the next frame draws them)updateMouseCursor();buildGhost(); // (the stroke preview, as run() draws it)@@ -1186,7 +1191,7 @@ int App::run() {touchTick(); // a finger's press that waited for a second finger long enough goes throughhardwareProfileFrameBegin(); // the frame governor's CPU and GPU timing- if (uiScaleDirty_) applyUiScale(); // (Preferences, a display-scale change: #87)+ if (uiScaleDirty_ || glyphs::pending()) applyUiScale(); // (Preferences, a display-scale change: #87; typed text's glyphs)ImGui_ImplOpenGL3_NewFrame();ImGui_ImplSDL3_NewFrame();keepImGuiOnPen();@@ -1194,6 +1199,8 @@ int App::run() {drawUi();drawHardwareProfileOverlay();ImGui::Render();+ glyphs::endFrame();+ if (glyphs::pending()) redrawIn(0.0); // (the next frame draws them)updateMouseCursor();mark();@@ -1342,8 +1349,11 @@ float App::targetUiScale() const {void App::applyUiScale() {uiScaleDirty_ = false;const float scale = targetUiScale();- if (!uiScaleChanged(uiScale_, scale) && fontsLanguage_ == language()) return;- SDL_Log("UI scale %.0f%%", double(scale * 100.0f));+ if (fontsLanguage_ != language()) glyphs::discardPending(); // (its own glyphs come with the new atlas)+ const bool newGlyphs = glyphs::resolve(language() == Language::TraditionalChinese);+ const bool rescale = uiScaleChanged(uiScale_, scale);+ if (!rescale && !newGlyphs && fontsLanguage_ == language()) return;+ if (rescale) SDL_Log("UI scale %.0f%%", double(scale * 100.0f));uiScale_ = scale;ImGui::GetIO().Fonts->Clear();buildUiFonts(scale);@@ -1378,12 +1388,20 @@ void App::mergeCjkFont(float px) {if (simplified) merge(assets::fontCjkSc, assets::fontCjkSc_size, kCjkRanges);merge(assets::fontCjk, assets::fontCjk_size, traditional ? kCjkRanges : kTraditionalName);if (!simplified) merge(assets::fontCjkSc, assets::fontCjkSc_size, kSimplifiedName);+ glyphs::merge(px); // what people typed that the bundled fonts lack, from the system's fonts (UserGlyphs.h)}// Every font the UI uses, rasterised at `scale` for crisp text (Dear ImGui 1.91 has no dynamic font sizes).void App::buildUiFonts(float scale) {ImGuiIO& io = ImGui::GetIO();fontsLanguage_ = language();+ { // the bundled fonts a typed character is looked for in first: the interface's Chinese face, then Inter+ const bool tc = fontsLanguage_ == Language::TraditionalChinese;+ const glyphs::Embedded embedded[] = {{tc ? assets::fontCjk : assets::fontCjkSc, size_t(tc ? assets::fontCjk_size : assets::fontCjkSc_size)},+ {tc ? assets::fontCjkSc : assets::fontCjk, size_t(tc ? assets::fontCjkSc_size : assets::fontCjk_size)},+ {assets::fontRegular, size_t(assets::fontRegular_size)}};+ glyphs::install(embedded, 3, !options_.uiTest.empty());+ }const bool recording = !options_.recordPath.empty() || !options_.uiTest.empty();// Inter (SIL OFL), embedded in the binary. Rasterised at the final size for crisp text.ImFontConfig fontConfig;diff --git a/src/app/Shell.cpp b/src/app/Shell.cppindex a64d8ef5..25724dc1 100644--- a/src/app/Shell.cpp+++ b/src/app/Shell.cpp@@ -230,7 +230,7 @@ void centredText(ImDrawList* dl, ImFont* font, ImVec2 a, ImVec2 b, ImU32 col, coui::CentredGlyph(dl, font ? font : ImGui::GetFont(), a, b, col, text);}-// Text clipped to `width` with an ellipsis.+// Text clipped to `width` with an ellipsis, by whole characters (a Chinese name cut mid-character drew U+FFFD).std::string elide(ImFont* font, const std::string& text, float width) {if (font->CalcTextSizeA(font->FontSize, FLT_MAX, 0.0f, text.c_str()).x <= width) return text;std::string s = text;diff --git a/src/app/UiTest.cpp b/src/app/UiTest.cppindex 21ef0e65..2f7da707 100644--- a/src/app/UiTest.cpp+++ b/src/app/UiTest.cpp@@ -294,7 +294,9 @@// ui_scale PERCENT | auto Preferences > Interface > UI scale (applied live, #87); display_scale PERCENT: the display's// content scale changes, with SDL's event (Windows DPI, another monitor); logical_width W: the display scale that makes the window W logical px wide (#105)// expect_value ui_scale (percent built now), font_height (default font, px), frame_height, panel_width (right-// shelf, px), title_height+// shelf, px), title_height, glyphs_missing (glyphs drawn as "?" in the last frame),+// glyphs_merged (typed characters taken from other fonts: SF_FALLBACK_FONTS, the system's),+// font_atlas_kpx (the font atlas texture, thousands of pixels)// expect_value look (0 Classic, 1 Forge Terminal, 2 Phosphor, 3 Blueprint), shell_layout (0 classic, 1 SculptForge)#include "app/App.h"#include "ai/Http.h"@@ -304,6 +306,7 @@#endif#include "app/Demo.h"#include "app/Ui.h"+#include "app/UserGlyphs.h"#include "core/BrushLibrary.h"#include "core/CloseHoles.h"@@ -1048,6 +1051,12 @@ double Demo::query(const std::string& name, bool& known) const {if (name == "timeline_top") return app_.uiPrefs_.timelineTop ? 1.0 : 0.0;// The style's minimum window height in unscaled px (32): switching looks must not scale it again each time.if (name == "ui_scale") return std::round(double(app_.uiScale_) * 100.0); // percent, as built now (#87)+ if (name == "glyphs_missing") return double(glyphs::missingLastFrame()); // drawn as "?" in the last frame+ if (name == "glyphs_merged") return double(glyphs::mergedCount()); // typed characters taken from other fonts+ if (name == "font_atlas_kpx") { // the font atlas texture, thousands of pixels (its size: memory, upload time)+ const ImFontAtlas* a = ImGui::GetIO().Fonts;+ return std::round(double(a->TexWidth) * double(a->TexHeight) / 1000.0);+ }if (name == "font_height") { // the default UI font's size in pixels, as rasterised in the atlasconst ImGuiIO& io = ImGui::GetIO();const ImFont* f = io.FontDefault ? io.FontDefault : io.Fonts->Fonts.empty() ? nullptr : io.Fonts->Fonts[0];diff --git a/src/app/UserGlyphs.cpp b/src/app/UserGlyphs.cppnew file mode 100644index 00000000..c23385a6--- /dev/null+++ b/src/app/UserGlyphs.cpp@@ -0,0 +1,337 @@+// SculptForge - open source digital sculpting+// SPDX-License-Identifier: GPL-3.0-or-later+#include "app/UserGlyphs.h"++#include <SDL3/SDL.h>++#include <algorithm>+#include <cstdint>+#include <cstdlib>+#include <filesystem>+#include <fstream>+#include <memory>+#include <string>+#include <unordered_set>+#include <vector>++#if defined(__linux__) || defined(__FreeBSD__)+#include <dlfcn.h>+#endif++// stb_truetype (with ImGui) only to ask a font whether it has a character, before the atlas merges it.+#if defined(__GNUC__)+#pragma GCC diagnostic push+#pragma GCC diagnostic ignored "-Wunused-function"+#pragma GCC diagnostic ignored "-Wsign-compare"+#pragma GCC diagnostic ignored "-Wconversion"+#pragma GCC diagnostic ignored "-Wshadow"+#elif defined(_MSC_VER)+#pragma warning(push, 0)+#endif+#define STBTT_STATIC+#define STB_TRUETYPE_IMPLEMENTATION+#include <imstb_truetype.h>+#if defined(__GNUC__)+#pragma GCC diagnostic pop+#elif defined(_MSC_VER)+#pragma warning(pop)+#endif++// Called by ImFont::FindGlyph for a character the font lacks (cmake/Dependencies.cmake adds it to imgui_draw.cpp).+extern void (*GImFontMissingGlyph)(ImFont* font, ImWchar c);++namespace sf::glyphs {+namespace {++constexpr size_t kMaxSeen = 20000; // characters looked up at most (binary junk pasted as a name)+constexpr int kMaxMerged = 2000; // characters merged at most: the atlas is rebuilt per font size with them+constexpr uintmax_t kMaxFileBytes = 160u << 20; // a system font file read whole (PingFang is ~80 MB)++struct Source {+ std::shared_ptr<const std::vector<unsigned char>> file; // a system font file, shared by its faces (embedded: none)+ const unsigned char* data = nullptr;+ size_t size = 0;+ std::string path;+ int index = 0; // the face in a collection (.ttc)+ stbtt_fontinfo info{};+ std::vector<ImWchar> found; // characters this source gives, sorted+ std::vector<ImWchar> ranges; // `found` as ImGui ranges, 0-terminated+ bool has(ImWchar c) const { return stbtt_FindGlyphIndex(&info, int(c)) != 0; }+};++struct Candidate {+ std::string path;+ int index = 0;+};++struct State {+ bool testFonts = false;+ std::vector<std::unique_ptr<Source>> sources; // embedded first, then system fonts in the order they were needed+ std::unordered_set<std::string> opened; // candidate files tried (loaded or not)+ std::unordered_set<ImWchar> seen;+ std::vector<ImWchar> waiting;+ int missingThisFrame = 0, missingLastFrame = 0, merged = 0;+};++State& state() {+ static State s;+ return s;+}++void onMissing(ImFont* font, ImWchar c) {+ if (!font->FallbackGlyph) return; // the atlas build probing the font (a space in the icons-only font)+ if (c < 0x20 || c == 0x7F) return; // control characters (tab, newline) are never drawn+ State& s = state();+ ++s.missingThisFrame;+ if (c == 0xFFFD) return; // broken UTF-8, not a character: fix the text, don't load a font for it+ if (s.seen.size() < kMaxSeen && s.seen.insert(c).second) s.waiting.push_back(c);+}++std::unique_ptr<Source> makeSource(const unsigned char* data, size_t size, int index) {+ auto src = std::make_unique<Source>();+ src->data = data;+ src->size = size;+ src->index = index;+ const int offset = stbtt_GetFontOffsetForIndex(data, index);+ if (offset < 0 || size_t(offset) >= size || !stbtt_InitFont(&src->info, data, offset)) return nullptr;+ return src;+}++Source* loadFile(const Candidate& c) {+ State& s = state();+ const std::string key = c.path + "#" + std::to_string(c.index);+ if (!s.opened.insert(key).second) return nullptr;+ std::shared_ptr<const std::vector<unsigned char>> file;+ for (const auto& src : s.sources) // another face of a collection already read (Noto Sans CJK: SC, then KR)+ if (src->file && src->path == c.path) file = src->file;+ if (!file) {+ const std::filesystem::path path(std::u8string(c.path.begin(), c.path.end()));+ std::error_code ec;+ const uintmax_t bytes = std::filesystem::file_size(path, ec);+ if (ec || bytes < 12 || bytes > kMaxFileBytes) return nullptr;+ auto data = std::make_shared<std::vector<unsigned char>>(static_cast<size_t>(bytes));+ std::ifstream in(path, std::ios::binary);+ if (!in.read(reinterpret_cast<char*>(data->data()), std::streamsize(data->size()))) return nullptr;+ file = std::move(data);+ }+ auto src = makeSource(file->data(), file->size(), c.index);+ if (!src) return nullptr; // (also a colour-bitmap-only font, e.g. Noto Color Emoji: stb_truetype draws outlines)+ src->file = std::move(file);+ src->path = c.path;+ SDL_Log("User text font: %s (face %d)", c.path.c_str(), c.index);+ s.sources.push_back(std::move(src));+ return s.sources.back().get();+}++// Font files that may have the character, best first, for this platform.+std::vector<Candidate> systemCandidates(bool traditional, size_t& tested) {+ std::vector<Candidate> out;+ if (state().testFonts) // UI tests: the same font on every machine, before the system's+ if (const char* list = std::getenv("SF_FALLBACK_FONTS")) {+ const std::string all = list;+ for (size_t a = 0; a <= all.size();) {+ const size_t b = std::min(all.find(';', a), all.size());+ if (b > a) out.push_back({all.substr(a, b - a), 0});+ a = b + 1;+ }+ }+ tested = out.size();+#if defined(_WIN32)+ const char* windir = std::getenv("WINDIR");+ const std::string dir = std::string(windir && *windir ? windir : "C:\\Windows") + "\\Fonts\\";+ const char* zh[] = {"msyh.ttc", "msjh.ttc"}; // Microsoft YaHei (Simplified), JhengHei (Traditional)+ out.push_back({dir + zh[traditional ? 1 : 0]});+ out.push_back({dir + zh[traditional ? 0 : 1]});+ for (const char* f : {"YuGothR.ttc", "meiryo.ttc", "malgun.ttf", "simsun.ttc", "simsunb.ttf", "mingliub.ttc",+ "segoeui.ttf", "seguiemj.ttf", "seguisym.ttf"})+ out.push_back({dir + f}); // Yu Gothic, Meiryo, Malgun Gothic, SimSun (+ Ext-B), Segoe UI (+ Emoji, its outlines, + Symbol)+#elif defined(__APPLE__)+ out.push_back({"/System/Library/Fonts/PingFang.ttc", traditional ? 1 : 0}); // (faces: SC, TC, HK...; older macOS)+ out.push_back({traditional ? "/System/Library/Fonts/STHeiti Light.ttc" : "/System/Library/Fonts/Hiragino Sans GB.ttc"});+ out.push_back({traditional ? "/System/Library/Fonts/Hiragino Sans GB.ttc" : "/System/Library/Fonts/STHeiti Light.ttc"});+ out.push_back({"/System/Library/Fonts/ヒラギノ角ゴシック W3.ttc"});+ out.push_back({"/System/Library/Fonts/AppleSDGothicNeo.ttc"});+ out.push_back({"/System/Library/Fonts/Supplemental/Arial Unicode.ttf"});+ out.push_back({"/Library/Fonts/Arial Unicode.ttf"});+#else+ // fontconfig picks per character (systemMatch); these are the usual packages' files when it isn't there.+ for (const char* f : {"/usr/share/fonts/noto-cjk/NotoSansCJK-Regular.ttc",+ "/usr/share/fonts/opentype/noto/NotoSansCJK-Regular.ttc",+ "/usr/share/fonts/google-noto-cjk/NotoSansCJK-Regular.ttc",+ "/usr/share/fonts/google-noto-sans-cjk-fonts/NotoSansCJK-Regular.ttc",+ "/usr/share/fonts/noto/NotoSansCJK-Regular.ttc",+ "/usr/share/fonts/wenquanyi/wqy-microhei/wqy-microhei.ttc",+ "/usr/share/fonts/truetype/wqy/wqy-microhei.ttc",+ "/usr/share/fonts/truetype/droid/DroidSansFallbackFull.ttf"})+ out.push_back({f, traditional ? 3 : 2}); // Noto Sans CJK's faces: JP KR SC TC HK (others: face 0 below)+ for (size_t i = tested; i < out.size(); ++i)+ if (out[i].path.find("NotoSansCJK") == std::string::npos) out[i].index = 0;+#endif+ return out;+}++#if defined(__linux__) || defined(__FreeBSD__)+// fontconfig (loaded at the first lookup, if the system has it): the file the desktop itself would draw `c` with.+bool systemMatch(ImWchar c, bool traditional, Candidate& out) {+ using Pattern = void;+ using CharSet = void;+ struct Fc {+ Pattern* (*nameParse)(const unsigned char*) = nullptr;+ CharSet* (*charSetCreate)() = nullptr;+ int (*charSetAddChar)(CharSet*, unsigned) = nullptr;+ void (*charSetDestroy)(CharSet*) = nullptr;+ int (*patternAddCharSet)(Pattern*, const char*, const CharSet*) = nullptr;+ int (*configSubstitute)(void*, Pattern*, int) = nullptr;+ void (*defaultSubstitute)(Pattern*) = nullptr;+ Pattern* (*fontMatch)(void*, Pattern*, int*) = nullptr;+ int (*patternGetString)(const Pattern*, const char*, int, unsigned char**) = nullptr;+ int (*patternGetInteger)(const Pattern*, const char*, int, int*) = nullptr;+ void (*patternDestroy)(Pattern*) = nullptr;+ bool ok = false;+ };+ static const Fc fc = [] {+ Fc f;+ void* h = dlopen("libfontconfig.so.1", RTLD_NOW | RTLD_LOCAL);+ if (!h) return f;+ auto sym = [h](auto& fn, const char* name) { fn = reinterpret_cast<std::remove_reference_t<decltype(fn)>>(dlsym(h, name)); };+ sym(f.nameParse, "FcNameParse");+ sym(f.charSetCreate, "FcCharSetCreate");+ sym(f.charSetAddChar, "FcCharSetAddChar");+ sym(f.charSetDestroy, "FcCharSetDestroy");+ sym(f.patternAddCharSet, "FcPatternAddCharSet");+ sym(f.configSubstitute, "FcConfigSubstitute");+ sym(f.defaultSubstitute, "FcDefaultSubstitute");+ sym(f.fontMatch, "FcFontMatch");+ sym(f.patternGetString, "FcPatternGetString");+ sym(f.patternGetInteger, "FcPatternGetInteger");+ sym(f.patternDestroy, "FcPatternDestroy");+ f.ok = f.nameParse && f.charSetCreate && f.charSetAddChar && f.charSetDestroy && f.patternAddCharSet &&+ f.configSubstitute && f.defaultSubstitute && f.fontMatch && f.patternGetString && f.patternGetInteger &&+ f.patternDestroy;+ return f;+ }();+ if (!fc.ok) return false;+ // (color=false: a colour emoji font is bitmaps only, which stb_truetype can't draw; an outline one can)+ const char* name = traditional ? "sans-serif:lang=zh-tw:color=false" : "sans-serif:lang=zh-cn:color=false";+ Pattern* p = fc.nameParse(reinterpret_cast<const unsigned char*>(name));+ if (!p) return false;+ CharSet* cs = fc.charSetCreate();+ fc.charSetAddChar(cs, unsigned(c));+ fc.patternAddCharSet(p, "charset", cs);+ fc.configSubstitute(nullptr, p, 0 /* FcMatchPattern */);+ fc.defaultSubstitute(p);+ int result = 0;+ Pattern* m = fc.fontMatch(nullptr, p, &result);+ bool ok = false;+ unsigned char* file = nullptr;+ int index = 0;+ if (m && fc.patternGetString(m, "file", 0, &file) == 0 && file) {+ fc.patternGetInteger(m, "index", 0, &index);+ out = {reinterpret_cast<const char*>(file), index & 0xFFFF}; // (high bits: a variable font's instance)+ ok = true;+ }+ if (m) fc.patternDestroy(m);+ fc.charSetDestroy(cs);+ fc.patternDestroy(p);+ return ok;+}+#else+bool systemMatch(ImWchar, bool, Candidate&) { return false; }+#endif++void rebuildRanges(Source& src) {+ std::sort(src.found.begin(), src.found.end());+ src.ranges.clear();+ for (ImWchar c : src.found) {+ if (!src.ranges.empty() && src.ranges.back() + 1 == c) src.ranges.back() = c;+ else src.ranges.insert(src.ranges.end(), {c, c});+ }+ src.ranges.push_back(0);+}++} // namespace++void install(const Embedded* embedded, int count, bool testFonts) {+ State& s = state();+ s.testFonts = testFonts;+ if (s.sources.empty())+ for (int i = 0; i < count; ++i)+ if (auto src = makeSource(embedded[i].data, embedded[i].size, 0)) s.sources.push_back(std::move(src));+ GImFontMissingGlyph = onMissing;+}++bool pending() { return !state().waiting.empty(); }++bool resolve(bool traditional) {+ State& s = state();+ if (s.waiting.empty()) return false;+ std::vector<ImWchar> waiting;+ waiting.swap(s.waiting);+ std::vector<Candidate> candidates; // listed at the first character no loaded font has+ size_t next = 0, tested = 0; // candidates tried; the first `tested` are SF_FALLBACK_FONTS+ bool listed = false;+ std::vector<Source*> changed;+ for (ImWchar c : waiting) {+ if (s.merged >= kMaxMerged) break;+ Source* found = nullptr;+ for (auto& src : s.sources)+ if (src->has(c)) {+ found = src.get();+ break;+ }+ if (!found && !listed) {+ candidates = systemCandidates(traditional, tested);+ listed = true;+ }+ auto tryFrom = [&](size_t end) {+ while (!found && next < end)+ if (Source* src = loadFile(candidates[next++]); src && src->has(c)) found = src;+ };+ tryFrom(tested); // (UI tests' fonts)+ Candidate match;+ if (!found && systemMatch(c, traditional, match))+ if (Source* src = loadFile(match); src && src->has(c)) found = src;+ tryFrom(candidates.size());+ if (!found) continue; // no font here has it: it stays "?", looked up once+ found->found.push_back(c);+ ++s.merged;+ if (std::find(changed.begin(), changed.end(), found) == changed.end()) changed.push_back(found);+ }+ for (Source* src : changed) rebuildRanges(*src);+ if (!changed.empty()) {+ std::string list; // (the first few, for the log)+ for (size_t i = 0; i < waiting.size() && i < 8; ++i) { char hex[16]; SDL_snprintf(hex, sizeof hex, " U+%04X", unsigned(waiting[i])); list += hex; }+ SDL_Log("Glyphs looked up:%s%s (%d merged in all)", list.c_str(), waiting.size() > 8 ? " ..." : "", s.merged);+ }+ return !changed.empty();+}++void discardPending() {+ State& s = state();+ for (ImWchar c : s.waiting) s.seen.erase(c);+ s.waiting.clear();+}++void merge(float px) {+ for (auto& src : state().sources) {+ if (src->found.empty()) continue;+ ImFontConfig cfg;+ cfg.MergeMode = true;+ cfg.FontDataOwnedByAtlas = false;+ cfg.OversampleH = 1; // as the bundled Chinese glyphs: dense, and oversampling only grows the atlas+ cfg.FontNo = src->index;+ ImGui::GetIO().Fonts->AddFontFromMemoryTTF(const_cast<unsigned char*>(src->data), int(src->size), px, &cfg,+ src->ranges.data());+ }+}++void endFrame() {+ State& s = state();+ s.missingLastFrame = s.missingThisFrame;+ s.missingThisFrame = 0;+}++int missingLastFrame() { return state().missingLastFrame; }+int mergedCount() { return state().merged; }++} // namespace sf::glyphsdiff --git a/src/app/UserGlyphs.h b/src/app/UserGlyphs.hnew file mode 100644index 00000000..417af444--- /dev/null+++ b/src/app/UserGlyphs.h@@ -0,0 +1,41 @@+// SculptForge - open source digital sculpting+// SPDX-License-Identifier: GPL-3.0-or-later+//+// Glyphs for text people type (Part, folder, layer and brush-set names, file names, Library items, pasted text).+// The bundled fonts hold Latin and the Chinese subsets of our own strings only, so a character outside them drew as+// "?". ImGui reports each glyph it draws as the fallback (the hook cmake/Dependencies.cmake patches into+// ImFont::FindGlyph); between frames resolve() looks those characters up, first in the bundled fonts, then in the+// system's own (Windows: Microsoft YaHei / JhengHei, Yu Gothic, Malgun Gothic; macOS: PingFang, Hiragino, Apple SD+// Gothic; Linux: fontconfig, e.g. Noto Sans CJK), and the atlas is built again with them merged in (merge()).+// Nothing is read or allocated until such a character is drawn.+#pragma once++#include <imgui.h>++#include <cstddef>++namespace sf::glyphs {++struct Embedded {+ const unsigned char* data;+ size_t size;+};++// Hooks ImGui (once). `embedded`: the bundled fonts to look in first, in order; `testFonts`: honour+// SF_FALLBACK_FONTS (font files, ';'-separated, looked in before the system's: UI tests only).+void install(const Embedded* embedded, int count, bool testFonts);+// Characters drawn as "?" that haven't been looked up yet (resolve() before the next frame).+bool pending();+// Looks them up; true when at least one was found and the atlas needs building again. `traditional`: Traditional+// Chinese glyph shapes first (the interface language), otherwise Simplified.+bool resolve(bool traditional);+// Forgets what waits (the frame was drawn with the previous language's atlas): still missing, it comes back.+void discardPending();+// Merges the characters found into the font added just before (MergeMode), at `px`.+void merge(float px);+// Glyphs drawn as "?" in the last finished frame (UI tests: expect_value glyphs_missing) and characters merged.+void endFrame();+int missingLastFrame();+int mergedCount();++} // namespace sf::glyphsdiff --git a/tests/data/CREDITS.md b/tests/data/CREDITS.mdindex 32f48f76..6cf78408 100644--- a/tests/data/CREDITS.md+++ b/tests/data/CREDITS.md@@ -3,6 +3,7 @@| File | Source | Licence ||---|---|---|| `marble-bust.glb` | "Marble Bust 01" by Rico Cilliers, [Poly Haven](https://polyhaven.com/a/marble_bust_01) (the 1k glTF's mesh only, no textures, converted to GLB by SculptForge). A real sculpted human head for the facial shapes tests (tests/ui/face_shapes.sfui, tools/face/shape_grid.py). | [CC0 1.0](https://creativecommons.org/publicdomain/zero/1.0/) |+| `fonts/cjk-fallback-test.otf` | Noto Sans CJK JP (Google / Adobe) cut down to 鬱龘𠀋 for tests/ui/user_text_glyphs.sfui (the fallback font every machine has). | [SIL OFL 1.1](fonts/OFL.txt) |The other files here were made for SculptForge's tests (GPL-3.0-or-later, like the rest of the repository). Thelit-sphere images in tests/ui/data (`Gold.png`, `Rose.png`) are drawn by `tests/ui/data/make_test_litspheres.py`.diff --git a/tests/data/fonts/OFL.txt b/tests/data/fonts/OFL.txtnew file mode 100644index 00000000..7a855b15--- /dev/null+++ b/tests/data/fonts/OFL.txt@@ -0,0 +1,95 @@+Noto Sans CJK TC, cut down to the characters SculptForge uses (tools/i18n/subset_cjk_font.py).+Copyright © 2014-2021 Adobe (http://www.adobe.com/). Noto is a trademark of Google LLC.++This Font Software is licensed under the SIL Open Font License,+Version 1.1.++This license is copied below, and is also available with a FAQ at:+http://scripts.sil.org/OFL++-----------------------------------------------------------+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007+-----------------------------------------------------------++PREAMBLE+The goals of the Open Font License (OFL) are to stimulate worldwide+development of collaborative font projects, to support the font+creation efforts of academic and linguistic communities, and to+provide a free and open framework in which fonts may be shared and+improved in partnership with others.++The OFL allows the licensed fonts to be used, studied, modified and+redistributed freely as long as they are not sold by themselves. The+fonts, including any derivative works, can be bundled, embedded,+redistributed and/or sold with any software provided that any reserved+names are not used by derivative works. The fonts and derivatives,+however, cannot be released under any other type of license. The+requirement for fonts to remain under this license does not apply to+any document created using the fonts or their derivatives.++DEFINITIONS+"Font Software" refers to the set of files released by the Copyright+Holder(s) under this license and clearly marked as such. This may+include source files, build scripts and documentation.++"Reserved Font Name" refers to any names specified as such after the+copyright statement(s).++"Original Version" refers to the collection of Font Software+components as distributed by the Copyright Holder(s).++"Modified Version" refers to any derivative made by adding to,+deleting, or substituting -- in part or in whole -- any of the+components of the Original Version, by changing formats or by porting+the Font Software to a new environment.++"Author" refers to any designer, engineer, programmer, technical+writer or other person who contributed to the Font Software.++PERMISSION & CONDITIONS+Permission is hereby granted, free of charge, to any person obtaining+a copy of the Font Software, to use, study, copy, merge, embed,+modify, redistribute, and sell modified and unmodified copies of the+Font Software, subject to the following conditions:++1) Neither the Font Software nor any of its individual components, in+Original or Modified Versions, may be sold by itself.++2) Original or Modified Versions of the Font Software may be bundled,+redistributed and/or sold with any software, provided that each copy+contains the above copyright notice and this license. These can be+included either as stand-alone text files, human-readable headers or+in the appropriate machine-readable metadata fields within text or+binary files as long as those fields can be easily viewed by the user.++3) No Modified Version of the Font Software may use the Reserved Font+Name(s) unless explicit written permission is granted by the+corresponding Copyright Holder. This restriction only applies to the+primary font name as presented to the users.++4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font+Software shall not be used to promote, endorse or advertise any+Modified Version, except to acknowledge the contribution(s) of the+Copyright Holder(s) and the Author(s) or with their explicit written+permission.++5) The Font Software, modified or unmodified, in part or in whole,+must be distributed entirely under this license, and must not be+distributed under any other license. The requirement for fonts to+remain under this license does not apply to any document created using+the Font Software.++TERMINATION+This license becomes null and void if any of the above conditions are+not met.++DISCLAIMER+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM+OTHER DEALINGS IN THE FONT SOFTWARE.diff --git a/tests/data/fonts/cjk-fallback-test.otf b/tests/data/fonts/cjk-fallback-test.otfnew file mode 100644index 00000000..54f51a2fBinary files /dev/null and b/tests/data/fonts/cjk-fallback-test.otf differdiff --git a/tests/ui/user_text_glyphs.sfui b/tests/ui/user_text_glyphs.sfuinew file mode 100644index 00000000..1508871d--- /dev/null+++ b/tests/ui/user_text_glyphs.sfui@@ -0,0 +1,40 @@+# Text people type (a Part's name here) in characters the bundled fonts lack: 鬱龘 (rare Han) and 𠀋 (U+2000B, past+# the BMP) come from another font instead of drawing as "?" (src/app/UserGlyphs.h). The app takes them from the+# system's fonts; the test gives it a three-character cut of Noto Sans CJK JP so every machine draws the same.+env SF_FALLBACK_FONTS $SCRIPT_DIR/../data/fonts/cjk-fallback-test.otf+run ui_look look=classic layout=classic+run new_sphere subdivisions=2 ; part_rename to=Body+wait 0.1+expect "Parts/Body"+expect_value glyphs_merged == 0 # nothing looked up or loaded while no such text is drawn+expect_value glyphs_missing == 0++run part_rename to=鬱龘𠀋+wait 0.2+expect "Parts/鬱龘𠀋"+expect_value glyphs_merged == 3+expect_value glyphs_missing == 0+shot en-1x++display_scale 200 # HiDPI: the atlas is built again at 2x, with them+wait 0.2+expect_value ui_scale == 200+expect_value glyphs_missing == 0+shot en-hidpi+display_scale 100+wait 0.2++# Simplified Chinese: the interface's own glyphs come from the bundled cut, the name's from the other font.+click "Preferences##palette.preferences"+click "Interface##preferences.interface"+click "简体中文##language.zh-CN"+expect "偏好设置##palette.preferences"+key escape+wait 0.2+expect "Parts/鬱龘𠀋"+expect_value glyphs_missing == 0+shot zh-cn-1x+display_scale 200+wait 0.2+expect_value glyphs_missing == 0+shot zh-cn-hidpi