diff --git a/.gitignore b/.gitignore index 0e96f79e..b5d9b573 100644 --- a/.gitignore +++ b/.gitignore @@ -3,6 +3,8 @@ /.idea/ /.vscode/ /run/* +*.jfc +*.jfr /build/ /eclipse/ .classpath @@ -30,6 +32,7 @@ src/main/resources/mixins.*([!.]).json *.bat *.DS_Store !gradlew.bat +!tools/regen_java_flatc.bat .factorypath addon.local.gradle addon.local.gradle.kts @@ -60,3 +63,21 @@ layout.json /gradle-user .claude/ CLAUDE.md + +### Rust layout-engine ### +/layout-engine/target/ +/layout-engine/src/guidenh_layout_generated.rs +/layout-engine/.cargo/ + +### Visual inspection tooling (API keys & python artifacts) ### +.env +.env.local +tools/visual-inspection/.env +__pycache__/ +*.pyc +.venv/ +visualtest/local/ + +# personal agent-ops notes (not project documentation) +visualtest/docs/EXECUTOR-CALIBRATION.md +visualtest/docs/ARCHITECTURE-AUDIT.md diff --git a/build.gradle.kts b/build.gradle.kts index 6e746230..9f15220a 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -8,12 +8,21 @@ minecraft { extraRunJvmArguments.addAll("-Xmx4G", "-Xms512m", "-Dgtnhlib.dumpkeys=true") } +dependencies { + // fastutil is available at MC runtime but not in test scope + testImplementation("it.unimi.dsi:fastutil:8.5.12") +} + tasks.withType().configureEach { options.annotationProcessorPath = configurations.annotationProcessor.get() } tasks.withType().configureEach { useJUnitPlatform() + val nativeLib = System.getProperty("guide.native.lib.path") + if (nativeLib != null) { + jvmArgs("-Dguide.native.lib.path=$nativeLib") + } } tasks.named("shadowJar") { @@ -49,5 +58,87 @@ runConfigs.forEach { (taskName, path) -> doFirst { workingDir.mkdirs() } + // Forward the layout-overlay flag to the client JVM: + // ./gradlew runClient25 -Dguidenh.layoutOverlay=true + providers.systemProperty("guidenh.layoutOverlay").orNull?.let { + jvmArgs("-Dguidenh.layoutOverlay=$it") + } + providers.systemProperty("guidenh.debug.scenerender").orNull?.let { + jvmArgs("-Dguidenh.debug.scenerender=$it") + } + // Forward extra development resource-pack source (visual-test fixture pack): + // ./gradlew runClient25 -Dguidenh.guide.sources=D:/Projects/GuideNH/visualtest/resourcepack + providers.systemProperty("guidenh.guide.sources").orNull?.let { + jvmArgs("-Dguideme.resourcePack.sources=$it") + } + // Forward headless-render driver props to the client JVM: + // ./gradlew runClient25 -Dguidenh.headlessRender=true -Dguidenh.renderpage.guide=guidenh:guidenh -Dguidenh.renderpage.page=guidenh:guidenh/en_us/markdown + providers.systemProperty("guidenh.headlessRender").orNull?.let { + jvmArgs("-Dguidenh.headlessRender=$it") + } + listOf("guide", "page", "md", "width", "out", "lang", "bounds", "overlay", "world", "scale", "allPages", "list", "chrome", "navscroll", "mermaidzoom", "mermaidoffset", "guiscale", "title").forEach { key -> + providers.systemProperty("guidenh.renderpage.$key").orNull?.let { + jvmArgs("-Dguidenh.renderpage.$key=$it") + } + } } } + + +/** Standalone task: build Rust native library. + * Run manually: ./gradlew buildRustNative + * Does NOT wire into the main build pipeline. + * Requires Rust toolchain: https://rustup.rs + */ +/** Resolve the Rust DLL path eagerly (configuration-cache friendly): prefer the + * redirected target dir on E:, fall back to the in-tree target dir. */ +val rustDllPath: String = run { + val eDrive = File("E:/build_out/guide_nh_rust/release/guide_layout_engine.dll") + if (eDrive.exists()) eDrive.absolutePath else "${rootDir}/layout-engine/target/release/guide_layout_engine.dll" +} + +/** Run GlyphRenderTest main class. Requires Rust DLL built first. */ +val runGlyphTest by tasks.registering(JavaExec::class) { + description = "Run GlyphRenderTest visual glyph verification window" + group = "verification" + classpath = sourceSets.test.get().runtimeClasspath + mainClass.set("com.hfstudio.guidenh.guide.layout.GlyphRenderTest") + jvmArgs("-Dguide.native.lib.path=$rustDllPath", "-Dsun.java2d.uiScale=1.0") +} + +/** Headless diagnostic: print glyph pipeline to console. */ +val runGlyphDiag by tasks.registering(JavaExec::class) { + description = "Run GlyphDiag: headless glyph data diagnostic" + group = "verification" + classpath = sourceSets.test.get().runtimeClasspath + mainClass.set("com.hfstudio.guidenh.guide.layout.GlyphDiag") + jvmArgs("-Dguide.native.lib.path=$rustDllPath", "-Dsun.java2d.uiScale=1.0") +} + +/** Headless layout pipeline test bench: synthetic pages → invariants + tree dump. */ +val runLayoutDump by tasks.registering(JavaExec::class) { + description = "Run LayoutPipelineHarness: headless layout pipeline verification" + group = "verification" + classpath = sourceSets.test.get().runtimeClasspath + mainClass.set("com.hfstudio.guidenh.guide.layout.LayoutPipelineHarness") + jvmArgs("-Dguide.native.lib.path=$rustDllPath", "-Dsun.java2d.uiScale=1.0") + setIgnoreExitValue(true) +} + +/** Headless A/B: cosmic renderText vs parley renderTextParley. */ +val runParleySmoke by tasks.registering(JavaExec::class) { + description = "Headless A/B: cosmic renderText vs parley renderTextParley" + group = "verification" + classpath = sourceSets.test.get().runtimeClasspath + mainClass.set("com.hfstudio.guidenh.guide.layout.GlyphRenderTest") + jvmArgs("-Dguide.native.lib.path=$rustDllPath", "-Dsun.java2d.uiScale=1.0") + args("--headless") +} + +val buildRustNative by tasks.registering(Exec::class) { + description = "Build Rust native library (layout-engine/guide_layout_engine.dll)" + group = "build" + workingDir = file("layout-engine") + commandLine("cargo", "build", "--release") + outputs.file("layout-engine/target/release/guide_layout_engine.dll") +} diff --git a/layout-engine/Cargo.lock b/layout-engine/Cargo.lock new file mode 100644 index 00000000..3defb2d0 --- /dev/null +++ b/layout-engine/Cargo.lock @@ -0,0 +1,2035 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "adler2" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa" + +[[package]] +name = "aligned" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee4508988c62edf04abd8d92897fca0c2995d907ce1dfeaf369dac3716a40685" +dependencies = [ + "as-slice", +] + +[[package]] +name = "aligned-vec" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc890384c8602f339876ded803c97ad529f3842aba97f6392b3dba0dd171769b" +dependencies = [ + "equator", +] + +[[package]] +name = "anyhow" +version = "1.0.104" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470" + +[[package]] +name = "arbitrary" +version = "1.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3d036a3c4ab069c7b410a2ce876bd74808d2d0888a82667669f8e783a898bf1" + +[[package]] +name = "arg_enum_proc_macro" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ae92a5119aa49cdbcf6b9f893fe4e1d98b04ccbf82ee0584ad948a44a734dea" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.118", +] + +[[package]] +name = "arrayvec" +version = "0.7.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3fb67a6e08acf24fdeccbac2cb6ac4305825bd1f117462e0e6f2f193345ad56" + +[[package]] +name = "as-slice" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "516b6b4f0e40d50dcda9365d53964ec74560ad4284da2e7fc97122cd83174516" +dependencies = [ + "stable_deref_trait", +] + +[[package]] +name = "autocfg" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53" + +[[package]] +name = "av-scenechange" +version = "0.14.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0f321d77c20e19b92c39e7471cf986812cbb46659d2af674adc4331ef3f18394" +dependencies = [ + "aligned", + "anyhow", + "arg_enum_proc_macro", + "arrayvec", + "log", + "num-rational", + "num-traits", + "pastey", + "rayon", + "thiserror 2.0.19", + "v_frame", + "y4m", +] + +[[package]] +name = "av1-grain" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8cfddb07216410377231960af4fcab838eaa12e013417781b78bd95ee22077f8" +dependencies = [ + "anyhow", + "arrayvec", + "log", + "nom", + "num-rational", + "v_frame", +] + +[[package]] +name = "avif-serialize" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7178fe5f7d460b13895ebb9dcb28a3a6216d2df2574a0806cb51b555d297f38" +dependencies = [ + "arrayvec", +] + +[[package]] +name = "bit_field" +version = "0.10.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e4b40c7323adcfc0a41c4b88143ed58346ff65a288fc144329c5c45e05d70c6" + +[[package]] +name = "bitflags" +version = "1.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" + +[[package]] +name = "bitflags" +version = "2.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4388bee8683e3d04af747c73422af53102d2bd24d9eadb6cbc100baef4b43f8" + +[[package]] +name = "bitstream-io" +version = "4.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7eff00be299a18769011411c9def0d827e8f2d7bf0c3dbf53633147a8867fd1f" +dependencies = [ + "no_std_io2", +] + +[[package]] +name = "built" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c0e531d93d39c34eef561e929e8a7f86d77a5af08aac4f6d6e39976c51858e9" + +[[package]] +name = "bumpalo" +version = "3.20.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649" + +[[package]] +name = "bytemuck" +version = "1.25.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6aedf8ae72766347502cf3cb4f41cf5e9cc37d28bee90f1fdaaae15f9cf9424" +dependencies = [ + "bytemuck_derive", +] + +[[package]] +name = "bytemuck_derive" +version = "1.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f65693059b6b9c588b9f62fed1cedbf0a8b805631457ea162d68f0de186f3de5" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.118", +] + +[[package]] +name = "byteorder-lite" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495" + +[[package]] +name = "bytes" +version = "1.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc652a48c352aef3ea3aed32080501cf3ef6ed5da78602a020c991775b0aff04" + +[[package]] +name = "cc" +version = "1.2.67" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e17dd265a7d0f31ef544e1b20e03add05d3b45b491b633b10d67145d2acc1a38" +dependencies = [ + "find-msvc-tools", + "jobserver", + "libc", + "shlex", +] + +[[package]] +name = "cesu8" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c" + +[[package]] +name = "cfg-if" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801" + +[[package]] +name = "cmake" +version = "0.1.58" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c0f78a02292a74a88ac736019ab962ece0bc380e3f977bf72e376c5d78ff0678" +dependencies = [ + "cc", +] + +[[package]] +name = "color_quant" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b" + +[[package]] +name = "combine" +version = "4.6.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba5a308b75df32fe02788e748662718f03fde005016435c444eea572398219fd" +dependencies = [ + "bytes", + "memchr", +] + +[[package]] +name = "crc32fast" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "crossbeam-deque" +version = "0.8.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5181e0de7b61eb03a81e347d6dd8797bae9da5146707b51077e2d71a54ec0ceb" +dependencies = [ + "crossbeam-epoch", + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-epoch" +version = "0.9.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2d6914041f254d6e9176c01941b21115dcfb7089e55135a35411081bd106ef3f" +dependencies = [ + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-utils" +version = "0.8.22" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "61803da095bee82a81bb1a452ecc25d3b2f1416d1897eb86430c6159ef717c17" + +[[package]] +name = "crunchy" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5" + +[[package]] +name = "displaydoc" +version = "0.2.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1ac70aa55017e108007fbaf5aa0f54b021c98f92ff8af59d42eda9da96e3dd4f" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.118", +] + +[[package]] +name = "dlib" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ab8ecd87370524b461f8557c119c405552c396ed91fc0a8eec68679eab26f94a" +dependencies = [ + "libloading", +] + +[[package]] +name = "either" +version = "1.16.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "91622ff5e7162018101f2fea40d6ebf4a78bbe5a49736a2020649edf9693679e" + +[[package]] +name = "equator" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4711b213838dfee0117e3be6ac926007d7f433d7bbe33595975d4190cb07e6fc" +dependencies = [ + "equator-macro", +] + +[[package]] +name = "equator-macro" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "44f23cf4b44bfce11a86ace86f8a73ffdec849c9fd00a386a53d278bd9e81fb3" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.118", +] + +[[package]] +name = "exr" +version = "1.74.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "711fe42c9964295e01ee3fba3f9fe0e1d24b98886950d68efe81b1c76e21adf3" +dependencies = [ + "bit_field", + "half", + "lebe", + "miniz_oxide", + "num-complex", + "pulp", + "rayon-core", + "smallvec", + "zune-inflate", +] + +[[package]] +name = "fax" +version = "0.2.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "caf1079563223d5d59d83c85886a56e586cfd5c1a26292e971a0fa266531ac5a" + +[[package]] +name = "fdeflate" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c" +dependencies = [ + "simd-adler32", +] + +[[package]] +name = "find-msvc-tools" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582" + +[[package]] +name = "flatbuffers" +version = "24.12.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4f1baf0dbf96932ec9a3038d57900329c015b0bfb7b63d904f3bc27e2b02a096" +dependencies = [ + "bitflags 1.3.2", + "rustc_version", +] + +[[package]] +name = "flatc" +version = "0.2.2+23.5.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d4bba3050358223ece3d79720f9800139503b600e93b1d68493500a2d8c3721e" +dependencies = [ + "cmake", +] + +[[package]] +name = "flate2" +version = "1.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c" +dependencies = [ + "crc32fast", + "miniz_oxide", +] + +[[package]] +name = "foldhash" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb" + +[[package]] +name = "font-types" +version = "0.11.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b38ad915f6dadd993ced50848a8291a543bd41ca62bc10740d5e64e2ab4cfd7" +dependencies = [ + "bytemuck", +] + +[[package]] +name = "font-types" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad67eced03f5504d9cbd3a879b5958b5c54d4e5fd794361c6eb21b05fb703411" +dependencies = [ + "bytemuck", +] + +[[package]] +name = "fontique" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e04c4750a17111ebd77c3e0aea00476ce33f59235bc4d9e7f0aded5033ad3fc" +dependencies = [ + "hashbrown", + "linebender_resource_handle", + "memmap2", + "objc2", + "objc2-core-foundation", + "objc2-core-text", + "objc2-foundation", + "parlance", + "read-fonts 0.40.2", + "roxmltree", + "smallvec", + "windows", + "windows-core", + "yeslogic-fontconfig-sys", +] + +[[package]] +name = "getrandom" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd" +dependencies = [ + "cfg-if", + "libc", + "r-efi 5.3.0", + "wasip2", +] + +[[package]] +name = "getrandom" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099" +dependencies = [ + "cfg-if", + "libc", + "r-efi 6.0.0", +] + +[[package]] +name = "gif" +version = "0.14.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee8cfcc411d9adbbaba82fb72661cc1bcca13e8bba98b364e62b2dba8f960159" +dependencies = [ + "color_quant", + "weezl", +] + +[[package]] +name = "grid" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b40ca9252762c466af32d0b1002e91e4e1bc5398f77455e55474deb466355ff5" + +[[package]] +name = "guide-layout-engine" +version = "0.1.0" +dependencies = [ + "flatbuffers", + "flatc", + "image", + "jni", + "parley", + "swash", + "taffy", +] + +[[package]] +name = "half" +version = "2.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b" +dependencies = [ + "cfg-if", + "crunchy", + "zerocopy", +] + +[[package]] +name = "harfrust" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0589ddd0d2935dd2845827ac606b4081c266225d613b268ed2910f832889cab" +dependencies = [ + "bitflags 2.13.0", + "bytemuck", + "read-fonts 0.40.2", + "smallvec", +] + +[[package]] +name = "hashbrown" +version = "0.17.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a" +dependencies = [ + "foldhash", +] + +[[package]] +name = "icu_collections" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2984d1cd16c883d7935b9e07e44071dca8d917fd52ecc02c04d5fa0b5a3f191c" +dependencies = [ + "displaydoc", + "potential_utf", + "utf8_iter", + "yoke", + "zerofrom", + "zerovec", +] + +[[package]] +name = "icu_locale" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d5a396343c7208121dc86e35623d3dfe19814a7613cfd14964994cdc9c9a2e26" +dependencies = [ + "icu_collections", + "icu_locale_core", + "icu_locale_data", + "icu_provider", + "potential_utf", + "tinystr", + "zerovec", +] + +[[package]] +name = "icu_locale_core" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "92219b62b3e2b4d88ac5119f8904c10f8f61bf7e95b640d25ba3075e6cac2c29" +dependencies = [ + "displaydoc", + "litemap", + "serde", + "tinystr", + "writeable", + "zerovec", +] + +[[package]] +name = "icu_locale_data" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d5fdcc9ac77c6d74ff5cf6e65ef3181d6af32003b16fce3a77fb451d2f695993" + +[[package]] +name = "icu_normalizer" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c56e5ee99d6e3d33bd91c5d85458b6005a22140021cc324cea84dd0e72cff3b4" +dependencies = [ + "icu_collections", + "icu_normalizer_data", + "icu_properties", + "icu_provider", + "smallvec", + "zerovec", +] + +[[package]] +name = "icu_normalizer_data" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da3be0ae77ea334f4da67c12f149704f19f81d1adf7c51cf482943e84a2bad38" + +[[package]] +name = "icu_properties" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bee3b67d0ea5c2cca5003417989af8996f8604e34fb9ddf96208a033901e70de" +dependencies = [ + "icu_collections", + "icu_locale_core", + "icu_properties_data", + "icu_provider", + "zerotrie", + "zerovec", +] + +[[package]] +name = "icu_properties_data" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e2bbb201e0c04f7b4b3e14382af113e17ba4f63e2c9d2ee626b720cbce54a14" + +[[package]] +name = "icu_provider" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "139c4cf31c8b5f33d7e199446eff9c1e02decfc2f0eec2c8d71f65befa45b421" +dependencies = [ + "displaydoc", + "icu_locale_core", + "serde", + "stable_deref_trait", + "writeable", + "yoke", + "zerofrom", + "zerotrie", + "zerovec", +] + +[[package]] +name = "icu_segmenter" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c0794db0b1a86193ac9c48768d0e6c52c54448e0870ad87907d456ee0dac964" +dependencies = [ + "icu_collections", + "icu_locale", + "icu_provider", + "icu_segmenter_data", + "potential_utf", + "utf8_iter", + "zerovec", +] + +[[package]] +name = "icu_segmenter_data" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e4a2c462a4d927d512f5f882a033ddd62f33a05bb9f230d98f736ac3dc85938f" + +[[package]] +name = "image" +version = "0.25.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85ab80394333c02fe689eaf900ab500fbd0c2213da414687ebf995a65d5a6104" +dependencies = [ + "bytemuck", + "byteorder-lite", + "color_quant", + "exr", + "gif", + "image-webp", + "moxcms", + "num-traits", + "png", + "qoi", + "ravif", + "rayon", + "rgb", + "tiff", + "zune-core", + "zune-jpeg", +] + +[[package]] +name = "image-webp" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "525e9ff3e1a4be2fbea1fdf0e98686a6d98b4d8f937e1bf7402245af1909e8c3" +dependencies = [ + "byteorder-lite", + "quick-error", +] + +[[package]] +name = "imgref" +version = "1.12.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "89194689a993ab15268672e99e7b0e19da2da3268ac682e8f02d29d4d1434cd7" + +[[package]] +name = "interpolate_name" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c34819042dc3d3971c46c2190835914dfbe0c3c13f61449b2997f4e9722dfa60" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.118", +] + +[[package]] +name = "itertools" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285" +dependencies = [ + "either", +] + +[[package]] +name = "jni" +version = "0.21.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1a87aa2bb7d2af34197c04845522473242e1aa17c12f4935d5856491a7fb8c97" +dependencies = [ + "cesu8", + "cfg-if", + "combine", + "jni-sys 0.3.1", + "log", + "thiserror 1.0.69", + "walkdir", + "windows-sys 0.45.0", +] + +[[package]] +name = "jni-sys" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41a652e1f9b6e0275df1f15b32661cf0d4b78d4d87ddec5e0c3c20f097433258" +dependencies = [ + "jni-sys 0.4.1", +] + +[[package]] +name = "jni-sys" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6377a88cb3910bee9b0fa88d4f42e1d2da8e79915598f65fb0c7ee14c878af2" +dependencies = [ + "jni-sys-macros", +] + +[[package]] +name = "jni-sys-macros" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38c0b942f458fe50cdac086d2f946512305e5631e720728f2a61aabcd47a6264" +dependencies = [ + "quote", + "syn 2.0.118", +] + +[[package]] +name = "jobserver" +version = "0.1.35" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c00acbd29eabad4a2392fa0e921c874934dbbf4194312ad20f04a0ed67a3cb3" +dependencies = [ + "getrandom 0.4.3", + "libc", +] + +[[package]] +name = "lebe" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7a79a3332a6609480d7d0c9eab957bca6b455b91bb84e66d19f5ff66294b85b8" + +[[package]] +name = "libc" +version = "0.2.186" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66" + +[[package]] +name = "libfuzzer-sys" +version = "0.4.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a9fd2f41a1cba099f79a0b6b6c35656cf7c03351a7bae8ff0f28f25270f929d2" +dependencies = [ + "arbitrary", + "cc", +] + +[[package]] +name = "libloading" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55" +dependencies = [ + "cfg-if", + "windows-link", +] + +[[package]] +name = "libm" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981" + +[[package]] +name = "linebender_resource_handle" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d4a5ff6bcca6c4867b1c4fd4ef63e4db7436ef363e0ad7531d1558856bae64f4" + +[[package]] +name = "litemap" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "92daf443525c4cce67b150400bc2316076100ce0b3686209eb8cf3c31612e6f0" + +[[package]] +name = "log" +version = "0.4.33" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ceec5bc11778974d1bcb055b18002eba7f4b3518b6a0081b3af5f21666da9ad" + +[[package]] +name = "loop9" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fae87c125b03c1d2c0150c90365d7d6bcc53fb73a9acaef207d2d065860f062" +dependencies = [ + "imgref", +] + +[[package]] +name = "maybe-rayon" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ea1f30cedd69f0a2954655f7188c6a834246d2bcf1e315e2ac40c4b24dc9519" +dependencies = [ + "cfg-if", + "rayon", +] + +[[package]] +name = "memchr" +version = "2.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98" + +[[package]] +name = "memmap2" +version = "0.9.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d1219ed1b7f229ee7104d281dd01d6802fe28bb6e95d292942c4daacdeb798c0" +dependencies = [ + "libc", +] + +[[package]] +name = "miniz_oxide" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316" +dependencies = [ + "adler2", + "simd-adler32", +] + +[[package]] +name = "moxcms" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bb85c154ba489f01b25c0d36ae69a87e4a1c73a72631fc6c0eb6dde34a73e44b" +dependencies = [ + "num-traits", + "pxfm", +] + +[[package]] +name = "new_debug_unreachable" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086" + +[[package]] +name = "no_std_io2" +version = "0.9.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "418abd1b6d34fbf6cae440dc874771b0525a604428704c76e48b29a5e67b8003" +dependencies = [ + "memchr", +] + +[[package]] +name = "nom" +version = "8.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df9761775871bdef83bee530e60050f7e54b1105350d6884eb0fb4f46c2f9405" +dependencies = [ + "memchr", +] + +[[package]] +name = "noop_proc_macro" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0676bb32a98c1a483ce53e500a81ad9c3d5b3f7c920c28c24e9cb0980d0b5bc8" + +[[package]] +name = "num-bigint" +version = "0.4.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c89e69e7e0f03bea5ef08013795c25018e101932225a656383bd384495ecc367" +dependencies = [ + "num-integer", + "num-traits", +] + +[[package]] +name = "num-complex" +version = "0.4.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495" +dependencies = [ + "bytemuck", + "num-traits", +] + +[[package]] +name = "num-derive" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed3955f1a9c7c0c15e092f9c887db08b1fc683305fdf6eb6684f22555355e202" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.118", +] + +[[package]] +name = "num-integer" +version = "0.1.46" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f" +dependencies = [ + "num-traits", +] + +[[package]] +name = "num-rational" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824" +dependencies = [ + "num-bigint", + "num-integer", + "num-traits", +] + +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", +] + +[[package]] +name = "objc2" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3a12a8ed07aefc768292f076dc3ac8c48f3781c8f2d5851dd3d98950e8c5a89f" +dependencies = [ + "objc2-encode", +] + +[[package]] +name = "objc2-core-foundation" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536" +dependencies = [ + "bitflags 2.13.0", +] + +[[package]] +name = "objc2-core-text" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0cde0dfb48d25d2b4862161a4d5fcc0e3c24367869ad306b0c9ec0073bfed92d" +dependencies = [ + "bitflags 2.13.0", + "objc2-core-foundation", +] + +[[package]] +name = "objc2-encode" +version = "4.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef25abbcd74fb2609453eb695bd2f860d389e457f67dc17cafc8b8cbc89d0c33" + +[[package]] +name = "objc2-foundation" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3e0adef53c21f888deb4fa59fc59f7eb17404926ee8a6f59f5df0fd7f9f3272" +dependencies = [ + "bitflags 2.13.0", + "objc2", +] + +[[package]] +name = "once_cell" +version = "1.21.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50" + +[[package]] +name = "parlance" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4b6937eda350acc1a5d05872c3cbf99fe78619c269096e2be3d4a350058639d5" + +[[package]] +name = "parley" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e0478b47dd9885a5e0a4f1c0782ffc42bf6ee8c41dea0917d7a9bcee3e6585fc" +dependencies = [ + "fontique", + "harfrust", + "hashbrown", + "icu_normalizer", + "icu_properties", + "icu_segmenter", + "linebender_resource_handle", + "parlance", + "parley_data", + "skrifa 0.43.2", +] + +[[package]] +name = "parley_data" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a649e01a1acc917247ee147b56b8a1fa91824acf7117bd003b4204306d601255" +dependencies = [ + "icu_properties", +] + +[[package]] +name = "paste" +version = "1.0.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a" + +[[package]] +name = "pastey" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "35fb2e5f958ec131621fdd531e9fc186ed768cbe395337403ae56c17a74c68ec" + +[[package]] +name = "pkg-config" +version = "0.3.33" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "19f132c84eca552bf34cab8ec81f1c1dcc229b811638f9d283dceabe58c5569e" + +[[package]] +name = "png" +version = "0.18.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "60769b8b31b2a9f263dae2776c37b1b28ae246943cf719eb6946a1db05128a61" +dependencies = [ + "bitflags 2.13.0", + "crc32fast", + "fdeflate", + "flate2", + "miniz_oxide", +] + +[[package]] +name = "potential_utf" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0103b1cef7ec0cf76490e969665504990193874ea05c85ff9bab8b911d0a0564" +dependencies = [ + "serde_core", + "writeable", + "zerovec", +] + +[[package]] +name = "ppv-lite86" +version = "0.2.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9" +dependencies = [ + "zerocopy", +] + +[[package]] +name = "proc-macro2" +version = "1.0.106" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "profiling" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d595e54a326bc53c1c197b32d295e14b169e3cfeaa8dc82b529f947fba6bcf5" +dependencies = [ + "profiling-procmacros", +] + +[[package]] +name = "profiling-procmacros" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4488a4a36b9a4ba6b9334a32a39971f77c1436ec82c38707bce707699cc3bbcb" +dependencies = [ + "quote", + "syn 2.0.118", +] + +[[package]] +name = "pulp" +version = "0.22.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "046aa45b989642ec2e4717c8e72d677b13edd831a4d3b6cf37d9a3e54912496a" +dependencies = [ + "bytemuck", + "cfg-if", + "libm", + "num-complex", + "paste", + "pulp-wasm-simd-flag", + "raw-cpuid", + "reborrow", + "version_check", +] + +[[package]] +name = "pulp-wasm-simd-flag" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d8f70e07b9c3962945a74e59ca1c511bba65b6419468acc217c457d93f3c740" + +[[package]] +name = "pxfm" +version = "0.1.30" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d55d956fa96f5ec02be2e13af0e20391a5aa83d6a074e3ad368959d0fab299ea" + +[[package]] +name = "qoi" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f6d64c71eb498fe9eae14ce4ec935c555749aef511cca85b5568910d6e48001" +dependencies = [ + "bytemuck", +] + +[[package]] +name = "quick-error" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3" + +[[package]] +name = "quote" +version = "1.0.46" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dfbc457d0c7a0759a614551b11a6409e5951f6c7537be1f1b7682b9ae9230368" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "r-efi" +version = "5.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" + +[[package]] +name = "r-efi" +version = "6.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf" + +[[package]] +name = "rand" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9ef1d0d795eb7d84685bca4f72f3649f064e6641543d3a8c415898726a57b41" +dependencies = [ + "rand_chacha", + "rand_core", +] + +[[package]] +name = "rand_chacha" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb" +dependencies = [ + "ppv-lite86", + "rand_core", +] + +[[package]] +name = "rand_core" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c" +dependencies = [ + "getrandom 0.3.4", +] + +[[package]] +name = "rav1e" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "43b6dd56e85d9483277cde964fd1bdb0428de4fec5ebba7540995639a21cb32b" +dependencies = [ + "aligned-vec", + "arbitrary", + "arg_enum_proc_macro", + "arrayvec", + "av-scenechange", + "av1-grain", + "bitstream-io", + "built", + "cfg-if", + "interpolate_name", + "itertools", + "libc", + "libfuzzer-sys", + "log", + "maybe-rayon", + "new_debug_unreachable", + "noop_proc_macro", + "num-derive", + "num-traits", + "paste", + "profiling", + "rand", + "rand_chacha", + "simd_helpers", + "thiserror 2.0.19", + "v_frame", + "wasm-bindgen", +] + +[[package]] +name = "ravif" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e52310197d971b0f5be7fe6b57530dcd27beb35c1b013f29d66c1ad73fbbcc45" +dependencies = [ + "avif-serialize", + "imgref", + "loop9", + "quick-error", + "rav1e", + "rayon", + "rgb", +] + +[[package]] +name = "raw-cpuid" +version = "11.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "498cd0dc59d73224351ee52a95fee0f1a617a2eae0e7d9d720cc622c73a54186" +dependencies = [ + "bitflags 2.13.0", +] + +[[package]] +name = "rayon" +version = "1.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d" +dependencies = [ + "either", + "rayon-core", +] + +[[package]] +name = "rayon-core" +version = "1.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91" +dependencies = [ + "crossbeam-deque", + "crossbeam-utils", +] + +[[package]] +name = "read-fonts" +version = "0.39.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c4ed38b89c2c77ff968c524145ad65fb010f38af5c7a224b53b81d47ac2daa81" +dependencies = [ + "bytemuck", + "font-types 0.11.3", +] + +[[package]] +name = "read-fonts" +version = "0.40.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "487889119a5f19ff7c0a20637196bdc76b9f54ebec17e3588b5d75e4999f8773" +dependencies = [ + "bytemuck", + "font-types 0.12.1", + "once_cell", +] + +[[package]] +name = "reborrow" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "03251193000f4bd3b042892be858ee50e8b3719f2b08e5833ac4353724632430" + +[[package]] +name = "rgb" +version = "0.8.53" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "47b34b781b31e5d73e9fbc8689c70551fd1ade9a19e3e28cfec8580a79290cc4" + +[[package]] +name = "roxmltree" +version = "0.21.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1964b10c76125c36f8afe190065a4bf9a87bf324842c05701330bba9f1cacbb" +dependencies = [ + "memchr", +] + +[[package]] +name = "rustc_version" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92" +dependencies = [ + "semver", +] + +[[package]] +name = "rustversion" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f" + +[[package]] +name = "same-file" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502" +dependencies = [ + "winapi-util", +] + +[[package]] +name = "semver" +version = "1.0.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd" + +[[package]] +name = "serde" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.118", +] + +[[package]] +name = "shlex" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba" + +[[package]] +name = "simd-adler32" +version = "0.3.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3a219298ac11a56ea9a6d2120044824d6f01aeb034955e7af7bc16858527deea" + +[[package]] +name = "simd_helpers" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "95890f873bec569a0362c235787f3aca6e1e887302ba4840839bcc6459c42da6" +dependencies = [ + "quote", +] + +[[package]] +name = "skrifa" +version = "0.42.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c34617370ae968efb7161bb2beb517d9084659aae19e24b89e3db25b46e4564" +dependencies = [ + "bytemuck", + "read-fonts 0.39.2", +] + +[[package]] +name = "skrifa" +version = "0.43.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4cbe997d0f2480442d727488fbe2150779114cbe480ecdbadef58b33e0318ffb" +dependencies = [ + "bytemuck", + "read-fonts 0.40.2", +] + +[[package]] +name = "slotmap" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bdd58c3c93c3d278ca835519292445cb4b0d4dc59ccfdf7ceadaab3f8aeb4038" +dependencies = [ + "version_check", +] + +[[package]] +name = "smallvec" +version = "1.15.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ed6a63f02c8539c91a8685a86f4099661ba3da017932f6ebbea6de3f0fa7c90" + +[[package]] +name = "stable_deref_trait" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596" + +[[package]] +name = "swash" +version = "0.2.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0811b01ca2c4e8718760713911feaf4675c24f94e50530a015ec646cfb622f7c" +dependencies = [ + "skrifa 0.42.1", + "yazi", + "zeno", +] + +[[package]] +name = "syn" +version = "2.0.118" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b9ae57f904213ebb649ce6895b8a66c66f0203b9319718f69a5612a065b1422" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "syn" +version = "3.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a207d6d6a2b7fc470b80443726053f18a2481b7e1eee970597051596567987a3" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "synstructure" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.118", +] + +[[package]] +name = "taffy" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "73afc801dd6bd47529eaa7c7e90557f107527d1b7c9c7ed7d7803c7b8d0c357f" +dependencies = [ + "arrayvec", + "grid", + "serde", + "slotmap", +] + +[[package]] +name = "thiserror" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52" +dependencies = [ + "thiserror-impl 1.0.69", +] + +[[package]] +name = "thiserror" +version = "2.0.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09a43598840e33d5b0331f38c5e30d13bb11c11210a4b58f0d9b18a5a5eefcd9" +dependencies = [ + "thiserror-impl 2.0.19", +] + +[[package]] +name = "thiserror-impl" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.118", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "43cbfe0cf76104d42a574802844187e84a305e531ed54455f11fbde0f10541cd" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.2", +] + +[[package]] +name = "tiff" +version = "0.11.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b63feaf3343d35b6ca4d50483f94843803b0f51634937cc2ec519fc32232bc52" +dependencies = [ + "fax", + "flate2", + "half", + "quick-error", + "weezl", + "zune-jpeg", +] + +[[package]] +name = "tinystr" +version = "0.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c8323304221c2a851516f22236c5722a72eaa19749016521d6dff0824447d96d" +dependencies = [ + "displaydoc", + "serde_core", + "zerovec", +] + +[[package]] +name = "unicode-ident" +version = "1.0.24" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" + +[[package]] +name = "utf8_iter" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be" + +[[package]] +name = "v_frame" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "666b7727c8875d6ab5db9533418d7c764233ac9c0cff1d469aec8fa127597be2" +dependencies = [ + "aligned-vec", + "num-traits", + "wasm-bindgen", +] + +[[package]] +name = "version_check" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" + +[[package]] +name = "walkdir" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b" +dependencies = [ + "same-file", + "winapi-util", +] + +[[package]] +name = "wasip2" +version = "1.0.4+wasi-0.2.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b67efb37e106e55ce722a510d6b5f9c17f083e5fc79afc2badeb12cc313d9487" +dependencies = [ + "wit-bindgen", +] + +[[package]] +name = "wasm-bindgen" +version = "0.2.126" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4b067c0c11094aef6b7a801c1e34a26affafdf3d051dba08456b868789aaf9a4" +dependencies = [ + "cfg-if", + "once_cell", + "rustversion", + "wasm-bindgen-macro", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-macro" +version = "0.2.126" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "167ce5e579f6bcf889c4f7175a8a5a585de84e8ff93976ce393efa5f2837aab1" +dependencies = [ + "quote", + "wasm-bindgen-macro-support", +] + +[[package]] +name = "wasm-bindgen-macro-support" +version = "0.2.126" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f3997c7839262f4ef12cf90b818d6340c18e80f263f1a94bf157d0ec4420380e" +dependencies = [ + "bumpalo", + "proc-macro2", + "quote", + "syn 2.0.118", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-shared" +version = "0.2.126" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc1b4cb0cc549fcf58d7dfc081778139b3d283a081644e833e84682ad71cea24" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "weezl" +version = "0.1.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a28ac98ddc8b9274cb41bb4d9d4d5c425b6020c50c46f25559911905610b4a88" + +[[package]] +name = "winapi-util" +version = "0.1.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22" +dependencies = [ + "windows-sys 0.61.2", +] + +[[package]] +name = "windows" +version = "0.62.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "527fadee13e0c05939a6a05d5bd6eec6cd2e3dbd648b9f8e447c6518133d8580" +dependencies = [ + "windows-collections", + "windows-core", + "windows-future", + "windows-numerics", +] + +[[package]] +name = "windows-collections" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "23b2d95af1a8a14a3c7367e1ed4fc9c20e0a26e79551b1454d72583c97cc6610" +dependencies = [ + "windows-core", +] + +[[package]] +name = "windows-core" +version = "0.62.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb" +dependencies = [ + "windows-implement", + "windows-interface", + "windows-link", + "windows-result", + "windows-strings", +] + +[[package]] +name = "windows-future" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e1d6f90251fe18a279739e78025bd6ddc52a7e22f921070ccdc67dde84c605cb" +dependencies = [ + "windows-core", + "windows-link", + "windows-threading", +] + +[[package]] +name = "windows-implement" +version = "0.60.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.118", +] + +[[package]] +name = "windows-interface" +version = "0.59.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.118", +] + +[[package]] +name = "windows-link" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" + +[[package]] +name = "windows-numerics" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e2e40844ac143cdb44aead537bbf727de9b044e107a0f1220392177d15b0f26" +dependencies = [ + "windows-core", + "windows-link", +] + +[[package]] +name = "windows-result" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-strings" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-sys" +version = "0.45.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0" +dependencies = [ + "windows-targets", +] + +[[package]] +name = "windows-sys" +version = "0.61.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-targets" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071" +dependencies = [ + "windows_aarch64_gnullvm", + "windows_aarch64_msvc", + "windows_i686_gnu", + "windows_i686_msvc", + "windows_x86_64_gnu", + "windows_x86_64_gnullvm", + "windows_x86_64_msvc", +] + +[[package]] +name = "windows-threading" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3949bd5b99cafdf1c7ca86b43ca564028dfe27d66958f2470940f73d86d75b37" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43" + +[[package]] +name = "windows_i686_gnu" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f" + +[[package]] +name = "windows_i686_msvc" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0" + +[[package]] +name = "wit-bindgen" +version = "0.57.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e" + +[[package]] +name = "writeable" +version = "0.6.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1ffae5123b2d3fc086436f8834ae3ab053a283cfac8fe0a0b8eaae044768a4c4" + +[[package]] +name = "y4m" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7a5a4b21e1a62b67a2970e6831bc091d7b87e119e7f9791aef9702e3bef04448" + +[[package]] +name = "yazi" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e01738255b5a16e78bbb83e7fbba0a1e7dd506905cfc53f4622d89015a03fbb5" + +[[package]] +name = "yeslogic-fontconfig-sys" +version = "6.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d8b8abf912b9a29ff112e1671c97c33636903d13a69712037190e6805af4f76" +dependencies = [ + "dlib", + "once_cell", + "pkg-config", +] + +[[package]] +name = "yoke" +version = "0.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "709fe23a0424b6a435d82152b1bd3fdfb0833487d5fa90d05d42762a9891fef5" +dependencies = [ + "stable_deref_trait", + "yoke-derive", + "zerofrom", +] + +[[package]] +name = "yoke-derive" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "de844c262c8848816172cef550288e7dc6c7b7814b4ee56b3e1553f275f1858e" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.118", + "synstructure", +] + +[[package]] +name = "zeno" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6df3dc4292935e51816d896edcd52aa30bc297907c26167fec31e2b0c6a32524" + +[[package]] +name = "zerocopy" +version = "0.8.54" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b7cbbc0a705a0fd05cc3676525980d2bf5a9bc4adac6d6475209a7887cf59d19" +dependencies = [ + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.8.54" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e2e817b7b52d0c7358d3246da9d69935ebb18116b2b102b4230dac079b4862f5" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.118", +] + +[[package]] +name = "zerofrom" +version = "0.1.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ec05a11813ea801ff6d75110ad09cd0824ddba17dfe17128ea0d5f68e6c5272" +dependencies = [ + "zerofrom-derive", +] + +[[package]] +name = "zerofrom-derive" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "11532158c46691caf0f2593ea8358fed6bbf68a0315e80aae9bd41fbade684a1" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.118", + "synstructure", +] + +[[package]] +name = "zerotrie" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0f9152d31db0792fa83f70fb2f83148effb5c1f5b8c7686c3459e361d9bc20bf" +dependencies = [ + "displaydoc", + "yoke", + "zerofrom", + "zerovec", +] + +[[package]] +name = "zerovec" +version = "0.11.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "90f911cbc359ab6af17377d242225f4d75119aec87ea711a880987b18cd7b239" +dependencies = [ + "serde", + "yoke", + "zerofrom", + "zerovec-derive", +] + +[[package]] +name = "zerovec-derive" +version = "0.11.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "625dc425cab0dca6dc3c3319506e6593dcb08a9f387ea3b284dbd52a92c40555" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.118", +] + +[[package]] +name = "zune-core" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cb8a0807f7c01457d0379ba880ba6322660448ddebc890ce29bb64da71fb40f9" + +[[package]] +name = "zune-inflate" +version = "0.2.54" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "73ab332fe2f6680068f3582b16a24f90ad7096d5d39b974d1c0aff0125116f02" +dependencies = [ + "simd-adler32", +] + +[[package]] +name = "zune-jpeg" +version = "0.5.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "27bc9d5b815bc103f142aa054f561d9187d191692ec7c2d1e2b4737f8dbd7296" +dependencies = [ + "zune-core", +] diff --git a/layout-engine/Cargo.toml b/layout-engine/Cargo.toml new file mode 100644 index 00000000..51c953f9 --- /dev/null +++ b/layout-engine/Cargo.toml @@ -0,0 +1,32 @@ +[package] +name = "guide-layout-engine" +version = "0.1.0" +edition = "2021" + +[lib] +crate-type = ["cdylib", "lib"] + +[features] +default = [] + +[dependencies] +# JNI bridge +jni = "0.21" + +# Layout engine +taffy = { version = "0.12", features = ["flexbox", "grid", "block_layout", "float_layout"] } + +# Line-box text layout (per-line geometry control) +parley = { version = "0.11", features = ["complex-scripts"] } + +# Rasterization +swash = "0.2" + +# Serialization +flatbuffers = "24" + +[build-dependencies] +flatc = "0.2" + +[dev-dependencies] +image = "0.25" diff --git a/layout-engine/build.rs b/layout-engine/build.rs new file mode 100644 index 00000000..4b23b2d3 --- /dev/null +++ b/layout-engine/build.rs @@ -0,0 +1,44 @@ +use std::fs; +use std::path::Path; +use std::process::Command; + +fn main() { + let schema = Path::new("schema").join("guidenh_layout.fbs"); + let out_dir = Path::new("src"); + let generated = out_dir.join("guidenh_layout_generated.rs"); + + println!("cargo:rerun-if-changed={}", schema.display()); + + let flatc_path = flatc::flatc(); + + let status = Command::new(&flatc_path) + .args(["--rust", "-o", out_dir.to_str().unwrap(), schema.to_str().unwrap()]) + .status() + .expect("flatc binary failed to execute"); + + if !status.success() { + panic!("flatc exited with code {:?}", status.code()); + } + + // Patch the generated file to work with Rust 2021: + // 1. Remove all `extern crate flatbuffers;` — Rust 2021 auto-imports extern crates + // 2. Change `use self::flatbuffers::` to `use ::flatbuffers::` — `self::flatbuffers` + // inside `mod flatbuffers { }` refers to the module, not the crate + if generated.exists() { + let content = fs::read_to_string(&generated).unwrap_or_default(); + // Remove ALL `extern crate flatbuffers;` regardless of indentation or line endings + let patched = content + .lines() + .filter(|l| !l.trim().starts_with("extern crate flatbuffers")) + .collect::>() + .join("\n") + .replace("use self::flatbuffers::{EndianScalar, Follow};", "use ::flatbuffers::{EndianScalar, Follow};") + .replace("use self::flatbuffers::Verifiable;", "use ::flatbuffers::Verifiable;"); + if patched != content { + fs::write(&generated, patched).expect("Failed to patch generated file"); + println!("cargo:warning=Patched generated file (extern crate + self::flatbuffers fixed)"); + } + } + + println!("cargo:warning=Generated {}", generated.display()); +} diff --git a/layout-engine/examples/flex_probe.rs b/layout-engine/examples/flex_probe.rs new file mode 100644 index 00000000..68a29441 --- /dev/null +++ b/layout-engine/examples/flex_probe.rs @@ -0,0 +1,72 @@ +//! Minimal Taffy flex behavior probe: Row[grow text child, fixed-size leaf], +//! mirroring the production toolbar style (align CENTER + padding 8/8/4/4) +//! and the production measure dispatch. +use taffy::prelude::*; + +fn main() { + let mut t: TaffyTree<()> = TaffyTree::new(); + let label = t + .new_leaf(Style { + flex_grow: 1.0, + ..Default::default() + }) + .unwrap(); + let button = t + .new_leaf(Style { + size: Size { + width: Dimension::length(16.0), + height: Dimension::length(16.0), + }, + ..Default::default() + }) + .unwrap(); + let row = t + .new_with_children( + Style { + display: Display::Flex, + flex_direction: FlexDirection::Row, + align_items: Some(AlignItems::CENTER), + padding: Rect { + left: LengthPercentage::length(8.0), + right: LengthPercentage::length(8.0), + top: LengthPercentage::length(4.0), + bottom: LengthPercentage::length(4.0), + }, + size: Size { + width: Dimension::length(533.0), + height: Dimension::AUTO, + }, + ..Default::default() + }, + &[label, button], + ) + .unwrap(); + + t.compute_layout_with_measure( + row, + Size { + width: AvailableSpace::Definite(533.0), + height: AvailableSpace::MaxContent, + }, + |known, _avail, node_id, _ctx, _style| { + // Mirror production dispatch: label (node_type 1) measures text at + // 24x23; button (node_type 0) gets ZERO then known-dims wrap. + let measured = if node_id == NodeId::from(0usize) { + Size { + width: 24.0, + height: 23.0, + } + } else { + Size::ZERO + }; + Size { + width: known.width.unwrap_or(measured.width), + height: known.height.unwrap_or(measured.height), + } + }, + ) + .unwrap(); + + println!("label: {:?}", t.layout(label).unwrap()); + println!("button: {:?}", t.layout(button).unwrap()); +} diff --git a/layout-engine/examples/float_bridge_probe.rs b/layout-engine/examples/float_bridge_probe.rs new file mode 100644 index 00000000..180fc374 --- /dev/null +++ b/layout-engine/examples/float_bridge_probe.rs @@ -0,0 +1,410 @@ +use taffy::prelude::*; +use taffy::style::Float; + +#[derive(Clone)] +struct Ctx { + kind: u8, + id: usize, +} + +#[derive(Clone, Copy)] +struct FRect { + x: f32, + y: f32, + w: f32, + h: f32, + right: bool, +} + +#[derive(Clone, Copy)] +struct Clip { + y_top: f32, + y_bottom: f32, + x: f32, + width: f32, +} + +#[derive(Clone, Copy)] +enum Kind { + F, + P(usize), +} + +const LH: f32 = 10.0; +const GAP: f32 = 5.0; +const SPACE: f32 = 3.0; + +fn clip_w(rel_y: f32, clips: &[Clip], w: f32) -> f32 { + let mut x0: f32 = 0.0; + let mut x1 = w; + for c in clips { + if c.y_bottom <= rel_y || c.y_top >= rel_y + LH { + continue; + } + if c.x <= 0.0 { + x0 = x0.max(c.x + c.width); + } else { + x1 = x1.min(c.x); + } + } + (x1 - x0).max(1.0) +} + +fn greedy(words: &[f32], mut line_w: impl FnMut(f32) -> f32, y0: f32) -> (f32, Vec) { + let mut lines: Vec = Vec::new(); + let mut rel = 0.0; + let mut i = 0; + while i < words.len() { + let lw = line_w(y0 + rel); + let mut used = 0.0; + let mut took = 0; + while i + took < words.len() { + let add = if took == 0 { + words[i + took] + } else { + used + SPACE + words[i + took] + }; + if add > lw && took > 0 { + break; + } + used = add; + took += 1; + if used >= lw { + break; + } + } + if took == 0 { + took = 1; + used = words[i]; + } + lines.push(used); + i += took; + rel += LH; + } + if lines.is_empty() { + lines.push(0.0); + rel = LH; + } + (rel, lines) +} + +fn wrap_clips(words: &[f32], clips: &[Clip], w: f32) -> (f32, Vec) { + greedy(words, |rel_y| clip_w(rel_y, clips, w), 0.0) +} + +fn float_edges(abs_y: f32, floats: &[FRect], para_x: f32, para_w: f32) -> f32 { + let mut l = para_x; + let mut r = para_x + para_w; + for f in floats { + if f.y + f.h <= abs_y || f.y >= abs_y + LH { + continue; + } + if f.right { + r = r.min(f.x); + } else { + l = l.max(f.x + f.w); + } + } + (r - l).max(1.0) +} + +fn wrap_floats(words: &[f32], floats: &[FRect], para_x: f32, para_w: f32, para_abs_y: f32) -> (f32, Vec) { + greedy( + words, + |abs_y| float_edges(abs_y, floats, para_x, para_w), + para_abs_y, + ) +} + +fn words(n: usize) -> Vec { + vec![30.0; n] +} + +fn run_scene(name: &str, avail: f32, fw: f32, fh: f32, paras: &[Vec], layout: &[Kind]) { + println!("==== {} (avail={} fw={} fh={}) ====", name, avail, fw, fh); + + // ---- Algorithm Y: single-pass document-flow driver (Java-homologous) ---- + let mut y_floats: Vec = Vec::new(); + let mut y_h = vec![0.0f32; paras.len()]; + let mut y_lines: Vec> = vec![Vec::new(); paras.len()]; + let mut cursor = 0.0f32; + for k in layout { + match k { + Kind::F => { + let fx = avail - fw; + y_floats.push(FRect { + x: fx - GAP, + y: cursor, + w: fw + GAP, + h: fh + GAP, + right: true, + }); + } + Kind::P(idx) => { + let (h, lines) = wrap_floats(¶s[*idx], &y_floats, 0.0, avail, cursor); + y_h[*idx] = h; + y_lines[*idx] = lines; + cursor += h; + } + } + } + + // ---- Algorithm X: two-or-more-pass taffy, clips replayed from taffy geometry ---- + let mut t: TaffyTree = TaffyTree::new(); + let mut node_ids: Vec<(Kind, NodeId)> = Vec::new(); + for k in layout { + let (style, ctx) = match k { + Kind::F => ( + Style { + float: Float::Right, + size: Size { + width: Dimension::length(fw), + height: Dimension::length(fh), + }, + ..Default::default() + }, + Ctx { kind: 0, id: usize::MAX }, + ), + Kind::P(idx) => ( + Style { + size: Size { + width: Dimension::AUTO, + height: Dimension::AUTO, + }, + ..Default::default() + }, + Ctx { kind: 1, id: *idx }, + ), + }; + let id = t.new_leaf_with_context(style, ctx).unwrap(); + node_ids.push((*k, id)); + } + let child_ids: Vec = node_ids.iter().map(|(_, id)| *id).collect(); + let root = t + .new_with_children( + Style { + display: Display::Block, + size: Size { + width: Dimension::length(avail), + height: Dimension::AUTO, + }, + ..Default::default() + }, + &child_ids, + ) + .unwrap(); + + let n = paras.len(); + let mut clips_per_para: Vec> = vec![Vec::new(); n]; + let mut history: Vec> = Vec::new(); + let mut x_lines: Vec> = vec![Vec::new(); n]; + let mut converged = false; + let mut oscillate = false; + let max_pass = 6; + + for pass in 0..max_pass { + let mut lines_out: Vec> = vec![Vec::new(); n]; + let clips_ref = &clips_per_para; + let paras_ref = paras; + let lines_ref = &mut lines_out; + t.compute_layout_with_measure( + root, + Size { + width: AvailableSpace::Definite(avail), + height: AvailableSpace::MaxContent, + }, + move |known, available, _node_id, ctx, _style| { + let c = match ctx { + Some(c) => c, + None => return Size::ZERO, + }; + if c.kind == 0 { + return Size { + width: known.width.unwrap_or(0.0), + height: known.height.unwrap_or(0.0), + }; + } + let id = c.id; + let w = match available.width { + AvailableSpace::Definite(x) => x, + _ => avail, + }; + let (h, lines) = wrap_clips(¶s_ref[id], &clips_ref[id], w); + lines_ref[id] = lines; + Size { + width: known.width.unwrap_or(w), + height: known.height.unwrap_or(h), + } + }, + ) + .unwrap(); + + let mut float_rect: Option<(f32, f32, f32, f32)> = None; + for (k, id) in &node_ids { + if let Kind::F = k { + let l = t.layout(*id).unwrap(); + float_rect = Some((l.location.x, l.location.y, l.size.width, l.size.height)); + } + } + let (frx, fry, _frw, frh) = float_rect.unwrap(); + let reg_x = frx - GAP; + let reg_h = frh + GAP; + + let mut new_clips: Vec> = vec![Vec::new(); n]; + let mut heights = vec![0.0f32; n]; + for (k, id) in &node_ids { + if let Kind::P(idx) = k { + let l = t.layout(*id).unwrap(); + let px = l.location.x; + let py = l.location.y; + let pw = l.size.width; + let ph = l.size.height; + heights[*idx] = ph; + if reg_h > 0.0 && !(fry + reg_h <= py || fry >= py + ph) { + let y_top = fry.max(py) - py; + let y_bottom = (fry + reg_h).min(py + ph) - py; + if y_bottom > y_top { + new_clips[*idx].push(Clip { + y_top, + y_bottom, + x: reg_x - px, + width: ((px + pw) - reg_x).max(1.0), + }); + } + } + } + } + x_lines = lines_out; + clips_per_para = new_clips; + + let stable = history.last().map_or(false, |prev| *prev == heights); + history.push(heights.clone()); + if pass > 0 && stable { + converged = true; + break; + } + let len = history.len(); + if len >= 3 && history[len - 1] == history[len - 3] && history[len - 1] != history[len - 2] { + oscillate = true; + break; + } + } + + println!(" X pass heights:"); + for (i, h) in history.iter().enumerate() { + println!(" pass {}: {:?}", i, h); + } + println!( + " X status: {}{}", + if converged { "CONVERGED" } else { "NOT-CONVERGED" }, + if oscillate { " OSCILLATE" } else { "" } + ); + println!(" X final lines: {:?}", x_lines); + println!(" Y heights: {:?}", y_h); + println!(" Y lines: {:?}", y_lines); + + let x_final = history.last().cloned().unwrap_or_default(); + let h_match = x_final == y_h; + let l_match = x_lines == y_lines; + println!( + " VERDICT: heights {} | lines {} | oscillate {}", + if h_match { "MATCH" } else { "DIVERGE" }, + if l_match { "MATCH" } else { "DIVERGE" }, + oscillate + ); + println!(); +} + +fn probe_float_display() { + println!("==== float under FLEX vs BLOCK container ===="); + let avail = 400.0; + let fw = 120.0; + let fh = 80.0; + + for (label, display) in [("FLEX", Display::Flex), ("BLOCK", Display::Block)] { + let mut t: TaffyTree = TaffyTree::new(); + let f = t + .new_leaf_with_context( + Style { + float: Float::Right, + size: Size { + width: Dimension::length(fw), + height: Dimension::length(fh), + }, + ..Default::default() + }, + Ctx { kind: 0, id: 0 }, + ) + .unwrap(); + let p = t + .new_leaf_with_context( + Style::default(), + Ctx { kind: 1, id: 0 }, + ) + .unwrap(); + let root = t + .new_with_children( + Style { + display, + flex_direction: FlexDirection::Column, + size: Size { + width: Dimension::length(avail), + height: Dimension::AUTO, + }, + ..Default::default() + }, + &[f, p], + ) + .unwrap(); + t.compute_layout_with_measure( + root, + Size { + width: AvailableSpace::Definite(avail), + height: AvailableSpace::MaxContent, + }, + |known, _a, _n, ctx, _s| { + let c = match ctx { + Some(c) => c, + None => return Size::ZERO, + }; + if c.kind == 1 { + return Size { width: 200.0, height: 30.0 }; + } + Size { + width: known.width.unwrap_or(0.0), + height: known.height.unwrap_or(0.0), + } + }, + ) + .unwrap(); + let fl = t.layout(f).unwrap(); + let pl = t.layout(p).unwrap(); + println!( + " {} -> float loc=({:.0},{:.0}) size=({:.0},{:.0}) | para loc=({:.0},{:.0})", + label, fl.location.x, fl.location.y, fl.size.width, fl.size.height, pl.location.x, + pl.location.y + ); + } + println!(" (float active = para.y stays at 0 and float.x right-aligned; float ignored under flex = para.y pushed below float height)"); + println!(); +} + +fn main() { + probe_float_display(); + run_scene( + "S1 float-first, bottom lands inside para2", + 400.0, + 120.0, + 75.0, + &[words(36), words(36), words(36)], + &[Kind::F, Kind::P(0), Kind::P(1), Kind::P(2)], + ); + run_scene( + "S2 float after a short paragraph", + 400.0, + 120.0, + 75.0, + &[words(4), words(36), words(36)], + &[Kind::P(0), Kind::F, Kind::P(1), Kind::P(2)], + ); +} diff --git a/layout-engine/examples/space_probe.rs b/layout-engine/examples/space_probe.rs new file mode 100644 index 00000000..dee70b26 --- /dev/null +++ b/layout-engine/examples/space_probe.rs @@ -0,0 +1,76 @@ +use guide_layout_engine::parley_text::ParleyFonts; + +fn main() { + let mut parley = ParleyFonts::new(); + + let text = " indented line"; + let layout = parley.layout_paragraph(text, 9.0, 10.0 / 9.0, Some(500.0)); + + let mut total_advance = 0.0f32; + let mut glyph_count = 0; + for line in layout.lines() { + for item in line.items() { + if let parley::PositionedLayoutItem::GlyphRun(gr) = item { + for g in gr.positioned_glyphs() { + glyph_count += 1; + total_advance = g.x + g.advance; + } + } + } + } + + let single_space = parley.layout_paragraph(" indented line", 9.0, 10.0 / 9.0, Some(500.0)); + let mut single_advance = 0.0f32; + let mut single_count = 0; + for line in single_space.lines() { + for item in line.items() { + if let parley::PositionedLayoutItem::GlyphRun(gr) = item { + for g in gr.positioned_glyphs() { + single_count += 1; + single_advance = g.x + g.advance; + } + } + } + } + + println!("4-space: glyphs={} advance={:.2}", glyph_count, total_advance); + println!("1-space: glyphs={} advance={:.2}", single_count, single_advance); + println!( + "diff={:.2} (expect ~3 space widths if NOT collapsed)", + total_advance - single_advance + ); + + let one_space = parley.layout_paragraph(" ", 9.0, 10.0 / 9.0, Some(500.0)); + let mut space_w = 0.0f32; + for line in one_space.lines() { + for item in line.items() { + if let parley::PositionedLayoutItem::GlyphRun(gr) = item { + for g in gr.positioned_glyphs() { + space_w = g.advance; + } + } + } + } + println!("single space advance={:.2}", space_w); + println!( + "VERDICT: {}", + if (total_advance - single_advance - 3.0 * space_w).abs() < 1.0 { + "SPACES PRESERVED (not collapsed)" + } else { + "SPACES COLLAPSED" + } + ); + + let nl_text = "line1\nline2"; + let nl_layout = parley.layout_paragraph(nl_text, 9.0, 10.0 / 9.0, Some(500.0)); + let nl_lines = nl_layout.lines().count(); + println!("\nnewline test: \"line1\\nline2\" → {} line(s)", nl_lines); + println!( + "VERDICT: {}", + if nl_lines == 1 { + "\\n FOLDED TO SPACE (need breaks mechanism)" + } else { + "\\n TREATED AS LINE BREAK" + } + ); +} diff --git a/layout-engine/schema/README.md b/layout-engine/schema/README.md new file mode 100644 index 00000000..d56b588b --- /dev/null +++ b/layout-engine/schema/README.md @@ -0,0 +1,67 @@ +# layout-engine schema：guidenh_layout.fbs 生成链路与变更策略 + +> 本文档由架构审计行动表 A5 补齐，是"动 schema"类任务的前置阅读材料。 + +## 1. Schema 位置与命名空间 + +- Schema 文件：`layout-engine/schema/guidenh_layout.fbs`（555 行，38 个 table） +- namespace：`com.hfstudio.guidenh.guide.layout.flatbuffers` +- 数据合约方向：Java 侧序列化 → Rust 侧（layout-engine）消费 +- Java 生成类检入位置：`src/main/java/com/hfstudio/guidenh/guide/layout/flatbuffers/`（38 个 .java，与 38 个 table 一一对应） + +## 2. 生成链路现状 + +### Rust 侧（自动） +- `layout-engine/build.rs` 在 cargo build 时调用 `flatc` crate 提供的二进制（`flatc::flatc()`），执行： + `flatc --rust -o layout-engine/src layout-engine/schema/guidenh_layout.fbs` +- 输出 `layout-engine/src/guidenh_layout_generated.rs`，随后 build.rs 自动打补丁： + 1. 删除所有 `extern crate flatbuffers;`（Rust 2021 自动导入 extern crate） + 2. 把 `use self::flatbuffers::` 改为 `use ::flatbuffers::`（`self::flatbuffers` 在 `mod flatbuffers { }` 内指模块而非 crate） +- 因此 Rust 侧无需手工再生成。 + +### Java 侧（手工/脚本） +- 生成方式：`tools/regen_java_flatc.bat` —— 定位 flatc → 校验版本 → `flatc --java` 生成到临时目录 → 与检入类比对 → 不一致时覆盖（`--dry-run` 只预览，`--check-only` 供 CI 校验）。 +- **切勿手改生成类**。历史教训：commit `2b547572` / `b52e2ab1` 曾手工改生成类，造成检入类与 schema 漂移。 + 现状核查（2026-08-02）：`TextData.java` 仍残留手改痕迹 —— R4-17 文档注释与 `addAlignment`/`addSeparator` 调用顺序与 flatc 输出不一致；运行脚本 apply 模式会将其归一。本次审计不代改。 +- flatc 唯一来源：cargo `flatc` crate 构建产物 + `E:/build_out/guide_nh_rust/{debug,release}/build/flatc-*/out/bin/flatc.exe`（实测版本 23.5.26）。 + Gradle 侧无 flatc 配置（全仓 grep 无结果），Gradle 构建不会自动再生成 Java 类。 + +## 3. 变更流程（改 schema 的标准步骤） + +1. 修改 `layout-engine/schema/guidenh_layout.fbs`（必须遵守 wire-compat，见 §5） +2. 重新生成 Java 类： + - 预览差异：`tools\regen_java_flatc.bat --dry-run` + - 应用覆盖：`tools\regen_java_flatc.bat`（无参数 = 覆盖式再生成） + - CI/手动同步校验：`tools\regen_java_flatc.bat --check-only`（不一致 exit 1） +3. Rust 侧无需操作：build.rs 在下次 cargo build 时自动再生成 + 打补丁 +4. 跑 gate：`./gradlew compileJava compileTestJava test runLayoutDump` +5. 提交（schema + Java 生成类 + Rust 生成 rs 同一 commit） + +## 4. 版本策略 + +- flatc 必须为 **23.5.26**，与运行时 `flatbuffers-java` 23.5.26 完全一致。 +- 生成的每个 Java 类含版本守卫：`ValidateVersion() { Constants.FLATBUFFERS_23_5_26(); }`，与运行时版本不符会在反序列化入口处失败。 +- 升级 flatbuffers-java 运行时**必须同步**：升级 flatc → 重新生成全部 38 个类 → 跑 gate。 +- `tools/regen_java_flatc.bat` 内置版本校验：`flatc --version` 不含 `23.5.26` 直接报错退出。 + +## 5. Wire-compat 策略 + +- schema 变更必须 **append-only**：只加字段/表，不删字段、不改类型、不改字段语义。 +- 字段弃用约定：**keep field, write zero** —— 字段保留在 schema（vtable 槽位不变），写入侧传 0/默认值。 +- DEPRECATED 先例清单（4 个字段名 / 5 处，行号为 2026-08-02 快照，随变更漂移）： + + | 表 | 字段 | 位置 | + |---|---|---| + | `TextData` | `bands` | guidenh_layout.fbs:106 | + | `TextData` | `float_clips` | guidenh_layout.fbs:108 | + | `PieChartData` | `chrome_height` | guidenh_layout.fbs:221 | + | `ChartData` | `chrome_height` | guidenh_layout.fbs:241 | + | `MediaWikiSpecialGeneratedData` | `max_content_height` | guidenh_layout.fbs:290 | + +- 上述字段当前语义：写入侧传 0/默认，Rust 侧已改为内部计算（parley 迁移、chrome、maxColumnHeight）。 + +## 6. 第二生成集（不在本脚本范围） + +- `src/main/java/guideme/flatbuffers/scene/`（16 个 `Exp*` 类：`ExpScene`、`ExpMesh`、`ExpMaterial` 等）来自上游 GuideME schema。 +- 本仓库**无对应 .fbs 源**，`tools/regen_java_flatc.bat` 不覆盖该类；改动需在上游工程完成。 diff --git a/layout-engine/schema/guidenh_layout.fbs b/layout-engine/schema/guidenh_layout.fbs new file mode 100644 index 00000000..a89e58fd --- /dev/null +++ b/layout-engine/schema/guidenh_layout.fbs @@ -0,0 +1,570 @@ +/// GuideNH FlatBuffer schema — 定义 Java ↔ Rust 数据合约 +/// 生成命令: flatc --rust -o src/ schema/guidenh_layout.fbs + +namespace com.hfstudio.guidenh.guide.layout.flatbuffers; + +// ═══════════════════ 通用类型 ═══════════════════ + +/// 尺寸：Auto | Points | Percent +table Dimension { + value: float = 0.0; + unit: byte = 0; // 0=Auto 1=Points 2=Percent +} + +// ═══════════════════ Style ═══════════════════ + +table Style { + display: byte = 0; // 0=Flex 1=Grid 2=Block 3=None + flex_direction: byte = 1; // 0=Row 1=Column + flex_wrap: byte = 0; // 0=NoWrap 1=Wrap + align_items: byte = 0; // 0=Start 1=Center 2=End 3=Stretch 4=Baseline + align_self: byte = 0; // 0=Auto 1=Start 2=Center 3=End 4=Stretch + justify_content: byte = 0; // 0=Start 1=Center 2=End 3=SpaceBetween 4=SpaceAround 5=SpaceEvenly + gap_w: Dimension; + gap_h: Dimension; + size_w: Dimension; + size_h: Dimension; + min_w: Dimension; + min_h: Dimension; + max_w: Dimension; + max_h: Dimension; + aspect_ratio: float = 0.0; + margin_left: float = 0.0; + margin_right: float = 0.0; + margin_top: float = 0.0; + margin_bottom: float = 0.0; + margin_auto_left: bool = false; + margin_auto_right: bool = false; + margin_auto_top: bool = false; + margin_auto_bottom: bool = false; + padding_left: float = 0.0; + padding_right: float = 0.0; + padding_top: float = 0.0; + padding_bottom: float = 0.0; + border_left: float = 0.0; + border_right: float = 0.0; + border_top: float = 0.0; + border_bottom: float = 0.0; + overflow: byte = 0; // 0=Visible 1=Hidden 2=Scroll + flex_grow: float = 0.0; + flex_shrink: float = 1.0; + flex_basis: Dimension; + float: byte = 0; // 0=None 1=Left 2=Right + clear: byte = 0; // 0=None 1=Left 2=Right 3=Both + position: byte = 0; // 0=Relative 1=Absolute + inset_top: Dimension; + inset_right: Dimension; + inset_bottom: Dimension; + inset_left: Dimension; +} + +// ═══════════════════ TextStyle ═══════════════════ + +table TextStyle { + font_size: float = 14.0; + bold: bool = false; + italic: bool = false; + font_scale: float = 1.0; + color: uint = 0xFFFFFFFF; + font: uint = 0; + underline: bool = false; + strikethrough: bool = false; + highlight_argb: uint = 0; // span background fill (0 = none) + inline_code: bool = false; // highlight geometry variant (no side padding) + baseline_shift: float = 0.0; // R4-21: vertical offset in EM (fraction of font_size×font_scale); sup=-0.3 sub=+0.3 + wavy_underline: bool = false; // T1: wavy underline decoration (Rust emits DecorationRect kind 4) + dotted_underline: bool = false; // T1: dotted underline decoration (Rust emits DecorationRect kind 5) +} + +// ═══════════════════ 节点数据类型 ═══════════════════ + +/// Inline block reference: pairs a U+FFFC placeholder (in document order) with +/// the inner block's flat index and its vertical alignment request. +/// align: 0 = block bottom sits 2px below the text baseline (default) +/// 1 = baseline ascent — block top sits `param` px above the text baseline +/// (LaTeX math-baseline alignment: param = formula ascent above its +/// math baseline, so the formula's baseline lands on the text's) +/// 2 = center on the text line, then shift down by `param` px (item icons) +/// 3 = float left — block floats to paragraph left edge, text wraps right +/// 4 = float right — block floats to paragraph right edge, text wraps left +table InlineBlockRef { + node: uint; + align: byte = 0; + param: float = 0.0; +} + +/// One styled run of a rich paragraph: `text` concatenated over all spans +/// equals TextData.text (same document order, U+FFFC placeholders included). +table TextSpan { + text: string; + style: TextStyle; +} + +table TextData { + text: string; + style: TextStyle; + white_space: byte = 0; // 0=Normal 1=PreWrap + inline_blocks: [InlineBlockRef]; // paired with U+FFFC placeholders, in document order + bands: [TextBand]; // DEPRECATED (parley migration): replaced by float_clips + spans: [TextSpan]; // rich multi-style runs (empty = single-style shaping) + float_clips: [FloatClip]; // DEPRECATED: per-line wrapping now owned by the Rust pusher's live float table + clears: [ClearBreak]; // in-paragraph
breaks (raw UTF-8 byte offset + side) + breaks: [uint]; // raw UTF-8 byte offsets of every in-paragraph
(hard line break); + // the Rust pusher splits the paragraph at these offsets and shapes + // each piece independently (a hard break, not a whitespace char), so + //
works under any white-space mode and PRE_WRAP code bodies keep + // their line structure. Coordinates are in the break-free text. + separator: bool = false; // T6b-4: heading paragraph (depth 1/2) — Rust emits a kind=3 + // DecorationRect for the last line's full float-compressed window + // so Java can draw a themed separator across the real text area. + alignment: byte = 0; // R4-17: per-paragraph text alignment. + // 0=Start(Left) 1=Center 2=End(Right) +} + +/// One in-paragraph clear break (`
`). `raw_offset` is the +/// UTF-8 byte offset into TextData.text (the original text, U+FFFC included) +/// at which the break occurs; the Rust pusher maps it to its cleaned text and, +/// after the line covering that offset is laid out, drops subsequent lines to +/// the cleared floats' bottom edge. side: 1=left 2=right 3=both. +table ClearBreak { + raw_offset: uint = 0; + side: byte = 0; +} + +/// One forbidden interval the text must not occupy, in paragraph-relative +/// coordinates (typically a float's rect ∩ the paragraph). The Rust line +/// breaker subtracts clips from the available width per line: x<=0 is a +/// left-side clip (text starts right of x+width), otherwise a right-side +/// clip (text ends at x). +table FloatClip { + y_top: float = 0.0; + y_bottom: float = 0.0; + x: float = 0.0; + width: float = 0.0; +} + +/// One float-wrap band: the paragraph's text is shaped in sequential bands at +/// per-band widths (CSS float wrapping: narrow beside the float, full width +/// below it). Bands are ordered; the first band starts at split_byte 0, each +/// later band starts at its split_byte and continues to the next band's start. +table TextBand { + split_byte: uint = 0; // start byte offset (UTF-8) of this band's text + width: float = 0.0; // shaping width for this band (px) + margin_left: float = 0.0; // extra left inset for this band's glyphs +} + +table ImageData { + natural_w: float; + natural_h: float; + crop_x: int = 0; + crop_y: int = 0; + crop_w: int = -1; + crop_h: int = -1; + scale_x: float = 1.0; + scale_y: float = 1.0; + explicit_w: float = -1.0; + explicit_h: float = -1.0; +} + +table SlotData { + slot_size: float = 18.0; +} + +table ThematicBreakData { + height: float = 6.0; +} + +table CustomData { + type_id: uint; // Rust 消费: LatexDisplay(8) + // Java-only: MediaWiki/Mermaid/StructureView/Chart/Scene3D/Mindmap/ContentTabs/RecipeBox + payload: [ubyte]; +} + +table LatexDisplayData { + formula: string; + fill_color_argb: uint = 0xFFFFFFFF; + source_scale: float = 100.0; + user_scale: float = 1.0; + offset_x: int = 0; + offset_y: int = 0; + raw_w: float; + raw_h: float; + ref_h: float; +} + +table RecipeBoxData { + /// Handler-reported body content width (px), from registry.lookupRecipeHandlerWidth. + body_width: float; + /// Resolved body content height (px), from NeiRecipeLayoutMetrics.resolveBodyHeight. + body_height: float; + /// Additional top inset for GregTech handler (0 for normal handlers). + body_top_inset: float = 0.0; + /// Vertical shift applied by the handler registry. + body_y_shift: float = 0.0; + /// Title text pixel width, computed via Minecraft font metrics (Java-only). + title_text_width: float; + /// Icon display size: 8 if an icon (stack or image) is present, else 0. + icon_size: float; + /// Whether the action button (jump to NEI) is shown. + recipe_jump_enabled: bool = false; + /// Title bar height = Math.max(ICON_SIZE, FONT_HEIGHT) + TITLE_PAD_TOP + TITLE_PAD_BOTTOM. + title_height: float; +} + +table PieChartData { + /// preferred_width = (explicitWidth > 0 ? explicitWidth : DEFAULT_WIDTH) + extraPlotWidth. + /// Java-precomputed input to the sizing formula. + preferred_width: float; + /// total_height = explicitHeight > 0 ? explicitHeight : DEFAULT_HEIGHT. + /// Java-precomputed height baseline (before body scaling). + total_height: float; + /// DEPRECATED: Rust now computes chrome internally from the final width w. + /// Kept for backward compatibility with old serialized data. + chrome_height: float; + /// Title lineHeight(TITLE_STYLE) + TITLE_GAP; 0 if no title (width-independent). + title_chrome: float = 0.0; + /// Legend position: 0=NONE 1=TOP 2=BOTTOM 3=LEFT 4=RIGHT. + legend_position: byte = 0; + /// Row height for legend wrapping: max(LEGEND_SWATCH_SIZE, lineHeight(LEGEND_LABEL_STYLE)). + legend_row_height: float = 10.0; + /// Per-entry legend label widths: LEGEND_SWATCH_SIZE + SWATCH_TEXT_GAP + measureWidth(label, style). + legend_label_widths: [float]; +} + +/// Generic Cartesian chart sizing data (Bar/Column/Line/Scatter). +/// Same fields as PieChartData, kept as a separate table so node_type 21 +/// (PieChart) retains backward compatibility. node_type 22 (BarChart) and +/// future Cartesian charts use this table. +table ChartData { + preferred_width: float; + total_height: float; + /// DEPRECATED: Rust now computes chrome internally from the final width w. + /// Kept for backward compatibility with old serialized data. + chrome_height: float; + /// Title lineHeight(TITLE_STYLE) + TITLE_GAP; 0 if no title (width-independent). + title_chrome: float = 0.0; + /// Legend position: 0=NONE 1=TOP 2=BOTTOM 3=LEFT 4=RIGHT. + legend_position: byte = 0; + /// Row height for legend wrapping: max(LEGEND_SWATCH_SIZE, lineHeight(LEGEND_LABEL_STYLE)). + legend_row_height: float = 10.0; + /// Per-entry legend label widths: LEGEND_SWATCH_SIZE + SWATCH_TEXT_GAP + measureWidth(label, style). + legend_label_widths: [float]; +} + +/// Isometric structure view sizing data (node_type 26). +/// Mirrors LytStructureView.computeLayout: view_width/view_height are the +/// block's intrinsic dimensions (setViewSize or DEFAULT_WIDTH/HEIGHT), used +/// by the Rust measure function with visual_scale and available_width to +/// compute the responsive box. +table StructureViewData { + view_width: float; + view_height: float; +} + +/// Function graph sizing data (node_type 28). +/// Mirrors LytFunctionGraph.computeLayout term for term. +/// Minecraft-dependent values (label widths, line heights) are precomputed +/// by Java; Rust applies the responsive formula (scale_width, legend +/// wrapping, scale_body_height_for_width) with available_width and visual_scale. +table FunctionGraphData { + /// Intrinsic base width: explicitWidth > 0 ? explicitWidth : DEFAULT_WIDTH. + base_width: float; + /// Intrinsic base height: explicitHeight > 0 ? explicitHeight : DEFAULT_HEIGHT. + base_height: float; + /// lineHeight(TITLE_STYLE) + TITLE_GAP if title present and non-empty, else 0. + title_chrome: float; + /// Row height for legend wrapping: max(LEGEND_SWATCH_SIZE, lineHeight(LEGEND_LABEL_STYLE)). + legend_row_height: float; + /// Per-plot legend item widths (0 for plots without labels): + /// LEGEND_SWATCH_SIZE + LEGEND_SWATCH_TEXT_GAP + measureWidth(label, style). + label_item_widths: [float]; +} + +/// MediaWiki special generated block sizing data (node_type 30). +/// Java passes width-independent font facts (title widths, subtitle word widths, +/// line heights, estimated heights). Rust computes columnWidth from availableWidth, +/// wraps subtitle words per entry, packs columns (shortest-column-first), and +/// produces maxColumnHeight. Width is always availableWidth — the block fills +/// the parent's content box. +table MediaWikiSpecialGeneratedData { + /// DEPRECATED (T6b-2): Rust now computes maxColumnHeight internally. + /// Kept for backward compatibility with old serialized data. + max_content_height: float; + + // ═══════════════════ Width-independent layout constants ═══════════════════ + + /// resolveColumnCount result (depends only on definition.name()/kind). + column_count: int = 1; + /// hasMore flag from the visible result: adds LOAD_MORE_HEIGHT after the + /// column content when true. + has_more: bool = false; + /// Number of groups (for grouped/group-index kinds; flat builds one group + /// per column, see group_flat_entry_count). + group_count: int = 0; + + /// Per-group title measureWidth: 0 means no title (no header row). + /// Length = group_count. + group_title_widths: [float]; + /// Per-group entry count in the visible result's entry order. + /// Length = group_count. + group_entry_counts: [int]; + /// Per-group estimated total height (estimateHeight), width-independent, + /// used by Rust's shortest-column-first packing. Length = group_count. + group_estimated_heights: [float]; + + /// Total number of entries across all groups. Entries are indexed 0..N-1 + /// in the order they appear in the visible result (group-major). + total_entry_count: int = 0; + + /// Per-entry title pixel width: measureWidth(title, LINK_STYLE). + /// Width-independent font fact. Length = total_entry_count. + entry_title_widths: [float]; + /// Per-entry icon presence (1 = has icon). Length = total_entry_count. + entry_has_icon: [byte]; + /// Per-entry estimated height (estimateEntryHeight), width-independent. + /// Length = total_entry_count. + entry_estimated_heights: [float]; + /// Per-entry raw subtitle line count (GuideStringLines.splitLines result, + /// 0 = no subtitle). Length = total_entry_count. + entry_subtitle_line_counts: [int]; + + /// Per-raw-subtitle-line word count (GuideStringLines.splitLines then + /// split by \\s+) — concatenated across all entries' raw lines. + subtitle_line_word_counts: [int]; + /// Per-word pixel width (measureWidth(word, SUBTITLE_STYLE)) — concatenated + /// across all words of all raw lines of all entries. + subtitle_word_widths: [float]; + /// Width of a space character in SUBTITLE_STYLE (for word-gap calculations). + subtitle_space_width: float = 4.0; + + /// Line height of LINK_STYLE — GuideText.lineHeight(LINK_STYLE) (= 17 at + /// scale 1). Mirrors Java computeEntryHeight's getLineHeight(LINK_STYLE) / + /// rowContentHeight's GuideText.lineHeight(rowStyle). Default 10.0 keeps + /// old serialized data (which lacked this field) rendering as before. + link_line_height: float = 10.0; + /// Line height of SUBTITLE_STYLE — GuideText.lineHeight(SUBTITLE_STYLE) + /// (= 17 at scale 1). Mirrors Java computeEntryHeight/rowContentHeight's + /// GuideText.lineHeight(SUBTITLE_STYLE). Default 10.0 keeps old serialized + /// data (which lacked this field) rendering as before. + subtitle_line_height: float = 10.0; +} + +/// MediaWiki generated list sizing data (node_type 29). +/// Mirrors MediaWikiGeneratedListBlock.computeLayout term for term. +/// The column-planning algorithm depends on Java object data (entry sort keys, +/// titles, section grouping); Rust cannot replicate it. Java precomputes the +/// max column content height (the tallest column's content, excluding +/// TOP_PADDING/BOTTOM_PADDING) via a getter set during computeLayout. +/// Rust adds the padding constants to produce the total block height. +/// Width is always availableWidth — the block fills the parent's content box. +table MediaWikiGeneratedListData { + /// Content height of the tallest column (not including TOP_PADDING=6 and + /// BOTTOM_PADDING=6). When entries are empty, this is ROW_HEIGHT=20. + /// Mirrors maxColumnHeight or ROW_HEIGHT in computeLayout, which is the + /// max over columns of (columnY - y - TOP_PADDING). + max_content_height: float; +} + +/// Guidebook scene sizing data (node_type 27). +/// Mirrors LytGuidebookScene.computeLayout term for term. +/// Minecraft-dependent values (block stats geometry, button visibility, +/// bottom control areas) are precomputed by Java; Rust applies the +/// responsive scene sizing formula (scale_width, dock clamping, +/// computeResponsiveSceneHeight) with available_width and visual_scale. +table GuidebookSceneData { + /// Intrinsic scene pixel width (setSceneSize or DEFAULT_WIDTH = 256). + scene_width: float; + /// Intrinsic scene pixel height (setSceneSize or DEFAULT_HEIGHT = 192). + scene_height: float; + /// Horizontal space reserved for the floating button column: + /// interactive && sceneButtonsVisible ? (BTN_OUTSIDE_GAP + BTN_SIZE) : 0. + button_column_reserve: float; + /// Total pixel height of scene buttons when stacked vertically: + /// interactive && sceneButtonsVisible ? (BTN_SIZE * count + BTN_GAP * max(0, count-1)) : 0. + buttons_total_height: float; + /// Block-stats left dock size + BLOCK_STATS_DOCK_GAP, or 0. + left_dock: float; + /// Block-stats right dock size + BLOCK_STATS_DOCK_GAP, or 0. + right_dock: float; + /// Block-stats top dock size + BLOCK_STATS_DOCK_GAP, or 0. + top_dock: float; + /// Block-stats bottom dock size + BLOCK_STATS_DOCK_GAP, or 0. + bottom_dock: float; + /// Bottom control area height from getBottomControlAreaHeight(). + bottom_control_area_height: float; + /// Whether the layout should reserve room for bottom controls. + reserve_bottom_control: bool = false; +} + +// ═══════════════════ 布局树节点 ═══════════════════ + +table FlatNode { + style: Style; + node_type: byte = 0; // 0=Container 1=Text 2=Image 3=Slot + // 4=ThematicBreak 5=Custom 6=FileTree + // 7=Table 8=Latex 20=RecipeBox 21=PieChart 22=BarChart + // 23=ColumnChart 24=LineChart 25=ScatterChart 26=StructureView + // 27=GuidebookScene (Rust MeasureFunc) + // 28=FunctionGraph (Rust MeasureFunc) + // 29=MediaWikiGeneratedList (Rust MeasureFunc) + // 30=MediaWikiSpecialGenerated (Rust MeasureFunc) + text: TextData; + image: ImageData; + slot: SlotData; + break_: ThematicBreakData; + custom: CustomData; + latex: LatexDisplayData; + custom_layout: byte = 0; // 0=None 1=ItemGrid 2=SlotGrid + children: [uint]; + recipe_box: RecipeBoxData; // node_type 20: NEI recipe box sizing data + pie_chart: PieChartData; // node_type 21: Pie chart sizing data + chart_data: ChartData; // node_type 22: Cartesian chart sizing data (Bar/Column/Line/Scatter) + structure_view_data: StructureViewData; // node_type 26: StructureView sizing data + guidebook_scene_data: GuidebookSceneData; // node_type 27: GuidebookScene sizing data + function_graph_data: FunctionGraphData; // node_type 28: FunctionGraph sizing data + mediawiki_generated_list_data: MediaWikiGeneratedListData; // node_type 29: MediaWikiGeneratedList sizing data + mediawiki_special_generated_data: MediaWikiSpecialGeneratedData; // node_type 30: MediaWikiSpecialGeneratedBlock sizing data +} + +// ═══════════════════ measureLayout 输入/输出 ═══════════════════ + +table LayoutInput { + available_width: float; + visual_scale: float = 1.0; + render_scale: float = 1.0; // display pixel ratio (MC guiScale) for hi-res glyph bitmaps + justify: byte = 1; // 0=off 1=auto (justify Latin-dominant lines by stretching spaces) + nodes: [FlatNode]; +} + +table LayoutResult { + nodes: [FlatLayout]; + glyph_runs: [GlyphRun]; + bitmaps: [GlyphBitmap]; + decorations: [DecorationRect]; + content_height: float; + debug_info: string; +} + +table FlatLayout { + x: float; + y: float; + w: float; + h: float; + order: uint = 0; +} + +/// One glyph run of a paragraph, grouped by span: `argb` tints the (white) +/// atlas bitmaps, `shear` asks the engine for a synthetic-italic slant. +/// Default values keep legacy single-style runs white and unslanted. +table GlyphRun { + node_index: uint; + glyphs: [PlacedGlyph]; + argb: uint = 0xFFFFFFFF; + shear: bool = false; +} + +/// A decoration rectangle in absolute document coordinates (top-left origin), +/// derived from a span's glyph extents: kind 0 = background (highlight / +/// inline-code), 1 = underline, 2 = strikethrough. +table DecorationRect { + node: uint = 0; + x: float; + y: float; + w: float; + h: float; + argb: uint; + kind: byte = 0; +} + +/// A glyph quad in absolute document coordinates (top-left origin). +/// w/h are the bitmap dimensions divided by render_scale (i.e. document units). +/// start/end are the glyph's byte range in the source text (for band-split +/// computations; 0 when not meaningful). +table PlacedGlyph { + bitmap_key: ulong; // opaque dedupe key into LayoutResult.bitmaps + x: float; + y: float; + w: float; + h: float; + start: uint = 0; + end: uint = 0; + line_index: uint = 0; // visual (wrapped) line index within the shaped buffer +} + +/// A unique rasterized glyph bitmap, at render_scale resolution. +/// Placement is already baked into the owning PlacedGlyph's quad. +table GlyphBitmap { + key: ulong; + w: uint; + h: uint; + rgba: [ubyte]; +} + +// ═══════════════════ rasterizeGlyphs 输入/输出 ═══════════════════ + +table RasterInput { + requests: [FontRequest]; +} + +table FontRequest { + font_id: uint; + font_size: float; + glyph_ids: [uint]; + pos_x: [float]; // document X positions, same length as glyph_ids + pos_y: [float]; // document Y positions +} + +table RasterResult { + glyphs: [GlyphPixels]; +} + +table GlyphPixels { + font_id: uint; + font_size: float; + glyph_id: uint; + width: uint; + height: uint; + rgba: [ubyte]; +} + +// ═══════════════════ renderText (combined shape + rasterize) ═══════════════════ + +// ═══════════════════ shapeText (unified text pipeline) ═══════════════════ + +/// One-off text shaping for the GuideText unified entry: same shaping and +/// rasterization as the layout pipeline's text path, returning atlas-keyed +/// quads (buffer-local, origin = text top-left) so Java can reuse the shared +/// glyph atlas and DrawGlyphRun execution as-is. +table ShapeTextInput { + text: string; + style: TextStyle; + max_width: float = -1.0; // <= 0: no wrapping + render_scale: float = 1.0; // display pixel ratio for hi-res bitmaps +} + +table ShapeTextResult { + width: float; + height: float; + ascent: float; // first-line baseline offset below the line top + line_height: float; + glyphs: [PlacedGlyph]; // buffer-local quads (origin = text top-left) + bitmaps: [GlyphBitmap]; + x_height: float = 0.0; // T4: baseline->lowercase x top, shaped-size px (first run); Rust fallback ascent*0.625 + cap_height: float = 0.0; // T4: baseline->cap top, shaped-size px (first run); Rust fallback ascent*0.7 +} + +table RenderGlyph { + x: int; // pixel X (SubpixelBin integer + placement, no rounding needed) + y: int; // pixel Y + w: uint; // bitmap width + h: uint; // bitmap height + rgba: [ubyte]; // RGBA pixel data +} + +table RenderResult { + width: float; // total content width + height: float; // total content height + glyphs: [RenderGlyph]; +} + +root_type LayoutInput; diff --git a/layout-engine/src/jni_bridge.rs b/layout-engine/src/jni_bridge.rs new file mode 100644 index 00000000..6eb06ea6 --- /dev/null +++ b/layout-engine/src/jni_bridge.rs @@ -0,0 +1,24 @@ +use jni::JNIEnv; +use jni::objects::JByteArray; + +/// Convert JNI jbyteArray to Rust Vec. +pub fn jbytearray_to_vec( + env: &mut JNIEnv, + array: &JByteArray, +) -> Result, jni::errors::Error> { + let size = env.get_array_length(array)? as usize; + let mut buf = vec![0i8; size]; + env.get_byte_array_region(array, 0, &mut buf)?; + Ok(buf.iter().map(|&b| b as u8).collect()) +} + +/// Convert Rust &[u8] to JNI jbyteArray. +pub fn vec_to_jbytearray( + env: &mut JNIEnv, + data: &[u8], +) -> Result { + let arr = env.new_byte_array(data.len() as i32)?; + let data_i8: Vec = data.iter().map(|&b| b as i8).collect(); + env.set_byte_array_region(&arr, 0, &data_i8)?; + Ok(arr.into_raw()) +} diff --git a/layout-engine/src/layout.rs b/layout-engine/src/layout.rs new file mode 100644 index 00000000..04987f15 --- /dev/null +++ b/layout-engine/src/layout.rs @@ -0,0 +1,1045 @@ +use std::collections::HashMap; + +use crate::fb::{ + DecorationRect, DecorationRectArgs, FlatLayout, FlatLayoutArgs, FlatNode, GlyphBitmap, + GlyphBitmapArgs, GlyphRun, GlyphRunArgs, LayoutInput, LayoutResult, LayoutResultArgs, + PlacedGlyph, PlacedGlyphArgs, +}; +use crate::measure::{create_measure_closure, measure_text, GlyphAccum, NodeContext}; +use crate::parley_text::{FloatRect, ParleyRasterGlyph}; +use crate::style_convert::flat_style_to_taffy; +use crate::text::GuideFontSystem; +use flatbuffers::FlatBufferBuilder; +use taffy::prelude::*; + +/// Document content-box padding, matching the legacy synthetic root and the +/// Java document padding (14px each side). +const CONTENT_PAD: f32 = 14.0; + +/// Synthetic-italic shear factor — MUST stay identical to the engine's +/// `GuideRenderEngine.GLYPH_SHEAR_K` (0.25f). The draw-time shear moves each +/// glyph's top edge right by `K × (baseY − y_top)` (see +/// italic_kerning_compensate below). The Java constant is the single source +/// of truth; this is the layout-side mirror so the compensation and the draw +/// transform share the same slant parameter. +const GLYPH_SHEAR_K: f32 = 0.25; + +/// Compute the available horizontal lane (absolute x and width) for a block +/// at the given absolute Y, consulting the float table. If floats fully +/// block the lane at start_y, push down past the nearest blocking float's +/// bottom and retry. Returns (lane_x, lane_width, adjusted_y). +/// +/// Mirrors the Java LytFloatAwareBlock.computeLayout loop: +/// query left/right floats at the current Y; if the resulting lane has +/// positive width, use it; otherwise find the next float bottom below and +/// skip to it. +fn compute_lane( + start_y: f32, + content_x: f32, + content_w: f32, + float_table: &[FloatRect], +) -> (f32, f32, f32) { + let mut lane_y = start_y; + loop { + let mut x0 = content_x; + let mut x1 = content_x + content_w; + let mut max_bottom: Option = None; + for f in float_table { + if f.y + f.h <= lane_y || f.y >= lane_y + 1.0 { + continue; + } + if f.right { + x1 = x1.min(f.x); + } else { + x0 = x0.max(f.x + f.w); + } + let b = f.y + f.h; + max_bottom = Some(max_bottom.map_or(b, |p| p.max(b))); + } + let lane_w = x1 - x0; + if lane_w > 0.0 { + return (x0, lane_w, lane_y); + } + // Fully blocked — jump below the blocking floats. + match max_bottom { + Some(b) => lane_y = b, + None => return (content_x, content_w, lane_y), + } + } +} + +/// Document-flow pusher (v1). Owns the single authoritative float table and +/// drives the top-level sequence in document order: top-level paragraphs are +/// shaped directly against the live table (real per-line wrapping — the +/// "bridge" is this in-process query, no precomputed clip table crosses any +/// boundary); top-level floats register into the table at the current cursor +/// without advancing it; top-level blocks are laid out as taffy subtrees. +/// Nested paragraphs inside those subtrees still wrap at full width (the +/// pusher does not yet recurse into block float contexts — transition). +pub fn compute_layout( + input_bytes: &[u8], + font_system: &mut GuideFontSystem, +) -> Vec { + let input = flatbuffers::root::(input_bytes) + .expect("Invalid LayoutInput FlatBuffer"); + + let avail_width = input.available_width(); + // NB: visual_scale is intentionally NOT applied to the root width (D-3) — + // Java blocks already pre-apply it per block (ResponsiveVisualSizing). + let visual_scale = input.visual_scale(); + // Display pixel ratio (MC guiScale): glyph bitmaps are rasterized at + // font_size * render_scale so 1 texel maps to 1 physical pixel; quad + // coordinates are then divided back into document units. + let render_scale = input.render_scale().max(0.25); + let fb_nodes = input.nodes(); + let justify = input.justify() != 0; + + let flat_nodes: Vec = fb_nodes + .map_or_else(Vec::new, |v| (0..v.len()).map(|i| v.get(i)).collect()); + + let content_x = CONTENT_PAD; + let content_y = CONTENT_PAD; + let content_w = (avail_width - 2.0 * CONTENT_PAD).max(1.0); + + // Document-top sequence = flat nodes not claimed as any container's child + // (the orphans the legacy synthetic root adopted; the pusher drives them). + let mut claimed = vec![false; flat_nodes.len()]; + for fb in flat_nodes.iter() { + if let Some(ch) = fb.children() { + for ci in ch.iter() { + claimed[ci as usize] = true; + } + } + } + let top_seq: Vec = (0..flat_nodes.len()).filter(|i| !claimed[*i]).collect(); + + let mut taffy: TaffyTree = TaffyTree::new(); + let mut abs_positions: Vec<(f32, f32)> = vec![(0.0, 0.0); flat_nodes.len()]; + let mut sizes: Vec<(f32, f32)> = vec![(0.0, 0.0); flat_nodes.len()]; + let mut glyph_acc: HashMap = HashMap::new(); + let mut float_table: Vec = Vec::new(); + let mut cursor: f32 = 0.0; + + for &idx in &top_seq { + let fb = &flat_nodes[idx]; + let (ml, mt, mr, mb, pos_abs, float_side, node_type) = match fb.style() { + Some(s) => ( + s.margin_left(), + s.margin_top(), + s.margin_right(), + s.margin_bottom(), + s.position() == 1, + s.float(), + fb.node_type(), + ), + None => (0.0, 0.0, 0.0, 0.0, false, 0, fb.node_type()), + }; + + if pos_abs { + // Inline block: position is assigned later by the inline post-pass; + // only its subtree size is needed here. + let (w, h, _sub) = build_subtree( + &mut taffy, + idx, + &flat_nodes, + font_system, + &mut glyph_acc, + justify, + visual_scale, + &mut abs_positions, + &mut sizes, + 0.0, + 0.0, + None, + ); + sizes[idx] = (w, h); + abs_positions[idx] = (0.0, 0.0); + continue; + } + + if float_side == 1 || float_side == 2 { + let right = float_side == 2; + let (w, h, sub) = build_subtree( + &mut taffy, + idx, + &flat_nodes, + font_system, + &mut glyph_acc, + justify, + visual_scale, + &mut abs_positions, + &mut sizes, + 0.0, + 0.0, + None, + ); + let fy = content_y + cursor; + let fx = if right { + content_x + content_w - w + } else { + content_x + }; + for &si in &sub { + abs_positions[si] = (abs_positions[si].0 + fx, abs_positions[si].1 + fy); + } + sizes[idx] = (w, h); + // The float's gap is expressed as the inner's margin (CSS-correct): + // the registered rectangle is the margin box, the drawn box is the + // content box. + float_table.push(FloatRect { + x: fx - ml, + y: fy - mt, + w: w + ml + mr, + h: h + mt + mb, + right, + }); + // A float does not advance the vertical cursor (zero flow height). + continue; + } + + if node_type == 1 { + // CSS-preposed margin: this paragraph's top margin opens the gap + // above its box, so the box starts at the already-advanced cursor + // (mirrors taffy subtrees and the legacy Java pusher). + cursor += mt; + let para_abs_y = content_y + cursor; + let para_x = content_x; + let avail = Size { + width: AvailableSpace::Definite(content_w), + height: AvailableSpace::MaxContent, + }; + let clears_raw: Vec<(usize, u8)> = flat_nodes[idx] + .text() + .and_then(|t| t.clears()) + .map(|v| { + v.iter() + .map(|c| (c.raw_offset() as usize, c.side() as u8)) + .collect() + }) + .unwrap_or_default(); + let (sz, clear_floor) = measure_text( + font_system, + &flat_nodes, + idx, + &mut glyph_acc, + avail, + justify, + &float_table, + para_abs_y, + para_x, + &clears_raw, + ); + abs_positions[idx] = (para_x, para_abs_y); + sizes[idx] = (sz.width, sz.height); + cursor += sz.height + mb; + // A trailing in-paragraph clear does not stretch this paragraph's + // box; it pushes the flow that follows it below the cleared float. + // Advance the cursor to that floor so the next block (a callout) + // starts below the float while this paragraph hugs its text. + if let Some(f) = clear_floor { + let f_rel = (f - content_y).max(0.0); + if f_rel > cursor { + cursor = f_rel; + } + } + continue; + } + + // Block container / image / slot / latex / break: compute the + // horizontal lane from the float table so blocks avoid overlapping + // with left/right floats (Java LytFloatAwareBlock behavior). + // CSS-preposed margin: advance past the top margin first, so the lane + // query and the block box both start at the margin box top. + cursor += mt; + let by = content_y + cursor; + let (lane_x, lane_w, lane_y) = + compute_lane(by, content_x, content_w, &float_table); + let (w, h, _sub) = build_subtree( + &mut taffy, + idx, + &flat_nodes, + font_system, + &mut glyph_acc, + justify, + visual_scale, + &mut abs_positions, + &mut sizes, + lane_x, + lane_y, + Some(lane_w), + ); + sizes[idx] = (w, h); + if let Some(c) = fb.style().map(|s| s.clear()) { + if c != 0 { + let mut cleared: f32 = 0.0; + for f in &float_table { + let side_match = + c == 3 || (c == 1 && !f.right) || (c == 2 && f.right); + if side_match { + cleared = cleared.max(f.y + f.h); + } + } + let cleared_rel = (cleared - content_y).max(0.0); + if cleared_rel > cursor { + cursor = cleared_rel; + } + } + } + // Advance cursor past the block. If compute_lane pushed the block + // down (lane_y > by), account for the gap; if CSS clear already + // pushed beyond that, respect the clear. + cursor = (lane_y - content_y).max(cursor) + h + mb; + } + + // Inline post-pass: anchor inline blocks at their parley InlineBox + // positions and grow lines vertically per their align modes. + inline_post_pass(&flat_nodes, &mut glyph_acc, &mut abs_positions, &mut sizes); + + // Content height = cursor plus any trailing float that extends below it. + let mut total_height = content_y + cursor; + for f in &float_table { + total_height = total_height.max(f.y + f.h); + } + + // ── Collect results ── + let mut fbb = FlatBufferBuilder::with_capacity(4096); + let mut flat_layout_offsets: Vec> = Vec::new(); + let mut glyph_run_offsets: Vec> = Vec::new(); + let mut decoration_offsets: Vec> = Vec::new(); + + let mut bitmap_keys: Vec = Vec::new(); + let mut bitmap_data: Vec<(u32, u32, Vec)> = Vec::new(); + let mut bitmap_index: std::collections::HashSet = std::collections::HashSet::new(); + + for (i, _fb_node) in flat_nodes.iter().enumerate() { + let (x, y) = abs_positions[i]; + let (w, h) = sizes[i]; + + flat_layout_offsets.push(FlatLayout::create( + &mut fbb, + &FlatLayoutArgs { + x, + y, + w, + h, + order: 0, + }, + )); + + if let Some(acc) = glyph_acc.remove(&i) { + let span_styles = span_style_table(&flat_nodes[i]); + let base_color = flat_nodes[i] + .text() + .and_then(|t| t.style()) + .map(|s| s.color()) + .unwrap_or(0xFFFFFFFF); + // Single-style paragraphs carry no TextData.spans (LayoutNodeSerializer + // needsRichSpans), so their run falls back to the base TextStyle — + // which already carries the resolved italic flag. Without this, a + // whole-paragraph italic never sets shear (the shear=false bug) and + // never gets the kerning compensation either. + let base_italic = flat_nodes[i] + .text() + .and_then(|t| t.style()) + .map(|s| s.italic()) + .unwrap_or(false); + let (quads, new_bitmaps) = + crate::parley_text::rasterize_out_glyphs(&acc.glyphs, render_scale); + for (key, bw, bh, rgba) in new_bitmaps { + if bitmap_index.insert(key) { + bitmap_keys.push(key); + bitmap_data.push((bw, bh, rgba)); + } + } + // Group rasterized quads by span (one GlyphRun per span, glyph + // order preserved within the run — parley emits a span's glyphs + // contiguously per line), then apply the synthetic-italic + // kerning compensation to sheared runs BEFORE emitting placed + // glyphs. baseY is run-wide (matching the engine's shearBaseY + // over the whole run), the cumulative shift accumulates per line + // (lines stack vertically, so a line's first glyph must not + // inherit the previous line's shift). + let mut run_quads: std::collections::BTreeMap< + u32, + Vec, + > = Default::default(); + for q in quads { + run_quads.entry(q.span_index).or_default().push(q); + } + let mut groups: std::collections::BTreeMap< + u32, + Vec>, + > = Default::default(); + for (si, mut rq) in run_quads { + if rq.is_empty() { + continue; + } + let italic = span_styles + .get(si as usize) + .map(|s| s.italic) + .unwrap_or(base_italic); + if italic { + italic_kerning_compensate(&mut rq); + } + let placed = rq + .into_iter() + .map(|q| { + PlacedGlyph::create( + &mut fbb, + &PlacedGlyphArgs { + bitmap_key: q.bitmap_key, + x: x + q.x, + y: y + q.y, + w: q.w, + h: q.h, + start: 0, + end: 0, + line_index: q.line_index, + }, + ) + }) + .collect::>(); + groups.insert(si, placed); + } + for (si, placed_offsets) in groups { + if placed_offsets.is_empty() { + continue; + } + let (argb, shear) = span_styles + .get(si as usize) + .map(|s| (s.color, s.italic)) + .unwrap_or((base_color, base_italic)); + let glyphs_vec = fbb.create_vector(&placed_offsets); + glyph_run_offsets.push(GlyphRun::create( + &mut fbb, + &GlyphRunArgs { + node_index: i as u32, + glyphs: Some(glyphs_vec), + argb, + shear, + }, + )); + } + emit_decorations( + &acc.glyphs, + &span_styles, + i as u32, + x, + y, + &mut fbb, + &mut decoration_offsets, + ); + // Emit separator-line window (kind=3) for heading paragraphs. + // The rect spans the full float-compressed line width, not just + // the glyph extents — Java LytHeading draws the themed separator + // across this interval. + if let Some((x_off, line_width)) = acc.last_line_window { + if flat_nodes[i].text().map(|t| t.separator()).unwrap_or(false) { + decoration_offsets.push(DecorationRect::create( + &mut fbb, + &DecorationRectArgs { + node: i as u32, + x: x + x_off, + y: 0.0, + w: line_width, + h: 0.0, + argb: 0, + kind: 3, + }, + )); + } + } + } + } + + let nodes_vec = fbb.create_vector(&flat_layout_offsets); + let glyph_runs_vec = fbb.create_vector(&glyph_run_offsets); + let decorations_vec = fbb.create_vector(&decoration_offsets); + + let mut bitmap_offsets: Vec> = Vec::new(); + for (i, (bw, bh, rgba)) in bitmap_data.iter().enumerate() { + let rgba_vec = fbb.create_vector(rgba); + bitmap_offsets.push(GlyphBitmap::create( + &mut fbb, + &GlyphBitmapArgs { + key: bitmap_keys[i], + w: *bw, + h: *bh, + rgba: Some(rgba_vec), + }, + )); + } + let bitmaps_vec = fbb.create_vector(&bitmap_offsets); + + let debug_info_str = fbb.create_string(&format!( + "total_height={} nodes={} top={} floats={}", + total_height, + flat_nodes.len(), + top_seq.len(), + float_table.len(), + )); + + let result = LayoutResult::create( + &mut fbb, + &LayoutResultArgs { + nodes: Some(nodes_vec), + glyph_runs: Some(glyph_runs_vec), + bitmaps: Some(bitmaps_vec), + decorations: Some(decorations_vec), + content_height: total_height, + debug_info: Some(debug_info_str), + }, + ); + + fbb.finish(result, None); + fbb.finished_data().to_vec() +} + +/// Lay out one flat node and its descendants as an isolated taffy subtree, +/// returning the node's size and the list of flat indices it covers. Absolute +/// positions are written relative to `(base_x, base_y)`. Paragraphs inside the +/// subtree are measured at full width (transition: the pusher's float context +/// does not yet recurse into block subtrees). +fn build_subtree( + taffy: &mut TaffyTree, + idx: usize, + flat_nodes: &[FlatNode], + font_system: &mut GuideFontSystem, + glyph_acc: &mut HashMap, + justify: bool, + visual_scale: f32, + abs_positions: &mut Vec<(f32, f32)>, + sizes: &mut Vec<(f32, f32)>, + base_x: f32, + base_y: f32, + known_w: Option, +) -> (f32, f32, Vec) { + let mut node_id_of: Vec> = vec![None; flat_nodes.len()]; + let mut sub: Vec = Vec::new(); + + fn build( + taffy: &mut TaffyTree, + idx: usize, + flat_nodes: &[FlatNode], + node_id_of: &mut Vec>, + sub: &mut Vec, + ) -> NodeId { + sub.push(idx); + let fb = &flat_nodes[idx]; + let style = fb + .style() + .map(|s| flat_style_to_taffy(&s)) + .unwrap_or_default(); + let nt = fb.node_type(); + let has_children = fb.children().map_or(false, |c| !c.is_empty()); + if !has_children || nt == 1 { + let id = taffy + .new_leaf_with_context( + style, + NodeContext { + flat_index: idx, + node_type: nt as u8, + }, + ) + .expect("leaf"); + node_id_of[idx] = Some(id); + return id; + } + let child_idxs: Vec = fb + .children() + .unwrap() + .iter() + .map(|ci| ci as usize) + .collect(); + let child_ids: Vec = child_idxs + .iter() + .map(|ci| build(taffy, *ci, flat_nodes, node_id_of, sub)) + .collect(); + let id = taffy + .new_with_children(style, &child_ids) + .expect("container"); + if nt == 1 { + let _ = taffy.set_node_context( + id, + Some(NodeContext { + flat_index: idx, + node_type: nt as u8, + }), + ); + } + node_id_of[idx] = Some(id); + id + } + + let root_id = build(taffy, idx, flat_nodes, &mut node_id_of, &mut sub); + + let mut measure_fn = create_measure_closure(font_system, flat_nodes, glyph_acc, justify, visual_scale); + let avail = Size { + width: known_w + .map(AvailableSpace::Definite) + .unwrap_or(AvailableSpace::MaxContent), + height: AvailableSpace::MaxContent, + }; + taffy + .compute_layout_with_measure(root_id, avail, &mut measure_fn) + .expect("subtree layout"); + + fn read( + taffy: &TaffyTree, + idx: usize, + flat_nodes: &[FlatNode], + node_id_of: &[Option], + abs_positions: &mut Vec<(f32, f32)>, + sizes: &mut Vec<(f32, f32)>, + parent_abs: (f32, f32), + ) { + let id = node_id_of[idx].expect("node id"); + let l = taffy.layout(id).expect("layout"); + let abs = (parent_abs.0 + l.location.x, parent_abs.1 + l.location.y); + abs_positions[idx] = abs; + sizes[idx] = (l.size.width, l.size.height); + if let Some(ch) = flat_nodes[idx].children() { + for ci in ch.iter() { + read(taffy, ci as usize, flat_nodes, node_id_of, abs_positions, sizes, abs); + } + } + } + + let rl = taffy.layout(root_id).expect("root layout"); + let root_abs = (base_x + rl.location.x, base_y + rl.location.y); + abs_positions[idx] = root_abs; + sizes[idx] = (rl.size.width, rl.size.height); + if let Some(ch) = flat_nodes[idx].children() { + for ci in ch.iter() { + read( + taffy, + ci as usize, + flat_nodes, + &node_id_of, + abs_positions, + sizes, + root_abs, + ); + } + } + + (rl.size.width, rl.size.height, sub) +} + +/// Inline post-pass: for every text node with inline-block markers, anchor +/// each block at its marker and grow the lines vertically per the block's +/// align mode. Parley's InlineBox already accounts block widths in pen +/// positions, so no glyph kerning shifts are needed — only the vertical +/// handling, mirroring the legacy layout's per-line box growth: a line +/// holding blocks grows by the space they need above the baseline and below +/// the line, pushing later lines down (the paragraph's measured height +/// already reserves the total — see measure.rs). +fn inline_post_pass( + flat_nodes: &[FlatNode], + glyph_acc: &mut HashMap, + abs_positions: &mut Vec<(f32, f32)>, + sizes: &mut Vec<(f32, f32)>, +) { + use crate::measure::marker_needs; + + for (i, acc) in glyph_acc.iter_mut() { + if acc.markers.is_empty() && acc.float_anchors.is_empty() { + continue; + } + let refs = match flat_nodes[*i].text().and_then(|t| t.inline_blocks()) { + Some(v) => v, + None => continue, + }; + let (node_x, node_y) = abs_positions[*i]; + let content_w = sizes[*i].0; + + // 1) Per-line growth from regular inline markers. + let mut by_line: std::collections::BTreeMap = Default::default(); + for (mi, m) in acc.markers.iter().enumerate() { + if mi >= refs.len() { + break; + } + let r = refs.get(mi); + let bh = sizes[r.node() as usize].1; + let (na, nb) = marker_needs(m, bh, r.align(), r.param()); + let e = by_line.entry(m.line_index).or_default(); + e.0 = e.0.max(na); + e.1 = e.1.max(nb); + } + let grown: Vec<(usize, f32, f32)> = by_line + .iter() + .map(|(l, (na, nb))| (*l, *na, *nb)) + .collect(); + let shift_of = |line: usize| -> f32 { + let mut s = 0.0; + for (l, na, nb) in &grown { + if *l < line { + s += na + nb; + } else { + if *l == line { + s += na; + } + break; + } + } + s + }; + if !grown.is_empty() { + for g in acc.glyphs.iter_mut() { + let s = shift_of(g.line_index); + g.y += s; + } + for m in acc.markers.iter_mut() { + let s = shift_of(m.line_index); + m.baseline_y += s; + m.line_top += s; + } + } + + // 2) Anchor regular inline blocks per their alignment mode. + // Markers are paired with refs by document order (both exclude floats). + let mut reg_mi = 0usize; + for ri in 0..refs.len() { + let r = refs.get(ri); + if r.align() >= 3 { + continue; + } + if reg_mi >= acc.markers.len() { + break; + } + let m = &acc.markers[reg_mi]; + let ci = r.node() as usize; + let (_, bh) = sizes[ci]; + let top = match r.align() { + 1 => m.baseline_y - r.param(), + 2 => m.line_top + (m.line_height - bh) / 2.0 + r.param(), + _ => m.baseline_y + 2.0 - bh, + }; + abs_positions[ci] = (node_x + m.pen_x, node_y + top); + reg_mi += 1; + } + + // 3) Anchor float-aligned inline blocks. + // float_anchors contains (node_index, paragraph-relative-y) in order. + // Pair with InlineBlockRef entries that have align=3 (float-left) or + // align=4 (float-right). + let mut float_i = 0usize; + for ri in 0..refs.len() { + let r = refs.get(ri); + if r.align() < 3 { + continue; + } + if float_i >= acc.float_anchors.len() { + break; + } + let (_, para_rel_y) = acc.float_anchors[float_i]; + let ci = r.node() as usize; + let (bw, _bh) = sizes[ci]; + // Float at paragraph edge; margins are already in sizes. + let x = if r.align() == 3 { + node_x + } else { + node_x + content_w - bw + }; + abs_positions[ci] = (x, node_y + para_rel_y); + float_i += 1; + } + } +} + +/// Per-span style facts needed by Pass B (grouping + decorations), extracted +/// from the node's TextData.spans vector. Empty for single-style paragraphs. +struct SpanStyleInfo { + color: u32, + italic: bool, + underline: bool, + strikethrough: bool, + highlight_argb: u32, + inline_code: bool, + wavy_underline: bool, + dotted_underline: bool, +} + +fn span_style_table(node: &FlatNode) -> Vec { + let mut out = Vec::new(); + if let Some(spans) = node.text().and_then(|t| t.spans()) { + for s in spans.iter() { + let st = s.style().unwrap(); + out.push(SpanStyleInfo { + color: st.color(), + italic: st.italic(), + underline: st.underline(), + strikethrough: st.strikethrough(), + highlight_argb: st.highlight_argb(), + inline_code: st.inline_code(), + wavy_underline: st.wavy_underline(), + dotted_underline: st.dotted_underline(), + }); + } + } + out +} + +/// Synthetic-italic kerning compensation: per-glyph cumulative advance shift +/// for a sheared run, restoring the upright sidebearings — the behavior of a +/// true italic face's hmtx advances (the mature synthetic-italic practice). +/// +/// The engine draws a sheared run by moving each glyph's TOP edge right by +/// `K × (baseY − y_top)` and its bottom edge by the same amount minus +/// `K × h` (GuideRenderEngine.emitGlyphQuads: `xTop = x + K·(baseY − y)`, +/// `xBottom = x + K·(baseY − y − h)`), where `baseY` is the run's lowest +/// quad bottom (`shearBaseY = max(g.y + g.h)` over the run, same file). But +/// parley SHAPES the run upright — shaping knows nothing of the slant — so +/// the italic ink overhangs its advance by that shear amount and glyphs +/// visibly collide. Compensating each glyph by the CUMULATIVE overhang of the +/// glyphs before it on the same line: +/// +/// ```text +/// x'_i = x_i + Σ_{j( + glyphs: &[crate::parley_text::OutGlyph], + span_styles: &[SpanStyleInfo], + node_index: u32, + node_x: f32, + node_y: f32, + fbb: &mut FlatBufferBuilder<'a>, + out: &mut Vec>>, +) { + if span_styles.is_empty() { + return; + } + struct Extent { + min_x: f32, + max_x: f32, + baseline: f32, + line_top: f32, + line_height: f32, + } + let mut by_line: std::collections::BTreeMap<(u32, usize), Extent> = Default::default(); + for g in glyphs { + let e = by_line.entry((g.span_index, g.line_index)).or_insert(Extent { + min_x: g.x, + max_x: g.x + g.w, + baseline: g.y, + line_top: g.line_top, + line_height: g.line_height, + }); + e.min_x = e.min_x.min(g.x); + e.max_x = e.max_x.max(g.x + g.w); + } + for ((span_index, _line), e) in by_line { + let Some(st) = span_styles.get(span_index as usize) else { continue }; + let w = e.max_x - e.min_x; + if st.highlight_argb != 0 { + // Background: inline-code hugs the text run; plain highlight pads + // 1px on each side (mirrors the legacy LineTextRun geometry). + let (bx, bw) = if st.inline_code { + (e.min_x, w) + } else { + (e.min_x - 1.0, w + 2.0) + }; + out.push(DecorationRect::create( + fbb, + &DecorationRectArgs { + node: node_index, + x: node_x + bx, + y: node_y + e.line_top - 1.0, + w: bw, + h: e.line_height, + argb: st.highlight_argb, + kind: 0, + }, + )); + } + if st.underline { + out.push(DecorationRect::create( + fbb, + &DecorationRectArgs { + node: node_index, + x: node_x + e.min_x, + y: node_y + e.baseline + 1.0, + w, + h: 1.0, + argb: st.color, + kind: 1, + }, + )); + } + if st.wavy_underline { + // T1: wavy underline — wave amplitude band 2px tall (Java draws the + // squiggle inside this rect). Same geometry as the underline band. + out.push(DecorationRect::create( + fbb, + &DecorationRectArgs { + node: node_index, + x: node_x + e.min_x, + y: node_y + e.baseline + 1.0, + w, + h: 2.0, + argb: st.color, + kind: 4, + }, + )); + } + if st.dotted_underline { + // T1: dotted underline — same band as underline; Java rasterizes + // the dot pattern inside the rect. + out.push(DecorationRect::create( + fbb, + &DecorationRectArgs { + node: node_index, + x: node_x + e.min_x, + y: node_y + e.baseline + 1.0, + w, + h: 1.0, + argb: st.color, + kind: 5, + }, + )); + } + if st.strikethrough { + out.push(DecorationRect::create( + fbb, + &DecorationRectArgs { + node: node_index, + x: node_x + e.min_x, + y: node_y + e.line_top + e.line_height / 2.0, + w, + h: 1.0, + argb: st.color, + kind: 2, + }, + )); + } + } +} + +/// shapeText JNI command: shape + rasterize a single styled text, returning a +/// ShapeTextResult FlatBuffer with atlas-keyed buffer-local quads and metrics. +pub fn shape_text_cmd(font_system: &mut GuideFontSystem, input_bytes: &[u8]) -> Vec { + use crate::fb::{ShapeTextInput, ShapeTextResult, ShapeTextResultArgs}; + + let input = flatbuffers::root::(input_bytes) + .expect("Invalid ShapeTextInput FlatBuffer"); + let text = input.text().unwrap_or(""); + let style = input.style().expect("ShapeTextInput.style missing"); + let render_scale = input.render_scale().max(0.25); + let max_w = if input.max_width() > 0.0 { + // Buffer is already at the scaled font size — width used as-is (D-1). + Some(input.max_width()) + } else { + None + }; + + let scaled = style.font_size() * style.font_scale(); + // Italic is NOT forwarded to shaping — the engine applies the synthetic + // slant at draw time (MC §o parity; forwarding both would double-slant). + let layout = font_system + .parley + .layout_styled(text, scaled, 1.55, style.bold(), max_w); + let content_height = layout.height(); + let ascent = layout + .lines() + .next() + .map(|l| l.metrics().baseline - l.metrics().block_min_coord) + .unwrap_or(scaled); + // T4: first-run real x_height/cap_height (shaped-size px, skrifa OS/2 + // sxHeight/sCapHeight scaled by font size); RunMetrics is Copy so this + // value-extension ends all borrows before collect_layout below. + let run_metrics = layout.lines().next().and_then(|l| l.runs().next()).map(|r| *r.metrics()); + let x_height = run_metrics.and_then(|m| m.x_height).unwrap_or(ascent * 0.625); + let cap_height = run_metrics.and_then(|m| m.cap_height).unwrap_or(ascent * 0.7); + let (glyphs, _markers, max_x, _content_height, _clear_floor, _last_window) = + crate::parley_text::collect_layout(&layout, &[], 0.0, 0.0, max_w.unwrap_or(f32::MAX), &[]); + let (quads, bitmaps) = crate::parley_text::rasterize_out_glyphs(&glyphs, render_scale); + + let mut fbb = flatbuffers::FlatBufferBuilder::with_capacity(4096); + let glyph_offsets: Vec> = quads + .iter() + .map(|q| { + PlacedGlyph::create( + &mut fbb, + &PlacedGlyphArgs { + bitmap_key: q.bitmap_key, + x: q.x, + y: q.y, + w: q.w, + h: q.h, + start: 0, + end: 0, + line_index: q.line_index, + }, + ) + }) + .collect(); + let glyphs_vec = fbb.create_vector(&glyph_offsets); + let bitmap_offsets: Vec> = bitmaps + .iter() + .map(|(key, w, h, rgba)| { + let rgba_vec = fbb.create_vector(rgba); + GlyphBitmap::create( + &mut fbb, + &GlyphBitmapArgs { + key: *key, + w: *w, + h: *h, + rgba: Some(rgba_vec), + }, + ) + }) + .collect(); + let bitmaps_vec = fbb.create_vector(&bitmap_offsets); + + let result = ShapeTextResult::create( + &mut fbb, + &ShapeTextResultArgs { + // Real advance, zero allowed (zero-width chars must measure 0 — + // the 1px clamp belongs to Taffy node sizing only, see measure.rs). + width: max_x, + height: content_height.max(1.0), + ascent, + line_height: scaled * 1.55, + glyphs: Some(glyphs_vec), + bitmaps: Some(bitmaps_vec), + x_height, + cap_height, + }, + ); + fbb.finish(result, None); + fbb.finished_data().to_vec() +} diff --git a/layout-engine/src/lib.rs b/layout-engine/src/lib.rs new file mode 100644 index 00000000..c6cf14de --- /dev/null +++ b/layout-engine/src/lib.rs @@ -0,0 +1,155 @@ +pub mod guidenh_layout_generated; +// Re-export generated types for convenience +pub use guidenh_layout_generated::com::hfstudio::guidenh::guide::layout::flatbuffers as fb; +pub mod jni_bridge; +pub mod layout; +pub mod measure; +pub mod parley_text; +pub mod style_convert; +pub mod text; + +use std::panic::{catch_unwind, AssertUnwindSafe}; + +use jni::JNIEnv; +use jni::objects::{JByteArray, JClass, JString}; +use jni::sys::{jbyteArray, jlong}; + +use crate::jni_bridge::{jbytearray_to_vec, vec_to_jbytearray}; +use crate::layout::compute_layout; +use crate::text::GuideFontSystem; + +/// Java: static native long init(byte[] fontTtfData, String locale); +#[no_mangle] +pub extern "system" fn Java_com_hfstudio_guidenh_guide_layout_LayoutBridge_init( + mut env: JNIEnv, + _class: JClass, + font_data: JByteArray, + locale: JString, +) -> jlong { + let result = catch_unwind(AssertUnwindSafe(|| { + let font_bytes = jbytearray_to_vec(&mut env, &font_data).unwrap_or_default(); + let _locale_str: String = env + .get_string(&locale) + .map(|s| s.into()) + .unwrap_or_default(); + + let mut font_system = GuideFontSystem::new(); + if !font_bytes.is_empty() { + font_system.load_font_data(font_bytes); + } + + let ptr = Box::into_raw(Box::new(font_system)); + ptr as jlong + })); + + match result { + Ok(h) => h, + Err(_) => 0, + } +} + +/// Java: static native void loadFallbackFont(long handle, byte[] fallbackData); +/// Best-effort: registers a symbol font and appends it to the Han fallback +/// key (see [`ParleyFonts::load_fallback_font_data`]). No-op on empty data +/// or any error — never affects the existing font system. +#[no_mangle] +pub extern "system" fn Java_com_hfstudio_guidenh_guide_layout_LayoutBridge_loadFallbackFont( + mut env: JNIEnv, + _class: JClass, + handle: jlong, + fallback_data: JByteArray, +) { + let result = catch_unwind(AssertUnwindSafe(|| { + if handle == 0 { + return; + } + let data = jbytearray_to_vec(&mut env, &fallback_data).unwrap_or_default(); + if data.is_empty() { + return; + } + let font_system = unsafe { &mut *(handle as *mut GuideFontSystem) }; + font_system.load_fallback_font_data(data); + })); + + let _ = result; +} + +/// Java: static native byte[] measureLayout(long handle, byte[] input); +#[no_mangle] +pub extern "system" fn Java_com_hfstudio_guidenh_guide_layout_LayoutBridge_measureLayout( + mut env: JNIEnv, + _class: JClass, + handle: jlong, + input: JByteArray, +) -> jbyteArray { + let result = catch_unwind(AssertUnwindSafe(|| { + if handle == 0 { + return vec_to_jbytearray(&mut env, &[]).unwrap_or(std::ptr::null_mut()); + } + let input_bytes = jbytearray_to_vec(&mut env, &input).unwrap_or_default(); + if input_bytes.is_empty() { + return vec_to_jbytearray(&mut env, &[]).unwrap_or(std::ptr::null_mut()); + } + + let font_system = unsafe { &mut *(handle as *mut GuideFontSystem) }; + let output = compute_layout(&input_bytes, font_system); + + vec_to_jbytearray(&mut env, &output).unwrap_or(std::ptr::null_mut()) + })); + + match result { + Ok(arr) => arr, + Err(_) => env + .new_byte_array(0) + .map(|a| a.into_raw()) + .unwrap_or(std::ptr::null_mut()), + } +} + +/// Java: static native byte[] shapeText(long handle, byte[] input); +/// Unified-text-pipeline entry: shape + rasterize one styled text into +/// atlas-keyed quads + metrics (ShapeTextResult FlatBuffer). +#[no_mangle] +pub extern "system" fn Java_com_hfstudio_guidenh_guide_layout_LayoutBridge_shapeText( + mut env: JNIEnv, + _class: JClass, + handle: jlong, + input: JByteArray, +) -> jbyteArray { + let result = catch_unwind(AssertUnwindSafe(|| { + if handle == 0 { + return vec_to_jbytearray(&mut env, &[]).unwrap_or(std::ptr::null_mut()); + } + let input_bytes = jbytearray_to_vec(&mut env, &input).unwrap_or_default(); + if input_bytes.is_empty() { + return vec_to_jbytearray(&mut env, &[]).unwrap_or(std::ptr::null_mut()); + } + + let font_system = unsafe { &mut *(handle as *mut GuideFontSystem) }; + let output = layout::shape_text_cmd(font_system, &input_bytes); + + vec_to_jbytearray(&mut env, &output).unwrap_or(std::ptr::null_mut()) + })); + + match result { + Ok(arr) => arr, + Err(_) => env + .new_byte_array(0) + .map(|a| a.into_raw()) + .unwrap_or(std::ptr::null_mut()), + } +} + +/// Java: static native void destroy(long handle); +#[no_mangle] +pub extern "system" fn Java_com_hfstudio_guidenh_guide_layout_LayoutBridge_destroy( + _env: JNIEnv, + _class: JClass, + handle: jlong, +) { + if handle != 0 { + unsafe { + drop(Box::from_raw(handle as *mut GuideFontSystem)); + } + } +} diff --git a/layout-engine/src/measure.rs b/layout-engine/src/measure.rs new file mode 100644 index 00000000..60e9f866 --- /dev/null +++ b/layout-engine/src/measure.rs @@ -0,0 +1,1380 @@ +use std::collections::HashMap; + +use crate::fb::FlatNode; +use crate::text::GuideFontSystem; +use taffy::prelude::*; + +/// Context stored in Taffy leaf nodes for measure closure dispatch. +#[derive(Debug, Clone)] +pub struct NodeContext { + pub flat_index: usize, + pub node_type: u8, +} + +/// Accumulator for shaped glyphs during measure closure. +/// Inserted on each call; last call wins (Taffy may measure multiple times). +pub struct GlyphAccum { + /// Relative glyphs (paragraph-local coordinates, no node offset). + pub glyphs: Vec, + /// Inline-block anchors in shaping order, consumed by the inline + /// post-pass in layout.rs. + pub markers: Vec, + /// Float-aligned inline block anchors: (flat_node_index, paragraph-relative y). + pub float_anchors: Vec<(usize, f32)>, + /// (x_off, line_width) of the last line's full float-compressed window + /// (paragraph-relative). None for empty paragraphs. Used by separator + /// line (kind=3 DecorationRect) for heading paragraphs. + pub last_line_window: Option<(f32, f32)>, +} + +/// One inline-block anchor in paragraph-local coordinates: pen position on +/// the line's baseline plus the line metrics the anchor's block needs for +/// its vertical alignment. +#[derive(Clone, Debug)] +pub struct InlineMarker { + pub pen_x: f32, + pub baseline_y: f32, + pub line_top: f32, + pub line_height: f32, + pub line_index: usize, + pub advance: f32, +} + +/// Space an inline block needs above its line's baseline / below its line's +/// bottom, per alignment mode (see InlineBlockRef in the schema). Positive +/// values grow the line; the legacy layout grew line boxes the same way. +pub(crate) fn marker_needs(m: &InlineMarker, block_h: f32, align: i8, param: f32) -> (f32, f32) { + let line_ascent = m.baseline_y - m.line_top; + let line_descent = (m.line_top + m.line_height) - m.baseline_y; + match align { + // Baseline ascent: block top sits `param` above the baseline. + 1 => ( + (param - line_ascent).max(0.0), + ((block_h - param) - line_descent).max(0.0), + ), + // Center on the line, then shift down by `param`. + 2 => { + let top_off = (m.line_height - block_h) / 2.0 + param; + ((-top_off).max(0.0), (top_off + block_h - m.line_height).max(0.0)) + } + // Default: block bottom sits 2px below the baseline. + _ => ( + (block_h - 2.0 - line_ascent).max(0.0), + (2.0 - line_descent).max(0.0), + ), + } +} + +/// Explicit pixel height of an inline block node (0 when not px-sized). +pub(crate) fn inline_block_height(nodes: &[FlatNode], idx: usize) -> f32 { + let Some(style) = nodes[idx].style() else { return 0.0 }; + let Some(d) = style.size_h() else { return 0.0 }; + if d.unit() == 1 { d.value() } else { 0.0 } +} + +/// Explicit pixel width of an inline block node (0 when not px-sized). +pub(crate) fn inline_block_width(nodes: &[FlatNode], idx: usize) -> f32 { + let Some(style) = nodes[idx].style() else { return 0.0 }; + let Some(d) = style.size_w() else { return 0.0 }; + if d.unit() == 1 { d.value() } else { 0.0 } +} + +/// Build the measure closure for compute_layout_with_measure. +/// Dispatches by node_type to the appropriate measurement function. +pub fn create_measure_closure<'a>( + font_system: &'a mut GuideFontSystem, + flat_nodes: &'a [FlatNode], + glyph_acc: &'a mut HashMap, + justify: bool, + visual_scale: f32, +) -> impl FnMut( + Size>, + Size, + NodeId, + Option<&mut NodeContext>, + &Style, +) -> Size + 'a { + move |known, available, _node_id, ctx, _style| -> Size { + let ctx = match ctx { + Some(c) => c, + None => return Size::ZERO, + }; + let index = ctx.flat_index; + + let (measured, _clear_floor) = match ctx.node_type { + 1 => measure_text( + font_system, flat_nodes, index, glyph_acc, available, justify, &[], 0.0, 0.0, &[], + ), + 2 => (measure_image(flat_nodes, index), None), + 3 => (measure_slot(flat_nodes, index), None), + 4 => (measure_thematic_break(flat_nodes, index, known, available), None), + 8 => (measure_latex(flat_nodes, index), None), + 20 => (measure_recipe_box(flat_nodes, index), None), + 21 => (measure_pie_chart(flat_nodes, index, known, available, visual_scale), None), + 22 | 23 | 24 | 25 => (measure_chart(flat_nodes, index, known, available, visual_scale), None), + 26 => (measure_structure_view(flat_nodes, index, known, available, visual_scale), None), + 27 => (measure_guidebook_scene(flat_nodes, index, known, available, visual_scale), None), + 28 => (measure_function_graph(flat_nodes, index, known, available, visual_scale), None), + 29 => (measure_mediawiki_generated_list(flat_nodes, index, known, available), None), + 30 => (measure_mediawiki_special_generated(flat_nodes, index, known, available), None), + _ => (Size::ZERO, None), + }; + // Explicit style sizes win over content measurement (CSS behavior): + // Taffy passes them in as known dimensions; honoring them is what lets + // opaque fixed-size leaves (buttons, sprites, px-pinned boxes) keep + // their declared size instead of collapsing to the measured ZERO. + Size { + width: known.width.unwrap_or(measured.width), + height: known.height.unwrap_or(measured.height), + } + } +} + +pub(crate) fn measure_text( + fs: &mut GuideFontSystem, + nodes: &[FlatNode], + idx: usize, + acc: &mut HashMap, + available: Size, + justify: bool, + floats: &[crate::parley_text::FloatRect], + para_abs_y: f32, + para_x: f32, + clears: &[(usize, u8)], +) -> (Size, Option) { + let node = &nodes[idx]; + let td = match node.text() { + Some(t) => t, + None => return (Size::ZERO, None), + }; + let text = td.text().unwrap_or(""); + let style = td.style().unwrap(); + let font_size = style.font_size(); + let font_scale = style.font_scale(); + // R4-17: read per-paragraph text alignment from FlatBuffer + let alignment = td.alignment_(); + // R6-2: read white_space from FlatBuffer (0=Normal 1=PreWrap 2=Pre/NoWrap). + // Value 2 disables wrapping for code blocks; the Rust shaping path was not + // reading this before and always used Wrap+BreakWord. + let white_space = td.white_space(); + + // Rich multi-style spans (TextData.spans) → builder ranges. Spans cover + // the full text in document order, so span byte boundaries index into it. + let mut span_styles: Vec = Vec::new(); + if let Some(v) = td.spans() { + if !v.is_empty() { + let mut pos = 0usize; + for s in v.iter() { + let t = s.text().unwrap_or(""); + let st = s.style().unwrap(); + span_styles.push(crate::parley_text::SpanStyle { + start: pos, + end: pos + t.len(), + bold: st.bold(), + italic: st.italic(), + baseline_shift: st.baseline_shift(), + }); + pos += t.len(); + } + } + } + + // Inline blocks: anchor bytes are the U+FFFC placeholders in document + // order; each box's width comes from its node's explicit pixel size. + let mut inlines: Vec = Vec::new(); + if let Some(refs) = td.inline_blocks() { + if !refs.is_empty() { + let anchors: Vec = text + .char_indices() + .filter(|(_, ch)| *ch == '\u{FFFC}') + .map(|(i, _)| i) + .collect(); + for (k, r) in refs.iter().enumerate() { + if k >= anchors.len() { + break; + } + let align = r.align(); + let float_side = match align { + 3 => Some(1u8), + 4 => Some(2u8), + _ => None, + }; + inlines.push(crate::parley_text::InlineSpec { + anchor_byte: anchors[k], + width: inline_block_width(nodes, r.node() as usize), + height: inline_block_height(nodes, r.node() as usize), + float_side, + node: r.node() as usize, + }); + } + } + } + + // The buffer is already at the scaled font size (parley_text), so the + // wrap width is used as-is (D-1). + let max_w = match available.width { + AvailableSpace::Definite(w) => w as f32, + // Min-content probe: wrap at zero width so every breakable point is + // taken — the measured width is then the longest unbreakable word, + // not the whole unwrapped line (D-5). + AvailableSpace::MinContent => 0.0, + _ => f32::MAX, + }; + + // Hard breaks (
): raw byte offsets (in the break-free text) at which the + // paragraph is split into independently shaped pieces. A
is a hard line + // break that must hold under ANY white-space mode, but parley 0.11 exposes no + // white-space control and its normal collapse would fold a literal '\n' into a + // space — so the break is realised structurally by shaping each piece on its + // own and stacking them vertically (piece k+1 starts at the accumulated height + // of the pieces before it). Pieces carry no inline boxes (a paragraph that has + // both inline boxes and hard breaks falls through to the single-shape path + // below, keeping inline geometry correct at the cost of the hard break). + let breaks: Vec = td + .breaks() + .map(|v| v.iter().map(|x| x as usize).collect()) + .unwrap_or_default(); + + let (shaped_glyphs, shaped_markers, shaped_h, shaped_max_x, shaped_floor, shaped_float_anchors, shaped_last_window) = + if !breaks.is_empty() && inlines.is_empty() { + let mut last_window: Option<(f32, f32)> = None; + let mut bounds: Vec = Vec::with_capacity(breaks.len() + 2); + bounds.push(0); + for &b in &breaks { + if b > *bounds.last().unwrap() && b <= text.len() { + bounds.push(b); + } + } + if *bounds.last().unwrap() != text.len() { + bounds.push(text.len()); + } + let mut all_glyphs: Vec = Vec::new(); + let mut all_markers: Vec = Vec::new(); + let mut acc_h: f32 = 0.0; + let mut max_x: f32 = 0.0; + let mut floor: Option = None; + for w in bounds.windows(2) { + let lo = w[0]; + let hi = w[1]; + if lo >= hi { + continue; + } + let sub_text = &text[lo..hi]; + let sub_spans: Vec = span_styles + .iter() + .filter_map(|sp| { + let ns = sp.start.max(lo); + let ne = sp.end.min(hi); + if ns < ne { + Some(crate::parley_text::SpanStyle { + start: ns - lo, + end: ne - lo, + bold: sp.bold, + italic: sp.italic, + baseline_shift: sp.baseline_shift, + }) + } else { + None + } + }) + .collect(); + let sub_clears: Vec<(usize, u8)> = clears + .iter() + .filter_map(|(o, s)| { + if *o >= lo && *o < hi { + Some((*o - lo, *s)) + } else { + None + } + }) + .collect(); + let seg_top = para_abs_y + acc_h; + let req = crate::parley_text::ShapeRequest { + text: sub_text, + spans: &sub_spans, + inlines: &[], + floats, + para_abs_y: seg_top, + para_x, + clears: &sub_clears, + font_size, + font_scale, + max_width: max_w, + justify, + alignment, + white_space, + }; + let shaped = crate::parley_text::shape_paragraph(&mut fs.parley, &req); + for mut g in shaped.glyphs { + g.y += acc_h; + g.line_top += acc_h; + all_glyphs.push(g); + } + for mut m in shaped.markers { + m.baseline_y += acc_h; + m.line_top += acc_h; + all_markers.push(m); + } + let sh = if shaped.content_height <= 0.0 { + font_size * font_scale * 1.55 + } else { + shaped.content_height + }; + acc_h += sh; + max_x = max_x.max(shaped.max_x); + floor = match (floor, shaped.clear_floor) { + (Some(a), Some(b)) => Some(a.max(b)), + (a, b) => a.or(b), + }; + // Track last segment's window for the separator-line mechanism + last_window = shaped.last_line_window; + } + (all_glyphs, all_markers, acc_h, max_x, floor, Vec::new(), last_window) + } else { + let req = crate::parley_text::ShapeRequest { + text, + spans: &span_styles, + inlines: &inlines, + floats, + para_abs_y, + para_x, + clears, + font_size, + font_scale, + max_width: max_w, + justify, + alignment, + white_space, + }; + let shaped = crate::parley_text::shape_paragraph(&mut fs.parley, &req); + let mut h = shaped.content_height; + if h <= 0.0 { + h = font_size * font_scale * 1.55; + } + if !shaped.markers.is_empty() { + h += inline_line_growth(nodes, idx, &shaped.markers); + } + (shaped.glyphs, shaped.markers, h, shaped.max_x, shaped.clear_floor, shaped.float_anchors, shaped.last_line_window) + }; + + acc.insert( + idx, + GlyphAccum { + glyphs: shaped_glyphs, + markers: shaped_markers, + float_anchors: shaped_float_anchors, + last_line_window: shaped_last_window, + }, + ); + + ( + Size { + width: match available.width { + AvailableSpace::Definite(max_w) => { + if alignment == 1 || alignment == 2 { + max_w.max(1.0) + } else if white_space == 2 { + // R6-2: Pre/NoWrap code — the measured width is the + // shaped natural width of the longest line (NOT clamped + // to the container), so the narrow scroll container + // lays out one unbroken line and scrolls horizontally. + shaped_max_x.max(1.0) + } else { + (shaped_max_x.min(max_w)).max(1.0) + } + } + _ => shaped_max_x.max(1.0), + }, + height: shaped_h.max(1.0), + }, + shaped_floor, + ) +} + +/// Extra paragraph height from inline blocks, mirroring the legacy per-line +/// box growth: every line holding an anchor grows by the space its blocks +/// need above the baseline plus below the line, and later lines are pushed +/// down by the accumulated growth (applied in the inline post-pass). +fn inline_line_growth(nodes: &[FlatNode], idx: usize, markers: &[InlineMarker]) -> f32 { + let Some(refs) = nodes[idx].text().and_then(|t| t.inline_blocks()) else { + return 0.0; + }; + let mut by_line: std::collections::BTreeMap = Default::default(); + for (mi, m) in markers.iter().enumerate() { + if mi >= refs.len() { + break; + } + let r = refs.get(mi); + let bh = inline_block_height(nodes, r.node() as usize); + let (na, nb) = marker_needs(m, bh, r.align(), r.param()); + let e = by_line.entry(m.line_index).or_default(); + e.0 = e.0.max(na); + e.1 = e.1.max(nb); + } + by_line.values().map(|(a, b)| a + b).sum() +} + +fn measure_image(nodes: &[FlatNode], idx: usize) -> Size { + let node = &nodes[idx]; + let img = match node.image() { + Some(i) => i, + None => return Size::ZERO, + }; + let ew = img.explicit_w(); + let eh = img.explicit_h(); + let nw = img.natural_w(); + let nh = img.natural_h(); + // F-N1 single-parameter mode: exactly one explicit dimension is given + // (the other is <= 0) and the source image has a real natural size — infer + // the missing dimension from the natural aspect ratio: + // inferred = explicit × natural_other / natural_given + // The inferred axis does NOT apply its own scale (the inferred value is + // already the final display pixel size). Two explicit dimensions win as-is; + // when both are missing (or natural size is unavailable) fall back to the + // legacy natural × scale behaviour. + let (w, h) = if ew > 0.0 && eh > 0.0 { + (ew, eh) + } else if ew > 0.0 && nw > 0.0 && nh > 0.0 { + (ew, ew * (nh / nw)) + } else if eh > 0.0 && nw > 0.0 && nh > 0.0 { + (eh * (nw / nh), eh) + } else { + let w = if ew > 0.0 { ew } else { nw * img.scale_x() }; + let h = if eh > 0.0 { eh } else { nh * img.scale_y() }; + (w, h) + }; + Size { + width: w.max(1.0), + height: h.max(1.0), + } +} + +fn measure_slot(nodes: &[FlatNode], idx: usize) -> Size { + let node = &nodes[idx]; + let slot = match node.slot() { + Some(s) => s, + None => return Size::ZERO, + }; + let sz = slot.slot_size(); + Size { + width: sz, + height: sz, + } +} + +fn measure_thematic_break( + nodes: &[FlatNode], + idx: usize, + known: Size>, + available: Size, +) -> Size { + let node = &nodes[idx]; + let tb = match node.break_() { + Some(t) => t, + None => return Size::ZERO, + }; + let fallback_w = match available.width { + AvailableSpace::Definite(a) => a.max(0.0), + _ => 0.0, + }; + Size { + width: known.width.unwrap_or(fallback_w), + height: tb.height(), + } +} + +fn measure_latex(nodes: &[FlatNode], idx: usize) -> Size { + let node = &nodes[idx]; + let latex = match node.latex() { + Some(l) => l, + None => return Size::ZERO, + }; + Size { + width: latex.raw_w(), + height: latex.raw_h() + 8.0, + } +} + +/// Measure an NEI recipe box (node_type = 20). The formula mirrors +/// LytNeiRecipeBox.computeLayout term for term, with Java-computed +/// pixel values (title_text_width, title_height, body dimensions) +/// provided via RecipeBoxData. Constants replicate the Java class's +/// static fields. +fn measure_recipe_box(nodes: &[FlatNode], idx: usize) -> Size { + const FRAME_BORDER: f32 = 4.0; + const TITLE_GAP_AFTER_ICON: f32 = 3.0; + const TITLE_GAP_BEFORE_ACTION: f32 = 3.0; + const ACTION_BUTTON_SIZE: f32 = 12.0; + const BODY_MARGIN: f32 = 2.0; + + let node = &nodes[idx]; + let rb = match node.recipe_box() { + Some(d) => d, + None => return Size::ZERO, + }; + + // titleWidth = iconSize + (iconSize > 0 ? TITLE_GAP_AFTER_ICON : 0) + titleTextWidth + let mut title_width = rb.icon_size() + + (if rb.icon_size() > 0.0 { TITLE_GAP_AFTER_ICON } else { 0.0 }) + + rb.title_text_width(); + // if recipeJumpEnabled: titleWidth += TITLE_GAP_BEFORE_ACTION + ACTION_BUTTON_SIZE + if rb.recipe_jump_enabled() { + title_width += TITLE_GAP_BEFORE_ACTION + ACTION_BUTTON_SIZE; + } + // innerW = max(bodyWidth, titleWidth) + let inner_w = f32::max(rb.body_width(), title_width); + // w = FRAME_BORDER + innerW + FRAME_BORDER + let w = FRAME_BORDER + inner_w + FRAME_BORDER; + + // h = FRAME_BORDER + titleHeight + BODY_MARGIN + bodyTopInset + bodyHeight + bodyYShift + FRAME_BORDER + let h = FRAME_BORDER + + rb.title_height() + + BODY_MARGIN + + rb.body_top_inset() + + rb.body_height() + + rb.body_y_shift() + + FRAME_BORDER; + + Size { width: w, height: h } +} + +/// Shared chart measurement formula, extracted from LytChartBase.computeLayout. +/// Used by both PieChart (node_type=21) via PieChartData and Cartesian charts +/// (BarChart node_type=22, future Column/Line/Scatter) via ChartData. +/// +/// Chrome height is now computed in Rust from the final width w, eliminating +/// the T6a-found discrepancy where the Java lazy getter used unscaled +/// preferredWidth for legend wrapping (T6a ticket: chromeHeight lazy 用未缩放宽度). +fn chart_measurement( + preferred_w: f32, + total_h: f32, + title_chrome: f32, + legend_position: i8, + legend_row_height: f32, + legend_label_widths: &[f32], + known: Size>, + available: Size, + visual_scale: f32, +) -> Size { + // Constants mirrored from LytChartBase: + const PADDING: f32 = 8.0; + const LEGEND_GAP: f32 = 6.0; + const LEGEND_ENTRY_GAP: f32 = 12.0; + const HORIZONTAL_ROW_GAP: f32 = 2.0; + const MIN_PLOT_HEIGHT: f32 = 72.0; + + // Width formula — mirrors LytChartBase.computeLayout: + // preferredWidth = (explicitW > 0 ? explicitW : DEFAULT_WIDTH) + extraPlotWidth + // scaledWidth = scaleWidth(preferredWidth, visualScale, 64) + // width = max(1, min(scaledWidth, availableWidth)) + // + // When explicitWidth > 0 (user-set via setExplicitSize), Taffy passes + // it as known.width and we use it directly. Otherwise known.width is + // None and we compute the width from the Java-precomputed preferred_width. + let w = match known.width { + Some(explicit) => explicit, + None => { + let scaled = scale_width(preferred_w, visual_scale, 64.0); + let avail = match available.width { + AvailableSpace::Definite(a) => a, + _ => f32::MAX, + }; + (scaled.min(avail)).max(1.0) + } + }; + + // Chrome height — Rust-computed from the final width w. + // Mirrors LytChartBase.estimateFixedChromeHeight: + // chrome = PADDING * 2 + // + title_chrome (Java-precomputed: lineHeight(titleStyle) + TITLE_GAP, 0 if no title) + // + legendHeight (only for TOP/BOTTOM legend) + // + LEGEND_GAP (if legend present and TOP/BOTTOM) + let content_w = (w - PADDING * 2.0).max(1.0); + let legend_h = chart_legend_height( + legend_row_height, + legend_label_widths, + content_w, + LEGEND_ENTRY_GAP, + HORIZONTAL_ROW_GAP, + ); + let mut chrome = PADDING * 2.0; + chrome += title_chrome; + // Chrome includes legend_h (may be 0 when entries empty) + LEGEND_GAP + // when legend is TOP/BOTTOM, matching LytChartBase.estimateFixedChromeHeight + // which always adds LEGEND_GAP for TOP/BOTTOM regardless of legend height. + let has_legend = legend_position == 1 || legend_position == 2; + if has_legend { + chrome += legend_h + LEGEND_GAP; + } + + // Height formula — mirrors LytChartBase.computeLayout: + // totalHeight = explicitH > 0 ? explicitH : DEFAULT_HEIGHT + // bodyHeight = max(1, totalHeight - clamp(chrome, 0, totalHeight - 1)) + // scaledBody = scaleHeightForWidth(preferredW, bodyHeight, width, MIN_PLOT_HEIGHT) + // height = chrome + scaledBody + let raw_h = total_h; + // Guard against raw_h < 1.0: clamp upper bound to at least 0 so the + // range is valid even when totalHeight is 0 or negative (T5.2 legacy). + let body = (raw_h - chrome.clamp(0.0, (raw_h - 1.0).max(0.0))).max(1.0); + let scaled_body = scale_height_for_width(preferred_w, body, w, MIN_PLOT_HEIGHT); + let h = chrome + scaled_body; + + Size { width: w, height: h } +} + +/// Compute the total height of a horizontal (TOP/BOTTOM) legend given per-entry +/// widths, row height, and layout constants. Mirrors +/// ChartLegendRenderer.measureHorizontalLegendHeight term for term, including +/// the first-item-no-gap rule and the computation: +/// rows * rowHeight + max(0, rows-1) * rowGap +fn chart_legend_height( + row_height: f32, + item_widths: &[f32], + available_width: f32, + entry_gap: f32, + row_gap: f32, +) -> f32 { + if row_height <= 0.0 || item_widths.is_empty() { + return 0.0; + } + let mut rows: i32 = 1; + let mut row_w: f32 = 0.0; + for &item_w in item_widths { + if item_w <= 0.0 { + continue; + } + let needed = if row_w == 0.0 { + item_w + } else { + row_w + entry_gap + item_w + }; + if row_w > 0.0 && needed > available_width { + rows += 1; + row_w = item_w; + } else { + row_w = needed; + } + } + // If rows stayed at 1 but no items had width > 0, return 0 (matching Java). + if row_w == 0.0 { + return 0.0; + } + rows as f32 * row_height + (rows - 1) as f32 * row_gap +} + +/// Measure a pie chart (node_type = 21). The formula mirrors +/// LytChartBase.computeLayout term for term, with Java-computed +/// font-metric values (title_chrome, legend_row_height, +/// legend_label_widths) provided via PieChartData. Chrome height +/// is computed in Rust from the actual width, using the legend +/// wrapping algorithm transplanted from ChartLegendRenderer. +/// Pure-arithmetic helper functions (scale_width, scale_height_for_width) +/// replicate ResponsiveVisualSizing on the Rust side. +fn measure_pie_chart( + nodes: &[FlatNode], + idx: usize, + known: Size>, + available: Size, + visual_scale: f32, +) -> Size { + let node = &nodes[idx]; + let pd = match node.pie_chart() { + Some(d) => d, + None => return Size::ZERO, + }; + + // Collect legend label widths from FlatBuffer vector into a Vec. + // This is needed because chart_measurement operates on &[f32] and the + // flatbuffers Vector does not implement Deref. + let widths: Vec = pd + .legend_label_widths() + .map(|v| (0..v.len()).map(|i| v.get(i)).collect()) + .unwrap_or_default(); + + chart_measurement( + pd.preferred_width(), + pd.total_height(), + pd.title_chrome(), + pd.legend_position(), + pd.legend_row_height(), + &widths, + known, + available, + visual_scale, + ) +} + +/// Measure a Cartesian chart (node_type = 22: BarChart, future Column/Line/Scatter). +/// Uses the same LytChartBase.computeLayout formula as PieChart, reading sizing +/// data from the ChartData table instead. Chrome height is computed in Rust +/// from the final width w, using the legend wrapping algorithm transplanted +/// from ChartLegendRenderer. +fn measure_chart( + nodes: &[FlatNode], + idx: usize, + known: Size>, + available: Size, + visual_scale: f32, +) -> Size { + let node = &nodes[idx]; + let cd = match node.chart_data() { + Some(d) => d, + None => return Size::ZERO, + }; + + // Collect legend label widths from FlatBuffer vector into a Vec. + let widths: Vec = cd + .legend_label_widths() + .map(|v| (0..v.len()).map(|i| v.get(i)).collect()) + .unwrap_or_default(); + + chart_measurement( + cd.preferred_width(), + cd.total_height(), + cd.title_chrome(), + cd.legend_position(), + cd.legend_row_height(), + &widths, + known, + available, + visual_scale, + ) +} + +/// Measure an isometric structure view (node_type = 26). The formula mirrors +/// LytStructureView.computeLayout term for term, with Java-precomputed +/// view_width and view_height (setViewSize or DEFAULT_WIDTH/HEIGHT) provided +/// via StructureViewData. Uses the shared scale_width/scale_height_for_width +/// helpers that replicate ResponsiveVisualSizing on the Rust side. +fn measure_structure_view( + nodes: &[FlatNode], + idx: usize, + known: Size>, + available: Size, + visual_scale: f32, +) -> Size { + let node = &nodes[idx]; + let sv = match node.structure_view_data() { + Some(d) => d, + None => return Size::ZERO, + }; + + let view_w = sv.view_width(); + let view_h = sv.view_height(); + + // targetWidth = scaleWidth(viewWidth, visualScale, 32) + let target_w = scale_width(view_w, visual_scale, 32.0); + // width = clamp(targetWidth, 1, availableWidth) + let avail_w = match available.width { + AvailableSpace::Definite(a) => a, + _ => f32::MAX, + }; + let w = target_w.max(1.0).min(avail_w); + // height = scaleHeightForWidth(viewWidth, viewHeight, width, 32) + let h = scale_height_for_width(view_w, view_h, w, 32.0); + + // Explicit style sizes (known dimensions from Taffy) win over content + // measurement — the caller's known.unwrap_or already handles this for + // the general case, but we include the logic for clarity. + Size { + width: w, + height: h, + } +} + +/// Measure a guidebook scene (node_type = 27). The formula mirrors +/// LytGuidebookScene.computeLayout term for term, with Java-precomputed +/// dock sizes, button column reserve, button total height, and bottom +/// control area height provided via GuidebookSceneData. The responsive +/// scene sizing (scale_width, dock clamping, computeResponsiveSceneHeight) +/// is replicated in Rust using available_width and visual_scale. +fn measure_guidebook_scene( + nodes: &[FlatNode], + idx: usize, + known: Size>, + available: Size, + visual_scale: f32, +) -> Size { + const MIN_RESPONSIVE_SCENE_SIZE: f32 = 16.0; + const BLOCK_STATS_DOCK_GAP: f32 = 4.0; // only used in dock clamping logic + const BLOCK_STATS_MIN_WIDTH: f32 = 32.0; + + let node = &nodes[idx]; + let gs = match node.guidebook_scene_data() { + Some(d) => d, + None => return Size::ZERO, + }; + + let scene_w = gs.scene_width(); + let scene_h = gs.scene_height(); + let reserve = gs.button_column_reserve(); + let buttons_total_h = gs.buttons_total_height(); + let mut left_dock = gs.left_dock(); + let mut right_dock = gs.right_dock(); + let top_dock = gs.top_dock(); + let bottom_dock = gs.bottom_dock(); + let bottom_ctrl_h = gs.bottom_control_area_height(); + let reserve_bottom = gs.reserve_bottom_control(); + + // targetSceneWidth = scaleWidth(width, visualScale, MIN_RESPONSIVE_SCENE_SIZE) + let target_scene_w = scale_width(scene_w, visual_scale, MIN_RESPONSIVE_SCENE_SIZE); + + // totalDesired = targetSceneWidth + reserve + leftDock + rightDock + let total_desired = target_scene_w + reserve + left_dock + right_dock; + + // availableWidth from Taffy + let avail_w = match available.width { + AvailableSpace::Definite(a) => a, + _ => f32::MAX, + }; + + // w = min(totalDesired, max(reserve + MIN_RESPONSIVE_SCENE_SIZE, availableWidth)) + let w = total_desired.min((reserve + MIN_RESPONSIVE_SCENE_SIZE).max(avail_w)); + + // availableForDocks = max(0, w - reserve - targetSceneWidth) + let available_for_docks = (w - reserve - target_scene_w).max(0.0); + + // Dock clamping: if left+right > availableForDocks, shrink proportionally + if left_dock + right_dock > available_for_docks { + if left_dock > 0.0 && right_dock > 0.0 { + left_dock = left_dock.min(available_for_docks / 2.0); + right_dock = right_dock.min(available_for_docks - left_dock); + } else if left_dock > 0.0 { + left_dock = left_dock.min(available_for_docks); + } else { + right_dock = right_dock.min(available_for_docks); + } + } + + // minDockSpace = BLOCK_STATS_MIN_WIDTH + BLOCK_STATS_DOCK_GAP + let min_dock_space = BLOCK_STATS_MIN_WIDTH + BLOCK_STATS_DOCK_GAP; + if left_dock > 0.0 && left_dock < min_dock_space { + left_dock = 0.0; + } + if right_dock > 0.0 && right_dock < min_dock_space { + right_dock = 0.0; + } + + // sceneW = max(MIN_RESPONSIVE_SCENE_SIZE, w - reserve - leftDock - rightDock) + let scene_w_responsive = (w - reserve - left_dock - right_dock).max(MIN_RESPONSIVE_SCENE_SIZE); + + // computeResponsiveSceneHeight(sceneW, buttonsTotalH) + let scene_h_responsive = compute_responsive_scene_height(scene_w, scene_h, scene_w_responsive, buttons_total_h, MIN_RESPONSIVE_SCENE_SIZE); + + // h = topDock + sceneH + (reserveBottomControlArea ? bottomControlAreaHeight : 0) + bottomDock + let h = top_dock + scene_h_responsive + (if reserve_bottom { bottom_ctrl_h } else { 0.0 }) + bottom_dock; + + // known dimensions (explicit style sizes) win over measured + Size { + width: known.width.unwrap_or(w), + height: known.height.unwrap_or(h), + } +} + +/// Mirrors LytGuidebookScene.computeResponsiveSceneHeight. +/// scene_width / scene_height are the intrinsic dimensions (setSceneSize or +/// defaults); actual_width is the responsive scene width after dock clamping. +fn compute_responsive_scene_height( + base_width: f32, + base_height: f32, + actual_width: f32, + buttons_total_h: f32, + min_size: f32, +) -> f32 { + let base_w = base_width.max(1.0); + let base_h = base_height.max(1.0); + if actual_width >= base_w { + return base_h.max(buttons_total_h); + } + let scale = actual_width / base_w; + let scaled_h = (base_h * scale).round().max(1.0).max(min_size); + scaled_h.max(buttons_total_h) +} + +/// Measure a function graph (node_type = 28). The formula mirrors +/// LytFunctionGraph.computeLayout term for term, with Java-precomputed +/// title_chrome, legend_row_height, and per-plot label_item_widths +/// (via FunctionGraphData). Uses shared scale_width/scale_height_for_width +/// helpers that replicate ResponsiveVisualSizing on the Rust side. +fn measure_function_graph( + nodes: &[FlatNode], + idx: usize, + known: Size>, + available: Size, + visual_scale: f32, +) -> Size { + const PADDING: f32 = 8.0; + const AXIS_PAD_LEFT: f32 = 28.0; + const AXIS_PAD_BOTTOM: f32 = 14.0; + const LEGEND_GAP_ABOVE: f32 = 4.0; + const LEGEND_ITEM_GAP: f32 = 10.0; + const LEGEND_ROW_GAP: f32 = 2.0; + const MIN_PLOT_HEIGHT: f32 = 88.0; + + let node = &nodes[idx]; + let fgd = match node.function_graph_data() { + Some(d) => d, + None => return Size::ZERO, + }; + + let base_w = fgd.base_width(); + let base_h = fgd.base_height(); + + // width = scaleWidth(baseWidth, visualScale, 72), clamped to [1, availableWidth] + let target_w = scale_width(base_w, visual_scale, 72.0); + let avail_w = match available.width { + AvailableSpace::Definite(a) => a, + _ => f32::MAX, + }; + let w = target_w.max(1.0).min(avail_w); + + // plotWidth = max(0, width - PADDING * 2 - AXIS_PAD_LEFT) + let plot_w = (w - PADDING * 2.0 - AXIS_PAD_LEFT).max(0.0); + + // fixedChromeHeight = PADDING * 2 + AXIS_PAD_BOTTOM + let mut fixed_chrome = PADDING * 2.0 + AXIS_PAD_BOTTOM; + + // if (title != null && !title.isEmpty()) fixedChrome += titleChrome (precomputed) + fixed_chrome += fgd.title_chrome(); + + // legendHeight = measureLegendHeight(plotWidth) + // Precomputed row height and per-label item widths; wrapping algorithm + // replicates LytFunctionGraph.measureLegendHeight. + let legend_row_h = fgd.legend_row_height(); + let legend_h = if legend_row_h > 0.0 { + let mut rows: i32 = 1; + let mut row_w: f32 = 0.0; + if let Some(widths) = fgd.label_item_widths() { + for i in 0..widths.len() { + let item_w = widths.get(i); + if item_w <= 0.0 { + continue; + } + let needed = if row_w == 0.0 { + item_w + } else { + row_w + LEGEND_ITEM_GAP + item_w + }; + if row_w > 0.0 && needed > plot_w { + rows += 1; + row_w = item_w; + } else { + row_w = needed; + } + } + } + // If rows stays 1 but no items had width > 0, the loop never + // ran (all labels empty or no plots). The Java code returns 0 + // for this case. Since we start at rows=1, check: legend_h = 0 + // when no items have been processed (row_w == 0.0). + if row_w == 0.0 { + 0.0 + } else { + rows as f32 * legend_row_h + (rows - 1) as f32 * LEGEND_ROW_GAP + } + } else { + 0.0 + }; + if legend_h > 0.0 { + fixed_chrome += legend_h + LEGEND_GAP_ABOVE; + } + + // height = scaleBodyHeightForWidth(baseWidth, baseHeight, width, fixedChrome, MIN_PLOT_HEIGHT) + let safe_total_h = base_h.max(1.0); + let safe_fixed_h = fixed_chrome.clamp(0.0, (safe_total_h - 1.0).max(0.0)); + let body_h = (safe_total_h - safe_fixed_h).max(1.0); + let scaled_body = scale_height_for_width(base_w, body_h, w, MIN_PLOT_HEIGHT); + let h = safe_fixed_h + scaled_body; + + // Explicit style sizes (known dimensions from Taffy) win over content + // measurement — the caller's known.unwrap_or already handles this. + Size { + width: known.width.unwrap_or(w), + height: known.height.unwrap_or(h), + } +} + +/// Measure a MediaWiki generated list block (node_type = 29). The formula mirrors +/// MediaWikiGeneratedListBlock.computeLayout term for term. The column-planning +/// algorithm (planColumns) depends on Java object data (entry sort keys, titles, +/// section grouping) and cannot be replicated in Rust. Java precomputes the max +/// column content height via MediaWikiGeneratedListData.max_content_height. +/// Rust adds the padding constants to produce the total block height. +/// Width is always availableWidth — the block fills the parent's content box. +fn measure_mediawiki_generated_list( + nodes: &[FlatNode], + idx: usize, + known: Size>, + available: Size, +) -> Size { + // Constants mirrored from MediaWikiGeneratedListBlock: + // private static final int TOP_PADDING = 6; + // private static final int BOTTOM_PADDING = 6; + const TOP_PADDING: f32 = 6.0; + const BOTTOM_PADDING: f32 = 6.0; + + let node = &nodes[idx]; + let data = match node.mediawiki_generated_list_data() { + Some(d) => d, + None => return Size::ZERO, + }; + + let max_content_h = data.max_content_height(); + + // Width: the block always fills available width (no intrinsic preference). + // Mirrors computeLayout: return new LytRect(x, y, availableWidth, ...). + let w = match available.width { + AvailableSpace::Definite(a) => a.max(0.0), + _ => 0.0, + }; + + // Height = TOP_PADDING + maxColumnContentHeight + BOTTOM_PADDING. + // Mirrors computeLayout: + // return new LytRect(x, y, availableWidth, TOP_PADDING + maxColumnHeight + BOTTOM_PADDING); + // and for empty entries: + // return new LytRect(x, y, availableWidth, TOP_PADDING + ROW_HEIGHT + BOTTOM_PADDING); + let h = TOP_PADDING + max_content_h + BOTTOM_PADDING; + + Size { + width: known.width.unwrap_or(w), + height: known.height.unwrap_or(h), + } +} + +/// Measure a MediaWiki special generated block (node_type = 30). +/// +/// Java passes width-independent font facts (title widths, subtitle word widths, +/// line-height constants, estimated heights). Rust computes columnWidth from +/// availableWidth, wraps subtitle words per entry, packs columns (shortest-column-first +/// for groups, even distribution for flat entries), and produces maxColumnHeight. +/// Width is always availableWidth — the block fills the parent's content box. +/// +/// Mirrors MediaWikiSpecialGeneratedBlock.computeLayout term for term, with the +/// entry-height computation now owned by Rust using the pre-measured word-width +/// array. This eliminates the T6a-found discrepancy between the lazy estimateEntryHeight +/// (hardcoded 9px, no wrapping) and computeEntryHeight (10px, wrapped by columnWidth). +fn measure_mediawiki_special_generated( + nodes: &[FlatNode], + idx: usize, + known: Size>, + available: Size, +) -> Size { + // Layout constants, mirrored from MediaWikiSpecialGeneratedBlock static fields. + const TOP_PADDING: f32 = 6.0; + const BOTTOM_PADDING: f32 = 6.0; + const SIDE_PADDING: f32 = 2.0; + const COLUMN_GAP: f32 = 10.0; + const GROUP_MARGIN: f32 = 6.0; + const HEADER_HEIGHT: f32 = 20.0; + const HEADER_MARGIN_TOP: f32 = 5.0; + const HEADER_MARGIN_BOTTOM: f32 = 5.0; + const ENTRY_HEIGHT: f32 = 20.0; + const ENTRY_GAP: f32 = 2.0; + const ICON_SIZE: f32 = 16.0; + const ICON_GAP: f32 = 4.0; + const LIST_MARKER_SIZE: f32 = 3.0; + const LIST_MARKER_GAP: f32 = 6.0; + const TITLE_SUBTITLE_GAP: f32 = 3.0; + const ENTRY_VERTICAL_PADDING_TOP: f32 = 3.0; + const ENTRY_VERTICAL_PADDING_BOTTOM: f32 = 3.0; + const LOAD_MORE_HEIGHT: f32 = 18.0; + const LOAD_MORE_MARGIN_TOP: f32 = 2.0; + // Line heights come from the serialized data: Java's + // GuideText.lineHeight(LINK_STYLE)/lineHeight(SUBTITLE_STYLE) (= 17 at + // scale 1). The fbs fields default to 10.0 for old serialized data. + // (Previously hardcoded 10.0 here, making the block ~1/3 too short.) + + let node = &nodes[idx]; + let data = match node.mediawiki_special_generated_data() { + Some(d) => d, + None => return Size::ZERO, + }; + + // Width: the block always fills available width (no intrinsic preference). + let w = match available.width { + AvailableSpace::Definite(a) => a.max(0.0), + _ => 0.0, + }; + + // ── Column width (mirrors Java computeLayout) ────────────────────────── + let inner_width = (w - SIDE_PADDING * 2.0).max(0.0); + let column_count = data.column_count().max(1) as usize; + let column_width = + ((inner_width - COLUMN_GAP * (column_count as f32 - 1.0)) / column_count as f32).max(1.0); + + // ── Read font-fact vectors ───────────────────────────────────────────── + let total_entries = data.total_entry_count() as usize; + let entry_title_widths = data.entry_title_widths(); + let entry_has_icon = data.entry_has_icon(); + let entry_subtitle_line_counts = data.entry_subtitle_line_counts(); + let subtitle_line_word_counts = data.subtitle_line_word_counts(); + let subtitle_word_widths = data.subtitle_word_widths(); + let subtitle_space_width = data.subtitle_space_width(); + + // Real line heights serialized from Java (GuideText.lineHeight), mirroring + // computeEntryHeight/rowContentHeight's getLineHeight(LINK_STYLE) and + // getLineHeight(SUBTITLE_STYLE). fbs defaults to 10.0 for old data. + let title_line_height = data.link_line_height(); + let subtitle_line_height = data.subtitle_line_height(); + + let group_cnt = data.group_count().max(0) as usize; + let group_title_widths = data.group_title_widths(); + let group_entry_counts = data.group_entry_counts(); + let group_estimated_heights = data.group_estimated_heights(); + + let has_more = data.has_more(); + + // ── Compute real entry height given columnWidth ──────────────────────── + // Mirrors computeEntryHeight: wrapping + line-height constants. + let compute_entry_height = |entry_idx: usize| -> f32 { + let has_icon = entry_has_icon + .as_ref() + .and_then(|v| if entry_idx < v.len() { Some(v.get(entry_idx)) } else { None }) + .unwrap_or(0i8) + != 0; + + let text_max_width = { + let reserve = LIST_MARKER_SIZE + + LIST_MARKER_GAP + + if has_icon { ICON_SIZE + ICON_GAP } else { 0.0 }; + (column_width - reserve).max(1.0) + }; + + let line_count = entry_subtitle_line_counts + .as_ref() + .and_then(|v| { + if entry_idx < v.len() { + Some(v.get(entry_idx) as usize) + } else { + None + } + }) + .unwrap_or(0); + + if line_count == 0 { + return ENTRY_HEIGHT; + } + + // ── Word-level wrapping ──────────────────────────────────────── + // Find the global line-index start for this entry within the flat arrays. + let line_start: usize = entry_subtitle_line_counts + .as_ref() + .map(|v| (0..entry_idx).map(|i| v.get(i) as usize).sum::()) + .unwrap_or(0); + + let mut total_wrapped: usize = 0; + if let (Some(wc_vec), Some(ww_vec)) = (subtitle_line_word_counts.as_ref(), subtitle_word_widths.as_ref()) { + // Compute word-index start: sum word counts of all lines before line_start. + let mut word_start: usize = 0; + for li in 0..line_start { + if li < wc_vec.len() { + word_start += wc_vec.get(li) as usize; + } + } + + for li in 0..line_count { + let global_line = line_start + li; + if global_line >= wc_vec.len() { + break; + } + let n_words = wc_vec.get(global_line) as usize; + if n_words == 0 { + continue; + } + + // Raw line width = word widths + spaces between words. + let raw_line_width: f32 = { + let mut sum = 0.0f32; + for wi in word_start..word_start + n_words { + if wi < ww_vec.len() { + sum += ww_vec.get(wi); + } + } + if n_words > 1 { + sum += subtitle_space_width * (n_words - 1) as f32; + } + sum + }; + + if raw_line_width <= text_max_width { + total_wrapped += 1; + } else { + // Word-wrap: mirrors Java appendWrappedLine. + let mut current_w: f32 = 0.0; + let mut sub_lines: usize = 0; + for wi in word_start..word_start + n_words { + if wi >= ww_vec.len() { + break; + } + let word_w = ww_vec.get(wi); + let needed = if current_w == 0.0 { + word_w + } else { + current_w + subtitle_space_width + word_w + }; + if current_w > 0.0 && needed > text_max_width { + sub_lines += 1; + current_w = word_w; + } else { + current_w = needed; + } + } + if current_w > 0.0 { + sub_lines += 1; + } + total_wrapped += sub_lines; + } + + word_start += n_words; + } + } + + if total_wrapped == 0 { + return ENTRY_HEIGHT; + } + + // Mirrors computeEntryHeight: + // contentHeight = max(ICON_SIZE, getLineHeight(LINK_STYLE) + TITLE_SUBTITLE_GAP + // + getLineHeight(SUBTITLE_STYLE) * subtitleLines.size()) + // height = max(ENTRY_HEIGHT, ENTRY_VERTICAL_PADDING_TOP + contentHeight + ENTRY_VERTICAL_PADDING_BOTTOM) + let content_height = (title_line_height + TITLE_SUBTITLE_GAP + + subtitle_line_height * total_wrapped as f32) + .max(ICON_SIZE); + (ENTRY_VERTICAL_PADDING_TOP + content_height + ENTRY_VERTICAL_PADDING_BOTTOM) + .max(ENTRY_HEIGHT) + }; + + // ── Packing & per-column height ──────────────────────────────────────── + let max_column_height: f32; + + if total_entries == 0 { + // Empty result: one row at ENTRY_HEIGHT (mirrors isEmpty branch). + max_column_height = ENTRY_HEIGHT; + } else if group_cnt > 0 { + // ── Grouped: shortest-column-first packing ───────────────────── + // Mirrors layoutColumns: assign each group to the shortest column + // using estimated heights, then recompute real heights. + let mut col_heights_est: Vec = vec![0.0; column_count]; + // For tracking which groups go to which column. + let mut col_groups: Vec> = vec![Vec::new(); column_count]; + + for g in 0..group_cnt { + // Find shortest column. + let target = col_heights_est + .iter() + .enumerate() + .min_by(|(_, a), (_, b)| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal)) + .map(|(i, _)| i) + .unwrap_or(0); + col_groups[target].push(g); + let est_h = group_estimated_heights + .as_ref() + .and_then(|v| if g < v.len() { Some(v.get(g)) } else { None }) + .unwrap_or(0.0); + col_heights_est[target] += est_h; + } + + // Compute real column heights using actual entry heights. + // Build per-group entry-index ranges. + let mut group_entry_start: Vec = Vec::with_capacity(group_cnt); + let mut cur: usize = 0; + for g in 0..group_cnt { + group_entry_start.push(cur); + let cnt = group_entry_counts + .as_ref() + .and_then(|v| if g < v.len() { Some(v.get(g) as usize) } else { None }) + .unwrap_or(0); + cur += cnt; + } + + let mut real_max: f32 = 0.0; + for col_g in &col_groups { + if col_g.is_empty() { + // Empty column gets no height contribution but we need to + // still consider it (prev max will capture the tallest). + continue; + } + let mut col_y: f32 = 0.0; + for &g in col_g { + // Group header. + let has_title = group_title_widths + .as_ref() + .and_then(|v| if g < v.len() { Some(v.get(g)) } else { None }) + .unwrap_or(0.0) + > 0.0; + if has_title { + col_y += HEADER_MARGIN_TOP + HEADER_HEIGHT + HEADER_MARGIN_BOTTOM; + } + // Entries in this group. + let start = group_entry_start[g]; + let end = group_entry_start.get(g + 1).copied().unwrap_or(cur); + for e in start..end { + col_y += compute_entry_height(e); + col_y += ENTRY_GAP; + } + col_y += GROUP_MARGIN; + } + real_max = real_max.max(col_y); + } + max_column_height = real_max; + } else { + // ── Flat: even distribution across columns ───────────────────── + // Mirrors layoutFlatColumns: perColumn = ceil(N / columnCount). + let per_column = ((total_entries + column_count - 1) / column_count).max(1); + let mut real_max: f32 = 0.0; + for col in 0..column_count { + let start = col * per_column; + if start >= total_entries { + break; + } + let end = (start + per_column).min(total_entries); + let mut col_y: f32 = 0.0; + for e in start..end { + col_y += compute_entry_height(e); + col_y += ENTRY_GAP; + } + // Flat entries are wrapped in a single no-title group per column. + col_y += GROUP_MARGIN; + real_max = real_max.max(col_y); + } + max_column_height = real_max; + } + + // hasMore adds LOAD_MORE_HEIGHT after the column content (mirrors Java). + let max_h = if has_more { + max_column_height + LOAD_MORE_MARGIN_TOP + LOAD_MORE_HEIGHT + } else { + max_column_height + }; + + let h = TOP_PADDING + max_h + BOTTOM_PADDING; + + Size { + width: known.width.unwrap_or(w), + height: known.height.unwrap_or(h), + } +} + +/// Mirrors ResponsiveVisualSizing.scaleWidth: apply a visual-scale factor +/// to a base width, then clamp. +fn scale_width(base_width: f32, visual_scale: f32, min_width: f32) -> f32 { + let safe_base = base_width.max(1.0); + let clamped = visual_scale.clamp(0.1, 1.0); + if clamped >= 0.999 { + return safe_base; + } + (safe_base * clamped).round().max(1.0).max(min_width) +} + +/// Mirrors ResponsiveVisualSizing.scaleHeightForWidth: proportionally scale +/// a base height when the actual width is narrower than the base width. +fn scale_height_for_width(base_width: f32, base_height: f32, actual_width: f32, min_height: f32) -> f32 { + let safe_base_w = base_width.max(1.0); + let safe_base_h = base_height.max(1.0); + let safe_actual_w = actual_width.max(1.0); + if safe_actual_w >= safe_base_w { + return safe_base_h; + } + let scale = safe_actual_w / safe_base_w; + (safe_base_h * scale).round().max(1.0).max(min_height) +} diff --git a/layout-engine/src/parley_text.rs b/layout-engine/src/parley_text.rs new file mode 100644 index 00000000..06c2d372 --- /dev/null +++ b/layout-engine/src/parley_text.rs @@ -0,0 +1,927 @@ +//! Parley text layout — the guide's line-box layer (migration target for the +//! cosmic shaping path). +//! +//! Owns the parley contexts (fontique FontContext + LayoutContext) and the +//! paragraph layout → positioned-glyph pipeline. Parley's `BreakLines` gives +//! per-line geometry control (`BreakerState.set_line_max_advance` / +//! `set_line_x`), so float wrapping is done by feeding each line its +//! available width from the clip query — no pre-split bands, no byte rebase, +//! no segmented re-shaping. Inline blocks are first-class `InlineBox`es +//! (width participates in wrapping; vertical growth stays with the Java-side +//! post-pass). Rasterization stays on the swash bridge. + +use std::sync::Arc; + +use parley::fontique; +use parley::{ + Alignment, AlignmentOptions, FontContext, FontData, FontFamily, FontFamilyName, FontWeight, + GenericFamily, InlineBox, InlineBoxKind, Layout, LayoutContext, LineHeight, OverflowWrap, + PositionedLayoutItem, StyleProperty, TextWrapMode, +}; + +/// Custom brush: carries the source span index (TextData.spans) through +/// shaping so each emitted glyph run can be tinted/decorated per span. +#[derive(Clone, Debug, Default, PartialEq)] +pub struct SpanBrush(pub u32); + +/// Parley-side font state riding inside [`crate::text::GuideFontSystem`] +/// alongside the (legacy) cosmic one during the migration. +pub struct ParleyFonts { + pub font_cx: FontContext, + pub layout_cx: LayoutContext, +} + +impl ParleyFonts { + pub fn new() -> Self { + Self { + font_cx: FontContext::new(), + layout_cx: LayoutContext::new(), + } + } + + pub fn load_font_data(&mut self, data: Vec) { + self.font_cx + .collection + .register_fonts(fontique::Blob::new(Arc::new(data)), None); + } + + /// Register an additional font file (e.g. a symbol font like + /// seguisym.ttf) and append its families to the Han fallback key so the + /// fontique Hani-fallback hack (collection/query.rs `set_fallbacks`) can + /// land Common-script symbols (ⓘ ✦ ➤ ⚠ ☢ — U+24D8/2726/27A4/26A0/2622) + /// that msyh.ttc lacks. + /// + /// Uses `append_fallbacks` — never `set_fallbacks` — so the system CJK + /// fallback list for the key is preserved and the symbol families land + /// AFTER it. Best-effort: empty data is a no-op. + pub fn load_fallback_font_data(&mut self, data: Vec) { + if data.is_empty() { + return; + } + let key = fontique::FallbackKey::new(fontique::Script::from_bytes(*b"Hani"), None); + let ids: Vec = self + .font_cx + .collection + .register_fonts(fontique::Blob::new(Arc::new(data)), None) + .into_iter() + .map(|(id, _)| id) + .collect(); + if ids.is_empty() { + return; + } + // Warm the system Hani fallback cache first so the appended symbol + // families are ordered after the system CJK fallbacks. + let _warm: Vec<_> = self.font_cx.collection.fallback_families(key).collect(); + for id in &ids { + self.font_cx.collection.append_fallbacks(key, core::iter::once(*id)); + } + // P5-C: register the symbol families as the leading generic Emoji + // family. ⚠ (U+26A0) / ☢ (U+2622) are classified emoji/pictograph by + // parley_data, so parley shapes them via `GenericFamily::Emoji` + // (parley shape/mod.rs:580-591) — the Hani fallback key above is + // bypassed entirely and the system resolves Segoe UI Emoji (COLR + // composite glyph), which collapses to a 22×10 fragment at 22px. + // `append_generic_families` lands the ids in `ours`, iterated before + // the system generic families (fontique collection/mod.rs:350-362), + // so the emoji query hits seguisym (Outline path, consistent with the + // monochrome pipeline) and stops. + self.font_cx + .collection + .append_generic_families(fontique::GenericFamily::Emoji, ids.iter().copied()); + } +} + +// ═══════════════ Phase 1: renderTextParley (window A/B) ═══════════════ + +impl ParleyFonts { + /// Lay out one single-style paragraph at `scaled_size` wrapped to + /// `max_width` (None = unwrapped), with line height + /// `scaled_size × line_height_rel`. + pub fn layout_styled( + &mut self, + text: &str, + scaled_size: f32, + line_height_rel: f32, + bold: bool, + max_width: Option, + ) -> Layout { + let mut builder = self + .layout_cx + .ranged_builder(&mut self.font_cx, text, 1.0, true); + builder.push_default(StyleProperty::FontSize(scaled_size)); + builder.push_default(StyleProperty::LineHeight(LineHeight::FontSizeRelative( + line_height_rel, + ))); + builder.push_default(StyleProperty::FontFamily(FontFamily::Single( + FontFamilyName::Generic(GenericFamily::SansSerif), + ))); + // R5-3/R5-4: emergency-break unbreakable runs (no-space CJK strings / + // overlong titles) at the line's advance limit instead of overflowing + // the content box. Mirrors CSS `overflow-wrap: break-word` — only + // lines with no fitting soft break point get intra-word breaks; normal + // text keeps breaking at spaces (NOT BreakAll, so Latin words do not + // fragment). + builder.push_default(StyleProperty::OverflowWrap(OverflowWrap::BreakWord)); + if bold { + builder.push_default(StyleProperty::FontWeight(FontWeight::BOLD)); + } + let mut layout = builder.build(text); + layout.break_all_lines(max_width); + layout.align(Alignment::Start, AlignmentOptions::default()); + layout + } + + /// Lay out one single-style paragraph at `font_size` wrapped to + /// `max_width` (None = unwrapped), with line height + /// `font_size × line_height_rel` (callers pass 10/9 for guide text, 1.5 + /// to A/B against the legacy renderText test window). + pub fn layout_paragraph( + &mut self, + text: &str, + font_size: f32, + line_height_rel: f32, + max_width: Option, + ) -> Layout { + self.layout_styled(text, font_size, line_height_rel, false, max_width) + } +} + +/// One rasterized glyph quad (RGBA bitmap + pixel position), matching the +/// RenderGlyph wire shape renderText emits. +pub struct RasterQuad { + pub x: i32, + pub y: i32, + pub w: u32, + pub h: u32, + pub rgba: Vec, +} + +/// Rasterize every glyph of a laid-out paragraph into RGBA quads (white text, +/// coverage as alpha — the guide text pipeline is monochrome, tinted at draw +/// time; color emoji bitmaps are out of scope). +pub fn rasterize_layout(layout: &Layout, font_size: f32) -> Vec { + let mut out = Vec::new(); + for line in layout.lines() { + for item in line.items() { + let PositionedLayoutItem::GlyphRun(gr) = item else { + continue; + }; + let fd = gr.run().font(); + let Some(font_ref) = swash::FontRef::from_index(fd.data.data(), fd.index as usize) + else { + continue; + }; + let mut ctx = swash::scale::ScaleContext::new(); + let mut scaler = ctx + .builder(font_ref) + .size(font_size) + .hint(true) + .build(); + for g in gr.positioned_glyphs() { + let Some(img) = swash::scale::Render::new(&[ + swash::scale::Source::ColorOutline(0), + swash::scale::Source::ColorBitmap(swash::scale::StrikeWith::BestFit), + swash::scale::Source::Outline, + ]) + .format(swash::zeno::Format::Alpha) + .render(&mut scaler, g.id as u16) else { + continue; + }; + let (w, h) = (img.placement.width as u32, img.placement.height as u32); + if w == 0 || h == 0 { + continue; + } + out.push(RasterQuad { + x: g.x as i32 + img.placement.left, + y: g.y as i32 - img.placement.top, + w, + h, + rgba: alpha_to_rgba(&img.data), + }); + } + } + } + out +} + +/// Alpha-mask bitmap → tightly packed white RGBA. +fn alpha_to_rgba(data: &[u8]) -> Vec { + let mut rgba = vec![0u8; data.len() * 4]; + for (i, &a) in data.iter().enumerate() { + rgba[i * 4] = 255; + rgba[i * 4 + 1] = 255; + rgba[i * 4 + 2] = 255; + rgba[i * 4 + 3] = a; + } + rgba +} + +// ═══════════════ Phase 2: paragraph shaping core ═══════════════ + +/// One registered document-level float, in absolute document coordinates. +/// The pusher owns the float table and hands it to paragraph shaping so the +/// line breaker can query the free interval per line in real time — there is +/// no precomputed clip table and no cross-boundary geometry (the "bridge" is +/// this in-process query). `right` mirrors CSS float side. +#[derive(Clone, Copy)] +pub struct FloatRect { + pub x: f32, + pub y: f32, + pub w: f32, + pub h: f32, + pub right: bool, +} + +/// One styled span: byte range into the ORIGINAL (unstripped) text + bold +/// flag. Index = position in TextData.spans; glyphs shaped from the range +/// report it back as their brush. +pub struct SpanStyle { + pub start: usize, + pub end: usize, + pub bold: bool, + /// Synthetic-italic flag, mirrored from the span's resolved style + /// (`TextStyle.italic`, serialized by LayoutNodeSerializer). Parley + /// shaping itself does not slant (no italic in the style properties), so + /// the flag rides along for the layout-side shear + kerning compensation + /// (layout.rs italic_kerning_compensate). + pub italic: bool, + pub baseline_shift: f32, +} + +/// One inline block to place: byte index of its U+FFFC anchor in the +/// ORIGINAL text + its layout width (paragraph-relative units). +/// `float_side`: None = regular inline, Some(1) = float-left, Some(2) = float-right. +pub struct InlineSpec { + pub anchor_byte: usize, + pub width: f32, + pub height: f32, + pub float_side: Option, + pub node: usize, +} + +pub struct ShapeRequest<'a> { + pub text: &'a str, + /// Rich spans covering the whole text in document order (empty = + /// single-style paragraph). + pub spans: &'a [SpanStyle], + /// Inline blocks in document order (paired with U+FFFC anchors). + pub inlines: &'a [InlineSpec], + /// Document-level floats registered so far (absolute coords); empty = + /// uniform-width paragraph. Queried per line against the line's absolute y. + pub floats: &'a [FloatRect], + /// Absolute document y of this paragraph's top edge; line y for the float + /// query is `para_abs_y + line_relative_y`. + pub para_abs_y: f32, + /// Absolute document x of this paragraph's content origin; float edges are + /// converted to paragraph-relative by subtracting this. + pub para_x: f32, + /// In-paragraph clear breaks (raw UTF-8 byte offset into the original text + /// + side 1=left 2=right 3=both), in document order. Mapped to cleaned-text + /// offsets inside shape_paragraph. + pub clears: &'a [(usize, u8)], + pub font_size: f32, + pub font_scale: f32, + pub max_width: f32, + pub justify: bool, + /// R4-17: per-paragraph text alignment. 0=Start(Left) 1=Center 2=End(Right) + pub alignment: i8, + /// FlatBuffer TextData.white_space: 0=Normal 1=PreWrap 2=Pre/NoWrap + /// (code blocks). Value 2 disables soft wrapping AND emergency + /// (break-word) wrapping so a long unbreakable code line stays on one + /// line and overflows horizontally instead of wrapping inside the + /// container. + pub white_space: i8, +} + +/// A shaped glyph in paragraph-local coordinates: (x, y) is the pen position +/// on the baseline; w is the advance. The font bytes ride along so the swash +/// rasterizer needs no other font database. +pub struct OutGlyph { + pub glyph_id: u32, + pub x: f32, + pub y: f32, + pub w: f32, + pub line_top: f32, + pub line_height: f32, + pub line_index: usize, + pub span_index: u32, + pub font: FontData, + pub font_size: f32, +} + +pub struct ParleyShaped { + pub glyphs: Vec, + /// Inline-box anchors in document order (consumed by the post-pass). + pub markers: Vec, + pub content_height: f32, + pub max_x: f32, + /// Absolute document y that the flow AFTER this paragraph must not rise + /// above, when the paragraph ends with a `
` whose drop no later + /// line inside the paragraph can carry (the common, trailing form). The + /// paragraph's own `content_height` is NOT inflated by it — the pusher + /// advances its cursor to this floor after the paragraph so the following + /// block (e.g. a callout) starts below the cleared float while this + /// paragraph's box still hugs its text. `None` when no such clear applies. + pub clear_floor: Option, + /// (x_off, line_width) of the last line in the paragraph, in paragraph- + /// relative coordinates. Used by the separator-line mechanism (kind=3 + /// DecorationRect) so LytHeading draws a themed separator across the + /// float-compressed full line window. + pub last_line_window: Option<(f32, f32)>, + /// Float-aligned inline block anchors: (flat_node_index, paragraph-relative y). + /// The x coordinate is computed later in inline_post_pass from the block's + /// align mode and the paragraph's content width. + pub float_anchors: Vec<(usize, f32)>, +} + +/// Shape one paragraph: spans → ranged styles, inline blocks → InlineBox, +/// float clips → per-line widths via BreakerState, then collect positioned +/// glyphs and inline markers. +/// +/// Float-aligned inline blocks trigger a two-pass shaping: pass 1 (full +/// width, all inlines as boxes) determines each float's anchor line; pass 2 +/// shapes with paragraph-level floats constraining subsequent line widths. +/// Regular paragraphs (no float inlines) take the fast one-pass path. +pub fn shape_paragraph(parley: &mut ParleyFonts, req: &ShapeRequest) -> ParleyShaped { + let scaled = req.font_size * req.font_scale; + + // ── Pre-processing: strip U+FFFC, build clean text ── + let mut clean = String::with_capacity(req.text.len()); + let mut box_clean_idx: Vec = Vec::with_capacity(req.inlines.len()); + let mut fffc_orig: Vec = Vec::with_capacity(req.inlines.len()); + for (i, ch) in req.text.char_indices() { + if ch == '\u{FFFC}' { + box_clean_idx.push(clean.len()); + fffc_orig.push(i); + } else { + clean.push(ch); + } + } + let adjust = |pos: usize| -> usize { + let n = fffc_orig.iter().take_while(|&&p| p < pos).count(); + pos - 3 * n + }; + let clean_clears: Vec<(usize, u8)> = + req.clears.iter().map(|(k, s)| (adjust(*k), *s)).collect(); + + let has_float = req.inlines.iter().any(|s| s.float_side.is_some()); + + // ── One-pass: fast path when no float inlines ── + if !has_float { + let mut b = parley.layout_cx.ranged_builder(&mut parley.font_cx, &clean, 1.0, true); + push_defaults(&mut b, scaled, req.white_space); + push_spans(&mut b, req.spans, &adjust, &clean); + push_inlines(&mut b, req.inlines, &box_clean_idx, false); + let mut layout = b.build(&clean); + break_and_align(&mut layout, req); + let (mut glyphs, markers, max_x, h, floor, last_window) = collect_layout( + &layout, req.floats, req.para_abs_y, req.para_x, req.max_width, &clean_clears, + ); + // R4-21: apply per-span baseline shift to glyph Y coordinates + for g in &mut glyphs { + let bs = req.spans.get(g.span_index as usize).map_or(0.0, |s| s.baseline_shift); + g.y += bs * scaled; + } + return ParleyShaped { + glyphs, + markers, + content_height: h, + max_x, + clear_floor: floor, + last_line_window: last_window, + float_anchors: Vec::new(), + }; + } + + // ── Two-pass: paragraph-level float inlines ── + + // Pass 1: all boxes (including floats), full width. Float blocks + // participate as inline boxes so their anchor line positions are correct. + let layout1 = { + let mut b = parley.layout_cx.ranged_builder(&mut parley.font_cx, &clean, 1.0, true); + push_defaults(&mut b, scaled, req.white_space); + push_spans(&mut b, req.spans, &adjust, &clean); + push_inlines(&mut b, req.inlines, &box_clean_idx, false); + let mut layout = b.build(&clean); + break_and_align(&mut layout, req); + layout + }; + + // Find float anchor line Y positions from pass 1 layout. + let mut para_floats: Vec = Vec::new(); + let mut float_anchor_ys: Vec<(usize, f32)> = Vec::new(); + for line in layout1.lines() { + let tr = line.text_range(); + let y = line.metrics().block_min_coord; + for (k, spec) in req.inlines.iter().enumerate() { + if k >= box_clean_idx.len() { + break; + } + if spec.float_side.is_none() { + continue; + } + if tr.contains(&box_clean_idx[k]) { + let abs_y = req.para_abs_y + y; + let side = spec.float_side.unwrap_or(1); + let fl = FloatRect { + x: if side == 1 { + req.para_x + } else { + (req.para_x + req.max_width - spec.width).max(req.para_x) + }, + y: abs_y, + w: spec.width.max(1.0), + h: spec.height.max(scaled * 1.55), + right: side == 2, + }; + para_floats.push(fl); + float_anchor_ys.push((spec.node, y)); + break; + } + } + } + + // Merge document floats + paragraph-local floats for pass 2. + let mut merged_floats: Vec = req.floats.to_vec(); + merged_floats.extend(para_floats.iter().cloned()); + + // Pass 2: skip float inline boxes, shape with constrained widths. + let layout2 = { + let mut b = parley.layout_cx.ranged_builder(&mut parley.font_cx, &clean, 1.0, true); + push_defaults(&mut b, scaled, req.white_space); + push_spans(&mut b, req.spans, &adjust, &clean); + push_inlines(&mut b, req.inlines, &box_clean_idx, true); + let mut layout = b.build(&clean); + if req.white_space == 2 { + layout.break_all_lines(None); + } else { + break_with_floats(&mut layout, req, &merged_floats, scaled); + } + layout.align( + resolve_alignment(req.justify, req.alignment), + AlignmentOptions::default(), + ); + layout + }; + + let (mut glyphs, markers, max_x, content_height, clear_floor, last_window) = collect_layout( + &layout2, &merged_floats, req.para_abs_y, req.para_x, req.max_width, &clean_clears, + ); + + // R4-21: apply per-span baseline shift to glyph Y coordinates + for g in &mut glyphs { + let bs = req.spans.get(g.span_index as usize).map_or(0.0, |s| s.baseline_shift); + g.y += bs * scaled; + } + + ParleyShaped { + glyphs, + markers, + content_height, + max_x, + clear_floor, + last_line_window: last_window, + float_anchors: float_anchor_ys, + } +} + +fn push_defaults(b: &mut parley::RangedBuilder, scaled: f32, white_space: i8) { + b.push_default(StyleProperty::FontSize(scaled)); + b.push_default(StyleProperty::LineHeight(LineHeight::FontSizeRelative(1.55))); + b.push_default(StyleProperty::FontFamily(FontFamily::Single( + FontFamilyName::Generic(GenericFamily::SansSerif), + ))); + if white_space == 2 { + // R6-2: white_space=2 (Pre/NoWrap, code blocks). NoWrap disables soft + // wrapping and OverflowWrap::Normal disables the emergency break-word + // pass, so a long unbreakable code line keeps its natural single line + // and overflows horizontally (the narrow container scrolls) instead of + // being chopped at the container's advance limit. + b.push_default(StyleProperty::TextWrapMode(TextWrapMode::NoWrap)); + b.push_default(StyleProperty::OverflowWrap(OverflowWrap::Normal)); + } else { + // R5-3/R5-4: emergency-break unbreakable runs (no-space CJK strings / + // overlong titles) at the line's advance limit instead of overflowing + // the content box. Mirrors CSS `overflow-wrap: break-word` — only + // lines with no fitting soft break point get intra-word breaks; normal + // text keeps breaking at spaces (NOT BreakAll, so Latin words do not + // fragment). + b.push_default(StyleProperty::OverflowWrap(OverflowWrap::BreakWord)); + } + b.push_default(StyleProperty::Brush(SpanBrush(0))); +} + +fn push_spans( + b: &mut parley::RangedBuilder, + spans: &[SpanStyle], + adjust: &dyn Fn(usize) -> usize, + text: &str, +) { + for (i, sp) in spans.iter().enumerate() { + let (s, e) = (adjust(sp.start), adjust(sp.end)); + if s >= e || e > text.len() { + continue; + } + b.push(StyleProperty::Brush(SpanBrush(i as u32)), s..e); + if sp.bold { + b.push(StyleProperty::FontWeight(FontWeight::BOLD), s..e); + } + } +} + +fn push_inlines( + b: &mut parley::RangedBuilder, + inlines: &[InlineSpec], + clean_idx: &[usize], + skip_floats: bool, +) { + for (k, spec) in inlines.iter().enumerate() { + if k >= clean_idx.len() { + break; + } + if skip_floats && spec.float_side.is_some() { + continue; + } + b.push_inline_box(InlineBox { + id: k as u64, + kind: InlineBoxKind::InFlow, + index: clean_idx[k], + width: spec.width, + height: 0.0, + }); + } +} + +fn break_and_align(layout: &mut Layout, req: &ShapeRequest) { + if req.white_space == 2 { + // R6-2: white_space=2 (Pre/NoWrap). Break at hard breaks only — + // break_all_lines(None) means max advance f32::MAX and NoWrap ignores + // the advance anyway, so every code line stays on one line. + layout.break_all_lines(None); + } else if req.floats.is_empty() { + layout.break_all_lines(Some(req.max_width)); + } else { + let est_h = req.font_size * req.font_scale * 1.55; + break_with_floats(layout, req, req.floats, est_h); + } + layout.align( + resolve_alignment(req.justify, req.alignment), + AlignmentOptions::default(), + ); +} + +/// R4-17: resolve text alignment from justify flag and per-paragraph alignment. +/// Paragraph-level alignment (1=Center, 2=End) takes precedence over justify. +/// Justify is applied only when alignment is default (0=Start/Left). +/// 0=Start(Left) 1=Center 2=End(Right) +fn resolve_alignment(justify: bool, alignment: i8) -> Alignment { + match alignment { + 1 => Alignment::Center, + 2 => Alignment::End, + _ if justify => Alignment::Justify, + _ => Alignment::Start, + } +} + +fn break_with_floats( + layout: &mut Layout, + req: &ShapeRequest, + floats: &[FloatRect], + est_h: f32, +) { + let mut breaker = layout.break_lines(); + breaker.state_mut().set_layout_max_advance(req.max_width.max(1.0)); + while !breaker.is_done() { + let rel_y = breaker.committed_y() as f32; + let (_, w) = + query_floats(req.para_abs_y + rel_y, est_h, req.para_x, req.max_width, floats); + breaker.state_mut().set_line_max_advance(w); + if breaker.break_next().is_none() { + break; + } + } + breaker.finish(); +} + +/// Collect positioned glyphs + inline markers from a laid-out paragraph, +/// applying per-line float x offsets and in-paragraph clear breaks. The +/// left-float indent lives ONLY here: the breaker sets just the per-line width +/// — under Justify, parley bakes a set_line_x origin into the glyph pens (line +/// fills [line_x, line_x+adv]), so setting it at break time would shift every +/// left-clipped line twice. +/// +/// `clears` are in-paragraph `
` breaks (cleaned-text byte offset + +/// side), in document order. After the line whose text range covers a break's +/// offset is laid out, every following line is dropped to the cleared floats' +/// bottom edge (`clear_floor`). This is exact for the only real-world form — a +/// clear at the paragraph's end (the break has no trailing text, so no line is +/// re-wrapped by the drop); a mid-paragraph clear drops later lines without +/// re-wrapping them (first-order: never mispositions into a float, only the +/// wrap of those later lines is approximate, and no real page uses that form). +/// Returns the paragraph content height including any clear-induced growth. +pub fn collect_layout( + layout: &Layout, + floats: &[FloatRect], + para_abs_y: f32, + para_x: f32, + max_width: f32, + clears: &[(usize, u8)], + ) -> (Vec, Vec, f32, f32, Option, Option<(f32, f32)>) { + let mut glyphs = Vec::new(); + let mut markers: Vec<(u64, crate::measure::InlineMarker)> = Vec::new(); + let mut max_x = 0.0f32; + let mut clear_floor: Option = None; // absolute y later lines must not rise above + let mut next_clear = 0usize; + let mut content_h = 0.0f32; + let mut last_window: Option<(f32, f32)> = None; + for (li, line) in layout.lines().enumerate() { + let m = line.metrics(); + let tr = line.text_range(); + let orig_top_abs = para_abs_y + m.block_min_coord; + let shift = clear_floor.map_or(0.0, |f| (f - orig_top_abs).max(0.0)); + let eff_top_abs = orig_top_abs + shift; + let (x_off, line_width) = if floats.is_empty() { + (0.0, max_width) + } else { + // Same query as the breaker, but at the (possibly clear-dropped) + // effective line top: a line pushed below the floats sees the full + // width, so its x-offset is 0 regardless of the exact dropped y. + query_floats(eff_top_abs, m.line_height, para_x, max_width, floats) + }; + for item in line.items() { + match item { + PositionedLayoutItem::GlyphRun(gr) => { + let span_index = gr.style().brush.0; + let fd = gr.run().font().clone(); + let fs = gr.run().font_size(); + for g in gr.positioned_glyphs() { + max_x = max_x.max(g.x + x_off + g.advance); + glyphs.push(OutGlyph { + glyph_id: g.id, + x: g.x + x_off, + y: g.y + shift, + w: g.advance, + line_top: m.block_min_coord + shift, + line_height: m.line_height, + line_index: li, + span_index, + font: fd.clone(), + font_size: fs, + }); + } + } + PositionedLayoutItem::InlineBox(bx) => { + max_x = max_x.max(bx.x + x_off + bx.width); + markers.push(( + bx.id, + crate::measure::InlineMarker { + pen_x: bx.x + x_off, + baseline_y: m.baseline + shift, + line_top: m.block_min_coord + shift, + line_height: m.line_height, + line_index: li, + advance: bx.width, + }, + )); + } + } + } + content_h = content_h.max(eff_top_abs + m.line_height - para_abs_y); + last_window = Some((x_off, line_width)); + // A clear takes effect after the line that covers its offset: the break + // sits at/after that line's text, so the line itself is not dropped but + // everything following it is. + while next_clear < clears.len() && clears[next_clear].0 <= tr.end { + let side = clears[next_clear].1; + let mut floor = 0.0f32; + for f in floats { + let side_match = + side == 3 || (side == 1 && !f.right) || (side == 2 && f.right); + if side_match { + floor = floor.max(f.y + f.h); + } + } + if floor > 0.0 { + clear_floor = Some(clear_floor.map_or(floor, |c| c.max(floor))); + } + next_clear += 1; + } + } + // A trailing clear (break after the last line's text — the only real-world + // form) has no following line inside this paragraph to carry its drop, so + // its floor is NOT added to this paragraph's height (that would stretch the + // box and leave a blank gap, the "callout not hugging" bug). Instead the + // floor is returned for the pusher to advance its cursor past it. A mid- + // paragraph clear needs no such hand-off: its dropped later lines already + // raised content_h via eff_top_abs, so the natural cursor advance already + // clears the floor. + markers.sort_by_key(|(id, _)| *id); + ( + glyphs, + markers + .into_iter() + .map(|(_, m)| m) + .collect(), + max_x, + content_h, + clear_floor, + last_window, + ) +} + +/// The free horizontal interval (paragraph-relative) for a line whose absolute +/// top is `abs_y` and height `h`: the node width minus every float intersecting +/// that absolute band, with float edges converted to paragraph-relative by +/// `para_x`. Left floats push the left edge right; right floats pull the right +/// edge left. +fn query_floats( + abs_y: f32, + h: f32, + para_x: f32, + node_w: f32, + floats: &[FloatRect], +) -> (f32, f32) { + let mut x0 = 0.0f32; + let mut x1 = node_w; + for f in floats { + if f.y + f.h <= abs_y || f.y >= abs_y + h { + continue; + } + if f.right { + x1 = x1.min(f.x - para_x); + } else { + x0 = x0.max(f.x + f.w - para_x); + } + } + (x0, (x1 - x0).max(1.0)) +} + +/// One rasterized glyph quad with its atlas key (same wire role as +/// layout.rs's cosmic RasterizedGlyph, produced from parley shaping). +pub struct ParleyRasterGlyph { + pub bitmap_key: u64, + pub x: f32, + pub y: f32, + pub w: f32, + pub h: f32, + pub line_index: u32, + pub span_index: u32, +} + +/// Glyph rasterization size ceiling — the F4 bleed-stop (defense-in-depth). +/// +/// Diagnosis (numerically closed): the live 23s/441-WARN flood comes from +/// glyphs rasterized at 1089–1452 ppem (bitmaps 966×1086 / 1402×1517), +/// traced back to `size = g.font_size × render_scale` below. The normal +/// live path tops out at 11 × 2.5(MAX_ZOOM) × 4 = 110 ppem; the +/// fontScale≈33 injection point that feeds this multiplier is NOT yet +/// located — every static path is value-bounded, so the oversized size must +/// arrive via an unidentified live path. +/// +/// THIS CLAMP IS THE TOURNIQUET, NOT THE FIX. The primary repair is +/// locating and fixing the injection point (the diagnostic log emitted on +/// the first clamp per key is the tracing payload for that hunt). This +/// ceiling only stops the symptom: oversized glyphs rasterize at 128 ppem +/// and — because the atlas key below is derived from the CLAMPED size — +/// all oversize injections collapse onto one shared 128ppem atlas entry +/// instead of flooding the glyph atlas with giant bitmaps. +/// +/// Normal glyphs (≤110 ppem, i.e. the entire legitimate range) take the +/// identical code path: `size` is untouched and the key is identical, so +/// rasterization output is byte-for-byte unchanged. +const MAX_RASTER_SIZE: f32 = 128.0; + +/// Fallback rasterization size for pathological font sizes — the F4 +/// root-cause repair (runtime-closed): ALL +/// 186 giant glyphs arrived with fontScale=0.0. Java passes ShapeTextInput +/// fontScale=0 → `scaled = font_size × font_scale = 0` → parley shapes at +/// size 0 → `OutGlyph.font_size = 0` (or NaN on some paths). Then +/// `raw_size = font_size × render_scale` is 0/NaN and the `> MAX_RASTER_SIZE` +/// clamp above is vacuous (0>128=false; NaN>128=false) — swash renders at +/// size 0/NaN and emits the glyph's raw outline coordinates as a giant +/// bitmap (1371×1516 etc). +/// +/// This fallback is NOT a clamp: it replaces an invalid size with a +/// legitimate one. 22ppem = 11pt × 2 — the standard body size at the +/// default 2× render scale — so these glyphs render at normal size instead +/// of raw outline coordinates. Because the atlas key is derived from the +/// final size, all fallback glyphs share one 22ppem atlas entry. +const DEFAULT_RASTER_SIZE: f32 = 22.0; + +/// Atlas keys whose oversize clamp has already been reported. Process-wide +/// so a flood spanning many layout calls still logs exactly once per key — +/// the diagnostic must not itself become a log flood. A poisoned lock (a +/// panic elsewhere in this thread) is skipped silently: reporting is +/// best-effort and must never alter rasterization. +static CLAMP_REPORTED: std::sync::LazyLock>> = + std::sync::LazyLock::new(|| std::sync::Mutex::new(std::collections::HashSet::new())); + +/// Rasterize shaped glyphs: pen positions → swash bitmaps, deduplicated by a +/// stable content key (font bytes ptr, face index, glyph id, size). Pen +/// positions snap to the integer grid — the MC pixel grid wants integer +/// placement anyway (subpixel bins deferred as a calibration item). +pub fn rasterize_out_glyphs( + glyphs: &[OutGlyph], + render_scale: f32, +) -> (Vec, Vec<(u64, u32, u32, Vec)>) { + use std::collections::hash_map::DefaultHasher; + use std::hash::{Hash, Hasher}; + + let mut quads = Vec::new(); + let mut bitmaps: Vec<(u64, u32, u32, Vec)> = Vec::new(); + let mut placements: std::collections::HashMap = Default::default(); + let mut ctx = swash::scale::ScaleContext::new(); + + for g in glyphs { + let Some(font_ref) = swash::FontRef::from_index(g.font.data.data(), g.font.index as usize) + else { + continue; + }; + let raw_size = g.font_size * render_scale; + // F4 bleed-stop: clamp the rasterization size before it reaches the + // swash scaler. Clamped glyphs share one key (derived below from the + // clamped size), so the atlas cannot be flooded by giant bitmaps. + let clamped = raw_size > MAX_RASTER_SIZE; + // F4 root-cause: fontScale=0 injection makes `font_size` 0 (or NaN), + // so raw_size is 0/NaN and the >MAX clamp above is vacuous + // (0>128=false; NaN>128=false) — swash would render at size 0/NaN and + // emit the glyph's raw outline coordinates as a giant bitmap. Fall + // back to DEFAULT_RASTER_SIZE instead. `clamped` keeps its exact + // meaning (`raw_size > MAX_RASTER_SIZE`, only ever true for finite + // positive raw_size); the two conditions are mutually exclusive. + let fallback = !raw_size.is_finite() || raw_size <= 0.0; + let size = if fallback { + DEFAULT_RASTER_SIZE + } else { + raw_size.min(MAX_RASTER_SIZE) + }; + let xi = (g.x * render_scale).trunc() as i32; + let yi = (g.y * render_scale).trunc() as i32; + + let mut h = DefaultHasher::new(); + (g.font.data.data().as_ptr(), g.font.index, g.glyph_id, size.to_bits()).hash(&mut h); + let key = h.finish(); + + let placement = match placements.get(&key) { + Some(p) => *p, + None => { + let mut scaler = ctx + .builder(font_ref) + .size(size) + .hint(true) + .build(); + let Some(img) = swash::scale::Render::new(&[ + swash::scale::Source::ColorOutline(0), + swash::scale::Source::ColorBitmap(swash::scale::StrikeWith::BestFit), + swash::scale::Source::Outline, + ]) + .format(swash::zeno::Format::Alpha) + .render(&mut scaler, g.glyph_id as u16) else { + continue; + }; + let (w, hh) = (img.placement.width as u32, img.placement.height as u32); + if w == 0 || hh == 0 { + continue; + } + // F4 bleed-stop diagnostic: first oversize clamp per key logs + // the injection shape (font_size, render_scale, raw size, + // bitmap w×h) once, process-wide — enough to pinpoint the + // live injection point on the next reproduction without the + // diagnostic itself flooding the log. + if clamped { + if let Ok(mut reported) = CLAMP_REPORTED.lock() { + if reported.insert(key) { + eprintln!( + "[guide_layout_engine][WARN] glyph rasterize size clamped \ + (F4 bleed-stop): font_size={} render_scale={} raw_size={} \ + bitmap={}x{} clamped_to={}ppem glyph_id={}", + g.font_size, + render_scale, + raw_size, + w, + hh, + MAX_RASTER_SIZE, + g.glyph_id + ); + } + } + } + let p = (img.placement.left, img.placement.top, w, hh); + bitmaps.push((key, w, hh, alpha_to_rgba(&img.data))); + placements.insert(key, p); + p + } + }; + let (left, top, w, hh) = placement; + quads.push(ParleyRasterGlyph { + bitmap_key: key, + x: (xi + left) as f32 / render_scale, + y: (yi - top) as f32 / render_scale, + w: w as f32 / render_scale, + h: hh as f32 / render_scale, + line_index: g.line_index as u32, + span_index: g.span_index, + }); + } + (quads, bitmaps) +} diff --git a/layout-engine/src/style_convert.rs b/layout-engine/src/style_convert.rs new file mode 100644 index 00000000..ffce3d0e --- /dev/null +++ b/layout-engine/src/style_convert.rs @@ -0,0 +1,174 @@ +use crate::fb::Style as FbStyle; +use taffy::prelude::*; +use taffy::style::{Clear, Float, Overflow}; + +/// Convert FlatBuffer Dimension → Taffy Dimension +fn fb_dim(unit: u8, value: f32) -> Dimension { + match unit { + 1 => Dimension::length(value), + 2 => Dimension::percent(value / 100.0), + _ => Dimension::AUTO, + } +} + +/// Convert FlatBuffer Dimension → LengthPercentageAuto (for margin) +fn fb_to_lpa(unit: u8, value: f32, auto: bool) -> LengthPercentageAuto { + if auto { + return LengthPercentageAuto::AUTO; + } + match unit { + 1 => LengthPercentageAuto::length(value), + 2 => LengthPercentageAuto::percent(value / 100.0), + _ => LengthPercentageAuto::AUTO, + } +} + +/// Convert FlatBuffer Dimension → LengthPercentage (for padding/border) +fn fb_to_lp(unit: u8, value: f32) -> LengthPercentage { + match unit { + 1 => LengthPercentage::length(value), + 2 => LengthPercentage::percent(value / 100.0), + _ => LengthPercentage::length(0.0), + } +} + +/// Convert a FlatBuffer byte to Dimension (for simple getters) +fn dim_from_opt(opt: Option) -> (u8, f32) { + match opt { + Some(d) => (d.unit() as u8, d.value()), + None => (0, 0.0), + } +} + +/// Full conversion: FlatBuffer Style → Taffy Style +pub fn flat_style_to_taffy(fb: &FbStyle) -> Style { + let (gw, gv) = dim_from_opt(fb.gap_w()); + let (gh, hv) = dim_from_opt(fb.gap_h()); + let (sw, sv) = dim_from_opt(fb.size_w()); + let (sh, shv) = dim_from_opt(fb.size_h()); + let (mnw, mnwv) = dim_from_opt(fb.min_w()); + let (mnh, mnhv) = dim_from_opt(fb.min_h()); + let (mxw, mxwv) = dim_from_opt(fb.max_w()); + let (mxh, mxhv) = dim_from_opt(fb.max_h()); + let (fbv, fbwv) = dim_from_opt(fb.flex_basis()); + let (it, itv) = dim_from_opt(fb.inset_top()); + let (ir, irv) = dim_from_opt(fb.inset_right()); + let (ib, ibv) = dim_from_opt(fb.inset_bottom()); + let (il, ilv) = dim_from_opt(fb.inset_left()); + + Style { + display: match fb.display() { + 1 => Display::Grid, + 2 => Display::Block, + 3 => Display::None, + _ => Display::Flex, + }, + flex_direction: match fb.flex_direction() { + 1 => FlexDirection::Column, + _ => FlexDirection::Row, + }, + flex_wrap: match fb.flex_wrap() { + 1 => FlexWrap::Wrap, + _ => FlexWrap::NoWrap, + }, + align_items: match fb.align_items() { + 1 => Some(AlignItems::CENTER), + 2 => Some(AlignItems::FLEX_END), + 3 => Some(AlignItems::STRETCH), + 4 => Some(AlignItems::BASELINE), + _ => Some(AlignItems::FLEX_START), + }, + align_self: match fb.align_self() { + 1 => Some(AlignSelf::FLEX_START), + 2 => Some(AlignSelf::CENTER), + 3 => Some(AlignSelf::FLEX_END), + 4 => Some(AlignSelf::STRETCH), + _ => None, + }, + justify_content: match fb.justify_content() { + 1 => Some(JustifyContent::CENTER), + 2 => Some(JustifyContent::FLEX_END), + 3 => Some(JustifyContent::SPACE_BETWEEN), + 4 => Some(JustifyContent::SPACE_AROUND), + 5 => Some(JustifyContent::SPACE_EVENLY), + _ => Some(JustifyContent::FLEX_START), + }, + gap: Size { width: fb_to_lp(gw, gv), height: fb_to_lp(gh, hv) }, + size: Size { + width: fb_dim(sw, sv), + height: fb_dim(sh, shv), + }, + min_size: Size { + width: fb_dim(mnw, mnwv), + height: fb_dim(mnh, mnhv), + }, + max_size: Size { + width: fb_dim(mxw, mxwv), + height: fb_dim(mxh, mxhv), + }, + aspect_ratio: if fb.aspect_ratio() > 0.0 { + Some(fb.aspect_ratio()) + } else { + None + }, + margin: Rect { + left: fb_to_lpa(1, fb.margin_left(), fb.margin_auto_left()), + right: fb_to_lpa(1, fb.margin_right(), fb.margin_auto_right()), + top: fb_to_lpa(1, fb.margin_top(), fb.margin_auto_top()), + bottom: fb_to_lpa(1, fb.margin_bottom(), fb.margin_auto_bottom()), + }, + padding: Rect { + left: fb_to_lp(1, fb.padding_left()), + right: fb_to_lp(1, fb.padding_right()), + top: fb_to_lp(1, fb.padding_top()), + bottom: fb_to_lp(1, fb.padding_bottom()), + }, + border: Rect { + left: fb_to_lp(1, fb.border_left()), + right: fb_to_lp(1, fb.border_right()), + top: fb_to_lp(1, fb.border_top()), + bottom: fb_to_lp(1, fb.border_bottom()), + }, + overflow: taffy::geometry::Point { + x: match fb.overflow() { + 1 => Overflow::Hidden, + 2 => Overflow::Scroll, + _ => Overflow::Visible, + }, + y: match fb.overflow() { + 1 => Overflow::Hidden, + 2 => Overflow::Scroll, + _ => Overflow::Visible, + }, + }, + flex_grow: fb.flex_grow(), + flex_shrink: fb.flex_shrink(), + flex_basis: fb_dim(fbv, fbwv), + position: match fb.position() { + 1 => Position::Absolute, + _ => Position::Relative, + }, + inset: Rect { + left: fb_to_lpa(il, ilv, false), + right: fb_to_lpa(ir, irv, false), + top: fb_to_lpa(it, itv, false), + bottom: fb_to_lpa(ib, ibv, false), + }, + // Float and Clear are feature-gated behind float_layout + // which is enabled in our Cargo.toml + float: if fb.float() == 1 { + Float::Left + } else if fb.float() == 2 { + Float::Right + } else { + Float::None + }, + clear: match fb.clear() { + 1 => Clear::Left, + 2 => Clear::Right, + 3 => Clear::Both, + _ => Clear::None, + }, + ..Default::default() + } +} diff --git a/layout-engine/src/text.rs b/layout-engine/src/text.rs new file mode 100644 index 00000000..1af4cc0d --- /dev/null +++ b/layout-engine/src/text.rs @@ -0,0 +1,22 @@ +/// Persistent font state per LayoutBridge handle. Only the parley contexts +/// remain; the legacy cosmic-text shaping/rasterization path was removed once +/// parley took over measureLayout and shapeText (P5). +pub struct GuideFontSystem { + pub parley: crate::parley_text::ParleyFonts, +} + +impl GuideFontSystem { + pub fn new() -> Self { + Self { + parley: crate::parley_text::ParleyFonts::new(), + } + } + + pub fn load_font_data(&mut self, data: Vec) { + self.parley.load_font_data(data); + } + + pub fn load_fallback_font_data(&mut self, data: Vec) { + self.parley.load_fallback_font_data(data); + } +} diff --git a/src/main/java/com/hfstudio/guidenh/ClientProxy.java b/src/main/java/com/hfstudio/guidenh/ClientProxy.java index 2d7ad07d..9b58179e 100644 --- a/src/main/java/com/hfstudio/guidenh/ClientProxy.java +++ b/src/main/java/com/hfstudio/guidenh/ClientProxy.java @@ -18,6 +18,8 @@ import com.hfstudio.guidenh.config.ModConfig; import com.hfstudio.guidenh.guide.internal.DefaultGuideResourcePackManager; import com.hfstudio.guidenh.guide.internal.GuideDevelopmentResourcePackWatcher; +import com.hfstudio.guidenh.guide.internal.headless.GuideNhHeadlessWindow; +import com.hfstudio.guidenh.guide.internal.headless.GuideNhHeadlessRenderDriver; import com.hfstudio.guidenh.guide.internal.GuideME; import com.hfstudio.guidenh.guide.internal.GuideOnStartup; import com.hfstudio.guidenh.guide.internal.GuideReloadListener; @@ -90,6 +92,7 @@ import cpw.mods.fml.common.event.FMLInitializationEvent; import cpw.mods.fml.common.event.FMLLoadCompleteEvent; import cpw.mods.fml.common.event.FMLPostInitializationEvent; +import cpw.mods.fml.common.FMLCommonHandler; import cpw.mods.fml.common.event.FMLPreInitializationEvent; import cpw.mods.fml.common.eventhandler.SubscribeEvent; import cpw.mods.fml.common.network.FMLNetworkEvent; @@ -111,6 +114,7 @@ public static CompileWorker getWorker() { @Override public void preInit(FMLPreInitializationEvent event) { super.preInit(event); + GuideNhHeadlessWindow.installEarly(); GuidebookLevel.setPreviewWorldFactory(GuidebookFakeWorld::new); GuideNhClientIntegrationBootstrap.preInitClient(); GuideME.initClientProxy(); @@ -228,6 +232,7 @@ public void init(FMLInitializationEvent event) { ModConfig.runtimeBridge.maxSubscriptions, ModConfig.runtimeBridge.maxConnections, ModConfig.runtimeBridge.maxDeltaEntries)); + GuideNhHeadlessWindow.hideNow(); } @Override @@ -243,6 +248,22 @@ public void completeInit(FMLLoadCompleteEvent event) { MasterScheduler.getInstance() .submit(new DevWatchWorkItem()); GuideOnStartup.init(); + + if (Boolean.getBoolean("guidenh.headlessRender")) { + GuideNhHeadlessRenderDriver.HeadlessRenderConfig config = + GuideNhHeadlessRenderDriver.parseConfig(); + if (config == null) { + GuideDebugLog.error( + "[GuideNH] [HeadlessRender] Invalid headless render configuration, exiting"); + FMLCommonHandler.instance().exitJava(1, false); + return; + } + GuideDebugLog.infoAlways( + "[GuideNH] [HeadlessRender] Registering headless render driver"); + FMLCommonHandler.instance() + .bus() + .register(new GuideNhHeadlessRenderDriver(config)); + } } @SubscribeEvent diff --git a/src/main/java/com/hfstudio/guidenh/client/command/GuideNhClientCommand.java b/src/main/java/com/hfstudio/guidenh/client/command/GuideNhClientCommand.java index 33b044a3..1cb59c71 100644 --- a/src/main/java/com/hfstudio/guidenh/client/command/GuideNhClientCommand.java +++ b/src/main/java/com/hfstudio/guidenh/client/command/GuideNhClientCommand.java @@ -6,12 +6,14 @@ import java.util.ArrayList; import java.util.List; +import net.minecraft.client.Minecraft; import net.minecraft.command.CommandBase; import net.minecraft.command.CommandException; import net.minecraft.command.ICommandSender; import net.minecraft.entity.Entity; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.util.AxisAlignedBB; +import net.minecraft.util.ChatComponentText; import net.minecraft.util.ChatComponentTranslation; import net.minecraft.util.MathHelper; import net.minecraft.util.ResourceLocation; @@ -36,13 +38,18 @@ import com.hfstudio.guidenh.guide.siteexport.site.GuideSiteExportOptions; import com.hfstudio.guidenh.guide.siteexport.site.GuideSiteExportTask; import com.hfstudio.guidenh.guide.siteexport.site.GuideSiteOutputPaths; +import com.hfstudio.guidenh.guide.internal.headless.RenderPageService; +import com.hfstudio.guidenh.guide.scene.support.GuideDebugLog; public class GuideNhClientCommand extends CommandBase { public static final String[] ROOT_SUB_COMMANDS = { "editor", "guideeditor", "guideedit", "list", "open", "reload", - "search", "export", "exportsite", "exportstructure", "dumppagelang", "pos1", "pos2", "clearselection" }; + "search", "export", "exportsite", "exportstructure", "dumppagelang", "pos1", "pos2", "clearselection", + "renderpage" }; public static final String[] EXPORT_STRUCTURE_FLAGS = { "--mode", "snbt", "snbt_e", "blocks", "blocks_e" }; public static final String[] EXPORT_SITE_FLAGS = { "--ponder-frames", "--ponder-every-tick" }; + public static final String[] RENDERPAGE_FLAGS = { "--guide", "--page", "--md", "--width", "--out", "--lang", "--bounds", + "--overlay", "--scale" }; @Override public String getCommandName() { @@ -90,6 +97,7 @@ public void processCommand(ICommandSender sender, String[] args) throws CommandE if (!requireSceneExportEnabled(sender)) return; clearSelection(sender); } + case "renderpage" -> renderPage(sender, args); default -> send(sender, GuidebookText.CommandClientUsage); } } @@ -115,6 +123,9 @@ public List addTabCompletionOptions(ICommandSender sender, String[] args if (args.length >= 2 && args[0].equalsIgnoreCase("exportstructure")) { return getListOfStringsMatchingLastWord(args, EXPORT_STRUCTURE_FLAGS); } + if (args.length >= 2 && args[0].equalsIgnoreCase("renderpage")) { + return getListOfStringsMatchingLastWord(args, RENDERPAGE_FLAGS); + } return List.of(); } @@ -431,6 +442,134 @@ private void clearSelection(ICommandSender sender) { send(sender, GuidebookText.RegionWandSelectionCleared); } + // ---- renderpage -------------------------------------------------------- + + private void renderPage(ICommandSender sender, String[] args) { + RenderPageOptions opts = parseRenderPageOptions(args); + + if (opts.guideId() == null) { + sender.addChatMessage(new ChatComponentText( + "§cUsage: /guidenhc renderpage --guide [--page | --md ] [--width ] [--out ] [--lang ] [--bounds] [--overlay] [--scale <1-4>]")); + return; + } + + boolean hasPage = opts.pageId() != null; + boolean hasMd = opts.mdFile() != null; + if (!hasPage && !hasMd) { + sender.addChatMessage(new ChatComponentText("§cError: Either --page or --md is required.")); + return; + } + if (hasPage && hasMd) { + sender.addChatMessage(new ChatComponentText("§cError: --page and --md are mutually exclusive.")); + return; + } + + if (opts.widthError() != null) { + sender.addChatMessage(new ChatComponentText( + "§cInvalid --width value: '" + opts.widthError() + "', should be integer between 100-4096")); + return; + } + + if (opts.width() < 100 || opts.width() > 4096) { + sender.addChatMessage(new ChatComponentText("§cError: --width must be between 100 and 4096.")); + return; + } + + if (opts.scaleError() != null) { + sender.addChatMessage(new ChatComponentText( + "§cInvalid --scale value: '" + opts.scaleError() + "', must be integer between 1-4")); + return; + } + if (opts.scale() < 1 || opts.scale() > 4) { + sender.addChatMessage(new ChatComponentText("§cError: --scale must be between 1 and 4.")); + return; + } + + try { + RenderPageService.RenderPageResult result = RenderPageService.render( + new RenderPageService.RenderPageRequest( + opts.guideId(), + opts.pageId(), + opts.mdFile(), + opts.language(), + opts.width(), + opts.outDir(), + opts.emitBoundsJson(), + opts.emitDebugOverlay(), + opts.scale() + ) + ); + sender.addChatMessage(new ChatComponentText( + String.format("§aRenderPage success: PNG=%s, %dx%dpx, %d blocks", + result.pngPath(), result.widthPx(), result.heightPx(), result.blockCount()))); + } catch (RenderPageService.RenderPageException e) { + sender.addChatMessage(new ChatComponentText( + String.format("§cRenderPage failed at %s: %s", e.getStage(), e.getMessage()))); + } catch (Throwable t) { + sender.addChatMessage(new ChatComponentText("§cRenderPage internal error: " + getErrorMessage(t))); + GuideDebugLog.error("RenderPage internal error", t); + } + } + + private RenderPageOptions parseRenderPageOptions(String[] args) { + String guideId = null; + String pageId = null; + Path mdFile = null; + int width = 900; + String widthError = null; + Path outDir = Minecraft.getMinecraft().mcDataDir.toPath().resolve("screenshots"); + String language = "en_us"; + boolean emitBoundsJson = false; + boolean emitDebugOverlay = false; + int scale = 1; + String scaleError = null; + + for (int i = 1; i < args.length; i++) { + String arg = args[i]; + switch (arg.toLowerCase()) { + case "--guide" -> { + if (i + 1 < args.length) guideId = args[++i]; + } + case "--page" -> { + if (i + 1 < args.length) pageId = args[++i]; + } + case "--md" -> { + if (i + 1 < args.length) mdFile = Paths.get(args[++i]); + } + case "--width" -> { + if (i + 1 < args.length) { + String raw = args[++i]; + try { + width = Integer.parseInt(raw); + } catch (NumberFormatException e) { + widthError = raw; + } + } + } + case "--out" -> { + if (i + 1 < args.length) outDir = Paths.get(args[++i]).toAbsolutePath(); + } + case "--lang" -> { + if (i + 1 < args.length) language = args[++i]; + } + case "--bounds" -> emitBoundsJson = true; + case "--overlay" -> emitDebugOverlay = true; + case "--scale" -> { + if (i + 1 < args.length) { + String raw = args[++i]; + try { + scale = Integer.parseInt(raw); + } catch (NumberFormatException e) { + scaleError = raw; + } + } + } + } + } + + return new RenderPageOptions(guideId, pageId, mdFile, width, outDir, language, emitBoundsJson, emitDebugOverlay, widthError, scale, scaleError); + } + private boolean requireSceneExportEnabled(ICommandSender sender) { if (GuideNhStructureExportAccess.canUseSceneExport()) { return true; @@ -462,4 +601,19 @@ public ExportSiteCommandOptions(String outDirArgument, boolean exportPonderEvery @Desugar private record ExportStructureOptions(RegionWandExportMode mode, int coordinateStartIndex) {} + + @Desugar + private record RenderPageOptions( + String guideId, + String pageId, + Path mdFile, + int width, + Path outDir, + String language, + boolean emitBoundsJson, + boolean emitDebugOverlay, + String widthError, + int scale, + String scaleError + ) {} } diff --git a/src/main/java/com/hfstudio/guidenh/config/ModConfig.java b/src/main/java/com/hfstudio/guidenh/config/ModConfig.java index dbd760e3..ebe0ce85 100644 --- a/src/main/java/com/hfstudio/guidenh/config/ModConfig.java +++ b/src/main/java/com/hfstudio/guidenh/config/ModConfig.java @@ -93,6 +93,10 @@ public static class Debug { @DefaultBoolean(true) public boolean showMousePosition = true; + @Comment("Show layout diagnostic overlay (green=Java bounds, red=Rust rects, blue=glyph quads, yellow=viewport scissor, gray=culled blocks)") + @DefaultBoolean(false) + public boolean layoutOverlay = false; + @Comment("Debug text color (ARGB format)") public int debugTextColor = 0xFFC47BA1; diff --git a/src/main/java/com/hfstudio/guidenh/guide/color/SymbolicColor.java b/src/main/java/com/hfstudio/guidenh/guide/color/SymbolicColor.java index 00726570..e95a1cc5 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/color/SymbolicColor.java +++ b/src/main/java/com/hfstudio/guidenh/guide/color/SymbolicColor.java @@ -2,7 +2,12 @@ /** * Symbolic colors can be overridden more easily in styles and define both a light- and dark-themed color variant. + * + * @deprecated Migrate to {@link com.hfstudio.guidenh.guide.style.token.GuideThemeManager} + * and declare {@code TokenKey} static fields on each node class. + * This enum will be removed once all nodes have been migrated. */ +@Deprecated public enum SymbolicColor implements ColorValue { LINK(Colors.rgb(0, 213, 255), Colors.rgb(0, 213, 255)), diff --git a/src/main/java/com/hfstudio/guidenh/guide/compiler/PageCompiler.java b/src/main/java/com/hfstudio/guidenh/guide/compiler/PageCompiler.java index 1045ec26..8cf91e55 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/compiler/PageCompiler.java +++ b/src/main/java/com/hfstudio/guidenh/guide/compiler/PageCompiler.java @@ -63,6 +63,7 @@ import com.hfstudio.guidenh.guide.scene.support.GuideDebugLog; import com.hfstudio.guidenh.guide.sound.GuideSoundParsers; import com.hfstudio.guidenh.guide.style.TextAlignment; +import com.hfstudio.guidenh.guide.style.TextStyle; import com.hfstudio.guidenh.guide.style.WhiteSpaceMode; import com.hfstudio.guidenh.libs.mdast.MdAst; import com.hfstudio.guidenh.libs.mdast.MdAstYamlFrontmatter; @@ -74,6 +75,7 @@ import com.hfstudio.guidenh.libs.mdast.mdx.model.MdxJsxTextElement; import com.hfstudio.guidenh.libs.mdast.model.MdAstAnyContent; import com.hfstudio.guidenh.libs.mdast.model.MdAstDefinition; +import com.hfstudio.guidenh.libs.mdast.model.MdAstFlowContent; import com.hfstudio.guidenh.libs.mdast.model.MdAstNode; import com.hfstudio.guidenh.libs.mdast.model.MdAstParagraph; import com.hfstudio.guidenh.libs.mdast.model.MdAstParent; @@ -174,63 +176,27 @@ public static ParsedGuidePage parse(String sourcePack, ResourceLocation id, Stri public static ParsedGuidePage parse(String sourcePack, String language, ResourceLocation id, String pageContent) { pageContent = pageContent != null ? pageContent : ""; - long parseStartedAt = System.nanoTime(); - long stageStartedAt = parseStartedAt; pageContent = normalizeLineEndings(pageContent); - long normalizeNs = System.nanoTime() - stageStartedAt; - - stageStartedAt = System.nanoTime(); pageContent = FootnotePreprocessor.preprocess(pageContent); - long footnoteNs = System.nanoTime() - stageStartedAt; - - stageStartedAt = System.nanoTime(); var sourceFrontmatter = parseFrontmatterFromSource(id, pageContent); - long sourceFrontmatterNs = System.nanoTime() - stageStartedAt; - - stageStartedAt = System.nanoTime(); MarkdownLatexShorthand.MaskResult latexMask = MarkdownLatexShorthand.mask(pageContent); - long latexMaskNs = System.nanoTime() - stageStartedAt; - - stageStartedAt = System.nanoTime(); String parseContent = MdxCommentMasker.mask(latexMask.source()); - long commentMaskNs = System.nanoTime() - stageStartedAt; MdAstRoot astRoot; String parseFailureMessage = null; UnistPoint parseFailureFrom = null; UnistPoint parseFailureTo = null; Frontmatter frontmatter; - long markdownParseNs = 0L; - long latexRestoreNs = 0L; - long htmlNormalizeNs = 0L; - long mdAstConvertNs = 0L; try { - stageStartedAt = System.nanoTime(); astRoot = MdAst.fromMarkdown(parseContent, PARSE_OPTIONS); - markdownParseNs = System.nanoTime() - stageStartedAt; - - stageStartedAt = System.nanoTime(); MarkdownLatexShorthand.restore(astRoot, latexMask); - latexRestoreNs = System.nanoTime() - stageStartedAt; - - stageStartedAt = System.nanoTime(); MarkdownHtmlRuntimeNormalizer.normalize(astRoot); - htmlNormalizeNs = System.nanoTime() - stageStartedAt; - // Collect definitions before conversion (converter needs them - // for link/image reference resolution). - stageStartedAt = System.nanoTime(); Map definitions = GuideMarkdownDefinitions.collect(astRoot); - - // Parse frontmatter BEFORE conversion — the converter removes - // MdAstYamlFrontmatter from children. frontmatter = parseFrontmatter(id, astRoot); - MdAstToMdxConverter.convert(astRoot, definitions); - mdAstConvertNs = System.nanoTime() - stageStartedAt; } catch (RuntimeException t) { if (t instanceof ParseException e) { - markdownParseNs = System.nanoTime() - stageStartedAt; parseFailureFrom = e.getFrom(); parseFailureTo = e.getTo(); } @@ -241,29 +207,10 @@ public static ParsedGuidePage parse(String sourcePack, String language, Resource frontmatter = new Frontmatter(null, Collections.emptyMap()); } - long astFrontmatterNs = System.nanoTime() - stageStartedAt; if (parseFailureMessage != null && sourceFrontmatter.navigationEntry() != null) { frontmatter = sourceFrontmatter; } - long totalNs = System.nanoTime() - parseStartedAt; - GuideDebugLog.info( - "[GuideNH] [PageCompiler] Parsed page {} lang={} totalNs={} normalizeNs={} footnoteNs={} sourceFrontmatterNs={} latexMaskNs={} commentMaskNs={} markdownParseNs={} latexRestoreNs={} htmlNormalizeNs={} mdAstConvertNs={} astFrontmatterNs={} parseFailed={}", - id, - language, - totalNs, - normalizeNs, - footnoteNs, - sourceFrontmatterNs, - latexMaskNs, - commentMaskNs, - markdownParseNs, - latexRestoreNs, - htmlNormalizeNs, - mdAstConvertNs, - astFrontmatterNs, - parseFailureMessage != null); - return new ParsedGuidePage( sourcePack, id, @@ -299,7 +246,7 @@ public static ParsedGuidePage parseFrontmatterOnly(String sourcePack, String lan null, // astRoot — triggers lazy parse on first getAstRoot() sourceFrontmatter, language, - null, // no parse failure yet + null, null, null); } @@ -330,24 +277,50 @@ public static MdAstRoot buildErrorPage(String errorText) { public static MdAstRoot buildErrorPage(String headingText, String errorText) { var root = new MdAstRoot(); + //

headingText

var heading = new MdxJsxFlowElement(); heading.setName("h1"); heading.addAttribute("depth", 1); root.addChild(heading); + var headingColor = new MdxJsxTextElement("Color", new ArrayList<>()); + headingColor.addAttribute("id", "error_text"); var headingTextNode = new MdAstText(); headingTextNode.setValue(headingText); - heading.addChild(headingTextNode); + headingColor.addChild(headingTextNode); + safeAddChild(heading, headingColor); + //

errorText

var errorParagraph = new MdxJsxFlowElement(); errorParagraph.setName("p"); root.addChild(errorParagraph); + var errorColor = new MdxJsxTextElement("Color", new ArrayList<>()); + errorColor.addAttribute("id", "error_text"); var errorTextNode = new MdAstText(); errorTextNode.setValue(errorText); - errorParagraph.addChild(errorTextNode); + errorColor.addChild(errorTextNode); + safeAddChild(errorParagraph, errorColor); return root; } + /** + * Adds a child node to an {@link MdxJsxFlowElement} with type validation. + * If the node is a valid {@link MdAstFlowContent} (the expected child type), + * it is added via the normal {@code addChild} path. Otherwise, raw-type + * access is used as a safe fallback to bypass the type constraint — this + * prevents the error page builder itself from crashing when attempting to + * add phrasing content (e.g. {@link MdAstText}) that is semantically valid + * inside flow elements like {@code

} or {@code

}. + */ + @SuppressWarnings({"unchecked", "rawtypes"}) + private static void safeAddChild(MdxJsxFlowElement element, MdAstNode node) { + if (node instanceof MdAstFlowContent) { + element.addChild(node); + } else { + ((List) element.children()).add(node); + } + } + public static GuidePage buildErrorGuidePage(PageCollection pages, ExtensionCollection extensions, String sourcePack, ResourceLocation id, String pageContent, String headingText, String errorText) { var errorRoot = buildErrorPage(headingText, errorText); @@ -700,63 +673,6 @@ private void compileParagraphBlock(MdAstParagraph astParagraph, LytBlockContaine parent.append(wrapFloatAwareIfNeeded(paragraph)); } - private LytBlock compileTable(GfmTable astTable, List widthHints) { - var table = new LytTable(); - table.setMarginBottom(DEFAULT_ELEMENT_SPACING); - - var astRows = astTable.children(); - // The GFM table parser swallows a trailing kramdown attribute line such as - // `{: widths="..." }` as an extra row; drop it during rendering so it does - // not appear as the last visible row of the table. - int rowCount = astRows.size(); - if (rowCount > 0) { - var lastRow = astRows.get(rowCount - 1); - String lastRowText = getTableRowText(lastRow); - if (lastRowText != null && TABLE_ATTRIBUTE_LINE.matcher(lastRowText.trim()) - .matches()) { - if (widthHints == null || widthHints.isEmpty()) { - Matcher matcher = TABLE_ATTRIBUTE_LINE.matcher(lastRowText.trim()); - if (matcher.matches()) { - widthHints = parseWidthHintsFromMetaExpression(matcher.group(1)); - } - } - rowCount--; - } - } - - boolean firstRow = true; - int rowIndex = 0; - for (int rowI = 0; rowI < rowCount; rowI++) { - var astRow = astRows.get(rowI); - var row = table.appendRow(); - if (firstRow) { - row.modifyStyle(style -> style.bold(true)); - firstRow = false; - } - - var astCells = astRow.children(); - for (int i = 0; i < astCells.size(); i++) { - if (rowIndex == 0 && i < widthHints.size() && widthHints.get(i) > 0) { - table.getOrCreateColumn(i) - .setPreferredWidth(widthHints.get(i)); - } - var cell = row.appendCell(); - // Apply alignment - if (astTable.align != null && i < astTable.align.size()) { - switch (astTable.align.get(i)) { - case CENTER -> cell.modifyStyle(style -> style.alignment(TextAlignment.CENTER)); - case RIGHT -> cell.modifyStyle(style -> style.alignment(TextAlignment.RIGHT)); - } - } - - compileTableCellContent(astCells.get(i), cell); - } - rowIndex++; - } - - return wrapFloatAwareIfNeeded(table); - } - public static LytBlock wrapFloatAwareIfNeeded(LytBlock block) { if (block instanceof LytParagraph || block instanceof LytDocumentFloat || block instanceof LytFloatAwareBlock @@ -766,18 +682,6 @@ public static LytBlock wrapFloatAwareIfNeeded(LytBlock block) { return new LytFloatAwareBlock(block); } - private @Nullable String getTableRowText(GfmTableRow row) { - StringBuilder sb = new StringBuilder(); - for (var cell : row.children()) { - if (!sb.isEmpty()) { - sb.append(' '); - } - sb.append(cell.toText()); - } - String text = sb.toString(); - return text.isEmpty() ? null : text; - } - public void compileFlowContext(MdAstParent markdownParent, LytFlowParent layoutParent) { compileFlowContext(markdownParent.children(), layoutParent); } @@ -799,9 +703,18 @@ private void compileFlowContent(LytFlowParent layoutParent, MdAstAnyContent cont } else if (compileInlineDollarLatex(layoutParent, astText.value)) { layoutChild = null; } else { - var text = new LytFlowText(); - text.setText(astText.value); - layoutChild = text; + String value = astText.value; + if (value.indexOf('§') >= 0) { + List fragments = parseSectionFormatting(value); + for (var fragment : fragments) { + layoutParent.append(fragment); + } + layoutChild = null; + } else { + var text = new LytFlowText(); + text.setText(value); + layoutChild = text; + } } } else if (content instanceof MdxJsxTextElement el) { if ("Spoiler".equals(el.name())) { @@ -910,6 +823,7 @@ private boolean compileInlineDollarLatex(LytFlowParent layoutParent, String text var block = new LytLatexBlock( segment.getValue(), LatexRenderOptions.builder() + .style(org.scilab.forge.jlatexmath.TeXConstants.STYLE_TEXT) .valign(LatexVerticalAlign.BASELINE) .build()); layoutParent.append(LytFlowInlineBlock.of(block)); @@ -1200,4 +1114,146 @@ private record SourceSlice(String source) {} @Desugar public record State (String name, Class dataClass, T defaultValue) {} + + // ---- § color/format code parsing ---- + + /** + * Parses Minecraft § color/format codes in {@code text} and returns a list of + * styled flow content fragments (plain {@link LytFlowText} or {@link LytFlowSpan} + * wrapping a text node). + */ + static List parseSectionFormatting(String text) { + if (text.isEmpty()) { + return Collections.emptyList(); + } + + List result = new ArrayList<>(); + StringBuilder segment = new StringBuilder(); + + // Current style state. Boolean null = inherit/not set. + ConstantColor color = null; + Boolean bold = null; + Boolean italic = null; + Boolean underlined = null; + Boolean strikethrough = null; + Boolean obfuscated = null; + + for (int i = 0; i < text.length(); i++) { + char ch = text.charAt(i); + if (ch == '§' && i + 1 < text.length()) { + char code = text.charAt(i + 1); + int mappedColor = mapSectionColor(code); + if (mappedColor != 0 || isSectionFormatCode(code)) { + // Valid § code – flush current segment and apply + flushSectionSegment(result, segment, color, bold, italic, underlined, strikethrough, obfuscated); + + if (mappedColor != 0) { + // §0-§f color: reset all formatting and set colour + color = new ConstantColor(mappedColor); + bold = false; + italic = false; + underlined = false; + strikethrough = false; + obfuscated = false; + } else { + // §k-§o, §r: format code + switch (Character.toLowerCase(code)) { + case 'l' -> bold = true; + case 'o' -> italic = true; + case 'm' -> strikethrough = true; + case 'n' -> underlined = true; + case 'k' -> obfuscated = true; + case 'r' -> { + color = null; + bold = null; + italic = null; + underlined = null; + strikethrough = null; + obfuscated = null; + } + default -> { /* unreachable – isSectionFormatCode already validated */ } + } + } + i++; // skip the format-code character + continue; + } + } + segment.append(ch); + } + + flushSectionSegment(result, segment, color, bold, italic, underlined, strikethrough, obfuscated); + return result; + } + + /** Appends the accumulated {@code segment} text as either plain or styled flow content. */ + private static void flushSectionSegment(List result, StringBuilder segment, + ConstantColor color, Boolean bold, Boolean italic, Boolean underlined, + Boolean strikethrough, Boolean obfuscated) { + if (segment.isEmpty()) { + return; + } + String text = segment.toString(); + segment.setLength(0); + + if (color == null && bold == null && italic == null && underlined == null + && strikethrough == null && obfuscated == null) { + result.add(LytFlowText.of(text)); + return; + } + + var span = new LytFlowSpan(); + var builder = TextStyle.builder(); + if (color != null) { + builder = builder.color(color); + } + if (bold != null) { + builder = builder.bold(bold); + } + if (italic != null) { + builder = builder.italic(italic); + } + if (underlined != null) { + builder = builder.underlined(underlined); + } + if (strikethrough != null) { + builder = builder.strikethrough(strikethrough); + } + if (obfuscated != null) { + builder = builder.obfuscated(obfuscated); + } + span.setStyle(builder.build()); + span.appendText(text); + result.add(span); + } + + /** Returns ARGB color int for §0-§f, or 0 if {@code code} is not a colour code. */ + static int mapSectionColor(char code) { + return switch (Character.toLowerCase(code)) { + case '0' -> 0xFF000000; // Black + case '1' -> 0xFF0000AA; // Dark Blue + case '2' -> 0xFF00AA00; // Dark Green + case '3' -> 0xFF00AAAA; // Dark Aqua + case '4' -> 0xFFAA0000; // Dark Red + case '5' -> 0xFFAA00AA; // Dark Purple + case '6' -> 0xFFFFAA00; // Gold + case '7' -> 0xFFAAAAAA; // Gray + case '8' -> 0xFF555555; // Dark Gray + case '9' -> 0xFF5555FF; // Blue + case 'a' -> 0xFF55FF55; // Green + case 'b' -> 0xFF55FFFF; // Aqua + case 'c' -> 0xFFFF5555; // Red + case 'd' -> 0xFFFF55FF; // Light Purple + case 'e' -> 0xFFFFFF55; // Yellow + case 'f' -> 0xFFFFFFFF; // White + default -> 0; + }; + } + + /** Returns true for §k/l/m/n/o/r (format codes, not colour codes). */ + private static boolean isSectionFormatCode(char code) { + return switch (Character.toLowerCase(code)) { + case 'k', 'l', 'm', 'n', 'o', 'r' -> true; + default -> false; + }; + } } diff --git a/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/BlockTagCompiler.java b/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/BlockTagCompiler.java index cc5fb085..83affc5d 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/BlockTagCompiler.java +++ b/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/BlockTagCompiler.java @@ -98,7 +98,7 @@ private static void applyFlowFloatMargins(LytBlock node, InlineBlockAlignment al } } - private static LytBlock applyBlockEmbed(LytBlock node, ContentWrapMode wrapMode, ContentAlign align) { + public static LytBlock embedBlock(LytBlock node, ContentWrapMode wrapMode, ContentAlign align) { if (wrapMode.isDocumentFloat()) { return new LytDocumentFloat(node, align == ContentAlign.RIGHT); } @@ -107,4 +107,8 @@ private static LytBlock applyBlockEmbed(LytBlock node, ContentWrapMode wrapMode, } return PageCompiler.wrapFloatAwareIfNeeded(node); } + + private static LytBlock applyBlockEmbed(LytBlock node, ContentWrapMode wrapMode, ContentAlign align) { + return embedBlock(node, wrapMode, align); + } } diff --git a/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/BlockquoteCompiler.java b/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/BlockquoteCompiler.java index 16381ece..b9d0fb8e 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/BlockquoteCompiler.java +++ b/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/BlockquoteCompiler.java @@ -99,14 +99,34 @@ private void compileDirectiveBody(PageCompiler compiler, BlockquoteDirective dir } private void normalizeBlockMargins(LytNode box) { - var boxChildren = box.getChildren(); - if (!boxChildren.isEmpty()) { - if (boxChildren.getFirst() instanceof LytParagraph) { - ((LytParagraph) boxChildren.getFirst()).setMarginTop(0); - } - if (boxChildren.getLast() instanceof LytParagraph) { - ((LytParagraph) boxChildren.getLast()).setMarginBottom(0); - } + // The alert/quote box title row is an independent margin-less paragraph, + // so the FIRST BODY paragraph still carries the block-paragraph top + // margin (5) that would otherwise double the title-row gap (VBox gap 4 + + // margin 5 ≈ the reported one-line blank band). The plain blockquote has + // no title row and its children ARE the body paragraphs. + if (box instanceof LytQuoteBox quoteBox) { + // Body paragraphs live in a nested content container below the title + // row; clear the first body paragraph's top margin so the title-row + // spacing is carried by the container's gap alone. + clearFirstParagraphTopMargin(quoteBox.getBodyContainer()); + return; + } + var children = box.getChildren(); + // LytAlertBox always carries its title row at index 0 (appended in its + // constructor), so the first BODY paragraph is at index 1. + int firstBody = box instanceof LytAlertBox ? 1 : 0; + if (children.size() > firstBody && children.get(firstBody) instanceof LytParagraph first) { + first.setMarginTop(0); + } + if (!children.isEmpty() && children.getLast() instanceof LytParagraph last) { + last.setMarginBottom(0); + } + } + + private static void clearFirstParagraphTopMargin(LytNode container) { + var children = container.getChildren(); + if (!children.isEmpty() && children.getFirst() instanceof LytParagraph first) { + first.setMarginTop(0); } } diff --git a/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/CommandLinkCompiler.java b/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/CommandLinkCompiler.java index 7b1ea5f1..d0c26292 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/CommandLinkCompiler.java +++ b/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/CommandLinkCompiler.java @@ -11,6 +11,7 @@ import com.hfstudio.guidenh.guide.document.flow.LytFlowLink; import com.hfstudio.guidenh.guide.document.flow.LytFlowParent; import com.hfstudio.guidenh.guide.document.interaction.TextTooltip; +import com.hfstudio.guidenh.guide.render.GuideText; import com.hfstudio.guidenh.libs.mdast.mdx.model.MdxJsxElementFields; public class CommandLinkCompiler extends FlowTagCompiler { @@ -41,7 +42,14 @@ protected void compile(PageCompiler compiler, LytFlowParent parent, MdxJsxElemen link.setData("close", closeGuide); link.setData("title", title); - compiler.compileFlowContext(el.children(), link); + var children = el.children(); + if (children.isEmpty()) { + // Self-closing: synthesize visible label from attributes + String label = title.isEmpty() ? command : title; + link.appendText(label); + } else { + compiler.compileFlowContext(children, link); + } parent.append(link); } @@ -52,7 +60,7 @@ public static TextTooltip buildTooltip(@Nullable String title, String command) { sb.append(tooltipTitle) .append("\n"); } - var displayCmd = command.length() > 25 ? command.substring(0, 25) + "..." : command; + var displayCmd = GuideText.clipToChars(command, 28, GuideText.ClipSuffix.DOTS3); sb.append(displayCmd); return new TextTooltip(sb.toString()); } diff --git a/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/CsvTableCompiler.java b/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/CsvTableCompiler.java index 6ffdf903..fd34b681 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/CsvTableCompiler.java +++ b/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/CsvTableCompiler.java @@ -45,6 +45,8 @@ protected void compile(PageCompiler compiler, LytBlockContainer parent, MdxJsxEl boolean header = MdxAttrs.getBoolean(compiler, parent, el, "header", true); List widths = parseWidthHints(MdxAttrs.getString(compiler, parent, el, "widths", null)); + String wrapAttr = el.getAttributeString("wrap", null); + String alignAttr = el.getAttributeString("align", null); CsvTablePlaceholder placeholder = new CsvTablePlaceholder( csvId.toString(), @@ -53,7 +55,9 @@ protected void compile(PageCompiler compiler, LytBlockContainer parent, MdxJsxEl compiler.getSourcePack(), compiler.getLanguage(), compiler.getPageId() - .toString()); + .toString(), + wrapAttr, + alignAttr); placeholder.appendText("[CsvTable]"); parent.append(placeholder); } @@ -109,6 +113,7 @@ public static LytTable buildTable(PageCompiler compiler, List> rows var row = table.appendRow(); if (firstRow && header) { row.modifyStyle(style -> style.bold(true)); + row.setHeader(true); } for (int columnIndex = 0; columnIndex < values.size(); columnIndex++) { if (rowIndex == 0 && columnIndex < widthHints.size() && widthHints.get(columnIndex) > 0) { @@ -193,15 +198,19 @@ public static class CsvTablePlaceholder extends LytParagraph { public final String sourcePack; public final String language; public final String pageId; + public final String wrap; + public final String align; public CsvTablePlaceholder(String src, boolean header, List widths, String sourcePack, String language, - String pageId) { + String pageId, String wrap, String align) { this.src = src; this.header = header; this.widths = widths; this.sourcePack = sourcePack; this.language = language; this.pageId = pageId; + this.wrap = wrap; + this.align = align; setStyleClass("CsvTable"); setStyle(LytParagraph.PLACEHOLDER_STYLE); } diff --git a/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/FloatingImageCompiler.java b/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/FloatingImageCompiler.java index 17e33157..97e5a5b5 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/FloatingImageCompiler.java +++ b/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/FloatingImageCompiler.java @@ -13,7 +13,15 @@ import com.hfstudio.guidenh.guide.compiler.IndexingContext; import com.hfstudio.guidenh.guide.compiler.IndexingSink; import com.hfstudio.guidenh.guide.compiler.PageCompiler; +import com.hfstudio.guidenh.guide.compiler.TagCompiler; +import com.hfstudio.guidenh.guide.document.LytErrorSink; import com.hfstudio.guidenh.guide.document.block.ImageRegionAnnotation; +import com.hfstudio.guidenh.guide.document.block.LytBlockContainer; +import com.hfstudio.guidenh.guide.document.block.ContentAlign; +import com.hfstudio.guidenh.guide.document.block.ContentWrapMode; +import com.hfstudio.guidenh.guide.document.block.LytAlignedBlock; +import com.hfstudio.guidenh.guide.document.block.LytBlock; +import com.hfstudio.guidenh.guide.document.block.LytDocumentFloat; import com.hfstudio.guidenh.guide.document.block.LytImageBlock; import com.hfstudio.guidenh.guide.document.block.LytParagraph; import com.hfstudio.guidenh.guide.document.block.LytVBox; @@ -25,14 +33,24 @@ import com.hfstudio.guidenh.guide.sound.GuideSoundParsers; import com.hfstudio.guidenh.guide.sound.GuideSoundTrigger; import com.hfstudio.guidenh.libs.mdast.mdx.model.MdxJsxElementFields; +import com.hfstudio.guidenh.libs.mdast.mdx.model.MdxJsxFlowElement; +import com.hfstudio.guidenh.libs.mdast.mdx.model.MdxJsxTextElement; -public class FloatingImageCompiler extends FlowTagCompiler { +public class FloatingImageCompiler implements TagCompiler { public static final String TAG_NAME = "FloatingImage"; private static final Random RANDOM = new Random(0); - private record CropSpec(int x, int y, int width, int height) {} + /** + * Parsed crop / size specification. With both dimensions given this is a + * classic crop rectangle (x/y/width/height). With exactly one dimension + * given (hasWidth XOR hasHeight) it is a whole-image display size: the + * given dimension is the final display pixel size × scale and the missing + * dimension is inferred from the image's natural aspect ratio downstream + * (Rust measure_image and the Java mirror paths). + */ + private record CropSpec(int x, int y, int width, int height, boolean hasWidth, boolean hasHeight) {} private record ScaleSpec(double scaleX, double scaleY) {} @@ -42,20 +60,120 @@ public Set getTagNames() { } @Override - protected void compile(PageCompiler compiler, LytFlowParent parent, MdxJsxElementFields el) { + public void compileBlockContext(PageCompiler compiler, LytBlockContainer parent, MdxJsxFlowElement el) { + String wrapAttr = el.getAttributeString("wrap", null); + String alignAttr = el.getAttributeString("align", null); + + var wrapMode = ContentWrapMode.fromString(wrapAttr); + var align = ContentAlign.fromString(alignAttr); + + // Inline wrap: only explicit wrap="inline" goes to the inline‑block path. + if ("inline".equals(wrapAttr)) { + var paragraph = new LytParagraph(); + compileInline(compiler, paragraph, el); + parent.append(paragraph); + return; + } + + // Build the image block for all non‑inline modes. + LytImageBlock imageBlock = buildImageBlock(compiler, parent, el); + if (imageBlock == null) return; + + // No explicit wrap + left/right align → document float (matching legacy behaviour). + if (wrapAttr == null && ("left".equals(alignAttr) || "right".equals(alignAttr))) { + LytDocumentFloat docFloat = new LytDocumentFloat(imageBlock, "right".equals(alignAttr)); + parent.append(docFloat); + return; + } + + // Square / tight / through → document float (same as BlockTagCompiler.applyBlockEmbed). + if (wrapMode.isDocumentFloat()) { + LytDocumentFloat docFloat = new LytDocumentFloat(imageBlock, align == ContentAlign.RIGHT); + parent.append(docFloat); + return; + } + + // Behind / front / top‑bottom → aligned block path (matching + // BlockTagCompiler.applyBlockEmbed: lines 105‑108), not a document float. + LytBlock result = imageBlock; + if (align != ContentAlign.LEFT) { + result = new LytAlignedBlock(result, align); + } + parent.append(PageCompiler.wrapFloatAwareIfNeeded(result)); + } + + @Override + public void compileFlowContext(PageCompiler compiler, LytFlowParent parent, MdxJsxTextElement el) { + compileInline(compiler, parent, el); + } + + /** + * Inline path: build the image block and wrap in a {@link LytFlowInlineBlock} + * with FLOAT_LEFT / FLOAT_RIGHT / INLINE alignment. + *

+ * Used by: + *

    + *
  • {@link #compileFlowContext} – the parent is the actual flow container
    • + *
  • {@link #compileBlockContext} inline fallback – the parent is a freshly + * created {@link LytParagraph} that will be appended to the block container
    • + *
+ */ + private void compileInline(PageCompiler compiler, LytFlowParent parent, MdxJsxElementFields el) { + LytImageBlock block = buildImageBlock(compiler, parent, el); + if (block == null) return; + + String wrap = el.getAttributeString("wrap", null); + String align = el.getAttributeString("align", "left"); + var inlineBlock = new LytFlowInlineBlock(); + inlineBlock.setBlock(block); + if ("inline".equals(wrap)) { + inlineBlock.setAlignment(InlineBlockAlignment.INLINE); + parent.append(inlineBlock); + return; + } + switch (align) { + case "left" -> { + inlineBlock.setAlignment(InlineBlockAlignment.FLOAT_LEFT); + block.setMarginRight(5); + block.setMarginBottom(5); + } + case "right" -> { + inlineBlock.setAlignment(InlineBlockAlignment.FLOAT_RIGHT); + block.setMarginLeft(5); + block.setMarginBottom(5); + } + default -> { + parent.append(compiler.createErrorFlowContent("Invalid align. Must be left or right.", el)); + return; + } + } + parent.append(inlineBlock); + } + + /** + * Shared block-building logic used by both + * {@link #compileBlockContext(PageCompiler, LytBlockContainer, MdxJsxFlowElement)} + * (document‑float path) and + * {@link #compileInline(PageCompiler, LytFlowParent, MdxJsxElementFields)} + * (inline path). + * + * @return the fully‑configured {@link LytImageBlock}, or {@code null} on parse failure + */ + @Nullable + private static LytImageBlock buildImageBlock(PageCompiler compiler, LytErrorSink errorSink, MdxJsxElementFields el) { var src = el.getAttributeString("src", null); if (src == null || src.trim() .isEmpty()) { - parent.appendError(compiler, "FloatingImage requires a non-empty src attribute.", el); - return; + errorSink.appendError(compiler, "FloatingImage requires a non-empty src attribute.", el); + return null; } var align = el.getAttributeString("align", "left"); var title = el.getAttributeString("title", null); var alt = el.getAttributeString("alt", null); - CropSpec crop = parseCropSpec(compiler, parent, el); - ScaleSpec scale = parseScaleSpec(compiler, parent, el); + CropSpec crop = parseCropSpec(compiler, errorSink, el); + ScaleSpec scale = parseScaleSpec(compiler, errorSink, el); if (crop == null || scale == null) { - return; + return null; } LytImageBlock block = new LytImageBlock(); @@ -71,8 +189,17 @@ protected void compile(PageCompiler compiler, LytFlowParent parent, MdxJsxElemen } block.setCropX(crop.x()); block.setCropY(crop.y()); - block.setCropWidth(crop.width()); - block.setCropHeight(crop.height()); + // F-N1 single-parameter mode (width-only / height-only) is a + // whole-image display size: no crop is applied and the missing explicit + // dimension stays -1 so downstream measurement infers it from the + // natural aspect ratio. + if (crop.hasWidth() && crop.hasHeight()) { + block.setCropWidth(crop.width()); + block.setCropHeight(crop.height()); + } else { + block.setCropWidth(-1); + block.setCropHeight(-1); + } block.setScaleX(scale.scaleX()); block.setScaleY(scale.scaleY()); @@ -90,11 +217,11 @@ protected void compile(PageCompiler compiler, LytFlowParent parent, MdxJsxElemen } block.setSrc(resolvedSrc); - var wholeImageSound = GuideSoundParsers.parseAttributes(compiler, parent, el, "soundSrc"); + var wholeImageSound = GuideSoundParsers.parseAttributes(compiler, errorSink, el, "soundSrc"); if (wholeImageSound != null) { var soundAnnotation = new ImageRegionAnnotation(false, ConstantColor.WHITE, 1); soundAnnotation.setSound(wholeImageSound); - soundAnnotation.setSoundTrigger(parseTrigger(compiler, parent, el)); + soundAnnotation.setSoundTrigger(parseTrigger(compiler, errorSink, el)); block.addAnnotation(soundAnnotation); } @@ -103,10 +230,10 @@ protected void compile(PageCompiler compiler, LytFlowParent parent, MdxJsxElemen if (children != null) { for (var child : children) { if (child instanceof MdxJsxElementFields annEl && "ImageAnnotation".equals(annEl.name())) { - var ann = parseImageAnnotation(compiler, parent, annEl); + var ann = parseImageAnnotation(compiler, errorSink, annEl); block.addAnnotation(ann); } else if (child instanceof MdxJsxElementFields soundEl && "SoundArea".equals(soundEl.name())) { - var ann = parseSoundArea(compiler, parent, soundEl); + var ann = parseSoundArea(compiler, errorSink, soundEl); if (ann != null) { block.addAnnotation(ann); } @@ -114,34 +241,23 @@ protected void compile(PageCompiler compiler, LytFlowParent parent, MdxJsxElemen } } - // Wrap it in a flow content inline block - var inlineBlock = new LytFlowInlineBlock(); - inlineBlock.setBlock(block); - String wrap = el.getAttributeString("wrap", null); - boolean inlineWrap = "inline".equals(wrap); - if (inlineWrap) { - inlineBlock.setAlignment(InlineBlockAlignment.INLINE); - parent.append(inlineBlock); - return; + // Forward crop dimensions × scale as explicit size for Rust measure_image + // so that scaleX/scaleY are reflected in the final measured size. + // F-N1: in single-parameter mode the given dimension × scale is the + // explicit display size (missing axis inferred from natural aspect + // ratio); the missing dimension stays -1. + if (crop.hasWidth()) { + block.setExplicitWidth((int) Math.round(crop.width() * scale.scaleX())); + } else { + block.setExplicitWidth(-1); } - switch (align) { - case "left" -> { - inlineBlock.setAlignment(InlineBlockAlignment.FLOAT_LEFT); - block.setMarginRight(5); - block.setMarginBottom(5); - } - case "right" -> { - inlineBlock.setAlignment(InlineBlockAlignment.FLOAT_RIGHT); - block.setMarginLeft(5); - block.setMarginBottom(5); - } - default -> { - parent.append(compiler.createErrorFlowContent("Invalid align. Must be left or right.", el)); - return; - } + if (crop.hasHeight()) { + block.setExplicitHeight((int) Math.round(crop.height() * scale.scaleY())); + } else { + block.setExplicitHeight(-1); } - parent.append(inlineBlock); + return block; } /** @@ -160,9 +276,9 @@ protected void compile(PageCompiler compiler, LytFlowParent parent, MdxJsxElemen * Child MDX content is compiled as the rich-text tooltip body. */ @NotNull - private static ImageRegionAnnotation parseImageAnnotation(PageCompiler compiler, LytFlowParent parent, + private static ImageRegionAnnotation parseImageAnnotation(PageCompiler compiler, LytErrorSink errorSink, MdxJsxElementFields annEl) { - ImageRegionAnnotation ann = parseImageAnnotationRegion(compiler, parent, annEl, true); + ImageRegionAnnotation ann = parseImageAnnotationRegion(compiler, errorSink, annEl, true); // Compile tooltip rich-text content from child elements. var contentBox = new LytVBox(); @@ -171,39 +287,39 @@ private static ImageRegionAnnotation parseImageAnnotation(PageCompiler compiler, .isEmpty()) { ann.setTooltip(new ContentTooltip(contentBox)); } - ann.setSound(GuideSoundParsers.parseAttributes(compiler, parent, annEl)); - ann.setSoundTrigger(parseTrigger(compiler, parent, annEl)); + ann.setSound(GuideSoundParsers.parseAttributes(compiler, errorSink, annEl)); + ann.setSoundTrigger(parseTrigger(compiler, errorSink, annEl)); return ann; } - private static ImageRegionAnnotation parseSoundArea(PageCompiler compiler, LytFlowParent parent, + private static ImageRegionAnnotation parseSoundArea(PageCompiler compiler, LytErrorSink errorSink, MdxJsxElementFields el) { - var sound = GuideSoundParsers.parseAttributes(compiler, parent, el); + var sound = GuideSoundParsers.parseAttributes(compiler, errorSink, el); if (sound == null) { - parent.appendError(compiler, "SoundArea requires a sound or src attribute.", el); + errorSink.appendError(compiler, "SoundArea requires a sound or src attribute.", el); return null; } - ImageRegionAnnotation ann = parseImageAnnotationRegion(compiler, parent, el, false); + ImageRegionAnnotation ann = parseImageAnnotationRegion(compiler, errorSink, el, false); ann.setSound(sound); - ann.setSoundTrigger(parseTrigger(compiler, parent, el)); + ann.setSoundTrigger(parseTrigger(compiler, errorSink, el)); return ann; } - private static ImageRegionAnnotation parseImageAnnotationRegion(PageCompiler compiler, LytFlowParent parent, + private static ImageRegionAnnotation parseImageAnnotationRegion(PageCompiler compiler, LytErrorSink errorSink, MdxJsxElementFields el, boolean allowBorder) { - int x = MdxAttrs.getInt(compiler, parent, el, "x", -1); - int y = MdxAttrs.getInt(compiler, parent, el, "y", -1); - int w = MdxAttrs.getInt(compiler, parent, el, "w", -1); - int h = MdxAttrs.getInt(compiler, parent, el, "h", -1); + int x = MdxAttrs.getInt(compiler, errorSink, el, "x", -1); + int y = MdxAttrs.getInt(compiler, errorSink, el, "y", -1); + int w = MdxAttrs.getInt(compiler, errorSink, el, "w", -1); + int h = MdxAttrs.getInt(compiler, errorSink, el, "h", -1); boolean wholeImage = x < 0 && y < 0 && w < 0 && h < 0; - boolean showBorder = allowBorder && MdxAttrs.getBoolean(compiler, parent, el, "border", false); - int borderThickness = allowBorder ? MdxAttrs.getInt(compiler, parent, el, "borderThickness", 1) : 1; + boolean showBorder = allowBorder && MdxAttrs.getBoolean(compiler, errorSink, el, "border", false); + int borderThickness = allowBorder ? MdxAttrs.getInt(compiler, errorSink, el, "borderThickness", 1) : 1; ColorValue borderColor; if (allowBorder && el.getAttribute("borderColor") != null) { - borderColor = MdxAttrs.getColor(compiler, parent, el, "borderColor", ConstantColor.WHITE); + borderColor = MdxAttrs.getColor(compiler, errorSink, el, "borderColor", ConstantColor.WHITE); } else { borderColor = allowBorder ? new ConstantColor(0xFF000000 | RANDOM.nextInt(0x1000000)) : ConstantColor.WHITE; } @@ -219,9 +335,9 @@ private static ImageRegionAnnotation parseImageAnnotationRegion(PageCompiler com return new ImageRegionAnnotation(ax, ay, aw, ah, showBorder, borderColor, borderThickness); } - private static GuideSoundTrigger parseTrigger(PageCompiler compiler, LytFlowParent parent, MdxJsxElementFields el) { + private static GuideSoundTrigger parseTrigger(PageCompiler compiler, LytErrorSink errorSink, MdxJsxElementFields el) { return GuideSoundTrigger - .parse(MdxAttrs.getString(compiler, parent, el, "trigger", null), GuideSoundTrigger.CLICK); + .parse(MdxAttrs.getString(compiler, errorSink, el, "trigger", null), GuideSoundTrigger.CLICK); } @Override @@ -243,93 +359,131 @@ public static int parseIntAttr(MdxJsxElementFields el, String name, int def) { } @Nullable - private static CropSpec parseCropSpec(PageCompiler compiler, LytFlowParent parent, MdxJsxElementFields el) { + private static CropSpec parseCropSpec(PageCompiler compiler, LytErrorSink errorSink, MdxJsxElementFields el) { String widthValue = el.getAttributeString("width", null); String widthAlias = el.getAttributeString("w", null); String heightValue = el.getAttributeString("height", null); String heightAlias = el.getAttributeString("h", null); if (widthValue != null && widthAlias != null) { - parent.appendError(compiler, "FloatingImage cannot use both width and w.", el); + errorSink.appendError(compiler, "FloatingImage cannot use both width and w.", el); return null; } if (heightValue != null && heightAlias != null) { - parent.appendError(compiler, "FloatingImage cannot use both height and h.", el); + errorSink.appendError(compiler, "FloatingImage cannot use both height and h.", el); return null; } - Integer x = parseRequiredIntAttr(compiler, parent, el, "x"); - Integer y = parseRequiredIntAttr(compiler, parent, el, "y"); - Integer width = parseRequiredAliasedIntAttr(compiler, parent, el, "width", "w"); - Integer height = parseRequiredAliasedIntAttr(compiler, parent, el, "height", "h"); - if (x == null || y == null || width == null || height == null) { + boolean hasWidth = (widthValue != null && !widthValue.trim() + .isEmpty()) || (widthAlias != null && !widthAlias.trim() + .isEmpty()); + boolean hasHeight = (heightValue != null && !heightValue.trim() + .isEmpty()) || (heightAlias != null && !heightAlias.trim() + .isEmpty()); + // F-N1: a single explicit dimension (width-only or height-only) is a + // valid whole-image display size; only the "both missing" case is an + // error. + if (!hasWidth && !hasHeight) { + errorSink.appendError(compiler, "FloatingImage requires width or w, and height or h.", el); return null; } - if (x < 0 || y < 0 || width <= 0 || height <= 0) { - parent.appendError( + Integer x = parseOptionalIntAttr(compiler, errorSink, el, "x", 0); + Integer y = parseOptionalIntAttr(compiler, errorSink, el, "y", 0); + Integer width = parseAliasedIntAttr(compiler, errorSink, el, "width", "w"); + Integer height = parseAliasedIntAttr(compiler, errorSink, el, "height", "h"); + if (x == null || y == null) { + return null; + } + if ((hasWidth && width == null) || (hasHeight && height == null)) { + return null; + } + if (x < 0 || y < 0 || (hasWidth && width <= 0) || (hasHeight && height <= 0)) { + errorSink.appendError( compiler, "FloatingImage crop values must be non-negative and width/height must be positive.", el); return null; } - return new CropSpec(x, y, width, height); + return new CropSpec(x, y, hasWidth ? width : -1, hasHeight ? height : -1, hasWidth, hasHeight); } @Nullable - private static ScaleSpec parseScaleSpec(PageCompiler compiler, LytFlowParent parent, MdxJsxElementFields el) { - Double scaleX = parseDoubleAttr(compiler, parent, el, "scaleX", 1.0d); - Double scaleY = parseDoubleAttr(compiler, parent, el, "scaleY", 1.0d); + private static ScaleSpec parseScaleSpec(PageCompiler compiler, LytErrorSink errorSink, MdxJsxElementFields el) { + Double scaleX = parseDoubleAttr(compiler, errorSink, el, "scaleX", 1.0d); + Double scaleY = parseDoubleAttr(compiler, errorSink, el, "scaleY", 1.0d); if (scaleX == null || scaleY == null) { return null; } if (scaleX <= 0.0d || scaleY <= 0.0d) { - parent.appendError(compiler, "FloatingImage scaleX and scaleY must be positive.", el); + errorSink.appendError(compiler, "FloatingImage scaleX and scaleY must be positive.", el); return null; } return new ScaleSpec(scaleX, scaleY); } + /** + * Parses an aliased integer attribute (primary name or alias) as optional. + * Returns {@code null} when the attribute is absent — a valid state under + * F-N1 single-parameter mode where exactly one dimension is required (the + * "both missing" error is reported by {@link #parseCropSpec}). A present + * but malformed value appends an error and returns {@code null}. + */ @Nullable - private static Integer parseRequiredAliasedIntAttr(PageCompiler compiler, LytFlowParent parent, + private static Integer parseAliasedIntAttr(PageCompiler compiler, LytErrorSink errorSink, MdxJsxElementFields el, String primaryName, String aliasName) { String primaryValue = el.getAttributeString(primaryName, null); String aliasValue = el.getAttributeString(aliasName, null); if (primaryValue != null && aliasValue != null) { - parent + errorSink .appendError(compiler, "FloatingImage cannot use both " + primaryName + " and " + aliasName + ".", el); return null; } String resolved = primaryValue != null ? primaryValue : aliasValue; if (resolved == null || resolved.trim() .isEmpty()) { - parent.appendError(compiler, "FloatingImage requires x, y, width or w, and height or h.", el); return null; } try { return Integer.parseInt(resolved.trim()); } catch (NumberFormatException ex) { - parent.appendError(compiler, "FloatingImage " + primaryName + " must be an integer.", el); + errorSink.appendError(compiler, "FloatingImage " + primaryName + " must be an integer.", el); return null; } } @Nullable - private static Integer parseRequiredIntAttr(PageCompiler compiler, LytFlowParent parent, MdxJsxElementFields el, + private static Integer parseRequiredIntAttr(PageCompiler compiler, LytErrorSink errorSink, MdxJsxElementFields el, String name) { String value = el.getAttributeString(name, null); if (value == null || value.trim() .isEmpty()) { - parent.appendError(compiler, "FloatingImage requires x, y, width or w, and height or h.", el); + errorSink.appendError(compiler, "FloatingImage requires x, y, width or w, and height or h.", el); return null; } try { return Integer.parseInt(value.trim()); } catch (NumberFormatException ex) { - parent.appendError(compiler, "FloatingImage " + name + " must be an integer.", el); + errorSink.appendError(compiler, "FloatingImage " + name + " must be an integer.", el); + return null; + } + } + + @Nullable + private static Integer parseOptionalIntAttr(PageCompiler compiler, LytErrorSink errorSink, MdxJsxElementFields el, + String name, int defaultValue) { + String value = el.getAttributeString(name, null); + if (value == null || value.trim() + .isEmpty()) { + return defaultValue; + } + try { + return Integer.parseInt(value.trim()); + } catch (NumberFormatException ex) { + errorSink.appendError(compiler, "FloatingImage " + name + " must be an integer.", el); return null; } } @Nullable - private static Double parseDoubleAttr(PageCompiler compiler, LytFlowParent parent, MdxJsxElementFields el, + private static Double parseDoubleAttr(PageCompiler compiler, LytErrorSink errorSink, MdxJsxElementFields el, String name, double defaultValue) { String value = el.getAttributeString(name, null); if (value == null || value.trim() @@ -339,7 +493,7 @@ private static Double parseDoubleAttr(PageCompiler compiler, LytFlowParent paren try { return Double.parseDouble(value.trim()); } catch (NumberFormatException ex) { - parent.appendError(compiler, "FloatingImage " + name + " must be a number.", el); + errorSink.appendError(compiler, "FloatingImage " + name + " must be a number.", el); return null; } } diff --git a/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/HeadingCompiler.java b/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/HeadingCompiler.java index b01fa887..08c9f007 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/HeadingCompiler.java +++ b/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/HeadingCompiler.java @@ -5,6 +5,7 @@ import com.hfstudio.guidenh.guide.compiler.PageCompiler; import com.hfstudio.guidenh.guide.document.block.LytBlockContainer; import com.hfstudio.guidenh.guide.document.block.LytHeading; +import com.hfstudio.guidenh.guide.document.block.LytNode; import com.hfstudio.guidenh.libs.mdast.mdx.model.MdxJsxElementFields; public class HeadingCompiler extends BlockTagCompiler { @@ -23,6 +24,21 @@ protected void compile(PageCompiler compiler, LytBlockContainer parent, MdxJsxEl heading.setDepth(Math.max(1, Math.min(depth, 6))); compiler.compileFlowContext(el.children(), heading); parent.append(heading); + // Adjacent-heading margin collapse: taffy adds margins without CSS + // collapsing, so two consecutive headings would sum the first's bottom + // margin and the second's top margin into an oversized gap (H3 7 + H4 12 + // ≈ 19px hole). When the sibling directly before this heading is also a + // heading, zero its bottom margin so the pair keeps only this heading's + // top margin (see LytHeading#collapseBottomForAdjacent). Heading→body + // spacing is untouched. + LytNode holder = heading.getParent(); + if (holder != null) { + var siblings = holder.getChildren(); + int size = siblings.size(); + if (size >= 2 && siblings.get(size - 2) instanceof LytHeading previous) { + previous.collapseBottomForAdjacent(); + } + } } private static int parseIntSafe(String s, int fallback) { diff --git a/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/ImageCompiler.java b/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/ImageCompiler.java index 6e47a2ed..c6d69b85 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/ImageCompiler.java +++ b/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/ImageCompiler.java @@ -5,14 +5,21 @@ import com.hfstudio.guidenh.guide.compiler.IdUtils; import com.hfstudio.guidenh.guide.compiler.PageCompiler; +import com.hfstudio.guidenh.guide.compiler.TagCompiler; +import com.hfstudio.guidenh.guide.document.block.ContentAlign; +import com.hfstudio.guidenh.guide.document.block.LytAlignedBlock; +import com.hfstudio.guidenh.guide.document.block.LytBlock; +import com.hfstudio.guidenh.guide.document.block.LytBlockContainer; import com.hfstudio.guidenh.guide.document.block.LytImageBlock; import com.hfstudio.guidenh.guide.document.block.LytParagraph; import com.hfstudio.guidenh.guide.document.flow.LytFlowInlineBlock; import com.hfstudio.guidenh.guide.document.flow.LytFlowParent; import com.hfstudio.guidenh.guide.scene.support.GuideDebugLog; import com.hfstudio.guidenh.libs.mdast.mdx.model.MdxJsxElementFields; +import com.hfstudio.guidenh.libs.mdast.mdx.model.MdxJsxFlowElement; +import com.hfstudio.guidenh.libs.mdast.mdx.model.MdxJsxTextElement; -public class ImageCompiler extends FlowTagCompiler { +public class ImageCompiler implements TagCompiler { @Override public Set getTagNames() { @@ -20,7 +27,31 @@ public Set getTagNames() { } @Override - protected void compile(PageCompiler compiler, LytFlowParent parent, MdxJsxElementFields el) { + public void compileFlowContext(PageCompiler compiler, LytFlowParent parent, MdxJsxTextElement el) { + LytImageBlock block = buildBlock(compiler, el); + + var inlineBlock = new LytFlowInlineBlock(); + inlineBlock.setBlock(block); + parent.append(inlineBlock); + } + + @Override + public void compileBlockContext(PageCompiler compiler, LytBlockContainer parent, MdxJsxFlowElement el) { + LytImageBlock block = buildBlock(compiler, el); + + String alignAttr = el.getAttributeString("align", null); + LytBlock result = block; + if (alignAttr != null) { + ContentAlign align = ContentAlign.fromString(alignAttr); + if (align != ContentAlign.LEFT) { + result = new LytAlignedBlock(result, align); + } + } + + parent.append(PageCompiler.wrapFloatAwareIfNeeded(result)); + } + + private static LytImageBlock buildBlock(PageCompiler compiler, MdxJsxElementFields el) { LytImageBlock block = new LytImageBlock(); block.setStyleClass("Img"); @@ -40,11 +71,13 @@ protected void compile(PageCompiler compiler, LytFlowParent parent, MdxJsxElemen if (!alt.isEmpty()) block.setAlt(alt); if (!title.isEmpty()) block.setTitle(title); + String alignAttr = el.getAttributeString("align", null); + if (alignAttr != null) { + block.setAlign(alignAttr); + } + block.setStyle(LytParagraph.PLACEHOLDER_STYLE); block.appendText("[Image]"); - - var inlineBlock = new LytFlowInlineBlock(); - inlineBlock.setBlock(block); - parent.append(inlineBlock); + return block; } } diff --git a/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/ItemGridCompiler.java b/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/ItemGridCompiler.java index 70321019..9993b79b 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/ItemGridCompiler.java +++ b/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/ItemGridCompiler.java @@ -5,6 +5,8 @@ import java.util.List; import java.util.Set; +import org.jetbrains.annotations.Nullable; + import com.hfstudio.guidenh.guide.compiler.IndexingContext; import com.hfstudio.guidenh.guide.compiler.IndexingSink; import com.hfstudio.guidenh.guide.compiler.PageCompiler; @@ -21,21 +23,29 @@ public Set getTagNames() { @Override protected void compile(PageCompiler compiler, LytBlockContainer parent, MdxJsxElementFields el) { - List itemIds = new ArrayList<>(); + List entries = new ArrayList<>(); // We expect children to only contain ItemIcon elements for (var childNode : el.children()) { if (childNode instanceof MdxJsxElementFields jsxChild && "ItemIcon".equals(jsxChild.name())) { - var itemId = MdxAttrs.getString(compiler, parent, jsxChild, "id", null); - if (itemId != null) { - itemIds.add(itemId); + // Extract raw attributes (no registry lookups); keep both id and + // ore so ore-dictionary entries can be resolved at runtime. + String itemId = MdxAttrs.getString(compiler, parent, jsxChild, "id", null); + String ore = MdxAttrs.getString(compiler, parent, jsxChild, "ore", null); + if (itemId == null && ore == null) { + parent.appendError(compiler, "Missing id or ore attribute.", jsxChild); + continue; } + entries.add( + new ItemGridEntry( + itemId != null ? itemId.trim() : null, + ore != null ? ore.trim() : null)); continue; } parent.appendError(compiler, "Unsupported child-element in ItemGrid", childNode); } - ItemGridPlaceholder placeholder = new ItemGridPlaceholder(itemIds); + ItemGridPlaceholder placeholder = new ItemGridPlaceholder(entries); parent.append(placeholder); } @@ -44,13 +54,16 @@ public void index(IndexingContext indexer, MdxJsxElementFields el, IndexingSink public static class ItemGridPlaceholder extends LytParagraph { - public final List itemIds; + public final List entries; - public ItemGridPlaceholder(List itemIds) { - this.itemIds = itemIds; + public ItemGridPlaceholder(List entries) { + this.entries = entries; setStyleClass("ItemGrid"); setStyle(LytParagraph.PLACEHOLDER_STYLE); appendText("[ItemGrid]"); } } + + /** A single {@code } child: raw item id and/or ore dictionary name. */ + public record ItemGridEntry(@Nullable String id, @Nullable String ore) {} } diff --git a/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/LatexTagCompiler.java b/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/LatexTagCompiler.java index d9833a28..c29b6129 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/LatexTagCompiler.java +++ b/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/LatexTagCompiler.java @@ -93,6 +93,7 @@ private LytLatexBlock buildInlineBlock(PageCompiler compiler, LytFlowParent pare return new LytLatexBlock( formula, LatexRenderOptions.builder() + .style(org.scilab.forge.jlatexmath.TeXConstants.STYLE_TEXT) .fillColorArgb(fillColor) .sourceScale(sourceScale) .userScale(userScale) diff --git a/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/ListItemCompiler.java b/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/ListItemCompiler.java index 5ae9582c..4793c46f 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/ListItemCompiler.java +++ b/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/ListItemCompiler.java @@ -1,6 +1,7 @@ package com.hfstudio.guidenh.guide.compiler.tags; import java.util.Collections; +import java.util.List; import java.util.Set; import com.hfstudio.guidenh.guide.compiler.PageCompiler; @@ -10,6 +11,7 @@ import com.hfstudio.guidenh.guide.document.block.LytTaskListItem; import com.hfstudio.guidenh.guide.internal.markdown.MarkdownListSemantics; import com.hfstudio.guidenh.libs.mdast.mdx.model.MdxJsxElementFields; +import com.hfstudio.guidenh.libs.mdast.mdx.model.MdxJsxFlowElement; public class ListItemCompiler extends BlockTagCompiler { @@ -26,13 +28,32 @@ protected void compile(PageCompiler compiler, LytBlockContainer parent, MdxJsxEl if (taskMarker != null) { LytTaskListItem taskItem = new LytTaskListItem(); taskItem.setChecked(taskMarker.checked()); - taskMarker.textNode() - .setValue(taskMarker.remainingText()); + + // Strip the task-marker prefix from text nodes TEMPORARILY so the + // compiled output omits "[x] "/"[ ] ". + // Save original values and restore after compileBlockContext so the + // AST remains immutable for re-compilation (CompileWorker may have + // pre-compiled the same ParsedGuidePage on the guidenh-compile thread, + // then RenderPageService compiles it again — mutation would lose the + // marker on the second pass). + MdxJsxFlowElement p = MarkdownListSemantics.findFirstP(el.children()); + List savedPrefixTexts = p != null + ? MarkdownListSemantics.stripPrefixInPlace(p, taskMarker.prefixLen()) + : List.of(); + listItem = taskItem; + try { + compiler.compileBlockContext(el.children(), listItem); + } finally { + // Restore original text values so AST is reusable + if (p != null) { + MarkdownListSemantics.restoreTextValues(p, savedPrefixTexts); + } + } } else { listItem = new LytListItem(); + compiler.compileBlockContext(el.children(), listItem); } - compiler.compileBlockContext(el.children(), listItem); // Normalize first child margins var children = listItem.getChildren(); diff --git a/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/NodeContentTagCompiler.java b/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/NodeContentTagCompiler.java new file mode 100644 index 00000000..bc030e3b --- /dev/null +++ b/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/NodeContentTagCompiler.java @@ -0,0 +1,47 @@ +package com.hfstudio.guidenh.guide.compiler.tags; + +import java.util.Collections; +import java.util.Set; + +import com.hfstudio.guidenh.guide.compiler.PageCompiler; +import com.hfstudio.guidenh.guide.compiler.TagCompiler; +import com.hfstudio.guidenh.guide.document.block.LytBlockContainer; +import com.hfstudio.guidenh.guide.document.flow.LytFlowParent; +import com.hfstudio.guidenh.guide.scene.support.GuideDebugLog; +import com.hfstudio.guidenh.libs.mdast.mdx.model.MdxJsxFlowElement; +import com.hfstudio.guidenh.libs.mdast.mdx.model.MdxJsxTextElement; + +/** + * Tag compiler for {@code } — rich content blocks inside + * {@code } diagrams. + * + *

NodeContent is only meaningful as a child of {@code }, where + * the {@link MermaidCompiler} extracts and compiles it directly from the + * element tree (see {@code compileNodeContentBlocks}). At the page level + * this compiler acts as a no-op (with a debug log) to prevent the + * "Unhandled MDX: NodeContent" error. + */ +public class NodeContentTagCompiler implements TagCompiler { + + @Override + public Set getTagNames() { + return Collections.singleton("NodeContent"); + } + + @Override + public void compileBlockContext(PageCompiler compiler, LytBlockContainer parent, MdxJsxFlowElement el) { + // NodeContent is only valid as a child of . The MermaidCompiler + // handles extraction and compilation directly from el.children(). + // At page level: no-op to suppress "Unhandled MDX" error. + String id = el.getAttributeString("id", null); + GuideDebugLog.debug( + "[GuideNH] [NodeContentTagCompiler] Ignored at page level (id={})", + id != null ? id : ""); + } + + @Override + public void compileFlowContext(PageCompiler compiler, LytFlowParent parent, MdxJsxTextElement el) { + // Inline NodeContent is not valid; silently ignore. + GuideDebugLog.debug("[GuideNH] [NodeContentTagCompiler] Ignored in flow context"); + } +} diff --git a/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/ParagraphCompiler.java b/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/ParagraphCompiler.java index db5078dd..5881f0b3 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/ParagraphCompiler.java +++ b/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/ParagraphCompiler.java @@ -4,8 +4,12 @@ import java.util.Set; import com.hfstudio.guidenh.guide.compiler.PageCompiler; +import com.hfstudio.guidenh.guide.document.block.LatexRenderOptions; import com.hfstudio.guidenh.guide.document.block.LytBlockContainer; +import com.hfstudio.guidenh.guide.document.block.LytLatexDisplayBlock; import com.hfstudio.guidenh.guide.document.block.LytParagraph; +import com.hfstudio.guidenh.guide.internal.markdown.MarkdownLatexShorthand; +import com.hfstudio.guidenh.libs.mdast.model.MdAstText; import com.hfstudio.guidenh.libs.mdast.mdx.model.MdxJsxElementFields; public class ParagraphCompiler extends BlockTagCompiler { @@ -17,6 +21,27 @@ public Set getTagNames() { @Override protected void compile(PageCompiler compiler, LytBlockContainer parent, MdxJsxElementFields el) { + // Sole $$...$$ block-level display formula detection. + // A paragraph whose single text child is exactly $$formula$$ produces a + // centered LytLatexDisplayBlock instead of an inline LytLatexBlock. + if (el.children().size() == 1) { + Object sole = el.children().getFirst(); + if (sole instanceof MdAstText soleText) { + String formula = MarkdownLatexShorthand.extractSoleDisplayFormula(soleText.value); + if (formula != null) { + var displayBlock = new LytLatexDisplayBlock( + formula, + LatexRenderOptions.builder() + .build()); + displayBlock.setMarginTop(PageCompiler.DEFAULT_ELEMENT_SPACING); + displayBlock.setMarginBottom(PageCompiler.DEFAULT_ELEMENT_SPACING); + parent.append(PageCompiler.wrapFloatAwareIfNeeded(displayBlock)); + return; + } + } + } + + // Default paragraph compilation (inline flow content). LytParagraph paragraph = new LytParagraph(); compiler.compileFlowContext(el.children(), paragraph); paragraph.setMarginTop(PageCompiler.DEFAULT_ELEMENT_SPACING); diff --git a/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/PreCompiler.java b/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/PreCompiler.java index ce322baa..e512cbc9 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/PreCompiler.java +++ b/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/PreCompiler.java @@ -12,9 +12,13 @@ import com.github.bsideup.jabel.Desugar; import com.hfstudio.guidenh.guide.compiler.PageCompiler; import com.hfstudio.guidenh.guide.compiler.tags.functiongraph.FunctionGraphFenceParser; +import com.hfstudio.guidenh.guide.document.block.ContentAlign; +import com.hfstudio.guidenh.guide.document.block.ContentWrapMode; +import com.hfstudio.guidenh.guide.document.block.LytAlignedBlock; import com.hfstudio.guidenh.guide.document.block.LytBlock; import com.hfstudio.guidenh.guide.document.block.LytBlockContainer; import com.hfstudio.guidenh.guide.document.block.LytCodeBlock; +import com.hfstudio.guidenh.guide.document.block.LytDocumentFloat; import com.hfstudio.guidenh.guide.document.block.LytMermaidFlowchart; import com.hfstudio.guidenh.guide.document.block.LytMermaidMindmap; import com.hfstudio.guidenh.guide.internal.csv.CsvTableParser; @@ -22,6 +26,7 @@ import com.hfstudio.guidenh.guide.internal.markdown.CodeBlockLanguageDetector; import com.hfstudio.guidenh.guide.internal.markdown.FileTreeCompiler; import com.hfstudio.guidenh.guide.internal.mermaid.MermaidDiagramType; +import com.hfstudio.guidenh.guide.internal.mermaid.MermaidLayoutPrecomputer; import com.hfstudio.guidenh.guide.internal.mermaid.MermaidSourceExtractor; import com.hfstudio.guidenh.guide.internal.mermaid.flowchart.FlowchartParser; import com.hfstudio.guidenh.guide.internal.mermaid.mindmap.MindmapParser; @@ -34,6 +39,8 @@ public class PreCompiler extends BlockTagCompiler { private static final Pattern CODEBLOCK_META_WIDTH = Pattern.compile("(^|\\s)width=(\"([^\"]+)\"|'([^']+)'|(\\S+))"); private static final Pattern CODEBLOCK_META_HEIGHT = Pattern .compile("(^|\\s)height=(\"([^\"]+)\"|'([^']+)'|(\\S+))"); + private static final Pattern CODEBLOCK_META_WRAP = Pattern.compile("(^|\\s)wrap=(\"([^\"]+)\"|'([^']+)'|(\\S+))"); + private static final Pattern CODEBLOCK_META_ALIGN = Pattern.compile("(^|\\s)align=(\"([^\"]+)\"|'([^']+)'|(\\S+))"); @Override public Set getTagNames() { @@ -52,6 +59,16 @@ protected void compile(PageCompiler compiler, LytBlockContainer parent, MdxJsxEl String lang = el.getAttributeString("lang", null); String meta = el.getAttributeString("meta", null); + // Indented code block (no lang attribute) → plain text, no toolbar, no language detection + if (lang == null) { + LytCodeBlock codeBlock = new LytCodeBlock(); + codeBlock.setCodeContent("text", codeText); + codeBlock.setToolbarVisible(false); + codeBlock.applyLanguage(new CodeBlockLanguage("text", "Text")); + parent.append(codeBlock); + return; + } + CodeBlockLanguage language = CodeBlockLanguageDetector.detect(lang, codeText); // CSV table @@ -94,7 +111,10 @@ protected void compile(PageCompiler compiler, LytBlockContainer parent, MdxJsxEl if (forcedHeight != null) { codeBlock.setForcedBodyHeight(forcedHeight); } - parent.append(codeBlock); + // Parse wrap/align from fence meta for float embedding (R4-9) + ContentWrapMode wrapMode = ContentWrapMode.fromString(parseCodeBlockWrapMeta(meta)); + ContentAlign align = ContentAlign.fromString(parseCodeBlockAlignMeta(meta)); + parent.append(applyBlockEmbed(codeBlock, wrapMode, align)); } private LytBlock compileCsvCodeBlock(PageCompiler compiler, String source, @Nullable String meta) { @@ -201,6 +221,16 @@ private record CsvFenceMeta(boolean header, List widthHints) {} private @Nullable LytMermaidMindmap compileMermaidMindmap(String normalized) { try { LytMermaidMindmap block = new LytMermaidMindmap(MindmapParser.parse(normalized), normalized); + // Pre-compute diagram layout before first Rust layout so the canvas + // gets a correct preferredHeight and the VBox receives its real height + // in the initial layout pass (no second pass needed). + int pageWidth = 480; // no page-width info available at compile time + GuideDebugLog.debugAlways( + "[GuideNH-Mermaid] [PreCompiler] precomputeMindmapLayout entered pageWidth={}", pageWidth); + MermaidLayoutPrecomputer.precomputeMindmapLayout(block, pageWidth); + GuideDebugLog.debugAlways( + "[GuideNH-Mermaid] [PreCompiler] precomputeMindmapLayout exit explicitHeight={}", + block.getCanvas().getExplicitHeight()); GuideDebugLog .debug("[GuideNH] [PreCompiler] Compiled fenced Mermaid mindmap block ({} chars)", normalized.length()); return block; @@ -214,6 +244,16 @@ private record CsvFenceMeta(boolean header, List widthHints) {} private LytMermaidFlowchart compileMermaidFlowchart(String normalized) { var document = FlowchartParser.parse(normalized); LytMermaidFlowchart block = new LytMermaidFlowchart(document, normalized); + // Pre-compute diagram layout before first Rust layout so the canvas + // gets a correct preferredHeight and the VBox receives its real height + // in the initial layout pass (no second pass needed). + int pageWidth = 480; // no page-width info available at compile time + GuideDebugLog.debugAlways( + "[GuideNH-Mermaid] [PreCompiler] precomputeFlowchartLayout entered pageWidth={}", pageWidth); + MermaidLayoutPrecomputer.precomputeFlowchartLayout(block, pageWidth); + GuideDebugLog.debugAlways( + "[GuideNH-Mermaid] [PreCompiler] precomputeFlowchartLayout exit explicitHeight={}", + block.getCanvas().getExplicitHeight()); GuideDebugLog .debug("[GuideNH] [PreCompiler] Compiled fenced Mermaid flowchart stub ({} chars)", normalized.length()); return block; @@ -288,4 +328,49 @@ private static boolean isFunctionGraphFence(@Nullable String fenceLanguage) { return null; } } + + private static @Nullable String parseCodeBlockWrapMeta(@Nullable String meta) { + if (meta == null || meta.trim() + .isEmpty()) { + return null; + } + Matcher matcher = CODEBLOCK_META_WRAP.matcher(meta); + if (!matcher.find()) { + return null; + } + String value = matcher.group(3) != null ? matcher.group(3) + : matcher.group(4) != null ? matcher.group(4) : matcher.group(5); + return (value == null || value.trim() + .isEmpty()) ? null : value.trim(); + } + + private static @Nullable String parseCodeBlockAlignMeta(@Nullable String meta) { + if (meta == null || meta.trim() + .isEmpty()) { + return null; + } + Matcher matcher = CODEBLOCK_META_ALIGN.matcher(meta); + if (!matcher.find()) { + return null; + } + String value = matcher.group(3) != null ? matcher.group(3) + : matcher.group(4) != null ? matcher.group(4) : matcher.group(5); + return (value == null || value.trim() + .isEmpty()) ? null : value.trim(); + } + + /** + * Applies floating/alignment embed to a block, consistent with + * {@link BlockTagCompiler#applyBlockEmbed} semantics for JSX wrap/align. + * Duplicated here because {@code applyBlockEmbed} is private in the parent. + */ + private static LytBlock applyBlockEmbed(LytBlock node, ContentWrapMode wrapMode, ContentAlign align) { + if (wrapMode.isDocumentFloat()) { + return new LytDocumentFloat(node, align == ContentAlign.RIGHT); + } + if (align != ContentAlign.LEFT) { + node = new LytAlignedBlock(node, align); + } + return PageCompiler.wrapFloatAwareIfNeeded(node); + } } diff --git a/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/RecipeCompiler.java b/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/RecipeCompiler.java index 16fd2ef0..55d53592 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/RecipeCompiler.java +++ b/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/RecipeCompiler.java @@ -141,6 +141,8 @@ public static void appendRecipes(LytBlockContainer parent, List= 0 ? soundPath.substring(lastDot + 1) : soundPath; + link.appendText(shortName); + } + } else { + compiler.compileInlineFragment(children, link); + } parent.append(link); } diff --git a/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/SubscriptTagCompiler.java b/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/SubscriptTagCompiler.java index 976b26d7..c380868c 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/SubscriptTagCompiler.java +++ b/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/SubscriptTagCompiler.java @@ -18,7 +18,7 @@ public Set getTagNames() { @Override protected void compile(PageCompiler compiler, LytFlowParent parent, MdxJsxElementFields el) { LytFlowSpan span = new LytFlowSpan(); - span.modifyStyle(style -> style.fontScale(0.85f)); + span.modifyStyle(style -> style.fontScale(0.85f).baselineShift(0.3f)); compiler.compileFlowContext(el.children(), span); parent.append(span); } diff --git a/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/SuperscriptTagCompiler.java b/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/SuperscriptTagCompiler.java index 272cd5a3..47aa7ebb 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/SuperscriptTagCompiler.java +++ b/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/SuperscriptTagCompiler.java @@ -18,7 +18,7 @@ public Set getTagNames() { @Override protected void compile(PageCompiler compiler, LytFlowParent parent, MdxJsxElementFields el) { LytFlowSpan span = new LytFlowSpan(); - span.modifyStyle(style -> style.fontScale(0.85f)); + span.modifyStyle(style -> style.fontScale(0.85f).baselineShift(-0.3f)); compiler.compileFlowContext(el.children(), span); parent.append(span); } diff --git a/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/TableCompiler.java b/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/TableCompiler.java index 2b47437a..12dbe738 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/TableCompiler.java +++ b/src/main/java/com/hfstudio/guidenh/guide/compiler/tags/TableCompiler.java @@ -23,10 +23,12 @@ public Set getTagNames() { @Override protected void compile(PageCompiler compiler, LytBlockContainer parent, MdxJsxElementFields el) { LytTable table = new LytTable(); + table.setMarginTop(PageCompiler.DEFAULT_ELEMENT_SPACING); table.setMarginBottom(PageCompiler.DEFAULT_ELEMENT_SPACING); // Parse align attribute back to list String alignStr = el.getAttributeString("align", ""); + el.removeAttribute("align"); boolean firstRow = true; int rowIndex = 0; @@ -48,6 +50,7 @@ protected void compile(PageCompiler compiler, LytBlockContainer parent, MdxJsxEl LytTableRow row = table.appendRow(); if (firstRow) { row.modifyStyle(style -> style.bold(true)); + row.setHeader(true); firstRow = false; } @@ -74,16 +77,35 @@ protected void compile(PageCompiler compiler, LytBlockContainer parent, MdxJsxEl rowIndex++; } } + if (table.getChildren().isEmpty()) { + parent.appendError(compiler, "Empty table: no rows found", el); + return; + } parent.append(table); } private static String extractKramdownExpression(String content) { int start = content.indexOf('{'); int end = content.lastIndexOf('}'); + String stripped; if (start >= 0 && end > start) { - return content.substring(start + 1, end) + stripped = content.substring(start + 1, end) .trim(); + } else { + stripped = content.trim(); + } + // Try double quotes first + int firstQuote = stripped.indexOf('"'); + int lastQuote = stripped.lastIndexOf('"'); + if (firstQuote >= 0 && lastQuote > firstQuote) { + return stripped.substring(firstQuote + 1, lastQuote); + } + // Try single quotes + firstQuote = stripped.indexOf('\''); + lastQuote = stripped.lastIndexOf('\''); + if (firstQuote >= 0 && lastQuote > firstQuote) { + return stripped.substring(firstQuote + 1, lastQuote); } - return ""; + return stripped; } } diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/DefaultStyles.java b/src/main/java/com/hfstudio/guidenh/guide/document/DefaultStyles.java index e786e1a9..5403b2e2 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/DefaultStyles.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/DefaultStyles.java @@ -31,7 +31,8 @@ private DefaultStyles() {} TextAlignment.LEFT, false, null, - false); + false, + 0.0f); public static final TextStyle BODY_TEXT = TextStyle.builder() .font(UNIFORM_FONT) @@ -47,33 +48,48 @@ private DefaultStyles() {} .color(SymbolicColor.CRAFTING_RECIPE_TYPE) .build(); + /** + * Heading size ladder — strictly monotonic decreasing (H1 > H2 > ... > H6) + * so section depth reads from glyph size alone. All headings are bold and + * white to stay clearly distinct from the regular gray body text + * ({@link SymbolicColor#BODY_TEXT} #d2d2d2), compensating for the low + * contrast between title white and body gray. + */ public static final TextStyle HEADING1 = TextStyle.builder() - .fontScale(1.3f) + .fontScale(1.5f) .bold(true) .font(null) .color(ConstantColor.WHITE) .build(); public static final TextStyle HEADING2 = TextStyle.builder() - .fontScale(1.1f) + .fontScale(1.4f) + .bold(true) .font(null) + .color(ConstantColor.WHITE) .build(); public static final TextStyle HEADING3 = TextStyle.builder() - .fontScale(1f) + .fontScale(1.15f) + .bold(true) .font(null) + .color(ConstantColor.WHITE) .build(); public static final TextStyle HEADING4 = TextStyle.builder() - .fontScale(1.1f) + .fontScale(1.08f) .bold(true) .font(UNIFORM_FONT) + .color(ConstantColor.WHITE) .build(); public static final TextStyle HEADING5 = TextStyle.builder() .fontScale(1f) .bold(true) .font(UNIFORM_FONT) + .color(ConstantColor.WHITE) .build(); public static final TextStyle HEADING6 = TextStyle.builder() - .fontScale(1f) + .fontScale(0.95f) + .bold(true) .font(UNIFORM_FONT) + .color(ConstantColor.WHITE) .build(); public static final TextStyle SEARCH_RESULT_HIGHLIGHT = TextStyle.builder() diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/AlignItems.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/AlignItems.java index 1f6bfa27..8de0075c 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/AlignItems.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/AlignItems.java @@ -11,7 +11,8 @@ public enum AlignItems implements SerializedEnum { CENTER, START, - END; + END, + BASELINE; private final String serializedName; diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/IconMetrics.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/IconMetrics.java new file mode 100644 index 00000000..f366e349 --- /dev/null +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/IconMetrics.java @@ -0,0 +1,330 @@ +package com.hfstudio.guidenh.guide.document.block; + +import java.awt.image.BufferedImage; +import java.io.InputStream; +import java.util.Collections; +import java.util.HashSet; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.ConcurrentHashMap; + +import javax.imageio.ImageIO; + +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.texture.TextureAtlasSprite; +import net.minecraft.client.resources.IResource; +import net.minecraft.client.resources.IResourceManager; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; +import net.minecraft.util.ResourceLocation; + +import org.jetbrains.annotations.Nullable; + +import com.hfstudio.guidenh.guide.scene.support.GuideDebugLog; + +/** + * Computes the "ink" bounding box of an item icon texture — the smallest source + * rectangle covering every pixel whose alpha exceeds {@link #INK_ALPHA_THRESHOLD}, + * expressed in 16-unit icon space. This is the optical basis for the tight + * advance of inline item icons: the layout cell shrinks to {@code inkWidth * + * scale + 2 * PAD} and the icon is drawn at {@code -inkLeft * scale + PAD} so + * the ink left edge sits exactly {@code PAD} px from the cell's left edge + * (fixes "ItemLink icon sits too close to the item name / inconsistent gap"). + * + *

Pixel reads are inherently best-effort. The primary source is the atlas + * sprite's CPU frame data ({@link TextureAtlasSprite#getFrameTextureData(int)}), + * which is present for animated sprites (compass/clock) but cleared for static + * sprites after the atlas upload — in that case the source PNG is loaded from + * the resource manager (the same image the atlas stitched, always available on + * disk). Custom icons, the missing-texture sprite, and every other failure + * path return {@code null} so the caller keeps its legacy 16px-cell behavior + * with zero regression. + * + *

Results are cached statically keyed by {@code item:meta} (mirrors + * {@link com.hfstudio.guidenh.guide.internal.item.GuideDisplayItemStacks}), so + * per-frame stack swapping (e.g. {@link LytCyclingItemImage}) never pays the + * pixel scan more than once per item meta. + */ +public final class IconMetrics { + + /** Alpha (0-255) strictly above which a source pixel counts as ink. */ + public static final int INK_ALPHA_THRESHOLD = 8; + + /** Unit size of the icon draw quad (all item icons render into a 16x16 box). */ + private static final float ICON_UNIT_SIZE = 16f; + + private static final int MAX_CACHE_SIZE = 2048; + private static final Map CACHE = new ConcurrentHashMap<>(); + private static final Set WARNED = Collections.synchronizedSet(new HashSet<>()); + + /** Left edge of the ink bbox in 16-unit icon space (inclusive). */ + public final int inkLeft; + /** Right edge of the ink bbox in 16-unit icon space (inclusive). */ + public final int inkRight; + /** Top edge of the ink bbox in 16-unit icon space (inclusive). */ + public final int inkTop; + /** Bottom edge of the ink bbox in 16-unit icon space (inclusive). */ + public final int inkBottom; + /** Ink width in 16-unit icon space ({@code inkRight - inkLeft + 1}). */ + public final int width; + /** Ink height in 16-unit icon space ({@code inkBottom - inkTop + 1}). */ + public final int height; + + private IconMetrics(int inkLeft, int inkRight, int inkTop, int inkBottom) { + this.inkLeft = inkLeft; + this.inkRight = inkRight; + this.inkTop = inkTop; + this.inkBottom = inkBottom; + this.width = inkRight - inkLeft + 1; + this.height = inkBottom - inkTop + 1; + } + + /** + * Returns the ink metrics for {@code stack}, computing and caching them on + * first use. Returns {@code null} (without caching) on any failure path so + * callers fall back to their legacy 16px-cell behavior. + */ + @Nullable + public static IconMetrics forStack(@Nullable ItemStack stack) { + if (stack == null) { + return null; + } + Item item = stack.getItem(); + if (item == null) { + return null; + } + int meta = stack.getItemDamage(); + String key = metaCacheKey(item, meta); + IconMetrics cached = CACHE.get(key); + if (cached != null) { + return cached; + } + IconMetrics computed = compute(stack, item, key); + if (computed != null) { + if (CACHE.size() >= MAX_CACHE_SIZE) { + CACHE.clear(); + } + CACHE.put(key, computed); + } + return computed; + } + + @Nullable + private static IconMetrics compute(ItemStack stack, Item item, String key) { + int passes; + try { + passes = item.requiresMultipleRenderPasses() + ? Math.max(1, item.getRenderPasses(stack.getItemDamage())) + : 1; + } catch (Throwable t) { + warnOnce("passes:" + key, t); + passes = 1; + } + + int minLeft = Integer.MAX_VALUE; + int minTop = Integer.MAX_VALUE; + int maxRight = -1; + int maxBottom = -1; + + for (int pass = 0; pass < passes; pass++) { + IIcon icon; + try { + icon = passes > 1 ? item.getIcon(stack, pass) : stack.getIconIndex(); + } catch (Throwable t) { + warnOnce("icon:" + key + ":" + pass, t); + continue; + } + // TextureAtlasSprite is the only IIcon implementation carrying + // pixel data; custom icons and the missing-texture sprite fall back + // to the legacy cell. + if (!(icon instanceof TextureAtlasSprite)) { + continue; + } + if ("missingno".equals(icon.getIconName())) { + continue; + } + int[] ink = scanPass(key, (TextureAtlasSprite) icon, pass); + if (ink == null) { + continue; + } + if (ink[0] < minLeft) { + minLeft = ink[0]; + } + if (ink[1] < minTop) { + minTop = ink[1]; + } + if (ink[2] > maxRight) { + maxRight = ink[2]; + } + if (ink[3] > maxBottom) { + maxBottom = ink[3]; + } + } + + // No pass produced a single ink pixel (empty/fully-transparent texture) + // — treat as unmeasurable and fall back to the legacy cell. + if (maxRight < 0) { + return null; + } + return new IconMetrics(minLeft, maxRight, minTop, maxBottom); + } + + /** + * Scans one render pass's icon for ink pixels. + * + * @return {@code {inkLeft, inkTop, inkRight, inkBottom}} in 16-unit icon + * space, or {@code null} when no readable pixel source yields ink. + */ + @Nullable + private static int[] scanPass(String key, TextureAtlasSprite sprite, int pass) { + // Primary source: the atlas sprite's CPU frame data (task-specified). + // getIconWidth()/getIconHeight() account for the +16px padding that + // anisotropic filtering bakes into the pixel array, so pixel indexing + // MUST use them. + int w = sprite.getIconWidth(); + int h = sprite.getIconHeight(); + if (w > 0 && h > 0) { + try { + int[][] frames = sprite.getFrameTextureData(0); + if (frames != null && frames.length > 0) { + int[] pixels = frames[0]; + if (pixels != null && pixels.length >= w * h) { + return scanInkNormalized(pixels, w, h); + } + } + } catch (Throwable t) { + // Expected for static sprites: their CPU frame data is cleared + // after the atlas upload, so getFrameTextureData throws. This + // is the task-required tolerated fallback path; fall through to + // the resource-pack PNG source below instead of silently + // skipping the item. + } + } + // Fallback source: the sprite's source PNG from the resource manager — + // the same image the atlas stitched, always present on disk. + BufferedImage img = loadIconImage(sprite.getIconName()); + if (img == null) { + warnOnce("png:" + key + ":" + pass, "[GuideNH] IconMetrics: no readable pixel source for {}; falling back to legacy 16px cell"); + return null; + } + int iw = img.getWidth(); + int ih = img.getHeight(); + if (iw <= 0 || ih <= 0) { + warnOnce("png:" + key + ":" + pass, "[GuideNH] IconMetrics: no readable pixel source for {}; falling back to legacy 16px cell"); + return null; + } + int[] pixels = img.getRGB(0, 0, iw, ih, null, 0, iw); + return scanInkNormalized(pixels, iw, ih); + } + + /** + * Scans a row-major ARGB pixel array and returns the ink bbox normalized + * from the raw pixel grid to 16-unit icon space (item icons are drawn on a + * 16x16 quad regardless of the source texture's pixel dimensions). + */ + @Nullable + private static int[] scanInkNormalized(int[] pixels, int w, int h) { + int minLeft = Integer.MAX_VALUE; + int minTop = Integer.MAX_VALUE; + int maxRight = -1; + int maxBottom = -1; + for (int y = 0; y < h; y++) { + int rowBase = y * w; + for (int x = 0; x < w; x++) { + if (((pixels[rowBase + x] >>> 24) & 0xFF) > INK_ALPHA_THRESHOLD) { + if (x < minLeft) { + minLeft = x; + } + if (x > maxRight) { + maxRight = x; + } + if (y < minTop) { + minTop = y; + } + if (y > maxBottom) { + maxBottom = y; + } + } + } + } + if (maxRight < 0) { + return null; + } + return new int[] { + Math.round(minLeft * ICON_UNIT_SIZE / w), + Math.round(minTop * ICON_UNIT_SIZE / h), + Math.round(maxRight * ICON_UNIT_SIZE / w), + Math.round(maxBottom * ICON_UNIT_SIZE / h) }; + } + + /** + * Loads the source PNG of the sprite named {@code iconName} (e.g. + * {@code apple} or {@code crafting_table_top}) from the item or block + * texture folders, mirroring the atlas's own path resolution. + */ + @Nullable + private static BufferedImage loadIconImage(@Nullable String iconName) { + if (iconName == null || iconName.isEmpty()) { + return null; + } + Minecraft mc = Minecraft.getMinecraft(); + if (mc == null) { + return null; + } + IResourceManager rm = mc.getResourceManager(); + if (rm == null) { + return null; + } + ResourceLocation base; + try { + base = new ResourceLocation(iconName); + } catch (Throwable t) { + return null; + } + BufferedImage img = tryLoad(rm, base, "textures/items"); + if (img == null) { + img = tryLoad(rm, base, "textures/blocks"); + } + return img; + } + + @Nullable + private static BufferedImage tryLoad(IResourceManager rm, ResourceLocation base, String folder) { + try { + ResourceLocation loc = new ResourceLocation( + base.getResourceDomain(), + folder + "/" + base.getResourcePath() + ".png"); + IResource res = rm.getResource(loc); + if (res == null) { + return null; + } + try (InputStream in = res.getInputStream()) { + return ImageIO.read(in); + } + } catch (Throwable t) { + return null; + } + } + + /** Reuses the {@code item:meta} key convention from GuideDisplayItemStacks. */ + private static String metaCacheKey(Item item, int meta) { + Object name = Item.itemRegistry.getNameForObject(item); + return (name != null ? name.toString() : item.getClass().getName()) + ":" + meta; + } + + private static void warnOnce(String key, String message) { + if (WARNED.add(key)) { + GuideDebugLog.warnAlways(message, key); + } + } + + private static void warnOnce(String key, Throwable t) { + if (WARNED.add(key)) { + GuideDebugLog.warnAlways( + "[GuideNH] IconMetrics: failed to read ink metrics for {}; falling back to legacy 16px cell", + key, + t); + } + } +} diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/LatexRenderOptions.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/LatexRenderOptions.java index 02cbcca0..9041a921 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/LatexRenderOptions.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/LatexRenderOptions.java @@ -1,13 +1,14 @@ package com.hfstudio.guidenh.guide.document.block; import org.jetbrains.annotations.Nullable; +import org.scilab.forge.jlatexmath.TeXConstants; import com.github.bsideup.jabel.Desugar; import com.hfstudio.guidenh.guide.document.interaction.GuideTooltip; @Desugar -public record LatexRenderOptions(int fillColorArgb, float sourceScale, float userScale, @Nullable GuideTooltip tooltip, - LatexVerticalAlign valign, int offsetX, int offsetY) { +public record LatexRenderOptions(int style, int fillColorArgb, float sourceScale, float userScale, + @Nullable GuideTooltip tooltip, LatexVerticalAlign valign, int offsetX, int offsetY) { public static final int DEFAULT_FILL_COLOR_ARGB = 0xFFFFFFFF; public static final float DEFAULT_SOURCE_SCALE = 100.0f; @@ -23,10 +24,14 @@ public static Builder builder() { if (valign == null) { valign = LatexVerticalAlign.BASELINE; } + if (style != TeXConstants.STYLE_DISPLAY && style != TeXConstants.STYLE_TEXT) { + style = TeXConstants.STYLE_DISPLAY; + } } public static final class Builder { + private int style = TeXConstants.STYLE_DISPLAY; private int fillColorArgb = DEFAULT_FILL_COLOR_ARGB; private float sourceScale = DEFAULT_SOURCE_SCALE; private float userScale = DEFAULT_USER_SCALE; @@ -38,6 +43,11 @@ public static final class Builder { private Builder() {} + public Builder style(int style) { + this.style = style; + return this; + } + public Builder fillColorArgb(int fillColorArgb) { this.fillColorArgb = fillColorArgb; return this; @@ -70,7 +80,7 @@ public Builder offset(int offsetX, int offsetY) { } public LatexRenderOptions build() { - return new LatexRenderOptions(fillColorArgb, sourceScale, userScale, tooltip, valign, offsetX, offsetY); + return new LatexRenderOptions(style, fillColorArgb, sourceScale, userScale, tooltip, valign, offsetX, offsetY); } } } diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytAlignedBlock.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytAlignedBlock.java index b36528e8..1774b73b 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytAlignedBlock.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytAlignedBlock.java @@ -4,6 +4,7 @@ import com.hfstudio.guidenh.guide.document.LytRect; import com.hfstudio.guidenh.guide.layout.LayoutContext; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.render.RenderContext; import lombok.Getter; @@ -92,6 +93,16 @@ public LytNode pickNode(int x, int y) { return inner.pickNode(x, y); } + @Override + public boolean usePrimitives() { + return true; + } + + @Override + public void computePrimitives(PrimitiveCollector c) { + // No-op: inner child is picked up by PrimitiveCollector.collectFrom traversal. + } + @Override public void render(RenderContext context) { inner.render(context); diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytBalancedColumns.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytBalancedColumns.java deleted file mode 100644 index 33990626..00000000 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytBalancedColumns.java +++ /dev/null @@ -1,115 +0,0 @@ -package com.hfstudio.guidenh.guide.document.block; - -import com.hfstudio.guidenh.guide.document.LytRect; -import com.hfstudio.guidenh.guide.layout.LayoutContext; -import com.hfstudio.guidenh.guide.layout.Layouts; - -import lombok.Getter; -import lombok.Setter; - -/** - * Places children into up to two columns, always preferring the left-most column when it has the - * same or more free vertical space than the right column. Falls back to a normal vertical stack - * when any child cannot fit inside a half-width column. - */ -@Getter -@Setter -public class LytBalancedColumns extends LytBox { - - private static final int DEFAULT_COLUMN_COUNT = 2; - - private int gap; - - @Override - protected LytRect computeBoxLayout(LayoutContext context, int x, int y, int availableWidth) { - if (children.isEmpty()) { - return new LytRect(x, y, 0, 0); - } - - if (children.size() < DEFAULT_COLUMN_COUNT) { - return verticalFallback(context, x, y, availableWidth); - } - - int columnWidth = Math.max(1, (availableWidth - gap * (DEFAULT_COLUMN_COUNT - 1)) / DEFAULT_COLUMN_COUNT); - int[] columnBottoms = new int[DEFAULT_COLUMN_COUNT]; - int[] columnCounts = new int[DEFAULT_COLUMN_COUNT]; - LytBlock[] previousBlocks = new LytBlock[DEFAULT_COLUMN_COUNT]; - int contentWidth = 0; - int contentHeight = 0; - - for (LytBlock child : children) { - int blockWidth = Math.max(1, columnWidth - child.getMarginLeft() - child.getMarginRight()); - - int leftColumnX = x + child.getMarginLeft(); - int leftColumnY = Layouts - .offsetIntoContentArea(LytAxis.VERTICAL, y + columnBottoms[0], previousBlocks[0], child); - LytRect childBounds = child.layout(context, leftColumnX, leftColumnY, blockWidth); - int occupiedWidth = childBounds.width() + child.getMarginLeft() + child.getMarginRight(); - if (occupiedWidth > columnWidth) { - return verticalFallback(context, x, y, availableWidth); - } - - int leftProjectedBottom = childBounds.bottom() - y + child.getMarginBottom() + gap; - - int rightColumnX = x + columnWidth + gap + child.getMarginLeft(); - int rightColumnY = Layouts - .offsetIntoContentArea(LytAxis.VERTICAL, y + columnBottoms[1], previousBlocks[1], child); - int rightProjectedBottom = rightColumnY - y + childBounds.height() + child.getMarginBottom() + gap; - - int columnIndex = selectColumn( - columnBottoms[0], - columnBottoms[1], - leftProjectedBottom, - rightProjectedBottom, - columnCounts[0], - columnCounts[1]); - - if (columnIndex == 1) { - child.moveLayoutPos(rightColumnX - leftColumnX, rightColumnY - leftColumnY); - childBounds = child.getBounds(); - } - - columnBottoms[columnIndex] = columnIndex == 0 ? leftProjectedBottom : rightProjectedBottom; - columnCounts[columnIndex]++; - previousBlocks[columnIndex] = child; - contentWidth = Math.max(contentWidth, childBounds.right() - x); - contentHeight = Math.max(contentHeight, childBounds.bottom() - y); - } - - return new LytRect(x, y, contentWidth, contentHeight); - } - - private LytRect verticalFallback(LayoutContext context, int x, int y, int availableWidth) { - return Layouts.verticalLayout(context, children, x, y, availableWidth, 0, 0, 0, 0, gap, AlignItems.START); - } - - private static int selectColumn(int leftBottom, int rightBottom, int leftProjectedBottom, int rightProjectedBottom, - int leftCount, int rightCount) { - int leftProjectedHeight = Math.max(leftProjectedBottom, rightBottom); - int rightProjectedHeight = Math.max(leftBottom, rightProjectedBottom); - if (leftProjectedHeight < rightProjectedHeight) { - return 0; - } - if (rightProjectedHeight < leftProjectedHeight) { - return 1; - } - - int leftProjectedGap = Math.abs(leftProjectedBottom - rightBottom); - int rightProjectedGap = Math.abs(leftBottom - rightProjectedBottom); - if (leftProjectedGap < rightProjectedGap) { - return 0; - } - if (rightProjectedGap < leftProjectedGap) { - return 1; - } - - if (leftCount < rightCount) { - return 0; - } - if (rightCount < leftCount) { - return 1; - } - - return 0; - } -} diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytBlock.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytBlock.java index 04652261..a800c1b7 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytBlock.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytBlock.java @@ -1,8 +1,11 @@ package com.hfstudio.guidenh.guide.document.block; +import org.jetbrains.annotations.Nullable; + import com.hfstudio.guidenh.guide.document.LytPoint; import com.hfstudio.guidenh.guide.document.LytRect; import com.hfstudio.guidenh.guide.layout.LayoutContext; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.render.RenderContext; import com.hfstudio.guidenh.guide.style.BorderStyle; @@ -16,6 +19,24 @@ public abstract class LytBlock extends LytNode { */ protected LytRect bounds = LytRect.empty(); + /** + * Bounds used for viewport culling: the union of this block's own bounds + * and all descendants' bounds. Computed after each external layout pass — + * floated or otherwise overflowing children must keep their ancestors + * visible even when the ancestor's own rect leaves the viewport. + */ + @Nullable + private LytRect cullBounds; + + /** Culling bounds: subtree union when computed, own bounds otherwise. */ + public LytRect getCullBounds() { + return cullBounds != null ? cullBounds : bounds; + } + + public void setCullBounds(@Nullable LytRect cullBounds) { + this.cullBounds = cullBounds; + } + @Getter @Setter private int marginTop; @@ -49,13 +70,61 @@ public abstract class LytBlock extends LytNode { @Setter private boolean fullWidth; + /** + * Flex grow factor for this block inside a row/column flex container + * (declared by the block itself, e.g. the code toolbar's language label + * takes the remaining width). Read directly by the layout compiler — no + * serializer-side special case. + */ + @Getter + @Setter + private float flexGrow; + + /** + * Override the layout bounds with an externally computed rect (the Rust + * layout engine). Children receive their own rects from the same pass, so + * no propagation happens here. Subclasses with position/size-dependent + * internal state (sample caches, precomputed geometry) should override + * {@link #onExternalLayoutApplied} to invalidate it. + */ + public void applyExternalLayout(LytRect rect) { + LytRect old = bounds; + bounds = rect; + onExternalLayoutApplied(old, rect); + } + + /** + * The rect this block occupies in the document flow. Unlike + * {@link #getBounds()} this is never overridden for visual overflow — e.g. + * {@code LytDocumentFloat} reports a zero-height flow rect while its inner + * content visually overflows into the following content. + */ + public LytRect getFlowBounds() { + return bounds; + } + + /** + * Called after {@link #applyExternalLayout} replaced this block's bounds. + * Default no-op. Subclasses with position/size-dependent internal state + * (sample caches, precomputed geometry) should override to invalidate it. + */ + protected void onExternalLayoutApplied(LytRect oldBounds, LytRect newBounds) {} + + /** + * Called after the entire external-layout writeback pass completed — + * i.e. when this block's children's bounds are also final. Default no-op. + * Scroll containers override it to re-apply their scroll offset to the + * content (the writeback resets content to the unscrolled position). + */ + protected void afterExternalLayout() {} + @Override public LytRect getBounds() { return bounds; } public boolean isCulled(LytRect viewport) { - return !viewport.intersects(bounds); + return !viewport.intersects(getCullBounds()); } public final void setLayoutPos(LytPoint point) { @@ -77,6 +146,13 @@ public final void setLayoutPos(LytPoint point) { public final void moveLayoutPos(int deltaX, int deltaY) { if (deltaX != 0 || deltaY != 0) { bounds = bounds.move(deltaX, deltaY); + // The cull bounds (subtree union) move rigidly with the block — + // scroll replay/smooth scrolling move the whole subtree by the same + // delta, so a fresh union is unnecessary; without this, content + // scrolled into view gets culled by its stale rect (B-1). + if (cullBounds != null) { + cullBounds = cullBounds.move(deltaX, deltaY); + } onLayoutMoved(deltaX, deltaY); } } @@ -118,4 +194,68 @@ public void setBorder(BorderStyle style) { protected abstract void onLayoutMoved(int deltaX, int deltaY); public abstract void render(RenderContext context); + + // ---- explicit size --------------------------------------------------- + + /** + * Override to declare a preferred width in pixels. + * Returns -1 when no explicit width is set. + */ + public int getExplicitWidth() { + return -1; + } + + /** + * Override to declare a preferred height in pixels. + * Returns -1 when no explicit height is set. + */ + public int getExplicitHeight() { + return -1; + } + + // ---- primitive collection -------------------------------------------- + + /** + * Whether this block renders through {@link #computePrimitives}. When + * {@code false}, {@link PrimitiveCollector} emits a legacy-render fallback + * ({@link GuideRenderPrimitive.HostDraw}) that invokes {@link #render} for + * the whole subtree and does not recurse into children. + *

+ * Defaults to {@code false} so unmigrated blocks keep rendering via the + * legacy path; subclasses that implement {@code computePrimitives} must + * override this to return {@code true}. The decision may be dynamic + * (e.g. LytParagraph returns true only when a Rust-shaped glyph run is + * available). + */ + public boolean usePrimitives() { + return false; + } + + /** + * Emit this block's own draw primitives. Do not iterate + * {@link #getChildren()} — the {@link PrimitiveCollector} handles + * tree traversal. Nodes with private rendering data (e.g. MermaidCanvas) + * may call {@link PrimitiveCollector#collectFrom} on their internal + * subtrees here. + */ + public void computePrimitives(PrimitiveCollector c) {} + + /** + * Override to declare a clip rectangle for this block's children. + * The PrimitiveCollector will automatically emit PushScissor before + * recursing into children and PopScissor after, using the returned + * rectangle in document coordinates. + * + * @return a clip rect in document coordinates, or null for no clipping + */ + public @org.jetbrains.annotations.Nullable LytRect getChildrenClipRect() { + return null; + } + + /** + * Emit decoration primitives (borders, outlines) that must paint + * after children. Called by {@link PrimitiveCollector#collectFrom} + * after recursing into {@link #getChildren()}. + */ + public void emitDecorations(PrimitiveCollector c) {} } diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytBox.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytBox.java index 1b3e6b2d..4328240f 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytBox.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytBox.java @@ -8,7 +8,10 @@ import com.hfstudio.guidenh.guide.color.SymbolicColor; import com.hfstudio.guidenh.guide.document.LytRect; import com.hfstudio.guidenh.guide.layout.LayoutContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.render.RenderContext; +import com.hfstudio.guidenh.guide.style.BorderStyle; import lombok.Setter; @@ -144,4 +147,59 @@ public void render(RenderContext context) { .render(context, bounds, getBorderTop(), getBorderLeft(), getBorderRight(), getBorderBottom()); } } + + @Override + public boolean usePrimitives() { + return true; + } + + @Override + public void computePrimitives(PrimitiveCollector c) { + if (backgroundColor != null) { + c.emit( + new GuideRenderPrimitive.FillRect( + bounds.x(), + bounds.y(), + bounds.width(), + bounds.height(), + resolveBackgroundArgb())); + } + } + + @Override + public void emitDecorations(PrimitiveCollector c) { + if (getBorderTop().width() > 0 || getBorderLeft().width() > 0 + || getBorderRight().width() > 0 + || getBorderBottom().width() > 0) { + c.emit( + new GuideRenderPrimitive.DrawBorder( + bounds.x(), + bounds.y(), + bounds.width(), + bounds.height(), + getBorderTop().width(), + getBorderLeft().width(), + getBorderRight().width(), + getBorderBottom().width(), + resolveBorderArgb())); + } + } + + private int resolveBackgroundArgb() { + if (backgroundColor == null) return 0; + return backgroundColor.resolve(com.hfstudio.guidenh.guide.color.LightDarkMode.current()); + } + + private int resolveBorderArgb() { + // DrawBorder is single-color; use the first side that declares one + // (some blocks, e.g. the code toolbar, only set a bottom border). + BorderStyle[] sides = { getBorderTop(), getBorderLeft(), getBorderRight(), getBorderBottom() }; + for (BorderStyle side : sides) { + var color = side.color(); + if (color != null) { + return color.resolve(com.hfstudio.guidenh.guide.color.LightDarkMode.current()); + } + } + return 0xFF000000; + } } diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytCodeBlock.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytCodeBlock.java index 6f7e4de0..cb7595e0 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytCodeBlock.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytCodeBlock.java @@ -18,6 +18,8 @@ import com.hfstudio.guidenh.guide.internal.util.GuideStringLines; import com.hfstudio.guidenh.guide.internal.util.SmoothFloatState; import com.hfstudio.guidenh.guide.layout.LayoutContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.render.RenderContext; import com.hfstudio.guidenh.guide.style.BorderStyle; import com.hfstudio.guidenh.guide.style.WhiteSpaceMode; @@ -38,10 +40,14 @@ public class LytCodeBlock extends LytVBox implements InteractiveElement, Documen private static final int MIN_SCROLLBAR_THUMB = 14; private final LytCodeBlockToolbar toolbar = new LytCodeBlockToolbar(); + private final LytViewportBox bodyViewport = new LytViewportBox(); private final LytParagraph body = new LytParagraph(); @Getter private String codeText = ""; + + @Getter + private boolean toolbarVisible = true; private String normalizedCodeText = ""; @Getter private String languageFenceName = ""; @@ -54,15 +60,10 @@ public class LytCodeBlock extends LytVBox implements InteractiveElement, Documen @Getter private int forcedBodyHeight; @Getter - private int bodyContentHeight; - private int bodyViewportX; - private int bodyViewportY; - private int bodyViewportWidth; - @Getter - private int bodyViewportHeight; - @Getter private int bodyScrollOffsetY; private final SmoothFloatState visualBodyScrollOffsetY = new SmoothFloatState(); + /** Visual-scroll delta currently baked into the body's bounds (see computePrimitives). */ + private int appliedVisualDeltaY; @Getter private boolean draggingBody; private int dragLastDocumentY; @@ -87,14 +88,32 @@ public LytCodeBlock() { body.setPaddingTop(BODY_PADDING); body.setPaddingBottom(BODY_PADDING); body.modifyStyle( - style -> style.whiteSpace(WhiteSpaceMode.PRE_WRAP) + style -> style.whiteSpace(WhiteSpaceMode.PRE) .color(CODE_DEFAULT)); + bodyViewport.setFullWidth(true); + bodyViewport.append(body); append(toolbar); - append(body); + append(bodyViewport); syncToolbar(); } + @Override + public List getChildren() { + // When toolbar is hidden, exclude it from the children list so the + // Rust layout engine and PrimitiveCollector do not process it. + // The internal children list (including toolbar) is still maintained + // for direct field access (render, mouse click, etc.). + if (!toolbarVisible) { + return List.of(bodyViewport); + } + return super.getChildren(); + } + + public void setToolbarVisible(boolean toolbarVisible) { + this.toolbarVisible = toolbarVisible; + } + public void setCodeText(String codeText) { setCodeContent(languageFenceName, codeText); } @@ -142,6 +161,10 @@ public void setPreferredBodyWidth(int preferredBodyWidth) { public void setForcedBodyHeight(int forcedBodyHeight) { this.forcedBodyHeight = Math.max(0, forcedBodyHeight); + // Make the viewport height visible to the Rust layout serializer: + // propagate the forced height (or -1 for auto) so serialization sees it + // before Rust measures. Aligns with computeBoxLayout semantics. + bodyViewport.setExplicitHeight(this.forcedBodyHeight > 0 ? this.forcedBodyHeight : -1); } public int getBodyLineCount() { @@ -151,7 +174,10 @@ public int getBodyLineCount() { @Override public boolean mouseClicked(GuideUiHost screen, int x, int y, int button, boolean doubleClick) { // Scrollbar-related interactions are handled by beginDrag/dragTo (mouseDown can start a drag directly). - return toolbar.mouseClicked(screen, x, y, button, doubleClick); + if (toolbarVisible && toolbar.mouseClicked(screen, x, y, button, doubleClick)) { + return true; + } + return false; } @Override @@ -159,7 +185,7 @@ public boolean beginDrag(int documentX, int documentY, int button) { if (button != 0) { return false; } - if (toolbar.getBounds() + if (toolbarVisible && toolbar.getBounds() .contains(documentX, documentY)) { return false; } @@ -212,32 +238,133 @@ public boolean scroll(int documentX, int documentY, int wheelDelta) { return true; } + @Override + public boolean usePrimitives() { + return true; + } + + @Override + public void computePrimitives(PrimitiveCollector c) { + super.computePrimitives(c); + c.emit( + new GuideRenderPrimitive.FillRect( + bounds.x(), + bounds.y(), + bounds.width(), + bounds.height(), + CODE_BACKGROUND.resolve(com.hfstudio.guidenh.guide.color.LightDarkMode.current()))); + + // Advance the smooth scroll and bake the visual delta into the body's + // bounds. The collector traverses the body right after this, so the + // body renders at its animated position and hit-tests stay aligned. + updateVisualScroll(); + int newDelta = bodyScrollOffsetY - visualBodyScrollOffsetY.rounded(); + if (newDelta != appliedVisualDeltaY && !body.getBounds() + .isEmpty()) { + body.moveLayoutPos(0, newDelta - appliedVisualDeltaY); + appliedVisualDeltaY = newDelta; + } + + if (getMaxBodyScroll() > 0) { + LytRect track = getScrollbarTrackBounds(); + if (!track.isEmpty()) { + c.emit( + new GuideRenderPrimitive.FillRect( + track.x(), + track.y(), + track.width(), + track.height(), + CODE_THEME.scrollbarTrackArgb())); + LytRect thumb = getScrollbarThumbBounds(); + if (!thumb.isEmpty()) { + c.emit( + new GuideRenderPrimitive.FillRect( + thumb.x(), + thumb.y(), + thumb.width(), + thumb.height(), + draggingScrollbar ? CODE_THEME.scrollbarThumbActiveArgb() + : CODE_THEME.scrollbarThumbArgb())); + } + } + } + } + + @Override + protected void afterExternalLayout() { + // The writeback reset the body to the unscrolled position; re-apply the + // current scroll offset and restart the visual-delta bookkeeping. + updateBodyPosition(); + appliedVisualDeltaY = 0; + } + @Override protected LytRect computeBoxLayout(LayoutContext context, int x, int y, int availableWidth) { int safeWidth = preferredBodyWidth > 0 ? Math.max(1, Math.min(availableWidth, preferredBodyWidth)) : Math.max(1, availableWidth); - toolbar.setPreferredWidth(safeWidth); - LytRect toolbarBounds = toolbar.layout(context, x, y, safeWidth); - int bodyY = toolbarBounds.bottom() + getGap(); + int toolbarHeight; + int bodyY; + if (toolbarVisible) { + toolbar.setPreferredWidth(safeWidth); + LytRect toolbarBounds = toolbar.layout(context, x, y, safeWidth); + toolbarHeight = toolbarBounds.height() + getGap(); + bodyY = toolbarBounds.bottom() + getGap(); + } else { + toolbarHeight = 0; + bodyY = y; + } int bodyAvailableWidth = safeWidth; LytRect measuredBody = body.layout(context, x, bodyY, bodyAvailableWidth); - bodyContentHeight = measuredBody.height(); - bodyViewportHeight = forcedBodyHeight > 0 ? forcedBodyHeight : bodyContentHeight; - if (forcedBodyHeight > 0 && bodyContentHeight > bodyViewportHeight) { + int contentHeight = measuredBody.height(); + int viewportHeight = forcedBodyHeight > 0 ? forcedBodyHeight : contentHeight; + if (forcedBodyHeight > 0 && contentHeight > viewportHeight) { bodyAvailableWidth = Math.max(1, safeWidth - SCROLLBAR_WIDTH - 4); measuredBody = body.layout(context, x, bodyY, bodyAvailableWidth); - bodyContentHeight = measuredBody.height(); + contentHeight = measuredBody.height(); } - bodyViewportHeight = forcedBodyHeight > 0 ? forcedBodyHeight : bodyContentHeight; - bodyViewportX = x; - bodyViewportY = bodyY; - bodyViewportWidth = bodyAvailableWidth; + viewportHeight = forcedBodyHeight > 0 ? forcedBodyHeight : contentHeight; + bodyViewport.setExplicitHeight(viewportHeight); + bodyViewport.layout(context, x, bodyY, bodyAvailableWidth); setBodyScrollOffset(bodyScrollOffsetY); snapVisualScrollToTarget(); - return new LytRect(x, y, safeWidth, toolbarBounds.height() + getGap() + bodyViewportHeight); + return new LytRect(x, y, safeWidth, toolbarHeight + viewportHeight); + } + + // ---- derived geometry (computed from current bounds; no layout-time fields) ---- + + private int getBodyContentHeight() { + return body.getBounds() + .height(); + } + + private LytRect getBodyViewportBounds() { + LytRect tb = toolbar.getBounds(); + int x = bounds.x() + getBorderLeft().width() + paddingLeft; + int y = tb.isEmpty() ? bounds.y() + getBorderTop().width() + paddingTop : tb.bottom() + getGap(); + int w = bounds.right() - getBorderRight().width() - paddingRight - x; + int h; + if (forcedBodyHeight > 0) { + h = forcedBodyHeight; + if (getMaxBodyScroll() > 0) { + w = Math.max(1, w - SCROLLBAR_WIDTH - 4); + } + } else { + h = getBodyContentHeight(); + } + return new LytRect(x, y, Math.max(0, w), Math.max(0, h)); + } + + /** Public viewport height accessor (derived; replaces the former layout-time field). */ + public int getBodyViewportHeight() { + return getBodyViewportBounds().height(); + } + + private int getMaxBodyScroll() { + if (forcedBodyHeight <= 0) return 0; + return Math.max(0, getBodyContentHeight() - forcedBodyHeight); } @Override @@ -249,14 +376,8 @@ public void render(RenderContext context) { } context.fillRect(ownBounds, CODE_BACKGROUND); - toolbar.render(context); - - LytRect bodyViewport = getBodyViewportBounds(); - context.pushLocalScissor(bodyViewport); - try { - renderBodyWithVisualOffset(context); - } finally { - context.popScissor(); + if (toolbarVisible) { + toolbar.render(context); } renderScrollbar(context); @@ -316,10 +437,6 @@ private void renderScrollbar(RenderContext context) { } } - private LytRect getBodyViewportBounds() { - return new LytRect(bodyViewportX, bodyViewportY, bodyViewportWidth, Math.max(0, bodyViewportHeight)); - } - private LytRect getScrollbarTrackBounds() { if (getMaxBodyScroll() <= 0) { return LytRect.empty(); @@ -334,8 +451,9 @@ private LytRect getScrollbarThumbBounds() { if (track.isEmpty()) { return LytRect.empty(); } - int thumbHeight = Math - .max(MIN_SCROLLBAR_THUMB, track.height() * track.height() / Math.max(track.height(), bodyContentHeight)); + int thumbHeight = Math.max( + MIN_SCROLLBAR_THUMB, + track.height() * track.height() / Math.max(track.height(), getBodyContentHeight())); thumbHeight = Math.min(thumbHeight, track.height()); int maxScroll = getMaxBodyScroll(); int thumbTrack = Math.max(1, track.height() - thumbHeight); @@ -346,41 +464,23 @@ private LytRect getScrollbarThumbBounds() { return new LytRect(track.x(), thumbY, track.width(), thumbHeight); } - private int getMaxBodyScroll() { - return Math.max(0, bodyContentHeight - bodyViewportHeight); - } - private void setBodyScrollOffset(int bodyScrollOffsetY) { this.bodyScrollOffsetY = SceneEditorVerticalScrollbar.clamp(bodyScrollOffsetY, 0, getMaxBodyScroll()); updateBodyPosition(); } private void updateBodyPosition() { - if (!body.getBounds() - .isEmpty() - && !toolbar.getBounds() - .isEmpty()) { - int bodyViewportY = toolbar.getBounds() - .bottom() + getGap(); + LytRect viewport = getBodyViewportBounds(); + if (!viewport.isEmpty() && !body.getBounds() + .isEmpty()) { body.moveLayoutPos( 0, - bodyViewportY - bodyScrollOffsetY + viewport.y() - bodyScrollOffsetY - body.getBounds() .y()); - } - } - - private void renderBodyWithVisualOffset(RenderContext context) { - int renderDeltaY = bodyScrollOffsetY - visualBodyScrollOffsetY.rounded(); - if (renderDeltaY == 0) { - body.render(context); - return; - } - body.moveLayoutPos(0, renderDeltaY); - try { - body.render(context); - } finally { - body.moveLayoutPos(0, -renderDeltaY); + // Bounds now sit at the scroll target; the visual delta restarts + // from here and is re-baked by computePrimitives each frame. + appliedVisualDeltaY = 0; } } @@ -404,6 +504,6 @@ private void snapVisualScrollToTarget() { private void updateVisualScroll() { visualBodyScrollOffsetY - .updateTowards(bodyScrollOffsetY, 28f, 0.25f, 0.01f, Math.max(128f, bodyViewportHeight * 2f)); + .updateTowards(bodyScrollOffsetY, 28f, 0.25f, 0.01f, Math.max(128f, getBodyViewportBounds().height() * 2f)); } } diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytCodeBlockToolbar.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytCodeBlockToolbar.java index 705a9734..3d39cba1 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytCodeBlockToolbar.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytCodeBlockToolbar.java @@ -17,6 +17,8 @@ import com.hfstudio.guidenh.guide.internal.screen.GuideIconButton; import com.hfstudio.guidenh.guide.layout.LayoutContext; import com.hfstudio.guidenh.guide.render.GuiSprite; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.render.RenderContext; import com.hfstudio.guidenh.guide.style.BorderStyle; import com.hfstudio.guidenh.guide.ui.GuideUiHost; @@ -66,6 +68,9 @@ public LytCodeBlockToolbar() { languageLabel.setMarginTop(0); languageLabel.setMarginBottom(0); + // The label takes the remaining toolbar width — declared on the block + // itself, read directly by the layout compiler (no special case). + languageLabel.setFlexGrow(1f); languageLabel.modifyStyle( style -> style.bold(true) .color(toolbarText)); @@ -168,6 +173,18 @@ public Optional getTooltip(float x, float y) { return Optional.empty(); } + @Override + public void computePrimitives(PrimitiveCollector c) { + super.computePrimitives(c); + c.emit( + new GuideRenderPrimitive.FillRect( + bounds.x(), + bounds.y(), + bounds.width(), + bounds.height(), + toolbarBackground.resolve(com.hfstudio.guidenh.guide.color.LightDarkMode.current()))); + } + @Override public void render(RenderContext context) { context.fillRect(bounds, toolbarBackground); diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytContentTabsBlock.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytContentTabsBlock.java index 175ad2f6..a4c5c1e7 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytContentTabsBlock.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytContentTabsBlock.java @@ -8,6 +8,7 @@ import com.hfstudio.guidenh.guide.color.ColorValue; import com.hfstudio.guidenh.guide.color.ConstantColor; +import com.hfstudio.guidenh.guide.color.LightDarkMode; import com.hfstudio.guidenh.guide.color.SymbolicColor; import com.hfstudio.guidenh.guide.compiler.PageCompiler; import com.hfstudio.guidenh.guide.compiler.tags.ContentTabsSpec; @@ -17,70 +18,37 @@ import com.hfstudio.guidenh.guide.document.interaction.InteractiveElement; import com.hfstudio.guidenh.guide.internal.debug.DebugComponent; import com.hfstudio.guidenh.guide.layout.LayoutContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.render.RenderContext; import com.hfstudio.guidenh.guide.style.BorderStyle; -import com.hfstudio.guidenh.guide.style.ResolvedTextStyle; -import com.hfstudio.guidenh.guide.style.TextAlignment; -import com.hfstudio.guidenh.guide.style.WhiteSpaceMode; import com.hfstudio.guidenh.guide.ui.GuideUiHost; +/** + * Tabbed container: an optional title paragraph, a {@link LytContentTabsHeader} + * strip, and the ACTIVE tab body. The tree only ever contains those live + * children — hidden tab bodies are reachable to semantic traversals (search, + * anchors, resource export) through {@link #visitChildren} but are never laid + * out or rendered. + */ public class LytContentTabsBlock extends LytBlock implements InteractiveElement, DebugComponent { private static final int ACCENT_WIDTH = 3; private static final int CONTAINER_PAD_X = 10; private static final int CONTAINER_PAD_Y = 6; - private static final int HEADER_GAP_X = 10; - private static final int HEADER_GAP_Y = 5; - private static final int HEADER_PAD_X = 2; - private static final int HEADER_PAD_TOP = 1; - private static final int HEADER_PAD_BOTTOM = 5; - private static final int HEADER_RULE_THICKNESS = 1; - private static final int ACTIVE_RULE_THICKNESS = 2; private static final int TITLE_GAP = 4; private static final int BODY_GAP = 6; - private static final ConstantColor DEFAULT_ACCENT = new ConstantColor(0xFF7C8795); + private static final int HEADER_RULE_THICKNESS = 1; private static final int HEADER_RULE_COLOR = 0x66586275; - private final List tabs = new ArrayList<>(); - private final List children = new ArrayList<>(); + private static final ConstantColor DEFAULT_ACCENT = new ConstantColor(0xFF7C8795); + + private final List titles = new ArrayList<>(); + private final List bodies = new ArrayList<>(); private final ColorValue accentColor; @Nullable private final LytParagraph titleParagraph; + private final LytContentTabsHeader headerBlock; private int selectedIndex; - private LytRect titleBounds = LytRect.empty(); - private LytRect headerBounds = LytRect.empty(); - private LytRect contentBounds = LytRect.empty(); - private static final ResolvedTextStyle SELECTED_STYLE = new ResolvedTextStyle( - 1.0f, - false, - false, - false, - false, - false, - false, - false, - "", - new ConstantColor(0xFFF4F7FB), - WhiteSpaceMode.NORMAL, - TextAlignment.LEFT, - false, - null, - false); - private static final ResolvedTextStyle IDLE_STYLE = new ResolvedTextStyle( - 1.0f, - false, - false, - false, - false, - false, - false, - false, - "", - new ConstantColor(0xFFD5DCE7), - WhiteSpaceMode.NORMAL, - TextAlignment.LEFT, - false, - null, - false); public LytContentTabsBlock(@Nullable String title, @Nullable LytFlowContent icon, int selectedIndex, @Nullable ColorValue accentColor, List entries) { @@ -89,13 +57,16 @@ public LytContentTabsBlock(@Nullable String title, @Nullable LytFlowContent icon this.titleParagraph = buildTitleParagraph(title, icon); if (titleParagraph != null) { titleParagraph.parent = this; - children.add(titleParagraph); + titleParagraph.setMarginBottom(TITLE_GAP); } for (ContentTabsSpec.TabEntry entry : entries) { - tabs.add(new TabState(entry.title(), entry.body())); - children.add(entry.body()); + titles.add(entry.title()); + bodies.add(entry.body()); entry.body().parent = this; } + headerBlock = new LytContentTabsHeader(titles, this.accentColor, this::getSafeSelectedIndex, this::selectTab); + headerBlock.parent = this; + headerBlock.setMarginBottom(BODY_GAP); setMarginTop(PageCompiler.DEFAULT_ELEMENT_SPACING); setMarginBottom(PageCompiler.DEFAULT_ELEMENT_SPACING); setFullWidth(true); @@ -104,147 +75,125 @@ public LytContentTabsBlock(@Nullable String title, @Nullable LytFlowContent icon @Override public List getChildren() { - // Expose every tab body to tree visitors so search, anchors, resource export, - // scene collection, and mount-time traversal still see hidden tabs. - return children; + // Live tree only: the layout engine and the render collector must not + // lay out or draw hidden tabs. + List out = new ArrayList<>(); + if (titleParagraph != null) { + out.add(titleParagraph); + } + out.add(headerBlock); + if (!bodies.isEmpty()) { + out.add(activeBody()); + } + return out; + } + + @Override + protected LytVisitor.Result visitChildren(LytVisitor visitor, boolean includeOutOfTreeContent) { + // Semantic traversals (search, anchors, resource export) keep seeing + // every tab body including hidden ones — pre-migration behavior. + for (LytNode child : getChildren()) { + if (child.visit(visitor, includeOutOfTreeContent) == LytVisitor.Result.STOP) { + return LytVisitor.Result.STOP; + } + } + for (LytBlock body : bodies) { + if (body != activeBody() && body.visit(visitor, includeOutOfTreeContent) == LytVisitor.Result.STOP) { + return LytVisitor.Result.STOP; + } + } + return LytVisitor.Result.CONTINUE; } @Override protected LytRect computeLayout(LayoutContext context, int x, int y, int availableWidth) { - if (tabs.isEmpty()) { - titleBounds = LytRect.empty(); - headerBounds = LytRect.empty(); - contentBounds = LytRect.empty(); + if (bodies.isEmpty()) { return new LytRect(x, y, 0, 0); } - - selectedIndex = Math.clamp(selectedIndex, 0, tabs.size() - 1); - int contentX = x + ACCENT_WIDTH + CONTAINER_PAD_X; int contentY = y + CONTAINER_PAD_Y; int contentWidth = Math.max(0, availableWidth - ACCENT_WIDTH - CONTAINER_PAD_X * 2); - int tabsY = contentY; - if (titleParagraph != null) { - titleBounds = titleParagraph.layout(context, contentX, contentY, contentWidth); - tabsY = titleBounds.bottom() + TITLE_GAP; - } else { - titleBounds = LytRect.empty(); - } - int cursorX = contentX; - int cursorY = tabsY; - int rowHeight = 0; - int headerBottom = tabsY; - for (TabState tab : tabs) { - int tabWidth = tab.measureWidth(context); - int tabHeight = tab.measureHeight(context); - if (cursorX > contentX && cursorX + tabWidth > contentX + contentWidth) { - cursorX = contentX; - cursorY += rowHeight + HEADER_GAP_Y; - rowHeight = 0; - } - tab.bounds = new LytRect(cursorX, cursorY, tabWidth, tabHeight); - cursorX += tabWidth + HEADER_GAP_X; - rowHeight = Math.max(rowHeight, tabHeight); - headerBottom = Math.max(headerBottom, tab.bounds.bottom()); + int cursorY = contentY; + int right = contentX; + if (titleParagraph != null) { + LytRect tb = titleParagraph.layout(context, contentX, cursorY, contentWidth); + cursorY = tb.bottom() + TITLE_GAP; + right = Math.max(right, tb.right()); } - - headerBounds = new LytRect(contentX, tabsY, contentWidth, Math.max(0, headerBottom - tabsY)); - int safeSelectedIndex = getSafeSelectedIndex(); - LytBlock activeBody = tabs.get(safeSelectedIndex).body; - LytRect bodyBounds = activeBody.layout(context, contentX, headerBounds.bottom() + BODY_GAP, contentWidth); - int contentRight = Math.max(Math.max(titleBounds.right(), headerBounds.right()), bodyBounds.right()); - int contentBottom = Math.max(headerBounds.bottom(), bodyBounds.bottom()); - contentBounds = new LytRect( - contentX, - contentY, - Math.max(0, contentRight - contentX), - Math.max(0, contentBottom - contentY)); + LytRect hb = headerBlock.layout(context, contentX, cursorY, contentWidth); + cursorY = hb.bottom() + BODY_GAP; + right = Math.max(right, hb.right()); + LytRect bb = activeBody().layout(context, contentX, cursorY, contentWidth); + right = Math.max(right, bb.right()); + + int contentW = right - contentX; + int contentH = bb.bottom() - contentY; return new LytRect( x, y, - Math.max(availableWidth, ACCENT_WIDTH + CONTAINER_PAD_X * 2 + contentBounds.width()), - contentBounds.height() + CONTAINER_PAD_Y * 2); + Math.max(availableWidth, ACCENT_WIDTH + CONTAINER_PAD_X * 2 + contentW), + contentH + CONTAINER_PAD_Y * 2); } @Override protected void onLayoutMoved(int deltaX, int deltaY) { - titleBounds = titleBounds.move(deltaX, deltaY); - headerBounds = headerBounds.move(deltaX, deltaY); - contentBounds = contentBounds.move(deltaX, deltaY); - if (titleParagraph != null) { - titleParagraph.moveLayoutPos(deltaX, deltaY); - } - for (TabState tab : tabs) { - tab.bounds = tab.bounds.move(deltaX, deltaY); - } - if (!tabs.isEmpty()) { - tabs.get(getSafeSelectedIndex()).body.moveLayoutPos(deltaX, deltaY); + for (LytNode child : getChildren()) { + if (child instanceof LytBlock b) { + b.moveLayoutPos(deltaX, deltaY); + } } } @Override - public void render(RenderContext context) { - if (tabs.isEmpty()) { - return; - } - int safeSelectedIndex = getSafeSelectedIndex(); - int accentArgb = context.resolveColor(accentColor); - context.fillRect(bounds, context.resolveColor(SymbolicColor.BLOCKQUOTE_BACKGROUND)); - context.fillRect(bounds.x(), bounds.y(), ACCENT_WIDTH, bounds.height(), accentArgb); - if (titleParagraph != null) { - titleParagraph.render(context); - } - float panelRuleY = headerBounds.bottom() + HEADER_RULE_THICKNESS * 0.5f; - context.drawLine( - headerBounds.x(), - panelRuleY, - headerBounds.right(), - panelRuleY, - HEADER_RULE_THICKNESS, - HEADER_RULE_COLOR); - for (int index = 0; index < tabs.size(); index++) { - TabState tab = tabs.get(index); - boolean selected = index == safeSelectedIndex; - context.drawText( - tab.title, - tab.bounds.x() + HEADER_PAD_X, - tab.bounds.y() + HEADER_PAD_TOP, - tab.style(selected)); - if (selected) { - float activeRuleY = tab.bounds.bottom() - ACTIVE_RULE_THICKNESS * 0.5f; - context.drawLine( - tab.bounds.x(), - activeRuleY, - tab.bounds.right(), - activeRuleY, - ACTIVE_RULE_THICKNESS, - accentArgb); - } + public boolean usePrimitives() { + return true; + } + + @Override + public void computePrimitives(PrimitiveCollector c) { + var bounds = getBounds(); + c.emit( + new GuideRenderPrimitive.FillRect( + bounds.x(), + bounds.y(), + bounds.width(), + bounds.height(), + SymbolicColor.BLOCKQUOTE_BACKGROUND.resolve(LightDarkMode.current()))); + c.emit( + new GuideRenderPrimitive.FillRect( + bounds.x(), + bounds.y(), + ACCENT_WIDTH, + bounds.height(), + accentColor.resolve(LightDarkMode.current()))); + // Panel rule between the header strip and the active body. + var hb = headerBlock.getBounds(); + if (hb != null && !hb.isEmpty()) { + float ruleY = hb.bottom() + HEADER_RULE_THICKNESS * 0.5f; + c.emit( + new GuideRenderPrimitive.DrawLine( + hb.x(), + ruleY, + hb.right(), + ruleY, + HEADER_RULE_THICKNESS, + HEADER_RULE_COLOR)); } - tabs.get(safeSelectedIndex).body.render(context); } + @Override + public void render(RenderContext context) {} + @Override public @Nullable LytNode pickNode(int x, int y) { if (!bounds.contains(x, y)) { return null; } - if (titleParagraph != null) { - LytNode titleNode = titleParagraph.pickNode(x, y); - if (titleNode != null) { - return titleNode; - } - } - for (TabState tab : tabs) { - if (tab.bounds.contains(x, y)) { - return this; - } - } - if (!tabs.isEmpty()) { - LytNode activeNode = tabs.get(getSafeSelectedIndex()).body.pickNode(x, y); - if (activeNode != null) { - return activeNode; + for (LytNode child : getChildren()) { + LytNode picked = child.pickNode(x, y); + if (picked != null) { + return picked; } } return this; @@ -252,34 +201,38 @@ public void render(RenderContext context) { @Override public boolean mouseClicked(GuideUiHost screen, int x, int y, int button, boolean doubleClick) { - if (tabs.isEmpty()) { - return false; - } - if (button == 0) { - for (int index = 0; index < tabs.size(); index++) { - if (tabs.get(index).bounds.contains(x, y)) { - if (selectedIndex != index) { - selectedIndex = index; - if (getDocument() != null) { - getDocument().invalidateLayout(); - } - } - return true; - } - } + if (headerBlock.mouseClicked(screen, x, y, button, doubleClick)) { + return true; } - LytBlock activeBody = tabs.get(getSafeSelectedIndex()).body; - return activeBody instanceof InteractiveElement interactive + LytBlock body = activeBody(); + return body instanceof InteractiveElement interactive && interactive.mouseClicked(screen, x, y, button, doubleClick); } @Override public Optional getTooltip(float x, float y) { - if (tabs.isEmpty()) { - return Optional.empty(); + LytBlock body = activeBody(); + return body instanceof InteractiveElement interactive ? interactive.getTooltip(x, y) : Optional.empty(); + } + + private void selectTab(int index) { + if (selectedIndex != index) { + selectedIndex = index; + if (getDocument() != null) { + getDocument().invalidateLayout(); + } + } + } + + private LytBlock activeBody() { + return bodies.get(getSafeSelectedIndex()); + } + + private int getSafeSelectedIndex() { + if (bodies.isEmpty()) { + return 0; } - LytBlock activeBody = tabs.get(getSafeSelectedIndex()).body; - return activeBody instanceof InteractiveElement interactive ? interactive.getTooltip(x, y) : Optional.empty(); + return Math.clamp(selectedIndex, 0, bodies.size() - 1); } @Nullable @@ -307,63 +260,24 @@ private LytParagraph buildTitleParagraph(@Nullable String title, @Nullable LytFl return paragraph; } - private int getSafeSelectedIndex() { - if (tabs.isEmpty()) { - return 0; - } - return Math.clamp(selectedIndex, 0, tabs.size() - 1); - } - - private static class TabState { - - private final String title; - private final LytBlock body; - private LytRect bounds = LytRect.empty(); - - private TabState(String title, LytBlock body) { - this.title = title; - this.body = body; - } - - private int measureWidth(LayoutContext context) { - return context.getStringWidth(title, style(false)) + HEADER_PAD_X * 2; - } - - private int measureHeight(LayoutContext context) { - return context.getLineHeight(style(false)) + HEADER_PAD_TOP + HEADER_PAD_BOTTOM; - } - - private ResolvedTextStyle style(boolean selected) { - return selected ? SELECTED_STYLE : IDLE_STYLE; - } - } - // Debug implementation @Override public List getDebugComponents() { List components = new ArrayList<>(); - - if (tabs.isEmpty() || headerBounds == null) { + var hb = headerBlock.getBounds(); + if (bodies.isEmpty() || hb == null) { return components; } - - // Each tab button - int tabWidth = headerBounds.width() / tabs.size(); - for (int i = 0; i < tabs.size(); i++) { - TabState tab = tabs.get(i); - int tabX = headerBounds.x() + (i * tabWidth); - LytRect tabBounds = new LytRect(tabX, headerBounds.y(), tabWidth, headerBounds.height()); - + var tabBounds = headerBlock.getTabBounds(); + for (int i = 0; i < tabBounds.size(); i++) { String extra = "Index: " + i; - if (i == selectedIndex) { + if (i == getSafeSelectedIndex()) { extra += ", Active"; } - - int priority = (i == selectedIndex) ? 20 : 15; - components.add(new SimpleComponentEntry("Tab:" + tab.title, tabBounds, extra, priority)); + int priority = (i == getSafeSelectedIndex()) ? 20 : 15; + components.add(new SimpleComponentEntry("Tab:" + titles.get(i), tabBounds.get(i), extra, priority)); } - return components; } } diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytContentTabsHeader.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytContentTabsHeader.java new file mode 100644 index 00000000..a93b07fa --- /dev/null +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytContentTabsHeader.java @@ -0,0 +1,236 @@ +package com.hfstudio.guidenh.guide.document.block; + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; +import java.util.function.IntConsumer; +import java.util.function.IntSupplier; + +import org.jetbrains.annotations.Nullable; + +import com.hfstudio.guidenh.guide.color.ColorValue; +import com.hfstudio.guidenh.guide.color.ConstantColor; +import com.hfstudio.guidenh.guide.color.LightDarkMode; +import com.hfstudio.guidenh.guide.document.LytRect; +import com.hfstudio.guidenh.guide.document.interaction.GuideTooltip; +import com.hfstudio.guidenh.guide.document.interaction.InteractiveElement; +import com.hfstudio.guidenh.guide.layout.LayoutContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.GuideText; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; +import com.hfstudio.guidenh.guide.render.RenderContext; +import com.hfstudio.guidenh.guide.style.ResolvedTextStyle; +import com.hfstudio.guidenh.guide.style.TextAlignment; +import com.hfstudio.guidenh.guide.style.WhiteSpaceMode; +import com.hfstudio.guidenh.guide.ui.GuideUiHost; + +/** + * The clickable tab strip of a {@link LytContentTabsBlock}: wraps tab titles + * into rows and draws them (selected/idle style + active underline). A real + * block, so the Rust layout treats the tabs block as three plain children + * (title, header, active body) with no spacers or pins. + *

+ * Measurement goes through {@link GuideText} (unified text pipeline), keeping + * measure and render on the same font. + */ +public class LytContentTabsHeader extends LytBlock implements InteractiveElement { + + private static final int HEADER_GAP_X = 10; + private static final int HEADER_GAP_Y = 5; + private static final int HEADER_PAD_X = 2; + private static final int HEADER_PAD_TOP = 1; + private static final int HEADER_PAD_BOTTOM = 5; + private static final int ACTIVE_RULE_THICKNESS = 2; + + private static final ResolvedTextStyle SELECTED_STYLE = new ResolvedTextStyle( + 1.0f, + false, + false, + false, + false, + false, + false, + false, + "", + new ConstantColor(0xFFF4F7FB), + WhiteSpaceMode.NORMAL, + TextAlignment.LEFT, + false, + null, + false, + 0.0f); + private static final ResolvedTextStyle IDLE_STYLE = new ResolvedTextStyle( + 1.0f, + false, + false, + false, + false, + false, + false, + false, + "", + new ConstantColor(0xFFD5DCE7), + WhiteSpaceMode.NORMAL, + TextAlignment.LEFT, + false, + null, + false, + 0.0f); + + private final List titles; + private final ColorValue accentColor; + private final IntSupplier selectedIndex; + private final IntConsumer onSelect; + private final List tabBounds = new ArrayList<>(); + + public LytContentTabsHeader(List titles, ColorValue accentColor, IntSupplier selectedIndex, + IntConsumer onSelect) { + this.titles = titles; + this.accentColor = accentColor; + this.selectedIndex = selectedIndex; + this.onSelect = onSelect; + } + + /** Tab hit rects in document coordinates (debug overlay / hit testing). */ + public List getTabBounds() { + return tabBounds; + } + + @Override + protected LytRect computeLayout(LayoutContext context, int x, int y, int availableWidth) { + tabBounds.clear(); + int cursorX = x; + int cursorY = y; + int rowHeight = 0; + int bottom = y; + for (String title : titles) { + int w = GuideText.measureWidth(title, IDLE_STYLE) + HEADER_PAD_X * 2; + int h = GuideText.lineHeight(IDLE_STYLE) + HEADER_PAD_TOP + HEADER_PAD_BOTTOM; + if (cursorX > x && cursorX + w > x + availableWidth) { + cursorX = x; + cursorY += rowHeight + HEADER_GAP_Y; + rowHeight = 0; + } + tabBounds.add(new LytRect(cursorX, cursorY, w, h)); + cursorX += w + HEADER_GAP_X; + rowHeight = Math.max(rowHeight, h); + bottom = Math.max(bottom, cursorY + h); + } + return new LytRect(x, y, availableWidth, bottom - y); + } + + @Override + protected void afterExternalLayout() { + // Recompute tab hit rects from the Rust-computed bounds. The Java + // layout pre-pass no longer calls computeLayout, so tabBounds must + // be rebuilt here to stay valid for hit testing and rendering. + recomputeTabBounds(); + } + + private void recomputeTabBounds() { + tabBounds.clear(); + int x = bounds.x(); + int y = bounds.y(); + int availableWidth = Math.max(1, bounds.width()); + int cursorX = x; + int cursorY = y; + int rowHeight = 0; + int bottom = y; + for (String title : titles) { + int w = GuideText.measureWidth(title, IDLE_STYLE) + HEADER_PAD_X * 2; + int h = GuideText.lineHeight(IDLE_STYLE) + HEADER_PAD_TOP + HEADER_PAD_BOTTOM; + if (cursorX > x && cursorX + w > x + availableWidth) { + cursorX = x; + cursorY += rowHeight + HEADER_GAP_Y; + rowHeight = 0; + } + tabBounds.add(new LytRect(cursorX, cursorY, w, h)); + cursorX += w + HEADER_GAP_X; + rowHeight = Math.max(rowHeight, h); + bottom = Math.max(bottom, cursorY + h); + } + } + + @Override + protected void onLayoutMoved(int deltaX, int deltaY) { + for (int i = 0; i < tabBounds.size(); i++) { + tabBounds.set( + i, + tabBounds.get(i) + .move(deltaX, deltaY)); + } + } + + @Override + public int getExplicitHeight() { + if (titles.isEmpty()) { + return 0; + } + return GuideText.lineHeight(IDLE_STYLE) + HEADER_PAD_TOP + HEADER_PAD_BOTTOM; + } + + @Override + public boolean usePrimitives() { + return true; + } + + @Override + public void computePrimitives(PrimitiveCollector c) { + int sel = Math.clamp(selectedIndex.getAsInt(), 0, Math.max(0, titles.size() - 1)); + int accentArgb = accentColor.resolve(LightDarkMode.current()); + for (int i = 0; i < tabBounds.size(); i++) { + LytRect tb = tabBounds.get(i); + boolean selected = i == sel; + GuideText.emitText( + c, + titles.get(i), + tb.x() + HEADER_PAD_X, + tb.y() + HEADER_PAD_TOP, + selected ? SELECTED_STYLE : IDLE_STYLE); + if (selected) { + c.emit( + new GuideRenderPrimitive.FillRect( + tb.x(), + tb.bottom() - ACTIVE_RULE_THICKNESS, + tb.width(), + ACTIVE_RULE_THICKNESS, + accentArgb)); + } + } + } + + @Override + public void render(RenderContext context) {} + + @Override + public @Nullable LytNode pickNode(int x, int y) { + for (LytRect tb : tabBounds) { + if (tb.contains(x, y)) { + return this; + } + } + return null; + } + + @Override + public boolean mouseClicked(GuideUiHost screen, int x, int y, int button, boolean doubleClick) { + if (button != 0) { + return false; + } + for (int i = 0; i < tabBounds.size(); i++) { + if (tabBounds.get(i) + .contains(x, y)) { + if (i != selectedIndex.getAsInt()) { + onSelect.accept(i); + } + return true; + } + } + return false; + } + + @Override + public Optional getTooltip(float x, float y) { + return Optional.empty(); + } +} diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytCyclingItemImage.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytCyclingItemImage.java index bfe7552b..334b157f 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytCyclingItemImage.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytCyclingItemImage.java @@ -29,6 +29,14 @@ private ItemStack currentStack() { return stacks.get(cachedIdx); } + @Override + public void computePrimitives(com.hfstudio.guidenh.guide.render.PrimitiveCollector c) { + // Swap in the currently displayed stack before collecting (per-second + // cycling, evaluated fresh each frame). + this.stack = currentStack(); + super.computePrimitives(c); + } + @Override public void render(RenderContext context) { this.stack = currentStack(); diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytDetailsBlock.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytDetailsBlock.java index 2d81bd6d..af77d721 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytDetailsBlock.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytDetailsBlock.java @@ -12,6 +12,8 @@ import com.hfstudio.guidenh.guide.internal.editor.gui.SceneEditorVerticalScrollbar; import com.hfstudio.guidenh.guide.internal.util.SmoothFloatState; import com.hfstudio.guidenh.guide.layout.LayoutContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.render.RenderContext; import com.hfstudio.guidenh.guide.style.BorderStyle; import com.hfstudio.guidenh.guide.ui.GuideUiHost; @@ -27,6 +29,21 @@ public class LytDetailsBlock extends LytBlock implements InteractiveElement, Lyt private static final int PADDING = 6; private static final int GAP = 4; private static final int BORDER_WIDTH = 1; + /** + * Top margin on the summary-marker paragraph (in px) that optically centers + * the ">"/"v" marker glyphs against the summary text. The marker glyphs are + * mid-em symbols whose ink sits higher inside their 1.55x line-height box + * than the text's visual (x-height) centerline; the row's alignItems CENTER + * aligns whole line-height boxes, so the marker needs its own box nudged + * down. Taffy's CENTER aligns the margin box, which shifts the marker's + * content box down by half this margin (same declaration pattern as the + * search-result icon rows, GuideSearchResultDocumentBuilder + * RESULT_ICON_MARGIN_TOP). A 1px margin = 0.5px downward shift; measured + * against the actual guide font (Microsoft YaHei) ">" sits ~0.55px high and + * "v" ~0px off the x-height middle, so half a pixel puts ">" on the + * centerline with only a negligible nudge to "v". + */ + private static final int SUMMARY_MARKER_ALIGN_MARGIN_TOP = 1; private static final int SCROLLBAR_WIDTH = 5; private static final int SCROLLBAR_GAP = 4; private static final int MIN_SCROLLBAR_THUMB = 14; @@ -36,7 +53,8 @@ public class LytDetailsBlock extends LytBlock implements InteractiveElement, Lyt private final LytHBox summaryRow = new LytHBox(); private final LytParagraph summaryMarker = new LytParagraph(); private final LytParagraph summaryContent = new LytParagraph(); - private final LytVBox content = new LytVBox(); + /** Scrollable content viewport; clips its children to its own bounds. */ + private final LytViewportBox content = new LytViewportBox(); private final BorderRenderer borderRenderer = new BorderRenderer(); private final SmoothFloatState visualContentScrollOffsetY = new SmoothFloatState(); @@ -48,12 +66,9 @@ public class LytDetailsBlock extends LytBlock implements InteractiveElement, Lyt private int preferredWidth; @Getter private int preferredContentHeight; - private int contentHeight; - private int contentViewportX; - private int contentViewportY; - private int contentViewportWidth; - private int contentViewportHeight; private int contentScrollOffsetY; + /** Visual-scroll delta currently baked into the content bounds (see computePrimitives). */ + private int visualDeltaY; private boolean draggingContent; private int dragLastDocumentY; private boolean draggingScrollbar; @@ -66,7 +81,7 @@ public LytDetailsBlock() { summaryRow.setFullWidth(true); summaryRow.setAlignItems(AlignItems.CENTER); - summaryMarker.setMarginTop(0); + summaryMarker.setMarginTop(SUMMARY_MARKER_ALIGN_MARGIN_TOP); summaryMarker.setMarginBottom(0); summaryMarker.modifyStyle( style -> style.bold(true) @@ -80,7 +95,21 @@ public LytDetailsBlock() { content.parent = this; content.setGap(4); - content.setFullWidth(true); + // No setFullWidth(true) on purpose: fullWidth serializes as an explicit + // align-self Stretch, which under Taffy 0.12 resolves against the viewport + // width WITHOUT subtracting the declared margins — the viewport would + // overflow the details body by 2*(PADDING+BORDER_WIDTH) on each side. + // Leaving the cross size auto makes align-self Auto, so it inherits this + // block's default alignItems Stretch (LayoutStyleExtractor returns Stretch + // for every non-LytAxisBox container), and the stretch computes the width + // as details body width minus the margins below. + // Inset the content viewport inside the details body by the padding + + // border (7px/side): Rust positions the viewport at details.x+7. Declared + // as margins (LytDetailsBlock is a plain LytBlock — it has no box + // padding/border to serialize; LayoutStyleExtractor carries block + // margins to the FlatBuffer style verbatim). + content.setMarginLeft(PADDING + BORDER_WIDTH); + content.setMarginRight(PADDING + BORDER_WIDTH); summaryRow.append(summaryMarker); summaryRow.append(summaryContent); @@ -172,31 +201,30 @@ protected LytRect computeLayout(LayoutContext context, int x, int y, int availab LytRect summaryBounds = summaryRow.layout(context, innerX, innerY, innerWidth); int totalHeight = PADDING + BORDER_WIDTH + summaryBounds.height() + PADDING + BORDER_WIDTH; - contentHeight = 0; - contentViewportX = innerX; - contentViewportY = summaryBounds.bottom() + GAP; - contentViewportWidth = innerWidth; - contentViewportHeight = 0; - if (open) { - LytRect measuredContent = content.layout(context, contentViewportX, contentViewportY, contentViewportWidth); - contentHeight = measuredContent.height(); - contentViewportHeight = preferredContentHeight > 0 ? preferredContentHeight : contentHeight; - if (preferredContentHeight > 0 && contentHeight > contentViewportHeight) { - contentViewportWidth = Math.max(1, innerWidth - SCROLLBAR_WIDTH - SCROLLBAR_GAP); - measuredContent = content.layout(context, contentViewportX, contentViewportY, contentViewportWidth); - contentHeight = measuredContent.height(); + int contentX = innerX; + int contentY = summaryBounds.bottom() + GAP; + int contentWidth = innerWidth; + LytRect measuredContent = content.layout(context, contentX, contentY, contentWidth); + int naturalHeight = measuredContent.height(); + int viewportHeight = preferredContentHeight > 0 ? preferredContentHeight : naturalHeight; + if (preferredContentHeight > 0 && naturalHeight > viewportHeight) { + contentWidth = Math.max(1, innerWidth - SCROLLBAR_WIDTH - SCROLLBAR_GAP); + measuredContent = content.layout(context, contentX, contentY, contentWidth); + naturalHeight = measuredContent.height(); + viewportHeight = preferredContentHeight; } - contentViewportHeight = preferredContentHeight > 0 ? preferredContentHeight : contentHeight; + content.setExplicitHeight(viewportHeight); setContentScrollOffset(contentScrollOffsetY); snapVisualScrollToTarget(); totalHeight = PADDING + BORDER_WIDTH + summaryBounds.height() + GAP - + contentViewportHeight + + viewportHeight + PADDING + BORDER_WIDTH; } else { + content.setExplicitHeight(-1); setContentScrollOffset(0); snapVisualScrollToTarget(); } @@ -204,32 +232,124 @@ protected LytRect computeLayout(LayoutContext context, int x, int y, int availab return new LytRect(x, y, safeWidth, totalHeight); } + // ---- derived geometry (computed from current bounds; no layout-time fields) ---- + + /** The content viewport rect is simply the viewport box's own bounds. */ + private LytRect getContentViewportBounds() { + return content.getBounds(); + } + + /** + * Natural (unscrolled) content height, derived from the children's current + * bounds. The scroll offset cancels out: children and the content box move + * together. + */ + private int getContentNaturalHeight() { + int bottom = Integer.MIN_VALUE; + for (LytNode child : content.getChildren()) { + if (child instanceof LytBlock childBlock) { + bottom = Math.max( + bottom, + childBlock.getBounds() + .bottom()); + } + } + return bottom == Integer.MIN_VALUE ? 0 + : Math.max( + 0, + bottom - content.getBounds() + .y()); + } + + private int getContentViewportHeight() { + return preferredContentHeight > 0 ? preferredContentHeight : getContentNaturalHeight(); + } + + private int getMaxContentScroll() { + return Math.max(0, getContentNaturalHeight() - getContentViewportHeight()); + } + @Override protected void onLayoutMoved(int deltaX, int deltaY) { summaryRow.moveLayoutPos(deltaX, deltaY); content.moveLayoutPos(deltaX, deltaY); - contentViewportX += deltaX; - contentViewportY += deltaY; } @Override - public void render(RenderContext context) { + public boolean usePrimitives() { + return true; + } + + @Override + public void computePrimitives(PrimitiveCollector c) { + c.emit( + new GuideRenderPrimitive.FillRect( + bounds.x(), + bounds.y(), + bounds.width(), + bounds.height(), + SymbolicColor.BLOCKQUOTE_BACKGROUND.resolve(com.hfstudio.guidenh.guide.color.LightDarkMode.current()))); + + // Advance the smooth scroll and bake the visual delta into the content + // bounds (collector traverses the content right after this). updateVisualScroll(); - context.fillRect(bounds, SymbolicColor.BLOCKQUOTE_BACKGROUND); - summaryRow.render(context); - if (open) { - LytRect viewport = getContentViewportBounds(); - context.pushLocalScissor(viewport); - try { - renderContentWithVisualOffset(context); - } finally { - context.popScissor(); + int newDelta = contentScrollOffsetY - visualContentScrollOffsetY.rounded(); + if (open && newDelta != visualDeltaY + && !content.getBounds() + .isEmpty()) { + content.moveLayoutPos(0, newDelta - visualDeltaY); + visualDeltaY = newDelta; + } + + LytRect trackBounds = getScrollbarTrackBounds(); + if (open && !trackBounds.isEmpty()) { + c.emit( + new GuideRenderPrimitive.FillRect( + trackBounds.x(), + trackBounds.y(), + trackBounds.width(), + trackBounds.height(), + 0x30242B33)); + LytRect thumbBounds = getScrollbarThumbBounds(); + if (!thumbBounds.isEmpty()) { + c.emit( + new GuideRenderPrimitive.FillRect( + thumbBounds.x(), + thumbBounds.y(), + thumbBounds.width(), + thumbBounds.height(), + draggingScrollbar ? 0xFFCDD6E1 : 0xA0AAB5C2)); } - renderScrollbar(context); } - borderRenderer.render(context, bounds, DETAILS_BORDER, DETAILS_BORDER, DETAILS_BORDER, DETAILS_BORDER); } + @Override + public void emitDecorations(PrimitiveCollector c) { + c.emit( + new GuideRenderPrimitive.DrawBorder( + bounds.x(), + bounds.y(), + bounds.width(), + bounds.height(), + BORDER_WIDTH, + BORDER_WIDTH, + BORDER_WIDTH, + BORDER_WIDTH, + DETAILS_BORDER.color() != null ? DETAILS_BORDER.color() + .resolve(com.hfstudio.guidenh.guide.color.LightDarkMode.current()) : 0xFF000000)); + } + + @Override + protected void afterExternalLayout() { + // The writeback reset the content to the unscrolled position; re-apply + // the current scroll offset and restart the visual-delta bookkeeping. + updateContentPosition(); + visualDeltaY = 0; + } + + @Override + public void render(RenderContext context) {} + @Override public boolean mouseClicked(GuideUiHost screen, int x, int y, int button, boolean doubleClick) { if (button != 0) { @@ -333,19 +453,12 @@ private void renderScrollbar(RenderContext context) { } } - private LytRect getContentViewportBounds() { - return new LytRect(contentViewportX, contentViewportY, contentViewportWidth, contentViewportHeight); - } - private LytRect getScrollbarTrackBounds() { if (getMaxContentScroll() <= 0) { return LytRect.empty(); } - return new LytRect( - contentViewportX + contentViewportWidth + SCROLLBAR_GAP, - contentViewportY, - SCROLLBAR_WIDTH, - contentViewportHeight); + LytRect viewport = getContentViewportBounds(); + return new LytRect(viewport.right() + SCROLLBAR_GAP, viewport.y(), SCROLLBAR_WIDTH, viewport.height()); } private LytRect getScrollbarThumbBounds() { @@ -353,8 +466,9 @@ private LytRect getScrollbarThumbBounds() { if (track.isEmpty()) { return LytRect.empty(); } - int thumbHeight = Math - .max(MIN_SCROLLBAR_THUMB, track.height() * track.height() / Math.max(track.height(), contentHeight)); + int thumbHeight = Math.max( + MIN_SCROLLBAR_THUMB, + track.height() * track.height() / Math.max(track.height(), getContentNaturalHeight())); thumbHeight = Math.min(thumbHeight, track.height()); int maxScroll = getMaxContentScroll(); int thumbTrack = Math.max(1, track.height() - thumbHeight); @@ -365,10 +479,6 @@ private LytRect getScrollbarThumbBounds() { return new LytRect(track.x(), thumbY, track.width(), thumbHeight); } - private int getMaxContentScroll() { - return Math.max(0, contentHeight - contentViewportHeight); - } - private void setContentScrollOffset(int contentScrollOffsetY) { this.contentScrollOffsetY = SceneEditorVerticalScrollbar.clamp(contentScrollOffsetY, 0, getMaxContentScroll()); updateContentPosition(); @@ -376,30 +486,21 @@ private void setContentScrollOffset(int contentScrollOffsetY) { private void updateContentPosition() { if (!content.getBounds() - .isEmpty()) { + .isEmpty() + && !summaryRow.getBounds() + .isEmpty()) { + int naturalX = bounds.x() + PADDING + BORDER_WIDTH; + int naturalY = summaryRow.getBounds() + .bottom() + GAP; content.moveLayoutPos( - contentViewportX - content.getBounds() + naturalX - content.getBounds() .x(), - contentViewportY - contentScrollOffsetY + naturalY - contentScrollOffsetY - content.getBounds() .y()); } } - private void renderContentWithVisualOffset(RenderContext context) { - int renderDeltaY = contentScrollOffsetY - visualContentScrollOffsetY.rounded(); - if (renderDeltaY == 0) { - content.render(context); - return; - } - content.moveLayoutPos(0, renderDeltaY); - try { - content.render(context); - } finally { - content.moveLayoutPos(0, -renderDeltaY); - } - } - private void updateScrollFromMouseY(int mouseY) { LytRect track = getScrollbarTrackBounds(); LytRect thumb = getScrollbarThumbBounds(); @@ -420,6 +521,6 @@ private void snapVisualScrollToTarget() { private void updateVisualScroll() { visualContentScrollOffsetY - .updateTowards(contentScrollOffsetY, 28f, 0.25f, 0.01f, Math.max(128f, contentViewportHeight * 2f)); + .updateTowards(contentScrollOffsetY, 28f, 0.25f, 0.01f, Math.max(128f, getContentViewportHeight() * 2f)); } } diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytDocument.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytDocument.java index 49f316c0..513b6059 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytDocument.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytDocument.java @@ -1,21 +1,38 @@ package com.hfstudio.guidenh.guide.document.block; +import java.nio.ByteBuffer; import java.util.ArrayList; +import java.util.HashMap; import java.util.List; +import java.util.Map; import java.util.Objects; import org.jetbrains.annotations.Nullable; +import org.lwjgl.opengl.GL11; import com.github.bsideup.jabel.Desugar; import com.hfstudio.guidenh.guide.document.LytRect; +import com.hfstudio.guidenh.guide.document.block.recipes.LytRecipeGalleryRow; import com.hfstudio.guidenh.guide.document.flow.LytFlowContainer; import com.hfstudio.guidenh.guide.document.flow.LytFlowContent; import com.hfstudio.guidenh.guide.document.flow.LytFlowInlineBlock; import com.hfstudio.guidenh.guide.document.interaction.DocumentInteractionSnapshot; import com.hfstudio.guidenh.guide.document.interaction.FlowInteractionPath; +import com.hfstudio.guidenh.guide.internal.util.DisplayScale; +import com.hfstudio.guidenh.guide.layout.LayoutBridge; import com.hfstudio.guidenh.guide.layout.LayoutContext; -import com.hfstudio.guidenh.guide.layout.Layouts; +import com.hfstudio.guidenh.guide.layout.LayoutTreeSerializer; +import com.hfstudio.guidenh.guide.layout.flatbuffers.LayoutResult; +import com.hfstudio.guidenh.guide.render.GlyphRunData; +import com.hfstudio.guidenh.guide.render.GlyphRunGroup; +import com.hfstudio.guidenh.guide.render.GlyphRunHolder; +import com.hfstudio.guidenh.guide.render.GuideGlyphAtlas; +import com.hfstudio.guidenh.guide.render.GuideRenderEngine; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.GuidebookSceneRenderer; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.render.RenderContext; +import com.hfstudio.guidenh.guide.scene.support.GuideDebugLog; import lombok.Getter; @@ -27,12 +44,31 @@ public class LytDocument extends LytNode implements LytBlockContainer { private static final FlowInteractionPath EMPTY_FLOW_PATH = FlowInteractionPath.empty(); + private static volatile GuideRenderEngine renderEngine; + + public static GuideRenderEngine getRenderEngine() { + GuideRenderEngine e = renderEngine; + if (e == null) { + synchronized (LytDocument.class) { + e = renderEngine; + if (e == null) { + renderEngine = e = new GuideRenderEngine(GuideGlyphAtlas.instance(), new GuidebookSceneRenderer()); + } + } + } + return e; + } + @Getter private final List blocks = new ArrayList<>(); @Nullable private Layout layout; + /** Cache key state for {@link #updateLayout}: font handle + render scale. */ + private long layoutFontHandle = -1; + private int layoutRenderScale = -1; + @Nullable private DocumentInteractionSnapshot hoveredElement; @@ -47,6 +83,20 @@ public class LytDocument extends LytNode implements LytBlockContainer { private int cachedViewportBottom = Integer.MIN_VALUE; private boolean visibleCacheValid; + /** + * Diagnostic overlay (JVM flag {@code -Dguidenh.layoutOverlay=true} or the + * in-game debug menu option): draws Java bounds (green), Rust FlatLayout + * rects (red), glyph quads (blue) and the viewport scissor (yellow) on top + * of the document. Resolved per call so the in-game toggle takes effect + * immediately. + */ + private static boolean isOverlayEnabled() { + return GuideDebugLog.isLayoutOverlayEnabled(); + } + + private final List overlayRustBlocks = new ArrayList<>(); + private final List overlayRustRects = new ArrayList<>(); + public int getAvailableWidth() { return layout != null ? layout.availableWidth() : 0; } @@ -151,30 +201,277 @@ private void invalidateVisibleCache() { } public void updateLayout(LayoutContext context, int availableWidth) { - if (layout != null && layout.availableWidth == availableWidth) { + // Cache key must include the font handle (a 0→non-zero transition must + // not leave the document stuck on the Java fallback) and the display + // pixel ratio (glyph bitmaps are rasterized per render scale) — B-3. + long fontHandle = com.hfstudio.guidenh.guide.layout.LayoutBridge.getFontHandle(); + int renderScale = com.hfstudio.guidenh.guide.internal.util.DisplayScale.scaleFactor(); + if (layout != null && layout.availableWidth == availableWidth + && layoutFontHandle == fontHandle + && layoutRenderScale == renderScale) { return; } + layoutFontHandle = fontHandle; + layoutRenderScale = renderScale; + groupRecipeGalleries(); layout = createLayout(context, availableWidth); } + /** + * Group runs of ≥ 2 consecutive recipe boxes at the document top level + * into wrapping {@link LytRecipeGalleryRow}s, so recipes fill the available + * width instead of stacking one per row. Idempotent: an already-grouped + * document is left untouched (no mutation, no extra invalidation). Runs + * before every layout so asynchronously inserted recipe boxes (placeholders + * resolving late) join an adjacent gallery. + */ + private void groupRecipeGalleries() { + // Pass 1: existing gallery rows absorb immediately following single + // recipe boxes (manual index — the list shrinks on each absorb). + for (int i = 0; i + 1 < blocks.size();) { + if (blocks.get(i) instanceof LytRecipeGalleryRow row + && LytRecipeGalleryRow.isRecipeBox(blocks.get(i + 1))) { + row.append(blocks.get(i + 1)); // re-parents the box off the document + invalidateLayout(); + } else { + i++; + } + } + // Pass 2: wrap remaining runs of >= 2 consecutive recipe boxes. + for (int i = 0; i < blocks.size(); i++) { + if (!LytRecipeGalleryRow.isRecipeBox(blocks.get(i))) continue; + int j = i + 1; + while (j < blocks.size() && LytRecipeGalleryRow.isRecipeBox(blocks.get(j))) j++; + if (j - i >= 2) { + List run = new ArrayList<>(blocks.subList(i, j)); + var row = new LytRecipeGalleryRow(); + for (LytBlock box : run) { + row.append(box); // re-parents each box off the document + } + row.parent = this; + blocks.add(i, row); + invalidateLayout(); + } + i = j; // continue after the run — a single box does NOT stop the scan + } + } + private Layout createLayout(LayoutContext context, int availableWidth) { - var bounds = Layouts.verticalLayout(context, blocks, 0, 0, availableWidth, 5, 5, 5, 5, 0, AlignItems.START); - int contentHeight = bounds.height(); - // Document-level floats (LytDocumentFloat) report zero height so they do not advance the - // vertical cursor in verticalLayout. If a float is taller than the text that wraps beside - // it, the float visually extends below the last paragraph but the computed contentHeight - // does not reflect this, causing the scroll area to be truncated. - // After the full layout pass, any remaining active floats represent exactly this case. - // Retrieve their maximum bottom edge and extend contentHeight to cover them. - var floatBottom = context.clearFloats(true, true); - if (floatBottom.isPresent() && floatBottom.getAsInt() > contentHeight) { - contentHeight = floatBottom.getAsInt() + 5; + // The Java layout pre-pass is gone from the main document pipeline: the + // tree is serialized without a pre-layout step and Rust is the sole + // authority for document geometry. The Java pre-pass (Layouts.java) is + // still live for the non-document chains — tooltip / annotation / editor + // / page-title / inline-block (Mermaid fallback) — which bypass the + // collector and lay out via LayoutContext directly. + + // --- Rust layout pipeline (sole authority for geometry) --- + int contentHeight = 0; + long fontHandle = LayoutBridge.getFontHandle(); + // Clear glyph runs up front, across the WHOLE tree (not just the + // serialized nodes): on any Rust failure/empty result, no stale + // run may survive to be drawn at outdated coordinates (B-2/B-11). + for (LytBlock top : blocks) { + clearGlyphRuns(top); + } + try { + var serializer = new LayoutTreeSerializer(); + byte[] input = serializer + .serialize(this, availableWidth, context.getVisualScale(), DisplayScale.scaleFactor()); + long t0 = System.nanoTime(); + byte[] result = LayoutBridge.measureLayout(fontHandle, input); + long elapsed = System.nanoTime() - t0; + GuideDebugLog.warnAlways("Layout: measureLayout took {} ms", elapsed / 1_000_000); + if (result.length > 0) { + var flatResult = LayoutResult.getRootAsLayoutResult(ByteBuffer.wrap(result)); + String debugInfo = flatResult.debugInfo(); + if (debugInfo != null && !debugInfo.isEmpty()) { + GuideDebugLog.warnAlways("Layout: Rust debug_info = {}", debugInfo); + } + contentHeight = (int) flatResult.contentHeight(); + // Layout landing: overwrite every serialized block's bounds with + // the Rust-computed rect so blocks, glyph runs and floats share + // one coordinate truth. The FlatLayout vector is index-aligned + // with the serializer's flat nodes. + overlayRustBlocks.clear(); + overlayRustRects.clear(); + int numLayouts = flatResult.nodesLength(); + for (int i = 0; i < numLayouts; i++) { + var fl = flatResult.nodes(i); + if (fl == null) continue; + LytNode node = serializer.getNodeByFlatIndex(i); + if (!(node instanceof LytBlock lb)) continue; + LytRect rustRect = new LytRect( + Math.round(fl.x()), + Math.round(fl.y()), + Math.max(0, Math.round(fl.w())), + Math.max(0, Math.round(fl.h()))); + lb.applyExternalLayout(rustRect); + if (isOverlayEnabled()) { + overlayRustBlocks.add(lb); + overlayRustRects.add(rustRect); + } + } + // Upload unique glyph bitmaps (hi-res, rasterized by Rust at + // render_scale) to the atlas. Placement is already baked into + // the per-glyph quads below. + var atlas = GuideGlyphAtlas.instance(); + int numBitmaps = flatResult.bitmapsLength(); + for (int bi = 0; bi < numBitmaps; bi++) { + var bmp = flatResult.bitmaps(bi); + if (bmp == null) continue; + int w = (int) bmp.w(); + int h = (int) bmp.h(); + if (w <= 0 || h <= 0) continue; + ByteBuffer rgbaBuf = bmp.rgbaAsByteBuffer(); + byte[] rgba = new byte[rgbaBuf.remaining()]; + rgbaBuf.get(rgba); + atlas.upload(bmp.key(), rgba, w, h); + } + // Extract glyph runs (final document-space quads, top-left + // origin) and group them per paragraph node — a rich + // paragraph yields one run per span — then inject together + // with the span decoration rects. + Map> runsByNode = new HashMap<>(); + int numRuns = flatResult.glyphRunsLength(); + for (int ri = 0; ri < numRuns; ri++) { + var fbRun = flatResult.glyphRuns(ri); + if (fbRun == null) continue; + int numGlyphs = fbRun.glyphsLength(); + var placed = new ArrayList(numGlyphs); + for (int gi = 0; gi < numGlyphs; gi++) { + var fbg = fbRun.glyphs(gi); + if (fbg != null) { + placed.add( + new GuideRenderPrimitive.PlacedGlyph( + fbg.bitmapKey(), + fbg.x(), + fbg.y(), + fbg.w(), + fbg.h(), + (int) fbg.lineIndex())); + } + } + runsByNode.computeIfAbsent((int) fbRun.nodeIndex(), k -> new ArrayList<>()) + .add(new GlyphRunGroup(placed, (int) fbRun.argb(), fbRun.shear())); + } + Map> backgroundsByNode = new HashMap<>(); + Map> linesByNode = new HashMap<>(); + Map> separatorsByNode = new HashMap<>(); + Map> decorationsByNode = new HashMap<>(); + int numDecorations = flatResult.decorationsLength(); + for (int di = 0; di < numDecorations; di++) { + var d = flatResult.decorations(di); + if (d == null) continue; + var rect = new GuideRenderPrimitive.FillRect( + Math.round(d.x()), + Math.round(d.y()), + Math.round(d.w()), + Math.round(d.h()), + (int) d.argb()); + if (d.kind() == 3) { + separatorsByNode + .computeIfAbsent((int) d.node(), k -> new ArrayList<>()) + .add(rect); + } else if (d.kind() == 0) { + backgroundsByNode + .computeIfAbsent((int) d.node(), k -> new ArrayList<>()) + .add(rect); + } else if (d.kind() == 4 || d.kind() == 5) { + // Wavy (4) / dotted (5) decorations keep their kind so + // the render engine can pick the sine / dot brush — they + // must NOT fall into the plain-line (lines) bucket. + decorationsByNode + .computeIfAbsent((int) d.node(), k -> new ArrayList<>()) + .add( + new GuideRenderPrimitive.DrawDecorationLine( + d.x(), + d.y(), + d.w(), + d.h(), + (int) d.argb(), + d.kind())); + } else { + linesByNode + .computeIfAbsent((int) d.node(), k -> new ArrayList<>()) + .add(rect); + } + } + for (var entry : runsByNode.entrySet()) { + LytNode node = serializer.getNodeByFlatIndex(entry.getKey()); + if (node instanceof GlyphRunHolder holder) { + holder.setGlyphData( + new GlyphRunData( + entry.getValue(), + backgroundsByNode.getOrDefault(entry.getKey(), List.of()), + linesByNode.getOrDefault(entry.getKey(), List.of()), + separatorsByNode.getOrDefault(entry.getKey(), List.of()), + decorationsByNode.getOrDefault(entry.getKey(), List.of()))); + GuideDebugLog.warnAlways( + "Layout: set {} glyph groups on paragraph at flat index {}", + entry.getValue() + .size(), + entry.getKey()); + } + } + // Post pass: let blocks re-apply state that depends on their + // children's final bounds (e.g. scroll offsets) BEFORE the + // cull-bounds union is recomputed from the moved subtrees. + // Runs AFTER glyph-data injection so onLayoutMoved() shifts + // existing glyph quads together with the block position. + for (int i = 0; i < numLayouts; i++) { + LytNode node = serializer.getNodeByFlatIndex(i); + if (node instanceof LytBlock lb) { + lb.afterExternalLayout(); + } + } + } + } catch (Exception e) { + GuideDebugLog.warnAlways("Layout: Rust pipeline failed", e); } + // Culling bounds: subtree union, recomputed on EVERY layout (success or + // fallback — stale unions cull content that moved into view, B-2). A + // floated child (or any overflowing content) must keep its ancestors + // visible — Taffy does not extend containers for floats. + for (LytBlock top : blocks) { + computeCullBounds(top); + } + // ----------------------------------------- + var cachedBounds = new LytRect(0, 0, availableWidth, contentHeight); return new Layout(availableWidth, contentHeight, cachedBounds); } + /** + * Recursively clear glyph runs in the subtree (pre-layout wipe so no stale + * run survives a failed layout pass). + */ + private static void clearGlyphRuns(LytBlock block) { + if (block instanceof GlyphRunHolder holder) { + holder.setGlyphData(null); + } + for (LytNode child : block.getChildren()) { + if (child instanceof LytBlock childBlock) { + clearGlyphRuns(childBlock); + } + } + } + + /** + * Recompute the subtree-union cull bounds for {@code block} (post-order: + * children first). Returns the union rect, also stored on the block. + */ + private static LytRect computeCullBounds(LytBlock block) { + LytRect union = block.getBounds() != null ? block.getBounds() : LytRect.empty(); + for (LytNode child : block.getChildren()) { + if (child instanceof LytBlock childBlock) { + union = LytRect.union(union, computeCullBounds(childBlock)); + } + } + block.setCullBounds(union); + return union; + } + public void render(RenderContext context) { var viewport = context.viewport(); var top = viewport.y(); @@ -190,13 +487,121 @@ public void render(RenderContext context) { cachedViewportBottom = bottom; visibleCacheValid = true; } - // Render from the cached visible list. Each block's render is a stable function of its - // own state; viewport-dependent culling has already been factored out above. - for (LytBlock lytBlock : visibleCache) { - lytBlock.render(context); + // Primitive pipeline. The render engine owns the document->screen + // conversion: root transform maps screen = doc * zoom + (tx, ty), + // matching VanillaRenderContext.toScreenRect. The screen viewport scissor + // is fixed on screen regardless of scroll/zoom, so it is emitted in + // screen coordinates (PushScreenScissor) before the root transform. + float zoom = context.getZoom(); + float scrollY = context.getPreciseScrollOffsetY(); + int originX = context.getDocumentOriginX(); + int originY = context.getDocumentOriginY(); + LytRect screenViewport = context.getScreenViewport(); + + var engine = getRenderEngine(); + engine.beginFrame(screenViewport, DisplayScale.scaleFactor()); + var pc = new PrimitiveCollector(screenViewport, context); + pc.pushScreenScissor(screenViewport.x(), screenViewport.y(), screenViewport.width(), screenViewport.height()); + pc.pushTransform(originX, originY - scrollY * zoom, zoom); + try { + for (LytBlock lb : visibleCache) { + pc.collectFrom(lb); + } + } finally { + pc.popTransform(); + pc.popScreenScissor(); + } + var prims = pc.result(); + if (!prims.isEmpty()) { + engine.execute(prims); + } + engine.endFrame(); + if (isOverlayEnabled()) { + renderLayoutOverlay(originX, originY - scrollY * zoom, zoom, screenViewport, pc.getCulledDocRects()); + } + } + + // ---- diagnostic layout overlay (JVM flag or in-game debug menu option) --- + + private void renderLayoutOverlay(float tx, float ty, float zoom, LytRect screenViewport, + List culledRects) { + // Clip all overlay drawing to the viewport: without this, rects of + // offscreen/culled blocks bleed into the screen and look like empty panels. + var mc = net.minecraft.client.Minecraft.getMinecraft(); + int s = DisplayScale.scaleFactor(); + GL11.glEnable(GL11.GL_SCISSOR_TEST); + GL11.glScissor( + screenViewport.x() * s, + Math.max(0, mc.displayHeight - screenViewport.bottom() * s), + screenViewport.width() * s, + screenViewport.height() * s); + try { + // Yellow: fixed viewport scissor (screen space) + drawScreenOutline( + screenViewport.x(), + screenViewport.y(), + screenViewport.width(), + screenViewport.height(), + 0xFFFFFF00); + // Green: Java-side block bounds; Blue: glyph quads + overlayWalk(this, tx, ty, zoom); + // Red: Rust FlatLayout rects + for (LytRect r : overlayRustRects) { + drawDocOutline(r.x(), r.y(), r.width(), r.height(), tx, ty, zoom, 0xFFFF0000); + } + // Gray: blocks culled this frame (correctly not rendered) + for (LytRect r : culledRects) { + drawDocOutline(r.x(), r.y(), r.width(), r.height(), tx, ty, zoom, 0xFF888888); + } + } finally { + GL11.glDisable(GL11.GL_SCISSOR_TEST); + } + } + + private void overlayWalk(LytNode node, float tx, float ty, float zoom) { + if (node instanceof LytBlock block) { + LytRect b = block.getBounds(); + if (b != null) { + drawDocOutline(b.x(), b.y(), b.width(), b.height(), tx, ty, zoom, 0xFF00FF00); + } + if (block instanceof LytParagraph paragraph && paragraph.getGlyphData() != null) { + for (var group : paragraph.getGlyphData() + .runs()) { + for (var g : group.glyphs()) { + drawDocOutline( + Math.round(g.x()), + Math.round(g.y()), + Math.round(g.w()), + Math.round(g.h()), + tx, + ty, + zoom, + 0xFF0000FF); + } + } + } + } + for (LytNode child : node.getChildren()) { + overlayWalk(child, tx, ty, zoom); } } + private void drawDocOutline(int x, int y, int w, int h, float tx, float ty, float zoom, int argb) { + drawScreenOutline( + Math.round(x * zoom + tx), + Math.round(y * zoom + ty), + Math.max(1, Math.round(w * zoom)), + Math.max(1, Math.round(h * zoom)), + argb); + } + + private static void drawScreenOutline(int x, int y, int w, int h, int argb) { + net.minecraft.client.gui.Gui.drawRect(x, y, x + w, y + 1, argb); + net.minecraft.client.gui.Gui.drawRect(x, y + h - 1, x + w, y + h, argb); + net.minecraft.client.gui.Gui.drawRect(x, y + 1, x + 1, y + h - 1, argb); + net.minecraft.client.gui.Gui.drawRect(x + w - 1, y + 1, x + w, y + h - 1, argb); + } + public @Nullable DocumentInteractionSnapshot getHoveredElement() { return hoveredElement; } diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytDocumentFloat.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytDocumentFloat.java index d410e312..8aef708f 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytDocumentFloat.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytDocumentFloat.java @@ -4,6 +4,7 @@ import com.hfstudio.guidenh.guide.document.LytRect; import com.hfstudio.guidenh.guide.layout.LayoutContext; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.render.RenderContext; import lombok.Getter; @@ -40,7 +41,7 @@ @Getter public class LytDocumentFloat extends LytBlock { - private static final int FLOAT_GAP = 5; + public static final int FLOAT_GAP = 5; private LytBlock inner; private final boolean floatRight; @@ -77,16 +78,23 @@ public boolean isCulled(LytRect viewport) { @Override protected LytRect computeLayout(LayoutContext context, int x, int y, int availableWidth) { + // Measure natural width without fullWidth expansion, then relayout at + // the measured width so the inner does not stretch to page width (R4-9). + boolean wasFullWidth = inner.isFullWidth(); + inner.setFullWidth(false); + var naturalBounds = inner.layout(context, x, y, availableWidth); + inner.setFullWidth(wasFullWidth); + int innerWidth = naturalBounds.width(); + if (floatRight) { - var naturalBounds = inner.layout(context, x, y, availableWidth); - int innerWidth = naturalBounds.width(); int rx = x + availableWidth - innerWidth; inner.layout(context, rx, y, innerWidth); context.addRightFloat( new LytRect(rx - FLOAT_GAP, y, innerWidth + FLOAT_GAP, naturalBounds.height() + FLOAT_GAP)); } else { - var innerBounds = inner.layout(context, x, y, availableWidth); - context.addLeftFloat(new LytRect(x, y, innerBounds.width() + FLOAT_GAP, innerBounds.height() + FLOAT_GAP)); + inner.layout(context, x, y, innerWidth); + context.addLeftFloat( + new LytRect(x, y, innerWidth + FLOAT_GAP, naturalBounds.height() + FLOAT_GAP)); } return new LytRect(x, y, 0, 0); } @@ -106,6 +114,16 @@ public LytNode pickNode(int x, int y) { return inner.pickNode(x, y); } + @Override + public boolean usePrimitives() { + return true; + } + + @Override + public void computePrimitives(PrimitiveCollector c) { + // No-op: inner child is picked up by PrimitiveCollector.collectFrom traversal. + } + @Override public void render(RenderContext context) { inner.render(context); diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytFileTree.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytFileTree.java index eadd7750..8712c239 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytFileTree.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytFileTree.java @@ -9,18 +9,23 @@ import com.hfstudio.guidenh.guide.document.LytRect; import com.hfstudio.guidenh.guide.internal.markdown.FileTreeParser.SlotKind; import com.hfstudio.guidenh.guide.layout.LayoutContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.render.RenderContext; import lombok.Getter; /** * A block that renders a file tree as a stack of rows where each row carries a configurable depth - * of connector lines drawn directly with {@link RenderContext#fillRect}, an optional icon block - * and a {@link LytParagraph} payload re-parsed from inline markdown. + * of connector lines drawn directly via {@link #computePrimitives}, an optional icon block and a + * {@link LytParagraph} payload re-parsed from inline markdown. * - *

- * Connectors are derived strictly from the slot kinds parsed for each row, so the visual output is - * deterministic with respect to the source. + *

Each row is wrapped in a {@link LytHBox} row container whose {@code marginLeft} encodes the + * indentation level ({@code slots.size() * indentPx}) and whose children are the optional icon + * block followed by the payload paragraph. The row containers are full tree children + * ({@link #getChildren()}), so they participate in Rust layout — the paragraphs receive proper + * glyph data and bounds computed by the Rust layout engine. Connector lines are still drawn in + * {@link #computePrimitives} using the Rust-computed row container bounds for Y positions. */ public class LytFileTree extends LytBlock { @@ -31,7 +36,7 @@ public class LytFileTree extends LytBlock { private static final int CONNECTOR_THICKNESS = 1; private final List rows = new ArrayList<>(); - private final List childNodes = new ArrayList<>(); + private final List rowContainers = new ArrayList<>(); @Getter private int indentPx = DEFAULT_INDENT_PX; @Getter @@ -40,14 +45,34 @@ public class LytFileTree extends LytBlock { private int iconGapPx = DEFAULT_ICON_GAP_PX; public void appendRow(List slots, @Nullable LytBlock iconBlock, LytParagraph payload) { - Row row = new Row(new ArrayList<>(slots), iconBlock, payload); + LytHBox container = new LytHBox(); + container.setWrap(false); + container.setGap(iconGapPx); + container.setAlignItems(AlignItems.CENTER); if (iconBlock != null) { - iconBlock.parent = this; - childNodes.add(iconBlock); + container.append(iconBlock); + } + container.append(payload); + // Indentation as margin-left on the row container (previously set in + // computeLayout — moved here so the margin is available for serialization + // even after the Java layout pre-pass is removed). + int marginLeft = slots.size() * indentPx; + container.setMarginLeft(marginLeft); + // Gap between rows as margin-bottom (last-row gap cleared by + // finalizeRowGaps). + container.setMarginBottom(rowGapPx); + rows.add(new Row(new ArrayList<>(slots), container)); + rowContainers.add(container); + } + + /** + * Clear the bottom margin on the last row so no trailing gap is added. + * Call after all rows have been appended. + */ + public void finalizeRowGaps() { + if (!rowContainers.isEmpty()) { + rowContainers.get(rowContainers.size() - 1).setMarginBottom(0); } - payload.parent = this; - childNodes.add(payload); - rows.add(row); } public void setIndentPx(int indentPx) { @@ -66,27 +91,16 @@ public boolean isEmpty() { @Override public List getChildren() { - return childNodes; + return rowContainers; } @Override public void removeChild(LytNode node) { - for (int rowIndex = 0; rowIndex < rows.size(); rowIndex++) { - Row row = rows.get(rowIndex); - if (row.payload == node) { - row.payload.parent = null; - childNodes.remove(row.payload); - if (row.iconBlock != null) { - row.iconBlock.parent = null; - childNodes.remove(row.iconBlock); - } - rows.remove(rowIndex); - return; - } - if (row.iconBlock == node) { - row.iconBlock.parent = null; - childNodes.remove(row.iconBlock); - rows.set(rowIndex, new Row(row.slots, null, row.payload)); + for (int i = 0; i < rowContainers.size(); i++) { + if (rowContainers.get(i) == node) { + rowContainers.get(i).parent = null; + rowContainers.remove(i); + rows.remove(i); return; } } @@ -94,70 +108,107 @@ public void removeChild(LytNode node) { @Override protected LytRect computeLayout(LayoutContext context, int x, int y, int availableWidth) { + // Margins are now set in appendRow / finalizeRowGaps. + // Children are laid out by the Rust layout engine — this method + // is retained for compatibility but is no longer called by the + // document pipeline (the Java layout pre-pass has been removed). + // If called directly, lay out children minimally. int currentY = y; int totalHeight = 0; - for (int i = 0; i < rows.size(); i++) { Row row = rows.get(i); - int iconX = x + row.slots.size() * indentPx; - int payloadX; - int iconHeight = 0; - if (row.iconBlock != null) { - // Give the icon enough headroom so its natural width can be measured. Cap it to - // half of the remaining row space so a runaway label cannot eat the whole row. - int iconAvailable = Math.max(iconBoxPx, (x + availableWidth - iconX) / 2); - row.iconBlock.layout(context, iconX, currentY, Math.max(1, iconAvailable)); - LytRect iconBounds = row.iconBlock.getBounds(); - int actualIconWidth = iconBounds.width(); - int reservedIconWidth = Math.max(iconBoxPx, actualIconWidth); - iconHeight = iconBounds.height(); - payloadX = iconX + reservedIconWidth + iconGapPx; - } else { - payloadX = iconX; - } - int payloadAvailable = Math.max(1, x + availableWidth - payloadX); - LytRect payloadBounds = row.payload.layout(context, payloadX, currentY, payloadAvailable); - int payloadHeight = payloadBounds.height(); - int rowHeight = Math.max(payloadHeight, iconHeight); - if (rowHeight <= 0) { - rowHeight = 1; - } - centerRowChild(row.payload, rowHeight, payloadHeight); - if (row.iconBlock != null) { - centerRowChild(row.iconBlock, rowHeight, iconHeight); - } - row.rowY = currentY; - row.rowHeight = rowHeight; - currentY += rowHeight; + LytHBox container = row.container; + int marginLeft = container.getMarginLeft(); + container.layout(context, x + marginLeft, currentY, availableWidth - marginLeft); + LytRect rowBounds = container.getBounds(); + int rowHeight = Math.max(1, rowBounds.height()); totalHeight += rowHeight; - if (i < rows.size() - 1) { - currentY += rowGapPx; - totalHeight += rowGapPx; - } + currentY += rowHeight + container.getMarginBottom(); } - return new LytRect(x, y, availableWidth, totalHeight); } @Override protected void onLayoutMoved(int deltaX, int deltaY) { - for (Row row : rows) { - row.rowY += deltaY; - if (row.iconBlock != null) { - row.iconBlock.moveLayoutPos(deltaX, deltaY); + for (LytHBox row : rowContainers) { + row.moveLayoutPos(deltaX, deltaY); + } + } + + @Override + public boolean usePrimitives() { + return true; + } + + @Override + public void computePrimitives(PrimitiveCollector c) { + int baseX = bounds.x(); + int connectorColor = SymbolicColor.TABLE_BORDER + .resolve(com.hfstudio.guidenh.guide.color.LightDarkMode.current()); + int halfIndent = indentPx / 2; + for (int i = 0; i < rows.size(); i++) { + Row row = rows.get(i); + LytRect rowBounds = row.container.getBounds(); + int rowY = rowBounds.y(); + int rowHeight = rowBounds.height(); + int rowMidY = rowY + Math.max(0, rowHeight - CONNECTOR_THICKNESS) / 2; + // Extend vertical connector to the bottom of the margin-box gap. + int rowBottomY = rowY + rowHeight + row.container.getMarginBottom(); + int slotCount = row.slots.size(); + int columnCenterX = baseX + halfIndent; + for (int slotIndex = 0; slotIndex < slotCount; slotIndex++, columnCenterX += indentPx) { + SlotKind slot = row.slots.get(slotIndex); + switch (slot) { + case VERTICAL -> emitVerticalLine(c, columnCenterX, rowY, rowBottomY, connectorColor); + case BRANCH -> { + emitVerticalLine(c, columnCenterX, rowY, rowBottomY, connectorColor); + emitHorizontalLine( + c, + columnCenterX, + columnCenterX - halfIndent + indentPx, + rowMidY, + connectorColor); + } + case LAST_BRANCH -> { + emitVerticalLine(c, columnCenterX, rowY, rowMidY + CONNECTOR_THICKNESS, connectorColor); + emitHorizontalLine( + c, + columnCenterX, + columnCenterX - halfIndent + indentPx, + rowMidY, + connectorColor); + } + case EMPTY -> { + // Empty slot draws nothing. + } + } } - row.payload.moveLayoutPos(deltaX, deltaY); } } + private static void emitVerticalLine(PrimitiveCollector c, int x, int yStart, int yEnd, int color) { + int top = Math.min(yStart, yEnd); + int height = Math.abs(yEnd - yStart); + if (height <= 0) { + return; + } + c.emit(new GuideRenderPrimitive.FillRect(x, top, CONNECTOR_THICKNESS, height, color)); + } + + private static void emitHorizontalLine(PrimitiveCollector c, int xStart, int xEnd, int y, int color) { + int left = Math.min(xStart, xEnd); + int width = Math.abs(xEnd - xStart); + if (width <= 0) { + return; + } + c.emit(new GuideRenderPrimitive.FillRect(left, y, width, CONNECTOR_THICKNESS, color)); + } + @Override public void render(RenderContext context) { renderConnectors(context); - for (Row row : rows) { - if (row.iconBlock != null) { - row.iconBlock.render(context); - } - row.payload.render(context); + for (LytHBox row : rowContainers) { + row.render(context); } } @@ -166,11 +217,13 @@ private void renderConnectors(RenderContext context) { // Resolve symbolic color once per frame instead of on every fillRect. int connectorColor = context.resolveColor(SymbolicColor.TABLE_BORDER); int halfIndent = indentPx / 2; - for (Row row : rows) { - int rowY = row.rowY; - int rowHeight = row.rowHeight; + for (int i = 0; i < rows.size(); i++) { + Row row = rows.get(i); + LytRect rowBounds = row.container.getBounds(); + int rowY = rowBounds.y(); + int rowHeight = rowBounds.height(); int rowMidY = rowY + Math.max(0, rowHeight - CONNECTOR_THICKNESS) / 2; - int rowBottomY = rowY + rowHeight + rowGapPx; + int rowBottomY = rowY + rowHeight + row.container.getMarginBottom(); int slotCount = row.slots.size(); int columnCenterX = baseX + halfIndent; for (int slotIndex = 0; slotIndex < slotCount; slotIndex++, columnCenterX += indentPx) { @@ -203,13 +256,6 @@ private void renderConnectors(RenderContext context) { } } - private void centerRowChild(LytBlock child, int rowHeight, int childHeight) { - if (childHeight <= 0 || childHeight >= rowHeight) { - return; - } - child.moveLayoutPos(0, (rowHeight - childHeight) / 2); - } - private static void drawVerticalLine(RenderContext context, int x, int yStart, int yEnd, int color) { int top = Math.min(yStart, yEnd); int height = Math.abs(yEnd - yStart); @@ -231,16 +277,11 @@ private static void drawHorizontalLine(RenderContext context, int xStart, int xE private static class Row { final List slots; - @Nullable - final LytBlock iconBlock; - final LytParagraph payload; - int rowY; - int rowHeight; + final LytHBox container; - Row(List slots, @Nullable LytBlock iconBlock, LytParagraph payload) { + Row(List slots, LytHBox container) { this.slots = slots; - this.iconBlock = iconBlock; - this.payload = payload; + this.container = container; } } } diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytFloatAwareBlock.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytFloatAwareBlock.java index 58c34791..631bf7f2 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytFloatAwareBlock.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytFloatAwareBlock.java @@ -6,6 +6,7 @@ import com.hfstudio.guidenh.guide.document.LytRect; import com.hfstudio.guidenh.guide.layout.LayoutContext; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.render.RenderContext; import lombok.Getter; @@ -27,6 +28,7 @@ public class LytFloatAwareBlock extends LytBlock { public LytFloatAwareBlock(LytBlock inner) { this.inner = inner; inner.parent = this; + setFullWidth(inner.isFullWidth()); } @Override @@ -65,6 +67,16 @@ protected void onLayoutMoved(int deltaX, int deltaY) { return inner.pickNode(x, y); } + @Override + public boolean usePrimitives() { + return true; + } + + @Override + public void computePrimitives(PrimitiveCollector c) { + // No-op: inner child is picked up by PrimitiveCollector.collectFrom traversal. + } + @Override public void render(RenderContext context) { inner.render(context); diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytGuiSprite.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytGuiSprite.java index 774632fd..99e5367c 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytGuiSprite.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytGuiSprite.java @@ -1,5 +1,9 @@ package com.hfstudio.guidenh.guide.document.block; +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.texture.ITextureObject; +import net.minecraft.util.ResourceLocation; + import org.jetbrains.annotations.Nullable; import com.hfstudio.guidenh.guide.color.ColorValue; @@ -10,6 +14,8 @@ import com.hfstudio.guidenh.guide.document.interaction.InteractiveElement; import com.hfstudio.guidenh.guide.layout.LayoutContext; import com.hfstudio.guidenh.guide.render.GuiSprite; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.render.RenderContext; import lombok.Getter; @@ -65,6 +71,16 @@ public void setSize(int width, int height) { setSize(new LytSize(width, height)); } + @Override + public int getExplicitWidth() { + return Math.round(size.width()); + } + + @Override + public int getExplicitHeight() { + return Math.round(size.height()); + } + @Override protected LytRect computeLayout(LayoutContext context, int x, int y, int availableWidth) { float actualWidth = size.width(); @@ -98,10 +114,55 @@ public void onMouseLeave() { hovered = false; } + @Override + public boolean usePrimitives() { + return true; + } + + @Override + public void computePrimitives(PrimitiveCollector c) { + if (sprite != null) { + var b = getBounds(); + int texId = getGlTextureId(sprite.getTexture()); + if (texId >= 0) { + float u = (float) sprite.getU() / sprite.getTexWidth(); + float v = (float) sprite.getV() / sprite.getTexHeight(); + float u2 = (float) (sprite.getU() + sprite.getWidth()) / sprite.getTexWidth(); + float v2 = (float) (sprite.getV() + sprite.getHeight()) / sprite.getTexHeight(); + ColorValue tint = hovered && hoverColor != null ? hoverColor : color; + int argb = tint.resolve(com.hfstudio.guidenh.guide.color.LightDarkMode.current()); + c.emit( + new GuideRenderPrimitive.BlitTexture( + texId, + b.x(), + b.y(), + b.width(), + b.height(), + u, + v, + u2, + v2, + argb)); + } + } + } + @Override public void render(RenderContext context) { if (sprite != null) { context.fillIcon(getBounds(), sprite, hovered && hoverColor != null ? hoverColor : color); } } + + private static int getGlTextureId(ResourceLocation res) { + try { + ITextureObject tex = Minecraft.getMinecraft() + .getTextureManager() + .getTexture(res); + return tex != null ? tex.getGlTextureId() : -1; + } catch (Throwable t) { + // Headless (unit tests) or texture unavailable: skip drawing. + return -1; + } + } } diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytHeading.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytHeading.java index 51c8cc85..e18eb966 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytHeading.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytHeading.java @@ -1,9 +1,10 @@ package com.hfstudio.guidenh.guide.document.block; +import com.hfstudio.guidenh.guide.color.LightDarkMode; import com.hfstudio.guidenh.guide.color.SymbolicColor; import com.hfstudio.guidenh.guide.document.DefaultStyles; -import com.hfstudio.guidenh.guide.document.LytRect; -import com.hfstudio.guidenh.guide.layout.LayoutContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.render.RenderContext; import lombok.Getter; @@ -12,15 +13,27 @@ public class LytHeading extends LytParagraph { @Getter private int depth = 1; - // Horizontal offset from bounds.x() to the float-adjusted text start position - private int separatorXOffset = 0; - private int separatorWidth = 0; public LytHeading() { setMarginTop(5); setMarginBottom(5); } + /** + * Per-depth vertical margins: the space before a heading grows with its + * level (H1 20 / H2 18 / H3 14 / H4 12 / H5-H6 10) while the space after + * stays small (H1-H2 6 / H3-H6 7; the top two were trimmed 8→6 so the + * separator-to-body gap lands ≈10-12px combined with + * {@link #HEADING_SEPARATOR_GAP}). The strong top/bottom ratio makes a + * heading "breathe" above while binding it to its own content below + * (taffy adds margins, no collapsing), so parent-child and sibling heading + * gaps stay distinguishable. Consecutive headings collapse instead of + * summing — see {@link #collapseBottomForAdjacent()}. Index 0 is the + * depth-agnostic fallback used when no valid depth is assigned. + */ + private static final int[] HEADING_MARGIN_TOP = { 5, 20, 18, 14, 12, 10, 10 }; + private static final int[] HEADING_MARGIN_BOTTOM = { 5, 6, 6, 7, 7, 7, 7 }; + public void setDepth(int depth) { this.depth = depth; var style = switch (depth) { @@ -33,19 +46,52 @@ public void setDepth(int depth) { default -> DefaultStyles.BODY_TEXT; }; setStyle(style); + int idx = (depth >= 1 && depth <= 6) ? depth : 0; + setMarginTop(HEADING_MARGIN_TOP[idx]); + setMarginBottom(HEADING_MARGIN_BOTTOM[idx]); + } + + /** + * CSS-style margin collapse for consecutive headings. Taffy sums adjacent + * margins without collapsing, so two headings with no body between them + * would keep both the first's bottom and the second's top margin (H3 7 + + * H4 12 = 19px — the "hole" between consecutive headings). When this + * heading is directly followed by another heading (detected at compile time + * in {@code HeadingCompiler}), its bottom margin is zeroed so the pair + * keeps only the following heading's top margin. Because every depth's top + * margin in {@link #HEADING_MARGIN_TOP} is ≥ every shallower heading's + * bottom margin in {@link #HEADING_MARGIN_BOTTOM}, this equals the CSS + * {@code max()} collapse rule. Heading→body spacing is unaffected. + */ + public void collapseBottomForAdjacent() { + setMarginBottom(0); } @Override - public LytRect computeLayout(LayoutContext context, int x, int y, int availableWidth) { - // Capture the active inline window so the separator follows the same wrapped line width - // that the heading text uses and never paints under floating content on either side. - int leftEdge = context.getLeftFloatRightEdgeOr(x); - int rightEdge = context.getRightFloatLeftEdgeOr(x + availableWidth); - int clampedLeftEdge = Math.max(x, leftEdge); - int clampedRightEdge = Math.min(x + availableWidth, rightEdge); - separatorXOffset = Math.max(0, clampedLeftEdge - x); - separatorWidth = Math.max(0, clampedRightEdge - clampedLeftEdge); - return super.computeLayout(context, x, y, availableWidth); + public void computePrimitives(PrimitiveCollector c) { + super.computePrimitives(c); + + // Separators stay reserved for the top two levels: the monotonic size + // ladder + bold white now distinguish H3-H6 from body text without a + // rule line (judgment per P2 typography pass — H3 gets no fainter line). + if (depth == 1) { + emitSeparator(c, SymbolicColor.HEADER1_SEPARATOR.resolve(LightDarkMode.current())); + } else if (depth == 2) { + emitSeparator(c, SymbolicColor.HEADER2_SEPARATOR.resolve(LightDarkMode.current())); + } + } + + /** + * Fixed gap between the lowest glyph bottom and the separator line, so the + * rule never grazes descender tails (g/p/y) regardless of how far they + * hang below the baseline. + */ + private static final int HEADING_SEPARATOR_GAP = 5; + + private void emitSeparator(PrimitiveCollector c, int argb) { + int sepY = separatorY(); + int[] ext = separatorExtent(); + c.emit(new GuideRenderPrimitive.FillRect(ext[0], sepY, ext[1], 1, argb)); } @Override @@ -53,15 +99,58 @@ public void render(RenderContext context) { super.render(context); if (depth == 1) { - var bounds = getBounds(); - int sepX = bounds.x() + separatorXOffset; - int sepW = Math.max(0, separatorWidth); - context.fillRect(sepX, bounds.bottom() - 1, sepW, 1, SymbolicColor.HEADER1_SEPARATOR); + emitSeparatorLegacy(context, SymbolicColor.HEADER1_SEPARATOR); } else if (depth == 2) { - var bounds = getBounds(); - int sepX = bounds.x() + separatorXOffset; - int sepW = Math.max(0, separatorWidth); - context.fillRect(sepX, bounds.bottom() - 1, sepW, 1, SymbolicColor.HEADER2_SEPARATOR); + emitSeparatorLegacy(context, SymbolicColor.HEADER2_SEPARATOR); + } + } + + private void emitSeparatorLegacy(RenderContext context, SymbolicColor color) { + int sepY = separatorY(); + int[] ext = separatorExtent(); + context.fillRect(ext[0], sepY, ext[1], 1, color); + } + + /** + * The separator's vertical position: a fixed gap below the actual lowest + * glyph bottom (baseline + real descender extent), decoupled from the + * block bounds bottom whose distance to the text depends on the font's + * ascent/descent allocation. Falls back to the block bottom when no glyph + * run is available (legacy/no-Rust path). + */ + private int separatorY() { + var data = getGlyphData(); + if (data != null) { + float maxBottom = Float.NEGATIVE_INFINITY; + boolean found = false; + for (var run : data.runs()) { + for (var g : run.glyphs()) { + maxBottom = Math.max(maxBottom, g.y() + g.h()); + found = true; + } + } + if (found) { + return Math.round(maxBottom) + HEADING_SEPARATOR_GAP; + } + } + return getBounds().bottom() - 1; + } + + /** + * Returns {@code [x, width]} for the separator, computed from the Rust- + * emitted kind=3 DecorationRect (the full float-compressed line window). + * Falls back to the block bounds when no separator rect is available + * (legacy/no-Rust path). + */ + private int[] separatorExtent() { + var bounds = getBounds(); + var data = getGlyphData(); + if (data != null && !data.separators() + .isEmpty()) { + var r = data.separators() + .get(0); + return new int[] { r.x(), Math.max(0, r.w()) }; } + return new int[] { bounds.x(), bounds.width() }; } } diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytImage.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytImage.java index 5fe43640..46b335e6 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytImage.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytImage.java @@ -4,16 +4,23 @@ import java.util.List; import java.util.Optional; +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.texture.ITextureObject; import net.minecraft.util.ResourceLocation; import org.jetbrains.annotations.Nullable; +import com.hfstudio.guidenh.guide.color.LightDarkMode; import com.hfstudio.guidenh.guide.document.LytRect; +import com.hfstudio.guidenh.guide.document.LytSize; import com.hfstudio.guidenh.guide.document.interaction.GuideTooltip; import com.hfstudio.guidenh.guide.document.interaction.InteractiveElement; import com.hfstudio.guidenh.guide.layout.LayoutContext; import com.hfstudio.guidenh.guide.render.GuiAssets; +import com.hfstudio.guidenh.guide.render.GuiSprite; import com.hfstudio.guidenh.guide.render.GuidePageTexture; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.render.RenderContext; import com.hfstudio.guidenh.guide.sound.GuideSoundPlayback; import com.hfstudio.guidenh.guide.sound.GuideSoundSpec; @@ -38,13 +45,21 @@ public class LytImage extends LytBlock implements InteractiveElement { @Setter private String alt; + @Getter private int explicitWidth = -1; + @Getter private int explicitHeight = -1; + @Getter private int cropX; + @Getter private int cropY; + @Getter private int cropWidth = -1; + @Getter private int cropHeight = -1; + @Getter private double scaleX = 1.0d; + @Getter private double scaleY = 1.0d; @Getter @@ -97,7 +112,29 @@ protected LytRect computeLayout(LayoutContext context, int x, int y, int availab int sourceHeight = Math.max(1, cropHeight > 0 ? cropHeight : size.height()); int width; int height; - if (explicitWidth > 0 || explicitHeight > 0) { + // Mirrors Rust measure_image (layout-engine/src/measure.rs) exactly: + // two explicit dimensions win as-is; a single explicit dimension + // (F-N1 whole-image display size) infers the missing axis from the + // natural aspect ratio (inferred = explicit × natural_other / + // natural_given, no per-axis scale on the inferred axis); otherwise + // fall back to natural × DEFAULT_LAYOUT_SCALE × scale. When the + // texture is missing the natural size is unreliable, so no inference + // happens and the legacy fallback applies. + boolean hasNatural = texture != null && !texture.isMissing() && sourceWidth > 0 && sourceHeight > 0; + if (explicitWidth > 0 && explicitHeight > 0) { + width = explicitWidth; + height = explicitHeight; + } else if (explicitWidth > 0 && hasNatural) { + width = explicitWidth; + height = Math.max(1, (int) Math.round(explicitWidth * (sourceHeight / (double) sourceWidth))); + } else if (explicitHeight > 0 && hasNatural) { + width = Math.max(1, (int) Math.round(explicitHeight * (sourceWidth / (double) sourceHeight))); + height = explicitHeight; + } else if (explicitWidth > 0 || explicitHeight > 0) { + // Single explicit dimension but the natural size is unavailable + // (missing / placeholder texture): no aspect-ratio inference — + // legacy behaviour, the explicit axis wins and the missing axis is + // natural × scale. width = explicitWidth > 0 ? explicitWidth : Math.max(1, (int) Math.round(sourceWidth * scaleX)); height = explicitHeight > 0 ? explicitHeight : Math.max(1, (int) Math.round(sourceHeight * scaleY)); } else { @@ -128,6 +165,116 @@ public void onMouseLeave() { hoveredSoundAnnotation = null; } + @Override + public boolean usePrimitives() { + return true; + } + + @Override + public void computePrimitives(PrimitiveCollector c) { + var bounds = getBounds(); + if (texture == null || texture.isMissing()) { + // Fall back to missing texture sprite + emitBlitGuiSprite(c, GuiAssets.MISSING_TEXTURE, bounds.x(), bounds.y(), bounds.width(), bounds.height()); + } else { + ResourceLocation resolvedTex = texture.getTexture(); + int texId = resolvedTex != null ? getGlTextureId(resolvedTex) : -1; + if (texId >= 0) { + // Compute UV from crop rect, or full texture when no cropping. + LytSize texSize = texture.getSize(); + float u1, v1, u2, v2; + if (cropWidth > 0) { + u1 = (float) cropX / texSize.width(); + v1 = (float) cropY / texSize.height(); + u2 = (float) (cropX + cropWidth) / texSize.width(); + v2 = (float) (cropY + cropHeight) / texSize.height(); + } else { + u1 = 0f; + v1 = 0f; + u2 = 1f; + v2 = 1f; + } + c.emit( + new GuideRenderPrimitive.BlitTexture( + texId, + bounds.x(), + bounds.y(), + bounds.width(), + bounds.height(), + u1, + v1, + u2, + v2)); + } else { + // Texture object not (yet) registered with the TextureManager — + // fall back to the missing-texture sprite instead of leaving an + // empty box. + emitBlitGuiSprite( + c, + GuiAssets.MISSING_TEXTURE, + bounds.x(), + bounds.y(), + bounds.width(), + bounds.height()); + } + } + } + + @Override + public void emitDecorations(PrimitiveCollector c) { + if (annotations.isEmpty()) { + return; + } + var bounds = getBounds(); + int dispW = bounds.width(); + int dispH = bounds.height(); + if (dispW <= 0 || dispH <= 0) { + return; + } + int natW = texture != null && !texture.isMissing() ? getEffectiveSourceWidth() : dispW; + int natH = texture != null && !texture.isMissing() ? getEffectiveSourceHeight() : dispH; + for (var ann : annotations) { + if (!ann.isShowBorder()) { + continue; + } + int bx; + int by; + int bw; + int bh; + if (ann.isWholeImage()) { + bx = bounds.x(); + by = bounds.y(); + bw = bounds.width(); + bh = bounds.height(); + } else { + int clampedX = Math.clamp(ann.getImgX(), 0, natW); + int clampedY = Math.clamp(ann.getImgY(), 0, natH); + int clampedW = Math.min(ann.getImgX() + ann.getImgW(), natW) - clampedX; + int clampedH = Math.min(ann.getImgY() + ann.getImgH(), natH) - clampedY; + if (clampedW <= 0 || clampedH <= 0) { + continue; + } + bx = bounds.x() + clampedX * dispW / natW; + by = bounds.y() + clampedY * dispH / natH; + bw = Math.max(1, clampedW * dispW / natW); + bh = Math.max(1, clampedH * dispH / natH); + } + int borderArgb = ann.getBorderColor() + .resolve(LightDarkMode.current()); + c.emit( + new GuideRenderPrimitive.DrawBorder( + bx, + by, + bw, + bh, + ann.getBorderThickness(), + ann.getBorderThickness(), + ann.getBorderThickness(), + ann.getBorderThickness(), + borderArgb)); + } + } + @Override public void render(RenderContext context) { if (texture == null) { @@ -320,6 +467,34 @@ private int getEffectiveSourceHeight() { : 1; } + /** + * Convert a Minecraft ResourceLocation to a GL texture ID for use with BlitTexture. + */ + private static int getGlTextureId(ResourceLocation res) { + try { + ITextureObject tex = Minecraft.getMinecraft() + .getTextureManager() + .getTexture(res); + return tex != null ? tex.getGlTextureId() : -1; + } catch (Throwable t) { + // Headless (unit tests) or texture unavailable: skip drawing. + return -1; + } + } + + /** + * Emit a BlitTexture for a GuiSprite at the given screen coordinates. + */ + private static void emitBlitGuiSprite(PrimitiveCollector c, GuiSprite sprite, int x, int y, int w, int h) { + int texId = getGlTextureId(sprite.getTexture()); + if (texId < 0) return; + float u = (float) sprite.getU() / sprite.getTexWidth(); + float v = (float) sprite.getV() / sprite.getTexHeight(); + float u2 = (float) (sprite.getU() + sprite.getWidth()) / sprite.getTexWidth(); + float v2 = (float) (sprite.getV() + sprite.getHeight()) / sprite.getTexHeight(); + c.emit(new GuideRenderPrimitive.BlitTexture(texId, x, y, w, h, u, v, u2, v2)); + } + public static class ImagePoint { public final float x; diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytItemGrid.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytItemGrid.java index 28deda74..fc125712 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytItemGrid.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytItemGrid.java @@ -19,7 +19,11 @@ public LytItemGrid() { @Override protected LytRect computeBoxLayout(LayoutContext context, int x, int y, int availableWidth) { - var cols = Math.max(1, availableWidth / LytSlot.OUTER_SIZE); + // Fixed 3-column semantic: cols = min(3, slotCount) — mirrors the + // lowering rule in LayoutStyleExtractor (explicitW = cols * OUTER_SIZE + // + horizontal padding; Taffy 0.12 sizes are border-box, so padding is + // included in size_w and must be added back to reach the content width). + var cols = Math.max(1, Math.min(3, slots.size())); var rows = (slots.size() + cols - 1) / cols; for (int i = 0; i < slots.size(); i++) { @@ -47,4 +51,9 @@ public void addItems(List stacks) { slots.add(slot); append(slot); } + + /** Number of added slots — drives the fixed 3-column lowering rule. */ + public int getSlotCount() { + return slots.size(); + } } diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytItemImage.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytItemImage.java index f5b104ed..0958a592 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytItemImage.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytItemImage.java @@ -6,18 +6,24 @@ import net.minecraft.item.ItemStack; import org.jetbrains.annotations.Nullable; -import org.lwjgl.opengl.GL11; import com.hfstudio.guidenh.guide.document.DefaultStyles; import com.hfstudio.guidenh.guide.document.LytRect; import com.hfstudio.guidenh.guide.document.interaction.GuideTooltip; import com.hfstudio.guidenh.guide.document.interaction.InteractiveElement; import com.hfstudio.guidenh.guide.document.interaction.ItemTooltip; -import com.hfstudio.guidenh.guide.internal.item.GuideDisplayItemStacks; + import com.hfstudio.guidenh.guide.layout.LayoutContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.GuideText; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.render.RenderContext; import com.hfstudio.guidenh.guide.style.ResolvedTextStyle; import com.hfstudio.guidenh.guide.style.TextStyle; +import com.hfstudio.guidenh.guide.style.token.DimensionValue; +import com.hfstudio.guidenh.guide.style.token.GuideThemeManager; +import com.hfstudio.guidenh.guide.style.token.TokenKey; +import com.hfstudio.guidenh.guide.style.token.TokenType; import lombok.Getter; import lombok.Setter; @@ -26,7 +32,30 @@ public class LytItemImage extends LytBlock implements InteractiveElement { public static final int BASE_SIZE = 16; - private static final int LABEL_GAP = 2; + /** + * Optical advance adjustment (layout px, applied after scale) for the + * no-label inline path. The tightW advance ({@code inkW * scale + 2*PAD}) + * and the renderX offset ({@code -inkLeft * scale + PAD}) must stay in + * lockstep through this shared constant. 0 = the icon's ink box fills its + * cell exactly (cell width = ink width); surrounding text glyphs already + * carry their own advance/bearing spacing, so a per-icon pad adds nothing + * but the "icon trailing kerning" gap the users reported. Only used on the + * no-label inline path; the label path and the block (non-inline) path + * keep the legacy 16px cell. + */ + private static final int INLINE_OPTICAL_PAD = 0; + + /** Theme token: gap between the item icon and its label text. */ + private static final TokenKey LABEL_GAP = TokenKey + .define("--lyt-item-image-label-gap", TokenType.DIMENSION, DimensionValue.px(2)); + + private static int labelGap() { + return GuideThemeManager.instance() + .active() + .dim(LABEL_GAP) + .pxInt(); + } + private static final int DEFAULT_INLINE_ITEM_VISUAL_Y_OFFSET = 0; public static int DEFAULT_TEXT_INLINE_Y_OFFSET = 0; @@ -67,6 +96,9 @@ public class LytItemImage extends LytBlock implements InteractiveElement { @Nullable private String labelFormat = null; private int layoutYOffset = 0; + /** Label text metrics cached from the last layout pass (used by computePrimitives). */ + private int labelTextW; + private int labelTextH; @Nullable private ResolvedTextStyle cachedLabelStyle = null; @Nullable @@ -80,6 +112,18 @@ public void setScale(float scale) { this.scale = Math.max(0.125f, scale); } + @Override + public int getExplicitWidth() { + if (!showIcon && labelPosition == null) return -1; + return computeContentSize()[0]; + } + + @Override + public int getExplicitHeight() { + if (!showIcon && labelPosition == null) return -1; + return computeContentSize()[1]; + } + /** Kept for backward compatibility. Prefer {@link #setShowTooltip(boolean)}. */ public void setTooltipSuppressed(boolean suppressed) { this.showTooltip = !suppressed; @@ -128,6 +172,66 @@ public void setLabelYOffsetOverride(@Nullable Integer override) { this.labelYOffsetOverride = override; } + /** + * Computes the full content size of this block (icon + label when both + * present, icon-only or text-only otherwise). Mirrors computeLayout + * arithmetic using static GuideText measurement. + * + * @return int[]{width, height} + */ + private int[] computeContentSize() { + int iconSize = Math.round(BASE_SIZE * scale); + boolean hasLabel = labelPosition != null && stack != null; + + if (!showIcon && !hasLabel) { + return new int[]{0, 0}; + } + if (!hasLabel) { + // Optical tight advance for inline icons: shrink the cell to the + // ink width (+ PAD on each side, PAD=0 by default) instead of the + // full 16px square, so the gap to the following text is consistent + // across items. Falls back to the legacy 16px cell when ink metrics + // are unavailable. + if (inline) { + IconMetrics m = stack != null ? IconMetrics.forStack(stack) : null; + if (m != null) { + int tightW = Math.round(m.width * scale) + 2 * INLINE_OPTICAL_PAD; + return new int[]{tightW, iconSize}; + } + } + return new int[]{iconSize, iconSize}; + } + + ResolvedTextStyle textStyle = resolveLabelStyle(); + String text = resolveLabelText(); + int textW = GuideText.measureWidth(text, textStyle); + int textH = GuideText.lineHeight(textStyle); + + if (!showIcon) { + return new int[]{textW, textH}; + } + + // showIcon + hasLabel — total width is same for label="left" and label="right" + int labelYOffset = inline && showIcon + ? Math.round( + (labelYOffsetOverride != null ? labelYOffsetOverride : DEFAULT_TEXT_INLINE_Y_OFFSET) * scale) + : 0; + int textTop = (iconSize - textH) / 2 + labelYOffset; + int top = Math.min(0, textTop); + int bottom = Math.max(iconSize, textTop + textH); + int totalW = iconSize + labelGap() + textW; + int totalH = Math.max(0, bottom - top); + return new int[]{totalW, totalH}; + } + + /** + * Computes the inline size (width, height) for serialization when no + * LayoutContext is available. Delegates to {@link #computeContentSize()}. + */ + public int[] measureSerializedInlineSize() { + return computeContentSize(); + } + @Override protected LytRect computeLayout(LayoutContext context, int x, int y, int availableWidth) { int iconSize = Math.round(BASE_SIZE * scale); @@ -142,6 +246,17 @@ protected LytRect computeLayout(LayoutContext context, int x, int y, int availab } if (!hasLabel) { layoutYOffset = 0; + // Mirrors computeContentSize: the no-label inline path uses the + // same tight ink advance (PAD=0), so serialization-size and + // layout-size never disagree for the same block. Non-inline and + // label paths keep the legacy 16px cell. + if (inline) { + IconMetrics m = stack != null ? IconMetrics.forStack(stack) : null; + if (m != null) { + int tightW = Math.round(m.width * scale) + 2 * INLINE_OPTICAL_PAD; + return new LytRect(x, y, tightW, iconSize); + } + } return new LytRect(x, y, iconSize, iconSize); } @@ -149,6 +264,8 @@ protected LytRect computeLayout(LayoutContext context, int x, int y, int availab String text = resolveLabelText(); int textW = measureTextWidth(context, text, textStyle); int textH = context.getLineHeight(textStyle); + labelTextW = textW; + labelTextH = textH; if (!showIcon) { layoutYOffset = 0; @@ -158,7 +275,7 @@ protected LytRect computeLayout(LayoutContext context, int x, int y, int availab int top = Math.min(0, textTop); int bottom = Math.max(iconSize, textTop + textH); layoutYOffset = top; - int totalW = iconSize + LABEL_GAP + textW; + int totalW = iconSize + labelGap() + textW; int totalH = Math.max(0, bottom - top); return new LytRect(x, y, totalW, totalH); } @@ -167,7 +284,12 @@ protected LytRect computeLayout(LayoutContext context, int x, int y, int availab protected void onLayoutMoved(int deltaX, int deltaY) {} @Override - public void render(RenderContext context) { + public boolean usePrimitives() { + return true; + } + + @Override + public void computePrimitives(PrimitiveCollector c) { if (stack == null || stack.stackSize == 0) return; int baseX = bounds.x(); @@ -182,9 +304,13 @@ public void render(RenderContext context) { if (hasLabel) { ResolvedTextStyle textStyle = resolveLabelStyle(); String text = resolveLabelText(); - int textW = context.getStringWidth(text, textStyle); - int textH = context.getLineHeight(textStyle); - int textVCenter = showIcon ? (iconSize - textH) / 2 : 0; + // On-the-spot measurement when the layout-pass cache is unpopulated + // (Java layout pre-pass was removed — computeLayout may not run). + if (labelTextW <= 0) { + labelTextW = GuideText.measureWidth(text, textStyle); + labelTextH = GuideText.lineHeight(textStyle); + } + int textVCenter = showIcon ? (iconSize - labelTextH) / 2 : 0; int labelYOffset = inline && showIcon ? Math .round((labelYOffsetOverride != null ? labelYOffsetOverride : DEFAULT_TEXT_INLINE_Y_OFFSET) * scale) @@ -192,42 +318,43 @@ public void render(RenderContext context) { if ("left".equals(labelPosition)) { textX = baseX; - iconX = showIcon ? baseX + textW + LABEL_GAP : baseX; + iconX = showIcon ? baseX + labelTextW + labelGap() : baseX; } else { iconX = baseX; - textX = showIcon ? baseX + iconSize + LABEL_GAP : baseX; + textX = showIcon ? baseX + iconSize + labelGap() : baseX; } textY = baseY + textVCenter + labelYOffset; - context.drawText(text, textX, textY, textStyle); + GuideText.emitText(c, text, textX, textY, textStyle); } if (showIcon) { int renderX = iconX; + if (inline && !hasLabel) { + // Optical tight placement on the no-label inline path: shift the + // icon so its ink left edge sits INLINE_OPTICAL_PAD (0) px from + // the cell's left edge, mirroring the tight advance computed in + // computeContentSize. Null metrics (atlas not ready / missingno) + // keep the legacy offset of 0. + IconMetrics m = stack != null ? IconMetrics.forStack(stack) : null; + if (m != null) { + renderX = iconX - Math.round(m.inkLeft * scale) + INLINE_OPTICAL_PAD; + } + } int renderY = baseY + getInlineVisualYOffset(); - renderIcon(context, renderX, renderY); - } - } - - private void renderIcon(RenderContext context, int renderX, int renderY) { - try { if (scale == 1f) { - context.renderItem(stack, renderX, renderY); + c.emit(new GuideRenderPrimitive.RenderItem(stack, renderX, renderY)); } else { - GL11.glPushMatrix(); - try { - GL11.glTranslatef(renderX, renderY, 0); - GL11.glScalef(scale, scale, 1f); - context.renderItem(stack, 0, 0); - } finally { - GL11.glPopMatrix(); - } + c.pushTransform(renderX, renderY, scale); + c.emit(new GuideRenderPrimitive.RenderItem(stack, 0, 0)); + c.popTransform(); } - } catch (Throwable t) { - GuideDisplayItemStacks.warnRenderFailure("LytItemImage", stack, t); - context.restoreExternalRenderState(); } } + @Override + public void render(RenderContext context) { + } + @Override public Optional getTooltip(float x, float y) { if (!showTooltip) return Optional.empty(); diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytLatexBlock.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytLatexBlock.java index 8ea7490e..a8c8fdbc 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytLatexBlock.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytLatexBlock.java @@ -3,12 +3,16 @@ import java.util.Optional; import org.jetbrains.annotations.Nullable; +import org.scilab.forge.jlatexmath.TeXConstants; import com.hfstudio.guidenh.guide.document.LytRect; import com.hfstudio.guidenh.guide.document.interaction.GuideTooltip; import com.hfstudio.guidenh.guide.document.interaction.InteractiveElement; import com.hfstudio.guidenh.guide.latex.GuideLatexRenderer; import com.hfstudio.guidenh.guide.layout.LayoutContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.GuideText; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.render.RenderContext; import lombok.Getter; @@ -41,6 +45,7 @@ public class LytLatexBlock extends LytBlock implements InteractiveElement { private final float sourceScale; @Getter private final float userScale; + private final int style; @Nullable private final GuideTooltip tooltip; @Getter @@ -54,17 +59,66 @@ public class LytLatexBlock extends LytBlock implements InteractiveElement { private int formulaDisplayW; /** Formula display height in GUI pixels, recomputed each layout pass. */ private int formulaDisplayH; + /** True when lazy computation has been attempted (even if result is 0). */ + private boolean formulaDisplayComputed; /** Vertical pixel offset inside the layout bounds, recomputed each layout pass. */ private int renderYOffset; + /** + * Distance from the formula's top to the text baseline it aligns with, in GUI + * pixels. Recomputed each layout pass; consumed by the Rust inline post-pass, + * which anchors the block's top this far above the placeholder's baseline. + */ + @Getter + private float baselineAscent; private boolean sourceMetricsResolved; private int sourceWidthPx; private int sourceHeightPx; - private int sourceDepthPx; private int sourceRefHeightPx; + /** + * Exact jlatexmath math-baseline ratio from + * {@code GuideLatexRenderer.measureBaselineRatio} (see + * {@link TeXIcon#getBaseLine()}: baseline distance from the icon top as a + * fraction of the icon's total height, insets included, in [0,1]). Used + * instead of a source-pixel depth so the display depth is rounded exactly + * once, at display resolution. + */ + private float sourceBaseLineRatio; + + /** + * Total icon insets (2px per side) applied by + * {@code GuideLatexRenderer.setInsets(new Insets(2,2,2,2), true)} to every measured icon + * and the calibration "x". The two-arg (trueValues) form is essential here: the single-arg + * {@code setInsets(Insets)} delegates to {@code setInsets(insets, false)} and silently adds + * {@code (int)(0.18f*size)} to every side — 18px extra per side at the default size 100, i.e. + * the "2px" padding was actually 20px/side (40px total per dimension). That phantom padding + * inflated {@code sourceRefHeightPx} so badly that this 4px subtraction could not recover the + * true x-content height, and inline formulas rendered ≈0.67× the body x-height. With the + * real 2px/side insets, {@code sourceRefHeightPx - LATEX_INSET_PX} is again the calibration + * "x" glyph content height; the fixed padding is removed from the calibration height before + * the scaling ratio so it does not distort the scale once the target is the (smaller) body + * x-height; the display box then scales the whole icon (content + insets) uniformly, so the + * padding is present but scaled, never inflating the glyph itself. + */ + static final int LATEX_INSET_PX = 4; + + /** + * Perceptual size compensation applied on top of the exact x-height + * calibration target. TeX math is designed with tight lower-case metrics + * (Computer Modern's x-height is small relative to its cap height, and + * formulas mostly consist of lower-case letters), so an inline formula + * whose body letters exactly equal the surrounding CJK text's x-height + * still reads as noticeably smaller than the body text. This factor + * restores visual weight parity: the calibration "x" targets + * {@code x-height × 1.2} instead of the raw x-height (user report: + * "公式字体过小"). + */ + static final float INLINE_PERCEPTUAL_FACTOR = 1.2f; public LytLatexBlock(String formula, int fillColorArgb, float sourceScale, float userScale, @Nullable GuideTooltip tooltip, LatexVerticalAlign valign, int offsetX, int offsetY) { - this(formula, new LatexRenderOptions(fillColorArgb, sourceScale, userScale, tooltip, valign, offsetX, offsetY)); + this(formula, + new LatexRenderOptions(TeXConstants.STYLE_DISPLAY, fillColorArgb, sourceScale, userScale, tooltip, valign, + offsetX, offsetY)); } public LytLatexBlock(String formula, LatexRenderOptions options) { @@ -72,14 +126,64 @@ public LytLatexBlock(String formula, LatexRenderOptions options) { this.fillColorArgb = options.fillColorArgb(); this.sourceScale = options.sourceScale(); this.userScale = options.userScale(); + this.style = options.style(); this.tooltip = options.tooltip(); this.valign = options.valign(); this.offsetX = options.offsetX(); this.offsetY = options.offsetY(); } + /** + * Returns the formula display width, computing it lazily if no layout pass has been run. + * Uses static font metrics via {@link GuideText} so it works without a {@link LayoutContext}. + */ + public int getFormulaDisplayW() { + if (!formulaDisplayComputed) { + computeFormulaDisplay(); + } + return formulaDisplayW; + } + + /** + * Returns the formula display height, computing it lazily if no layout pass has been run. + * Uses static font metrics via {@link GuideText} so it works without a {@link LayoutContext}. + */ + public int getFormulaDisplayH() { + if (!formulaDisplayComputed) { + computeFormulaDisplay(); + } + return formulaDisplayH; + } + + /** Lazy-compute formula display dimensions using static font metrics. */ + private void computeFormulaDisplay() { + formulaDisplayComputed = true; + if (!resolveSourceMetrics()) { + formulaDisplayW = 0; + formulaDisplayH = 0; + return; + } + int lineHeight = GuideText.lineHeight(null); + float scaleFactor = inlineScaleFactor(); + formulaDisplayH = scaleSourceMetricCeil(sourceHeightPx, scaleFactor); + formulaDisplayW = scaleSourceMetricCeil(sourceWidthPx, scaleFactor); + // baselineAscent must also be computed here — the Java layout pre-pass + // has been removed (Rust is sole geometry authority), so computeLayout() + // is never called. The Rust inline post-pass uses this value as param + // (align=1) to anchor the formula's math baseline at the text baseline. + int depthDisplay = scaleSourceDepthFromBaseline(sourceBaseLineRatio, formulaDisplayH); + int alignOffset = switch (valign) { + case CENTER -> (lineHeight - formulaDisplayH) / 2; + case BOTTOM -> lineHeight - formulaDisplayH; + case BASELINE -> lineHeight - formulaDisplayH + depthDisplay; + default -> 0; // TOP + }; + baselineAscent = lineHeight - (alignOffset + offsetY); + } + @Override protected LytRect computeLayout(LayoutContext context, int x, int y, int availableWidth) { + formulaDisplayComputed = true; if (!resolveSourceMetrics()) { formulaDisplayW = 0; formulaDisplayH = 0; @@ -88,8 +192,9 @@ protected LytRect computeLayout(LayoutContext context, int x, int y, int availab } int lineHeight = context.getLineHeight(null); - formulaDisplayH = scaleSourceMetricCeil(sourceHeightPx, lineHeight); - formulaDisplayW = scaleSourceMetricCeil(sourceWidthPx, lineHeight); + float scaleFactor = inlineScaleFactor(); + formulaDisplayH = scaleSourceMetricCeil(sourceHeightPx, scaleFactor); + formulaDisplayW = scaleSourceMetricCeil(sourceWidthPx, scaleFactor); int alignOffset = switch (valign) { case CENTER -> (lineHeight - formulaDisplayH) / 2; @@ -97,17 +202,23 @@ protected LytRect computeLayout(LayoutContext context, int x, int y, int availab case BASELINE -> { // Align the formula's math baseline with the text baseline. // - // Both calibrateRefHeight() and measureSize() apply the same Insets value, - // so the bottom-inset term B cancels out in the algebra: + // The anchor depth is the icon bottom minus the math baseline: + // the true content depth PLUS the 2px bottom inset, both scaled + // to display pixels by the actual texture scale (displayH / + // sourceHeightPx). The texture is the full icon (insets + // included) drawn uniformly into the displayH-tall box, so the + // math baseline sits exactly that far above the box bottom: + // + // alignOffset = lineHeight - displayH + depthDisplay // - // text_baseline = (refH - B) * lineHeight / refH - // formula_ascent = (size[1] - B - size[2]) * lineHeight * userScale / refH - // alignOffset = text_baseline - formula_ascent - // = (lineHeight - displayH) + size[2] * lineHeight * userScale / refH - // = (lineHeight - displayH) + depthDisplay + // The depth is derived from the exact TeXIcon#getBaseLine() + // ratio (baseline fraction of the icon height), so it is + // rounded exactly once at display resolution — the old path + // ceil'd the source depth then rounded again after scaling, + // introducing ≤1-2px anchor drift. // - // For depth-zero formulas (size[2]==0) this is identical to BOTTOM. - int depthDisplay = scaleSourceMetricRound(sourceDepthPx, lineHeight); + // For depth-zero formulas this is identical to BOTTOM. + int depthDisplay = scaleSourceDepthFromBaseline(sourceBaseLineRatio, formulaDisplayH); yield lineHeight - formulaDisplayH + depthDisplay; } default -> 0; // TOP @@ -116,6 +227,13 @@ protected LytRect computeLayout(LayoutContext context, int x, int y, int availab int topInset = Math.max(0, -desiredRenderYOffset); int bottomInset = Math.max(0, desiredRenderYOffset); renderYOffset = desiredRenderYOffset + topInset; + // Ascent above the text baseline, in the same units the Rust inline + // post-pass anchors with: for BASELINE this is the box-top-to-math- + // baseline distance (displayH - depthDisplay, depthDisplay including + // the scaled bottom inset), so the texture's math baseline lands on the + // text baseline; the algebra also covers TOP/CENTER/BOTTOM via their + // align offsets. + baselineAscent = lineHeight - desiredRenderYOffset; return new LytRect(x, y - topInset, formulaDisplayW, topInset + formulaDisplayH + bottomInset); } @@ -125,35 +243,145 @@ private boolean resolveSourceMetrics() { return sourceWidthPx > 0 && sourceHeightPx > 0; } sourceMetricsResolved = true; - int[] size = GuideLatexRenderer.INSTANCE.measureSize(formula, fillColorArgb, sourceScale); + int[] size = GuideLatexRenderer.INSTANCE.measureSize(formula, fillColorArgb, sourceScale, style); if (size == null) { return false; } sourceWidthPx = size[0]; sourceHeightPx = size[1]; - sourceDepthPx = size[2]; sourceRefHeightPx = GuideLatexRenderer.INSTANCE.calibrateRefHeight(sourceScale); + sourceBaseLineRatio = GuideLatexRenderer.INSTANCE.measureBaselineRatio(formula, fillColorArgb, sourceScale, style); return sourceWidthPx > 0 && sourceHeightPx > 0; } - private int scaleSourceMetricCeil(int sourceMetric, int lineHeight) { - return (int) Math.max(1, Math.ceil((double) sourceMetric * lineHeight * userScale / sourceRefHeightPx)); + /** + * Body size the inline formula calibrates against: a source "x" must + * display at the surrounding text's x-height, not at the full line height + * (the previous lineHeight target made inline formulas ≈ lineHeight / + * x-height ≈ 1.43× larger than body text) and not at the font ascent + * ({@link GuideText#ascent()} is the ascent ≈0.75-0.85em, which still + * leaves formula letters ≈1.4-1.6× larger than the ≈0.5em x-height). + * + *

The inline flow carries no style context (the line height is queried + * with a {@code null} style, i.e. font scale 1), so the target is + * {@link GuideText#xHeight()} at the base font scale. + * + *

The exact x-height target is then multiplied by + * {@link #INLINE_PERCEPTUAL_FACTOR} (×1.2): matching the raw x-height was + * still perceptually too small next to CJK body text, because TeX math + * glyphs follow their own design conventions (a lower x-height relative to + * the em than most body fonts), so formula body letters need a small + * upward nudge to read as the same visual weight as the surrounding text + * (user report: "公式字体过小"). + */ + private float inlineCalibrationTarget() { + return GuideText.xHeight() * INLINE_PERCEPTUAL_FACTOR; } - private int scaleSourceMetricRound(int sourceMetric, int lineHeight) { - return (int) Math.round((double) sourceMetric * lineHeight * userScale / sourceRefHeightPx); + /** + * Display pixels per source-content pixel for this block: the calibration + * "x" content height (sourceRefHeightPx minus the true 2px/side icon + * insets applied by {@code GuideLatexRenderer#setInsets(new Insets(2,2,2,2), true)}) + * maps to the body x-height × {@link #INLINE_PERCEPTUAL_FACTOR} × userScale. + * Keeping the insets out of the ratio avoids the fixed +4px padding + * distorting the scale once the target is the smaller x-height — with the + * old full-height ratio a simple inline formula's box matched the line + * height instead of the x-height (≈ lineHeight / x-height ≈ 1.43× too + * large). Note the two-arg inset call is mandatory: the single-arg + * {@code setInsets(Insets)} adds a phantom {@code (int)(0.18f*size)} per + * side, which made this subtraction undershoot the real content by 36px + * and shrank inline formulas to ≈0.67× the body x-height. + */ + private float inlineScaleFactor() { + float contentRefHeight = Math.max(1f, sourceRefHeightPx - LATEX_INSET_PX); + return inlineCalibrationTarget() * userScale / contentRefHeight; + } + + /** + * Scales an icon metric (width/height, insets included) to display pixels. + * The whole source icon (glyph content + the symmetric 2px/side insets of + * {@code setInsets(new Insets(2,2,2,2), true)}) is scaled in a single + * ceil: the texture is blitted with full UV coverage into a + * {@code displayW}×{@code displayH} box, so the display box is exactly + * the uniform scale of the source icon. One ceil over the whole icon + * replaces the old double rounding (content ceil + separately rounded + * scaled inset) and can never clip the glyph. + */ + private int scaleSourceMetricCeil(int sourceMetric, float scaleFactor) { + return Math.max(1, (int) Math.ceil(sourceMetric * scaleFactor)); + } + + /** + * Display distance from the formula's math baseline to the icon bottom, + * derived directly from the exact jlatexmath baseline ratio instead of a + * source-pixel depth. {@link TeXIcon#getBaseLine()} returns the distance + * from the icon's top edge to its math baseline as a fraction of the + * icon's total height (the true 2px/side insets of the two-arg + * {@code setInsets(insets, true)} included), so the math baseline sits + * {@code formulaDisplayH × (1 - ratio)} above the bottom of the uniformly + * scaled display box. This is rounded exactly once, at display resolution + * — the old path computed + * {@code round(displayH × (ceil(getTrueIconDepth()) + 2) / sourceHeightPx)}, + * which ceil'd the source depth first and then rounded the scaled result, + * a double rounding that drifted the anchor by ≤1-2px. It also replaces + * the old depth-plus-bottom-inset bookkeeping: the insets are already part + * of the icon height the ratio is measured against. + */ + private int scaleSourceDepthFromBaseline(float baseLineRatio, int formulaDisplayH) { + return Math.max(0, (int) Math.round(formulaDisplayH * (1f - baseLineRatio))); } @Override protected void onLayoutMoved(int deltaX, int deltaY) {} + /** + * External (Rust) layout anchors the block's bounds at the formula's visual + * box — the legacy line-expansion insets and render offset no longer apply. + * Zero the offset so the primitive blit and {@link #getVisualBounds()} use + * the bounds origin from now on (the legacy layout path recomputes it on + * the next Java pass before it is needed again). + */ + @Override + protected void afterExternalLayout() { + renderYOffset = 0; + } + + @Override + public boolean usePrimitives() { + return true; + } + + @Override + public void computePrimitives(PrimitiveCollector c) { + if (formulaDisplayW <= 0 || formulaDisplayH <= 0) { + return; + } + + int[] tex = GuideLatexRenderer.INSTANCE.getOrCreateTexture(formula, fillColorArgb, sourceScale, style); + if (tex == null) { + return; + } + + c.emit( + new GuideRenderPrimitive.BlitTexture( + tex[0], + bounds.x() + offsetX, + bounds.y() + renderYOffset, + formulaDisplayW, + formulaDisplayH, + 0f, + 0f, + 1f, + 1f)); + } + @Override public void render(RenderContext context) { if (formulaDisplayW <= 0 || formulaDisplayH <= 0) { return; } - int[] tex = GuideLatexRenderer.INSTANCE.getOrCreateTexture(formula, fillColorArgb, sourceScale); + int[] tex = GuideLatexRenderer.INSTANCE.getOrCreateTexture(formula, fillColorArgb, sourceScale, style); if (tex == null) { return; } diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytLatexDisplayBlock.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytLatexDisplayBlock.java index a108fe46..bd0ce2e9 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytLatexDisplayBlock.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytLatexDisplayBlock.java @@ -3,13 +3,21 @@ import java.util.Optional; import org.jetbrains.annotations.Nullable; +import org.scilab.forge.jlatexmath.TeXConstants; import com.hfstudio.guidenh.guide.document.LytRect; import com.hfstudio.guidenh.guide.document.interaction.GuideTooltip; import com.hfstudio.guidenh.guide.document.interaction.InteractiveElement; import com.hfstudio.guidenh.guide.latex.GuideLatexRenderer; import com.hfstudio.guidenh.guide.layout.LayoutContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.GuideText; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.render.RenderContext; +import com.hfstudio.guidenh.guide.style.token.DimensionValue; +import com.hfstudio.guidenh.guide.style.token.GuideThemeManager; +import com.hfstudio.guidenh.guide.style.token.TokenKey; +import com.hfstudio.guidenh.guide.style.token.TokenType; import lombok.Getter; @@ -22,7 +30,16 @@ */ public class LytLatexDisplayBlock extends LytBlock implements InteractiveElement { - private static final int VERTICAL_MARGIN = 4; + /** Theme token: vertical margin above and below a display formula. */ + private static final TokenKey VERTICAL_MARGIN = TokenKey + .define("--lyt-latex-display-vertical-margin", TokenType.DIMENSION, DimensionValue.px(4)); + + private static int verticalMargin() { + return GuideThemeManager.instance() + .active() + .dim(VERTICAL_MARGIN) + .pxInt(); + } @Getter private final String formula; @@ -32,6 +49,7 @@ public class LytLatexDisplayBlock extends LytBlock implements InteractiveElement private final float sourceScale; @Getter private final float userScale; + private final int style; @Nullable private final GuideTooltip tooltip; @Getter @@ -43,12 +61,15 @@ public class LytLatexDisplayBlock extends LytBlock implements InteractiveElement private int formulaDisplayW; /** Cached formula display height (pixels in GUI units), set during layout. */ private int formulaDisplayH; + /** True when lazy computation has been attempted (even if result is 0). */ + private boolean formulaDisplayComputed; public LytLatexDisplayBlock(String formula, int fillColorArgb, float sourceScale, float userScale, @Nullable GuideTooltip tooltip, int offsetX, int offsetY) { this( formula, new LatexRenderOptions( + TeXConstants.STYLE_DISPLAY, fillColorArgb, sourceScale, userScale, @@ -63,45 +84,129 @@ public LytLatexDisplayBlock(String formula, LatexRenderOptions options) { this.fillColorArgb = options.fillColorArgb(); this.sourceScale = options.sourceScale(); this.userScale = options.userScale(); + this.style = options.style(); this.tooltip = options.tooltip(); this.offsetX = options.offsetX(); this.offsetY = options.offsetY(); } + /** + * Returns the formula display width, computing it lazily if no layout pass has been run. + * Uses static font metrics via {@link GuideText} so it works without a {@link LayoutContext}. + */ + public int getFormulaDisplayW() { + if (!formulaDisplayComputed) { + computeFormulaDisplay(); + } + return formulaDisplayW; + } + + /** + * Returns the formula display height, computing it lazily if no layout pass has been run. + * Uses static font metrics via {@link GuideText} so it works without a {@link LayoutContext}. + */ + public int getFormulaDisplayH() { + if (!formulaDisplayComputed) { + computeFormulaDisplay(); + } + return formulaDisplayH; + } + + /** + * Display pixels per source-content pixel for this block, unified with the + * inline calibration standard (see {@link LytLatexBlock#inlineScaleFactor()}): + * the calibration "x" content height (refH minus the true 2px/side icon + * insets applied by {@code GuideLatexRenderer#setInsets(new Insets(2,2,2,2), true)}) + * maps to the body x-height × {@code INLINE_PERCEPTUAL_FACTOR} × userScale. + * Display and inline formulas therefore share one calibration target (body + * x-height × 1.2), matching the mature convention (MathJax/KaTeX/LaTeX) where + * display and inline math render at the same size and only the internal + * layout differs (handled by the jlatexmath style, not here). + */ + private float displayScaleFactor() { + int refH = GuideLatexRenderer.INSTANCE.calibrateRefHeight(sourceScale); + float contentRefHeight = Math.max(1f, refH - LytLatexBlock.LATEX_INSET_PX); + return GuideText.xHeight() * LytLatexBlock.INLINE_PERCEPTUAL_FACTOR * userScale / contentRefHeight; + } + + /** Lazy-compute formula display dimensions using static font metrics. */ + private void computeFormulaDisplay() { + formulaDisplayComputed = true; + int[] size = GuideLatexRenderer.INSTANCE.measureSize(formula, fillColorArgb, sourceScale, style); + if (size == null) { + formulaDisplayW = 0; + formulaDisplayH = 0; + return; + } + float scaleFactor = displayScaleFactor(); + formulaDisplayH = Math.max(1, (int) Math.ceil(size[1] * scaleFactor)); + formulaDisplayW = Math.max(1, (int) Math.ceil(size[0] * scaleFactor)); + } + @Override protected LytRect computeLayout(LayoutContext context, int x, int y, int availableWidth) { - int[] size = GuideLatexRenderer.INSTANCE.measureSize(formula, fillColorArgb, sourceScale); + formulaDisplayComputed = true; + int[] size = GuideLatexRenderer.INSTANCE.measureSize(formula, fillColorArgb, sourceScale, style); if (size == null) { formulaDisplayW = 0; formulaDisplayH = 0; return new LytRect(x, y, availableWidth, 0); } - int lineHeight = context.getLineHeight(null); - int refH = GuideLatexRenderer.INSTANCE.calibrateRefHeight(sourceScale); - - formulaDisplayH = (int) Math.max(1, Math.ceil((double) size[1] * lineHeight * userScale / refH)); - formulaDisplayW = (int) Math.max(1, Math.ceil((double) size[0] * lineHeight * userScale / refH)); + float scaleFactor = displayScaleFactor(); + formulaDisplayH = Math.max(1, (int) Math.ceil(size[1] * scaleFactor)); + formulaDisplayW = Math.max(1, (int) Math.ceil(size[0] * scaleFactor)); - return new LytRect(x, y, availableWidth, formulaDisplayH + 2 * VERTICAL_MARGIN); + return new LytRect(x, y, availableWidth, formulaDisplayH + 2 * verticalMargin()); } @Override protected void onLayoutMoved(int deltaX, int deltaY) {} + @Override + public boolean usePrimitives() { + return true; + } + + @Override + public void computePrimitives(PrimitiveCollector c) { + if (formulaDisplayW <= 0 || formulaDisplayH <= 0) { + return; + } + + int[] tex = GuideLatexRenderer.INSTANCE.getOrCreateTexture(formula, fillColorArgb, sourceScale, style); + if (tex == null) { + return; + } + + int centeredX = bounds.x() + (bounds.width() - formulaDisplayW) / 2; + int formulaY = bounds.y() + verticalMargin(); + c.emit( + new GuideRenderPrimitive.BlitTexture( + tex[0], + centeredX + offsetX, + formulaY + offsetY, + formulaDisplayW, + formulaDisplayH, + 0f, + 0f, + 1f, + 1f)); + } + @Override public void render(RenderContext context) { if (formulaDisplayW <= 0 || formulaDisplayH <= 0) { return; } - int[] tex = GuideLatexRenderer.INSTANCE.getOrCreateTexture(formula, fillColorArgb, sourceScale); + int[] tex = GuideLatexRenderer.INSTANCE.getOrCreateTexture(formula, fillColorArgb, sourceScale, style); if (tex == null) { return; } int centeredX = bounds.x() + (bounds.width() - formulaDisplayW) / 2; - int formulaY = bounds.y() + VERTICAL_MARGIN; + int formulaY = bounds.y() + verticalMargin(); GuideLatexRenderer.INSTANCE .renderLatex(centeredX + offsetX, formulaY + offsetY, formulaDisplayW, formulaDisplayH, tex[0]); } @@ -130,7 +235,7 @@ public LytRect getVisualBounds() { return bounds != null ? bounds : LytRect.empty(); } int centeredX = bounds.x() + (bounds.width() - formulaDisplayW) / 2; - int formulaY = bounds.y() + VERTICAL_MARGIN; + int formulaY = bounds.y() + verticalMargin(); return new LytRect(centeredX + offsetX, formulaY + offsetY, formulaDisplayW, formulaDisplayH); } diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytList.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytList.java index 5f20a29c..34e1bdb0 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytList.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytList.java @@ -1,5 +1,8 @@ package com.hfstudio.guidenh.guide.document.block; +import com.hfstudio.guidenh.guide.compiler.PageCompiler; +import com.hfstudio.guidenh.guide.document.LytRect; +import com.hfstudio.guidenh.guide.layout.LayoutContext; import lombok.Getter; @Getter @@ -11,6 +14,8 @@ public class LytList extends LytVBox { public LytList(boolean ordered, int start) { this.ordered = ordered; this.start = start; + setMarginTop(PageCompiler.DEFAULT_ELEMENT_SPACING); + setMarginBottom(PageCompiler.DEFAULT_ELEMENT_SPACING); } public int getDepth() { @@ -23,4 +28,20 @@ public int getDepth() { return depth; } + @Override + protected LytRect computeBoxLayout(LayoutContext context, int x, int y, int availableWidth) { + // Manual layout path — only reached from layoutContentSubtree for Mermaid + // NodeContent (no Rust pass). Lay out children (LytListItems) vertically + // and return accumulated bounds. Normal document pipeline bypasses this + // (Rust is the authoritative layout engine). + int cursorY = y; + int maxWidth = 0; + for (LytBlock child : children) { + var childBounds = child.layout(context, x, cursorY, availableWidth); + cursorY += childBounds.height(); + maxWidth = Math.max(maxWidth, childBounds.width()); + } + return new LytRect(x, y, maxWidth, Math.max(0, cursorY - y)); + } + } diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytListItem.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytListItem.java index 0077bfff..d4f82130 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytListItem.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytListItem.java @@ -1,17 +1,27 @@ package com.hfstudio.guidenh.guide.document.block; +import com.hfstudio.guidenh.guide.color.LightDarkMode; import com.hfstudio.guidenh.guide.color.SymbolicColor; import com.hfstudio.guidenh.guide.document.DefaultStyles; import com.hfstudio.guidenh.guide.document.LytRect; import com.hfstudio.guidenh.guide.layout.LayoutContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.GuideText; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.render.RenderContext; import com.hfstudio.guidenh.guide.style.ResolvedTextStyle; public class LytListItem extends LytVBox { public static final int LEVEL_MARGIN = 10; - private static final int BULLET_SIZE = 2; - private static final int BULLET_X_OFFSET = 5; + private static final int BULLET_SIZE = 3; + /** + * Shared marker gutter: both the unordered bullet and the ordered number + * right-align to this line (bounds.x() + LEVEL_MARGIN - MARKER_GUTTER_OFFSET), + * so every marker hangs from one vertical line and the text starts uniformly + * at bounds.x() + LEVEL_MARGIN (the item's content box via paddingLeft). + */ + private static final int MARKER_GUTTER_OFFSET = 5; private final ResolvedTextStyle style = DefaultStyles.BODY_TEXT.mergeWith(DefaultStyles.BASE_STYLE); @@ -22,9 +32,39 @@ public class LytListItem extends LytVBox { */ private int cachedOrderedNumber = -1; + public LytListItem() { + // paddingLeft is read by the Rust layout engine and creates the content + // indentation (replaces the legacy computeBoxLayout's x+margin pass). + // Markers are drawn relative to the border box (getBounds()) and land in + // the padding slot left of the content — matching the old render() semantics. + setPaddingLeft(LEVEL_MARGIN); + } + @Override protected LytRect computeBoxLayout(LayoutContext context, int x, int y, int availableWidth) { - // Compute and cache the ordered item number once per layout pass. + // Manual layout path — only reached from layoutContentSubtree for Mermaid + // NodeContent (no Rust pass). paddingLeft (LEVEL_MARGIN) is already + // applied by LytBox.computeLayout before this method; the extra margin + // below creates content indentation leaving the bullet/number zone + // visible. Normal document pipeline bypasses this (Rust is authoritative). + var margin = LEVEL_MARGIN; + int cursorY = y; + int contentAvailWidth = Math.max(1, availableWidth - margin); + int maxContentWidth = 0; + for (LytBlock child : children) { + var childBounds = child.layout(context, x + margin, cursorY, contentAvailWidth); + cursorY += childBounds.height(); + maxContentWidth = Math.max(maxContentWidth, childBounds.width()); + } + int contentHeight = Math.max(0, cursorY - y); + return new LytRect(x, y, maxContentWidth + margin, contentHeight); + } + + @Override + protected void afterExternalLayout() { + super.afterExternalLayout(); + // Compute ordered item number from parent list (rendering reads + // cachedOrderedNumber; avoid sibling scan every frame). if (parent instanceof LytList list && list.isOrdered()) { int number = list.getStart(); for (var child : list.getChildren()) { @@ -35,29 +75,75 @@ protected LytRect computeBoxLayout(LayoutContext context, int x, int y, int avai } else { cachedOrderedNumber = -1; } - var margin = LEVEL_MARGIN; - var bounds = super.computeBoxLayout(context, x + margin, y, availableWidth - margin); - return bounds.expand(LEVEL_MARGIN, 0, 0, 0); } @Override - public void render(RenderContext context) { + public void computePrimitives(PrimitiveCollector c) { + super.computePrimitives(c); + if (hasOwnMarker()) { + // Subclasses with a custom gutter marker (e.g. the task checkbox) + // draw it themselves; skip the shared bullet/number so both never + // paint the same slot. + return; + } if (cachedOrderedNumber >= 0) { String label = cachedOrderedNumber + "."; - var width = context.getWidth(label, style); + int width = GuideText.measureWidth(label, style); var bounds = getBounds(); - var x = bounds.x() + LEVEL_MARGIN - width - 2; - context.drawText(label, x, bounds.y(), style); + var markerLine = getMarkerLineBounds(); + // Right-aligned to the shared marker gutter: the number's right + // edge lands on bounds.x() + LEVEL_MARGIN - MARKER_GUTTER_OFFSET, + // the same hanging line the unordered bullet right-aligns to. + int x = bounds.x() + LEVEL_MARGIN - width - MARKER_GUTTER_OFFSET; + c.emit(new GuideRenderPrimitive.DrawText(label, x, markerLine.y(), style)); } else { var bounds = getBounds(); - var markerLine = getMarkerLineBounds(context); + var markerLine = getMarkerLineBounds(); int bulletY = markerLine.y() + (markerLine.height() - BULLET_SIZE) / 2; - context.fillRect(bounds.x() + BULLET_X_OFFSET, bulletY, BULLET_SIZE, BULLET_SIZE, SymbolicColor.BODY_TEXT); + int argb = SymbolicColor.BODY_TEXT.resolve(LightDarkMode.current()); + // Right-align the bullet to the same hanging line as ordered + // numbers (LEVEL_MARGIN - MARKER_GUTTER_OFFSET), so both marker + // types share one gutter and text starts uniformly at LEVEL_MARGIN. + int bulletX = bounds.x() + LEVEL_MARGIN - MARKER_GUTTER_OFFSET - BULLET_SIZE; + c.emit(new GuideRenderPrimitive.FillRect(bulletX, bulletY, BULLET_SIZE, BULLET_SIZE, argb)); + } + } + + @Override + public void render(RenderContext context) { + if (!hasOwnMarker()) { + if (cachedOrderedNumber >= 0) { + String label = cachedOrderedNumber + "."; + var width = context.getWidth(label, style); + var bounds = getBounds(); + var markerLine = getMarkerLineBounds(context); + // Same shared-gutter anchor as computePrimitives: right edge at + // bounds.x() + LEVEL_MARGIN - MARKER_GUTTER_OFFSET. + var x = bounds.x() + LEVEL_MARGIN - width - MARKER_GUTTER_OFFSET; + context.drawText(label, x, markerLine.y(), style); + } else { + var bounds = getBounds(); + var markerLine = getMarkerLineBounds(context); + int bulletY = markerLine.y() + (markerLine.height() - BULLET_SIZE) / 2; + int bulletX = bounds.x() + LEVEL_MARGIN - MARKER_GUTTER_OFFSET - BULLET_SIZE; + context.fillRect(bulletX, bulletY, BULLET_SIZE, BULLET_SIZE, SymbolicColor.BODY_TEXT); + } } super.render(context); } - private LytRect getMarkerLineBounds(RenderContext context) { + /** + * Whether this list item draws its own gutter marker (e.g. the task + * checkbox) instead of the shared bullet / ordered number. Subclasses with + * a custom marker must override to return {@code true} so {@link + * #computePrimitives(PrimitiveCollector)} and {@link #render(RenderContext)} + * skip the shared marker slot (both would otherwise double-draw). + */ + protected boolean hasOwnMarker() { + return false; + } + + protected LytRect getMarkerLineBounds(RenderContext context) { if (!children.isEmpty()) { LytBlock firstChild = children.getFirst(); if (firstChild instanceof LytParagraph paragraph) { @@ -65,7 +151,7 @@ private LytRect getMarkerLineBounds(RenderContext context) { if (firstTextRun != null) { return firstTextRun; } - LytRect firstLine = paragraph.getFirstLineBounds(); + LytRect firstLine = paragraph.getFirstTextRunBounds(); if (firstLine != null) { return new LytRect(firstLine.x(), firstLine.y(), firstLine.width(), context.getLineHeight(style)); } @@ -75,4 +161,24 @@ private LytRect getMarkerLineBounds(RenderContext context) { LytRect bounds = getBounds(); return new LytRect(bounds.x(), bounds.y(), bounds.width(), context.getLineHeight(style)); } + + /** Context-free overload for use in {@link #computePrimitives}. */ + protected LytRect getMarkerLineBounds() { + if (!children.isEmpty()) { + LytBlock firstChild = children.getFirst(); + if (firstChild instanceof LytParagraph paragraph) { + LytRect firstTextRun = paragraph.getFirstTextRunBounds(); + if (firstTextRun != null) { + return firstTextRun; + } + LytRect firstLine = paragraph.getFirstTextRunBounds(); + if (firstLine != null) { + return new LytRect(firstLine.x(), firstLine.y(), firstLine.width(), GuideText.lineHeight(style)); + } + } + return firstChild.getBounds(); + } + LytRect bounds = getBounds(); + return new LytRect(bounds.x(), bounds.y(), bounds.width(), GuideText.lineHeight(style)); + } } diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytMermaidCanvas.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytMermaidCanvas.java index eef07d18..8dea989d 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytMermaidCanvas.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytMermaidCanvas.java @@ -1,32 +1,39 @@ package com.hfstudio.guidenh.guide.document.block; +import java.nio.ByteBuffer; import java.util.ArrayList; import java.util.Collections; +import java.util.HashMap; import java.util.IdentityHashMap; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.Optional; -import net.minecraft.item.ItemStack; -import net.minecraft.util.ResourceLocation; - import org.jetbrains.annotations.Nullable; -import org.lwjgl.opengl.GL11; -import com.hfstudio.guidenh.guide.color.ColorValue; import com.hfstudio.guidenh.guide.color.ConstantColor; import com.hfstudio.guidenh.guide.color.LightDarkMode; import com.hfstudio.guidenh.guide.document.LytRect; -import com.hfstudio.guidenh.guide.document.flow.LytFlowContent; import com.hfstudio.guidenh.guide.document.interaction.DocumentDragTarget; import com.hfstudio.guidenh.guide.document.interaction.FlowInteractionPath; import com.hfstudio.guidenh.guide.document.interaction.GuideTooltip; import com.hfstudio.guidenh.guide.document.interaction.InteractiveElement; -import com.hfstudio.guidenh.guide.internal.recipe.LytNeiRecipeBox; +import com.hfstudio.guidenh.guide.internal.util.DisplayScale; import com.hfstudio.guidenh.guide.internal.util.SmoothFloatState; -import com.hfstudio.guidenh.guide.render.GuiSprite; +import com.hfstudio.guidenh.guide.layout.LayoutBridge; +import com.hfstudio.guidenh.guide.layout.LayoutContext; +import com.hfstudio.guidenh.guide.layout.LayoutTreeSerializer; +import com.hfstudio.guidenh.guide.layout.Layouts; +import com.hfstudio.guidenh.guide.layout.flatbuffers.LayoutResult; +import com.hfstudio.guidenh.guide.render.GlyphRunData; +import com.hfstudio.guidenh.guide.render.GlyphRunGroup; +import com.hfstudio.guidenh.guide.render.GlyphRunHolder; +import com.hfstudio.guidenh.guide.render.GuideGlyphAtlas; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.render.RenderContext; +import com.hfstudio.guidenh.guide.scene.support.GuideDebugLog; import com.hfstudio.guidenh.guide.style.ResolvedTextStyle; import com.hfstudio.guidenh.guide.ui.GuideUiHost; @@ -35,12 +42,25 @@ public abstract class LytMermaidCanvas> extends LytBlock implements DocumentDragTarget, InteractiveElement { + private static final boolean HEADLESS = Boolean.getBoolean("guidenh.headlessRender"); + private static final float ZOOM_STEP = 1.1f; private static final float MIN_ZOOM = 0.5f; - private static final float MAX_ZOOM = 2.5f; + private static final float MAX_ZOOM = 5.0f; static final ConstantColor PANEL_BACKGROUND = new ConstantColor(0x1A0C1117); static final ConstantColor PANEL_BORDER = new ConstantColor(0x66434C57); + /** + * Rust layout engine's document content-box padding (layout-engine + * {@code CONTENT_PAD}, layout.rs:17). The engine insets every serialized + * tree by this amount on all sides. A standalone NodeContent subtree + * serialized through {@link #layoutNodeContentWithRust} must therefore + * inflate its requested available width by 2×PAD so the inner content + * width equals {@code contentWidth} — keeping node sizing identical to the + * pre-Rust Java path (LytParagraph used to claim the full availableWidth). + */ + private static final int RUST_CONTENT_PAD = 14; + private int contentOffsetX; private int contentOffsetY; private final SmoothFloatState visualContentOffsetX = new SmoothFloatState(); @@ -55,17 +75,21 @@ public abstract class LytMermaidCanvas> extends Ly private final Map scaledStyleCache = new IdentityHashMap<>(); private float lastScaledStyleZoom = Float.NaN; + /** + * Headless render injection, applied by RenderPageService from + * {@code -Dguidenh.renderpage.mermaidzoom} / {@code -Dguidenh.renderpage.mermaidoffset} + * (mirroring the navscroll injection pattern). Zero zoom and zero offsets + * mean "no injection": the {@code HEADLESS} branch then keeps the + * historical fit-to-view + centre behaviour byte-identical. + */ + private float headlessZoomInjection; + private int headlessOffsetXInjection; + private int headlessOffsetYInjection; + // Common interaction state protected Map nodeContentBlocks; protected int preferredWidth; protected int preferredHeight; - protected int lastPickDocX; - protected int lastPickDocY; - protected boolean lastPickValid; - @Nullable - protected LytParagraph lastFlowHoverParagraph; - @Nullable - protected LytFlowContent lastFlowHoverContent; protected void initNodeContentBlocks(@Nullable Map blocks) { this.nodeContentBlocks = blocks == null ? Collections.emptyMap() : new LinkedHashMap<>(blocks); @@ -76,7 +100,29 @@ protected void initNodeContentBlocks(@Nullable Map blocks) { @Override public List getChildren() { - return new ArrayList<>(nodeContentBlocks.values()); + return List.of(); + } + + @Override + protected LytVisitor.Result visitChildren(LytVisitor visitor, boolean includeOutOfTreeContent) { + if (includeOutOfTreeContent && nodeContentBlocks != null) { + for (LytBlock block : nodeContentBlocks.values()) { + if (block.visit(visitor, true) == LytVisitor.Result.STOP) { + return LytVisitor.Result.STOP; + } + } + } + return LytVisitor.Result.CONTINUE; + } + + @Override + public int getExplicitWidth() { + return preferredWidth > 0 ? preferredWidth : -1; + } + + @Override + public int getExplicitHeight() { + return preferredHeight > 0 ? preferredHeight : -1; } protected abstract int canvasPadding(); @@ -91,15 +137,14 @@ public List getChildren() { protected abstract boolean diagramReady(); - protected abstract void renderDiagram(RenderContext context, int baseX, int baseY, float activeZoom); - protected void renderPanel(RenderContext context) { context.fillRect(bounds, PANEL_BACKGROUND); context.drawBorder(bounds, context.resolveColor(PANEL_BORDER), 1); } - protected void onPreRender() { - refreshFlowHover(); + @Override + public void render(RenderContext context) { + // Unused: subclasses use the primitives path (usePrimitives() == true). } @Nullable @@ -113,9 +158,6 @@ public void setPreferredSize(int width, int height) { @Override public LytNode pickNode(int x, int y) { if (!getBounds().contains(x, y)) return null; - lastPickDocX = x; - lastPickDocY = y; - lastPickValid = true; NodeHit hit = pickNodeHit(x, y); return hit != null ? hit.node() : this; } @@ -163,46 +205,68 @@ public Optional getTooltip(float x, float y) { return Optional.empty(); } - protected void refreshFlowHover() { - if (!lastPickValid || !diagramReady()) return; - NodeHit hit = pickNodeHit(lastPickDocX, lastPickDocY); - LytFlowContent hoveredFlow = null; - LytParagraph hoveredParagraph = null; - if (hit != null) { - for (var content : hit.flowPath() - .targets()) { - if (content instanceof InteractiveElement) { - hoveredFlow = content; - break; - } - } - if (hoveredFlow != null) { - for (LytNode node = hit.node(); node != null; node = node.getParent()) { - if (node instanceof LytParagraph p) { - hoveredParagraph = p; - break; - } - } + /** + * Active zoom used for rendering. + *

+ * Upper ceiling: every path — interactive scroll, direct-write + * {@code snapTo}, and the headless injection branch — is bounded by + * {@link #MAX_ZOOM} on every read. The ceiling guards glyph rasterization: + * an unclamped huge zoom would push fontScale to enormous sizes and + * overflow the glyph atlas pages. + *

+ * Lower floor: interactive zoom and headless zoom injection are + * floored at {@link #MIN_ZOOM}. The headless fit-to-view zoom + * (no injection) is exempt from the floor: it must stay at its exact + * computed value so a diagram larger than the viewport always fits + * (byte-identical no-injection regression). It is always {@code <= 1.0} + * by construction, so only the defensive upper bound applies. + *

+ * Tier quantization: the interactive and headless-injection paths + * snap their value to the nearest {@link #ZOOM_STEP}^n tier (scroll steps + * are themselves powers of {@link #ZOOM_STEP}, so targets are natively + * near-tier). Quantizing the easing intermediate values keeps the fontScale + * — and therefore the GuideText shape cache key — stable during a zoom + * animation instead of changing every frame (the per-frame re-rasterize / + * per-glyph re-upload churn that collapsed the frame rate). The + * no-injection fit path is exempt: fitZoom is always {@code <= 1.0} and is + * returned unquantized (byte-identical no-injection regression). + */ + public float getActiveZoom() { + if (HEADLESS) { + if (headlessZoomInjection > 0f) { + return quantizeZoom(Math.clamp(zoom, MIN_ZOOM, MAX_ZOOM)); } + // No-injection fit-to-view: exact value, never quantized. + return Math.min(MAX_ZOOM, zoom); } - if (hoveredParagraph != lastFlowHoverParagraph || hoveredFlow != lastFlowHoverContent) { - if (lastFlowHoverParagraph != null) lastFlowHoverParagraph.onMouseLeave(); - if (hoveredParagraph != null) hoveredParagraph.onMouseEnter(hoveredFlow); - lastFlowHoverParagraph = hoveredParagraph; - lastFlowHoverContent = hoveredFlow; - } + float v = visualZoom.value(); + return quantizeZoom(Math.clamp(v > 0f ? v : zoom, MIN_ZOOM, MAX_ZOOM)); } - public float getActiveZoom() { - return visualZoom.value(); + /** + * Quantize a zoom value to the nearest {@code ZOOM_STEP^n} tier (n an + * integer), then clamp the tier back into {@code [MIN_ZOOM, MAX_ZOOM]}. + *

+ * Order is semantically: clamp input, quantize, clamp tier. The final + * clamp guarantees the {@link #MAX_ZOOM} ceiling that guards glyph + * rasterization is never exceeded even when the nearest tier above + * {@code MAX_ZOOM} (1.1^17 ≈ 5.0545) would overshoot it — the returned + * value is always a 1.1^n tier except exactly at the [MIN, MAX] bounds. + */ + private static float quantizeZoom(float value) { + if (value <= 0f) { + return value; + } + double tier = Math.pow(ZOOM_STEP, Math.round(Math.log(value) / Math.log(ZOOM_STEP))); + return (float) Math.clamp(tier, MIN_ZOOM, MAX_ZOOM); } public int getVisualOffsetX() { - return visualContentOffsetX.rounded(); + return HEADLESS ? contentOffsetX : visualContentOffsetX.rounded(); } public int getVisualOffsetY() { - return visualContentOffsetY.rounded(); + return HEADLESS ? contentOffsetY : visualContentOffsetY.rounded(); } public int getScaledOriginX() { @@ -310,6 +374,16 @@ public void setContentOffset(int x, int y) { contentOffsetY = y; } + /** + * Apply headless zoom/offset injection. Zero zoom and zero offsets leave + * the {@code HEADLESS} branch on its historical fit-to-view + centre path. + */ + public void setHeadlessInjection(float zoomInjection, int offsetX, int offsetY) { + this.headlessZoomInjection = zoomInjection; + this.headlessOffsetXInjection = offsetX; + this.headlessOffsetYInjection = offsetY; + } + public int getRawOffsetX() { return contentOffsetX; } @@ -330,32 +404,108 @@ public void clampOffsets() { } @Override - public void render(RenderContext context) { - if (!diagramReady()) return; - onPreRender(); + public void computePrimitives(PrimitiveCollector c) { + // Drive the raw→visual easing chain at the entry of our own primitive + // collection (same pattern as LytCodeBlock driving updateVisualScroll in + // its computePrimitives): wheel-zoom (scroll) and drags write raw zoom / + // contentOffset, and getActiveZoom/getVisualOffsetX/Y read the visual + // side — without a per-frame driver the two stay permanently detached + // and the interaction never reaches the render. HEADLESS mode reads the + // raw values directly and the HEADLESS branch below overrides zoom / + // offset anyway, so this call is a no-op for headless rendering. updateVisualState(); + boolean ready = diagramReady(); + GuideDebugLog.debugAlways("[GuideNH-Mermaid] computePrimitives diagramReady={} bounds={}", + ready, bounds); + if (!ready) return; + LytRect b = getBounds(); + if (b == null) return; + + // Panel background and border + c.emit( + new GuideRenderPrimitive.FillRect( + b.x(), + b.y(), + b.width(), + b.height(), + PANEL_BACKGROUND.resolve(LightDarkMode.current()))); + c.emit( + new GuideRenderPrimitive.DrawBorder( + b.x(), + b.y(), + b.width(), + b.height(), + 1, + 1, + 1, + 1, + PANEL_BORDER.resolve(LightDarkMode.current()))); float activeZoom = getActiveZoom(); - if (Float.compare(lastScaledStyleZoom, activeZoom) != 0) { - scaledStyleCache.clear(); - lastScaledStyleZoom = activeZoom; - } - - renderPanel(context); - LytRect inner = getInnerViewport(); - int baseX = inner.x() + getVisualOffsetX() - getScaledOriginX(); - int baseY = inner.y() + getVisualOffsetY() - getScaledOriginY(); - - context.pushLocalScissor(inner); - try { - renderDiagram(context, baseX, baseY, activeZoom); - } finally { - context.popScissor(); + int offsetX = getVisualOffsetX(); + int offsetY = getVisualOffsetY(); + if (HEADLESS) { + // Headless: fit diagram in viewport with fit-to-view zoom, unless + // a -Dguidenh.renderpage.mermaidzoom / mermaidoffset injection was + // applied via setHeadlessInjection. Without injection the + // historical fit-to-view + centre behaviour is preserved + // byte-identically. + int contentW = contentWidth(); + int contentH = contentHeight(); + if (contentW > 0 && contentH > 0) { + float fitZoom = Math.min(1f, Math.min( + (float) inner.width() / contentW, + (float) inner.height() / contentH)); + zoom = headlessZoomInjection > 0f ? headlessZoomInjection : fitZoom; + // Route the injected zoom through getActiveZoom so it shares the + // [MIN_ZOOM, MAX_ZOOM] clamp (an over-ceiling -D injection is + // clamped to MAX_ZOOM instead of overflowing the atlas pages). + // The no-injection fit-to-view value is preserved exactly (the + // diagram must always fit; byte-identical regression). + activeZoom = getActiveZoom(); + if (headlessZoomInjection > 0f) { + GuideDebugLog.infoAlways( + "[GuideNH-Mermaid] headless zoom injection: requested={} quantized={}", + zoom, activeZoom); + } + } + int scaledContentW = Math.round(contentWidth() * activeZoom); + int scaledContentH = Math.round(contentHeight() * activeZoom); + if (headlessOffsetXInjection != 0 || headlessOffsetYInjection != 0) { + offsetX = headlessOffsetXInjection; + offsetY = headlessOffsetYInjection; + } else { + offsetX = (inner.width() - scaledContentW) / 2; + offsetY = (inner.height() - scaledContentH) / 2; + } } + int baseX = inner.x() + offsetX - getScaledOriginX(); + int baseY = inner.y() + offsetY - getScaledOriginY(); + + // Clip diagram primitives to the inner viewport (prevent overflow to + // subsequent page content). + c.pushScissor(inner.x(), inner.y(), inner.width(), inner.height()); + emitDiagramPrimitives(c, baseX, baseY, activeZoom); + c.popScissor(); } + /** + * Subclasses override to emit diagram-specific primitives (edges, nodes, + * content blocks) after the panel has been emitted. + */ + protected void emitDiagramPrimitives(PrimitiveCollector c, int baseX, int baseY, float activeZoom) {} + protected ResolvedTextStyle getOrScaleStyle(ResolvedTextStyle base, float zoom) { + // The scaled-style cache is keyed by the base style only (not by zoom), + // so it must be invalidated whenever the zoom changes — otherwise the + // text fontScale would keep the stale zoom and text would stop scaling + // in sync with the node boxes. Clearing on zoom change rebuilds the + // cache for the current zoom (cheap: at most a handful of base styles). + if (Float.compare(zoom, lastScaledStyleZoom) != 0) { + lastScaledStyleZoom = zoom; + scaledStyleCache.clear(); + } return MermaidNodeRenderer.getOrScaleStyle(scaledStyleCache, base, zoom); } @@ -370,44 +520,6 @@ public static int scaled(int base, int value, float activeZoom) { return base + Math.round(value * activeZoom); } - protected static boolean usesRawGl(LytBlock block) { - return block instanceof LytLatexBlock || block instanceof LytLatexDisplayBlock - || block instanceof LytItemImage - || block instanceof LytNeiRecipeBox; - } - - protected static void renderContainerDecoration(LytNode container, RenderContext context) { - if (!(container instanceof LytBox box)) return; - LytRect b = container.getBounds(); - if (box.getBackgroundColor() != null) { - context.fillRect(b, box.getBackgroundColor()); - } - int topW = box.getBorderTop() - .width(); - int bottomW = box.getBorderBottom() - .width(); - if (topW > 0) { - context.fillRect( - b.x(), - b.y(), - b.width(), - topW, - context.resolveColor( - box.getBorderTop() - .color())); - } - if (bottomW > 0) { - context.fillRect( - b.x(), - b.bottom() - bottomW, - b.width(), - bottomW, - context.resolveColor( - box.getBorderBottom() - .color())); - } - } - protected static LytRect resolveBlockVisualBounds(LytBlock block) { LytRect[] result = { LytRect.empty() }; block.visit(new LytVisitor() { @@ -457,55 +569,272 @@ protected static int contextLineHeight(ResolvedTextStyle style) { return Math.max(1, Math.round((9 + 1) * style.fontScale())); } - protected void renderNodeContentBlock(LytBlock block, NodeContentRenderContext nodeContext) { - if (block instanceof LytNode container && !container.getChildren() - .isEmpty()) { - for (var child : new ArrayList<>(container.getChildren())) { - if (child instanceof LytBlock childBlock) { - renderNodeContentBlock(childBlock, nodeContext); + protected static LytRect resolveNodeContentRect(NodeContentLayout contentLayout, LytRect nodeRect, int paddingX, + int contentY, float activeZoom) { + int availW = Math.max(1, nodeRect.width() - paddingX * 2); + int availH = Math.max(1, nodeRect.y() + nodeRect.height() - contentY); + return new LytRect( + nodeRect.x() + paddingX, + contentY, + Math.min( + Math.max(1, Math.round(contentLayout.visualBounds().width() * activeZoom)), + availW), + Math.min( + Math.max(1, Math.round(contentLayout.visualBounds().height() * activeZoom)), + availH)); + } + + // ---- primitives-path helpers for node content blocks ---- + + /** + * Lay out a Mermaid NodeContent root block through the Rust layout engine + * — the same serialize → measureLayout → writeback pipeline the main + * document uses ({@code LytDocument.createLayout}). This is required + * because NodeContent subtrees live off the document tree + * ({@code nodeContentBlocks}; {@link #getChildren()} is empty), so they + * never reach the document's Rust pass and their inline blocks keep a zero + * x-position (LytItemImage draws at {@code bounds.x()} → line start). A + * dedicated {@link LayoutTreeSerializer} + {@link LayoutBridge#measureLayout} + * pass runs Rust's inline post-pass on the subtree, which anchors each + * inline block at its paragraph marker's pen position and writes the real x + * back into its bounds. + *

+ * Coordinate system: the FlatLayout/glyph coordinates come back + * relative to the subtree's serialized root (the root sits at the + * engine's {@code CONTENT_PAD} inset — i.e. (14,14) for this subtree). Both + * {@link #resolveBlockVisualBounds} and {@link #emitNodeContentPrimitives} + * consume that same shifted space (the viewport origin subtracts + * {@code visualBounds.x()/y()} while the block/glyph coordinates include + * the identical inset), so the existing viewport translation stays valid + * without any extra offset math. + *

+ * Falls back to the Java manual layout ({@link #layoutContentSubtree}) when + * the native bridge is unavailable (font handle 0) or the measure pass + * fails, so NodeContent stays visible in environments without a loaded + * layout engine. Paragraph glyph runs are wiped before the pass so a failed + * pass never renders stale runs at outdated coordinates. + * + * @param context layout context (font metrics + visual scale) + * @param block the NodeContent root block (usually the LytVBox + * produced by {@code compileNodeContentBlock}) + * @param contentWidth the content width used to lay the block out + */ + protected void layoutNodeContentWithRust(LayoutContext context, LytBlock block, int contentWidth) { + LayoutContext localContext = new LayoutContext(context).withVisualScale(context.getVisualScale()); + // Root's own Java bounds are meaningless (LytVBox.computeBoxLayout is a + // stub), but keep the call so the Java fallback sees the same + // preconditions as before. + block.layout(localContext, 0, 0, contentWidth); + clearGlyphRuns(block); + long fontHandle = LayoutBridge.getFontHandle(); + if (fontHandle != 0) { + try { + var serializer = new LayoutTreeSerializer(); + byte[] input = serializer.serialize( + block, + contentWidth + 2 * RUST_CONTENT_PAD, + localContext.getVisualScale(), + DisplayScale.scaleFactor()); + byte[] result = LayoutBridge.measureLayout(fontHandle, input); + if (result.length > 0) { + var flatResult = LayoutResult.getRootAsLayoutResult(ByteBuffer.wrap(result)); + // Upload unique glyph bitmaps to the shared atlas (keys are + // content-stable, so repeated uploads are no-ops). + var atlas = GuideGlyphAtlas.instance(); + int numBitmaps = flatResult.bitmapsLength(); + for (int bi = 0; bi < numBitmaps; bi++) { + var bmp = flatResult.bitmaps(bi); + if (bmp == null) continue; + int w = (int) bmp.w(); + int h = (int) bmp.h(); + if (w <= 0 || h <= 0) continue; + ByteBuffer rgbaBuf = bmp.rgbaAsByteBuffer(); + byte[] rgba = new byte[rgbaBuf.remaining()]; + rgbaBuf.get(rgba); + if (w > 200 || h > 200) { + GuideDebugLog.warnAlways( + "[GuideNH] OVERSIZE glyph upload source=LytMermaidCanvas key={} w={} h={}", + bmp.key(), w, h); + } + atlas.upload(bmp.key(), rgba, w, h); + } + // Writeback: every serialized subtree block gets its + // Rust-computed bounds (glyph runs and inline blocks + // included). The vector is index-aligned with the + // serializer's flat nodes. + int numLayouts = flatResult.nodesLength(); + for (int i = 0; i < numLayouts; i++) { + var fl = flatResult.nodes(i); + if (fl == null) continue; + LytNode node = serializer.getNodeByFlatIndex(i); + if (!(node instanceof LytBlock lb)) continue; + lb.applyExternalLayout(new LytRect( + Math.round(fl.x()), + Math.round(fl.y()), + Math.max(0, Math.round(fl.w())), + Math.max(0, Math.round(fl.h())))); + } + // Inject glyph runs (final subtree-space quads) and span + // decoration rects into the paragraphs so they render rich + // text exactly like the main document pipeline. + Map> runsByNode = new HashMap<>(); + int numRuns = flatResult.glyphRunsLength(); + for (int ri = 0; ri < numRuns; ri++) { + var fbRun = flatResult.glyphRuns(ri); + if (fbRun == null) continue; + int numGlyphs = fbRun.glyphsLength(); + var placed = new ArrayList(numGlyphs); + for (int gi = 0; gi < numGlyphs; gi++) { + var fbg = fbRun.glyphs(gi); + if (fbg != null) { + placed.add(new GuideRenderPrimitive.PlacedGlyph( + fbg.bitmapKey(), + fbg.x(), + fbg.y(), + fbg.w(), + fbg.h(), + (int) fbg.lineIndex())); + } + } + runsByNode.computeIfAbsent((int) fbRun.nodeIndex(), k -> new ArrayList<>()) + .add(new GlyphRunGroup(placed, (int) fbRun.argb(), fbRun.shear())); + } + Map> backgroundsByNode = new HashMap<>(); + Map> linesByNode = new HashMap<>(); + Map> separatorsByNode = new HashMap<>(); + int numDecorations = flatResult.decorationsLength(); + for (int di = 0; di < numDecorations; di++) { + var d = flatResult.decorations(di); + if (d == null) continue; + var rect = new GuideRenderPrimitive.FillRect( + Math.round(d.x()), + Math.round(d.y()), + Math.round(d.w()), + Math.round(d.h()), + (int) d.argb()); + if (d.kind() == 3) { + separatorsByNode.computeIfAbsent((int) d.node(), k -> new ArrayList<>()) + .add(rect); + } else if (d.kind() == 0) { + backgroundsByNode.computeIfAbsent((int) d.node(), k -> new ArrayList<>()) + .add(rect); + } else { + linesByNode.computeIfAbsent((int) d.node(), k -> new ArrayList<>()) + .add(rect); + } + } + for (var entry : runsByNode.entrySet()) { + LytNode node = serializer.getNodeByFlatIndex(entry.getKey()); + if (node instanceof GlyphRunHolder holder) { + holder.setGlyphData(new GlyphRunData( + entry.getValue(), + backgroundsByNode.getOrDefault(entry.getKey(), List.of()), + linesByNode.getOrDefault(entry.getKey(), List.of()), + separatorsByNode.getOrDefault(entry.getKey(), List.of()))); + } + } + // Post pass: blocks that derive state from children's final + // bounds (e.g. ordered-list numbers) re-apply it now. + for (int i = 0; i < numLayouts; i++) { + LytNode node = serializer.getNodeByFlatIndex(i); + if (node instanceof LytBlock lb) { + lb.afterExternalLayout(); + } + } + return; } + } catch (Exception e) { + GuideDebugLog.warnAlways( + "[GuideNH-Mermaid] NodeContent Rust layout failed; falling back to Java layout", e); } - renderContainerDecoration(container, nodeContext); - } else if (usesRawGl(block)) { - GL11.glPushMatrix(); - GL11.glTranslatef(nodeContext.getDocumentOriginX(), nodeContext.getDocumentOriginY(), 0f); - GL11.glScalef(nodeContext.getScale(), nodeContext.getScale(), 1f); - try { - block.render(nodeContext); - } finally { - GL11.glPopMatrix(); + } + // Fallback: Java manual layout (the LytVBox stub is not a real pass). + layoutContentSubtree(localContext, block, contentWidth); + } + + /** + * Recursively lay out all LytVBox containers inside {@code block}, + * including nested ones (LytList / LytListItem / LytVBox), so every block + * in the subtree obtains non-empty bounds visible to + * {@link #resolveBlockVisualBounds} and the primitive collector. This is + * the Java fallback used when the Rust layout engine is unavailable — the + * normal document pipeline and the NodeContent Rust pass never reach it. + *

+ * Uses post-order traversal: subtrees are laid out first, then + * siblings are positioned via {@link Layouts#verticalLayout}. This ordering + * is required because {@link LytList} and {@link LytListItem} have real + * {@code computeBoxLayout} that recursively lay out children; a pre-order + * pass would re-layout those children a second time at incorrect + * coordinates (offset relative to 0 instead of the parent's actual Y + * position). + */ + protected static void layoutContentSubtree(LayoutContext context, LytBlock block, int contentWidth) { + if (!(block instanceof LytVBox vbox)) return; + List blockChildren = new ArrayList<>(); + for (LytNode child : vbox.getChildren()) { + if (child instanceof LytBlock b) blockChildren.add(b); + } + if (blockChildren.isEmpty()) return; + // Post-order: lay out child subtrees before positioning siblings. + for (LytBlock child : blockChildren) { + layoutContentSubtree(context, child, contentWidth); + } + // Content VBox created by compileNodeContentBlock has default + // padding (0), gap (0), and alignItems (START). + Layouts.verticalLayout(context, blockChildren, + 0, 0, contentWidth, + 0, 0, 0, 0, + vbox.getGap(), vbox.getAlignItems()); + } + + /** + * Recursively wipe glyph runs in the subtree so a failed Rust pass never + * leaves stale runs rendering at outdated coordinates (mirrors + * {@code LytDocument.clearGlyphRuns}). + */ + private static void clearGlyphRuns(LytBlock block) { + if (block instanceof GlyphRunHolder holder) { + holder.setGlyphData(null); + } + for (LytNode child : block.getChildren()) { + if (child instanceof LytBlock childBlock) { + clearGlyphRuns(childBlock); } - } else { - block.render(nodeContext); } } - protected final void renderNodeContent(RenderContext context, LytBlock block, LytRect contentViewport, + /** + * Emit primitives for a node content block using the collector, replacing + * the legacy NodeContentRenderContext path. The block is rendered inside + * a PushTransform/PopTransform frame so its local coordinates map to the + * correct screen position. + */ + protected void emitNodeContentPrimitives(PrimitiveCollector c, LytBlock block, LytRect contentViewport, LytRect visualBounds, float activeZoom) { LytRect innerViewport = getInnerViewport(); LytRect clip = intersect(innerViewport, contentViewport); if (clip == null) return; - context.pushLocalScissor(clip); - try { - int originX = contentViewport.x() - Math.round(visualBounds.x() * activeZoom); - int originY = contentViewport.y() - Math.round(visualBounds.y() * activeZoom); - NodeContentRenderContext nodeContext = new NodeContentRenderContext( - context, - clip, - originX, - originY, - activeZoom); - renderNodeContentBlock(block, nodeContext); - } finally { - context.popScissor(); - } - } - - protected static LytRect resolveNodeContentRect(NodeContentLayout contentLayout, LytRect nodeRect, int paddingX, - int contentY, float activeZoom) { - return new LytRect( - nodeRect.x() + paddingX, - contentY, + int originX = contentViewport.x() - Math.round(visualBounds.x() * activeZoom); + int originY = contentViewport.y() - Math.round(visualBounds.y() * activeZoom); + c.pushScissor(clip.x(), clip.y(), clip.width(), clip.height()); + c.pushTransform(originX, originY, activeZoom); + c.collectFrom(block); + c.popTransform(); + c.popScissor(); + } + + /** + * Overload that prepares the content viewport from a NodeContentLayout + * and a screen-space content area, then renders the block clipped to + * {@code innerViewport ∩ contentArea} (the node's inner content boundary, + * NOT the centered contentViewport) to prevent text overflow beyond the + * node bounds. + */ + protected void emitNodeContentPrimitives(PrimitiveCollector c, NodeContentLayout contentLayout, + LytRect contentArea, float activeZoom) { + LytRect rawViewport = new LytRect( + contentArea.x(), + contentArea.y(), Math.max( 1, Math.round( @@ -516,6 +845,27 @@ protected static LytRect resolveNodeContentRect(NodeContentLayout contentLayout, Math.round( contentLayout.visualBounds() .height() * activeZoom))); + int cvpX = rawViewport.x(); + int cvpY = rawViewport.y(); + if (rawViewport.width() < contentArea.width()) { + cvpX = contentArea.x() + (contentArea.width() - rawViewport.width()) / 2; + } + if (rawViewport.height() < contentArea.height()) { + cvpY = contentArea.y() + (contentArea.height() - rawViewport.height()) / 2; + } + LytRect contentViewport = new LytRect(cvpX, cvpY, rawViewport.width(), rawViewport.height()); + // Scissor uses node contentArea (not centered contentViewport) to + // prevent text overflow beyond the node's inner boundary. + LytRect innerViewport = getInnerViewport(); + LytRect clip = intersect(innerViewport, contentArea); + if (clip == null) return; + int originX = contentViewport.x() - Math.round(contentLayout.visualBounds().x() * activeZoom); + int originY = contentViewport.y() - Math.round(contentLayout.visualBounds().y() * activeZoom); + c.pushScissor(clip.x(), clip.y(), clip.width(), clip.height()); + c.pushTransform(originX, originY, activeZoom); + c.collectFrom(contentLayout.block()); + c.popTransform(); + c.popScissor(); } public record NodeHit(LytNode node, FlowInteractionPath flowPath, int localX, int localY) { @@ -536,305 +886,4 @@ public NodeContentLayout(LytBlock block, LytRect visualBounds) { } } - public static class NodeContentRenderContext implements RenderContext { - - private final RenderContext delegate; - private final LytRect viewport; - private final int originX; - private final int originY; - private final float scale; - private final Map scaledStyleCache = new IdentityHashMap<>(); - - public NodeContentRenderContext(RenderContext delegate, LytRect viewport, int originX, int originY, - float scale) { - this.delegate = delegate; - this.viewport = new LytRect( - 0, - 0, - Math.max(1, Math.round(viewport.width() / scale)), - Math.max(1, Math.round(viewport.height() / scale))); - this.originX = originX; - this.originY = originY; - this.scale = Math.max(0.0001f, scale); - } - - public float getScale() { - return scale; - } - - @Override - public LightDarkMode lightDarkMode() { - return delegate.lightDarkMode(); - } - - @Override - public LytRect viewport() { - return viewport; - } - - @Override - public int getDocumentOriginX() { - return originX; - } - - @Override - public int getDocumentOriginY() { - return originY; - } - - @Override - public LytRect toScreenRect(LytRect rect) { - LytRect s = scaleRect(rect); - return new LytRect( - s.x() + delegate.getDocumentOriginX(), - s.y() + delegate.getDocumentOriginY() - delegate.getScrollOffsetY(), - s.width(), - s.height()); - } - - @Override - public int resolveColor(ColorValue ref) { - return delegate.resolveColor(ref); - } - - @Override - public void fillRect(LytRect rect, int argbColor) { - delegate.fillRect(scaleRect(rect), argbColor); - } - - @Override - public void fillRect(int x, int y, int width, int height, int argbColor) { - delegate.fillRect(scaleX(x), scaleY(y), scaleLength(width), scaleLength(height), argbColor); - } - - @Override - public void drawBorder(LytRect rect, int argbColor, int thickness) { - delegate.drawBorder(scaleRect(rect), argbColor, Math.max(1, scaleLength(thickness))); - } - - @Override - public void drawBorder(int x, int y, int width, int height, int argbColor, int thickness) { - delegate.drawBorder( - scaleX(x), - scaleY(y), - scaleLength(width), - scaleLength(height), - argbColor, - Math.max(1, scaleLength(thickness))); - } - - @Override - public void drawText(String text, int x, int y, ResolvedTextStyle style) { - delegate.drawText(text, scaleX(x), scaleY(y), scaleStyle(style)); - } - - @Override - public int getStringWidth(String text, ResolvedTextStyle style) { - return scaleLength(delegate.getStringWidth(text, style)); - } - - @Override - public int getLineHeight(ResolvedTextStyle style) { - return scaleLength(delegate.getLineHeight(style)); - } - - @Override - public void renderItem(ItemStack stack, int x, int y) { - renderScaledItem(stack, x, y, true); - } - - @Override - public void renderItemIcon(ItemStack stack, int x, int y) { - renderScaledItem(stack, x, y, false); - } - - private void renderScaledItem(ItemStack stack, int x, int y, boolean overlay) { - int screenX = scaleX(x); - int screenY = scaleY(y); - GL11.glPushMatrix(); - try { - GL11.glTranslatef(screenX, screenY, 0f); - GL11.glScalef(scale, scale, 1f); - if (overlay) { - delegate.renderItem(stack, 0, 0); - } else { - delegate.renderItemIcon(stack, 0, 0); - } - } finally { - GL11.glPopMatrix(); - } - } - - @Override - public void blitGuiSprite(LytRect rect, GuiSprite sprite) { - if (sprite == null) return; - int sx = scaleX(rect.x()); - int sy = scaleY(rect.y()); - GL11.glPushMatrix(); - GL11.glTranslatef(sx, sy, 0f); - GL11.glScalef(scale, scale, 1f); - try { - delegate.blitTexture( - sprite.getTexture(), - 0, - 0, - sprite.getU(), - sprite.getV(), - sprite.getWidth(), - sprite.getHeight()); - } finally { - GL11.glPopMatrix(); - } - } - - @Override - public void fillIcon(LytRect rect, GuiSprite sprite, ColorValue color) { - delegate.fillIcon(scaleRect(rect), sprite, color); - } - - @Override - public void blitTexture(ResourceLocation texture, int x, int y, int u, int v, int width, int height) { - delegate.blitTexture(texture, scaleX(x), scaleY(y), u, v, scaleLength(width), scaleLength(height)); - } - - @Override - public void drawLine(float x1, float y1, float x2, float y2, float thickness, int argbColor) { - delegate.drawLine( - scaleFloatX(x1), - scaleFloatY(y1), - scaleFloatX(x2), - scaleFloatY(y2), - Math.max(1f, thickness * scale), - argbColor); - } - - @Override - public void fillTriangle(float x1, float y1, float x2, float y2, float x3, float y3, int argbColor) { - delegate.fillTriangle( - scaleFloatX(x1), - scaleFloatY(y1), - scaleFloatX(x2), - scaleFloatY(y2), - scaleFloatX(x3), - scaleFloatY(y3), - argbColor); - } - - @Override - public void fillPolygon(float[] xs, float[] ys, int argbColor) { - float[] scaledXs = new float[xs.length]; - float[] scaledYs = new float[ys.length]; - for (int i = 0; i < xs.length; i++) { - scaledXs[i] = scaleFloatX(xs[i]); - scaledYs[i] = scaleFloatY(ys[i]); - } - delegate.fillPolygon(scaledXs, scaledYs, argbColor); - } - - @Override - public void fillCircle(float cx, float cy, float radius, int argbColor) { - delegate.fillCircle(scaleFloatX(cx), scaleFloatY(cy), radius * scale, argbColor); - } - - @Override - public void fillEllipse(float cx, float cy, float rx, float ry, int argbColor) { - delegate.fillEllipse(scaleFloatX(cx), scaleFloatY(cy), rx * scale, ry * scale, argbColor); - } - - @Override - public void drawCircleOutline(float cx, float cy, float radius, float thickness, int argbColor) { - delegate.drawCircleOutline( - scaleFloatX(cx), - scaleFloatY(cy), - radius * scale, - Math.max(1f, thickness * scale), - argbColor); - } - - @Override - public void pushScissor(LytRect rect) { - delegate.pushScissor(scaleRect(rect)); - } - - @Override - public void pushLocalScissor(LytRect rect) { - delegate.pushLocalScissor(scaleRect(rect)); - } - - @Override - public LytRect currentScissor() { - return delegate.currentScissor(); - } - - @Override - public void popScissor() { - delegate.popScissor(); - } - - @Override - public void restoreExternalRenderState() { - delegate.restoreExternalRenderState(); - } - - @Override - public void beginLocalView() { - GL11.glPushMatrix(); - GL11.glTranslatef(originX, originY, 0f); - GL11.glScalef(scale, scale, 1f); - } - - @Override - public void endLocalView() { - GL11.glPopMatrix(); - } - - private ResolvedTextStyle scaleStyle(ResolvedTextStyle style) { - return scaledStyleCache.computeIfAbsent( - style, - key -> new ResolvedTextStyle( - key.fontScale() * scale, - key.bold(), - key.italic(), - key.underlined(), - key.wavyUnderline(), - key.dottedUnderline(), - key.strikethrough(), - key.obfuscated(), - key.font(), - key.color(), - key.whiteSpace(), - key.alignment(), - key.dropShadow(), - key.backgroundColor(), - key.inlineCode())); - } - - private LytRect scaleRect(LytRect rect) { - return new LytRect( - scaleX(rect.x()), - scaleY(rect.y()), - scaleLength(rect.width()), - scaleLength(rect.height())); - } - - private int scaleX(int x) { - return originX + Math.round(x * scale); - } - - private int scaleY(int y) { - return originY + Math.round(y * scale); - } - - private int scaleLength(int value) { - return Math.max(1, Math.round(value * scale)); - } - - private float scaleFloatX(float x) { - return originX + x * scale; - } - - private float scaleFloatY(float y) { - return originY + y * scale; - } - } } diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytMermaidFlowchart.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytMermaidFlowchart.java index 55f40618..8c688e04 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytMermaidFlowchart.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytMermaidFlowchart.java @@ -23,6 +23,7 @@ public class LytMermaidFlowchart extends LytVBox implements InteractiveElement { private final String sourceText; @Getter private final LytCodeBlockToolbar toolbar = new LytCodeBlockToolbar(); + @Getter private final LytMermaidFlowchartCanvas canvas; public LytMermaidFlowchart(FlowchartDocument flowchart, String sourceText) { diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytMermaidFlowchartCanvas.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytMermaidFlowchartCanvas.java index ba05ca9e..f7f2410c 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytMermaidFlowchartCanvas.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytMermaidFlowchartCanvas.java @@ -21,8 +21,13 @@ import com.hfstudio.guidenh.guide.internal.mermaid.flowchart.FlowchartLayoutStrategy; import com.hfstudio.guidenh.guide.internal.mermaid.flowchart.FlowchartNode; import com.hfstudio.guidenh.guide.internal.mermaid.flowchart.FlowchartSubgraph; +import com.hfstudio.guidenh.guide.layout.FontMetrics; import com.hfstudio.guidenh.guide.layout.LayoutContext; -import com.hfstudio.guidenh.guide.render.RenderContext; +import com.hfstudio.guidenh.guide.color.LightDarkMode; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.GuideText; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; +import com.hfstudio.guidenh.guide.scene.support.GuideDebugLog; import com.hfstudio.guidenh.guide.style.ResolvedTextStyle; import com.hfstudio.guidenh.guide.style.TextAlignment; import com.hfstudio.guidenh.guide.style.WhiteSpaceMode; @@ -39,6 +44,24 @@ public class LytMermaidFlowchartCanvas extends LytMermaidCanvas nodeContentLayouts = new LinkedHashMap<>(); private FlowchartLayoutResult layout; + private int precomputedLayoutWidth; public LytMermaidFlowchartCanvas(FlowchartDocument document, Map nodeContentBlocks) { this.document = document; @@ -139,10 +166,16 @@ protected boolean diagramReady() { } @Override - protected void renderDiagram(RenderContext context, int baseX, int baseY, float activeZoom) { - renderSubgraphs(context, baseX, baseY, activeZoom); - renderEdges(context, baseX, baseY, activeZoom); - renderNodes(context, baseX, baseY, activeZoom); + public boolean usePrimitives() { + return true; + } + + @Override + protected void emitDiagramPrimitives(PrimitiveCollector c, int baseX, int baseY, float activeZoom) { + emitSubgraphsPrimitives(c, baseX, baseY, activeZoom); + emitEdgesPrimitives(c, baseX, baseY, activeZoom); + emitNodesPrimitives(c, baseX, baseY, activeZoom); + emitEdgeLabelsPrimitives(c, baseX, baseY, activeZoom); } @Override @@ -203,7 +236,13 @@ private Map computeNodeMinSizes(LayoutContext context) { if (block != null) { LayoutContext localContext = new LayoutContext(context).withVisualScale(context.getVisualScale()); int contentWidth = Math.clamp(maxTextWidth + 60, 96, 240); - block.layout(localContext, 0, 0, contentWidth); + // LytVBox.computeBoxLayout is a stub (Rust is sole layout + // authority for the normal document pipeline), so NodeContent + // subtrees — which never reach the document's Rust pass — used + // to be laid out manually. The Rust engine now lays the subtree + // out directly (including the inline post-pass), with a Java + // fallback for environments without the native bridge. + layoutNodeContentWithRust(localContext, block, contentWidth); LytRect vb = resolveBlockVisualBounds(block); textWidth = vb.width(); textHeight = vb.height(); @@ -239,8 +278,8 @@ private Map computeNodeMinSizes(LayoutContext context) { LytRect minRect = FlowchartShapes .minNodeRect(node.getShape(), contentW, contentH, NODE_PADDING_X, NODE_PADDING_Y); - int width = minRect.width(); - int height = minRect.height(); + int width = minRect.width() + NODE_SIZE_ROUNDING_MARGIN; + int height = minRect.height() + NODE_SIZE_ROUNDING_MARGIN; if (isRoot) { width += 10; @@ -268,11 +307,226 @@ private void restoreViewportAfterLayout(int previousOffsetX, int previousOffsetY clampOffsets(); } + /** + * Pre-compute diagram layout before the first Rust layout pass and set + * preferredHeight so Rust allocates the correct canvas height immediately. + * Caches the layout result for reuse in afterExternalLayout when the + * actual bounds width matches the pre-computation width. + * + * @param ctx LayoutContext backed by GuideText-based FontMetrics + * @param availableWidth estimated canvas content width (page width or + * placeholder width) + */ + public void precomputeLayout(LayoutContext ctx, int availableWidth) { + int safeWidth = preferredWidth > 0 + ? Math.clamp(preferredWidth, 1, availableWidth) + : Math.max(1, availableWidth); + LytRect savedBounds = bounds; + bounds = new LytRect(0, 0, safeWidth, 0); + try { + FlowchartLayoutStrategy strategy = FlowchartLayoutStrategy.forMode(document.getLayoutMode()); + var minSizes = computeNodeMinSizes(ctx); + FlowchartLayoutResult result = strategy.layout(document, minSizes); + if (result != null) { + this.layout = result; + int desiredHeight = result.getHeight() + CANVAS_PADDING * 2; + preferredHeight = preferredHeight > 0 ? Math.max(48, preferredHeight) + : Math.clamp(desiredHeight, MIN_HEIGHT, MAX_HEIGHT); + // Constrain the canvas explicit width to the available page + // width. The unbounded layout width (ELK output) may exceed the + // page 2x for large diagrams; Rust's layout engine then sizes + // the canvas to that explicit width and the page-level clamp in + // computeLayout never runs on the Rust path, pushing the whole + // diagram off-page (fit-to-view centred it inside an oversized + // canvas). Clamping here keeps the canvas inside the page and + // lets fit-to-view centre the diagram in the visible viewport. + int diagramWidth = result.getWidth() + CANVAS_PADDING * 2; + preferredWidth = Math.min(diagramWidth, Math.max(1, safeWidth)); + this.precomputedLayoutWidth = preferredWidth; + GuideDebugLog.debugAlways( + "[GuideNH-Mermaid] precomputeLayout OK layoutHeight={} preferredHeight={} diagramWidth={}", + result.getHeight(), preferredHeight, diagramWidth); + GuideDebugLog.debugAlways( + "[GuideNH-Mermaid] precomputeLayout explicitWidth={} safeWidth={}", + preferredWidth, safeWidth); + } else { + GuideDebugLog.debugAlways( + "[GuideNH-Mermaid] precomputeLayout FAILED result=null safeWidth={}", + safeWidth); + } + } finally { + bounds = savedBounds; + } + } + + @Override + protected void afterExternalLayout() { + int safeWidth = preferredWidth > 0 + ? Math.clamp(preferredWidth, 1, Math.max(1, bounds.width())) + : Math.max(1, bounds.width()); + + GuideDebugLog.debugAlways( + "[GuideNH-Mermaid] afterExternalLayout entered layout={} safeWidth={} precomputedLayoutWidth={} bounds.height={}", + layout != null, safeWidth, precomputedLayoutWidth, bounds.height()); + + // Phase 1: ensure layout result matches the actual canvas width. + // If actual bounds.width() differs from the width used during + // precompute, the ELK layout may be suboptimal or clipped, so + // recompute at the actual canvas width. + int actualWidth = Math.max(1, bounds.width() - CANVAS_PADDING * 2); + if (layout == null || precomputedLayoutWidth <= 0 || precomputedLayoutWidth != bounds.width()) { + LayoutContext fallbackCtx = new LayoutContext(new FontMetrics() { + @Override + public float getAdvance(int codePoint, com.hfstudio.guidenh.guide.style.ResolvedTextStyle s) { + return GuideText.measureWidth(new String(Character.toChars(codePoint)), s); + } + @Override + public int getLineHeight(com.hfstudio.guidenh.guide.style.ResolvedTextStyle s) { + return GuideText.lineHeight(s); + } + }); + FlowchartLayoutStrategy strategy = FlowchartLayoutStrategy.forMode(document.getLayoutMode()); + var minSizes = computeNodeMinSizes(fallbackCtx); + layout = strategy.layout(document, minSizes); + precomputedLayoutWidth = (int) bounds.width(); + GuideDebugLog.debugAlways( + "[GuideNH-Mermaid] afterExternalLayout recomputed ELK at boundsWidth={} layout={}", + bounds.width(), layout != null); + } + + // Phase 2: if layout is valid, correct bounds height if needed (兜底). + if (layout != null) { + int desiredHeight = layout.getHeight() + CANVAS_PADDING * 2; + int expectedHeight = preferredHeight > 0 + ? Math.max(48, preferredHeight) + : Math.clamp(desiredHeight, MIN_HEIGHT, MAX_HEIGHT); + if (bounds.height() != expectedHeight) { + GuideDebugLog.debugAlways( + "[GuideNH-Mermaid] afterExternalLayout correcting bounds height {} -> {}", + bounds.height(), expectedHeight); + bounds = new LytRect(bounds.x(), bounds.y(), bounds.width(), expectedHeight); + } + } + + GuideDebugLog.debugAlways( + "[GuideNH-Mermaid] afterExternalLayout exit layout={} bounds.height={}", + layout != null, bounds.height()); + } + @Override protected void onLayoutMoved(int deltaX, int deltaY) {} - private void renderEdges(RenderContext context, int baseX, int baseY, float activeZoom) { - int defaultColor = context.resolveColor(EDGE_COLOR); + private @Nullable FlowchartEdge lookupEdge(String fromId, String toId, @Nullable String edgeId) { + if (edgeId != null) { + for (FlowchartEdge e : document.getEdges()) { + if (edgeId.equals(e.getEdgeId())) return e; + } + } + for (FlowchartEdge e : document.getEdges()) { + if (e.getFrom() + .equals(fromId) + && e.getTo() + .equals(toId)) + return e; + } + return null; + } + + @Override + @Nullable + protected NodeHit pickNodeHit(int documentX, int documentY) { + if (layout == null) return null; + LytRect innerViewport = getInnerViewport(); + float activeZoom = getActiveZoom(); + int baseX = innerViewport.x() + getVisualOffsetX() - getScaledOriginX(); + int baseY = innerViewport.y() + getVisualOffsetY() - getScaledOriginY(); + + for (var entry : layout.getNodePositions() + .entrySet()) { + String nodeId = entry.getKey(); + NodeContentLayout contentLayout = nodeContentLayouts.get(nodeId); + if (contentLayout == null) continue; + + NodePosition pos = entry.getValue(); + int sx = scaled(baseX, pos.getX(), activeZoom); + int sy = scaled(baseY, pos.getY(), activeZoom); + int sw = Math.max(1, Math.round(pos.getWidth() * activeZoom)); + int sh = Math.max(1, Math.round(pos.getHeight() * activeZoom)); + LytRect nodeRect = new LytRect(sx, sy, sw, sh); + + int paddingX = Math.max(1, Math.round(NODE_PADDING_X * activeZoom)); + int contentY = nodeRect.y() + Math.max(1, Math.round(NODE_PADDING_Y * activeZoom)) + + resolveNodeBadgeHeight(entry.getKey(), activeZoom); + LytRect contentScreenRect = resolveNodeContentRect(contentLayout, nodeRect, paddingX, contentY, activeZoom); + + if (!contentScreenRect.contains(documentX, documentY)) continue; + + int localX = unscaleCoordinate(documentX - contentScreenRect.x(), activeZoom); + int localY = unscaleCoordinate(documentY - contentScreenRect.y(), activeZoom); + DocumentInteractionSnapshot hit = LytDocument.pick(contentLayout.block(), localX, localY); + if (hit != null) { + return new NodeHit(hit.node(), hit.flowPath(), localX, localY); + } + } + return null; + } + + private int resolveNodeBadgeHeight(String nodeId, float activeZoom) { + FlowchartNode node = document.getNodes() + .get(nodeId); + if (node == null || node.getIcon() == null) return 0; + String badgeText = MermaidNodeRenderer.simplifyIcon(node.getIcon()); + if (badgeText == null) return 0; + ResolvedTextStyle badgeStyle = getOrScaleStyle(ICON_TEXT_STYLE, activeZoom); + int badgePaddingY = Math.max(1, Math.round(2 * activeZoom)); + int iconGapY = Math.max(1, Math.round(ICON_GAP_Y * activeZoom)); + return contextLineHeight(badgeStyle) + badgePaddingY * 2 + iconGapY; + } + + // ---- primitives pipeline (replaces render* for the primitives path) ---- + + private void emitSubgraphsPrimitives(PrimitiveCollector c, int baseX, int baseY, float activeZoom) { + if (layout == null) return; + for (var subgraph : document.getSubgraphs()) { + emitSubgraphRecursive(c, subgraph, layout.getNodePositions(), baseX, baseY, activeZoom, 0); + } + } + + private void emitSubgraphRecursive(PrimitiveCollector c, FlowchartSubgraph subgraph, + Map positions, int baseX, int baseY, float activeZoom, int depth) { + LytRect bounds = computeSubgraphBounds(subgraph, positions); + if (bounds == null) return; + + int pad = Math.round(SUBGRAPH_PADDING * activeZoom); + int sx = scaled(baseX, bounds.x() - pad, activeZoom); + int sy = scaled(baseY, bounds.y() - pad, activeZoom); + int sw = Math.max(1, Math.round((bounds.width() + pad * 2) * activeZoom)); + int sh = Math.max(1, Math.round((bounds.height() + pad * 2) * activeZoom)); + LytRect sgRect = new LytRect(sx, sy, sw, sh); + + int bg = SUBGRAPH_BG[depth % SUBGRAPH_BG.length].resolve(LightDarkMode.current()); + int border = SUBGRAPH_BORDER[depth % SUBGRAPH_BORDER.length].resolve(LightDarkMode.current()); + c.emit(new GuideRenderPrimitive.FillRect(sgRect.x(), sgRect.y(), sgRect.width(), sgRect.height(), bg)); + int borderThickness = Math.max(1, Math.round(1.5f * activeZoom)); + c.emit(new GuideRenderPrimitive.DrawBorder( + sgRect.x(), sgRect.y(), sgRect.width(), sgRect.height(), + borderThickness, borderThickness, borderThickness, borderThickness, border)); + + String label = subgraph.getLabel(); + if (label != null && !label.isEmpty()) { + int labelPadX = Math.max(2, Math.round(4 * activeZoom)); + int labelPadY = Math.max(1, Math.round(2 * activeZoom)); + ResolvedTextStyle labelStyle = getOrScaleStyle(NODE_TEXT_STYLE, activeZoom); + GuideText.emitText(c, label, sgRect.x() + labelPadX, sgRect.y() + labelPadY, labelStyle); + } + + for (var child : subgraph.getChildren()) { + emitSubgraphRecursive(c, child, positions, baseX, baseY, activeZoom, depth + 1); + } + } + + private void emitEdgesPrimitives(PrimitiveCollector c, int baseX, int baseY, float activeZoom) { + int defaultColor = EDGE_COLOR.resolve(LightDarkMode.current()); for (EdgePath edgePath : layout.getEdgePaths()) { FlowchartEdge flowEdge = lookupEdge(edgePath.getFromId(), edgePath.getToId(), edgePath.getEdgeId()); MermaidEdgeStyle style = flowEdge != null ? flowEdge.getStyle() : MermaidEdgeStyle.SOLID; @@ -319,9 +573,9 @@ private void renderEdges(RenderContext context, int baseX, int baseY, float acti float y2 = scaled(baseY, to.getY(), activeZoom); if (style == MermaidEdgeStyle.DASHED || style == MermaidEdgeStyle.DOTTED) { - drawDashedLine(context, x1, y1, x2, y2, edgeThickness, edgeColor, style == MermaidEdgeStyle.DOTTED); + emitDashedLine(c, x1, y1, x2, y2, edgeThickness, edgeColor, style == MermaidEdgeStyle.DOTTED); } else { - context.drawLine(x1, y1, x2, y2, edgeThickness, edgeColor); + c.emit(new GuideRenderPrimitive.DrawLine(x1, y1, x2, y2, edgeThickness, edgeColor)); } } @@ -337,7 +591,7 @@ private void renderEdges(RenderContext context, int baseX, int baseY, float acti dirX /= len; dirY /= len; if (arrowFwd) { - drawArrowHeadVariant(context, tipX, tipY, dirX, dirY, activeZoom, edgeColor, fwdHead); + emitArrowHeadVariant(c, tipX, tipY, dirX, dirY, activeZoom, edgeColor, fwdHead); } } @@ -352,34 +606,41 @@ private void renderEdges(RenderContext context, int baseX, int baseY, float acti if (revLen > 0.5f) { revDirX /= revLen; revDirY /= revLen; - drawArrowHeadVariant(context, tailX, tailY, revDirX, revDirY, activeZoom, edgeColor, revHead); + emitArrowHeadVariant(c, tailX, tailY, revDirX, revDirY, activeZoom, edgeColor, revHead); } } } - if (label != null && !label.isEmpty()) { - drawEdgeLabel(context, points, baseX, baseY, activeZoom, label); - } } } - private @Nullable FlowchartEdge lookupEdge(String fromId, String toId, @Nullable String edgeId) { - if (edgeId != null) { - for (FlowchartEdge e : document.getEdges()) { - if (edgeId.equals(e.getEdgeId())) return e; + /** + * Emit edge labels in a separate pass after nodes have been + * drawn, so labels appear on top of node shapes rather than being + * obscured by them (R4-39). Each label is anchored at the edge path's + * midpoint but clamped into the free span between its endpoint node + * borders (R3-13). + */ + private void emitEdgeLabelsPrimitives(PrimitiveCollector c, int baseX, int baseY, float activeZoom) { + if (layout == null) return; + for (EdgePath edgePath : layout.getEdgePaths()) { + FlowchartEdge flowEdge = lookupEdge(edgePath.getFromId(), edgePath.getToId(), edgePath.getEdgeId()); + String label = flowEdge != null ? flowEdge.getLabel() : null; + if (label != null && !label.isEmpty()) { + emitEdgeLabelPrimitives( + c, + edgePath.getPoints(), + layout.getPosition(edgePath.getFromId()), + layout.getPosition(edgePath.getToId()), + baseX, + baseY, + activeZoom, + label); } } - for (FlowchartEdge e : document.getEdges()) { - if (e.getFrom() - .equals(fromId) - && e.getTo() - .equals(toId)) - return e; - } - return null; } - private void drawDashedLine(RenderContext context, float x1, float y1, float x2, float y2, int thickness, int color, + private void emitDashedLine(PrimitiveCollector c, float x1, float y1, float x2, float y2, int thickness, int color, boolean dotted) { float dx = x2 - x1; float dy = y2 - y1; @@ -398,23 +659,23 @@ private void drawDashedLine(RenderContext context, float x1, float y1, float x2, float ex = x1 + nx * segEnd; float ey = y1 + ny * segEnd; if (draw) { - context.drawLine(sx, sy, ex, ey, thickness, color); + c.emit(new GuideRenderPrimitive.DrawLine(sx, sy, ex, ey, thickness, color)); } drawn = segEnd + gapLen; draw = !draw; } } - private void drawArrowHeadVariant(RenderContext context, float tipX, float tipY, float dirX, float dirY, + private void emitArrowHeadVariant(PrimitiveCollector c, float tipX, float tipY, float dirX, float dirY, float activeZoom, int color, MermaidArrowHead headType) { switch (headType) { - case CIRCLE -> drawCircleHead(context, tipX, tipY, dirX, dirY, activeZoom, color); - case CROSS -> drawCrossHead(context, tipX, tipY, dirX, dirY, activeZoom, color); - default -> drawTriangleHead(context, tipX, tipY, dirX, dirY, activeZoom, color); + case CIRCLE -> emitCircleHead(c, tipX, tipY, dirX, dirY, activeZoom, color); + case CROSS -> emitCrossHead(c, tipX, tipY, dirX, dirY, activeZoom, color); + default -> emitTriangleHead(c, tipX, tipY, dirX, dirY, activeZoom, color); } } - private void drawTriangleHead(RenderContext context, float tipX, float tipY, float dirX, float dirY, + private void emitTriangleHead(PrimitiveCollector c, float tipX, float tipY, float dirX, float dirY, float activeZoom, int color) { float size = Math.max(4f, 8f * activeZoom); float perpX = -dirY; @@ -424,101 +685,236 @@ private void drawTriangleHead(RenderContext context, float tipX, float tipY, flo float leftY = baseY + dirX * size * 0.4f; float rightX = baseX - perpX * size * 0.4f; float rightY = baseY - dirX * size * 0.4f; - context.fillTriangle(tipX, tipY, leftX, leftY, rightX, rightY, color); + c.emit(new GuideRenderPrimitive.DrawTriangle(tipX, tipY, leftX, leftY, rightX, rightY, color)); } - private void drawCircleHead(RenderContext context, float tipX, float tipY, float dirX, float dirY, float activeZoom, + private void emitCircleHead(PrimitiveCollector c, float tipX, float tipY, float dirX, float dirY, float activeZoom, int color) { float radius = Math.max(3f, 5f * activeZoom); float cx = tipX - dirX * radius; float cy = tipY - dirY * radius; - context.fillCircle(cx, cy, radius, color); + c.emit(new GuideRenderPrimitive.DrawCircle(cx, cy, radius, color, true)); } - private void drawCrossHead(RenderContext context, float tipX, float tipY, float dirX, float dirY, float activeZoom, + private void emitCrossHead(PrimitiveCollector c, float tipX, float tipY, float dirX, float dirY, float activeZoom, int color) { float size = Math.max(3f, 5f * activeZoom); float perpX = -dirY; float cx = tipX - dirX * size * 0.5f; float cy = tipY - dirY * size * 0.5f; float thickness = Math.max(1f, 1.5f * activeZoom); - context.drawLine( - cx + perpX * size * 0.7f, - cy + dirX * size * 0.7f, - cx - perpX * size * 0.7f, - cy - dirX * size * 0.7f, - thickness, - color); - context.drawLine( - cx + perpX * size * 0.7f, - cy - dirX * size * 0.7f, - cx - perpX * size * 0.7f, - cy + dirX * size * 0.7f, - thickness, - color); + c.emit(new GuideRenderPrimitive.DrawLine( + cx + perpX * size * 0.7f, cy + dirX * size * 0.7f, + cx - perpX * size * 0.7f, cy - dirX * size * 0.7f, + thickness, color)); + c.emit(new GuideRenderPrimitive.DrawLine( + cx + perpX * size * 0.7f, cy - dirX * size * 0.7f, + cx - perpX * size * 0.7f, cy + dirX * size * 0.7f, + thickness, color)); } - private void drawEdgeLabel(RenderContext context, List points, int baseX, int baseY, - float activeZoom, String label) { + /** + * Draw a single edge label. The label is anchored at the edge path's + * midpoint (measured by path length), then its background box is clamped + * into the free span between the two endpoint node borders so it keeps a + * constant {@link #EDGE_LABEL_GAP} clearance from both nodes. Previously + * the box was placed purely at the midpoint — with no minimum-gap + * constraint — so a label that nearly filled the gap pressed against a + * node border (right edge 1px at scale2), and integer rounding of the + * midpoint / half-width pushed it off-centre (R3-13). When the gap cannot + * hold the box at that clearance, the label is word-wrapped (with + * codepoint-level breaking of overlong words) and residual overlong + * fragments are ellipsized, so the box never overflows onto either node. + */ + private void emitEdgeLabelPrimitives(PrimitiveCollector c, List points, + @Nullable FlowchartLayoutResult.NodePosition fromPos, @Nullable FlowchartLayoutResult.NodePosition toPos, + int baseX, int baseY, float activeZoom, String label) { float totalLen = 0f; float[] segLens = new float[points.size() - 1]; for (int i = 1; i < points.size(); i++) { - float dx = points.get(i) - .getX() - - points.get(i - 1) - .getX(); - float dy = points.get(i) - .getY() - - points.get(i - 1) - .getY(); + float dx = points.get(i).getX() - points.get(i - 1).getX(); + float dy = points.get(i).getY() - points.get(i - 1).getY(); segLens[i - 1] = (float) Math.sqrt(dx * dx + dy * dy); totalLen += segLens[i - 1]; } if (totalLen < 1f) return; float halfLen = totalLen * 0.5f; float accumulated = 0f; - float mx = points.getFirst() - .getX(); - float my = points.getFirst() - .getY(); + float midDocX = points.getFirst().getX(); + float midDocY = points.getFirst().getY(); for (int i = 0; i < segLens.length; i++) { if (accumulated + segLens[i] >= halfLen) { float frac = (halfLen - accumulated) / Math.max(segLens[i], 0.0001f); - mx = points.get(i) - .getX() - + (points.get(i + 1) - .getX() - - points.get(i) - .getX()) - * frac; - my = points.get(i) - .getY() - + (points.get(i + 1) - .getY() - - points.get(i) - .getY()) - * frac; + midDocX = points.get(i).getX() + + (points.get(i + 1).getX() - points.get(i).getX()) * frac; + midDocY = points.get(i).getY() + + (points.get(i + 1).getY() - points.get(i).getY()) * frac; break; } accumulated += segLens[i]; } - int screenX = Math.round(scaled(baseX, Math.round(mx), activeZoom)); - int screenY = Math.round(scaled(baseY, Math.round(my), activeZoom)); + ResolvedTextStyle labelStyle = getOrScaleStyle(NODE_TEXT_STYLE, activeZoom); - int textWidth = context.getStringWidth(label, labelStyle); - int textHeight = context.getLineHeight(labelStyle); int pad = Math.max(1, Math.round(2 * activeZoom)); - int bgColor = context.resolveColor(new ConstantColor(0xCC0C1117)); - LytRect bg = new LytRect( - screenX - textWidth / 2 - pad, - screenY - textHeight / 2 - pad, - textWidth + pad * 2, - textHeight + pad * 2); - context.fillRect(bg, bgColor); - context.drawText(label, screenX - textWidth / 2, screenY - textHeight / 2, labelStyle); + int bgColor = new ConstantColor(0xCC0C1117).resolve(LightDarkMode.current()); + + // Free span between the two endpoint node borders along the edge's + // dominant axis, expressed in the same scaled space as the label box. + // nearBorder = border the box must stay clear of on the source side; + // farBorder = border on the target side. When the endpoint nodes are + // unavailable (e.g. cross-compound edges) the constraint is skipped. + int nearBorder = 0; + int farBorder = 0; + boolean horizontal = true; + boolean constrained = false; + if (fromPos != null && toPos != null) { + int fromCx = fromPos.getX() + fromPos.getWidth() / 2; + int fromCy = fromPos.getY() + fromPos.getHeight() / 2; + int toCx = toPos.getX() + toPos.getWidth() / 2; + int toCy = toPos.getY() + toPos.getHeight() / 2; + horizontal = Math.abs(toCx - fromCx) >= Math.abs(toCy - fromCy); + if (horizontal) { + if (toCx >= fromCx) { + nearBorder = fromPos.getX() + fromPos.getWidth(); + farBorder = toPos.getX(); + } else { + nearBorder = toPos.getX() + toPos.getWidth(); + farBorder = fromPos.getX(); + } + } else { + if (toCy >= fromCy) { + nearBorder = fromPos.getY() + fromPos.getHeight(); + farBorder = toPos.getY(); + } else { + nearBorder = toPos.getY() + toPos.getHeight(); + farBorder = fromPos.getY(); + } + } + int nearScreen = horizontal + ? baseX + Math.round(nearBorder * activeZoom) + : baseY + Math.round(nearBorder * activeZoom); + int farScreen = horizontal + ? baseX + Math.round(farBorder * activeZoom) + : baseY + Math.round(farBorder * activeZoom); + constrained = farScreen > nearScreen; + if (constrained) { + nearBorder = nearScreen; + farBorder = farScreen; + } + } + int span = constrained ? farBorder - nearBorder : 0; + + // Wrap the label so its box provably fits the gap with EDGE_LABEL_GAP + // clearance on both sides; a label that fits unchanged stays on a + // single line. Word-first wrapping preserves the full text; residual + // over-budget lines (e.g. a single glyph wider than the budget) are + // clipped so the box stays inside the gap (R3-13). + // + // The wrap budget is taken from the edge path's usable length (the + // total path length in rendered-logical px), NOT from the straight + // gap between the endpoint node borders. ELK routes edges as + // polylines; for routed edges the path length is far larger than the + // ~nodeSpacing straight gap, and mermaid renders edge labels + // horizontally along the path — so the budget must follow the path. + // Before this fix the budget wrongly used the node straight gap + // (span = nodeSpacing = 20px → budgetPx = 14), forcing every label + // wider than 14px ('Critical', 'Chinese 标签') into a per-glyph + // vertical column. + // + // R3-13 hard bound: the wrapped box must stay inside the straight + // node gap (span) so the label never presses against either endpoint + // node — the EDGE_LABEL_GAP clearance and the box-clamp below both + // assume boxWidth <= span - 2*EDGE_LABEL_GAP. When the path budget + // yields a box wider than the gap, the label is re-wrapped at the + // (narrower) gap budget so the FULL text is preserved in more lines + // instead of being truncated or overflowing onto the nodes. + List lines = List.of(label); + if (constrained) { + int pathBudgetPx = Math.max(0, (int) Math.floor(totalLen * activeZoom)) + - 2 * EDGE_LABEL_GAP - 2 * pad; + int gapBudgetPx = span - 2 * EDGE_LABEL_GAP - 2 * pad; + if (pathBudgetPx >= 1) { + List wrapped = GuideText.wrap(label, pathBudgetPx, labelStyle); + if (!wrapped.isEmpty()) { + lines = wrapped; + int boxWidth = 0; + for (String line : wrapped) { + boxWidth = Math.max(boxWidth, GuideText.measureWidth(line, labelStyle)); + } + // R3-13: if the path-budget box still cannot fit inside + // the node gap, re-wrap at the gap budget (full text kept). + if (gapBudgetPx >= 1 && boxWidth > gapBudgetPx) { + List gapWrapped = GuideText.wrap(label, gapBudgetPx, labelStyle); + if (!gapWrapped.isEmpty()) { + lines = gapWrapped; + } + } + int hardBudget = Math.max(1, gapBudgetPx); + for (int i = 0; i < lines.size(); i++) { + String line = lines.get(i); + int lineW = GuideText.measureWidth(line, labelStyle); + if (lineW > hardBudget) { + String clipped = GuideText.clipToWidth(line, hardBudget, labelStyle, + GuideText.ClipSuffix.NONE); + if (!clipped.isEmpty()) { + lines.set(i, clipped); + } + } + } + } + } + } + int lineHeight = GuideText.lineHeight(labelStyle); + int textWidth = 0; + for (String line : lines) { + textWidth = Math.max(textWidth, GuideText.measureWidth(line, labelStyle)); + } + int textHeight = lines.size() * lineHeight; + int boxHalfW = textWidth / 2 + pad; + int boxHalfH = textHeight / 2 + pad; + + // Label anchor. The old code rounded the doc-space midpoint to an + // integer before scaling and divided the half-width by integer + // truncation, which shifted the box off-centre by up to 1 logical px + // (2 rendered px at scale2) and pressed its near edge against the + // node border. Clamp the anchor so the box keeps EDGE_LABEL_GAP from + // both endpoint node borders. + float centerX = baseX + midDocX * activeZoom; + float centerY = baseY + midDocY * activeZoom; + if (constrained) { + float low = nearBorder + EDGE_LABEL_GAP + (horizontal ? boxHalfW : boxHalfH); + float high = farBorder - EDGE_LABEL_GAP - (horizontal ? boxHalfW : boxHalfH); + if (low <= high) { + if (horizontal) { + centerX = Math.max(low, Math.min(centerX, high)); + } else { + centerY = Math.max(low, Math.min(centerY, high)); + } + } else { + // Gap still too narrow after wrapping (e.g. a single glyph is + // wider than the budget): keep the label centred between the + // nodes rather than pushing it onto one of them. + float mid = (low + high) / 2f; + if (horizontal) { + centerX = mid; + } else { + centerY = mid; + } + } + } + + int bgX = Math.round(centerX - textWidth / 2f) - pad; + int bgY = Math.round(centerY - textHeight / 2f) - pad; + c.emit(new GuideRenderPrimitive.FillRect(bgX, bgY, textWidth + pad * 2, textHeight + pad * 2, bgColor)); + int textTop = Math.round(centerY - textHeight / 2f); + for (int i = 0; i < lines.size(); i++) { + String line = lines.get(i); + int lineWidth = GuideText.measureWidth(line, labelStyle); + GuideText.emitText(c, line, Math.round(centerX - lineWidth / 2f), textTop + i * lineHeight, labelStyle); + } } - private void renderNodes(RenderContext context, int baseX, int baseY, float activeZoom) { + private void emitNodesPrimitives(PrimitiveCollector c, int baseX, int baseY, float activeZoom) { ResolvedTextStyle badgeStyle = getOrScaleStyle(ICON_TEXT_STYLE, activeZoom); int paddingX = Math.max(1, Math.round(NODE_PADDING_X * activeZoom)); int paddingY = Math.max(1, Math.round(NODE_PADDING_Y * activeZoom)); @@ -562,15 +958,16 @@ private void renderNodes(RenderContext context, int baseX, int baseY, float acti colors = new MermaidNodeRenderer.NodeColors(colors.background(), strokeColor, colors.accent()); } } - FlowchartShapes.render(context, rect, node.getShape(), colors.background(), colors.border()); + FlowchartShapes.emitShape(c, node.getShape(), rect, colors.background(), colors.border()); if (colors.accent() != MermaidNodeRenderer.DEFAULT_ACCENT && FlowchartShapes.hasAccentBar(node.getShape())) { - MermaidNodeRenderer.renderAccentBar(context, rect, colors.accent()); + c.emit(new GuideRenderPrimitive.FillRect(rect.x(), rect.y(), 3, rect.height(), colors.accent())); } int contentW = rect.width() - 2 * pdX; int contentH = rect.height() - 2 * pdY; - LytRect contentArea = FlowchartShapes.contentBounds(rect, node.getShape(), contentW, contentH, pdX, pdY); + LytRect contentArea = FlowchartShapes.contentBounds(rect, node.getShape(), contentW, contentH, pdX, pdY, + activeZoom); int textY = contentArea.y(); String icon = node.getIcon(); @@ -579,16 +976,22 @@ private void renderNodes(RenderContext context, int baseX, int baseY, float acti if (badgeText != null) { int badgeWidth = Math.max( 1, - context.getStringWidth(badgeText, badgeStyle) + GuideText.measureWidth(badgeText, badgeStyle) + Math.max(2, Math.round(BADGE_PADDING_X * activeZoom)) * 2); int badgeHeight = Math.max( 1, - context.getLineHeight(badgeStyle) + Math.max(1, Math.round(BADGE_PADDING_Y * activeZoom)) * 2); + GuideText.lineHeight(badgeStyle) + + Math.max(1, Math.round(BADGE_PADDING_Y * activeZoom)) * 2); int badgeX = contentArea.x(); LytRect badge = new LytRect(badgeX, textY, badgeWidth, badgeHeight); - context.fillRect(badge, MermaidNodeRenderer.BADGE_BACKGROUND); - context.drawBorder(badge, MermaidNodeRenderer.BADGE_BORDER, 1); - context.drawText( + c.emit(new GuideRenderPrimitive.FillRect( + badge.x(), badge.y(), badge.width(), badge.height(), + MermaidNodeRenderer.BADGE_BACKGROUND)); + c.emit(new GuideRenderPrimitive.DrawBorder( + badge.x(), badge.y(), badge.width(), badge.height(), + 1, 1, 1, 1, MermaidNodeRenderer.BADGE_BORDER)); + GuideText.emitText( + c, badgeText, badge.x() + Math.max(2, Math.round(BADGE_PADDING_X * activeZoom)), badge.y() + Math.max(1, Math.round(BADGE_PADDING_Y * activeZoom)), @@ -602,147 +1005,36 @@ private void renderNodes(RenderContext context, int baseX, int baseY, float acti NodeContentLayout contentLayout = nodeContentLayouts.get(nodeId); if (contentLayout != null) { - renderNodeContent(context, contentLayout, contentArea, activeZoom); + emitNodeContentPrimitives(c, contentLayout, contentArea, activeZoom); } else { String label = node.getLabel(); if (label == null || label.isEmpty()) continue; - List lines = MermaidNodeRenderer.wrapText(context, style, label, visibleWidth); - int lineHeight = context.getLineHeight(style); + List lines = MermaidNodeRenderer.wrapText(new LayoutContext(new FontMetrics() { + + @Override + public float getAdvance(int codePoint, ResolvedTextStyle s) { + return GuideText.measureWidth(new String(Character.toChars(codePoint)), s); + } + + @Override + public int getLineHeight(ResolvedTextStyle s) { + return GuideText.lineHeight(s); + } + }), style, label, visibleWidth); + int lineHeight = GuideText.lineHeight(style); int totalTextHeight = lines.size() * lineHeight; int textAreaHeight = contentArea.y() + visibleHeight - textY; int baseTextY = textY + Math.max(0, (textAreaHeight - totalTextHeight) / 2); for (int i = 0; i < lines.size(); i++) { - int lineWidth = context.getStringWidth(lines.get(i), style); + int lineWidth = GuideText.measureWidth(lines.get(i), style); int textX = contentArea.x() + Math.max(0, (visibleWidth - lineWidth) / 2); - context.drawText(lines.get(i), textX, baseTextY + i * lineHeight, style); + GuideText.emitText(c, lines.get(i), textX, baseTextY + i * lineHeight, style); } } } } - private void renderNodeContent(RenderContext context, NodeContentLayout contentLayout, LytRect contentArea, - float activeZoom) { - LytRect rawViewport = new LytRect( - contentArea.x(), - contentArea.y(), - Math.max( - 1, - Math.round( - contentLayout.visualBounds() - .width() * activeZoom)), - Math.max( - 1, - Math.round( - contentLayout.visualBounds() - .height() * activeZoom))); - - int cvpX = rawViewport.x(); - int cvpY = rawViewport.y(); - if (rawViewport.width() < contentArea.width()) { - cvpX = contentArea.x() + (contentArea.width() - rawViewport.width()) / 2; - } - if (rawViewport.height() < contentArea.height()) { - cvpY = contentArea.y() + (contentArea.height() - rawViewport.height()) / 2; - } - LytRect contentViewport = new LytRect(cvpX, cvpY, rawViewport.width(), rawViewport.height()); - - renderNodeContent(context, contentLayout.block(), contentViewport, contentLayout.visualBounds(), activeZoom); - } - - @Override - @Nullable - protected NodeHit pickNodeHit(int documentX, int documentY) { - if (layout == null) return null; - LytRect innerViewport = getInnerViewport(); - float activeZoom = getActiveZoom(); - int baseX = innerViewport.x() + getVisualOffsetX() - getScaledOriginX(); - int baseY = innerViewport.y() + getVisualOffsetY() - getScaledOriginY(); - - for (var entry : layout.getNodePositions() - .entrySet()) { - String nodeId = entry.getKey(); - NodeContentLayout contentLayout = nodeContentLayouts.get(nodeId); - if (contentLayout == null) continue; - - NodePosition pos = entry.getValue(); - int sx = scaled(baseX, pos.getX(), activeZoom); - int sy = scaled(baseY, pos.getY(), activeZoom); - int sw = Math.max(1, Math.round(pos.getWidth() * activeZoom)); - int sh = Math.max(1, Math.round(pos.getHeight() * activeZoom)); - LytRect nodeRect = new LytRect(sx, sy, sw, sh); - - int paddingX = Math.max(1, Math.round(NODE_PADDING_X * activeZoom)); - int contentY = nodeRect.y() + Math.max(1, Math.round(NODE_PADDING_Y * activeZoom)) - + resolveNodeBadgeHeight(entry.getKey(), activeZoom); - LytRect contentScreenRect = resolveNodeContentRect(contentLayout, nodeRect, paddingX, contentY, activeZoom); - - if (!contentScreenRect.contains(documentX, documentY)) continue; - - int localX = unscaleCoordinate(documentX - contentScreenRect.x(), activeZoom); - int localY = unscaleCoordinate(documentY - contentScreenRect.y(), activeZoom); - DocumentInteractionSnapshot hit = LytDocument.pick(contentLayout.block(), localX, localY); - if (hit != null) { - return new NodeHit(hit.node(), hit.flowPath(), localX, localY); - } - } - return null; - } - - private int resolveNodeBadgeHeight(String nodeId, float activeZoom) { - FlowchartNode node = document.getNodes() - .get(nodeId); - if (node == null || node.getIcon() == null) return 0; - String badgeText = MermaidNodeRenderer.simplifyIcon(node.getIcon()); - if (badgeText == null) return 0; - ResolvedTextStyle badgeStyle = getOrScaleStyle(ICON_TEXT_STYLE, activeZoom); - int badgePaddingY = Math.max(1, Math.round(2 * activeZoom)); - int iconGapY = Math.max(1, Math.round(ICON_GAP_Y * activeZoom)); - return contextLineHeight(badgeStyle) + badgePaddingY * 2 + iconGapY; - } - - private void renderSubgraphs(RenderContext context, int baseX, int baseY, float activeZoom) { - if (layout == null) return; - for (var subgraph : document.getSubgraphs()) { - renderSubgraphRecursive(context, subgraph, layout.getNodePositions(), baseX, baseY, activeZoom, 0); - } - } - - private void renderSubgraphRecursive(RenderContext context, FlowchartSubgraph subgraph, - Map positions, int baseX, int baseY, float activeZoom, int depth) { - LytRect bounds = computeSubgraphBounds(subgraph, positions); - if (bounds == null) return; - - int pad = Math.round(SUBGRAPH_PADDING * activeZoom); - int sx = scaled(baseX, bounds.x() - pad, activeZoom); - int sy = scaled(baseY, bounds.y() - pad, activeZoom); - int sw = Math.max(1, Math.round((bounds.width() + pad * 2) * activeZoom)); - int sh = Math.max(1, Math.round((bounds.height() + pad * 2) * activeZoom)); - LytRect sgRect = new LytRect(sx, sy, sw, sh); - - int bg = context.resolveColor(SUBGRAPH_BG[depth % SUBGRAPH_BG.length]); - int border = context.resolveColor(SUBGRAPH_BORDER[depth % SUBGRAPH_BORDER.length]); - context.fillRect(sgRect, bg); - context.drawBorder(sgRect, border, Math.max(1, Math.round(1.5f * activeZoom))); - - String label = subgraph.getLabel(); - if (label != null && !label.isEmpty()) { - int labelPadX = Math.max(2, Math.round(4 * activeZoom)); - int labelPadY = Math.max(1, Math.round(2 * activeZoom)); - ResolvedTextStyle labelStyle = getOrScaleStyle(NODE_TEXT_STYLE, activeZoom); - LytRect labelRect = new LytRect( - sgRect.x() + labelPadX, - sgRect.y() + labelPadY, - context.getStringWidth(label, labelStyle), - context.getLineHeight(labelStyle)); - context.drawText(label, labelRect.x(), labelRect.y(), labelStyle); - } - - for (var child : subgraph.getChildren()) { - renderSubgraphRecursive(context, child, positions, baseX, baseY, activeZoom, depth + 1); - } - } - @Nullable private static LytRect computeSubgraphBounds(FlowchartSubgraph subgraph, Map positions) { LytRect result = null; diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytMermaidMindmapCanvas.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytMermaidMindmapCanvas.java index 5d23bb45..79459c26 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytMermaidMindmapCanvas.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytMermaidMindmapCanvas.java @@ -8,15 +8,19 @@ import com.hfstudio.guidenh.guide.color.ConstantColor; import com.hfstudio.guidenh.guide.document.LytRect; +import com.hfstudio.guidenh.guide.document.block.shapes.FlowchartShapes; import com.hfstudio.guidenh.guide.document.interaction.DocumentInteractionSnapshot; import com.hfstudio.guidenh.guide.internal.debug.DebugComponent; import com.hfstudio.guidenh.guide.internal.mermaid.MermaidNodeShape; import com.hfstudio.guidenh.guide.internal.mermaid.mindmap.MindmapDocument; import com.hfstudio.guidenh.guide.internal.mermaid.mindmap.MindmapLayoutMode; import com.hfstudio.guidenh.guide.internal.mermaid.mindmap.MindmapNode; +import com.hfstudio.guidenh.guide.layout.FontMetrics; import com.hfstudio.guidenh.guide.layout.LayoutContext; -import com.hfstudio.guidenh.guide.render.RenderContext; -import com.hfstudio.guidenh.guide.scene.LytGuidebookScene; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.GuideText; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; +import com.hfstudio.guidenh.guide.scene.support.GuideDebugLog; import com.hfstudio.guidenh.guide.style.ResolvedTextStyle; import com.hfstudio.guidenh.guide.style.TextAlignment; import com.hfstudio.guidenh.guide.style.WhiteSpaceMode; @@ -52,7 +56,8 @@ public class LytMermaidMindmapCanvas extends LytMermaidCanvas nodeContentBlocks) { this.mindmap = mindmap; @@ -146,11 +154,9 @@ protected LytRect computeLayout(LayoutContext context, int x, int y, int availab : Math.max(1, availableWidth); layout = buildLayout(context, safeWidth); int desiredHeight = layout.diagramHeight() + CANVAS_PADDING * 2; - int viewportHeight = preferredHeight > 0 ? Math.max(48, preferredHeight) - : Math.max(MIN_HEIGHT, Math.min(MAX_HEIGHT, desiredHeight)); - if (preferredHeight > 0 && safeWidth < resolvePreferredViewportWidth()) { - viewportHeight = Math.max(viewportHeight, Math.min(MAX_HEIGHT, desiredHeight)); - } + int viewportHeight = preferredHeight > 0 + ? Math.max(48, preferredHeight) + : Math.clamp(desiredHeight, MIN_HEIGHT, MAX_HEIGHT); int viewportWidth = Math.max(1, safeWidth - CANVAS_PADDING * 2); int innerViewportHeight = Math.max(1, viewportHeight - CANVAS_PADDING * 2); restoreViewportAfterLayout( @@ -164,13 +170,218 @@ protected LytRect computeLayout(LayoutContext context, int x, int y, int availab return new LytRect(x, y, safeWidth, viewportHeight); } + /** + * Pre-compute diagram layout before the first Rust layout pass and set + * preferredHeight so Rust allocates the correct canvas height immediately. + * Caches the layout result for reuse in afterExternalLayout when the + * actual bounds width matches the pre-computation width. + * + * @param ctx LayoutContext backed by GuideText-based FontMetrics + * @param availableWidth estimated canvas content width (page width or + * placeholder width) + */ + public void precomputeLayout(LayoutContext ctx, int availableWidth) { + int safeWidth = preferredWidth > 0 + ? Math.max(1, Math.min(preferredWidth, availableWidth)) + : Math.max(1, availableWidth); + this.layout = buildLayout(ctx, safeWidth); + this.precomputedLayoutWidth = safeWidth; + if (layout != null) { + int desiredHeight = layout.diagramHeight() + CANVAS_PADDING * 2; + int newPreferredHeight = preferredHeight > 0 + ? Math.max(48, preferredHeight) + : Math.clamp(desiredHeight, MIN_HEIGHT, MAX_HEIGHT); + preferredHeight = newPreferredHeight; + int diagramWidth = layout.diagramWidth() + CANVAS_PADDING * 2; + preferredWidth = diagramWidth; + GuideDebugLog.debugAlways( + "[GuideNH-Mermaid] precomputeLayout OK diagramHeight={} preferredHeight={}", + layout.diagramHeight(), preferredHeight); + GuideDebugLog.debugAlways( + "[GuideNH-Mermaid] precomputeLayout set explicitWidth={} diagramWidth={} safeWidth={}", + preferredWidth, layout.diagramWidth(), safeWidth); + } else { + GuideDebugLog.debugAlways( + "[GuideNH-Mermaid] precomputeLayout FAILED layout=null safeWidth={}", + safeWidth); + } + } + + @Override + protected void afterExternalLayout() { + int safeWidth = preferredWidth > 0 + ? Math.max(1, Math.min(preferredWidth, Math.max(1, bounds.width()))) + : Math.max(1, bounds.width()); + + GuideDebugLog.debugAlways( + "[GuideNH-Mermaid] afterExternalLayout entered layout={} safeWidth={} precomputedLayoutWidth={} bounds.height={}", + layout != null, safeWidth, precomputedLayoutWidth, bounds.height()); + + // Phase 1: ensure layout result matches the actual canvas width. + // Width matches precompute → reuse cached layout (no recompute). + // Width mismatch or no precompute → recompute at the correct width. + if (layout == null || precomputedLayoutWidth <= 0 || precomputedLayoutWidth != safeWidth) { + LayoutContext fallbackCtx = new LayoutContext(new FontMetrics() { + @Override + public float getAdvance(int codePoint, ResolvedTextStyle s) { + return GuideText.measureWidth(new String(Character.toChars(codePoint)), s); + } + @Override + public int getLineHeight(ResolvedTextStyle s) { + return GuideText.lineHeight(s); + } + }); + layout = buildLayout(fallbackCtx, safeWidth); + GuideDebugLog.debugAlways( + "[GuideNH-Mermaid] afterExternalLayout recomputed layout={}", + layout != null); + } + + // Phase 2: if layout is valid, correct bounds height if needed (兜底). + if (layout != null) { + int desiredHeight = layout.diagramHeight() + CANVAS_PADDING * 2; + int expectedHeight = preferredHeight > 0 + ? Math.max(48, preferredHeight) + : Math.clamp(desiredHeight, MIN_HEIGHT, MAX_HEIGHT); + if (bounds.height() != expectedHeight) { + GuideDebugLog.debugAlways( + "[GuideNH-Mermaid] afterExternalLayout correcting bounds height {} -> {}", + bounds.height(), expectedHeight); + bounds = new LytRect(bounds.x(), bounds.y(), bounds.width(), expectedHeight); + } + } + + GuideDebugLog.debugAlways( + "[GuideNH-Mermaid] afterExternalLayout exit layout={} bounds.height={}", + layout != null, bounds.height()); + } + @Override protected void onLayoutMoved(int deltaX, int deltaY) {} + // ---- primitives pipeline (replaces render* for the primitives path) ---- + @Override - protected void renderDiagram(RenderContext context, int baseX, int baseY, float activeZoom) { - renderConnectors(context, layout.root(), baseX, baseY); - renderNodes(context, layout.root(), baseX, baseY); + public boolean usePrimitives() { + return true; + } + + @Override + protected void emitDiagramPrimitives(PrimitiveCollector c, int baseX, int baseY, float activeZoom) { + emitConnectorsPrimitives(c, layout.root(), baseX, baseY, activeZoom); + emitNodesPrimitives(c, layout.root(), baseX, baseY, activeZoom); + } + + private void emitConnectorsPrimitives(PrimitiveCollector c, NodeLayout node, int baseX, int baseY, + float activeZoom) { + for (NodeLayout child : node.children) { + if (mindmap.getLayoutMode() == MindmapLayoutMode.TIDY_TREE) { + emitVerticalConnector( + c, + scaled(baseX, node.centerX(), activeZoom), + scaled(baseY, node.bottom(), activeZoom), + scaled(baseX, child.centerX(), activeZoom), + scaled(baseY, child.y, activeZoom), + 0xFF5D6C7C); + } else { + boolean rightSide = child.centerX() >= node.centerX(); + int parentEdgeX = scaled(baseX, rightSide ? node.right() : node.x, activeZoom); + int childEdgeX = scaled(baseX, rightSide ? child.x : child.right(), activeZoom); + emitHorizontalConnector( + c, + parentEdgeX, + scaled(baseY, node.centerY(), activeZoom), + childEdgeX, + scaled(baseY, child.centerY(), activeZoom), + 0xFF5D6C7C); + } + emitConnectorsPrimitives(c, child, baseX, baseY, activeZoom); + } + } + + private void emitHorizontalConnector(PrimitiveCollector c, int startX, int startY, int endX, int endY, int color) { + int midX = (startX + endX) / 2; + emitHorizontalLine(c, startX, midX, startY, color); + emitVerticalLine(c, midX, startY, endY, color); + emitHorizontalLine(c, midX, endX, endY, color); + } + + private void emitVerticalConnector(PrimitiveCollector c, int startX, int startY, int endX, int endY, int color) { + int midY = (startY + endY) / 2; + emitVerticalLine(c, startX, startY, midY, color); + emitHorizontalLine(c, startX, endX, midY, color); + emitVerticalLine(c, endX, midY, endY, color); + } + + private void emitHorizontalLine(PrimitiveCollector c, int startX, int endX, int y, int color) { + int left = Math.min(startX, endX); + int width = Math.abs(endX - startX) + 1; + c.emit(new GuideRenderPrimitive.FillRect(left, y, width, CONNECTOR_THICKNESS, color)); + } + + private void emitVerticalLine(PrimitiveCollector c, int x, int startY, int endY, int color) { + int top = Math.min(startY, endY); + int height = Math.abs(endY - startY) + 1; + c.emit(new GuideRenderPrimitive.FillRect(x, top, CONNECTOR_THICKNESS, height, color)); + } + + private void emitNodesPrimitives(PrimitiveCollector c, NodeLayout node, int baseX, int baseY, float activeZoom) { + LytRect rect = new LytRect( + scaled(baseX, node.x, activeZoom), + scaled(baseY, node.y, activeZoom), + Math.max(1, Math.round(node.width * activeZoom)), + Math.max(1, Math.round(node.height * activeZoom))); + LytRect boxRect = rect; + NodeColors colors = resolveColors(node.node); + MermaidNodeShape shape = node.node.getShape(); + FlowchartShapes.emitShape(c, shape, boxRect, colors.background, colors.border); + if (FlowchartShapes.hasAccentBar(shape)) { + c.emit(new GuideRenderPrimitive.FillRect(boxRect.x(), boxRect.y(), 3, boxRect.height(), colors.accent)); + } + + ResolvedTextStyle style = getOrScaleStyle(node.depth == 0 ? ROOT_TEXT_STYLE : NODE_TEXT_STYLE, activeZoom); + ResolvedTextStyle badgeStyle = getOrScaleStyle(ICON_TEXT_STYLE, activeZoom); + int paddingX = Math.max(1, Math.round(NODE_PADDING_X * activeZoom)); + int paddingY = Math.max(1, Math.round(NODE_PADDING_Y * activeZoom)); + int iconGapY = Math.max(1, Math.round(ICON_GAP_Y * activeZoom)); + int badgePaddingX = Math.max(2, Math.round(4 * activeZoom)); + int badgePaddingY = Math.max(1, Math.round(2 * activeZoom)); + int textY = rect.y() + paddingY; + if (node.showBadge && node.badgeText != null) { + int badgeWidth = Math.max(1, GuideText.measureWidth(node.badgeText, badgeStyle) + badgePaddingX * 2); + int badgeHeight = Math.max(1, GuideText.lineHeight(badgeStyle) + badgePaddingY * 2); + LytRect badge = new LytRect( + rect.x() + paddingX, + textY, + badgeWidth, + badgeHeight); + c.emit(new GuideRenderPrimitive.FillRect( + badge.x(), badge.y(), badge.width(), badge.height(), + MermaidNodeRenderer.BADGE_BACKGROUND)); + c.emit(new GuideRenderPrimitive.DrawBorder( + badge.x(), badge.y(), badge.width(), badge.height(), + 1, 1, 1, 1, MermaidNodeRenderer.BADGE_BORDER)); + GuideText.emitText(c, node.badgeText, badge.x() + badgePaddingX, badge.y() + badgePaddingY, badgeStyle); + textY = badge.bottom() + iconGapY; + } + + if (node.contentLayout != null) { + LytRect contentViewport = resolveNodeContentRect(node.contentLayout, rect, paddingX, textY, activeZoom); + emitNodeContentPrimitives(c, node.contentLayout.block(), contentViewport, + node.contentLayout.visualBounds(), activeZoom); + } else { + int lineHeight = GuideText.lineHeight(style); + for (String line : node.lines) { + int lineWidth = GuideText.measureWidth(line, style); + int textX = rect.x() + Math.max(paddingX, (rect.width() - lineWidth) / 2); + GuideText.emitText(c, line, textX, textY, style); + textY += lineHeight; + } + } + + for (NodeLayout child : node.children) { + emitNodesPrimitives(c, child, baseX, baseY, activeZoom); + } } private DiagramLayout buildLayout(LayoutContext context, int availableWidth) { @@ -355,7 +566,14 @@ private NodeLayout prepareLayout(LayoutContext context, MindmapNode node, int de } LayoutContext localContext = new LayoutContext(context).withVisualScale(context.getVisualScale()); int contentWidth = Math.clamp(maxNodeTextWidth + 60, 96, 240); - block.layout(localContext, 0, 0, contentWidth); + // LytVBox.computeBoxLayout is a stub (Rust is the sole layout authority + // for the normal document pipeline), so NodeContent subtrees — which + // never reach the document's Rust pass — used to be laid out manually. + // The Rust engine now lays the subtree out directly (including the + // inline post-pass that anchors inline ItemImage bounds at their text + // pen position), with a Java fallback for environments without the + // native bridge. + layoutNodeContentWithRust(localContext, block, contentWidth); LytRect visualBounds = resolveBlockVisualBounds(block); return new NodeContentLayout(block, visualBounds); } @@ -449,107 +667,6 @@ private void layoutTopDown(NodeLayout node, int x, int y) { } } - private void renderConnectors(RenderContext context, NodeLayout node, int baseX, int baseY) { - float activeZoom = getActiveZoom(); - for (NodeLayout child : node.children) { - if (mindmap.getLayoutMode() == MindmapLayoutMode.TIDY_TREE) { - drawVerticalConnector( - context, - scaled(baseX, node.centerX(), activeZoom), - scaled(baseY, node.bottom(), activeZoom), - scaled(baseX, child.centerX(), activeZoom), - scaled(baseY, child.y, activeZoom), - 0xFF5D6C7C); - } else { - boolean rightSide = child.centerX() >= node.centerX(); - int parentEdgeX = scaled(baseX, rightSide ? node.right() : node.x, activeZoom); - int childEdgeX = scaled(baseX, rightSide ? child.x : child.right(), activeZoom); - drawHorizontalConnector( - context, - parentEdgeX, - scaled(baseY, node.centerY(), activeZoom), - childEdgeX, - scaled(baseY, child.centerY(), activeZoom), - 0xFF5D6C7C); - } - renderConnectors(context, child, baseX, baseY); - } - } - - private void renderNodes(RenderContext context, NodeLayout node, int baseX, int baseY) { - float activeZoom = getActiveZoom(); - LytRect rect = new LytRect( - scaled(baseX, node.x, activeZoom), - scaled(baseY, node.y, activeZoom), - Math.max(1, Math.round(node.width * activeZoom)), - Math.max(1, Math.round(node.height * activeZoom))); - LytRect boxRect = rect; - NodeColors colors = resolveColors(node.node); - context.fillRect(boxRect, colors.background); - context.drawBorder(boxRect, colors.border, node.node.getShape() == MermaidNodeShape.BANG ? 2 : 1); - context.fillRect(new LytRect(boxRect.x(), boxRect.y(), 3, boxRect.height()), colors.accent); - - ResolvedTextStyle style = getOrScaleStyle(node.depth == 0 ? ROOT_TEXT_STYLE : NODE_TEXT_STYLE, activeZoom); - ResolvedTextStyle badgeStyle = getOrScaleStyle(ICON_TEXT_STYLE, activeZoom); - int paddingX = Math.max(1, Math.round(NODE_PADDING_X * activeZoom)); - int paddingY = Math.max(1, Math.round(NODE_PADDING_Y * activeZoom)); - int iconGapY = Math.max(1, Math.round(ICON_GAP_Y * activeZoom)); - int badgePaddingX = Math.max(2, Math.round(4 * activeZoom)); - int badgePaddingY = Math.max(1, Math.round(2 * activeZoom)); - int textY = rect.y() + paddingY; - if (node.showBadge && node.badgeText != null) { - int badgeWidth = Math.max(1, context.getStringWidth(node.badgeText, badgeStyle) + badgePaddingX * 2); - LytRect badge = new LytRect( - rect.x() + paddingX, - textY, - badgeWidth, - Math.max(1, context.getLineHeight(badgeStyle) + badgePaddingY * 2)); - context.fillRect(badge, 0x262A3340); - context.drawBorder(badge, 0x66434C57, 1); - context.drawText(node.badgeText, badge.x() + badgePaddingX, badge.y() + badgePaddingY, badgeStyle); - textY = badge.bottom() + iconGapY; - } - - if (node.contentLayout != null) { - renderNodeContent(context, node, rect, paddingX, textY, activeZoom); - } else { - int lineHeight = context.getLineHeight(style); - for (String line : node.lines) { - int lineWidth = MermaidNodeRenderer.measureText(context, style, line); - int textX = rect.x() + Math.max(paddingX, (rect.width() - lineWidth) / 2); - context.drawText(line, textX, textY, style); - textY += lineHeight; - } - } - - for (NodeLayout child : node.children) { - renderNodes(context, child, baseX, baseY); - } - } - - private void renderNodeContent(RenderContext context, NodeLayout node, LytRect rect, int paddingX, int contentY, - float activeZoom) { - if (node.contentLayout == null) return; - LytRect contentViewport = resolveNodeContentRect(node.contentLayout, rect, paddingX, contentY, activeZoom); - renderNodeContent( - context, - node.contentLayout.block(), - contentViewport, - node.contentLayout.visualBounds(), - activeZoom); - } - - private static boolean containsScene(@Nullable LytBlock block) { - if (block == null) return false; - if (block instanceof LytGuidebookScene) return true; - if (block instanceof LytNode container) { - for (var child : container.getChildren()) { - if (child instanceof LytBlock childBlock && containsScene(childBlock)) return true; - } - } - return false; - } - @Override @Nullable protected NodeHit pickNodeHit(int documentX, int documentY) { @@ -683,50 +800,10 @@ private NodeColors resolveColors(MindmapNode node) { return new NodeColors(background, border, accent); } - private void drawHorizontalConnector(RenderContext context, int startX, int startY, int endX, int endY, int color) { - int midX = (startX + endX) / 2; - fillHorizontalLine(context, startX, midX, startY, color); - fillVerticalLine(context, midX, startY, endY, color); - fillHorizontalLine(context, midX, endX, endY, color); - } - - private void drawVerticalConnector(RenderContext context, int startX, int startY, int endX, int endY, int color) { - int midY = (startY + endY) / 2; - fillVerticalLine(context, startX, startY, midY, color); - fillHorizontalLine(context, startX, endX, midY, color); - fillVerticalLine(context, endX, midY, endY, color); - } - - private void fillHorizontalLine(RenderContext context, int startX, int endX, int y, int color) { - int left = Math.min(startX, endX); - int width = Math.abs(endX - startX) + 1; - context.fillRect(new LytRect(left, y, width, CONNECTOR_THICKNESS), color); - } - - private void fillVerticalLine(RenderContext context, int x, int startY, int endY, int color) { - int top = Math.min(startY, endY); - int height = Math.abs(endY - startY) + 1; - context.fillRect(new LytRect(x, top, CONNECTOR_THICKNESS, height), color); - } - private int resolvePreferredViewportWidth() { return preferredWidth > 0 ? preferredWidth : MIN_WIDTH; } - LytRect getContentBoundsForTesting() { - return layout != null ? layout.contentBounds() : LytRect.empty(); - } - - public interface AdvanceFunction { - - float getAdvance(int codePoint, ResolvedTextStyle style); - } - - private interface WordVisitor { - - boolean accept(String word); - } - public static class DiagramLayout { private final NodeLayout root; diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytParagraph.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytParagraph.java index ff4c68b5..58c6b074 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytParagraph.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytParagraph.java @@ -11,20 +11,288 @@ import com.hfstudio.guidenh.guide.document.LytRect; import com.hfstudio.guidenh.guide.document.flow.LytFlowContainer; import com.hfstudio.guidenh.guide.document.flow.LytFlowContent; +import com.hfstudio.guidenh.guide.document.flow.LytFlowInlineBlock; +import com.hfstudio.guidenh.guide.document.flow.LytFlowSpan; +import com.hfstudio.guidenh.guide.document.flow.LytFlowText; +import com.hfstudio.guidenh.guide.document.flow.LytSpoilerSpan; import com.hfstudio.guidenh.guide.document.interaction.FlowInteractionPath; import com.hfstudio.guidenh.guide.internal.debug.DebugFlowContainer; import com.hfstudio.guidenh.guide.layout.LayoutContext; -import com.hfstudio.guidenh.guide.layout.flow.FlowBuilder; -import com.hfstudio.guidenh.guide.layout.flow.LineElement; +import com.hfstudio.guidenh.guide.render.GlyphRunData; +import com.hfstudio.guidenh.guide.render.GlyphRunGroup; +import com.hfstudio.guidenh.guide.render.GlyphRunHolder; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.GuideText; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.render.RenderContext; +import com.hfstudio.guidenh.guide.style.ResolvedTextStyle; import com.hfstudio.guidenh.guide.style.TextStyle; import lombok.Getter; import lombok.Setter; -public class LytParagraph extends LytBlock implements LytFlowContainer, DebugFlowContainer { +public class LytParagraph extends LytBlock implements LytFlowContainer, DebugFlowContainer, GlyphRunHolder { - protected final FlowBuilder content = new FlowBuilder(); + private final List flowContent = new ArrayList<>(); + + // Rich glyph output from Rust cosmic-text shaping (per-span runs + decorations) + @Nullable + private GlyphRunData glyphData; + + @Override + public void setGlyphData(@Nullable GlyphRunData data) { + this.glyphData = data; + } + + @Override + public @Nullable GlyphRunData getGlyphData() { + return glyphData; + } + + /** + * Render through the primitive pipeline when a Rust-shaped glyph run is + * available. Opaque paragraphs (§k/obfuscated, float-aligned inline blocks) + * keep legacy HostDraw rendering via {@link #render(RenderContext)}. + */ + @Override + public boolean usePrimitives() { + return !flowContent.isEmpty(); + } + + @Override + public List getChildren() { + // Surface inline blocks (icons, formulas, etc. embedded in the flow + // content) as real tree children: the serializer pairs them with the + // U+FFFC placeholders in the paragraph text, and the render collector + // traverses them like any other child. + return getInlineBlocks(); + } + + /** + * The inner blocks of this paragraph's {@code LytFlowInlineBlock} wrappers, + * in document order. Empty for plain-text paragraphs. + */ + public List getInlineBlocks() { + List out = new ArrayList<>(); + for (LytFlowContent fc : getContent()) { + collectInlineBlocks(fc, out); + } + return out; + } + + private static void collectInlineBlocks(LytFlowContent fc, List out) { + if (fc instanceof LytFlowInlineBlock ib && ib.getBlock() != null) { + out.add(ib.getBlock()); + } else if (fc instanceof LytFlowSpan fs) { + for (LytFlowContent child : fs.getChildren()) { + collectInlineBlocks(child, out); + } + } + } + + @Override + protected void onExternalLayoutApplied(LytRect oldBounds, LytRect newBounds) { + } + + @Override + public void computePrimitives(PrimitiveCollector c) { + // Obfuscated (§k) paragraphs: render per-frame random characters via + // GuideText at the Rust-computed paragraph bounds. Layout geometry + // comes from Rust (single authority); animation is a rendering concern. + if (hasObfuscatedStyles(getContent())) { + emitObfuscatedText(c); + return; + } + if (glyphData != null && !glyphData.runs() + .isEmpty()) { + // Span backgrounds (highlight / inline-code) behind the glyphs; + // underline / strikethrough on top. + for (GuideRenderPrimitive.FillRect bg : glyphData.backgrounds()) { + c.emit(bg); + } + List spanOwners = hasSpoiler() ? collectSpanOwners() : null; + List runs = glyphData.runs(); + for (int si = 0; si < runs.size(); si++) { + GlyphRunGroup group = runs.get(si); + if (spanOwners != null && si < spanOwners.size() && isSpoilerHidden(spanOwners.get(si))) { + emitSpoilerMask(c, group); + } else { + c.emit( + new GuideRenderPrimitive.DrawGlyphRun( + group.glyphs(), + group.argb(), + group.shear(), + resolveStyle().dropShadow())); + } + } + for (GuideRenderPrimitive.FillRect line : glyphData.lines()) { + c.emit(line); + } + // Wavy / dotted decorations (kind 4/5) draw on top, after the + // plain underline / strikethrough lines. + for (GuideRenderPrimitive.DrawDecorationLine decoration : glyphData.decorations()) { + c.emit(decoration); + } + return; + } + // Fallback: glyph data unavailable — emit text through GuideText so the + // paragraph renders as visible text instead of silent blank. + emitTextFallback(c); + } + + private boolean hasSpoiler() { + for (LytFlowContent fc : getContent()) { + if (hasSpoilerIn(fc)) return true; + } + return false; + } + + private static boolean hasSpoilerIn(LytFlowContent fc) { + if (fc instanceof LytSpoilerSpan) return true; + if (fc instanceof LytFlowSpan span) { + for (LytFlowContent child : span.getChildren()) { + if (hasSpoilerIn(child)) return true; + } + } + return false; + } + + private boolean isSpoilerHidden(LytFlowContent owner) { + LytSpoilerSpan spoiler = owner.findAncestor(LytSpoilerSpan.class); + if (spoiler == null) return false; + if (owner instanceof LytSpoilerSpan) spoiler = (LytSpoilerSpan) owner; + boolean hovered = hoveredPath != null && hoveredPath.containsPrimaryOrDescendant(owner); + boolean revealed = revealedPath != null && revealedPath.containsOrAncestors(owner); + return !hovered && !revealed; + } + + private static void emitSpoilerMask(PrimitiveCollector c, GlyphRunGroup group) { + if (group.glyphs() + .isEmpty()) return; + float minX = Float.MAX_VALUE, minY = Float.MAX_VALUE, maxX = 0, maxY = 0; + for (var g : group.glyphs()) { + minX = Math.min(minX, g.x()); + minY = Math.min(minY, g.y()); + maxX = Math.max(maxX, g.x() + g.w()); + maxY = Math.max(maxY, g.y() + g.h()); + } + c.emit( + new GuideRenderPrimitive.FillRect( + Math.round(minX) - 1, + Math.round(minY) - 1, + Math.round(maxX - minX) + 2, + Math.round(maxY - minY) + 2, + 0xFF000000)); + } + + /** + * Emit obfuscated (§k) text via GuideText with per-frame random characters. + * Rust provides layout geometry (paragraph bounds); rendering is handled + * here as a native GuideText call — no LineBuilder dependency. + */ + private void emitObfuscatedText(PrimitiveCollector c) { + StringBuilder text = new StringBuilder(); + for (LytFlowContent fc : getContent()) { + collectObfuscatedText(fc, text); + } + if (text.isEmpty()) return; + StringBuilder random = new StringBuilder(text.length()); + for (int i = 0; i < text.length(); i++) { + char ch = text.charAt(i); + if (Character.isWhitespace(ch)) { + random.append(ch); + } else { + random.append(randomObfuscatedChar()); + } + } + GuideText.emitText(c, random.toString(), bounds.x(), bounds.y(), resolveStyle()); + } + + private static void collectObfuscatedText(LytFlowContent fc, StringBuilder out) { + if (fc instanceof LytFlowText ft) { + out.append(ft.getText()); + } else if (fc instanceof LytFlowInlineBlock) { + out.append(' '); // placeholder space for inline blocks + } else if (fc instanceof LytFlowSpan fs) { + for (LytFlowContent child : fs.getChildren()) { + collectObfuscatedText(child, out); + } + } + } + + /** + * Fallback emission: collect all plain text from flow content and emit via + * GuideText (atlas-backed glyph run). Used when glyphData is null or empty + * so the paragraph renders visible text instead of silent blank. + */ + private void emitTextFallback(PrimitiveCollector c) { + StringBuilder text = new StringBuilder(); + for (LytFlowContent fc : getContent()) { + collectPlainText(fc, text); + } + if (text.isEmpty()) return; + GuideText.emitText(c, text.toString(), bounds.x(), bounds.y(), resolveStyle()); + } + + /** + * Collect plain (non-obfuscated) text from a flow-content subtree. + */ + private static void collectPlainText(LytFlowContent fc, StringBuilder out) { + if (fc instanceof LytFlowText ft) { + out.append(ft.getText()); + } else if (fc instanceof LytFlowInlineBlock) { + out.append(' '); // placeholder space for inline blocks + } else if (fc instanceof LytFlowSpan fs) { + for (LytFlowContent child : fs.getChildren()) { + collectPlainText(child, out); + } + } + } + + private static char randomObfuscatedChar() { + // Fast per-frame random character from ASCII letters and digits, + // matching Minecraft's §k visual style. + long t = System.nanoTime(); + int idx = (int) (t % 62); + if (idx < 26) return (char) ('A' + idx); + if (idx < 52) return (char) ('a' + idx - 26); + return (char) ('0' + idx - 52); + } + + /** + * Obfuscated-only detection: {@code §k} content cannot be baked into a + * static glyph run (per-frame random animation). Spoiler spans are NOT + * included — they get glyph runs with a render-time overlay. + */ + public static boolean hasObfuscatedStyles(Iterable content) { + for (LytFlowContent fc : content) { + if (hasObfuscatedIn(fc)) { + return true; + } + } + return false; + } + + private static boolean hasObfuscatedIn(LytFlowContent fc) { + if (fc instanceof LytFlowSpan span) { + for (LytFlowContent child : span.getChildren()) { + if (hasObfuscatedIn(child)) { + return true; + } + } + } + if (fc instanceof LytFlowText text) { + if (text.getText() + .contains("§k")) { + return true; + } + if (fc.resolveStyle() + .obfuscated()) { + return true; + } + } + return false; + } @Getter @Setter @@ -46,17 +314,12 @@ public class LytParagraph extends LytBlock implements LytFlowContainer, DebugFlo @Override public void append(LytFlowContent child) { - content.append(child); + flowContent.add(child); child.setParent(this); } @Override public boolean isCulled(LytRect viewport) { - // If we have floating content, account for its bounding box exceeding our content box - if (content.floatsIntersect(viewport)) { - return false; - } - return super.isCulled(viewport); } @@ -67,19 +330,83 @@ public LytRect computeLayout(LayoutContext context, int x, int y, int availableW availableWidth -= paddingLeft + paddingRight; y += paddingTop; - var style = resolveStyle(); - - var bounds = content.computeLayout(context, x, y, availableWidth, style.alignment()); - - if (paddingBottom != 0) { - return bounds.withHeight(bounds.height() + paddingBottom); + // Paragraph geometry is Rust's sole authority — all paragraphs skip + // the expensive LineBuilder pass. Inline block children still need + // their sizes computed here (the serializer reads them before Rust + // takes over); positions are assigned later by the Rust inline post-pass. + for (LytBlock ib : getInlineBlocks()) { + ib.layout(context, 0, 0, availableWidth); } - return bounds; + int h = paddingTop + paddingBottom + 10; // minimal estimate + return new LytRect(x - paddingLeft, y - paddingTop, availableWidth, h); } @Override protected void onLayoutMoved(int deltaX, int deltaY) { - content.move(deltaX, deltaY); + // The Rust-baked glyph run uses absolute document coordinates — it must + // follow the paragraph's bounds (scroll replay, smooth scrolling) or the + // text detaches from the paragraph's background/clip/hover geometry. + if (glyphData != null && !glyphData.runs() + .isEmpty()) { + List movedGroups = new ArrayList<>( + glyphData.runs() + .size()); + for (GlyphRunGroup group : glyphData.runs()) { + List moved = new ArrayList<>( + group.glyphs() + .size()); + for (var g : group.glyphs()) { + moved.add( + new GuideRenderPrimitive.PlacedGlyph( + g.atlasKey(), + g.x() + deltaX, + g.y() + deltaY, + g.w(), + g.h(), + g.lineIndex())); + } + movedGroups.add(new GlyphRunGroup(moved, group.argb(), group.shear())); + } + // Decoration rects are absolute document coordinates too — they must + // follow the same move. + glyphData = new GlyphRunData( + movedGroups, + moveRects(glyphData.backgrounds(), deltaX, deltaY), + moveRects(glyphData.lines(), deltaX, deltaY), + moveRects(glyphData.separators(), deltaX, deltaY), + moveDecorations(glyphData.decorations(), deltaX, deltaY)); + } + } + + private static List moveRects(List rects, int deltaX, + int deltaY) { + if (rects.isEmpty() || (deltaX == 0 && deltaY == 0)) { + return rects; + } + List moved = new ArrayList<>(rects.size()); + for (var r : rects) { + moved.add(new GuideRenderPrimitive.FillRect(r.x() + deltaX, r.y() + deltaY, r.w(), r.h(), r.argb())); + } + return moved; + } + + private static List moveDecorations( + List decorations, int deltaX, int deltaY) { + if (decorations.isEmpty() || (deltaX == 0 && deltaY == 0)) { + return decorations; + } + List moved = new ArrayList<>(decorations.size()); + for (var d : decorations) { + moved.add( + new GuideRenderPrimitive.DrawDecorationLine( + d.x() + deltaX, + d.y() + deltaY, + d.w(), + d.h(), + d.argb(), + d.kind())); + } + return moved; } @Override @@ -103,41 +430,106 @@ public void onMouseLeave() { @Override public @Nullable LytNode pickNode(int x, int y) { - // If we are the host for any floating elements, those can exceed our own bounds - var fl = content.pickFloatingElement(x, y); - if (fl != null) { - return this; - } - return super.pickNode(x, y); } @Override public void render(RenderContext context) { - // Since we overwrite isCulled, we render even if our actual line content is culled, for floats - if (context.intersectsViewport(bounds)) { - content.render(context, hoveredPath, revealedPath); + // All block-tree rendering goes through computePrimitives (usePrimitives + // always returns true when content exists). This legacy-path fallback is + // only reached by direct render() callers outside the document pipeline + // (tooltip / annotation / editor chains, e.g. ContentTooltip content and + // TextAnnotation rich content). + if (flowContent.isEmpty()) return; + if (glyphData != null && !glyphData.runs() + .isEmpty()) return; + StringBuilder text = new StringBuilder(); + for (LytFlowContent fc : getContent()) { + collectPlainText(fc, text); + } + if (!text.isEmpty()) { + context.drawText(text.toString(), bounds.x(), bounds.y(), resolveStyle()); } - - content.renderFloats(context, hoveredPath, revealedPath); } @Override public @Nullable FlowInteractionPath pickContent(int x, int y) { - return content.pickPath(x, y); + if (glyphData != null && !glyphData.runs() + .isEmpty()) { + var hit = pickFromGlyphRuns(x, y); + if (hit != null) { + return hit; + } + } + return null; } - public @Nullable LytRect getFirstLineBounds() { - return content.getFirstLineBounds(); + @Nullable + private FlowInteractionPath pickFromGlyphRuns(int x, int y) { + List spanOwners = collectSpanOwners(); + var runs = glyphData.runs(); + for (int si = 0; si < runs.size(); si++) { + var group = runs.get(si); + for (var g : group.glyphs()) { + if (x >= g.x() && x <= g.x() + g.w() && y >= g.y() && y <= g.y() + g.h()) { + LytFlowContent owner = si < spanOwners.size() ? spanOwners.get(si) : null; + if (owner != null) { + return FlowInteractionPath.fromPrimary(owner); + } + return null; + } + } + } + return null; + } + + private List collectSpanOwners() { + List owners = new ArrayList<>(); + for (LytFlowContent fc : getContent()) { + collectSpanOwnersRecursive(fc, owners); + } + return owners; + } + + private static void collectSpanOwnersRecursive(LytFlowContent fc, List out) { + if (fc instanceof LytFlowText || fc instanceof LytFlowInlineBlock) { + out.add(fc); + } else if (fc instanceof LytFlowSpan span) { + for (LytFlowContent child : span.getChildren()) { + collectSpanOwnersRecursive(child, out); + } + } } public @Nullable LytRect getFirstTextRunBounds() { - return content.getFirstTextRunBounds(); + if (glyphData != null && !glyphData.runs() + .isEmpty()) { + return firstLineBoundsFromGlyphs(); + } + return null; + } + + @Nullable + private LytRect firstLineBoundsFromGlyphs() { + float minX = Float.MAX_VALUE, minY = Float.MAX_VALUE, maxX = 0, maxY = 0; + boolean found = false; + for (GlyphRunGroup group : glyphData.runs()) { + for (var g : group.glyphs()) { + if (g.lineIndex() != 0) continue; + found = true; + minX = Math.min(minX, g.x()); + minY = Math.min(minY, g.y()); + maxX = Math.max(maxX, g.x() + g.w()); + maxY = Math.max(maxY, g.y() + g.h()); + } + } + if (!found) return null; + return new LytRect(Math.round(minX), Math.round(minY), Math.round(maxX - minX), Math.round(maxY - minY)); } @Override public Stream enumerateContentBounds(LytFlowContent content) { - return this.content.enumerateContentBounds(content); + return Stream.empty(); } @Override @@ -154,15 +546,15 @@ protected LytVisitor.Result visitChildren(LytVisitor visitor, boolean includeOut } public Iterable getContent() { - return content.getContent(); + return flowContent; } public boolean isEmpty() { - return content.isEmpty(); + return flowContent.isEmpty(); } public void clearContent() { - content.clear(); + flowContent.clear(); } /** @@ -226,20 +618,11 @@ public static LytParagraph error(String text) { @Override @Nullable public FlowContentEntry pickFlowContent(int x, int y) { - LineElement element = content.pick(x, y); - if (element != null) { - return new FlowContentEntry(element.getFlowContent(), element.bounds); - } return null; } @Override public List getAllFlowContent() { - List entries = new ArrayList<>(); - for (LytFlowContent flowContent : getContent()) { - content.enumerateContentBounds(flowContent) - .forEach(bounds -> entries.add(new FlowContentEntry(flowContent, bounds))); - } - return entries; + return List.of(); } } diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytPlaceholderBlock.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytPlaceholderBlock.java deleted file mode 100644 index 8fc3e4fd..00000000 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytPlaceholderBlock.java +++ /dev/null @@ -1,80 +0,0 @@ -package com.hfstudio.guidenh.guide.document.block; - -import java.util.ArrayList; -import java.util.List; -import java.util.concurrent.CompletableFuture; - -import com.hfstudio.guidenh.guide.document.DefaultStyles; -import com.hfstudio.guidenh.guide.document.LytRect; -import com.hfstudio.guidenh.guide.layout.LayoutContext; -import com.hfstudio.guidenh.guide.render.RenderContext; -import com.hfstudio.guidenh.guide.scene.support.GuideDebugLog; - -/** - * This layout block shows a loading indicator and will ultimately replace itself with the final content. - */ -public class LytPlaceholderBlock extends LytBlock { - - private final CompletableFuture future; - - private LytBlock currentBlock; - - private final List currentChildren = new ArrayList<>(1); - - public LytPlaceholderBlock(CompletableFuture future) { - var loading = new LytParagraph(); - loading.appendText("Loading..."); - setCurrent(loading); - - this.future = future; - future.whenCompleteAsync(this::onLoad, Runnable::run); - } - - private void setCurrent(LytBlock block) { - if (currentBlock != block) { - currentChildren.clear(); - currentBlock = block; - currentChildren.add(block); - var document = getDocument(); - if (document != null) { - document.invalidateLayout(); - } - } - } - - private void onLoad(LytBlock element, Throwable error) { - if (error != null || element == null) { - GuideDebugLog.error("[GuideNH] [LytPlaceholderBlock] Failed to load an asynchronous guide element.", error); - var errorParagraph = new LytParagraph(); - errorParagraph.setStyle(DefaultStyles.ERROR_TEXT); - if (error == null) { - errorParagraph.appendText("An unknown error occurred"); - } else { - errorParagraph.appendText(error.toString()); - } - setCurrent(errorParagraph); - } else { - setCurrent(element); - } - } - - @Override - protected LytRect computeLayout(LayoutContext context, int x, int y, int availableWidth) { - return currentBlock.layout(context, x, y, availableWidth); - } - - @Override - protected void onLayoutMoved(int deltaX, int deltaY) { - currentBlock.onLayoutMoved(deltaX, deltaY); - } - - @Override - public void render(RenderContext context) { - currentBlock.render(context); - } - - @Override - public List getChildren() { - return List.copyOf(currentChildren); - } -} diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytQuoteBox.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytQuoteBox.java index 5f22d742..b610823b 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytQuoteBox.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytQuoteBox.java @@ -10,6 +10,7 @@ import com.hfstudio.guidenh.guide.document.LytRect; import com.hfstudio.guidenh.guide.document.flow.LytFlowContent; import com.hfstudio.guidenh.guide.layout.LayoutContext; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.render.RenderContext; import com.hfstudio.guidenh.guide.style.BorderStyle; @@ -85,6 +86,16 @@ public void append(LytBlock block) { content.append(block); } + /** + * The container holding this quote box's body paragraphs, nested below the + * optional title row. The blockquote compiler clears the body's edge + * paragraph margins against it so the title row's spacing is carried by the + * root's gap instead of the first body paragraph's own top margin. + */ + public LytVBox getBodyContainer() { + return content; + } + @Override public void removeChild(LytNode node) { content.removeChild(node); @@ -110,6 +121,17 @@ protected void onLayoutMoved(int deltaX, int deltaY) { root.moveLayoutPos(deltaX, deltaY); } + @Override + public boolean usePrimitives() { + return true; + } + + @Override + public void computePrimitives(PrimitiveCollector c) { + // No-op: the internal root (LytVBox) is a child returned by getChildren() + // and will be visited by PrimitiveCollector.collectFrom traversal. + } + @Override public void render(RenderContext context) { root.render(context); diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytSizeBox.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytSizeBox.java index 36e1e7d6..cb54aaaa 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytSizeBox.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytSizeBox.java @@ -7,6 +7,8 @@ import com.hfstudio.guidenh.guide.internal.editor.gui.SceneEditorVerticalScrollbar; import com.hfstudio.guidenh.guide.internal.util.SmoothFloatState; import com.hfstudio.guidenh.guide.layout.LayoutContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.render.RenderContext; import lombok.Getter; @@ -23,19 +25,42 @@ public class LytSizeBox extends LytVBox implements DocumentDragTarget { private int preferredWidth; @Getter private int preferredHeight; - private int contentHeight; - private int viewportX; - private int viewportY; - private int viewportWidth; - private int viewportHeight; + /** Scrollable viewport wrapping the content; clips children to its bounds. */ + private final LytViewportBox viewport = new LytViewportBox(); + /** Content container: receives all externally appended children. */ + private final LytVBox content = new LytVBox(); private int scrollOffsetY; private int appliedScrollOffsetY; + /** Visual-scroll delta currently baked into the content bounds (see computePrimitives). */ + private int visualDeltaY; private final SmoothFloatState visualScrollOffsetY = new SmoothFloatState(); private boolean draggingContent; private int dragLastDocumentY; private boolean draggingScrollbar; private int scrollbarGrabOffsetY; + public LytSizeBox() { + viewport.setFullWidth(true); + viewport.append(content); + super.append(viewport); + } + + /** External content is appended into the inner content box, inside the viewport. */ + @Override + public void append(LytBlock block) { + content.append(block); + } + + @Override + public void removeChild(LytNode node) { + content.removeChild(node); + } + + @Override + public void clearContent() { + content.clearContent(); + } + public void setPreferredWidth(int preferredWidth) { this.preferredWidth = Math.max(0, preferredWidth); } @@ -48,54 +73,106 @@ public void setPreferredHeight(int preferredHeight) { protected LytRect computeBoxLayout(LayoutContext context, int x, int y, int availableWidth) { int constrainedWidth = preferredWidth > 0 ? Math.min(availableWidth, preferredWidth) : availableWidth; int measuredWidth = Math.max(1, constrainedWidth); - viewportX = x; - viewportY = y; - viewportWidth = measuredWidth; - appliedScrollOffsetY = 0; - - LytRect contentBounds = super.computeBoxLayout(context, x, y, measuredWidth); - contentHeight = contentBounds.height(); - viewportHeight = preferredHeight > 0 ? preferredHeight : contentHeight; - - if (preferredHeight > 0 && contentHeight > viewportHeight) { - viewportWidth = Math.max(1, measuredWidth - SCROLLBAR_WIDTH - SCROLLBAR_GAP); - contentBounds = super.computeBoxLayout(context, x, y, viewportWidth); - contentHeight = contentBounds.height(); + int contentWidth = measuredWidth; + + LytRect contentBounds = content.layout(context, x, y, measuredWidth); + int contentH = contentBounds.height(); + int viewportH = preferredHeight > 0 ? preferredHeight : contentH; + if (preferredHeight > 0 && contentH > viewportH) { + contentWidth = Math.max(1, measuredWidth - SCROLLBAR_WIDTH - SCROLLBAR_GAP); + contentBounds = content.layout(context, x, y, contentWidth); + contentH = contentBounds.height(); + viewportH = preferredHeight; } - viewportHeight = preferredHeight > 0 ? preferredHeight : contentHeight; + viewport.setExplicitHeight(viewportH); + viewport.layout(context, x, y, contentWidth); setScrollOffset(scrollOffsetY); snapVisualScrollToTarget(); int totalWidth = preferredWidth > 0 ? measuredWidth : contentBounds.width() + (hasVerticalScroll() ? SCROLLBAR_WIDTH + SCROLLBAR_GAP : 0); - return new LytRect(x, y, totalWidth, viewportHeight); + return new LytRect(x, y, totalWidth, viewportH); } - @Override - public void render(RenderContext context) { - updateVisualScroll(); - if (!hasVerticalScroll()) { - super.render(context); - return; + // ---- derived geometry (computed from current bounds; no layout-time fields) ---- + + private int getContentHeight() { + return content.getBounds() + .height(); + } + + private int getViewportHeight() { + return preferredHeight > 0 ? preferredHeight : getContentHeight(); + } + + private LytRect getViewportBounds() { + int x = bounds.x() + getBorderLeft().width() + paddingLeft; + int y = bounds.y() + getBorderTop().width() + paddingTop; + int w = bounds.right() - getBorderRight().width() - paddingRight - x; + if (hasVerticalScroll()) { + w = Math.max(1, w - SCROLLBAR_WIDTH - SCROLLBAR_GAP); } + return new LytRect(x, y, Math.max(0, w), Math.max(0, getViewportHeight())); + } + + private int getMaxScrollOffset() { + return Math.max(0, getContentHeight() - getViewportHeight()); + } + + @Override + public boolean usePrimitives() { + return true; + } - if (getBackgroundColor() != null) { - context.fillRect(bounds, getBackgroundColor()); + @Override + public void computePrimitives(PrimitiveCollector c) { + super.computePrimitives(c); + + // Advance the smooth scroll and bake the visual delta into the content + // bounds (collector traverses the content right after this). + updateVisualScroll(); + int newDelta = appliedScrollOffsetY - visualScrollOffsetY.rounded(); + if (newDelta != visualDeltaY && !content.getBounds() + .isEmpty()) { + content.moveLayoutPos(0, newDelta - visualDeltaY); + visualDeltaY = newDelta; } - LytRect viewportBounds = getViewportBounds(); - context.pushLocalScissor(viewportBounds); - try { - renderChildrenWithVisualOffset(context); - } finally { - context.popScissor(); + LytRect trackBounds = getScrollbarTrackBounds(); + if (!trackBounds.isEmpty()) { + c.emit( + new GuideRenderPrimitive.FillRect( + trackBounds.x(), + trackBounds.y(), + trackBounds.width(), + trackBounds.height(), + 0x30242B33)); + LytRect thumbBounds = getScrollbarThumbBounds(); + if (!thumbBounds.isEmpty()) { + c.emit( + new GuideRenderPrimitive.FillRect( + thumbBounds.x(), + thumbBounds.y(), + thumbBounds.width(), + thumbBounds.height(), + draggingScrollbar ? 0xFFCDD6E1 : 0xA0AAB5C2)); + } } + } - renderScrollbar(context); - renderBorder(context); + @Override + protected void afterExternalLayout() { + // The writeback reset the content to the unscrolled position; re-apply + // the current scroll offset and restart the visual-delta bookkeeping. + content.moveLayoutPos(0, appliedScrollOffsetY - scrollOffsetY); + appliedScrollOffsetY = scrollOffsetY; + visualDeltaY = 0; } + @Override + public void render(RenderContext context) {} + @Override public boolean beginDrag(int documentX, int documentY, int button) { if (!hasVerticalScroll() || button != 0) { @@ -203,9 +280,7 @@ private void setScrollOffset(int scrollOffsetY) { this.scrollOffsetY = SceneEditorVerticalScrollbar.clamp(scrollOffsetY, 0, getMaxScrollOffset()); int deltaY = appliedScrollOffsetY - this.scrollOffsetY; if (deltaY != 0) { - for (LytBlock child : children) { - child.moveLayoutPos(0, deltaY); - } + content.moveLayoutPos(0, deltaY); appliedScrollOffsetY = this.scrollOffsetY; } } @@ -223,27 +298,24 @@ private void updateScrollFromMouseY(int mouseY) { scrollbarGrabOffsetY, trackBounds.y(), trackBounds.height(), - contentHeight, - viewportHeight)); - } - - private int getMaxScrollOffset() { - return Math.max(0, contentHeight - viewportHeight); + getContentHeight(), + getViewportHeight())); } private boolean hasVerticalScroll() { return getMaxScrollOffset() > 0; } - private LytRect getViewportBounds() { - return new LytRect(viewportX, viewportY, viewportWidth, viewportHeight); - } - private LytRect getScrollbarTrackBounds() { if (!hasVerticalScroll()) { return LytRect.empty(); } - return new LytRect(viewportX + viewportWidth + SCROLLBAR_GAP, viewportY, SCROLLBAR_WIDTH, viewportHeight); + LytRect viewportBounds = getViewportBounds(); + return new LytRect( + viewportBounds.right() + SCROLLBAR_GAP, + viewportBounds.y(), + SCROLLBAR_WIDTH, + viewportBounds.height()); } private LytRect getScrollbarThumbBounds() { @@ -255,8 +327,8 @@ private LytRect getScrollbarThumbBounds() { SceneEditorVerticalScrollbar.Thumb thumb = SceneEditorVerticalScrollbar.computeThumb( trackBounds.y(), trackBounds.height(), - contentHeight, - viewportHeight, + getContentHeight(), + getViewportHeight(), visualScrollOffsetY.rounded()); return new LytRect(trackBounds.x(), thumb.start(), trackBounds.width(), thumb.size()); } @@ -266,28 +338,6 @@ private void snapVisualScrollToTarget() { } private void updateVisualScroll() { - visualScrollOffsetY.updateTowards(scrollOffsetY, 28f, 0.25f, 0.01f, Math.max(128f, viewportHeight * 2f)); - } - - private void renderChildrenWithVisualOffset(RenderContext context) { - int renderDeltaY = appliedScrollOffsetY - visualScrollOffsetY.rounded(); - if (renderDeltaY != 0) { - moveChildrenLayoutY(renderDeltaY); - } - try { - for (LytBlock child : children) { - child.render(context); - } - } finally { - if (renderDeltaY != 0) { - moveChildrenLayoutY(-renderDeltaY); - } - } - } - - private void moveChildrenLayoutY(int deltaY) { - for (LytBlock child : children) { - child.moveLayoutPos(0, deltaY); - } + visualScrollOffsetY.updateTowards(scrollOffsetY, 28f, 0.25f, 0.01f, Math.max(128f, getViewportHeight() * 2f)); } } diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytSlot.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytSlot.java index 5c5989ea..88292fc2 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytSlot.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytSlot.java @@ -12,6 +12,8 @@ import com.hfstudio.guidenh.guide.document.interaction.ItemTooltip; import com.hfstudio.guidenh.guide.internal.item.GuideDisplayItemStacks; import com.hfstudio.guidenh.guide.layout.LayoutContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.render.RenderContext; import lombok.Getter; @@ -63,6 +65,33 @@ protected LytRect computeLayout(LayoutContext context, int x, int y, int availab @Override protected void onLayoutMoved(int deltaX, int deltaY) {} + @Override + public boolean usePrimitives() { + return true; + } + + @Override + public void computePrimitives(PrimitiveCollector c) { + var x = bounds.x(); + var y = bounds.y(); + int w = bounds.width(); + int h = bounds.height(); + + if (renderSlotBackground) { + c.emit(new GuideRenderPrimitive.FillRect(x, y, w, 1, SLOT_BORDER_DARK)); + c.emit(new GuideRenderPrimitive.FillRect(x, y, 1, h, SLOT_BORDER_DARK)); + c.emit(new GuideRenderPrimitive.FillRect(x, y + h - 1, w, 1, SLOT_BORDER_LIGHT)); + c.emit(new GuideRenderPrimitive.FillRect(x + w - 1, y, 1, h, SLOT_BORDER_LIGHT)); + c.emit(new GuideRenderPrimitive.FillRect(x + 1, y + 1, w - 2, h - 2, SLOT_INNER_BG)); + } + + var padding = largeSlot ? LARGE_PADDING : PADDING; + var stack = getDisplayedStack(); + if (stack != null) { + c.emit(new GuideRenderPrimitive.RenderItem(stack, x + padding, y + padding)); + } + } + @Override public void render(RenderContext context) { var x = bounds.x(); diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytStructureView.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytStructureView.java index a9a98a9f..d427132b 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytStructureView.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytStructureView.java @@ -8,6 +8,8 @@ import com.hfstudio.guidenh.guide.document.LytRect; import com.hfstudio.guidenh.guide.layout.LayoutContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.render.RenderContext; import lombok.Getter; @@ -44,6 +46,9 @@ public BlockEntry(int x, int y, int z, ItemStack stack) { // Invalidated whenever addBlock mutates the underlying list. private List sortedCache; + public int getViewWidth() { return viewWidth; } + public int getViewHeight() { return viewHeight; } + public void setViewSize(int width, int height) { this.viewWidth = Math.max(32, width); this.viewHeight = Math.max(32, height); @@ -68,10 +73,25 @@ protected LytRect computeLayout(LayoutContext context, int x, int y, int availab protected void onLayoutMoved(int deltaX, int deltaY) {} @Override - public void render(RenderContext context) { + public boolean usePrimitives() { + return true; + } + + @Override + public void computePrimitives(PrimitiveCollector c) { var bounds = getBounds(); - context.fillRect(bounds, 0xFF1E1E1E); - context.drawBorder(bounds, 0xFF555555, 1); + c.emit(new GuideRenderPrimitive.FillRect(bounds.x(), bounds.y(), bounds.width(), bounds.height(), 0xFF1E1E1E)); + c.emit( + new GuideRenderPrimitive.DrawBorder( + bounds.x(), + bounds.y(), + bounds.width(), + bounds.height(), + 1, + 1, + 1, + 1, + 0xFF555555)); if (blocks.isEmpty()) { return; @@ -104,18 +124,18 @@ public void render(RenderContext context) { sortedCache = sorted; } - context.pushLocalScissor(bounds); - try { - for (BlockEntry b : sorted) { - int px = projectX(b.x, b.z) + offsetX; - int py = projectY(b.x, b.y, b.z) + offsetY; - context.renderItem(b.stack, px, py); - } - } finally { - context.popScissor(); + c.pushScissor(bounds.x(), bounds.y(), bounds.width(), bounds.height()); + for (BlockEntry b : sorted) { + int px = projectX(b.x, b.z) + offsetX; + int py = projectY(b.x, b.y, b.z) + offsetY; + c.emit(new GuideRenderPrimitive.RenderItem(b.stack, px, py)); } + c.popScissor(); } + @Override + public void render(RenderContext context) {} + public static int projectX(int x, int z) { return (x - z) * TILE_W; } diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytTaskListItem.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytTaskListItem.java index 11eced30..be8eeb8a 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytTaskListItem.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytTaskListItem.java @@ -1,8 +1,11 @@ package com.hfstudio.guidenh.guide.document.block; +import com.hfstudio.guidenh.guide.color.LightDarkMode; import com.hfstudio.guidenh.guide.color.SymbolicColor; import com.hfstudio.guidenh.guide.document.LytRect; import com.hfstudio.guidenh.guide.layout.LayoutContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.render.RenderContext; import lombok.Getter; @@ -14,6 +17,12 @@ public class LytTaskListItem extends LytListItem { private boolean checked; + public LytTaskListItem() { + // Extra 4px beyond LytListItem's LEVEL_MARGIN, matching the legacy + // computeBoxLayout's x+4 offset for task item content. + setPaddingLeft(LEVEL_MARGIN + 4); + } + @Override protected LytRect computeBoxLayout(LayoutContext context, int x, int y, int availableWidth) { int margin = LEVEL_MARGIN + 4; @@ -21,12 +30,41 @@ protected LytRect computeBoxLayout(LayoutContext context, int x, int y, int avai return bounds.expand(4, 0, 0, 0); } + @Override + protected boolean hasOwnMarker() { + // The checkbox replaces the shared bullet / ordered number — the + // superclass must not also paint a marker in the gutter. + return true; + } + + @Override + public void computePrimitives(PrimitiveCollector c) { + super.computePrimitives(c); + LytRect bounds = getBounds(); + int boxSize = 7; + int boxX = bounds.x() + 1; + // Vertically center the checkbox on the marker's first-line text run + // (bounds written back by Rust): the checkbox's vertical center lands + // on the first line's vertical center, matching the bullet alignment. + LytRect markerLine = getMarkerLineBounds(); + int boxY = markerLine.y() + (markerLine.height() - boxSize) / 2; + int argb = SymbolicColor.BODY_TEXT.resolve(LightDarkMode.current()); + c.emit(new GuideRenderPrimitive.DrawBorder(boxX, boxY, boxSize, boxSize, 1, 1, 1, 1, argb)); + if (checked) { + int fillArgb = SymbolicColor.LINK.resolve(LightDarkMode.current()); + c.emit(new GuideRenderPrimitive.FillRect(boxX + 2, boxY + 2, 3, 3, fillArgb)); + } + } + @Override public void render(RenderContext context) { LytRect bounds = getBounds(); int boxSize = 7; int boxX = bounds.x() + 1; - int boxY = bounds.y() + 1; + // Same marker-line anchor as computePrimitives: center the checkbox on + // the first-line text run bounds (Rust layout authority). + LytRect markerLine = getMarkerLineBounds(context); + int boxY = markerLine.y() + (markerLine.height() - boxSize) / 2; context.drawBorder(new LytRect(boxX, boxY, boxSize, boxSize), context.resolveColor(SymbolicColor.BODY_TEXT), 1); if (checked) { context.fillRect(boxX + 2, boxY + 2, 3, 3, SymbolicColor.LINK); diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytThematicBreak.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytThematicBreak.java index e46771a5..80108bb6 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytThematicBreak.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytThematicBreak.java @@ -1,8 +1,11 @@ package com.hfstudio.guidenh.guide.document.block; +import com.hfstudio.guidenh.guide.color.LightDarkMode; import com.hfstudio.guidenh.guide.color.SymbolicColor; import com.hfstudio.guidenh.guide.document.LytRect; import com.hfstudio.guidenh.guide.layout.LayoutContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.render.RenderContext; public class LytThematicBreak extends LytBlock { @@ -15,6 +18,19 @@ public LytRect computeLayout(LayoutContext context, int x, int y, int availableW @Override protected void onLayoutMoved(int deltaX, int deltaY) {} + @Override + public boolean usePrimitives() { + return true; + } + + @Override + public void computePrimitives(PrimitiveCollector c) { + var line = bounds.withHeight(2) + .centerVerticallyIn(bounds); + int argb = SymbolicColor.THEMATIC_BREAK.resolve(LightDarkMode.current()); + c.emit(new GuideRenderPrimitive.FillRect(line.x(), line.y(), line.width(), line.height(), argb)); + } + @Override public void render(RenderContext context) { var line = bounds.withHeight(2) diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytVBox.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytVBox.java index aefa1c4d..3ed4166b 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytVBox.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytVBox.java @@ -2,28 +2,24 @@ import com.hfstudio.guidenh.guide.document.LytRect; import com.hfstudio.guidenh.guide.layout.LayoutContext; -import com.hfstudio.guidenh.guide.layout.Layouts; /** * Lays out its children vertically. + *

+ * The Java layout pre-pass has been removed — children are laid out by the + * Rust layout engine. This method is retained for compatibility (LytBox's + * final computeLayout calls it) but returns a minimal rect since real + * bounds are applied via {@link #applyExternalLayout}. */ public class LytVBox extends LytAxisBox { @Override protected LytRect computeBoxLayout(LayoutContext context, int x, int y, int availableWidth) { - // Padding is applied through the parent - return Layouts.verticalLayout( - context, - children, - x, - y, - availableWidth, - isFullWidth(), - 0, - 0, - 0, - 0, - getGap(), - getAlignItems()); + // NOTE: The document pipeline no longer calls this method — children + // are laid out by the Rust layout engine which is the authoritative + // source for bounds. This return value is only a fallback for the + // legacy layout() call chain (LytBox.computeLayout(final) expands the + // LytRect(x,y,0,0) with padding/border, producing a non-zero rect). + return new LytRect(x, y, 0, 0); } } diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytViewportBox.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytViewportBox.java new file mode 100644 index 00000000..315daebe --- /dev/null +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytViewportBox.java @@ -0,0 +1,39 @@ +package com.hfstudio.guidenh.guide.document.block; + +import org.jetbrains.annotations.Nullable; + +import com.hfstudio.guidenh.guide.document.LytRect; + +/** + * A scroll viewport: a plain vertical container that clips its children to its + * own bounds. Used by scroll containers (code blocks, size boxes, details + * blocks) as the single scrollable region — the framework's children-clip + * semantics then do the clipping, and the owner moves the content child's + * bounds to scroll. + *

+ * When the owner forces a viewport height, it is declared through + * {@link #setExplicitHeight(int)} so the layout engine reserves exactly that + * height; otherwise the viewport grows with its content (no scrolling). + */ +public class LytViewportBox extends LytVBox { + + private int explicitHeight = -1; + + public void setExplicitHeight(int explicitHeight) { + this.explicitHeight = explicitHeight; + } + + @Override + public int getExplicitHeight() { + return explicitHeight; + } + + @Override + public @Nullable LytRect getChildrenClipRect() { + // Clip children to the viewport: the content may be taller and scrolls + // beneath. When not scrollable the bounds equal the content bounds, so + // the clip is a no-op. + var b = getBounds(); + return b == null || b.isEmpty() ? null : b; + } +} diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytWidthBox.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytWidthBox.java index da044a9c..57aed249 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/LytWidthBox.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/LytWidthBox.java @@ -12,6 +12,13 @@ public class LytWidthBox extends LytVBox { public void setPreferredWidth(int preferredWidth) { this.preferredWidth = Math.max(0, preferredWidth); + // preferredWidth <= 0 means "no fixed width constraint": signal full + // width through the fullWidth mechanism (same pattern as + // LytDetailsBlock/LytCodeBlock) so LayoutStyleExtractor serializes + // size_w=100% and the authoritative Rust layout stretches this box to + // the available content width. (Rust has no knowledge of preferredWidth + // itself — serializing 0 as auto would shrink-wrap to content width.) + setFullWidth(this.preferredWidth <= 0); } @Override diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/MermaidNodeRenderer.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/MermaidNodeRenderer.java index ac7e1af5..8262ceab 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/MermaidNodeRenderer.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/MermaidNodeRenderer.java @@ -1,15 +1,11 @@ package com.hfstudio.guidenh.guide.document.block; -import java.util.ArrayList; import java.util.List; import java.util.Map; -import com.hfstudio.guidenh.guide.document.LytRect; import com.hfstudio.guidenh.guide.internal.mermaid.MermaidNodeShape; -import com.hfstudio.guidenh.guide.internal.util.GuideStringLines; -import com.hfstudio.guidenh.guide.layout.FontMetrics; import com.hfstudio.guidenh.guide.layout.LayoutContext; -import com.hfstudio.guidenh.guide.render.RenderContext; +import com.hfstudio.guidenh.guide.render.GuideText; import com.hfstudio.guidenh.guide.style.ResolvedTextStyle; public final class MermaidNodeRenderer { @@ -72,10 +68,6 @@ public static NodeColors resolveNodeColors(List classes, MermaidNodeShap return new NodeColors(background, accent, accent); } - public static void renderAccentBar(RenderContext context, LytRect boxRect, int accentColor) { - context.fillRect(new LytRect(boxRect.x(), boxRect.y(), 3, boxRect.height()), accentColor); - } - public static ResolvedTextStyle scaleTextStyle(ResolvedTextStyle base, float zoom) { return new ResolvedTextStyle( base.fontScale() * zoom, @@ -92,7 +84,8 @@ public static ResolvedTextStyle scaleTextStyle(ResolvedTextStyle base, float zoo base.alignment(), base.dropShadow(), base.backgroundColor(), - base.inlineCode()); + base.inlineCode(), + base.baselineShift()); } public static ResolvedTextStyle getOrScaleStyle(Map cache, @@ -134,10 +127,6 @@ public static int measureText(LayoutContext context, ResolvedTextStyle style, St return measureTextInternal(style, text, context::getAdvance); } - public static int measureText(RenderContext context, ResolvedTextStyle style, String text) { - return context.getStringWidth(text, style); - } - public static int measureTextInternal(ResolvedTextStyle style, String text, AdvanceFunction advance) { if (text == null || text.isEmpty()) { return 0; @@ -151,105 +140,12 @@ public static int measureTextInternal(ResolvedTextStyle style, String text, Adva return Math.round(width); } - public static List wrapText(RenderContext context, ResolvedTextStyle style, String text, int maxWidth) { - return wrapText(new LayoutContext(new FontMetrics() { - - @Override - public float getAdvance(int codePoint, ResolvedTextStyle s) { - return context.getStringWidth(new String(Character.toChars(codePoint)), s); - } - - @Override - public int getLineHeight(ResolvedTextStyle s) { - return context.getLineHeight(s); - } - }), style, text, maxWidth); - } - public static List wrapText(LayoutContext context, ResolvedTextStyle style, String text, int maxWidth) { - List result = new ArrayList<>(); - GuideStringLines.visitLines(text != null ? text : "", (paragraph, lineIndex) -> { - if (paragraph.isEmpty()) { - result.add(""); - return true; - } - - StringBuilder line = new StringBuilder(); - scanWords(paragraph, word -> appendWrappedWord(result, line, context, style, word, maxWidth)); - if (!line.isEmpty()) { - result.add(line.toString()); - } - return true; - }); - return result; - } - - private static boolean appendWrappedWord(List result, StringBuilder line, LayoutContext context, - ResolvedTextStyle style, String word, int maxWidth) { - if (line.isEmpty()) { - if (measureText(context, style, word) <= maxWidth) { - line.append(word); - } else { - appendBrokenWord(result, line, context, style, word, maxWidth); - } - return true; - } - - String candidate = line + " " + word; - if (measureText(context, style, candidate) <= maxWidth) { - line.append(' ') - .append(word); - return true; - } - - result.add(line.toString()); - line.setLength(0); - if (measureText(context, style, word) <= maxWidth) { - line.append(word); - } else { - appendBrokenWord(result, line, context, style, word, maxWidth); - } - return true; - } - - public static void scanWords(String text, WordVisitor visitor) { - int start = -1; - for (int index = 0, length = text.length(); index <= length; index++) { - char value = index < length ? text.charAt(index) : ' '; - if (Character.isWhitespace(value)) { - if (start >= 0) { - if (!visitor.accept(text.substring(start, index))) { - return; - } - start = -1; - } - } else if (start < 0) { - start = index; - } - } - } - - private static void appendBrokenWord(List result, StringBuilder line, LayoutContext context, - ResolvedTextStyle style, String word, int maxWidth) { - StringBuilder fragment = new StringBuilder(); - for (int offset = 0; offset < word.length();) { - int codePoint = word.codePointAt(offset); - String next = fragment + new String(Character.toChars(codePoint)); - if (!fragment.isEmpty() && measureText(context, style, next) > maxWidth) { - result.add(fragment.toString()); - fragment.setLength(0); - } - fragment.appendCodePoint(codePoint); - offset += Character.charCount(codePoint); - } - if (!fragment.isEmpty()) { - line.append(fragment); - } - } - - @FunctionalInterface - public interface WordVisitor { - - boolean accept(String word); + // A4 unified text pipeline: word-first wrapping + codepoint-level + // breaking of overlong words, measured by GuideText (Rust font system). + // LayoutContext is no longer used for measurement — GuideText.wrap + // measures with its own GuideText adapters, which are the same source + // as the former LayoutContext-based measurement (measurement-neutral). + return GuideText.wrap(text, maxWidth, style); } } diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/CartesianChartRenderer.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/CartesianChartRenderer.java index f91fefd0..53d35a1c 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/CartesianChartRenderer.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/CartesianChartRenderer.java @@ -1,7 +1,9 @@ package com.hfstudio.guidenh.guide.document.block.chart; import com.hfstudio.guidenh.guide.document.LytRect; -import com.hfstudio.guidenh.guide.render.RenderContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.GuideText; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.style.ResolvedTextStyle; /** @@ -12,10 +14,10 @@ public class CartesianChartRenderer { protected CartesianChartRenderer() {} /** Compute insets reserved for axis labels; returns [left, top, right, bottom] (pixels). */ - public static int[] computeAxisInsets(RenderContext context, ChartAxisOptions xAxis, ChartAxisOptions yAxis, - AxisRange xRange, AxisRange yRange, String[] xCategories, boolean showXTicks, boolean showYTicks) { + public static int[] computeAxisInsets(ChartAxisOptions xAxis, ChartAxisOptions yAxis, AxisRange xRange, + AxisRange yRange, String[] xCategories, boolean showXTicks, boolean showYTicks) { ResolvedTextStyle style = LytChartBase.textStyle(0xFFCCCCCC); - int lineH = context.getLineHeight(style); + int lineH = GuideText.lineHeight(style); int left = 4; int top = 4; int right = 4; @@ -24,7 +26,7 @@ public static int[] computeAxisInsets(RenderContext context, ChartAxisOptions xA int maxLabel = 0; for (double t = yRange.min; t <= yRange.max + 1e-9; t += yRange.step) { String s = yAxis.formatTick(t); - int w = context.getStringWidth(s, style); + int w = GuideText.measureWidth(s, style); if (w > maxLabel) { maxLabel = w; } @@ -45,15 +47,15 @@ public static int[] computeAxisInsets(RenderContext context, ChartAxisOptions xA // Reserve a small right margin so the last X tick label does not overflow the plot. if (xRange != null) { String last = xAxis.formatTick(xRange.max); - right = Math.max(right, context.getStringWidth(last, style) / 2 + 2); + right = Math.max(right, GuideText.measureWidth(last, style) / 2 + 2); } else if (xCategories != null && xCategories.length > 0) { String last = xCategories[xCategories.length - 1]; if (last != null) { - right = Math.max(right, context.getStringWidth(last, style) / 2 + 2); + right = Math.max(right, GuideText.measureWidth(last, style) / 2 + 2); } String first = xCategories[0]; if (first != null) { - left = Math.max(left, context.getStringWidth(first, style) / 2 + 2); + left = Math.max(left, GuideText.measureWidth(first, style) / 2 + 2); } } } @@ -73,7 +75,7 @@ public static float mapY(double value, AxisRange range, LytRect plotRect) { } /** Render axes + grid lines + tick text inside plotRect. */ - public static void drawAxes(RenderContext context, LytRect plotRect, ChartAxisOptions xAxis, ChartAxisOptions yAxis, + public static void drawAxes(PrimitiveCollector c, LytRect plotRect, ChartAxisOptions xAxis, ChartAxisOptions yAxis, AxisRange xRange, AxisRange yRange, String[] xCategories, boolean numericX) { ResolvedTextStyle xLabelStyle = LytChartBase.textStyle(xAxis.getLabelColor()); ResolvedTextStyle yLabelStyle = LytChartBase.textStyle(yAxis.getLabelColor()); @@ -83,12 +85,19 @@ public static void drawAxes(RenderContext context, LytRect plotRect, ChartAxisOp for (double t = yRange.min; t <= yRange.max + 1e-9; t += yRange.step) { float y = mapY(t, yRange, plotRect); if (yAxis.isGridVisible()) { - context.drawLine(plotRect.x(), y, plotRect.right(), y, 1f, yAxis.getGridColor()); + c.emit( + new GuideRenderPrimitive.DrawLine( + plotRect.x(), + y, + plotRect.right(), + y, + 1f, + yAxis.getGridColor())); } String s = yAxis.formatTick(t); - int sw = context.getStringWidth(s, yLabelStyle); - int lh = context.getLineHeight(yLabelStyle); - context.drawText(s, plotRect.x() - sw - 4, (int) y - lh / 2, yLabelStyle); + int sw = GuideText.measureWidth(s, yLabelStyle); + int lh = GuideText.lineHeight(yLabelStyle); + GuideText.emitText(c, s, plotRect.x() - sw - 4, (int) y - lh / 2, yLabelStyle); } } @@ -98,48 +107,68 @@ public static void drawAxes(RenderContext context, LytRect plotRect, ChartAxisOp for (double t = xRange.min; t <= xRange.max + 1e-9; t += xRange.step) { float x = mapX(t, xRange, plotRect); if (xAxis.isGridVisible()) { - context.drawLine(x, plotRect.y(), x, plotRect.bottom(), 1f, xAxis.getGridColor()); + c.emit( + new GuideRenderPrimitive.DrawLine( + x, + plotRect.y(), + x, + plotRect.bottom(), + 1f, + xAxis.getGridColor())); } String s = xAxis.formatTick(t); - int sw = context.getStringWidth(s, xLabelStyle); + int sw = GuideText.measureWidth(s, xLabelStyle); int tx = (int) x - sw / 2; // Allow at most half the label to extend past the plot edge so neighbouring text // does not collide with the chart border. tx = Math.max(plotRect.x() - sw / 2, Math.min(plotRect.right() - sw / 2, tx)); - context.drawText(s, tx, plotRect.bottom() + 3, xLabelStyle); + GuideText.emitText(c, s, tx, plotRect.bottom() + 3, xLabelStyle); } } else if (xCategories != null && xCategories.length > 0) { float step = (float) plotRect.width() / xCategories.length; for (int i = 0; i < xCategories.length; i++) { String label = xCategories[i] != null ? xCategories[i] : ""; - int sw = context.getStringWidth(label, xLabelStyle); + int sw = GuideText.measureWidth(label, xLabelStyle); float cx = plotRect.x() + step * (i + 0.5f); int tx = (int) cx - sw / 2; - context.drawText(label, tx, plotRect.bottom() + 3, xLabelStyle); + GuideText.emitText(c, label, tx, plotRect.bottom() + 3, xLabelStyle); } } // Axis border. - context.drawLine(plotRect.x(), plotRect.y(), plotRect.x(), plotRect.bottom(), 1f, xAxis.getAxisColor()); - context - .drawLine(plotRect.x(), plotRect.bottom(), plotRect.right(), plotRect.bottom(), 1f, xAxis.getAxisColor()); + c.emit( + new GuideRenderPrimitive.DrawLine( + plotRect.x(), + plotRect.y(), + plotRect.x(), + plotRect.bottom(), + 1f, + xAxis.getAxisColor())); + c.emit( + new GuideRenderPrimitive.DrawLine( + plotRect.x(), + plotRect.bottom(), + plotRect.right(), + plotRect.bottom(), + 1f, + xAxis.getAxisColor())); // Axis title. if (xAxis.getLabel() != null && !xAxis.getLabel() .isEmpty()) { - int sw = context.getStringWidth(xAxis.getLabel(), xLabelStyle); - int lh = context.getLineHeight(xLabelStyle); + int sw = GuideText.measureWidth(xAxis.getLabel(), xLabelStyle); + int lh = GuideText.lineHeight(xLabelStyle); // Center the X-axis label below the tick row, but clamp to the plot's horizontal range // so a long label does not bleed past the right edge. int tx = plotRect.x() + Math.max(0, (plotRect.width() - sw) / 2); - context.drawText(xAxis.getLabel(), tx, plotRect.bottom() + 3 + lh + 2, xLabelStyle); + GuideText.emitText(c, xAxis.getLabel(), tx, plotRect.bottom() + 3 + lh + 2, xLabelStyle); } if (yAxis.getLabel() != null && !yAxis.getLabel() .isEmpty()) { - int lh = context.getLineHeight(yLabelStyle); + int lh = GuideText.lineHeight(yLabelStyle); // Place the Y-axis label horizontally above the plot's top-left corner instead of to // its left, so long labels (e.g. "Strength (dB)") never overflow the chart frame. - context.drawText(yAxis.getLabel(), plotRect.x(), plotRect.y() - lh - 2, yLabelStyle); + GuideText.emitText(c, yAxis.getLabel(), plotRect.x(), plotRect.y() - lh - 2, yLabelStyle); } } } diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/ChartLegendRenderer.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/ChartLegendRenderer.java index edf6ad2e..91e90708 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/ChartLegendRenderer.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/ChartLegendRenderer.java @@ -3,11 +3,15 @@ import java.util.ArrayList; import java.util.List; -import org.lwjgl.opengl.GL11; +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.texture.ITextureObject; +import net.minecraft.util.ResourceLocation; import com.hfstudio.guidenh.guide.document.LytRect; import com.hfstudio.guidenh.guide.layout.LayoutContext; -import com.hfstudio.guidenh.guide.render.RenderContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.GuideText; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.style.ResolvedTextStyle; /** @@ -18,6 +22,9 @@ public class ChartLegendRenderer { private static final int SWATCH_TEXT_GAP = 4; private static final int HORIZONTAL_ROW_GAP = 2; + /** Exposed for Rust-side chrome computation. */ + public static int getSwatchTextGap() { return SWATCH_TEXT_GAP; } + protected ChartLegendRenderer() {} /** A single legend entry. */ @@ -65,8 +72,8 @@ public Layout(List entries, ChartLegendPosition position, LytRect l } } - public static Layout computeLayout(RenderContext context, List entries, ChartLegendPosition position, - int contentLeft, int contentTop, int contentRight, int contentBottom) { + public static Layout computeLayout(List entries, ChartLegendPosition position, int contentLeft, + int contentTop, int contentRight, int contentBottom) { if (entries == null || entries.isEmpty() || position == null || position == ChartLegendPosition.NONE) { return new Layout( entries != null ? entries : new ArrayList<>(), @@ -79,7 +86,7 @@ public static Layout computeLayout(RenderContext context, List entr } ResolvedTextStyle textStyle = LytChartBase.textStyle(0xFFCCCCCC); - int lineHeight = context.getLineHeight(textStyle); + int lineHeight = GuideText.lineHeight(textStyle); int swatch = LytChartBase.LEGEND_SWATCH_SIZE; int gap = LytChartBase.LEGEND_GAP; @@ -90,7 +97,7 @@ public static Layout computeLayout(RenderContext context, List entr entries, position, Math.max(1, contentRight - contentLeft), - context::getStringWidth, + (text, style) -> GuideText.measureWidth(text, style), lineHeight, swatch, textStyle); @@ -110,7 +117,7 @@ public static Layout computeLayout(RenderContext context, List entr case RIGHT: { int width = 0; for (LegendEntry e : entries) { - int w = swatch + SWATCH_TEXT_GAP + context.getStringWidth(e.name, textStyle); + int w = swatch + SWATCH_TEXT_GAP + GuideText.measureWidth(e.name, textStyle); if (w > width) { width = w; } @@ -140,12 +147,12 @@ public static Layout computeLayout(RenderContext context, List entr } } - public static void render(RenderContext context, Layout layout, ResolvedTextStyle styleTemplate) { + public static void emit(PrimitiveCollector c, Layout layout, ResolvedTextStyle styleTemplate) { if (layout.position == ChartLegendPosition.NONE || layout.entries.isEmpty()) { return; } ResolvedTextStyle textStyle = LytChartBase.textStyle(0xFFCCCCCC); - int lineHeight = context.getLineHeight(textStyle); + int lineHeight = GuideText.lineHeight(textStyle); int swatch = LytChartBase.LEGEND_SWATCH_SIZE; LytRect rect = layout.legendRect; @@ -155,7 +162,7 @@ public static void render(RenderContext context, Layout layout, ResolvedTextStyl int totalWidth = 0; for (int i = 0; i < layout.entries.size(); i++) { LegendEntry e = layout.entries.get(i); - totalWidth += swatch + SWATCH_TEXT_GAP + context.getStringWidth(e.name, textStyle); + totalWidth += swatch + SWATCH_TEXT_GAP + GuideText.measureWidth(e.name, textStyle); if (i < layout.entries.size() - 1) { totalWidth += LytChartBase.LEGEND_ENTRY_GAP; } @@ -166,17 +173,17 @@ public static void render(RenderContext context, Layout layout, ResolvedTextStyl int textY = y + (rowHeight - lineHeight) / 2; int swY = y + (rowHeight - swatch) / 2; for (LegendEntry e : layout.entries) { - int itemWidth = swatch + SWATCH_TEXT_GAP + context.getStringWidth(e.name, textStyle); + int itemWidth = swatch + SWATCH_TEXT_GAP + GuideText.measureWidth(e.name, textStyle); if (x > rect.x() && x + itemWidth > rect.right()) { x = rect.x(); y += rowHeight + HORIZONTAL_ROW_GAP; textY = y + (rowHeight - lineHeight) / 2; swY = y + (rowHeight - swatch) / 2; } - drawSwatch(context, e, x, swY, swatch); + emitSwatch(c, e, x, swY, swatch); x += swatch + SWATCH_TEXT_GAP; - context.drawText(e.name, x, textY, textStyle); - x += context.getStringWidth(e.name, textStyle) + LytChartBase.LEGEND_ENTRY_GAP; + GuideText.emitText(c, e.name, x, textY, textStyle); + x += GuideText.measureWidth(e.name, textStyle) + LytChartBase.LEGEND_ENTRY_GAP; } break; } @@ -186,8 +193,8 @@ public static void render(RenderContext context, Layout layout, ResolvedTextStyl int y = rect.y(); for (LegendEntry e : layout.entries) { int swY = y + (lineHeight - swatch) / 2; - drawSwatch(context, e, x, swY, swatch); - context.drawText(e.name, x + swatch + SWATCH_TEXT_GAP, y, textStyle); + emitSwatch(c, e, x, swY, swatch); + GuideText.emitText(c, e.name, x + swatch + SWATCH_TEXT_GAP, y, textStyle); y += lineHeight + 2; if (y + lineHeight > rect.bottom()) { break; @@ -219,6 +226,31 @@ public static int measureHeight(LayoutContext context, List entries textStyle); } + /** + * Version without {@link LayoutContext}; uses guide-level static font metrics + * ({@link GuideText#lineHeight} / {@link GuideText#measureWidth}) so it can + * be called from a lazy getter when the Java layout pre-pass has not run. + * The result is equivalent to {@link #measureHeight} for serialization purposes. + */ + public static int measureHeightStatic(List entries, ChartLegendPosition position, + int availableWidth) { + if (entries == null || entries.isEmpty() || position == null || position == ChartLegendPosition.NONE) { + return 0; + } + if (position != ChartLegendPosition.TOP && position != ChartLegendPosition.BOTTOM) { + return 0; + } + ResolvedTextStyle textStyle = LytChartBase.textStyle(0xFFCCCCCC); + return measureHorizontalLegendHeight( + entries, + position, + Math.max(1, availableWidth), + (text, style) -> GuideText.measureWidth(text, style), + GuideText.lineHeight(textStyle), + LytChartBase.LEGEND_SWATCH_SIZE, + textStyle); + } + private static int measureHorizontalLegendHeight(List entries, ChartLegendPosition position, int availableWidth, TextWidthMeasure textWidthMeasure, int lineHeight, int swatch, ResolvedTextStyle textStyle) { @@ -259,20 +291,37 @@ private interface TextWidthMeasure { int measure(String text, ResolvedTextStyle style); } - private static void drawSwatch(RenderContext context, LegendEntry entry, int x, int y, int size) { + private static void emitSwatch(PrimitiveCollector c, LegendEntry entry, int x, int y, int size) { if (entry.icon != null && entry.icon.hasItemStack()) { float scale = (float) size / 16f; - GL11.glPushMatrix(); - GL11.glTranslatef(x, y, 0f); - GL11.glScalef(scale, scale, 1f); - context.renderItem(entry.icon.getStack(), 0, 0); - GL11.glPopMatrix(); + c.pushTransform(x, y, scale); + c.emit(new GuideRenderPrimitive.RenderItem(entry.icon.getStack(), 0, 0)); + c.popTransform(); return; } if (entry.icon != null && entry.icon.hasImage()) { - context.fillTexturedRect(new LytRect(x, y, size, size), entry.icon.getTexture()); + ResourceLocation res = entry.icon.getTexture() + .getTexture(); + int texId = res != null ? getGlTextureId(res) : -1; + if (texId >= 0) { + // Full texture UV — matches the legacy fillTexturedRect behavior. + c.emit(new GuideRenderPrimitive.BlitTexture(texId, x, y, size, size, 0f, 0f, 1f, 1f)); + } return; } - context.fillRect(new LytRect(x, y, size, size), entry.color); + c.emit(new GuideRenderPrimitive.FillRect(x, y, size, size, entry.color)); + } + + /** Convert a Minecraft ResourceLocation to a GL texture ID for use with BlitTexture. */ + private static int getGlTextureId(ResourceLocation res) { + try { + ITextureObject tex = Minecraft.getMinecraft() + .getTextureManager() + .getTexture(res); + return tex != null ? tex.getGlTextureId() : -1; + } catch (Throwable t) { + // Headless (unit tests) or texture unavailable: skip drawing. + return -1; + } } } diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/CornerLegendRenderer.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/CornerLegendRenderer.java index 70a198de..c21be17e 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/CornerLegendRenderer.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/CornerLegendRenderer.java @@ -3,7 +3,9 @@ import java.util.List; import com.hfstudio.guidenh.guide.document.LytRect; -import com.hfstudio.guidenh.guide.render.RenderContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.GuideText; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.style.ResolvedTextStyle; public class CornerLegendRenderer { @@ -24,7 +26,11 @@ public class CornerLegendRenderer { protected CornerLegendRenderer() {} - public static void render(RenderContext context, LytRect plotRect, List entries, + /** + * Emits the corner legend as {@link GuideRenderPrimitive}s into {@code c}, + * measuring text through {@link GuideText}. + */ + public static void emit(PrimitiveCollector c, LytRect plotRect, List entries, CornerLegendPosition position, int maxWidth, int maxHeight, int backgroundColor) { if (position == null || position == CornerLegendPosition.NONE || entries == null @@ -32,7 +38,7 @@ public static void render(RenderContext context, LytRect plotRect, List maxWidth) { - return ""; - } - int end = text.length(); - while (end > 0) { - String candidate = text.substring(0, end) + suffix; - if (context.getStringWidth(candidate, TEXT_STYLE) <= maxWidth) { - return candidate; - } - end--; - } - return suffix; - } - private static int clamp(int value, int min, int max) { return Math.clamp(value, min, max); } diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/LytBarChart.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/LytBarChart.java index e0005dc8..1166acf8 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/LytBarChart.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/LytBarChart.java @@ -7,7 +7,9 @@ import com.hfstudio.guidenh.guide.document.LytRect; import com.hfstudio.guidenh.guide.internal.debug.DebugComponent; -import com.hfstudio.guidenh.guide.render.RenderContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.GuideText; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.style.ResolvedTextStyle; import lombok.Getter; @@ -70,7 +72,7 @@ public void setBarWidthRatio(float r) { } @Override - protected int getExtraPlotWidth() { + public int getExtraPlotWidth() { if (pieInset != null && pieInset.getPosition() == PieInsetSpec.Position.RIGHT_OUTSIDE) { return pieInset.getSize() + PIE_OUTSIDE_GAP; } @@ -90,9 +92,9 @@ protected List collectLegendEntries() { } @Override - protected void renderChart(RenderContext context, LytRect plotRect) { + protected LytRect renderChart(PrimitiveCollector c, LytRect plotRect) { int categoryCount = Math.max(categories.length, maxSeriesLength()); - if (categoryCount == 0 || (series.isEmpty() && lineOverlays.isEmpty())) return; + if (categoryCount == 0 || (series.isEmpty() && lineOverlays.isEmpty())) return plotRect; // Peel off a dedicated right-hand area for the pie inset when configured. LytRect pieArea = null; if (pieInset != null && pieInset.getPosition() == PieInsetSpec.Position.RIGHT_OUTSIDE) { @@ -120,76 +122,124 @@ protected void renderChart(RenderContext context, LytRect plotRect) { if (v > dMax) dMax = v; } } + // R4-14: BarChart is horizontal: the value axis is the horizontal (X) axis but the author's + // semantic "yAxis" attributes (yAxisMin/yAxisMax/yAxisStep/yAxisTickFormat/yAxisUnit) control + // the numeric axis. Use yAxis for range, tick format, and value label; xAxis remains the + // category (vertical) axis and controls grid appearance. AxisRange xRange = AxisRange - .compute(xAxis.getMin(), xAxis.getMax(), xAxis.getStep(), Math.min(0d, dMin), Math.max(0d, dMax)); + .compute(yAxis.getMin(), yAxis.getMax(), yAxis.getStep(), Math.min(0d, dMin), Math.max(0d, dMax)); xRangeCache = xRange; // Estimate left-side (category) and bottom (value tick) insets. ResolvedTextStyle style = textStyle(0xFFCCCCCC); - int lh = context.getLineHeight(style); + int lh = GuideText.lineHeight(style); int leftInset = 4; for (int i = 0; i < categoryCount; i++) { - String c = i < categories.length ? categories[i] : Integer.toString(i + 1); - int w = context.getStringWidth(c, style); + String cat = i < categories.length ? categories[i] : Integer.toString(i + 1); + int w = GuideText.measureWidth(cat, style); if (w > leftInset) leftInset = w; } leftInset += 6; int bottomInset = lh + 4; - if (xAxis.getLabel() != null && !xAxis.getLabel() + // R4-14: yAxis label (value axis) goes below the bottom, xAxis label (category) goes on the left. + if (yAxis.getLabel() != null && !yAxis.getLabel() .isEmpty()) { bottomInset += lh + 2; } LytRect inner = plotRect.shrink(leftInset, 4, 4, bottomInset); plotCache = inner; - if (inner.width() <= 4 || inner.height() <= 4) return; + if (inner.width() <= 4 || inner.height() <= 4) return inner; - // Grid (vertical lines correspond to X values). + // Grid (vertical lines correspond to value axis ticks). for (double t = xRange.min; t <= xRange.max + 1e-9; t += xRange.step) { float gx = CartesianChartRenderer.mapX(t, xRange, inner); if (xAxis.isGridVisible()) { - context.drawLine(gx, inner.y(), gx, inner.bottom(), 1f, xAxis.getGridColor()); + c.emit(new GuideRenderPrimitive.DrawLine(gx, inner.y(), gx, inner.bottom(), 1f, xAxis.getGridColor())); } - String s = xAxis.formatTick(t); - int sw = context.getStringWidth(s, style); - context.drawText(s, (int) gx - sw / 2, inner.bottom() + 3, style); + // R4-14: Use yAxis tick formatting (tickFormat + unit) for the value axis. + String s = yAxis.formatTick(t); + int sw = GuideText.measureWidth(s, style); + GuideText.emitText(c, s, (int) gx - sw / 2, inner.bottom() + 3, style); } - if (xAxis.getLabel() != null && !xAxis.getLabel() + // R4-14: yAxis label at bottom (value axis label). + if (yAxis.getLabel() != null && !yAxis.getLabel() .isEmpty()) { - int sw = context.getStringWidth(xAxis.getLabel(), style); - context - .drawText(xAxis.getLabel(), inner.x() + (inner.width() - sw) / 2, inner.bottom() + 3 + lh + 2, style); + int sw = GuideText.measureWidth(yAxis.getLabel(), style); + GuideText.emitText( + c, + yAxis.getLabel(), + inner.x() + (inner.width() - sw) / 2, + inner.bottom() + 3 + lh + 2, + style); } // Category ticks. float categoryHeight = (float) inner.height() / categoryCount; for (int i = 0; i < categoryCount; i++) { - String c = i < categories.length ? categories[i] : Integer.toString(i + 1); - int sw = context.getStringWidth(c, style); + String cat = i < categories.length ? categories[i] : Integer.toString(i + 1); + int sw = GuideText.measureWidth(cat, style); float cy = inner.y() + categoryHeight * (i + 0.5f); - context.drawText(c, inner.x() - sw - 4, (int) cy - lh / 2, style); + GuideText.emitText(c, cat, inner.x() - sw - 4, (int) cy - lh / 2, style); + } + // R4-14: X (category) axis label on the left side, below the last category label. + if (xAxis.getLabel() != null && !xAxis.getLabel() + .isEmpty()) { + int xsw = GuideText.measureWidth(xAxis.getLabel(), style); + int xLabelX = inner.x() - xsw - 4; + float lastCatCy = inner.y() + categoryHeight * (categoryCount - 0.5f); + int xLabelY = (int) lastCatCy + lh / 2 + 2; + GuideText.emitText(c, xAxis.getLabel(), xLabelX, xLabelY, style); } // Border. - context.drawLine(inner.x(), inner.y(), inner.x(), inner.bottom(), 1f, xAxis.getAxisColor()); - context.drawLine(inner.x(), inner.bottom(), inner.right(), inner.bottom(), 1f, xAxis.getAxisColor()); + c.emit( + new GuideRenderPrimitive.DrawLine( + inner.x(), + inner.y(), + inner.x(), + inner.bottom(), + 1f, + xAxis.getAxisColor())); + c.emit( + new GuideRenderPrimitive.DrawLine( + inner.x(), + inner.bottom(), + inner.right(), + inner.bottom(), + 1f, + xAxis.getAxisColor())); int seriesCount = series.size(); + // R4-1: Detect single-value mode where seriesCount == categoryCount and each series has + // exactly one value. In this mode, map each series directly to its corresponding category row. + boolean singleValueMode = seriesCount == categoryCount && seriesCount > 0; + if (singleValueMode) { + for (ChartSeries s : series) { + if (s.getYs().length != 1) { + singleValueMode = false; + break; + } + } + } float baselineX = CartesianChartRenderer.mapX(0d, xRange, inner); ResolvedTextStyle valueStyle = textStyle(getLabelColor()); if (seriesCount > 0) { float clusterHeight = categoryHeight * barWidthRatio; - float barHeight = clusterHeight / seriesCount; + int effSeriesCount = singleValueMode ? 1 : seriesCount; + float barHeight = clusterHeight / effSeriesCount; for (int ci = 0; ci < categoryCount; ci++) { float clusterCenter = inner.y() + categoryHeight * (ci + 0.5f); float clusterTop = clusterCenter - clusterHeight / 2f; - for (int si = 0; si < seriesCount; si++) { - ChartSeries s = series.get(si); - if (ci >= s.getYs().length) continue; - double v = s.getYs()[ci]; + for (int si = 0; si < effSeriesCount; si++) { + int seriesIdx = singleValueMode ? ci : si; + ChartSeries s = series.get(seriesIdx); + int valueIdx = singleValueMode ? 0 : ci; + if (valueIdx >= s.getYs().length) continue; + double v = s.getYs()[valueIdx]; float endX = CartesianChartRenderer.mapX(v, xRange, inner); float y0 = clusterTop + barHeight * si; float y1 = y0 + barHeight - 0.5f; - int key = encodeKey(si, ci); + int key = encodeKey(singleValueMode ? ci : si, ci); boolean hovered = key == hoveredKey; float xLeft = Math.min(endX, baselineX); float xRight = Math.max(endX, baselineX); @@ -201,11 +251,22 @@ protected void renderChart(RenderContext context, LytRect plotRect) { (int) y0, Math.max(1, (int) (xRight - xLeft)), Math.max(1, (int) (y1 - y0))); - context.fillRect(bar, s.getColor()); + c.emit( + new GuideRenderPrimitive.FillRect(bar.x(), bar.y(), bar.width(), bar.height(), s.getColor())); if (hovered) { - context.drawBorder(bar, 0xFF000000, 1); + c.emit( + new GuideRenderPrimitive.DrawBorder( + bar.x(), + bar.y(), + bar.width(), + bar.height(), + 1, + 1, + 1, + 1, + 0xFF000000)); } - drawValueLabel(context, valueStyle, v, bar, endX); + drawValueLabel(c, valueStyle, v, bar, endX); } } } @@ -230,31 +291,32 @@ protected void renderChart(RenderContext context, LytRect plotRect) { if (hoveredLineSeries == li && (hoveredLinePoint == i || hoveredLinePoint == i + 1)) { thick += 1f; } - context.drawLine(px[i], py[i], px[i + 1], py[i + 1], thick, s.getColor()); + c.emit(new GuideRenderPrimitive.DrawLine(px[i], py[i], px[i + 1], py[i + 1], thick, s.getColor())); } for (int i = 0; i < n; i++) { boolean ph = hoveredLineSeries == li && hoveredLinePoint == i; float r = ph ? LINE_POINT_RADIUS + 2f : LINE_POINT_RADIUS; - context.fillCircle(px[i], py[i], r, s.getColor()); + c.emit(new GuideRenderPrimitive.DrawCircle(px[i], py[i], r, s.getColor(), true)); if (ph) { - context.drawCircleOutline(px[i], py[i], r, 1f, 0xFF000000); + c.emit(new GuideRenderPrimitive.DrawCircleOutline(px[i], py[i], r, 1f, 0xFF000000)); } } } } if (pieArea != null) { - PieInsetRenderer.drawAt(context, pieArea, pieInset); + PieInsetRenderer.drawAt(c, pieArea, pieInset); } else { - PieInsetRenderer.draw(context, inner, pieInset); + PieInsetRenderer.draw(c, inner, pieInset); } + return inner; } - private void drawValueLabel(RenderContext context, ResolvedTextStyle style, double value, LytRect bar, float endX) { + private void drawValueLabel(PrimitiveCollector c, ResolvedTextStyle style, double value, LytRect bar, float endX) { if (getLabelPosition() == ChartLabelPosition.NONE) return; String text = formatValue(value); - int tw = context.getStringWidth(text, style); - int lh = context.getLineHeight(style); + int tw = GuideText.measureWidth(text, style); + int lh = GuideText.lineHeight(style); int textX; int textY = bar.y() + (bar.height() - lh) / 2; int textX1 = bar.x() + (bar.width() - tw) / 2; @@ -277,7 +339,7 @@ private void drawValueLabel(RenderContext context, ResolvedTextStyle style, doub default: return; } - context.drawText(text, textX, textY, style); + GuideText.emitText(c, text, textX, textY, style); } private int maxSeriesLength() { @@ -338,23 +400,32 @@ protected int hitTest(float x, float y) { } if (series.isEmpty()) return -1; int seriesCount = series.size(); + boolean singleValueMode = seriesCount == categoryCount && seriesCount > 0; + if (singleValueMode) { + for (ChartSeries s : series) { + if (s.getYs().length != 1) { singleValueMode = false; break; } + } + } float clusterHeight = categoryHeight * barWidthRatio; - float barHeight = clusterHeight / seriesCount; + int effSeriesCount = singleValueMode ? 1 : seriesCount; + float barHeight = clusterHeight / effSeriesCount; float baselineX = CartesianChartRenderer.mapX(0d, xRangeCache, plotCache); for (int ci = 0; ci < categoryCount; ci++) { float clusterCenter = plotCache.y() + categoryHeight * (ci + 0.5f); float clusterTop = clusterCenter - clusterHeight / 2f; - for (int si = 0; si < seriesCount; si++) { - ChartSeries s = series.get(si); - if (ci >= s.getYs().length) continue; - double v = s.getYs()[ci]; + for (int si = 0; si < effSeriesCount; si++) { + int seriesIdx = singleValueMode ? ci : si; + ChartSeries s = series.get(seriesIdx); + int valueIdx = singleValueMode ? 0 : ci; + if (valueIdx >= s.getYs().length) continue; + double v = s.getYs()[valueIdx]; float endX = CartesianChartRenderer.mapX(v, xRangeCache, plotCache); float y0 = clusterTop + barHeight * si; float y1 = y0 + barHeight; float xLeft = Math.min(endX, baselineX); float xRight = Math.max(endX, baselineX); if (x >= xLeft && x <= xRight && y >= y0 && y <= y1) { - return encodeKey(si, ci); + return encodeKey(singleValueMode ? ci : si, ci); } } } @@ -450,20 +521,29 @@ public List getDebugComponents() { int categoryCount = Math.max(categories.length, maxSeriesLength()); int seriesCount = series.size(); + boolean singleValueMode = seriesCount == categoryCount && seriesCount > 0; + if (singleValueMode) { + for (ChartSeries s : series) { + if (s.getYs().length != 1) { singleValueMode = false; break; } + } + } float categoryHeight = (float) plotCache.height() / categoryCount; float clusterHeight = categoryHeight * barWidthRatio; - float barHeight = clusterHeight / seriesCount; + int effSeriesCount = singleValueMode ? 1 : seriesCount; + float barHeight = clusterHeight / effSeriesCount; float baselineX = CartesianChartRenderer.mapX(0d, xRangeCache, plotCache); for (int ci = 0; ci < categoryCount; ci++) { float clusterCenter = plotCache.y() + categoryHeight * (ci + 0.5f); float clusterTop = clusterCenter - clusterHeight / 2f; - for (int si = 0; si < seriesCount; si++) { - ChartSeries s = series.get(si); - if (ci >= s.getYs().length) continue; + for (int si = 0; si < effSeriesCount; si++) { + int seriesIdx = singleValueMode ? ci : si; + ChartSeries s = series.get(seriesIdx); + int valueIdx = singleValueMode ? 0 : ci; + if (valueIdx >= s.getYs().length) continue; - double v = s.getYs()[ci]; + double v = s.getYs()[valueIdx]; float endX = CartesianChartRenderer.mapX(v, xRangeCache, plotCache); float y0 = clusterTop + barHeight * si; float y1 = y0 + barHeight - 0.5f; diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/LytChartBase.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/LytChartBase.java index 63afd166..53a0c279 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/LytChartBase.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/LytChartBase.java @@ -15,6 +15,9 @@ import com.hfstudio.guidenh.guide.document.interaction.TextTooltip; import com.hfstudio.guidenh.guide.internal.tooltip.AppendedItemTooltip; import com.hfstudio.guidenh.guide.layout.LayoutContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.GuideText; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.render.RenderContext; import com.hfstudio.guidenh.guide.style.ResolvedTextStyle; import com.hfstudio.guidenh.guide.style.TextAlignment; @@ -29,8 +32,8 @@ */ public abstract class LytChartBase extends LytBlock implements InteractiveElement { - protected static final int DEFAULT_WIDTH = 320; - protected static final int DEFAULT_HEIGHT = 200; + public static final int DEFAULT_WIDTH = 320; + public static final int DEFAULT_HEIGHT = 200; protected static final int PADDING = 8; protected static final int TITLE_GAP = 4; protected static final int LEGEND_GAP = 6; @@ -72,11 +75,115 @@ public abstract class LytChartBase extends LytBlock implements InteractiveElemen /** Currently hovered hit key; {@code -1} means none. The exact semantics is decided by each subclass. */ protected int hoveredKey = -1; + /** + * Chrome height (title + legend + padding), cached during {@link #computeLayout} + * for serialization into PieChartData. + * Computed lazily when accessed and still zero (no pre-pass), using static + * font metrics via {@link GuideText} instead of {@link LayoutContext}. + */ + private int chromeHeight; + + /** + * Returns the chrome height, computing it lazily if no layout pass has been run. + * Uses {@link GuideText} static font metrics so it works without a {@link LayoutContext}. + *

+ * NOTE: This is only used by the Java render path (computeLayout for scaling). + * The Rust measure path now computes chrome internally from the final width, + * using legend wrapping transplanted from {@link ChartLegendRenderer}. + * See the T6a fix in measure.rs for the Rust-side computation. + */ + public int getChromeHeight() { + if (chromeHeight <= 0) { + chromeHeight = computeChromeHeightForWidth(preferredWidth()); + } + return chromeHeight; + } + + /** + * Computes chrome height purely from block fields and static font metrics. + * Does NOT require a {@link LayoutContext}, so it works even without the + * Java layout pre-pass having been run. + */ + private int computeChromeHeightForWidth(int width) { + int chrome = PADDING * 2; + if (title != null && !title.isEmpty()) { + chrome += GuideText.lineHeight(textStyle(titleColor)) + TITLE_GAP; + } + int contentWidth = Math.max(1, width - PADDING * 2); + chrome += ChartLegendRenderer + .measureHeightStatic(collectLegendEntries(), legendPosition, contentWidth); + if (legendPosition == ChartLegendPosition.TOP || legendPosition == ChartLegendPosition.BOTTOM) { + chrome += legendPosition == ChartLegendPosition.NONE ? 0 : LEGEND_GAP; + } + return chrome; + } + + /** + * Returns the title chrome (lineHeight + TITLE_GAP), width-independent, + * for Rust-side chrome computation. 0 if no title is set. + */ + public float getTitleChromeForRust() { + if (title != null && !title.isEmpty()) { + return GuideText.lineHeight(textStyle(titleColor)) + TITLE_GAP; + } + return 0f; + } + + /** + * Returns the legend position as a byte matching the schema: + * 0=NONE, 1=TOP, 2=BOTTOM, 3=LEFT, 4=RIGHT. + */ + public byte getLegendPositionForRust() { + return switch (legendPosition) { + case TOP -> (byte) 1; + case BOTTOM -> (byte) 2; + case LEFT -> (byte) 3; + case RIGHT -> (byte) 4; + default -> (byte) 0; + }; + } + + /** + * Returns the legend row height (max of swatch size and line height) + * for Rust-side chrome computation. + */ + public float getLegendRowHeightForRust() { + ResolvedTextStyle legendStyle = textStyle(0xFFCCCCCC); + int lineHeight = GuideText.lineHeight(legendStyle); + return Math.max(LEGEND_SWATCH_SIZE, lineHeight); + } + + /** + * Returns per-legend-entry label widths for Rust-side chrome computation. + * Each entry's width = LEGEND_SWATCH_SIZE + SWATCH_TEXT_GAP + measureWidth(label, legendStyle). + */ + public float[] getLegendLabelWidthsForRust() { + List entries = collectLegendEntries(); + ResolvedTextStyle legendStyle = textStyle(0xFFCCCCCC); + float[] widths = new float[entries.size()]; + for (int i = 0; i < entries.size(); i++) { + ChartLegendRenderer.LegendEntry entry = entries.get(i); + int labelW = GuideText.measureWidth(entry.name, legendStyle); + widths[i] = LEGEND_SWATCH_SIZE + ChartLegendRenderer.getSwatchTextGap() + labelW; + } + return widths; + } + public void setExplicitSize(int width, int height) { this.explicitWidth = width > 0 ? width : -1; this.explicitHeight = height > 0 ? height : -1; } + @Override + public int getExplicitWidth() { + return explicitWidth; + } + + @Override + public int getExplicitHeight() { + return explicitHeight; + } + public void setLegendPosition(ChartLegendPosition legendPosition) { this.legendPosition = legendPosition != null ? legendPosition : ChartLegendPosition.NONE; } @@ -100,11 +207,13 @@ protected LytRect computeLayout(LayoutContext context, int x, int y, int availab width = ResponsiveVisualSizing.scaleWidth(width, context.getVisualScale(), 64); int height = explicitHeight > 0 ? explicitHeight : DEFAULT_HEIGHT; width = Math.max(1, Math.min(width, availableWidth)); + int estimatedChrome = estimateFixedChromeHeight(context, width); + this.chromeHeight = estimatedChrome; height = ResponsiveVisualSizing.scaleBodyHeightForWidth( preferredWidth(), height, width, - estimateFixedChromeHeight(context, width), + estimatedChrome, MIN_PLOT_HEIGHT); return new LytRect(x, y, width, height); } @@ -131,7 +240,7 @@ private int estimateFixedChromeHeight(LayoutContext context, int width) { * Subclasses override to request additional horizontal space (for example, a side-mounted pie inset). * Default 0. */ - protected int getExtraPlotWidth() { + public int getExtraPlotWidth() { return 0; } @@ -139,9 +248,30 @@ protected int getExtraPlotWidth() { protected void onLayoutMoved(int deltaX, int deltaY) {} @Override - public final void render(RenderContext context) { - context.fillRect(bounds, backgroundColor); - context.drawBorder(bounds, borderColor, 1); + public boolean usePrimitives() { + return true; + } + + @Override + public final void computePrimitives(PrimitiveCollector c) { + c.emit( + new GuideRenderPrimitive.FillRect( + bounds.x(), + bounds.y(), + bounds.width(), + bounds.height(), + backgroundColor)); + c.emit( + new GuideRenderPrimitive.DrawBorder( + bounds.x(), + bounds.y(), + bounds.width(), + bounds.height(), + 1, + 1, + 1, + 1, + borderColor)); ResolvedTextStyle textStyle = textStyle(0xFFFFFFFF); int contentTop = bounds.y() + PADDING; @@ -151,16 +281,16 @@ public final void render(RenderContext context) { if (title != null && !title.isEmpty()) { ResolvedTextStyle titleStyle = textStyle(titleColor); - int titleWidth = context.getStringWidth(title, titleStyle); + int titleWidth = GuideText.measureWidth(title, titleStyle); int titleX = bounds.x() + (bounds.width() - titleWidth) / 2; - context.drawText(title, titleX, contentTop, titleStyle); - contentTop += context.getLineHeight(titleStyle) + TITLE_GAP; + GuideText.emitText(c, title, titleX, contentTop, titleStyle); + contentTop += GuideText.lineHeight(titleStyle) + TITLE_GAP; } // Compute legend area. List legend = collectLegendEntries(); ChartLegendRenderer.Layout legendLayout = ChartLegendRenderer - .computeLayout(context, legend, legendPosition, contentLeft, contentTop, contentRight, contentBottom); + .computeLayout(legend, legendPosition, contentLeft, contentTop, contentRight, contentBottom); int plotLeft = legendLayout.plotLeft; int plotTop = legendLayout.plotTop; @@ -171,23 +301,30 @@ public final void render(RenderContext context) { } LytRect plotRect = new LytRect(plotLeft, plotTop, plotRight - plotLeft, plotBottom - plotTop); - renderChart(context, plotRect); - CornerLegendRenderer.render( - context, - plotRect, + LytRect innerPlotRect = renderChart(c, plotRect); + if (innerPlotRect == null || innerPlotRect.isEmpty()) { + innerPlotRect = plotRect; + } + CornerLegendRenderer.emit( + c, + innerPlotRect, collectCornerLegendEntries(), cornerLegendPosition, cornerLegendWidth, cornerLegendHeight, cornerLegendBackgroundColor); - ChartLegendRenderer.render(context, legendLayout, textStyle); + ChartLegendRenderer.emit(c, legendLayout, textStyle); } + @Override + public final void render(RenderContext context) {} + /** * Subclasses implement the chart-specific drawing; {@code plotRect} has already excluded the space * occupied by the title and legend. */ - protected abstract void renderChart(RenderContext context, LytRect plotRect); + /** @return the inner rectangle actually used for data plotting (may be {@code plotRect} itself) */ + protected abstract LytRect renderChart(PrimitiveCollector c, LytRect plotRect); /** * Collect legend entries; empty by default. Subclasses override as needed. @@ -283,7 +420,8 @@ public static ResolvedTextStyle textStyle(int argb) { TextAlignment.LEFT, false, null, - false); + false, + 0.0f); } public static String formatPercent(double ratio) { diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/LytColumnChart.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/LytColumnChart.java index 4be304ea..e5a24712 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/LytColumnChart.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/LytColumnChart.java @@ -7,7 +7,9 @@ import com.hfstudio.guidenh.guide.document.LytRect; import com.hfstudio.guidenh.guide.internal.debug.DebugComponent; -import com.hfstudio.guidenh.guide.render.RenderContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.GuideText; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.style.ResolvedTextStyle; import lombok.Getter; @@ -70,7 +72,7 @@ public void setBarWidthRatio(float r) { } @Override - protected int getExtraPlotWidth() { + public int getExtraPlotWidth() { if (pieInset != null && pieInset.getPosition() == PieInsetSpec.Position.RIGHT_OUTSIDE) { return pieInset.getSize() + PIE_OUTSIDE_GAP; } @@ -90,10 +92,10 @@ protected List collectLegendEntries() { } @Override - protected void renderChart(RenderContext context, LytRect plotRect) { + protected LytRect renderChart(PrimitiveCollector c, LytRect plotRect) { int categoryCount = Math.max(categories.length, maxSeriesLength()); if (categoryCount == 0 || (series.isEmpty() && lineOverlays.isEmpty())) { - return; + return plotRect; } // If the pie inset uses RIGHT_OUTSIDE, peel off a dedicated right-hand area for it so the // columns/lines do not have to share space with the pie. @@ -129,23 +131,15 @@ protected void renderChart(RenderContext context, LytRect plotRect) { yRangeCache = yRange; // Reserve space along the left/bottom for axis labels and tick text. - int[] insets = CartesianChartRenderer.computeAxisInsets( - context, - xAxis, - yAxis, - null, - yRange, - categories.length > 0 ? categories : null, - true, - true); + int[] insets = CartesianChartRenderer + .computeAxisInsets(xAxis, yAxis, null, yRange, categories.length > 0 ? categories : null, true, true); LytRect inner = plotRect.shrink(insets[0], insets[1], insets[2], insets[3]); plotCache = inner; if (inner.width() <= 4 || inner.height() <= 4) { - return; + return inner; } - CartesianChartRenderer - .drawAxes(context, inner, xAxis, yAxis, null, yRange, ensureCategories(categoryCount), false); + CartesianChartRenderer.drawAxes(c, inner, xAxis, yAxis, null, yRange, ensureCategories(categoryCount), false); float categoryWidth = (float) inner.width() / categoryCount; int seriesCount = series.size(); @@ -176,11 +170,22 @@ protected void renderChart(RenderContext context, LytRect plotRect) { (int) yTop, Math.max(1, (int) (x1 - x0)), Math.max(1, (int) (yBot - yTop))); - context.fillRect(bar, s.getColor()); + c.emit( + new GuideRenderPrimitive.FillRect(bar.x(), bar.y(), bar.width(), bar.height(), s.getColor())); if (hovered) { - context.drawBorder(bar, 0xFF000000, 1); + c.emit( + new GuideRenderPrimitive.DrawBorder( + bar.x(), + bar.y(), + bar.width(), + bar.height(), + 1, + 1, + 1, + 1, + 0xFF000000)); } - drawValueLabel(context, valueStyle, v, bar, baselineY, topY); + drawValueLabel(c, valueStyle, v, bar, baselineY, topY); } } } @@ -205,14 +210,14 @@ protected void renderChart(RenderContext context, LytRect plotRect) { if (hoveredLineSeries == li && (hoveredLinePoint == i || hoveredLinePoint == i + 1)) { thick += 1f; } - context.drawLine(px[i], py[i], px[i + 1], py[i + 1], thick, s.getColor()); + c.emit(new GuideRenderPrimitive.DrawLine(px[i], py[i], px[i + 1], py[i + 1], thick, s.getColor())); } for (int i = 0; i < n; i++) { boolean ph = hoveredLineSeries == li && hoveredLinePoint == i; float r = ph ? LINE_POINT_RADIUS + 2f : LINE_POINT_RADIUS; - context.fillCircle(px[i], py[i], r, s.getColor()); + c.emit(new GuideRenderPrimitive.DrawCircle(px[i], py[i], r, s.getColor(), true)); if (ph) { - context.drawCircleOutline(px[i], py[i], r, 1f, 0xFF000000); + c.emit(new GuideRenderPrimitive.DrawCircleOutline(px[i], py[i], r, 1f, 0xFF000000)); } } } @@ -220,18 +225,19 @@ protected void renderChart(RenderContext context, LytRect plotRect) { // Pie inset (if configured) goes after columns + lines so it sits on top. if (pieArea != null) { - PieInsetRenderer.drawAt(context, pieArea, pieInset); + PieInsetRenderer.drawAt(c, pieArea, pieInset); } else { - PieInsetRenderer.draw(context, inner, pieInset); + PieInsetRenderer.draw(c, inner, pieInset); } + return inner; } - private void drawValueLabel(RenderContext context, ResolvedTextStyle style, double value, LytRect bar, + private void drawValueLabel(PrimitiveCollector c, ResolvedTextStyle style, double value, LytRect bar, float baselineY, float topY) { if (getLabelPosition() == ChartLabelPosition.NONE) return; String text = formatValue(value); - int tw = context.getStringWidth(text, style); - int lh = context.getLineHeight(style); + int tw = GuideText.measureWidth(text, style); + int lh = GuideText.lineHeight(style); int textX = bar.x() + (bar.width() - tw) / 2; int textY; switch (getLabelPosition()) { @@ -251,7 +257,7 @@ private void drawValueLabel(RenderContext context, ResolvedTextStyle style, doub default: return; } - context.drawText(text, textX, textY, style); + GuideText.emitText(c, text, textX, textY, style); } private String[] ensureCategories(int count) { diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/LytLineChart.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/LytLineChart.java index 2bef87d2..00c76682 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/LytLineChart.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/LytLineChart.java @@ -6,7 +6,9 @@ import net.minecraft.item.ItemStack; import com.hfstudio.guidenh.guide.document.LytRect; -import com.hfstudio.guidenh.guide.render.RenderContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.GuideText; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.style.ResolvedTextStyle; import lombok.Getter; @@ -76,8 +78,8 @@ protected List collectCornerLegendEntries() { } @Override - protected void renderChart(RenderContext context, LytRect plotRect) { - if (series.isEmpty()) return; + protected LytRect renderChart(PrimitiveCollector c, LytRect plotRect) { + if (series.isEmpty()) return plotRect; double yMin = Double.POSITIVE_INFINITY; double yMax = Double.NEGATIVE_INFINITY; @@ -107,7 +109,6 @@ protected void renderChart(RenderContext context, LytRect plotRect) { int categoryCount = Math.max(categories.length, maxSeriesLength()); int[] insets = CartesianChartRenderer.computeAxisInsets( - context, xAxis, yAxis, xRange, @@ -117,10 +118,10 @@ protected void renderChart(RenderContext context, LytRect plotRect) { true); LytRect inner = plotRect.shrink(insets[0], insets[1], insets[2], insets[3]); plotCache = inner; - if (inner.width() <= 4 || inner.height() <= 4) return; + if (inner.width() <= 4 || inner.height() <= 4) return inner; CartesianChartRenderer.drawAxes( - context, + c, inner, xAxis, yAxis, @@ -148,7 +149,7 @@ protected void renderChart(RenderContext context, LytRect plotRect) { if (hoveredKey >= 0 && hoveredSeries == si && (hoveredPoint == i || hoveredPoint == i + 1)) { thick = LINE_THICKNESS + 1f; } - context.drawLine(px[i], py[i], px[i + 1], py[i + 1], thick, s.getColor()); + c.emit(new GuideRenderPrimitive.DrawLine(px[i], py[i], px[i + 1], py[i + 1], thick, s.getColor())); } // Data points. @@ -165,9 +166,9 @@ protected void renderChart(RenderContext context, LytRect plotRect) { y += off[1] * 2f; } float r = hovered ? POINT_RADIUS + 2f : POINT_RADIUS; - context.fillCircle(x, y, r, s.getColor()); + c.emit(new GuideRenderPrimitive.DrawCircle(x, y, r, s.getColor(), true)); if (hovered) { - context.drawCircleOutline(x, y, r, 1f, 0xFF000000); + c.emit(new GuideRenderPrimitive.DrawCircleOutline(x, y, r, 1f, 0xFF000000)); } } } @@ -175,10 +176,10 @@ protected void renderChart(RenderContext context, LytRect plotRect) { // Data value labels. if (getLabelPosition() != ChartLabelPosition.NONE) { ResolvedTextStyle style = textStyle(getLabelColor()); - int lh = context.getLineHeight(style); + int lh = GuideText.lineHeight(style); for (int i = 0; i < n; i++) { String text = formatValue(s.getYs()[i]); - int tw = context.getStringWidth(text, style); + int tw = GuideText.measureWidth(text, style); int tx = (int) px[i] - tw / 2; int ty; switch (getLabelPosition()) { @@ -196,10 +197,11 @@ protected void renderChart(RenderContext context, LytRect plotRect) { default: continue; } - context.drawText(text, tx, ty, style); + GuideText.emitText(c, text, tx, ty, style); } } } + return inner; } private static float[] computeOutwardNormal(float[] xs, float[] ys, int i, int n) { diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/LytPieChart.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/LytPieChart.java index adb5af01..90eb29ed 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/LytPieChart.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/LytPieChart.java @@ -7,7 +7,9 @@ import com.hfstudio.guidenh.guide.document.LytRect; import com.hfstudio.guidenh.guide.internal.debug.DebugComponent; -import com.hfstudio.guidenh.guide.render.RenderContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.GuideText; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.style.ResolvedTextStyle; import lombok.Getter; @@ -47,13 +49,13 @@ protected List collectLegendEntries() { } @Override - protected void renderChart(RenderContext context, LytRect plotRect) { - if (slices.isEmpty()) return; + protected LytRect renderChart(PrimitiveCollector c, LytRect plotRect) { + if (slices.isEmpty()) return plotRect; double total = 0d; for (PieSlice s : slices) { total += Math.max(0d, s.getValue()); } - if (total <= 0d) return; + if (total <= 0d) return plotRect; totalCache = total; float cx = plotRect.x() + plotRect.width() / 2f; @@ -64,7 +66,7 @@ protected void renderChart(RenderContext context, LytRect plotRect) { radiusCache = radius; ResolvedTextStyle labelStyle = textStyle(getLabelColor()); - int lh = context.getLineHeight(labelStyle); + int lh = GuideText.lineHeight(labelStyle); double angle = Math.toRadians(startAngleDeg); double dir = clockwise ? 1d : -1d; for (int i = 0; i < slices.size(); i++) { @@ -75,7 +77,7 @@ protected void renderChart(RenderContext context, LytRect plotRect) { // Hovered slice keeps its apex at (cx, cy); only the outer arc bulges outward by // HOVER_OFFSET so the wedge is emphasized without dislocating its centre. float drawRadius = hovered ? radius + HOVER_OFFSET : radius; - drawSlice(context, cx, cy, drawRadius, angle, sweep, slice.getColor()); + drawSlice(c, cx, cy, drawRadius, angle, sweep, slice.getColor()); // Label. ChartLabelPosition pos = getLabelPosition(); if (pos != ChartLabelPosition.NONE) { @@ -83,21 +85,29 @@ protected void renderChart(RenderContext context, LytRect plotRect) { case OUTSIDE, ABOVE, BELOW -> slice.getLabel() + " " + formatPercent(slice.getValue() / total); default -> formatPercent(slice.getValue() / total); }; - int tw = context.getStringWidth(text, labelStyle); + int tw = GuideText.measureWidth(text, labelStyle); + // R4-16: OUTSIDE labels use labelR = drawRadius + lh + 4f so text is pushed clear of + // the pie boundary instead of sitting only 4px out. The clamp is relaxed by tw/2 on + // left/right and lh/2 on top/bottom so large-slice labels are not pulled back inside. float labelR = pos == ChartLabelPosition.OUTSIDE || pos == ChartLabelPosition.ABOVE - || pos == ChartLabelPosition.BELOW ? drawRadius + 4f : drawRadius * 0.6f; + || pos == ChartLabelPosition.BELOW ? drawRadius + Math.max(lh + 2f, 8f) : drawRadius * 0.6f; float tx = cx + (float) Math.cos(mid) * labelR - tw / 2f; float ty = cy + (float) Math.sin(mid) * labelR - lh / 2f; - // Clamp label inside the plot rectangle so OUTSIDE labels do not overflow the chart frame. - int clampedTx = Math.max(plotRect.x(), Math.min(plotRect.right() - tw, (int) tx)); - int clampedTy = Math.max(plotRect.y(), Math.min(plotRect.bottom() - lh, (int) ty)); - context.drawText(text, clampedTx, clampedTy, labelStyle); + // Clamp label with relaxed bounds so outside labels project beyond the pie without + // overflowing the chart frame entirely. + int relaxedLeft = plotRect.x() - (pos == ChartLabelPosition.OUTSIDE ? tw / 2 : 0); + int relaxedRight = plotRect.right() - tw + (pos == ChartLabelPosition.OUTSIDE ? tw / 2 : 0); + int clampedTx = Math.max(relaxedLeft, Math.min(relaxedRight, (int) tx)); + int clampedTy = Math.max(plotRect.y() - (pos == ChartLabelPosition.OUTSIDE ? lh / 2 : 0), + Math.min(plotRect.bottom() - lh + (pos == ChartLabelPosition.OUTSIDE ? lh / 2 : 0), (int) ty)); + GuideText.emitText(c, text, clampedTx, clampedTy, labelStyle); } angle += sweep; } + return plotRect; } - private static void drawSlice(RenderContext context, float cx, float cy, float radius, double startAngle, + private static void drawSlice(PrimitiveCollector c, float cx, float cy, float radius, double startAngle, double sweepAngle, int color) { if (Math.abs(sweepAngle) < 1e-6) return; int segments = Math.max(2, (int) Math.ceil(CIRCLE_SEGMENTS * Math.abs(sweepAngle) / (Math.PI * 2d))); @@ -110,7 +120,7 @@ private static void drawSlice(RenderContext context, float cx, float cy, float r xs[i + 1] = cx + (float) Math.cos(a) * radius; ys[i + 1] = cy + (float) Math.sin(a) * radius; } - context.fillPolygon(xs, ys, color); + c.emit(new GuideRenderPrimitive.DrawPolygon(xs, ys, color)); } @Override diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/LytScatterChart.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/LytScatterChart.java index 586efeb6..37d0ad90 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/LytScatterChart.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/LytScatterChart.java @@ -6,7 +6,9 @@ import net.minecraft.item.ItemStack; import com.hfstudio.guidenh.guide.document.LytRect; -import com.hfstudio.guidenh.guide.render.RenderContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.GuideText; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.style.ResolvedTextStyle; import lombok.Getter; @@ -61,8 +63,8 @@ protected List collectCornerLegendEntries() { } @Override - protected void renderChart(RenderContext context, LytRect plotRect) { - if (series.isEmpty()) return; + protected LytRect renderChart(PrimitiveCollector c, LytRect plotRect) { + if (series.isEmpty()) return plotRect; double xMin = Double.POSITIVE_INFINITY; double xMax = Double.NEGATIVE_INFINITY; double yMin = Double.POSITIVE_INFINITY; @@ -90,16 +92,15 @@ protected void renderChart(RenderContext context, LytRect plotRect) { xRangeCache = xRange; yRangeCache = yRange; - int[] insets = CartesianChartRenderer - .computeAxisInsets(context, xAxis, yAxis, xRange, yRange, null, true, true); + int[] insets = CartesianChartRenderer.computeAxisInsets(xAxis, yAxis, xRange, yRange, null, true, true); LytRect inner = plotRect.shrink(insets[0], insets[1], insets[2], insets[3]); plotCache = inner; - if (inner.width() <= 4 || inner.height() <= 4) return; + if (inner.width() <= 4 || inner.height() <= 4) return inner; - CartesianChartRenderer.drawAxes(context, inner, xAxis, yAxis, xRange, yRange, null, true); + CartesianChartRenderer.drawAxes(c, inner, xAxis, yAxis, xRange, yRange, null, true); ResolvedTextStyle valueStyle = textStyle(getLabelColor()); - int lh = context.getLineHeight(valueStyle); + int lh = GuideText.lineHeight(valueStyle); int hoveredSeries = decodeSeries(hoveredKey); int hoveredPoint = decodePoint(hoveredKey); for (int si = 0; si < series.size(); si++) { @@ -111,13 +112,13 @@ protected void renderChart(RenderContext context, LytRect plotRect) { boolean hovered = hoveredKey >= 0 && hoveredSeries == si && hoveredPoint == i; float r = hovered ? POINT_RADIUS + 2f : POINT_RADIUS; int color = hovered ? brighten(s.getColor()) : s.getColor(); - context.fillCircle(x, y, r, color); + c.emit(new GuideRenderPrimitive.DrawCircle(x, y, r, color, true)); if (hovered) { - context.drawCircleOutline(x, y, r, 1f, 0xFF000000); + c.emit(new GuideRenderPrimitive.DrawCircleOutline(x, y, r, 1f, 0xFF000000)); } if (getLabelPosition() != ChartLabelPosition.NONE) { String text = "(" + formatValue(s.getXs()[i]) + "," + formatValue(s.getYs()[i]) + ")"; - int tw = context.getStringWidth(text, valueStyle); + int tw = GuideText.measureWidth(text, valueStyle); int tx = (int) x - tw / 2; int ty; switch (getLabelPosition()) { @@ -131,10 +132,11 @@ protected void renderChart(RenderContext context, LytRect plotRect) { default: continue; } - context.drawText(text, tx, ty, valueStyle); + GuideText.emitText(c, text, tx, ty, valueStyle); } } } + return inner; } private static int brighten(int argb) { diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/PieInsetRenderer.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/PieInsetRenderer.java index f6ec4318..be5ee573 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/PieInsetRenderer.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/chart/PieInsetRenderer.java @@ -1,7 +1,9 @@ package com.hfstudio.guidenh.guide.document.block.chart; import com.hfstudio.guidenh.guide.document.LytRect; -import com.hfstudio.guidenh.guide.render.RenderContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.GuideText; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.style.ResolvedTextStyle; /** @@ -15,7 +17,7 @@ public class PieInsetRenderer { protected PieInsetRenderer() {} - public static void draw(RenderContext context, LytRect plotRect, PieInsetSpec spec) { + public static void draw(PrimitiveCollector c, LytRect plotRect, PieInsetSpec spec) { if (spec == null || spec.getSlices() .isEmpty()) { return; @@ -46,14 +48,14 @@ public static void draw(RenderContext context, LytRect plotRect, PieInsetSpec sp areaY = plotRect.y() + MARGIN; break; } - drawInternal(context, spec, areaX, areaY, size); + drawInternal(c, spec, areaX, areaY, size); } /** * Draw the pie inset filling the provided rectangle entirely; used when the host chart reserves a * dedicated outside area (e.g. {@link PieInsetSpec.Position#RIGHT_OUTSIDE}). */ - public static void drawAt(RenderContext context, LytRect area, PieInsetSpec spec) { + public static void drawAt(PrimitiveCollector c, LytRect area, PieInsetSpec spec) { if (spec == null || area == null || area.width() <= 16 || area.height() <= 16) { return; } @@ -64,10 +66,10 @@ public static void drawAt(RenderContext context, LytRect area, PieInsetSpec spec int size = Math.min(area.width(), area.height()); int areaX = area.x() + (area.width() - size) / 2; int areaY = area.y() + (area.height() - size) / 2; - drawInternal(context, spec, areaX, areaY, size); + drawInternal(c, spec, areaX, areaY, size); } - private static void drawInternal(RenderContext context, PieInsetSpec spec, int areaX, int areaY, int size) { + private static void drawInternal(PrimitiveCollector c, PieInsetSpec spec, int areaX, int areaY, int size) { double total = 0d; for (PieSlice slice : spec.getSlices()) { total += Math.max(0d, slice.getValue()); @@ -79,13 +81,13 @@ private static void drawInternal(RenderContext context, PieInsetSpec spec, int a int titleHeight = 0; if (!spec.getTitle() .isEmpty()) { - titleHeight = context.getLineHeight(titleStyle); - int tw = context.getStringWidth(spec.getTitle(), titleStyle); + titleHeight = GuideText.lineHeight(titleStyle); + int tw = GuideText.measureWidth(spec.getTitle(), titleStyle); // Center within the inset; if the title is wider than the inset, anchor to the inset's // left edge so it does not bleed into the host plot. int tx = tw <= size ? areaX + (size - tw) / 2 : areaX; int ty = areaY; - context.drawText(spec.getTitle(), tx, ty, titleStyle); + GuideText.emitText(c, spec.getTitle(), tx, ty, titleStyle); } int pieSize = size - titleHeight; @@ -98,14 +100,14 @@ private static void drawInternal(RenderContext context, PieInsetSpec spec, int a double dir = spec.isClockwise() ? 1d : -1d; for (PieSlice slice : spec.getSlices()) { double sweep = (slice.getValue() / total) * Math.PI * 2d * dir; - drawSlice(context, cx, cy, radius, angle, sweep, slice.getColor()); + drawSlice(c, cx, cy, radius, angle, sweep, slice.getColor()); angle += sweep; } // Thin outline around the pie to separate it from the host plot. - context.drawCircleOutline(cx, cy, radius, 1f, 0xFF202020); + c.emit(new GuideRenderPrimitive.DrawCircleOutline(cx, cy, radius, 1f, 0xFF202020)); } - private static void drawSlice(RenderContext context, float cx, float cy, float radius, double startAngle, + private static void drawSlice(PrimitiveCollector c, float cx, float cy, float radius, double startAngle, double sweepAngle, int color) { if (Math.abs(sweepAngle) < 1e-6) return; int segments = Math.max(2, (int) Math.ceil(CIRCLE_SEGMENTS * Math.abs(sweepAngle) / (Math.PI * 2d))); @@ -118,7 +120,7 @@ private static void drawSlice(RenderContext context, float cx, float cy, float r xs[i + 1] = cx + (float) Math.cos(a) * radius; ys[i + 1] = cy + (float) Math.sin(a) * radius; } - context.fillPolygon(xs, ys, color); + c.emit(new GuideRenderPrimitive.DrawPolygon(xs, ys, color)); } private static ResolvedTextStyle textStyle(int color) { diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/functiongraph/DomainPredicate.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/functiongraph/DomainPredicate.java index 25e8da98..96752486 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/functiongraph/DomainPredicate.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/functiongraph/DomainPredicate.java @@ -131,12 +131,29 @@ static double parseNumberOrConstant(String text, double fallback) { if (text == null || text.isEmpty()) { return fallback; } - double constant = FunctionLibrary.constant(text); + String trimmed = text.trim(); + if (trimmed.isEmpty()) { + return fallback; + } + // Unary sign before a constant ("-pi", "+tau"): Double.parseDouble + // handles signed numbers itself, but the constant lookup needs the + // sign stripped and re-applied. + int sign = 1; + String body = trimmed; + if (body.startsWith("-")) { + sign = -1; + body = body.substring(1) + .trim(); + } else if (body.startsWith("+")) { + body = body.substring(1) + .trim(); + } + double constant = FunctionLibrary.constant(body); if (!Double.isNaN(constant)) { - return constant; + return sign * constant; } try { - return Double.parseDouble(text); + return Double.parseDouble(trimmed); } catch (NumberFormatException ex) { return fallback; } diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/functiongraph/LytFunctionGraph.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/functiongraph/LytFunctionGraph.java index 877711a3..a15f0414 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/functiongraph/LytFunctionGraph.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/functiongraph/LytFunctionGraph.java @@ -15,6 +15,9 @@ import com.hfstudio.guidenh.guide.document.interaction.GuideTooltip; import com.hfstudio.guidenh.guide.document.interaction.InteractiveElement; import com.hfstudio.guidenh.guide.layout.LayoutContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.GuideText; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.render.RenderContext; import com.hfstudio.guidenh.guide.style.ResolvedTextStyle; import com.hfstudio.guidenh.guide.style.TextAlignment; @@ -36,8 +39,8 @@ */ public class LytFunctionGraph extends LytBlock implements InteractiveElement, DocumentDragTarget { - private static final int DEFAULT_WIDTH = 320; - private static final int DEFAULT_HEIGHT = 220; + public static final int DEFAULT_WIDTH = 320; + public static final int DEFAULT_HEIGHT = 220; private static final int PADDING = 8; private static final int TITLE_GAP = 4; private static final int AXIS_LABEL_GAP = 4; @@ -71,6 +74,23 @@ public class LytFunctionGraph extends LytBlock implements InteractiveElement, Do private static final ResolvedTextStyle TOOLTIP_BODY_STYLE = makeStyle(0xFFD7DEE7, false); private static final ResolvedTextStyle LEGEND_LABEL_STYLE = makeStyle(0xFFD7DEE7, false); + // ---- Exposure for serializer precomputation (no flatc available) ---- + + /** @see #TITLE_GAP */ + public static int getTitleGapConstant() { return TITLE_GAP; } + + /** @see #TITLE_STYLE */ + public static ResolvedTextStyle getTitleStyle() { return TITLE_STYLE; } + + /** @see #LEGEND_LABEL_STYLE */ + public static ResolvedTextStyle getLegendLabelStyle() { return LEGEND_LABEL_STYLE; } + + /** @see #LEGEND_SWATCH_SIZE */ + public static int getLegendSwatchSize() { return LEGEND_SWATCH_SIZE; } + + /** @see #LEGEND_SWATCH_TEXT_GAP */ + public static int getLegendSwatchTextGap() { return LEGEND_SWATCH_TEXT_GAP; } + @Getter private final List plots = new ArrayList<>(); @Getter @@ -207,7 +227,9 @@ protected LytRect computeLayout(LayoutContext context, int x, int y, int availab if (title != null && !title.isEmpty()) { fixedChromeHeight += context.getLineHeight(TITLE_STYLE) + TITLE_GAP; } - int legendHeight = measureLegendHeight(context, plotWidth); + // R4-15: Skip bottom legend space when corner legend is active. + boolean hasCornerLegend = cornerLegendPosition != CornerLegendPosition.NONE; + int legendHeight = hasCornerLegend ? 0 : measureLegendHeight(plotWidth); if (legendHeight > 0) { fixedChromeHeight += legendHeight + LEGEND_GAP_ABOVE; } @@ -227,9 +249,35 @@ protected void onLayoutMoved(int deltaX, int deltaY) { } @Override - public void render(RenderContext context) { - context.fillRect(bounds, backgroundColor); - context.drawBorder(bounds, borderColor, 1); + protected void onExternalLayoutApplied(LytRect oldBounds, LytRect newBounds) { + invalidateSamples(); + } + + @Override + public boolean usePrimitives() { + return true; + } + + @Override + public void computePrimitives(PrimitiveCollector c) { + c.emit( + new GuideRenderPrimitive.FillRect( + bounds.x(), + bounds.y(), + bounds.width(), + bounds.height(), + backgroundColor)); + c.emit( + new GuideRenderPrimitive.DrawBorder( + bounds.x(), + bounds.y(), + bounds.width(), + bounds.height(), + 1, + 1, + 1, + 1, + borderColor)); int contentTop = bounds.y() + PADDING; int contentBottom = bounds.bottom() - PADDING; @@ -237,17 +285,19 @@ public void render(RenderContext context) { int contentRight = bounds.right() - PADDING; if (title != null && !title.isEmpty()) { - int tw = context.getStringWidth(title, TITLE_STYLE); + int tw = GuideText.measureWidth(title, TITLE_STYLE); int tx = bounds.x() + (bounds.width() - tw) / 2; - context.drawText(title, tx, contentTop, TITLE_STYLE); - contentTop += context.getLineHeight(TITLE_STYLE) + TITLE_GAP; + GuideText.emitText(c, title, tx, contentTop, TITLE_STYLE); + contentTop += GuideText.lineHeight(TITLE_STYLE) + TITLE_GAP; } int plotLeft = contentLeft + AXIS_PAD_LEFT; int plotRight = contentRight; int plotTop = contentTop; int legendWidth = Math.max(0, plotRight - plotLeft); - int legendHeight = measureLegendHeight(context, legendWidth); + // R4-15: When corner legend is active, skip the bottom legend entirely — no space reservation. + boolean hasCornerLegend = cornerLegendPosition != CornerLegendPosition.NONE; + int legendHeight = hasCornerLegend ? 0 : measureLegendHeight(legendWidth); int plotBottom = contentBottom - AXIS_PAD_BOTTOM - (legendHeight > 0 ? legendHeight + LEGEND_GAP_ABOVE : 0); if (plotRight - plotLeft <= 16 || plotBottom - plotTop <= 16) { return; @@ -265,31 +315,34 @@ public void render(RenderContext context) { } if (showGrid) { - drawGrid(context, plotRect); + drawGrid(c, plotRect); } if (showAxes) { - drawAxes(context, plotRect); + drawAxes(c, plotRect); } for (int i = 0; i < plots.size(); i++) { - renderPlot(context, plotRect, i); + renderPlot(c, plotRect, i); } - renderMarkedPoints(context, plotRect); - renderAutoPoints(context, plotRect); + renderMarkedPoints(c, plotRect); + renderAutoPoints(c, plotRect); if ((activePlotIndex >= 0 && activePlotIndex < plots.size()) || activeMarkedIndex >= 0 || activeAutoPlotIndex >= 0) { - renderActiveOverlay(context, plotRect); + renderActiveOverlay(c, plotRect); } - renderCornerLegend(context, plotRect); + renderCornerLegend(c, plotRect); if (legendHeight > 0) { int legendTop = plotRect.bottom() + AXIS_PAD_BOTTOM + LEGEND_GAP_ABOVE; - renderLegend(context, plotRect.x(), legendTop, legendWidth); + renderLegend(c, plotRect.x(), legendTop, legendWidth); } } + @Override + public void render(RenderContext context) {} + @Override public Optional getTooltip(float x, float y) { if (!isDragging) { @@ -512,61 +565,61 @@ private double unmapXToData(double screenX, boolean inverse) { return inverse ? unmapY(screenX) : unmapX(screenX); } - private void drawGrid(RenderContext context, LytRect plotRect) { + private void drawGrid(PrimitiveCollector c, LytRect plotRect) { if (effectiveXStep > 0) { double start = Math.ceil(effectiveXMin / effectiveXStep) * effectiveXStep; for (double v = start; v <= effectiveXMax + 1e-9; v += effectiveXStep) { float x = (float) mapX(v); - context.drawLine(x, plotRect.y(), x, plotRect.bottom(), 1f, gridColor); + c.emit(new GuideRenderPrimitive.DrawLine(x, plotRect.y(), x, plotRect.bottom(), 1f, gridColor)); } } if (effectiveYStep > 0) { double start = Math.ceil(effectiveYMin / effectiveYStep) * effectiveYStep; for (double v = start; v <= effectiveYMax + 1e-9; v += effectiveYStep) { float y = (float) mapY(v); - context.drawLine(plotRect.x(), y, plotRect.right(), y, 1f, gridColor); + c.emit(new GuideRenderPrimitive.DrawLine(plotRect.x(), y, plotRect.right(), y, 1f, gridColor)); } } } - private void drawAxes(RenderContext context, LytRect plotRect) { + private void drawAxes(PrimitiveCollector c, LytRect plotRect) { // Vertical (y) axis pinned to x = 0 when visible, otherwise to plotRect.x. float axisX = (float) mapX(0d); if (axisX < plotRect.x() || axisX > plotRect.right()) { axisX = plotRect.x(); } - context.drawLine(axisX, plotRect.y(), axisX, plotRect.bottom(), 1f, axisColor); + c.emit(new GuideRenderPrimitive.DrawLine(axisX, plotRect.y(), axisX, plotRect.bottom(), 1f, axisColor)); float axisY = (float) mapY(0d); if (axisY < plotRect.y() || axisY > plotRect.bottom()) { axisY = plotRect.bottom(); } - context.drawLine(plotRect.x(), axisY, plotRect.right(), axisY, 1f, axisColor); + c.emit(new GuideRenderPrimitive.DrawLine(plotRect.x(), axisY, plotRect.right(), axisY, 1f, axisColor)); // Y tick labels along left edge of plot rect. if (effectiveYStep > 0) { double start = Math.ceil(effectiveYMin / effectiveYStep) * effectiveYStep; - int lh = context.getLineHeight(AXIS_LABEL_STYLE); + int lh = GuideText.lineHeight(AXIS_LABEL_STYLE); for (double v = start; v <= effectiveYMax + 1e-9; v += effectiveYStep) { String label = formatTick(v); - int sw = context.getStringWidth(label, AXIS_LABEL_STYLE); + int sw = GuideText.measureWidth(label, AXIS_LABEL_STYLE); int ly = (int) mapY(v) - lh / 2; - context.drawText(label, plotRect.x() - sw - AXIS_LABEL_GAP, ly, AXIS_LABEL_STYLE); + GuideText.emitText(c, label, plotRect.x() - sw - AXIS_LABEL_GAP, ly, AXIS_LABEL_STYLE); } } if (effectiveXStep > 0) { double start = Math.ceil(effectiveXMin / effectiveXStep) * effectiveXStep; for (double v = start; v <= effectiveXMax + 1e-9; v += effectiveXStep) { String label = formatTick(v); - int sw = context.getStringWidth(label, AXIS_LABEL_STYLE); + int sw = GuideText.measureWidth(label, AXIS_LABEL_STYLE); int lx = (int) mapX(v) - sw / 2; lx = Math.clamp(lx, plotRect.x() - sw / 2, plotRect.right() - sw / 2); - context.drawText(label, lx, plotRect.bottom() + AXIS_LABEL_GAP, AXIS_LABEL_STYLE); + GuideText.emitText(c, label, lx, plotRect.bottom() + AXIS_LABEL_GAP, AXIS_LABEL_STYLE); } } } - private void renderPlot(RenderContext context, LytRect plotRect, int index) { + private void renderPlot(PrimitiveCollector c, LytRect plotRect, int index) { FunctionPlot plot = plots.get(index); float[] xs = sampleXs[index]; float[] ys = sampleYs[index]; @@ -597,11 +650,37 @@ private void renderPlot(RenderContext context, LytRect plotRect, int index) { if ((x1 < plotRect.x() && x2 < plotRect.x()) || (x1 > plotRect.right() && x2 > plotRect.right())) { continue; } - context.drawLine(x1, y1, x2, y2, thickness, color); + // R4-15: Quadrant mask clipping — skip segments whose data endpoints are both outside + // the allowed quadrants. + if (explicitQuadrantMask != 0 && explicitQuadrantMask != 0xF) { + double dx1 = unmapX(x1); + double dy1 = unmapY(y1); + double dx2 = unmapX(x2); + double dy2 = unmapY(y2); + if (!isPointInQuadrant(dx1, dy1, explicitQuadrantMask) + && !isPointInQuadrant(dx2, dy2, explicitQuadrantMask)) { + continue; + } + } + c.emit(new GuideRenderPrimitive.DrawLine(x1, y1, x2, y2, thickness, color)); + } + } + + /** + * R4-15: Check whether a data point falls within the allowed quadrant mask. + * Bits 0-3 correspond to quadrants 1-4 (Q1: x>=0,y>=0, Q2: x<0,y>=0, Q3: x<0,y<0, Q4: x>=0,y<0). + */ + private static boolean isPointInQuadrant(double dataX, double dataY, int mask) { + int q; + if (dataX >= 0d) { + q = dataY >= 0d ? 1 : 4; + } else { + q = dataY >= 0d ? 2 : 3; } + return (mask & (1 << (q - 1))) != 0; } - private void renderMarkedPoints(RenderContext context, LytRect plotRect) { + private void renderMarkedPoints(PrimitiveCollector c, LytRect plotRect) { for (MarkedPoint point : points) { double[] res = resolveMarkedPoint(point); if (res == null) { @@ -618,8 +697,8 @@ private void renderMarkedPoints(RenderContext context, LytRect plotRect) { if (sy < plotRect.y() - POINT_RADIUS || sy > plotRect.bottom() + POINT_RADIUS) { continue; } - context.fillCircle(sx, sy, POINT_RADIUS + POINT_OUTER_RING, 0xFFFFFFFF); - context.fillCircle(sx, sy, POINT_RADIUS, color); + c.emit(new GuideRenderPrimitive.DrawCircle(sx, sy, POINT_RADIUS + POINT_OUTER_RING, 0xFFFFFFFF, true)); + c.emit(new GuideRenderPrimitive.DrawCircle(sx, sy, POINT_RADIUS, color, true)); } } @@ -668,7 +747,7 @@ private double[] resolveMarkedPoint(MarkedPoint point) { return new double[] { dataX, dataY, (double) color }; } - private void renderAutoPoints(RenderContext context, LytRect plotRect) { + private void renderAutoPoints(PrimitiveCollector c, LytRect plotRect) { autoPointHitCache.clear(); for (int pi = 0; pi < plots.size(); pi++) { FunctionPlot plot = plots.get(pi); @@ -679,19 +758,19 @@ private void renderAutoPoints(RenderContext context, LytRect plotRect) { int color = spec.colorInherit() ? plot.getColor() : spec.color(); int drawn = 0; if (!Double.isNaN(spec.everyX())) { - drawn = renderAutoPointsEveryX(context, plotRect, plot, spec, color, drawn, pi); + drawn = renderAutoPointsEveryX(c, plotRect, plot, spec, color, drawn, pi); } if (!Double.isNaN(spec.everyY()) && drawn < AUTO_POINT_MAX_PER_PLOT) { - renderAutoPointsEveryY(context, plotRect, plot, spec, color, drawn, pi); + renderAutoPointsEveryY(c, plotRect, plot, spec, color, drawn, pi); } } } - private int renderAutoPointsEveryX(RenderContext context, LytRect plotRect, FunctionPlot plot, AutoPointSpec spec, + private int renderAutoPointsEveryX(PrimitiveCollector c, LytRect plotRect, FunctionPlot plot, AutoPointSpec spec, int color, int drawn, int plotIndex) { if (plot.isInverse()) { return renderAutoPointIntersectionsForAxis( - context, + c, plotRect, plot, spec, @@ -711,7 +790,7 @@ private int renderAutoPointsEveryX(RenderContext context, LytRect plotRect, Func while (value <= max + 1e-9 && drawn < AUTO_POINT_MAX_PER_PLOT && targets < AUTO_POINT_MAX_TARGETS_PER_PLOT) { double dataX = value; double dataY = plot.evaluate(value); - if (drawAutoPoint(context, plotRect, dataX, dataY, color, spec.labelMode(), plotIndex)) { + if (drawAutoPoint(c, plotRect, dataX, dataY, color, spec.labelMode(), plotIndex)) { drawn++; } value += step; @@ -720,7 +799,7 @@ private int renderAutoPointsEveryX(RenderContext context, LytRect plotRect, Func return drawn; } - private int renderAutoPointsEveryY(RenderContext context, LytRect plotRect, FunctionPlot plot, AutoPointSpec spec, + private int renderAutoPointsEveryY(PrimitiveCollector c, LytRect plotRect, FunctionPlot plot, AutoPointSpec spec, int color, int drawn, int plotIndex) { if (plot.isInverse()) { double step = spec.everyY(); @@ -730,7 +809,7 @@ private int renderAutoPointsEveryY(RenderContext context, LytRect plotRect, Func && targets < AUTO_POINT_MAX_TARGETS_PER_PLOT) { double dataY = value; double dataX = plot.evaluate(value); - if (drawAutoPoint(context, plotRect, dataX, dataY, color, spec.labelMode(), plotIndex)) { + if (drawAutoPoint(c, plotRect, dataX, dataY, color, spec.labelMode(), plotIndex)) { drawn++; } value += step; @@ -744,7 +823,7 @@ private int renderAutoPointsEveryY(RenderContext context, LytRect plotRect, Func while (value <= effectiveYMax + 1e-9 && drawn < AUTO_POINT_MAX_PER_PLOT && targets < AUTO_POINT_MAX_TARGETS_PER_PLOT) { drawn = renderAutoPointIntersectionsForAxis( - context, + c, plotRect, plot, spec, @@ -761,7 +840,7 @@ private int renderAutoPointsEveryY(RenderContext context, LytRect plotRect, Func return drawn; } - private int renderAutoPointIntersectionsForAxis(RenderContext context, LytRect plotRect, FunctionPlot plot, + private int renderAutoPointIntersectionsForAxis(PrimitiveCollector c, LytRect plotRect, FunctionPlot plot, AutoPointSpec spec, int color, double target, double targetMin, double targetMax, boolean targetX, int drawn, int plotIndex) { double independentMin = plot.isInverse() ? effectiveYMin : effectiveXMin; @@ -789,7 +868,7 @@ private int renderAutoPointIntersectionsForAxis(RenderContext context, LytRect p prevValue = value; continue; } - if (drawAutoPoint(context, plotRect, dataX, dataY, color, spec.labelMode(), plotIndex)) { + if (drawAutoPoint(c, plotRect, dataX, dataY, color, spec.labelMode(), plotIndex)) { drawn++; } } @@ -823,7 +902,7 @@ private double solveIndependentForAxis(FunctionPlot plot, double target, boolean return (lo + hi) * 0.5d; } - private boolean drawAutoPoint(RenderContext context, LytRect plotRect, double dataX, double dataY, int color, + private boolean drawAutoPoint(PrimitiveCollector c, LytRect plotRect, double dataX, double dataY, int color, AutoPointLabelMode labelMode, int plotIndex) { if (!Double.isFinite(dataX) || !Double.isFinite(dataY)) { return false; @@ -837,12 +916,12 @@ private boolean drawAutoPoint(RenderContext context, LytRect plotRect, double da return false; } autoPointHitCache.add(new double[] { sx, sy, dataX, dataY, (double) color, (double) plotIndex }); - context.fillCircle(sx, sy, POINT_RADIUS + POINT_OUTER_RING, 0xFFFFFFFF); - context.fillCircle(sx, sy, POINT_RADIUS, color); + c.emit(new GuideRenderPrimitive.DrawCircle(sx, sy, POINT_RADIUS + POINT_OUTER_RING, 0xFFFFFFFF, true)); + c.emit(new GuideRenderPrimitive.DrawCircle(sx, sy, POINT_RADIUS, color, true)); if (labelMode != null && labelMode != AutoPointLabelMode.NONE) { String label = autoPointLabel(labelMode, dataX, dataY); - int width = context.getStringWidth(label, TOOLTIP_BODY_STYLE); - int lineHeight = context.getLineHeight(TOOLTIP_BODY_STYLE); + int width = GuideText.measureWidth(label, TOOLTIP_BODY_STYLE); + int lineHeight = GuideText.lineHeight(TOOLTIP_BODY_STYLE); int x = (int) sx + AUTO_POINT_LABEL_GAP; if (x + width > plotRect.right()) { x = (int) sx - width - AUTO_POINT_LABEL_GAP; @@ -851,7 +930,7 @@ private boolean drawAutoPoint(RenderContext context, LytRect plotRect, double da if (y < plotRect.y()) { y = (int) sy + AUTO_POINT_LABEL_GAP; } - context.drawText(label, x, y, TOOLTIP_BODY_STYLE); + GuideText.emitText(c, label, x, y, TOOLTIP_BODY_STYLE); } return true; } @@ -865,7 +944,7 @@ private String autoPointLabel(AutoPointLabelMode labelMode, double dataX, double }; } - private void renderCornerLegend(RenderContext context, LytRect plotRect) { + private void renderCornerLegend(PrimitiveCollector c, LytRect plotRect) { if (cornerLegendPosition == CornerLegendPosition.NONE) { return; } @@ -876,8 +955,8 @@ private void renderCornerLegend(RenderContext context, LytRect plotRect) { entries.add(new CornerLegendEntry(plot.getLabel(), plot.getColor(), true)); } } - CornerLegendRenderer.render( - context, + CornerLegendRenderer.emit( + c, plotRect, entries, cornerLegendPosition, @@ -886,13 +965,13 @@ private void renderCornerLegend(RenderContext context, LytRect plotRect) { cornerLegendBackgroundColor); } - private void renderActiveOverlay(RenderContext context, LytRect plotRect) { + private void renderActiveOverlay(PrimitiveCollector c, LytRect plotRect) { if (activeMarkedIndex >= 0) { - renderMarkedPointOverlay(context, plotRect); + renderMarkedPointOverlay(c, plotRect); return; } if (activeAutoPlotIndex >= 0) { - renderAutoPointOverlay(context, plotRect); + renderAutoPointOverlay(c, plotRect); return; } if (activePlotIndex < 0 || activePlotIndex >= plots.size()) { @@ -915,16 +994,16 @@ private void renderActiveOverlay(RenderContext context, LytRect plotRect) { if (sx < plotRect.x() || sx > plotRect.right() || sy < plotRect.y() || sy > plotRect.bottom()) { return; } - context.fillCircle(sx, sy, POINT_RADIUS + POINT_OUTER_RING, 0xFFFFFFFF); - context.fillCircle(sx, sy, POINT_RADIUS, plot.getColor()); + c.emit(new GuideRenderPrimitive.DrawCircle(sx, sy, POINT_RADIUS + POINT_OUTER_RING, 0xFFFFFFFF, true)); + c.emit(new GuideRenderPrimitive.DrawCircle(sx, sy, POINT_RADIUS, plot.getColor(), true)); // Tooltip panel. String line1 = !isEmpty(plot.getLabel()) ? plot.getLabel() : plot.getExpressionText(); String line2 = "(" + formatValue(dataX) + ", " + formatValue(dataY) + ")"; - renderTooltipBox(context, sx, sy, line1, line2); + renderTooltipBox(c, sx, sy, line1, line2); } - private void renderMarkedPointOverlay(RenderContext context, LytRect plotRect) { + private void renderMarkedPointOverlay(PrimitiveCollector c, LytRect plotRect) { double dataX = activeMarkedDataX; double dataY = activeMarkedDataY; int color = activeMarkedColor; @@ -934,17 +1013,17 @@ private void renderMarkedPointOverlay(RenderContext context, LytRect plotRect) { return; } // Larger highlight for marked points. - context.fillCircle(sx, sy, POINT_RADIUS + 2f, 0xFFFFFFFF); - context.drawCircleOutline(sx, sy, POINT_RADIUS + 2f, 1f, 0xFF000000); - context.fillCircle(sx, sy, POINT_RADIUS, color); + c.emit(new GuideRenderPrimitive.DrawCircle(sx, sy, POINT_RADIUS + 2f, 0xFFFFFFFF, true)); + c.emit(new GuideRenderPrimitive.DrawCircleOutline(sx, sy, POINT_RADIUS + 2f, 1f, 0xFF000000)); + c.emit(new GuideRenderPrimitive.DrawCircle(sx, sy, POINT_RADIUS, color, true)); MarkedPoint point = points.get(activeMarkedIndex); String line1 = !isEmpty(point.getLabel()) ? point.getLabel() : "Point"; String line2 = "(" + formatValue(dataX) + ", " + formatValue(dataY) + ")"; - renderTooltipBox(context, sx, sy, line1, line2); + renderTooltipBox(c, sx, sy, line1, line2); } - private void renderAutoPointOverlay(RenderContext context, LytRect plotRect) { + private void renderAutoPointOverlay(PrimitiveCollector c, LytRect plotRect) { double dataX = activeAutoDataX; double dataY = activeAutoDataY; int color = activeAutoColor; @@ -953,20 +1032,20 @@ private void renderAutoPointOverlay(RenderContext context, LytRect plotRect) { if (sx < plotRect.x() || sx > plotRect.right() || sy < plotRect.y() || sy > plotRect.bottom()) { return; } - context.fillCircle(sx, sy, POINT_RADIUS + 2f, 0xFFFFFFFF); - context.drawCircleOutline(sx, sy, POINT_RADIUS + 2f, 1f, 0xFF000000); - context.fillCircle(sx, sy, POINT_RADIUS, color); + c.emit(new GuideRenderPrimitive.DrawCircle(sx, sy, POINT_RADIUS + 2f, 0xFFFFFFFF, true)); + c.emit(new GuideRenderPrimitive.DrawCircleOutline(sx, sy, POINT_RADIUS + 2f, 1f, 0xFF000000)); + c.emit(new GuideRenderPrimitive.DrawCircle(sx, sy, POINT_RADIUS, color, true)); FunctionPlot plot = plots.get(activeAutoPlotIndex); String line1 = !isEmpty(plot.getLabel()) ? plot.getLabel() : plot.getExpressionText(); String line2 = "(" + formatValue(dataX) + ", " + formatValue(dataY) + ")"; - renderTooltipBox(context, sx, sy, line1, line2); + renderTooltipBox(c, sx, sy, line1, line2); } - private void renderTooltipBox(RenderContext context, float sx, float sy, String line1, String line2) { - int lineH = context.getLineHeight(TOOLTIP_BODY_STYLE); + private void renderTooltipBox(PrimitiveCollector c, float sx, float sy, String line1, String line2) { + int lineH = GuideText.lineHeight(TOOLTIP_BODY_STYLE); int textWidth = Math - .max(context.getStringWidth(line1, TOOLTIP_TITLE_STYLE), context.getStringWidth(line2, TOOLTIP_BODY_STYLE)); + .max(GuideText.measureWidth(line1, TOOLTIP_TITLE_STYLE), GuideText.measureWidth(line2, TOOLTIP_BODY_STYLE)); int boxWidth = textWidth + TOOLTIP_PADDING_X * 2; int boxHeight = lineH * 2 + TOOLTIP_PADDING_Y * 2; int boxX = (int) sx - boxWidth / 2; @@ -977,54 +1056,17 @@ private void renderTooltipBox(RenderContext context, float sx, float sy, String boxX = Math.clamp(boxX, bounds.x() + 2, bounds.right() - boxWidth - 2); boxY = Math.clamp(boxY, bounds.y() + 2, bounds.bottom() - boxHeight - 2); - LytRect box = new LytRect(boxX, boxY, boxWidth, boxHeight); - context.fillRect(box, 0xEE202428); - context.drawBorder(box, 0xFF555555, 1); - context.drawText(line1, boxX + TOOLTIP_PADDING_X, boxY + TOOLTIP_PADDING_Y, TOOLTIP_TITLE_STYLE); - context.drawText(line2, boxX + TOOLTIP_PADDING_X, boxY + TOOLTIP_PADDING_Y + lineH, TOOLTIP_BODY_STYLE); + c.emit(new GuideRenderPrimitive.FillRect(boxX, boxY, boxWidth, boxHeight, 0xEE202428)); + c.emit(new GuideRenderPrimitive.DrawBorder(boxX, boxY, boxWidth, boxHeight, 1, 1, 1, 1, 0xFF555555)); + GuideText.emitText(c, line1, boxX + TOOLTIP_PADDING_X, boxY + TOOLTIP_PADDING_Y, TOOLTIP_TITLE_STYLE); + GuideText.emitText(c, line2, boxX + TOOLTIP_PADDING_X, boxY + TOOLTIP_PADDING_Y + lineH, TOOLTIP_BODY_STYLE); } /** * Measure the total height needed to lay out the legend below the plot, given the available * width. Returns {@code 0} when no plot has a label, suppressing the legend area entirely. */ - private int measureLegendHeight(RenderContext context, int availableWidth) { - if (availableWidth <= 0) { - return 0; - } - boolean any = false; - for (FunctionPlot plot : plots) { - if (plot.getLabel() != null && !plot.getLabel() - .isEmpty()) { - any = true; - break; - } - } - if (!any) { - return 0; - } - int rowHeight = Math.max(LEGEND_SWATCH_SIZE, context.getLineHeight(LEGEND_LABEL_STYLE)); - int rows = 1; - int rowWidth = 0; - for (FunctionPlot plot : plots) { - String label = plot.getLabel(); - if (label == null || label.isEmpty()) { - continue; - } - int itemWidth = LEGEND_SWATCH_SIZE + LEGEND_SWATCH_TEXT_GAP - + context.getStringWidth(label, LEGEND_LABEL_STYLE); - int needed = rowWidth == 0 ? itemWidth : rowWidth + LEGEND_ITEM_GAP + itemWidth; - if (rowWidth > 0 && needed > availableWidth) { - rows++; - rowWidth = itemWidth; - } else { - rowWidth = needed; - } - } - return rows * rowHeight + (rows - 1) * LEGEND_ROW_GAP; - } - - private int measureLegendHeight(LayoutContext context, int availableWidth) { + private int measureLegendHeight(int availableWidth) { if (availableWidth <= 0) { return 0; } @@ -1039,7 +1081,7 @@ private int measureLegendHeight(LayoutContext context, int availableWidth) { if (!any) { return 0; } - int rowHeight = Math.max(LEGEND_SWATCH_SIZE, context.getLineHeight(LEGEND_LABEL_STYLE)); + int rowHeight = Math.max(LEGEND_SWATCH_SIZE, GuideText.lineHeight(LEGEND_LABEL_STYLE)); int rows = 1; int rowWidth = 0; for (FunctionPlot plot : plots) { @@ -1048,7 +1090,7 @@ private int measureLegendHeight(LayoutContext context, int availableWidth) { continue; } int itemWidth = LEGEND_SWATCH_SIZE + LEGEND_SWATCH_TEXT_GAP - + measureTextWidth(context, LEGEND_LABEL_STYLE, label); + + GuideText.measureWidth(label, LEGEND_LABEL_STYLE); int needed = rowWidth == 0 ? itemWidth : rowWidth + LEGEND_ITEM_GAP + itemWidth; if (rowWidth > 0 && needed > availableWidth) { rows++; @@ -1060,28 +1102,15 @@ private int measureLegendHeight(LayoutContext context, int availableWidth) { return rows * rowHeight + (rows - 1) * LEGEND_ROW_GAP; } - private int measureTextWidth(LayoutContext context, ResolvedTextStyle style, String text) { - if (text == null || text.isEmpty()) { - return 0; - } - float width = 0f; - for (int offset = 0; offset < text.length();) { - int codePoint = text.codePointAt(offset); - width += context.getAdvance(codePoint, style); - offset += Character.charCount(codePoint); - } - return Math.round(width); - } - /** * Render the legend at {@code (left, top)}. Items flow left-to-right and wrap onto a new row * once the next item would exceed {@code availableWidth}. */ - private void renderLegend(RenderContext context, int left, int top, int availableWidth) { + private void renderLegend(PrimitiveCollector c, int left, int top, int availableWidth) { if (availableWidth <= 0) { return; } - int rowHeight = Math.max(LEGEND_SWATCH_SIZE, context.getLineHeight(LEGEND_LABEL_STYLE)); + int rowHeight = Math.max(LEGEND_SWATCH_SIZE, GuideText.lineHeight(LEGEND_LABEL_STYLE)); int x = left; int y = top; boolean firstInRow = true; @@ -1091,7 +1120,7 @@ private void renderLegend(RenderContext context, int left, int top, int availabl continue; } int itemWidth = LEGEND_SWATCH_SIZE + LEGEND_SWATCH_TEXT_GAP - + context.getStringWidth(label, LEGEND_LABEL_STYLE); + + GuideText.measureWidth(label, LEGEND_LABEL_STYLE); int needed = firstInRow ? itemWidth : (x - left) + LEGEND_ITEM_GAP + itemWidth; if (!firstInRow && needed > availableWidth) { y += rowHeight + LEGEND_ROW_GAP; @@ -1102,11 +1131,21 @@ private void renderLegend(RenderContext context, int left, int top, int availabl x += LEGEND_ITEM_GAP; } int swatchY = y + (rowHeight - LEGEND_SWATCH_SIZE) / 2; - LytRect swatch = new LytRect(x, swatchY, LEGEND_SWATCH_SIZE, LEGEND_SWATCH_SIZE); - context.fillRect(swatch, plot.getColor()); - context.drawBorder(swatch, 0xFF000000, 1); - int textY = y + (rowHeight - context.getLineHeight(LEGEND_LABEL_STYLE)) / 2; - context.drawText(label, x + LEGEND_SWATCH_SIZE + LEGEND_SWATCH_TEXT_GAP, textY, LEGEND_LABEL_STYLE); + c.emit( + new GuideRenderPrimitive.FillRect(x, swatchY, LEGEND_SWATCH_SIZE, LEGEND_SWATCH_SIZE, plot.getColor())); + c.emit( + new GuideRenderPrimitive.DrawBorder( + x, + swatchY, + LEGEND_SWATCH_SIZE, + LEGEND_SWATCH_SIZE, + 1, + 1, + 1, + 1, + 0xFF000000)); + int textY = y + (rowHeight - GuideText.lineHeight(LEGEND_LABEL_STYLE)) / 2; + GuideText.emitText(c, label, x + LEGEND_SWATCH_SIZE + LEGEND_SWATCH_TEXT_GAP, textY, LEGEND_LABEL_STYLE); x += itemWidth; firstInRow = false; } @@ -1361,7 +1400,8 @@ private static ResolvedTextStyle makeStyle(int argb, boolean bold) { TextAlignment.LEFT, false, null, - false); + false, + 0.0f); } @SuppressWarnings("unused") diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/recipes/LytGenericRecipeBox.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/recipes/LytGenericRecipeBox.java deleted file mode 100644 index 5878df27..00000000 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/recipes/LytGenericRecipeBox.java +++ /dev/null @@ -1,112 +0,0 @@ -package com.hfstudio.guidenh.guide.document.block.recipes; - -import java.util.ArrayList; -import java.util.List; - -import org.jetbrains.annotations.Nullable; - -import com.hfstudio.guidenh.guide.document.DefaultStyles; -import com.hfstudio.guidenh.guide.document.LytRect; -import com.hfstudio.guidenh.guide.document.block.LytBox; -import com.hfstudio.guidenh.guide.document.block.LytSlot; -import com.hfstudio.guidenh.guide.layout.LayoutContext; -import com.hfstudio.guidenh.guide.render.RenderContext; -import com.hfstudio.guidenh.integration.nei.NeiRecipeLookup; - -public class LytGenericRecipeBox extends LytBox { - - public static final int TITLE_HEIGHT = 10; - public static final int TITLE_COLOR = 0xFFAAAAAA; - public static final int SLOT_INSET = (LytSlot.OUTER_SIZE - 16) / 2; - - private final String title; - private final int normX; - private final int normY; - - public LytGenericRecipeBox(NeiRecipeLookup.Entry entry) { - this.title = entry.recipeName == null ? "" : entry.recipeName; - int mnx = Integer.MAX_VALUE; - int mny = Integer.MAX_VALUE; - for (NeiRecipeLookup.Slot s : collect(entry)) { - if (s.relx < mnx) mnx = s.relx; - if (s.rely < mny) mny = s.rely; - } - if (mnx == Integer.MAX_VALUE) { - mnx = 0; - mny = 0; - } - this.normX = mnx; - this.normY = mny; - - for (NeiRecipeLookup.Slot s : entry.ingredients) { - append(new PositionedSlot(s, false)); - } - for (NeiRecipeLookup.Slot s : entry.others) { - append(new PositionedSlot(s, false)); - } - if (entry.result != null) { - append(new PositionedSlot(entry.result, false)); - } - } - - public static List collect(NeiRecipeLookup.Entry entry) { - List all = new ArrayList<>(entry.ingredients.size() + entry.others.size() + 1); - all.addAll(entry.ingredients); - all.addAll(entry.others); - if (entry.result != null) all.add(entry.result); - return all; - } - - @Override - protected LytRect computeBoxLayout(LayoutContext context, int x, int y, int availableWidth) { - int maxX = x; - int maxY = y; - int topOffset = hasTitle() ? TITLE_HEIGHT : 0; - for (var child : children) { - PositionedSlot ps = (PositionedSlot) child; - int cellX = x + (ps.src.relx - normX) - SLOT_INSET; - int cellY = y + topOffset + (ps.src.rely - normY) - SLOT_INSET; - ps.layout(context, cellX, cellY, availableWidth); - int right = cellX + LytSlot.OUTER_SIZE; - int bottom = cellY + LytSlot.OUTER_SIZE; - if (right > maxX) maxX = right; - if (bottom > maxY) maxY = bottom; - } - int w = Math.max(maxX - x, 1); - int h = Math.max(maxY - y, topOffset); - return new LytRect(x, y, w, h); - } - - @Override - public void render(RenderContext context) { - if (hasTitle()) { - context.drawText(title, bounds.x(), bounds.y(), DefaultStyles.BASE_STYLE); - } - super.render(context); - } - - private boolean hasTitle() { - return title != null && !title.isEmpty(); - } - - public static class PositionedSlot extends LytSlot { - - private final NeiRecipeLookup.Slot src; - - public PositionedSlot(NeiRecipeLookup.Slot src, boolean large) { - super(src.stacks); - this.src = src; - if (large) setLargeSlot(true); - } - } - - public static @Nullable List forAll(List entries, int limit) { - if (entries == null || entries.isEmpty()) return null; - int cap = limit <= 0 ? entries.size() : Math.min(limit, entries.size()); - List out = new ArrayList<>(cap); - for (int i = 0; i < cap; i++) { - out.add(new LytGenericRecipeBox(entries.get(i))); - } - return out; - } -} diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/recipes/LytRecipeGalleryRow.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/recipes/LytRecipeGalleryRow.java new file mode 100644 index 00000000..0a714fdf --- /dev/null +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/recipes/LytRecipeGalleryRow.java @@ -0,0 +1,29 @@ +package com.hfstudio.guidenh.guide.document.block.recipes; + +import com.hfstudio.guidenh.guide.document.block.LytBlock; +import com.hfstudio.guidenh.guide.document.block.LytHBox; +import com.hfstudio.guidenh.guide.internal.recipe.LytNeiRecipeBox; + +/** + * A wrapping horizontal row that groups consecutive recipe boxes into a + * "gallery" so multiple recipes share a row when the available width allows. + * Created by {@code LytDocument}'s recipe-gallery grouping pass; also the + * marker type used to recognize (and extend) existing galleries. + */ +public class LytRecipeGalleryRow extends LytHBox { + + /** Matches {@code RecipeCompiler.MULTI_GAP} (kept local to avoid a compiler dependency). */ + public static final int GAP = 4; + + public LytRecipeGalleryRow() { + setWrap(true); + setGap(GAP); + // Full width so the flex row wraps at the document's content edge. + setFullWidth(true); + } + + /** Recipe box block types eligible for gallery grouping. */ + public static boolean isRecipeBox(LytBlock block) { + return block instanceof LytNeiRecipeBox || block instanceof LytStandardRecipeBox; + } +} diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/recipes/LytStandardRecipeBox.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/recipes/LytStandardRecipeBox.java index 7235d0b4..59552595 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/recipes/LytStandardRecipeBox.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/recipes/LytStandardRecipeBox.java @@ -11,6 +11,8 @@ import com.hfstudio.guidenh.guide.document.block.LytSlot; import com.hfstudio.guidenh.guide.document.block.LytSlotGrid; import com.hfstudio.guidenh.guide.layout.LayoutContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.render.RenderContext; import lombok.Getter; @@ -36,11 +38,27 @@ public LytStandardRecipeBox(LytSlotGrid inputs, ItemStack resultStack, boolean s this.inputs = inputs; this.output = new LytSlot(resultStack); this.output.setLargeSlot(true); + // Reserve the crafting-arrow gap as the output slot's own left margin, + // so the flex-row layout (Rust) leaves room for the arrow between the + // inputs grid and the output — declared by the block, not the compiler. + this.output.setMarginLeft(GAP * 2 + ARROW_W); this.shapeless = shapeless; append(inputs); append(output); } + private static int getGlTextureId(ResourceLocation res) { + try { + var tex = net.minecraft.client.Minecraft.getMinecraft() + .getTextureManager() + .getTexture(res); + return tex != null ? tex.getGlTextureId() : -1; + } catch (Throwable t) { + // Headless (unit tests) or texture unavailable: skip drawing. + return -1; + } + } + public static LytStandardRecipeBox shaped3x3(List stacks, ItemStack result) { var grid = new LytSlotGrid(3, 3); int n = Math.min(9, stacks == null ? 0 : stacks.size()); @@ -85,6 +103,32 @@ protected LytRect computeBoxLayout(LayoutContext context, int x, int y, int avai return new LytRect(x, y, totalW, totalH); } + @Override + public void computePrimitives(PrimitiveCollector c) { + super.computePrimitives(c); + + int inW = inputs.getWidth() * LytSlot.OUTER_SIZE; + int inH = inputs.getHeight() * LytSlot.OUTER_SIZE; + int arrowX = bounds.x() + inW + GAP; + int arrowY = bounds.y() + (inH - ARROW_H) / 2; + int texId = getGlTextureId(CRAFTING_TEXTURE); + if (texId >= 0) { + // Vanilla container GUI textures are 256x256 (same assumption as + // VanillaRenderContext.blitTexture). + c.emit( + new GuideRenderPrimitive.BlitTexture( + texId, + arrowX, + arrowY, + ARROW_W, + ARROW_H, + ARROW_U / 256f, + ARROW_V / 256f, + (ARROW_U + ARROW_W) / 256f, + (ARROW_V + ARROW_H) / 256f)); + } + } + @Override public void render(RenderContext context) { super.render(context); diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/AsymmetricShape.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/AsymmetricShape.java index 294afef9..b2b060c8 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/AsymmetricShape.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/AsymmetricShape.java @@ -1,12 +1,13 @@ package com.hfstudio.guidenh.guide.document.block.shapes; import com.hfstudio.guidenh.guide.document.LytRect; -import com.hfstudio.guidenh.guide.render.RenderContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; public class AsymmetricShape implements ShapeRenderer { @Override - public void render(RenderContext context, LytRect rect, int backgroundColor, int borderColor) { + public void emitPrimitives(PrimitiveCollector c, LytRect rect, int backgroundColor, int borderColor) { int x = rect.x(), y = rect.y(), w = rect.width(), h = rect.height(); int r = rect.right(), b = rect.bottom(), cy = y + h / 2; int inset = Math.max(2, h / 4); @@ -30,12 +31,12 @@ public void render(RenderContext context, LytRect rect, int backgroundColor, int shrunkYs[i] = ys[i]; } } - context.fillPolygon(xs, ys, borderColor); - context.fillPolygon(shrunkXs, shrunkYs, backgroundColor); + c.emit(new GuideRenderPrimitive.DrawPolygon(xs, ys, borderColor)); + c.emit(new GuideRenderPrimitive.DrawPolygon(shrunkXs, shrunkYs, backgroundColor)); } @Override - public LytRect contentBounds(LytRect nodeRect, int cw, int ch, int padX, int padY) { + public LytRect contentBounds(LytRect nodeRect, int cw, int ch, int padX, int padY, float zoom) { int w = nodeRect.width(); int h = nodeRect.height(); int cx = nodeRect.x() + w / 2; diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/BangShape.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/BangShape.java index cd86b0b5..1aafd3b5 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/BangShape.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/BangShape.java @@ -4,12 +4,12 @@ import java.util.List; import com.hfstudio.guidenh.guide.document.LytRect; -import com.hfstudio.guidenh.guide.render.RenderContext; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; public class BangShape implements ShapeRenderer { @Override - public void render(RenderContext context, LytRect rect, int backgroundColor, int borderColor) { + public void emitPrimitives(PrimitiveCollector c, LytRect rect, int backgroundColor, int borderColor) { int x = rect.x(), y = rect.y(), w = rect.width(), h = rect.height(); float[] raw = buildBangPolygon(w, h); int n = raw.length / 2; @@ -49,8 +49,8 @@ public void render(RenderContext context, LytRect rect, int backgroundColor, int } } - ShapeUtils.fillPolygonCentered(context, xs, ys, borderColor); - ShapeUtils.fillPolygonCentered(context, ixs, iys, backgroundColor); + ShapeUtils.emitPolygonCentered(c, xs, ys, borderColor); + ShapeUtils.emitPolygonCentered(c, ixs, iys, backgroundColor); } private static float[] buildBangPolygon(float w, float h) { @@ -93,7 +93,7 @@ private static float[] buildBangPolygon(float w, float h) { } @Override - public LytRect contentBounds(LytRect nodeRect, int cw, int ch, int padX, int padY) { + public LytRect contentBounds(LytRect nodeRect, int cw, int ch, int padX, int padY, float zoom) { int w = nodeRect.width(); int h = nodeRect.height(); int cx = nodeRect.x() + w / 2; diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/CircleShape.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/CircleShape.java index 74cce343..025525a0 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/CircleShape.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/CircleShape.java @@ -1,27 +1,28 @@ package com.hfstudio.guidenh.guide.document.block.shapes; import com.hfstudio.guidenh.guide.document.LytRect; -import com.hfstudio.guidenh.guide.render.RenderContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; public class CircleShape implements ShapeRenderer { @Override - public void render(RenderContext context, LytRect rect, int backgroundColor, int borderColor) { + public void emitPrimitives(PrimitiveCollector c, LytRect rect, int backgroundColor, int borderColor) { int cx = rect.x() + rect.width() / 2; int cy = rect.y() + rect.height() / 2; int r = Math.min(rect.width(), rect.height()) / 2; if (r > 0) { - context.fillCircle(cx, cy, r, borderColor); - context.fillCircle(cx, cy, Math.max(r - 1, 1), backgroundColor); + c.emit(new GuideRenderPrimitive.DrawCircle(cx, cy, r, borderColor, true)); + c.emit(new GuideRenderPrimitive.DrawCircle(cx, cy, Math.max(r - 1, 1), backgroundColor, true)); } } @Override - public LytRect contentBounds(LytRect nodeRect, int cw, int ch, int padX, int padY) { + public LytRect contentBounds(LytRect nodeRect, int cw, int ch, int padX, int padY, float zoom) { int cx = nodeRect.x() + nodeRect.width() / 2; int cy = nodeRect.y() + nodeRect.height() / 2; - int r = Math.min(nodeRect.width(), nodeRect.height()) / 2; - int insSide = (int) (r * Math.sqrt(2)); + double r = Math.min(nodeRect.width(), nodeRect.height()) / 2.0; + int insSide = (int) Math.ceil(r * Math.sqrt(2)); return new LytRect(cx - insSide / 2, cy - insSide / 2, insSide, insSide); } diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/CloudShape.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/CloudShape.java index db227c8e..fa85b0d8 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/CloudShape.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/CloudShape.java @@ -4,12 +4,12 @@ import java.util.List; import com.hfstudio.guidenh.guide.document.LytRect; -import com.hfstudio.guidenh.guide.render.RenderContext; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; public class CloudShape implements ShapeRenderer { @Override - public void render(RenderContext context, LytRect rect, int backgroundColor, int borderColor) { + public void emitPrimitives(PrimitiveCollector c, LytRect rect, int backgroundColor, int borderColor) { int x = rect.x(), y = rect.y(), w = rect.width(), h = rect.height(); float[] raw = buildCloudPolygon(w, h); int n = raw.length / 2; @@ -49,8 +49,8 @@ public void render(RenderContext context, LytRect rect, int backgroundColor, int } } - ShapeUtils.fillPolygonCentered(context, xs, ys, borderColor); - ShapeUtils.fillPolygonCentered(context, ixs, iys, backgroundColor); + ShapeUtils.emitPolygonCentered(c, xs, ys, borderColor); + ShapeUtils.emitPolygonCentered(c, ixs, iys, backgroundColor); } private static float[] buildCloudPolygon(float w, float h) { @@ -95,11 +95,14 @@ private static float[] buildCloudPolygon(float w, float h) { } @Override - public LytRect contentBounds(LytRect nodeRect, int cw, int ch, int padX, int padY) { + public LytRect contentBounds(LytRect nodeRect, int cw, int ch, int padX, int padY, float zoom) { int cx = nodeRect.x() + nodeRect.width() / 2; int cy = nodeRect.y() + nodeRect.height() / 2; - int r = Math.min(nodeRect.width(), nodeRect.height()) / 3; - int insSide = (int) (r * Math.sqrt(2)); + // Compute the inscribed-side inset in float and round UP so the + // content rect never shrinks below the scaled text width through + // truncation ((int) casts were losing ~1px on the zoomed path). + double r = Math.min(nodeRect.width(), nodeRect.height()) / 3.0; + int insSide = (int) Math.ceil(r * Math.sqrt(2)); int availW = Math.max(insSide - 2 * padX, 1); int availH = Math.max(insSide - 2 * padY, 1); int contentW = Math.min(availW, cw); diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/CylinderShape.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/CylinderShape.java index 76b7e5fd..fde7251f 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/CylinderShape.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/CylinderShape.java @@ -1,12 +1,13 @@ package com.hfstudio.guidenh.guide.document.block.shapes; import com.hfstudio.guidenh.guide.document.LytRect; -import com.hfstudio.guidenh.guide.render.RenderContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; public class CylinderShape implements ShapeRenderer { @Override - public void render(RenderContext context, LytRect rect, int backgroundColor, int borderColor) { + public void emitPrimitives(PrimitiveCollector c, LytRect rect, int backgroundColor, int borderColor) { int x = rect.x(), y = rect.y(), w = rect.width(), h = rect.height(); int cx = x + w / 2; int rx = w / 2; @@ -53,27 +54,24 @@ public void render(RenderContext context, LytRect rect, int backgroundColor, int } } - ShapeUtils.fillPolygonCentered(context, oxs, oys, borderColor); - ShapeUtils.fillPolygonCentered(context, ixs, iys, backgroundColor); + ShapeUtils.emitPolygonCentered(c, oxs, oys, borderColor); + ShapeUtils.emitPolygonCentered(c, ixs, iys, backgroundColor); - drawEllipseFrontArc(context, cx, bodyTop, rx, ry, borderColor); - } - - private static void drawEllipseFrontArc(RenderContext context, float cx, float cy, float rx, float ry, int color) { - int segments = 20; - for (int i = 0; i < segments; i++) { - double a1 = Math.PI * i / segments; - double a2 = Math.PI * (i + 1) / segments; + // Emit the 20 line segments for the ellipse front arc + int arcSegments = 20; + for (int i = 0; i < arcSegments; i++) { + double a1 = Math.PI * i / arcSegments; + double a2 = Math.PI * (i + 1) / arcSegments; float x1 = cx + (float) (Math.cos(a1) * rx); - float y1 = cy + (float) (Math.sin(a1) * ry); + float y1 = bodyTop + (float) (Math.sin(a1) * ry); float x2 = cx + (float) (Math.cos(a2) * rx); - float y2 = cy + (float) (Math.sin(a2) * ry); - context.drawLine(x1, y1, x2, y2, 1, color); + float y2 = bodyTop + (float) (Math.sin(a2) * ry); + c.emit(new GuideRenderPrimitive.DrawLine(x1, y1, x2, y2, 1, borderColor)); } } @Override - public LytRect contentBounds(LytRect nodeRect, int cw, int ch, int padX, int padY) { + public LytRect contentBounds(LytRect nodeRect, int cw, int ch, int padX, int padY, float zoom) { int rx = nodeRect.width() / 2; int ry = Math.max(1, rx / 3); int extraV = Math.max(2, ry / 3); diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/DiamondShape.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/DiamondShape.java index 5b861327..d9dca148 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/DiamondShape.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/DiamondShape.java @@ -1,12 +1,13 @@ package com.hfstudio.guidenh.guide.document.block.shapes; import com.hfstudio.guidenh.guide.document.LytRect; -import com.hfstudio.guidenh.guide.render.RenderContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; public class DiamondShape implements ShapeRenderer { @Override - public void render(RenderContext context, LytRect rect, int backgroundColor, int borderColor) { + public void emitPrimitives(PrimitiveCollector c, LytRect rect, int backgroundColor, int borderColor) { int cx = rect.x() + rect.width() / 2; int cy = rect.y() + rect.height() / 2; int r = rect.right(); @@ -18,12 +19,12 @@ public void render(RenderContext context, LytRect rect, int backgroundColor, int float[] shrunkXs = new float[4]; float[] shrunkYs = new float[4]; shrinkPoly(xs, ys, shrunkXs, shrunkYs, cx, cy); - context.fillPolygon(xs, ys, borderColor); - context.fillPolygon(shrunkXs, shrunkYs, backgroundColor); + c.emit(new GuideRenderPrimitive.DrawPolygon(xs, ys, borderColor)); + c.emit(new GuideRenderPrimitive.DrawPolygon(shrunkXs, shrunkYs, backgroundColor)); } @Override - public LytRect contentBounds(LytRect nodeRect, int cw, int ch, int padX, int padY) { + public LytRect contentBounds(LytRect nodeRect, int cw, int ch, int padX, int padY, float zoom) { int cx = nodeRect.x() + nodeRect.width() / 2; int cy = nodeRect.y() + nodeRect.height() / 2; int insW = nodeRect.width() / 2; diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/DoubleCircleShape.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/DoubleCircleShape.java index ee619874..841ce135 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/DoubleCircleShape.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/DoubleCircleShape.java @@ -1,32 +1,33 @@ package com.hfstudio.guidenh.guide.document.block.shapes; import com.hfstudio.guidenh.guide.document.LytRect; -import com.hfstudio.guidenh.guide.render.RenderContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; public class DoubleCircleShape implements ShapeRenderer { private static final int GAP = 5; @Override - public void render(RenderContext context, LytRect rect, int backgroundColor, int borderColor) { + public void emitPrimitives(PrimitiveCollector c, LytRect rect, int backgroundColor, int borderColor) { int cx = rect.x() + rect.width() / 2; int cy = rect.y() + rect.height() / 2; int outerR = Math.min(rect.width(), rect.height()) / 2; int innerR = Math.max(outerR - GAP, 1); if (outerR > 0) { - context.fillCircle(cx, cy, outerR, borderColor); - context.fillCircle(cx, cy, Math.max(outerR - 1, 1), backgroundColor); - context.fillCircle(cx, cy, innerR, borderColor); - context.fillCircle(cx, cy, Math.max(innerR - 1, 0), backgroundColor); + c.emit(new GuideRenderPrimitive.DrawCircle(cx, cy, outerR, borderColor, true)); + c.emit(new GuideRenderPrimitive.DrawCircle(cx, cy, Math.max(outerR - 1, 1), backgroundColor, true)); + c.emit(new GuideRenderPrimitive.DrawCircle(cx, cy, innerR, borderColor, true)); + c.emit(new GuideRenderPrimitive.DrawCircle(cx, cy, Math.max(innerR - 1, 0), backgroundColor, true)); } } @Override - public LytRect contentBounds(LytRect nodeRect, int cw, int ch, int padX, int padY) { + public LytRect contentBounds(LytRect nodeRect, int cw, int ch, int padX, int padY, float zoom) { int cx = nodeRect.x() + nodeRect.width() / 2; int cy = nodeRect.y() + nodeRect.height() / 2; - int r = Math.min(nodeRect.width(), nodeRect.height()) / 2; - int insSide = (int) (r * Math.sqrt(2)); + double r = Math.min(nodeRect.width(), nodeRect.height()) / 2.0; + int insSide = (int) Math.ceil(r * Math.sqrt(2)); return new LytRect(cx - insSide / 2, cy - insSide / 2, insSide, insSide); } diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/FlowchartShapes.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/FlowchartShapes.java index 33c7deb0..0aab2d04 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/FlowchartShapes.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/FlowchartShapes.java @@ -5,7 +5,7 @@ import com.hfstudio.guidenh.guide.document.LytRect; import com.hfstudio.guidenh.guide.internal.mermaid.MermaidNodeShape; -import com.hfstudio.guidenh.guide.render.RenderContext; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; public final class FlowchartShapes { @@ -31,17 +31,21 @@ public final class FlowchartShapes { private FlowchartShapes() {} - public static void render(RenderContext context, LytRect rect, MermaidNodeShape shape, int backgroundColor, + public static void emitShape(PrimitiveCollector c, MermaidNodeShape shape, LytRect rect, int backgroundColor, int borderColor) { ShapeRenderer renderer = RENDERERS.get(shape); if (renderer != null) { - renderer.render(context, rect, backgroundColor, borderColor); + renderer.emitPrimitives(c, rect, backgroundColor, borderColor); + } else { + RectShape fallback = new RectShape(); + fallback.emitPrimitives(c, rect, backgroundColor, borderColor); } } - public static LytRect contentBounds(LytRect nodeRect, MermaidNodeShape shape, int cw, int ch, int padX, int padY) { + public static LytRect contentBounds(LytRect nodeRect, MermaidNodeShape shape, int cw, int ch, int padX, int padY, + float zoom) { ShapeRenderer renderer = RENDERERS.get(shape); - return renderer != null ? renderer.contentBounds(nodeRect, cw, ch, padX, padY) : nodeRect; + return renderer != null ? renderer.contentBounds(nodeRect, cw, ch, padX, padY, zoom) : nodeRect; } public static LytRect minNodeRect(MermaidNodeShape shape, int cw, int ch, int padX, int padY) { diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/HexagonShape.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/HexagonShape.java index 722788ec..a7f03bb6 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/HexagonShape.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/HexagonShape.java @@ -1,12 +1,13 @@ package com.hfstudio.guidenh.guide.document.block.shapes; import com.hfstudio.guidenh.guide.document.LytRect; -import com.hfstudio.guidenh.guide.render.RenderContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; public class HexagonShape implements ShapeRenderer { @Override - public void render(RenderContext context, LytRect rect, int backgroundColor, int borderColor) { + public void emitPrimitives(PrimitiveCollector c, LytRect rect, int backgroundColor, int borderColor) { int x = rect.x(), y = rect.y(), w = rect.width(), h = rect.height(); int r = rect.right(), b = rect.bottom(), cy = y + h / 2; int inset = Math.max(1, h / 4); @@ -30,12 +31,12 @@ public void render(RenderContext context, LytRect rect, int backgroundColor, int shrunkYs[i] = ys[i]; } } - context.fillPolygon(xs, ys, borderColor); - context.fillPolygon(shrunkXs, shrunkYs, backgroundColor); + c.emit(new GuideRenderPrimitive.DrawPolygon(xs, ys, borderColor)); + c.emit(new GuideRenderPrimitive.DrawPolygon(shrunkXs, shrunkYs, backgroundColor)); } @Override - public LytRect contentBounds(LytRect nodeRect, int cw, int ch, int padX, int padY) { + public LytRect contentBounds(LytRect nodeRect, int cw, int ch, int padX, int padY, float zoom) { int w = nodeRect.width(); int h = nodeRect.height(); int cx = nodeRect.x() + w / 2; diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/RectShape.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/RectShape.java index 201ce7e8..3c56a7c0 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/RectShape.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/RectShape.java @@ -1,18 +1,29 @@ package com.hfstudio.guidenh.guide.document.block.shapes; import com.hfstudio.guidenh.guide.document.LytRect; -import com.hfstudio.guidenh.guide.render.RenderContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; public class RectShape implements ShapeRenderer { @Override - public void render(RenderContext context, LytRect rect, int backgroundColor, int borderColor) { - context.fillRect(rect, backgroundColor); - context.drawBorder(rect, borderColor, 1); + public void emitPrimitives(PrimitiveCollector c, LytRect rect, int backgroundColor, int borderColor) { + c.emit(new GuideRenderPrimitive.FillRect(rect.x(), rect.y(), rect.width(), rect.height(), backgroundColor)); + c.emit( + new GuideRenderPrimitive.DrawBorder( + rect.x(), + rect.y(), + rect.width(), + rect.height(), + 1, + 1, + 1, + 1, + borderColor)); } @Override - public LytRect contentBounds(LytRect nodeRect, int cw, int ch, int padX, int padY) { + public LytRect contentBounds(LytRect nodeRect, int cw, int ch, int padX, int padY, float zoom) { return nodeRect.shrink(padX, padY, padX, padY); } diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/RoundedRectShape.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/RoundedRectShape.java index 8295984d..c350c3d7 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/RoundedRectShape.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/RoundedRectShape.java @@ -1,33 +1,34 @@ package com.hfstudio.guidenh.guide.document.block.shapes; import com.hfstudio.guidenh.guide.document.LytRect; -import com.hfstudio.guidenh.guide.render.RenderContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; public class RoundedRectShape implements ShapeRenderer { @Override - public void render(RenderContext context, LytRect rect, int backgroundColor, int borderColor) { + public void emitPrimitives(PrimitiveCollector c, LytRect rect, int backgroundColor, int borderColor) { int x = rect.x(), y = rect.y(), w = rect.width(), h = rect.height(); int r = Math.clamp(Math.min(w, h) / 5, 2, 12); - context.fillRect(rect, borderColor); - context.fillCircle(x + r, y + r, r, borderColor); - context.fillCircle(x + w - r, y + r, r, borderColor); - context.fillCircle(x + r, y + h - r, r, borderColor); - context.fillCircle(x + w - r, y + h - r, r, borderColor); + c.emit(new GuideRenderPrimitive.FillRect(x, y, w, h, borderColor)); + c.emit(new GuideRenderPrimitive.DrawCircle(x + r, y + r, r, borderColor, true)); + c.emit(new GuideRenderPrimitive.DrawCircle(x + w - r, y + r, r, borderColor, true)); + c.emit(new GuideRenderPrimitive.DrawCircle(x + r, y + h - r, r, borderColor, true)); + c.emit(new GuideRenderPrimitive.DrawCircle(x + w - r, y + h - r, r, borderColor, true)); int inset = 1; int ir = Math.max(r - inset, 1); int ix = x + inset, iy = y + inset, iw = w - inset * 2, ih = h - inset * 2; - context.fillRect(ix, iy, iw, ih, backgroundColor); - context.fillCircle(ix + ir, iy + ir, ir, backgroundColor); - context.fillCircle(ix + iw - ir, iy + ir, ir, backgroundColor); - context.fillCircle(ix + ir, iy + ih - ir, ir, backgroundColor); - context.fillCircle(ix + iw - ir, iy + ih - ir, ir, backgroundColor); + c.emit(new GuideRenderPrimitive.FillRect(ix, iy, iw, ih, backgroundColor)); + c.emit(new GuideRenderPrimitive.DrawCircle(ix + ir, iy + ir, ir, backgroundColor, true)); + c.emit(new GuideRenderPrimitive.DrawCircle(ix + iw - ir, iy + ir, ir, backgroundColor, true)); + c.emit(new GuideRenderPrimitive.DrawCircle(ix + ir, iy + ih - ir, ir, backgroundColor, true)); + c.emit(new GuideRenderPrimitive.DrawCircle(ix + iw - ir, iy + ih - ir, ir, backgroundColor, true)); } @Override - public LytRect contentBounds(LytRect nodeRect, int cw, int ch, int padX, int padY) { + public LytRect contentBounds(LytRect nodeRect, int cw, int ch, int padX, int padY, float zoom) { return nodeRect.shrink(padX, padY, padX, padY); } diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/ShapeRenderer.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/ShapeRenderer.java index 7637b958..81a94771 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/ShapeRenderer.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/ShapeRenderer.java @@ -1,13 +1,23 @@ package com.hfstudio.guidenh.guide.document.block.shapes; import com.hfstudio.guidenh.guide.document.LytRect; -import com.hfstudio.guidenh.guide.render.RenderContext; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; public interface ShapeRenderer { - void render(RenderContext context, LytRect rect, int backgroundColor, int borderColor); + /** Emit primitives for this shape into the collector. */ + void emitPrimitives(PrimitiveCollector c, LytRect rect, int backgroundColor, int borderColor); - LytRect contentBounds(LytRect nodeRect, int contentW, int contentH, int padX, int padY); + /** + * Compute the content rect (text/badge area) inside a rendered node rect. + * {@code nodeRect} is in the scaled render coordinate space (already + * multiplied by the active zoom); {@code zoom} lets shapes that consume + * fixed logical insets (subprocess frame, circular insets) scale those + * insets consistently, so the content rect stays self-consistent with + * the scaled text width at any zoom (otherwise the content area shrinks + * faster than the text and spurious word-wrap / overflow appears). + */ + LytRect contentBounds(LytRect nodeRect, int contentW, int contentH, int padX, int padY, float zoom); LytRect minNodeRect(int contentW, int contentH, int padX, int padY); } diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/ShapeUtils.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/ShapeUtils.java index 6c7c2fc7..05b42f0a 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/ShapeUtils.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/ShapeUtils.java @@ -3,18 +3,15 @@ import java.util.ArrayList; import java.util.List; -import com.hfstudio.guidenh.guide.render.RenderContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; final class ShapeUtils { private ShapeUtils() {} - /** - * Fills a polygon using a triangle fan from the centroid. - * This avoids artifacts from using a boundary vertex as the fan origin - * (which happens with plain {@link RenderContext#fillPolygon(float[], float[], int)}). - */ - static void fillPolygonCentered(RenderContext context, float[] xs, float[] ys, int color) { + /** Same as fillPolygonCentered but emits a DrawPolygon primitive. */ + static void emitPolygonCentered(PrimitiveCollector c, float[] xs, float[] ys, int color) { int n = xs.length; if (n < 3) return; float cx = 0, cy = 0; @@ -32,7 +29,7 @@ static void fillPolygonCentered(RenderContext context, float[] xs, float[] ys, i System.arraycopy(ys, 0, fanYs, 1, n); fanXs[n + 1] = xs[0]; fanYs[n + 1] = ys[0]; - context.fillPolygon(fanXs, fanYs, color); + c.emit(new GuideRenderPrimitive.DrawPolygon(fanXs, fanYs, color)); } static List arcToPoints(float cx, float cy, float rx, float ry, float startAngle, float endAngle, diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/StadiumShape.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/StadiumShape.java index 4b483588..9d10208c 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/StadiumShape.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/StadiumShape.java @@ -1,28 +1,29 @@ package com.hfstudio.guidenh.guide.document.block.shapes; import com.hfstudio.guidenh.guide.document.LytRect; -import com.hfstudio.guidenh.guide.render.RenderContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; public class StadiumShape implements ShapeRenderer { @Override - public void render(RenderContext context, LytRect rect, int backgroundColor, int borderColor) { + public void emitPrimitives(PrimitiveCollector c, LytRect rect, int backgroundColor, int borderColor) { int x = rect.x(), y = rect.y(), w = rect.width(), h = rect.height(); int r = h / 2; float cy = y + h / 2f; - context.fillRect(x + r, y, w - r * 2, h, borderColor); - context.fillCircle(x + r, cy, r, borderColor); - context.fillCircle(x + w - r, cy, r, borderColor); + c.emit(new GuideRenderPrimitive.FillRect(x + r, y, w - r * 2, h, borderColor)); + c.emit(new GuideRenderPrimitive.DrawCircle(x + r, cy, r, borderColor, true)); + c.emit(new GuideRenderPrimitive.DrawCircle(x + w - r, cy, r, borderColor, true)); int ir = Math.max(r - 1, 0); - context.fillRect(x + r, y + 1, w - r * 2, h - 2, backgroundColor); - context.fillCircle(x + r, cy, ir, backgroundColor); - context.fillCircle(x + w - r, cy, ir, backgroundColor); + c.emit(new GuideRenderPrimitive.FillRect(x + r, y + 1, w - r * 2, h - 2, backgroundColor)); + c.emit(new GuideRenderPrimitive.DrawCircle(x + r, cy, ir, backgroundColor, true)); + c.emit(new GuideRenderPrimitive.DrawCircle(x + w - r, cy, ir, backgroundColor, true)); } @Override - public LytRect contentBounds(LytRect nodeRect, int cw, int ch, int padX, int padY) { + public LytRect contentBounds(LytRect nodeRect, int cw, int ch, int padX, int padY, float zoom) { return nodeRect.shrink(padX, padY, padX, padY); } diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/SubprocessShape.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/SubprocessShape.java index 4e16e043..e55968d9 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/SubprocessShape.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/SubprocessShape.java @@ -1,29 +1,35 @@ package com.hfstudio.guidenh.guide.document.block.shapes; import com.hfstudio.guidenh.guide.document.LytRect; -import com.hfstudio.guidenh.guide.render.RenderContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; public class SubprocessShape implements ShapeRenderer { private static final int FRAME_WIDTH = 8; @Override - public void render(RenderContext context, LytRect rect, int backgroundColor, int borderColor) { + public void emitPrimitives(PrimitiveCollector c, LytRect rect, int backgroundColor, int borderColor) { int x = rect.x(), y = rect.y(), w = rect.width(), h = rect.height(); int innerX = x + FRAME_WIDTH; int innerW = w - FRAME_WIDTH * 2; - context.fillRect(x, y, w, h, borderColor); - context.fillRect(innerX, y, innerW, h, backgroundColor); - - context.drawLine(innerX, y, innerX, y + h, 1, borderColor); - context.drawLine(innerX + innerW, y, innerX + innerW, y + h, 1, borderColor); + c.emit(new GuideRenderPrimitive.FillRect(x, y, w, h, borderColor)); + c.emit(new GuideRenderPrimitive.FillRect(innerX, y, innerW, h, backgroundColor)); + c.emit(new GuideRenderPrimitive.DrawLine(innerX, y, innerX, y + h, 1, borderColor)); + c.emit(new GuideRenderPrimitive.DrawLine(innerX + innerW, y, innerX + innerW, y + h, 1, borderColor)); } @Override - public LytRect contentBounds(LytRect nodeRect, int cw, int ch, int padX, int padY) { - int innerX = nodeRect.x() + FRAME_WIDTH; - int innerW = nodeRect.width() - FRAME_WIDTH * 2; + public LytRect contentBounds(LytRect nodeRect, int cw, int ch, int padX, int padY, float zoom) { + // The frame inset must scale with zoom: the node rect is already in + // scaled render space, so an unscaled FRAME_WIDTH would carve a fixed + // logical-8px frame out of a scaled rect and shrink the content area + // faster than the (scaled) text, forcing spurious word-wrap/overflow + // on the zoomed path. + int frame = Math.max(1, Math.round(FRAME_WIDTH * zoom)); + int innerX = nodeRect.x() + frame; + int innerW = nodeRect.width() - frame * 2; return new LytRect(innerX + padX, nodeRect.y() + padY, innerW - 2 * padX, nodeRect.height() - 2 * padY); } diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/TrapezoidShape.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/TrapezoidShape.java index 45e60ac6..7612f18f 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/TrapezoidShape.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/shapes/TrapezoidShape.java @@ -1,12 +1,13 @@ package com.hfstudio.guidenh.guide.document.block.shapes; import com.hfstudio.guidenh.guide.document.LytRect; -import com.hfstudio.guidenh.guide.render.RenderContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; public class TrapezoidShape implements ShapeRenderer { @Override - public void render(RenderContext context, LytRect rect, int backgroundColor, int borderColor) { + public void emitPrimitives(PrimitiveCollector c, LytRect rect, int backgroundColor, int borderColor) { int x = rect.x(), y = rect.y(), w = rect.width(), h = rect.height(); int r = rect.right(), b = rect.bottom(); int inset = Math.max(1, h / 4); @@ -30,12 +31,12 @@ public void render(RenderContext context, LytRect rect, int backgroundColor, int shrunkYs[i] = ys[i]; } } - context.fillPolygon(xs, ys, borderColor); - context.fillPolygon(shrunkXs, shrunkYs, backgroundColor); + c.emit(new GuideRenderPrimitive.DrawPolygon(xs, ys, borderColor)); + c.emit(new GuideRenderPrimitive.DrawPolygon(shrunkXs, shrunkYs, backgroundColor)); } @Override - public LytRect contentBounds(LytRect nodeRect, int cw, int ch, int padX, int padY) { + public LytRect contentBounds(LytRect nodeRect, int cw, int ch, int padX, int padY, float zoom) { int w = nodeRect.width(); int h = nodeRect.height(); int cx = nodeRect.x() + w / 2; diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/table/LytTable.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/table/LytTable.java index 3ffc890d..c4ace22b 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/table/LytTable.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/table/LytTable.java @@ -7,6 +7,8 @@ import com.hfstudio.guidenh.guide.document.LytRect; import com.hfstudio.guidenh.guide.document.block.LytBlock; import com.hfstudio.guidenh.guide.layout.LayoutContext; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.render.RenderContext; import lombok.Getter; @@ -17,6 +19,13 @@ public class LytTable extends LytBlock { * Width of border around cells. */ public static final int CELL_BORDER = 1; + + /** + * Thickness of the horizontal separator drawn below the header row. + * Deliberately thicker than the 1px data-row separators so the header row + * is visually distinct. + */ + public static final int HEADER_SEPARATOR_THICKNESS = 2; private final List rows = new ArrayList<>(); @Getter @@ -30,18 +39,11 @@ protected LytRect computeLayout(LayoutContext context, int x, int y, int availab layoutColumns(x, availableWidth); - // Layout each row + // Layout each row (rows lay out their own cells against the column model) var currentY = y + CELL_BORDER; for (var row : rows) { - var rowTop = currentY; - var rowBottom = currentY; - for (var cell : row.getChildren()) { - var column = cell.column; - var cellBounds = cell.layout(context, column.x, currentY, column.width); - rowBottom = Math.max(rowBottom, cellBounds.bottom()); - } - row.bounds = new LytRect(x, rowTop, availableWidth, rowBottom - rowTop); - currentY = rowBottom + CELL_BORDER; + var rowBounds = row.layout(context, x, currentY, availableWidth); + currentY = rowBounds.bottom() + CELL_BORDER; } return new LytRect(x, y, availableWidth, currentY - y); @@ -53,37 +55,133 @@ protected void onLayoutMoved(int deltaX, int deltaY) { col.x += deltaX; } for (var row : rows) { - row.bounds = row.bounds.move(deltaX, deltaY); - for (var cell : row.getChildren()) { - cell.moveLayoutPos(deltaX, deltaY); - } + row.moveLayoutPos(deltaX, deltaY); + } + } + + @Override + public boolean usePrimitives() { + return true; + } + + @Override + public void computePrimitives(PrimitiveCollector c) { + var bounds = getBounds(); + // Column border lines (vertical lines between columns). X comes from the + // Rust-written cell bounds of the row with the most cells (F3 — Java + // must not compute geometry). column.x/column.width are x=0 + // serialization-time declarations and must not drive drawing. + var sourceRow = widestRow(); + for (int i = 0; i < columns.size() - 1; i++) { + c.emit( + new GuideRenderPrimitive.FillRect( + columnSeparatorX(sourceRow, i), + bounds.y(), + 1, + bounds.height(), + SymbolicColor.TABLE_BORDER.resolve(com.hfstudio.guidenh.guide.color.LightDarkMode.current()))); + } + // Row border lines (horizontal lines between rows) + for (int i = 0; i < rows.size() - 1; i++) { + var row = rows.get(i); + c.emit( + new GuideRenderPrimitive.FillRect( + bounds.x(), + row.getBounds() + .bottom(), + bounds.width(), + row.isHeader() ? HEADER_SEPARATOR_THICKNESS : 1, + SymbolicColor.TABLE_BORDER.resolve(com.hfstudio.guidenh.guide.color.LightDarkMode.current()))); } + // Cells are children — collectFrom traversal handles them } @Override public void render(RenderContext context) { // Render the table cell borders var bounds = getBounds(); + var sourceRow = widestRow(); for (int i = 0; i < columns.size() - 1; i++) { - var column = columns.get(i); - var colRight = column.x + column.width; - context.fillRect(colRight, bounds.y(), 1, bounds.height(), SymbolicColor.TABLE_BORDER); + context.fillRect(columnSeparatorX(sourceRow, i), bounds.y(), 1, bounds.height(), SymbolicColor.TABLE_BORDER); } for (int i = 0; i < rows.size() - 1; i++) { var row = rows.get(i); - context.fillRect(bounds.x(), row.bounds.bottom(), bounds.width(), 1, SymbolicColor.TABLE_BORDER); + context.fillRect( + bounds.x(), + row.getBounds() + .bottom(), + bounds.width(), + row.isHeader() ? HEADER_SEPARATOR_THICKNESS : 1, + SymbolicColor.TABLE_BORDER); } for (var row : rows) { - for (var cell : row.getChildren()) { - cell.render(context); + row.render(context); + } + } + + /** + * The row with the most cells (first row wins ties). Its Rust-written cell + * bounds are the source for vertical separator positions — all rows share + * the table's column x-structure, so one row's cell boundaries stand in + * for every row. {@code null} when the table has no rows (then no + * vertical separators can be derived; column model is the fallback). + */ + private LytTableRow widestRow() { + LytTableRow widest = null; + for (var row : rows) { + if (widest == null || row.getChildren().size() > widest.getChildren().size()) { + widest = row; + } + } + return widest; + } + + /** + * Document-space x of the vertical separator between column {@code i} and + * {@code i + 1}, derived from the Rust-written cell bounds of + * {@code sourceRow} (F3 — the line positions must come from Rust layout + * data, never from Java-computed column geometry). + *

+ * Primary reference: {@code cell[i].getBounds().right()} — the left edge of + * the 1px CELL_BORDER gutter between adjacent cells. This mirrors the + * horizontal separators, which are drawn at {@code row.getBounds().bottom()} + * (the top edge of the row gutter), so vertical and horizontal lines meet at + * the cell corners. The alternative {@code cell[i+1].getBounds().x()} is the + * gutter's right edge — exactly 1px right of {@code right()} while the gutter + * is CELL_BORDER wide — and their integer midpoint degenerates to the left + * edge, so {@code right()} is the stable choice. When cell {@code i}'s + * bounds are missing, the boundary is recovered from the right neighbour's + * {@code cell[i+1].x() - CELL_BORDER}. + *

+ * Fallback: when the widest row has no usable Rust bounds for this boundary + * (no rows, fewer cells than columns, or bounds not written back), the + * legacy column-model position {@code column.x + column.width} is used. This + * only guards degenerate / pre-layout paths — after a Rust layout pass every + * flat node (cells included) receives a written-back rect. + */ + private int columnSeparatorX(LytTableRow sourceRow, int i) { + if (sourceRow != null && i + 1 < sourceRow.getChildren().size()) { + var cells = sourceRow.getChildren(); + LytRect left = cells.get(i).getBounds(); + LytRect right = cells.get(i + 1).getBounds(); + if (!left.isEmpty()) { + return left.right(); + } + if (!right.isEmpty()) { + return right.x() - CELL_BORDER; } } + return columns.get(i).x + columns.get(i).width; } public LytTableRow appendRow() { var row = new LytTableRow(this); + if (rows.isEmpty()) { + row.setMarginTop(CELL_BORDER); + } + row.setMarginBottom(CELL_BORDER); rows.add(row); return row; } @@ -95,7 +193,13 @@ public LytTableColumn getOrCreateColumn(int index) { return columns.get(index); } - private void layoutColumns(int x, int availableWidth) { + /** + * Distribute available width among columns. Called by the serializer + * (no longer by the Java pre-pass) so column widths are set before + * serialization. {@code x} is the table's left edge in document coords. + */ + public void layoutColumns(int x, int availableWidth) { + if (columns.isEmpty()) return; int innerWidth = Math.max(0, availableWidth - (columns.size() + 1) * CELL_BORDER); int totalPreferredWidth = 0; int flexibleColumns = 0; @@ -119,9 +223,16 @@ private void layoutColumns(int x, int availableWidth) { colX += column.width + CELL_BORDER; } - if (assignedWidth < innerWidth) { + // Only distribute remainder to flexible (undeclared) columns. + // When all columns have declared widths, the table stays at the + // sum of declared widths (natural width) — the last column must + // NOT absorb the leftover space (R4-4 fix). + if (flexibleColumns > 0 && assignedWidth < innerWidth) { + int leftover = innerWidth - assignedWidth; var lastCol = columns.getLast(); - lastCol.width += innerWidth - assignedWidth; + if (lastCol.preferredWidth == 0) { + lastCol.width += leftover; + } } return; } diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/table/LytTableColumn.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/table/LytTableColumn.java index 12c21a49..ecc12983 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/table/LytTableColumn.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/table/LytTableColumn.java @@ -4,7 +4,9 @@ public class LytTableColumn { + @Getter int x; + @Getter int width; @Getter int preferredWidth; diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/block/table/LytTableRow.java b/src/main/java/com/hfstudio/guidenh/guide/document/block/table/LytTableRow.java index c8771376..e3e260cf 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/block/table/LytTableRow.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/block/table/LytTableRow.java @@ -4,33 +4,87 @@ import java.util.List; import com.hfstudio.guidenh.guide.document.LytRect; +import com.hfstudio.guidenh.guide.document.block.LytBlock; import com.hfstudio.guidenh.guide.document.block.LytNode; +import com.hfstudio.guidenh.guide.layout.LayoutContext; +import com.hfstudio.guidenh.guide.render.RenderContext; + +import lombok.Getter; +import lombok.Setter; /** * A row in {@link LytTable}. Contains {@link LytTableCell}. + *

+ * A real block (not an eliminated wrapper): the Rust layout lays rows out as + * flex Row containers — row height follows the tallest cell's content, so + * wrapped text can no longer overflow a Java-pinned height. */ -public class LytTableRow extends LytNode { +public class LytTableRow extends LytBlock { private final LytTable table; private final List cells = new ArrayList<>(); - LytRect bounds = LytRect.empty(); + + /** + * Whether this row is the table's header row. Set by the table compilers + * (GFM markdown tables treat the first row as the header). The table + * renderer draws a thicker separator below it to visually distinguish the + * header from data rows. + */ + @Getter + @Setter + private boolean header; public LytTableRow(LytTable table) { this.table = table; this.parent = table; } - @Override - public LytRect getBounds() { - return bounds; - } - public LytTableCell appendCell() { var cell = new LytTableCell(table, this, table.getOrCreateColumn(cells.size())); + cell.setMarginLeft(LytTable.CELL_BORDER); + if (!cells.isEmpty()) { + // The closing 1px border moves to the new last cell. + cells.getLast() + .setMarginRight(0); + } + cell.setMarginRight(LytTable.CELL_BORDER); cells.add(cell); return cell; } + @Override + public boolean usePrimitives() { + // Rows have no visuals of their own (borders are the table's); the + // collector descends to the cells. Without this the whole row would + // fall back to a legacy HostDraw subtree. + return true; + } + + @Override + protected LytRect computeLayout(LayoutContext context, int x, int y, int availableWidth) { + var rowBottom = y; + for (var cell : cells) { + var column = cell.column; + var cellBounds = cell.layout(context, column.x, y, column.width); + rowBottom = Math.max(rowBottom, cellBounds.bottom()); + } + return new LytRect(x, y, availableWidth, rowBottom - y); + } + + @Override + protected void onLayoutMoved(int deltaX, int deltaY) { + for (var cell : cells) { + cell.moveLayoutPos(deltaX, deltaY); + } + } + + @Override + public void render(RenderContext context) { + for (var cell : cells) { + cell.render(context); + } + } + @Override public List getChildren() { return cells; diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/flow/LytFlowInlineBlock.java b/src/main/java/com/hfstudio/guidenh/guide/document/flow/LytFlowInlineBlock.java index 12117251..c62816e1 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/flow/LytFlowInlineBlock.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/flow/LytFlowInlineBlock.java @@ -11,7 +11,6 @@ import com.hfstudio.guidenh.guide.document.interaction.GuideTooltip; import com.hfstudio.guidenh.guide.document.interaction.InteractiveElement; import com.hfstudio.guidenh.guide.layout.LayoutContext; -import com.hfstudio.guidenh.guide.layout.MinecraftFontMetrics; import com.hfstudio.guidenh.guide.ui.GuideUiHost; import lombok.Getter; @@ -21,29 +20,21 @@ @Setter public class LytFlowInlineBlock extends LytFlowContent implements InteractiveElement { - private static final ThreadLocal MEASURE_LAYOUT_CONTEXT = ThreadLocal - .withInitial(() -> new LayoutContext(new MinecraftFontMetrics())); - private LytBlock block; private InlineBlockAlignment alignment = InlineBlockAlignment.INLINE; - public LytSize getPreferredSize(int lineWidth) { - return measurePreferredBounds(lineWidth).size(); - } - - public LytRect getPreferredBounds(int lineWidth) { - return measurePreferredBounds(lineWidth); + public LytSize getPreferredSize(LayoutContext context, int lineWidth) { + return getPreferredBounds(context, lineWidth).size(); } - private LytRect measurePreferredBounds(int lineWidth) { + public LytRect getPreferredBounds(LayoutContext context, int lineWidth) { if (block == null) { return LytRect.empty(); } - - var layoutContext = MEASURE_LAYOUT_CONTEXT.get() - .resetTransientState(); - return block.layout(layoutContext, 0, 0, lineWidth); + // Measure with the ambient layout context (same font metrics as the + // rest of the pass — and headless-safe in tests). + return block.layout(context, 0, 0, lineWidth); } @Override diff --git a/src/main/java/com/hfstudio/guidenh/guide/document/flow/LytFlowLink.java b/src/main/java/com/hfstudio/guidenh/guide/document/flow/LytFlowLink.java index b637b9f6..bd5fe1de 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/document/flow/LytFlowLink.java +++ b/src/main/java/com/hfstudio/guidenh/guide/document/flow/LytFlowLink.java @@ -30,7 +30,7 @@ public class LytFlowLink extends LytTooltipSpan { private boolean playedCustomClickSound; public LytFlowLink() { - modifyStyle(style -> style.color(SymbolicColor.LINK)); + modifyStyle(style -> style.color(SymbolicColor.LINK).underlined(true)); modifyHoverStyle(style -> style.underlined(true)); } diff --git a/src/main/java/com/hfstudio/guidenh/guide/internal/GuideLightweightReloadService.java b/src/main/java/com/hfstudio/guidenh/guide/internal/GuideLightweightReloadService.java index c931a328..761b8464 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/internal/GuideLightweightReloadService.java +++ b/src/main/java/com/hfstudio/guidenh/guide/internal/GuideLightweightReloadService.java @@ -47,8 +47,6 @@ public static void reloadDevelopmentGuides() { } public static void reloadGuides(IResourceManager resourceManager) { - GuideDebugLog.info("[GuideNH] [GuideLightweightReloadService] Reloading guide data..."); - long startedAt = System.nanoTime(); var activeResourcePacks = DataDrivenGuideLoader.getActiveResourcePacks(resourceManager); DataDrivenGuideLoader.clearCaches(); RecipeCache.clear(); @@ -65,23 +63,15 @@ public static void reloadGuides(IResourceManager resourceManager) { ClientProxy.getLytHost() .clearPageCaches(); - long stageStartedAt = System.nanoTime(); - GuideRegistry.setDataDriven(DataDrivenGuideLoader.load(activeResourcePacks)); + DataDrivenGuideLoader.ScanResult scan = DataDrivenGuideLoader + .scanAndBuildAll(DataDrivenGuideLoader.AUTO_GUIDE_FOLDER, activeResourcePacks); + GuideRegistry.setDataDriven(scan.guides()); MediaWikiTranslationStats.invalidateCache(); - long dataDrivenLoadNs = System.nanoTime() - stageStartedAt; var guidePages = new HashMap>(); - var pagePathCache = new LinkedHashMap>>(); String language = LangUtil.getCurrentLanguage(); - GuideDebugLog.warnAlways( - "[GuideNH] [GuideLightweightReloadService] reloadGuides currentLanguage='{}' (raw gameSettings.language='{}')", - language, - Minecraft.getMinecraft() != null && Minecraft.getMinecraft().gameSettings != null - ? Minecraft.getMinecraft().gameSettings.language - : "null"); - stageStartedAt = System.nanoTime(); for (var guide : GuideRegistry.getAll()) { var pages = loadPages( resourceManager, @@ -89,18 +79,15 @@ public static void reloadGuides(IResourceManager resourceManager) { guide.getContentRootFolder(), guide.getDefaultLanguage(), language, - pagePathCache, + scan.pagePaths(), activeResourcePacks); guidePages.put(guide.getId(), pages); } - long pageLoadNs = System.nanoTime() - stageStartedAt; - stageStartedAt = System.nanoTime(); for (var entry : guidePages.entrySet()) { GuideRegistry.updatePages(entry.getKey(), entry.getValue(), false); } GuideRegistry.invalidateMergedNavigationTree(); - // Trigger background compilation of all loaded pages CompileWorker worker = ClientProxy.getWorker(); var allPageIds = new ArrayList(); for (var pages : guidePages.values()) { @@ -109,9 +96,7 @@ public static void reloadGuides(IResourceManager resourceManager) { if (!allPageIds.isEmpty()) { worker.reset(allPageIds); } - long registryUpdateNs = System.nanoTime() - stageStartedAt; - stageStartedAt = System.nanoTime(); try { GuideME.getSearch() .indexAll(); @@ -119,63 +104,41 @@ public static void reloadGuides(IResourceManager resourceManager) { GuideDebugLog .warnAlways("[GuideNH] [GuideLightweightReloadService] Failed to reindex search after reload", t); } - long searchIndexNs = System.nanoTime() - stageStartedAt; - - int loadedPageCount = countLoadedPages(guidePages); - int loadedLanguageCount = countLoadedLanguages(guidePages); - long totalNs = System.nanoTime() - startedAt; - - GuideDebugLog.info( - "[GuideNH] [GuideLightweightReloadService] Guide reload complete, loaded {} guides, {} pages, {} languages in {} ns (dataDrivenLoadNs={}, pageLoadNs={}, registryUpdateNs={}, searchIndexNs={})", - guidePages.size(), - loadedPageCount, - loadedLanguageCount, - totalNs, - dataDrivenLoadNs, - pageLoadNs, - registryUpdateNs, - searchIndexNs); } - /** - * Scans the guide folder tree and loads all markdown files under {@code assets///_/...}. - */ public static Map loadPages(IResourceManager resourceManager, ResourceLocation guideId, String folder, String defaultLanguage, @Nullable String currentLanguage) { + var activePacks = DataDrivenGuideLoader.getActiveResourcePacks(resourceManager); + var paths = DataDrivenGuideLoader.discoverPagePaths(guideId, folder, activePacks); + var singleGuidePaths = new LinkedHashMap>(); + if (!paths.isEmpty()) { + singleGuidePaths.put(guideId.getResourceDomain(), new LinkedHashSet<>(paths)); + } return loadPages( resourceManager, guideId, folder, defaultLanguage, currentLanguage, - new LinkedHashMap<>(), - DataDrivenGuideLoader.getActiveResourcePacks(resourceManager)); + singleGuidePaths, + activePacks); } public static Map loadPages(IResourceManager resourceManager, ResourceLocation guideId, String folder, String defaultLanguage, @Nullable String currentLanguage, - Map>> pagePathCache, - Iterable activeResourcePacks) { - long startedAt = System.nanoTime(); + Map> allPagePaths, Iterable activeResourcePacks) { var pages = new HashMap(); - var pagePaths = pagePathsForGuide( - guideId, - folder, - pagePathCache, - lookupFolder -> DataDrivenGuideLoader.discoverPagePaths(lookupFolder, activeResourcePacks)); + LinkedHashSet pagePaths = allPagePaths != null ? allPagePaths.get(guideId.getResourceDomain()) : null; + if (pagePaths == null || pagePaths.isEmpty()) { + pagePaths = new LinkedHashSet<>(); + } String lang = currentLanguage != null ? currentLanguage : defaultLanguage; String sourceNamespace = guideId.getResourceDomain(); - String sourcePack = "resources:" + sourceNamespace; - int localizedHits = 0; - int defaultLanguageHits = 0; - int rawSourceHits = 0; - int failedLoads = 0; for (var pagePath : pagePaths) { ResourceLocation pageId = new ResourceLocation(sourceNamespace, pagePath); - PageLoadResult loadResult = loadPage( + PageLoadResult result = loadPage( resourceManager, - sourcePack, sourceNamespace, folder, defaultLanguage, @@ -183,42 +146,10 @@ public static Map loadPages(IResourceManager pagePath, pageId, activeResourcePacks); - ParsedGuidePage parsed = loadResult != null ? loadResult.page() : null; - if (parsed == null) { - failedLoads++; - GuideDebugLog.warn("[GuideNH] [GuideLightweightReloadService] Failed to load guide page {}", pageId); - continue; + if (result != null) { + pages.put(pageId, result.page()); } - switch (loadResult.kind()) { - case LOCALIZED: - localizedHits++; - break; - case DEFAULT_LANGUAGE: - defaultLanguageHits++; - break; - case RAW_SOURCE: - rawSourceHits++; - break; - default: - break; - } - pages.put(pageId, parsed); } - - long totalNs = System.nanoTime() - startedAt; - GuideDebugLog.info( - "[GuideNH] [GuideLightweightReloadService] Loaded {} pages for guide {} folder {} requestedLanguage={} defaultLanguage={} discoveredPaths={} localizedHits={} defaultLanguageHits={} rawSourceHits={} failedLoads={} durationNs={}", - pages.size(), - guideId, - folder, - lang, - defaultLanguage, - pagePaths.size(), - localizedHits, - defaultLanguageHits, - rawSourceHits, - failedLoads, - totalNs); return pages; } @@ -244,24 +175,6 @@ private static PageLoadResult tryLoadPage(String sourcePack, String requestedLan return page != null ? new PageLoadResult(page, kind) : null; } - public static @Nullable ParsedGuidePage loadPageForLanguage(ResourceLocation guideId, String folder, - String requestedLanguage, String sourceLanguage, ResourceLocation pageId) { - String normalizedRequestedLanguage = LangUtil.normalizeLanguage(requestedLanguage); - String normalizedSourceLanguage = LangUtil.normalizeLanguage(sourceLanguage); - String sourcePack = "resources:" + guideId.getResourceDomain(); - PageLoadResult result = tryLoadPage( - sourcePack, - normalizedRequestedLanguage, - normalizedSourceLanguage, - guideId.getResourceDomain(), - folder, - pageId.getResourcePath(), - pageId, - LoadKind.LOCALIZED, - DataDrivenGuideLoader.getActiveResourcePacks()); - return result != null ? result.page() : null; - } - public static @Nullable ParsedGuidePage tryLoadNeutralPageForExport(IResourceManager resourceManager, String sourcePack, String requestedLanguage, String contentRootFolder, ResourceLocation pageId, ResourceLocation sourceId) { @@ -275,31 +188,31 @@ private static PageLoadResult tryLoadPage(String sourcePack, String requestedLan DataDrivenGuideLoader.getActiveResourcePacks()); } - @Nullable - private static ParsedGuidePage tryParsePage(IResourceManager resourceManager, String sourcePack, String language, - String contentRootFolder, ResourceLocation pageId, ResourceLocation sourceId, - Iterable activeResourcePacks) { - GuidePageResourceSelector.SelectedPageResource selected = GuidePageResourceSelector - .select(sourceId, activeResourcePacks); - byte[] bytes = selected != null ? selected.bytes() : null; - if (bytes == null) { - bytes = GuideResourceAccess.readBytes(resourceManager, sourceId); - } - if (bytes == null) { - return null; - } - return parsePageBytes(sourcePack, language, contentRootFolder, pageId, sourceId, bytes); + public static @Nullable ParsedGuidePage loadPageForLanguage(ResourceLocation guideId, String folder, + String requestedLanguage, String sourceLanguage, ResourceLocation pageId) { + String sourcePack = "resources:" + guideId.getResourceDomain(); + PageLoadResult result = tryLoadPage( + sourcePack, + LangUtil.normalizeLanguage(requestedLanguage), + LangUtil.normalizeLanguage(sourceLanguage), + guideId.getResourceDomain(), + folder, + pageId.getResourcePath(), + pageId, + LoadKind.LOCALIZED, + DataDrivenGuideLoader.getActiveResourcePacks()); + return result != null ? result.page() : null; } @Nullable private static ParsedGuidePage tryParsePageCandidate(String sourcePack, String language, String contentRootFolder, ResourceLocation pageId, ResourceLocation sourceId, Iterable activeResourcePacks) { - GuidePageResourceSelector.SelectedPageResource selected = GuidePageResourceSelector + GuidePageResourceSelector.SelectedPack selected = GuidePageResourceSelector .select(sourceId, activeResourcePacks); - if (selected == null) { - return null; - } - return parsePageBytes(sourcePack, language, contentRootFolder, pageId, sourceId, selected.bytes()); + if (selected == null) return null; + byte[] bytes = DataDrivenGuideLoader.readBytes(selected.pack(), sourceId); + if (bytes == null) return null; + return parsePageBytes(sourcePack, language, contentRootFolder, pageId, sourceId, bytes); } @Nullable @@ -309,31 +222,20 @@ private static ParsedGuidePage parsePageBytes(String sourcePack, String language return GuideLocalizedPageSourceResolver .parseFrontmatterOnly(sourcePack, language, contentRootFolder, pageId, bytes); } catch (Exception ex) { - GuideDebugLog - .error("[GuideNH] [GuideLightweightReloadService] Error parsing page {} from {}", pageId, sourceId, ex); + GuideDebugLog.warnAlways( + "[GuideNH] [GuideLightweightReloadService] Error parsing page {} from {}", + pageId, + sourceId, + ex); return null; } } - static byte @Nullable [] selectPageCandidate(ResourceLocation sourceId) { - return selectPageCandidate(sourceId, DataDrivenGuideLoader.getActiveResourcePacks()); - } - - static byte @Nullable [] selectPageCandidate(ResourceLocation sourceId, - Iterable resourcePacks) { - GuidePageResourceSelector.SelectedPageResource winner = GuidePageResourceSelector - .select(sourceId, resourcePacks); - return winner != null ? winner.bytes() : null; - } - - static int readLoadPriority(ResourceLocation sourceId, byte[] bytes) { - return GuidePageResourceSelector.readLoadPriority(sourceId, bytes); - } - @Nullable - private static PageLoadResult loadPage(IResourceManager resourceManager, String sourcePack, String namespace, - String folder, String defaultLanguage, String requestedLanguage, String pagePath, ResourceLocation pageId, + private static PageLoadResult loadPage(IResourceManager resourceManager, String namespace, String folder, + String defaultLanguage, String requestedLanguage, String pagePath, ResourceLocation pageId, Iterable activeResourcePacks) { + String sourcePack = "resources:" + namespace; PageLoadResult localized = tryLoadPage( sourcePack, requestedLanguage, @@ -344,9 +246,7 @@ private static PageLoadResult loadPage(IResourceManager resourceManager, String pageId, LoadKind.LOCALIZED, activeResourcePacks); - if (localized != null) { - return localized; - } + if (localized != null) return localized; if (!requestedLanguage.equals(defaultLanguage)) { PageLoadResult fallback = tryLoadPage( sourcePack, @@ -358,9 +258,7 @@ private static PageLoadResult loadPage(IResourceManager resourceManager, String pageId, LoadKind.DEFAULT_LANGUAGE, activeResourcePacks); - if (fallback != null) { - return fallback; - } + if (fallback != null) return fallback; } ParsedGuidePage rawPage = tryParsePage( resourceManager, @@ -373,22 +271,31 @@ private static PageLoadResult loadPage(IResourceManager resourceManager, String return rawPage != null ? new PageLoadResult(rawPage, LoadKind.RAW_SOURCE) : null; } - private static int countLoadedPages(Map> guidePages) { - int total = 0; - for (var pages : guidePages.values()) { - total += pages.size(); - } - return total; + @Nullable + private static ParsedGuidePage tryParsePage(IResourceManager resourceManager, String sourcePack, String language, + String contentRootFolder, ResourceLocation pageId, ResourceLocation sourceId, + Iterable activeResourcePacks) { + GuidePageResourceSelector.SelectedPack selected = GuidePageResourceSelector + .select(sourceId, activeResourcePacks); + if (selected == null) return null; + byte[] bytes = DataDrivenGuideLoader.readBytes(selected.pack(), sourceId); + if (bytes == null) return null; + return parsePageBytes(sourcePack, language, contentRootFolder, pageId, sourceId, bytes); } - private static int countLoadedLanguages(Map> guidePages) { - var languages = new LinkedHashSet(); - for (var pages : guidePages.values()) { - for (var parsedPage : pages.values()) { - languages.add(parsedPage.getLanguage()); - } - } - return languages.size(); + static byte @Nullable [] selectPageCandidate(ResourceLocation sourceId) { + return selectPageCandidate(sourceId, DataDrivenGuideLoader.getActiveResourcePacks()); + } + + static byte @Nullable [] selectPageCandidate(ResourceLocation sourceId, + Iterable resourcePacks) { + GuidePageResourceSelector.SelectedPack winner = GuidePageResourceSelector.select(sourceId, resourcePacks); + if (winner == null) return null; + return DataDrivenGuideLoader.readBytes(winner.pack(), sourceId); + } + + static int readLoadPriority(ResourceLocation sourceId, byte[] bytes) { + return GuidePageResourceSelector.readLoadPriority(sourceId, bytes); } private enum LoadKind { diff --git a/src/main/java/com/hfstudio/guidenh/guide/internal/GuideScreen.java b/src/main/java/com/hfstudio/guidenh/guide/internal/GuideScreen.java index b7ccc08e..3f9ee65a 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/internal/GuideScreen.java +++ b/src/main/java/com/hfstudio/guidenh/guide/internal/GuideScreen.java @@ -129,8 +129,11 @@ import com.hfstudio.guidenh.guide.internal.util.LangUtil; import com.hfstudio.guidenh.guide.internal.welcome.GuideWelcomeContent; import com.hfstudio.guidenh.guide.internal.welcome.GuideWelcomeScreen; +import com.hfstudio.guidenh.guide.layout.FontProvider; +import com.hfstudio.guidenh.guide.layout.LayoutBridge; import com.hfstudio.guidenh.guide.layout.LayoutContext; -import com.hfstudio.guidenh.guide.layout.MinecraftFontMetrics; +import com.hfstudio.guidenh.guide.layout.RustFontMetrics; +import com.hfstudio.guidenh.guide.layout.SystemFontProvider; import com.hfstudio.guidenh.guide.mediawiki.MediaWikiExternalLinkSupport; import com.hfstudio.guidenh.guide.mediawiki.MediaWikiPageIds; import com.hfstudio.guidenh.guide.mediawiki.MediaWikiSpecialCatalog; @@ -138,6 +141,8 @@ import com.hfstudio.guidenh.guide.mediawiki.MediaWikiSpecialPageIds; import com.hfstudio.guidenh.guide.navigation.NavigationNode; import com.hfstudio.guidenh.guide.navigation.NavigationTree; +import com.hfstudio.guidenh.guide.render.GuideRenderEngine; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; import com.hfstudio.guidenh.guide.render.VanillaRenderContext; import com.hfstudio.guidenh.guide.scene.LytGuidebookScene; import com.hfstudio.guidenh.guide.scene.annotation.DiamondAnnotation; @@ -230,6 +235,19 @@ public class GuideScreen extends GuiContainer btnGuideEditorLayoutEditorOnly, btnGuideEditorLayoutPreviewOnly, btnGuideEditorAdvancedToggle; public static final int TOOLBAR_H = 16; public static final int TOOLBAR_GAP = 3; + + /** + * Toolbar page-title style: fontScale 0.8 → line height round(17×0.8) = 14 + * < TOOLBAR_H, mirroring {@code GuideNavBar.TITLE_FONT_SCALE}. The laid-out + * bounds height is the LytParagraph minimal estimate (10), so the centered + * titleY = (16-10)/2 + 2 = 5; glyph ink stays inside the 16px toolbar band. + */ + public static final TextStyle TOOLBAR_TITLE_STYLE = TextStyle.builder() + .fontScale(0.8f) + .bold(true) + .font(null) + .color(SymbolicColor.WHITE) + .build(); private static final int GUIDE_EDITOR_TOOLBAR_H = 16; private static final int GUIDE_EDITOR_MIN_SPLIT_PANE_W = 15; private static final int SCROLLBAR_W = SceneEditorMultilineTextArea.SCROLLBAR_SIZE; @@ -268,7 +286,7 @@ private static LytDocument buildLoadingDocument() { private final GuideScreenHomeHistory homeHistory = GuideScreenHomeHistory.shared(); private final HomePageDataBuilder homePageDataBuilder = new HomePageDataBuilder(); private final HomePageController homePageController = new HomePageController(); - private final MinecraftFontMetrics layoutFontMetrics = new MinecraftFontMetrics(); + private final RustFontMetrics layoutFontMetrics = new RustFontMetrics(); private final CodeBlockClipboardService codeBlockClipboardService = new CodeBlockClipboardService(); private final GuideDebugOverlay debugOverlay = new GuideDebugOverlay(); private final GuideScreenScrollbarOutline scrollbarOutline = new GuideScreenScrollbarOutline(); @@ -520,7 +538,7 @@ private GuideScreen(GuideScreenRoute route, @Nullable GuideScreenViewState resto this.parentScreen = parentScreen; applyRoute(route); pageTitle = new LytParagraph(); - pageTitle.setStyle(DefaultStyles.HEADING1); + pageTitle.setStyle(TOOLBAR_TITLE_STYLE); try { this.fullWidth = ModConfig.ui.fullWidth; } catch (Throwable ignored) { @@ -2589,6 +2607,19 @@ private LayoutContext createLayoutContext(int actualWidth, int referenceWidth) { } private void ensureLayout() { + // Lazy-init the Rust font system handle with system CJK font + if (LayoutBridge.getFontHandle() == 0) { + FontProvider fontProvider = new SystemFontProvider(); + byte[] fontData = fontProvider.getFontData("zh_CN"); + GuideDebugLog.warnAlways( + "GuideScreen: initializing Rust font system from {} ({} bytes)", + fontProvider.getFontPath(), + fontData.length); + long handle = LayoutBridge.init(fontData, "zh_CN"); + LayoutBridge.setFontHandle(handle); + loadFallbackSymbolFont(fontProvider, handle); + } + var activeDocument = getActiveDocument(); if (activeDocument == null) return; int layoutWidth = Math.max(1, Math.round(contentW / currentZoom)); @@ -2605,6 +2636,23 @@ private void ensureLayout() { } } + /** + * Best-effort fallback symbol font registration (seguisym.ttf covers the + * callout icons ⓘ ✦ ➤ ⚠ ☢ that msyh.ttc lacks). Runs once right after + * font init; empty data and stale native libs are skipped/ignored. + */ + private void loadFallbackSymbolFont(FontProvider fontProvider, long handle) { + if (handle == 0) return; + byte[] fallbackData = fontProvider.getFallbackFontData("zh_CN"); + if (fallbackData.length == 0) return; + try { + LayoutBridge.loadFallbackFont(handle, fallbackData); + } catch (UnsatisfiedLinkError e) { + GuideDebugLog.warnAlways( + "GuideScreen: loadFallbackFont unavailable (stale native lib?): {}", e.getMessage()); + } + } + private void scrollToCurrentAnchor() { if (isHomeRoute()) return; if (!pendingAnchorScroll) return; @@ -3149,26 +3197,17 @@ private void renderGuideEditorPreview(int x, int y, int width, int height) { cachedPreviewScissor = cachedRect(cachedPreviewScissor, x, y, renderWidth, renderHeight); reusableRenderCtx.setLightDarkMode(LightDarkMode.LIGHT_MODE); reusableRenderCtx.setViewport(cachedPreviewViewport); + reusableRenderCtx.setScreenViewport(cachedPreviewScissor); reusableRenderCtx.setScreenHeight(this.height); reusableRenderCtx.setDocumentOrigin(x, y); reusableRenderCtx.setScrollOffsetY(guideEditorPreviewScrollY); reusableRenderCtx.setZoom(1.0f); - reusableRenderCtx.pushScissor(cachedPreviewScissor); - GL11.glPushMatrix(); - GL11.glTranslatef(x, y, 0f); - GL11.glTranslatef(0f, -(float) guideEditorPreviewScrollY, 0f); + // No GL matrix or context scissor here: the primitive pipeline's render + // engine owns the document->screen transform and the viewport clip. try { previewDocument.render(reusableRenderCtx); } catch (Throwable t) { GuideDebugLog.warnAlways("Failed to render guide editor preview", t); - } finally { - GL11.glPopMatrix(); - reusableRenderCtx.restoreExternalRenderState(); - reusableRenderCtx.popScissor(); - reusableRenderCtx.restoreExternalRenderState(); - GL11.glDisable(GL11.GL_SCISSOR_TEST); - GL11.glEnable(GL11.GL_TEXTURE_2D); - GL11.glColor4f(1f, 1f, 1f, 1f); } drawGuideEditorPreviewScrollbar( x + renderWidth - SCROLLBAR_W, @@ -3954,6 +3993,12 @@ private void drawPageTitle() { if (pageTitle.isEmpty()) return; int reservedRight = (16 + TOOLBAR_GAP) * 5 + PANEL_PADDING + 4; + // Ordinary toolbar title (user decision): placed naturally from the + // toolbar band's left edge (panelX + PANEL_PADDING), unrelated to the + // content column — no more alignment to contentX. The navbar sits + // below the toolbar band (navY = panelY + TOOLBAR_H + 1), so the title + // has no navbar conflict and may fill the toolbar band; the reserved + // right-side icon area is kept. int availableW = Math.max(20, panelW - PANEL_PADDING - reservedRight); int titleX = panelX + PANEL_PADDING; @@ -3969,18 +4014,35 @@ private void drawPageTitle() { int titleY = Math.max(0, (TOOLBAR_H - titleH) / 2) + panelY + 2; var ctx = reusableContentTooltipCtx; - cachedTitleViewport = cachedRect(cachedTitleViewport, 0, 0, availableW, Math.max(titleH, TOOLBAR_H)); + // Defensive clip for the legacy RenderContext fallback path only: the + // atlas-backed glyph runs (DrawGlyphRun) are NOT clipped by this + // viewport. The title stays inside the toolbar band because + // TOOLBAR_TITLE_STYLE's line height (round(17×0.8) = 14) fits under + // TOOLBAR_H — that style, not this clamp, is the actual constraint. + cachedTitleViewport = cachedRect(cachedTitleViewport, 0, 0, availableW, Math.min(titleH, TOOLBAR_H)); ctx.setLightDarkMode(LightDarkMode.LIGHT_MODE); ctx.setViewport(cachedTitleViewport); ctx.setScreenHeight(this.height); ctx.setDocumentOrigin(titleX, titleY); ctx.setScrollOffsetY(0); - GL11.glPushMatrix(); - GL11.glTranslatef(titleX, titleY, 0f); try { - pageTitle.render(ctx); + // Use the primitive pipeline instead of the legacy render() call: + // pageTitle now renders through computePrimitives() (usePrimitives() + // always returns true when content exists), which emits atlas-backed + // glyph runs when glyphData is available, or a GuideText fallback + // (DrawGlyphRun / DrawText) when glyphData is null/empty. This + // eliminates the silent blank from the previous empty render() path. + var engine = LytDocument.getRenderEngine(); + LytRect titleScreenVp = new LytRect(titleX, titleY, availableW, Math.max(titleH, TOOLBAR_H)); + var pc = new PrimitiveCollector(titleScreenVp, ctx); + pc.pushTransform(titleX, titleY, 1.0f); + pc.collectFrom(pageTitle); + pc.popTransform(); + var prims = pc.result(); + if (!prims.isEmpty()) { + engine.execute(prims); + } } finally { - GL11.glPopMatrix(); ctx.restoreExternalRenderState(); GL11.glDisable(GL11.GL_SCISSOR_TEST); GL11.glEnable(GL11.GL_TEXTURE_2D); @@ -4462,27 +4524,19 @@ private void renderDocument(int mouseX, int mouseY) { cachedViewportRect = cachedRect(cachedViewportRect, 0, viewportTopInDocument, contentW, documentH); cachedScissorRect = cachedRect(cachedScissorRect, contentX, documentY, contentW, documentH); ctx.setViewport(cachedViewportRect); + ctx.setScreenViewport(cachedScissorRect); ctx.setScreenHeight(this.height); int documentRenderY = getDocumentViewportY() + documentRenderOffsetY; ctx.setDocumentOrigin(contentX, documentRenderY); ctx.setScrollOffsetY(renderedScrollY); ctx.setPreciseScrollOffsetY(visualScrollY); ctx.setZoom(currentZoom); - ctx.pushScissor(cachedScissorRect); - GL11.glPushMatrix(); - GL11.glTranslatef(contentX, documentRenderY, 0f); - if (currentZoom != 1.0f) { - GL11.glScalef(currentZoom, currentZoom, 1f); - } - GL11.glTranslatef(0f, -visualScrollY, 0f); + // No GL matrix or context scissor here: the primitive pipeline's render + // engine owns the document->screen transform and the viewport clip. try { activeDocument.render(ctx); } catch (Throwable t) { GuideDebugLog.error("Error rendering guide document {}", currentAnchor.pageId(), t); - } finally { - GL11.glPopMatrix(); - ctx.restoreExternalRenderState(); - ctx.popScissor(); } } @@ -5409,14 +5463,11 @@ private Path resolveContextResourcePackFile(MutableGuide targetGuide, ResourceLo @Nullable private Path resolveContextResourcePackPath(MutableGuide targetGuide, ResourceLocation pageId, String language) { - GuidePageResourceSelector.SelectedPageResource selected = resolveContextSelectedResource( - targetGuide, - pageId, - language); + GuidePageResourceSelector.SelectedPack selected = resolveContextSelectedResource(targetGuide, pageId, language); if (selected == null) { return null; } - var resourcePackFile = DataDrivenGuideLoader.getResourcePackFile(selected.resourcePack()); + var resourcePackFile = DataDrivenGuideLoader.getResourcePackFile(selected.pack()); if (resourcePackFile == null) { return null; } @@ -5440,11 +5491,8 @@ private Path resolveContextResourcePackPath(MutableGuide targetGuide, ResourceLo @Nullable private IResourcePack resolveContextResourcePack(MutableGuide targetGuide, ResourceLocation pageId, String language) { - GuidePageResourceSelector.SelectedPageResource selected = resolveContextSelectedResource( - targetGuide, - pageId, - language); - return selected != null ? selected.resourcePack() : null; + GuidePageResourceSelector.SelectedPack selected = resolveContextSelectedResource(targetGuide, pageId, language); + return selected != null ? selected.pack() : null; } private ResourceLocation resolveGuidePageSourceId(MutableGuide targetGuide, ResourceLocation pageId, @@ -5457,7 +5505,7 @@ private ResourceLocation resolveGuidePageSourceId(MutableGuide targetGuide, Reso } @Nullable - private GuidePageResourceSelector.SelectedPageResource resolveContextSelectedResource(MutableGuide targetGuide, + private GuidePageResourceSelector.SelectedPack resolveContextSelectedResource(MutableGuide targetGuide, ResourceLocation pageId, String language) { ResourceLocation localizedSourceId = resolveGuidePageSourceId(targetGuide, pageId, language); ResourceLocation defaultSourceId = language != null && !language.equals(targetGuide.getDefaultLanguage()) diff --git a/src/main/java/com/hfstudio/guidenh/guide/internal/datadriven/DataDrivenGuideLoader.java b/src/main/java/com/hfstudio/guidenh/guide/internal/datadriven/DataDrivenGuideLoader.java index 71a0fa02..80031588 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/internal/datadriven/DataDrivenGuideLoader.java +++ b/src/main/java/com/hfstudio/guidenh/guide/internal/datadriven/DataDrivenGuideLoader.java @@ -3,10 +3,12 @@ import java.io.File; import java.io.IOException; import java.lang.reflect.Field; +import java.nio.charset.StandardCharsets; import java.nio.file.Files; import java.nio.file.Path; import java.util.ArrayList; import java.util.Collections; +import java.util.HashMap; import java.util.IdentityHashMap; import java.util.LinkedHashMap; import java.util.LinkedHashSet; @@ -14,6 +16,8 @@ import java.util.Map; import java.util.Set; import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.zip.ZipEntry; import java.util.zip.ZipFile; import net.minecraft.client.Minecraft; @@ -23,12 +27,17 @@ import net.minecraft.client.resources.IResourcePack; import net.minecraft.client.resources.SimpleReloadableResourceManager; import net.minecraft.util.ResourceLocation; +import net.minecraft.util.StringTranslate; + +import org.jetbrains.annotations.Nullable; -import com.hfstudio.guidenh.config.ModConfig; import com.hfstudio.guidenh.guide.Guide; +import com.hfstudio.guidenh.guide.compiler.Frontmatter; +import com.hfstudio.guidenh.guide.compiler.PageCompiler; import com.hfstudio.guidenh.guide.internal.DirectoryResourcePack; import com.hfstudio.guidenh.guide.internal.GuideDevelopmentResourcePacks; import com.hfstudio.guidenh.guide.internal.MutableGuide; +import com.hfstudio.guidenh.guide.internal.localization.GuidePageLanguageIndex; import com.hfstudio.guidenh.guide.internal.resource.GuideResourceAccess; import com.hfstudio.guidenh.guide.internal.util.LangUtil; import com.hfstudio.guidenh.guide.scene.support.GuideDebugLog; @@ -43,241 +52,183 @@ public class DataDrivenGuideLoader { public static final String AUTO_GUIDE_FOLDER = "guidenh"; public static final String LANGUAGE_FOLDER_PREFIX = "_"; - private static final Map, Field> LOOSE_ROOT_FIELDS = new IdentityHashMap<>(); - private static volatile List lastActiveResourcePacks = List.of(); - private static volatile List lastResourceManagerResourcePacks = List.of(); - private static volatile Map> lastResourceManagerDomainsByPack = Map.of(); - private static volatile GuideLanguageDiscoverySnapshot lastGuideLanguageDiscovery = GuideLanguageDiscoverySnapshot - .empty(); - private static final ConcurrentHashMap> nativeNamespaceRootsCache = new ConcurrentHashMap<>(); + private static final String DEFAULT_LANGUAGE = "en_us"; - private DataDrivenGuideLoader() {} + public record PackCandidate(IResourcePack pack, int loadPriority, int order) { - public static Map load() { - return load(getActiveResourcePacks()); - } - - public static Map load(IResourceManager resourceManager) { - return load(getActiveResourcePacks(resourceManager)); + boolean shouldReplace(PackCandidate previous) { + return loadPriority > previous.loadPriority() + || loadPriority == previous.loadPriority() && order > previous.order(); + } } - public static Map load(Iterable activeResourcePacks) { - long startedAt = System.nanoTime(); - long stageStartedAt = startedAt; - var resolvedResourcePacks = toList(activeResourcePacks); - long resourcePackResolveNs = System.nanoTime() - stageStartedAt; + public record ScanResult(Map guides, Map> pagePaths, + Map> discoveredLanguages) {} - stageStartedAt = System.nanoTime(); - var discoveredLanguages = discoverGuideLanguages(resolvedResourcePacks); - long scanNs = System.nanoTime() - stageStartedAt; + private record NamespaceRoot(String namespace, File directory, boolean allowDirectoryAsGuideRoot) {} - stageStartedAt = System.nanoTime(); - var guides = new LinkedHashMap(); - for (var entry : discoveredLanguages.entrySet()) { - ResourceLocation guideId = entry.getKey(); - var builder = Guide.builder(guideId) - .register(false) - .folder(AUTO_GUIDE_FOLDER) - .defaultLanguage(autoDiscoveredDefaultLanguage()); - guides.put(guideId, (MutableGuide) builder.build()); - } - long buildNs = System.nanoTime() - stageStartedAt; - int discoveredLanguageCount = countDiscoveredLanguages(discoveredLanguages); - long totalNs = System.nanoTime() - startedAt; - if (ModConfig.debug.enableDebugMode) { - GuideDebugLog.info( - "[GuideNH] [DataDrivenGuideLoader] Loaded {} guides across {} languages from {} resource packs in {} ns (resourcePackResolveNs={}, scanNs={}, buildNs={})", - guides.size(), - discoveredLanguageCount, - resolvedResourcePacks.size(), - totalNs, - resourcePackResolveNs, - scanNs, - buildNs); - } - return guides; - } - - public static Map> discoverGuideLanguages() { - return discoverGuideLanguages(getActiveResourcePacks()); - } - - public static Map> discoverGuideLanguages( - Iterable activeResourcePacks) { - var resolvedResourcePacks = toList(activeResourcePacks); - GuideLanguageDiscoverySnapshot cached = lastGuideLanguageDiscovery; - if (cached.matches(resolvedResourcePacks)) { - return cached.discoveredLanguages(); - } + private static final Map, Field> LOOSE_ROOT_FIELDS = new IdentityHashMap<>(); + private static volatile List lastActiveResourcePacks = List.of(); + private static volatile List lastResourceManagerResourcePacks = List.of(); + private static volatile Map> lastResourceManagerDomainsByPack = Map.of(); + private static final Map> pagePackIndex = new ConcurrentHashMap<>(); + private static volatile boolean indexReady = false; + private static final AtomicInteger pagePackOrder = new AtomicInteger(0); + static final Map> PACK_LANG_FILE_PATHS = new IdentityHashMap<>(); - var discoveredLanguages = new LinkedHashMap>(); - for (var resourcePack : resolvedResourcePacks) { - scanResourcePack(resourcePack, discoveredLanguages); - } + private static volatile @Nullable ScanCache lastScanCache = null; - var frozen = freezeDiscoveredLanguages(discoveredLanguages); - lastGuideLanguageDiscovery = new GuideLanguageDiscoverySnapshot(List.copyOf(resolvedResourcePacks), frozen); - return frozen; - } + private record ScanCache(List packRoots, String folder, ScanResult result, + Map> pagePackIndexSnapshot, Map> langFilePathsSnapshot, + Map> langKeys) { - public static LinkedHashMap> discoverPagePaths(String folder) { - return discoverPagePaths(folder, getActiveResourcePacks()); + boolean matches(List roots, String f) { + return folder.equals(f) && packRoots.equals(roots); + } } - public static LinkedHashMap> discoverPagePaths(String folder, - Iterable activeResourcePacks) { - long startedAt = System.nanoTime(); - var resolvedResourcePacks = toList(activeResourcePacks); - var pagePaths = new LinkedHashMap>(); + private static final ConcurrentHashMap> nativeNamespaceRootsCache = new ConcurrentHashMap<>(); - for (var resourcePack : resolvedResourcePacks) { - scanPagePathsAllNamespaces(resourcePack, folder, pagePaths); - } + private DataDrivenGuideLoader() {} - long totalNs = System.nanoTime() - startedAt; - if (ModConfig.debug.enableDebugMode) { - GuideDebugLog.info( - "[GuideNH] [DataDrivenGuideLoader] Discovered {} page paths across {} namespaces for folder {} from {} resource packs in {} ns", - countDiscoveredPagePaths(pagePaths), - pagePaths.size(), - folder, - resolvedResourcePacks.size(), - totalNs); - } - return pagePaths; + public static ScanResult scanAndBuildAll(String folder) { + return scanAndBuildAll(folder, getActiveResourcePacks()); } - private static int countDiscoveredPagePaths(LinkedHashMap> pagePaths) { - int total = 0; - for (var namespacePaths : pagePaths.values()) { - total += namespacePaths.size(); + public static ScanResult scanAndBuildAll(String folder, Iterable activeResourcePacks) { + // Cache hit: same pack roots, same folder → restore index and return cached result + var resolvedPacks = toList(activeResourcePacks); + var packRoots = resolvePackRoots(resolvedPacks); + ScanCache cache = lastScanCache; + if (cache != null && cache.matches(packRoots, folder)) { + indexReady = true; + pagePackIndex.putAll(cache.pagePackIndexSnapshot()); + PACK_LANG_FILE_PATHS.putAll(cache.langFilePathsSnapshot()); + GuidePageLanguageIndex.preload(cache.langKeys()); + return cache.result(); } - return total; - } - private static int countDiscoveredLanguages(Map> discoveredLanguages) { - int total = 0; - for (var languages : discoveredLanguages.values()) { - total += languages.size(); - } - return total; - } + pagePackIndex.clear(); + indexReady = false; + pagePackOrder.set(0); - private static void scanPagePathsAllNamespaces(IResourcePack resourcePack, String folder, - LinkedHashMap> pagePaths) { - var resourcePackRoot = getLooseResourcePackRoot(resourcePack); - if (resourcePackRoot == null || !resourcePackRoot.exists()) { - return; + var pagePaths = new LinkedHashMap>(); + var discoveredLanguages = new LinkedHashMap>(); + var guidePageLangKeys = new LinkedHashMap>(); + + for (var pack : resolvedPacks) { + var root = getLooseResourcePackRoot(pack); + if (root == null || !root.exists()) continue; + if (!root.isDirectory()) { + scanZipBuildIndex(root, folder, pagePaths, pack, discoveredLanguages, guidePageLangKeys); + } else { + scanDirectoryBuildIndex(pack, root, folder, pagePaths, discoveredLanguages, guidePageLangKeys); + } } - if (!resourcePackRoot.isDirectory()) { - scanZipPagePathsAllNamespaces(resourcePackRoot, folder, pagePaths); - return; + var guides = new LinkedHashMap(); + for (var entry : discoveredLanguages.entrySet()) { + guides.put( + entry.getKey(), + (MutableGuide) Guide.builder(entry.getKey()) + .register(false) + .folder(folder) + .defaultLanguage(DEFAULT_LANGUAGE) + .build()); + } + + GuidePageLanguageIndex.preload(freezeLangKeys(guidePageLangKeys)); + + // Save cache BEFORE indexReady — pagePackIndex must not be touched by readers + // during the snapshot (Map.copyOf on ConcurrentHashMap can throw on concurrent read). + if (!resolvedPacks.isEmpty() && guides.size() > 0) { + lastScanCache = new ScanCache( + List.copyOf(packRoots), + folder, + new ScanResult(guides, pagePaths, freezeDiscoveredLanguages(discoveredLanguages)), + new HashMap<>(pagePackIndex), + new HashMap<>(PACK_LANG_FILE_PATHS), + freezeLangKeys(guidePageLangKeys)); } - scanPagePathsAllNamespaces(resourcePack, resourcePackRoot, folder, pagePaths); - } - public static void scanPagePathsAllNamespaces(File resourcePackRoot, String folder, - LinkedHashMap> pagePaths) { - if (!resourcePackRoot.isDirectory()) { - scanZipPagePathsAllNamespaces(resourcePackRoot, folder, pagePaths); - return; - } + indexReady = true; - for (NamespaceRoot namespaceRoot : discoverNamespaceRoots(resourcePackRoot)) { - scanPagePathsForNamespaceRoot(namespaceRoot, folder, pagePaths); - } + return new ScanResult(guides, pagePaths, freezeDiscoveredLanguages(discoveredLanguages)); } - private static void scanPagePathsAllNamespaces(IResourcePack resourcePack, File resourcePackRoot, String folder, - LinkedHashMap> pagePaths) { - var discoveredRoots = discoverNamespaceRoots(resourcePackRoot); - if (!discoveredRoots.isEmpty()) { - for (NamespaceRoot namespaceRoot : discoveredRoots) { - scanPagePathsForNamespaceRoot(namespaceRoot, folder, pagePaths); - } - return; - } - - for (String domain : getResourceDomains(resourcePack)) { - scanPagePathsForNamespaceRoot(resourcePackRoot, namespaceFromDirectoryName(domain), folder, pagePaths); - } + public static @Nullable List getCandidatesFor(ResourceLocation pageLocation) { + return pagePackIndex.get(pageLocation); } - private static void scanPagePathsForNamespaceRoot(File resourcePackRoot, String namespace, String folder, - LinkedHashMap> pagePaths) { - if (!isValidNamespace(namespace)) { - return; - } - - var discovered = new LinkedHashSet(); - for (File guideRoot : guideRootCandidates(resourcePackRoot, namespace, folder)) { - scanFolderPagePaths(guideRoot, discovered); - } - if (!discovered.isEmpty()) { - pagePaths.computeIfAbsent(namespace, k -> new LinkedHashSet<>()) - .addAll(discovered); - } + public static boolean isIndexPopulated() { + return indexReady; } - private static void scanPagePathsForNamespaceRoot(NamespaceRoot namespaceRoot, String folder, - LinkedHashMap> pagePaths) { - var discovered = new LinkedHashSet(); - for (File guideRoot : guideRootCandidates(namespaceRoot, folder)) { - scanFolderPagePaths(guideRoot, discovered); - } - if (!discovered.isEmpty()) { - pagePaths.computeIfAbsent(namespaceRoot.namespace(), k -> new LinkedHashSet<>()) - .addAll(discovered); - } + public static void clearCaches() { + pagePackIndex.clear(); + PACK_LANG_FILE_PATHS.clear(); + nativeNamespaceRootsCache.clear(); + indexReady = false; + pagePackOrder.set(0); + // NOTE: lastScanCache is NOT cleared here — it persists across reloads + // so that GuideReloadListener's second call (same packs) hits cache. } - private static void scanZipPagePathsAllNamespaces(File resourcePackFile, String folder, - LinkedHashMap> pagePaths) { + private static void scanZipBuildIndex(File resourcePackFile, String folder, + LinkedHashMap> pagePaths, IResourcePack resourcePack, + Map> discoveredLanguages, + LinkedHashMap> guidePageLangKeys) { var prefix = "assets/"; try (var zip = new ZipFile(resourcePackFile)) { var entries = zip.entries(); while (entries.hasMoreElements()) { var entry = entries.nextElement(); - if (entry.isDirectory()) { - continue; - } - + if (entry.isDirectory()) continue; var path = entry.getName(); - if (!path.startsWith(prefix) || !path.endsWith(".md")) { + if (!path.startsWith(prefix)) continue; + + if (path.endsWith(".lang")) { + collectLangKeys(zip, entry, path, guidePageLangKeys); + PACK_LANG_FILE_PATHS.computeIfAbsent(resourcePackFile, k -> new ArrayList<>()) + .add(path); continue; } + if (!path.endsWith(".md")) continue; - // path format: assets///_/.md var afterAssets = path.substring(prefix.length()); var firstSlash = afterAssets.indexOf('/'); - if (firstSlash <= 0) { - continue; - } - + if (firstSlash <= 0) continue; var namespace = afterAssets.substring(0, firstSlash); var afterNamespace = afterAssets.substring(firstSlash + 1); - - // Check that afterNamespace starts with folder/ - if (!afterNamespace.startsWith(folder + "/")) { - continue; - } - + if (!afterNamespace.startsWith(folder + "/")) continue; var afterFolder = afterNamespace.substring(folder.length() + 1); var slashIndex = afterFolder.indexOf('/'); - if (slashIndex <= 0) { - continue; - } - + if (slashIndex <= 0) continue; var language = afterFolder.substring(0, slashIndex); - if (!isLanguageFolder(language)) { - continue; - } - + if (!isLanguageFolder(language)) continue; var pagePath = afterFolder.substring(slashIndex + 1); - if (!pagePath.isEmpty()) { - pagePaths.computeIfAbsent(namespace, k -> new LinkedHashSet<>()) - .add(pagePath); + if (pagePath.isEmpty()) continue; + + pagePaths.computeIfAbsent(namespace, k -> new LinkedHashSet<>()) + .add(pagePath); + discoveredLanguages.computeIfAbsent(new ResourceLocation(namespace, folder), k -> new LinkedHashSet<>()) + .add(toLanguageCode(language)); + + int loadPriority = parseLoadPriorityFromZipEntry( + zip, + entry, + new ResourceLocation(namespace, folder + "/" + language + "/" + pagePath)); + synchronized (pagePackIndex) { + pagePackIndex + .computeIfAbsent( + new ResourceLocation(namespace, folder + "/" + language + "/" + pagePath), + k -> new ArrayList<>()) + .add(new PackCandidate(resourcePack, loadPriority, pagePackOrder.getAndIncrement())); + pagePackIndex + .computeIfAbsent( + new ResourceLocation(namespace, folder + "/" + pagePath), + k -> new ArrayList<>()) + .add(new PackCandidate(resourcePack, loadPriority, pagePackOrder.getAndIncrement())); } } } catch (IOException e) { @@ -288,6 +239,156 @@ private static void scanZipPagePathsAllNamespaces(File resourcePackFile, String } } + private static void collectLangKeys(ZipFile zip, ZipEntry entry, String path, + LinkedHashMap> guidePageLangKeys) { + try (var input = zip.getInputStream(entry)) { + var langFile = StringTranslate.parseLangFile(input); + for (var langEntry : langFile.entrySet()) { + if (langEntry.getKey() + .startsWith("guidenh.page.")) { + int langStart = path.lastIndexOf('/') + 1; + int langEnd = path.lastIndexOf('.'); + if (langStart <= 0 || langEnd <= langStart) continue; + guidePageLangKeys + .computeIfAbsent( + LangUtil.normalizeLanguage(path.substring(langStart, langEnd)), + k -> new LinkedHashMap<>()) + .put(langEntry.getKey(), langEntry.getValue()); + } + } + } catch (IOException ignored) {} + } + + private static int parseLoadPriorityFromZipEntry(ZipFile zip, ZipEntry entry, ResourceLocation loc) { + try (var stream = zip.getInputStream(entry)) { + String content = new String(GuideResourceAccess.readFully(stream), StandardCharsets.UTF_8); + if (content.startsWith("")) content = content.substring(1); + String yamlText = PageCompiler.extractFrontmatterText(PageCompiler.normalizeLineEndings(content)); + if (yamlText != null) { + var nav = Frontmatter.parse(loc, yamlText) + .navigationEntry(); + return nav != null ? nav.loadPriority() : 0; + } + } catch (IOException ignored) {} + return 0; + } + + private static void scanDirectoryBuildIndex(IResourcePack resourcePack, File resourcePackRoot, String folder, + LinkedHashMap> pagePaths, + Map> discoveredLanguages, + LinkedHashMap> guidePageLangKeys) { + for (NamespaceRoot namespaceRoot : discoverNamespaceRoots(resourcePackRoot)) { + scanDirectoryBuildIndexForNamespace( + resourcePack, + namespaceRoot, + folder, + pagePaths, + discoveredLanguages, + guidePageLangKeys); + } + // .lang files in assets/*/lang/ + File assetsDir = new File(resourcePackRoot, "assets"); + File[] nsDirs = assetsDir.listFiles(File::isDirectory); + if (nsDirs != null) { + for (File nsDir : nsDirs) { + File langDir = new File(nsDir, "lang"); + if (!langDir.isDirectory()) continue; + File[] langFiles = langDir.listFiles((dir, name) -> name.endsWith(".lang")); + if (langFiles == null) continue; + for (File langFile : langFiles) { + String fileName = langFile.getName(); + int dot = fileName.lastIndexOf('.'); + if (dot <= 0) continue; + try (var input = new java.io.FileInputStream(langFile)) { + var parsed = StringTranslate.parseLangFile(input); + for (var entry : parsed.entrySet()) { + if (entry.getKey() + .startsWith("guidenh.page.")) { + guidePageLangKeys + .computeIfAbsent( + LangUtil.normalizeLanguage(fileName.substring(0, dot)), + k -> new LinkedHashMap<>()) + .put(entry.getKey(), entry.getValue()); + } + } + } catch (IOException ignored) {} + } + } + } + } + + private static void scanDirectoryBuildIndexForNamespace(IResourcePack resourcePack, NamespaceRoot namespaceRoot, + String folder, LinkedHashMap> pagePaths, + Map> discoveredLanguages, + LinkedHashMap> guidePageLangKeys) { + File guideRoot = new File(namespaceRoot.directory(), folder); + if (!guideRoot.isDirectory()) return; + File[] languageDirs = guideRoot.listFiles(File::isDirectory); + if (languageDirs == null) return; + + for (File languageDir : languageDirs) { + String language = languageDir.getName(); + if (!isLanguageFolder(language)) continue; + discoveredLanguages + .computeIfAbsent(new ResourceLocation(namespaceRoot.namespace(), folder), k -> new LinkedHashSet<>()) + .add(toLanguageCode(language)); + + var collectors = new LinkedHashSet(); + collectMarkdownPaths(languageDir, "", collectors); + + for (String pagePath : collectors) { + pagePaths.computeIfAbsent(namespaceRoot.namespace(), k -> new LinkedHashSet<>()) + .add(pagePath); + var loc = new ResourceLocation(namespaceRoot.namespace(), folder + "/" + language + "/" + pagePath); + int loadPriority = parseLoadPriorityFromFile( + languageDir.toPath() + .resolve(pagePath), + loc); + synchronized (pagePackIndex) { + pagePackIndex.computeIfAbsent(loc, k -> new ArrayList<>()) + .add(new PackCandidate(resourcePack, loadPriority, pagePackOrder.getAndIncrement())); + pagePackIndex + .computeIfAbsent( + new ResourceLocation(namespaceRoot.namespace(), folder + "/" + pagePath), + k -> new ArrayList<>()) + .add(new PackCandidate(resourcePack, loadPriority, pagePackOrder.getAndIncrement())); + } + } + } + } + + private static int parseLoadPriorityFromFile(Path filePath, ResourceLocation loc) { + try { + String content = new String(Files.readAllBytes(filePath), StandardCharsets.UTF_8); + if (content.startsWith("")) content = content.substring(1); + String yamlText = PageCompiler.extractFrontmatterText(PageCompiler.normalizeLineEndings(content)); + if (yamlText != null) { + var nav = Frontmatter.parse(loc, yamlText) + .navigationEntry(); + return nav != null ? nav.loadPriority() : 0; + } + } catch (IOException ignored) {} + return 0; + } + + public static List getLangFilePaths(File resourcePackFile) { + List paths = PACK_LANG_FILE_PATHS.get(resourcePackFile); + return paths != null ? paths : List.of(); + } + + public static Map readLangFile(IResourcePack resourcePack, String entryPath) { + if (!entryPath.startsWith("assets/") || !entryPath.endsWith(".lang")) return Map.of(); + var afterAssets = entryPath.substring("assets/".length()); + var firstSlash = afterAssets.indexOf('/'); + if (firstSlash <= 0) return Map.of(); + try (var input = resourcePack.getInputStream( + new ResourceLocation(afterAssets.substring(0, firstSlash), afterAssets.substring(firstSlash + 1)))) { + return StringTranslate.parseLangFile(input); + } catch (IOException e) { + return Map.of(); + } + } + public static Set discoverPagePaths(ResourceLocation guideId, String folder) { return discoverPagePaths(guideId, folder, getActiveResourcePacks()); } @@ -295,32 +396,71 @@ public static Set discoverPagePaths(ResourceLocation guideId, String fol public static Set discoverPagePaths(ResourceLocation guideId, String folder, Iterable activeResourcePacks) { var result = new LinkedHashSet(); - for (var resourcePack : activeResourcePacks) { - scanPagePathsForNamespace(resourcePack, guideId.getResourceDomain(), folder, result); + for (var pack : activeResourcePacks) { + var root = getLooseResourcePackRoot(pack); + if (root == null || !root.exists()) continue; + if (root.isDirectory()) { + for (File guideRoot : guideRootCandidates(root, guideId.getResourceDomain(), folder)) { + var langDirs = guideRoot.listFiles(File::isDirectory); + if (langDirs == null) continue; + for (var langDir : langDirs) { + if (isLanguageFolder(langDir.getName())) { + collectMarkdownPaths(langDir, "", result); + } + } + } + } else { + scanZipPagePaths(root, "assets/" + guideId.getResourceDomain() + "/" + folder + "/", result); + } } return result; } - public static void scanPagePathsForNamespace(IResourcePack resourcePack, String namespace, String folder, - Set pagePaths) { - var resourcePackRoot = getLooseResourcePackRoot(resourcePack); - if (resourcePackRoot == null || !resourcePackRoot.exists()) { - return; + public static void scanZipPagePaths(File resourcePackFile, String prefix, Set pagePaths) { + try (var zip = new ZipFile(resourcePackFile)) { + var entries = zip.entries(); + while (entries.hasMoreElements()) { + var entry = entries.nextElement(); + if (entry.isDirectory()) continue; + var path = entry.getName(); + if (!path.startsWith(prefix) || !path.endsWith(".md")) continue; + var relative = path.substring(prefix.length()); + var slashIndex = relative.indexOf('/'); + if (slashIndex <= 0) continue; + if (!isLanguageFolder(relative.substring(0, slashIndex))) continue; + var pagePath = relative.substring(slashIndex + 1); + if (!pagePath.isEmpty()) pagePaths.add(pagePath); + } + } catch (IOException e) { + GuideDebugLog.warnAlways( + "[GuideNH] [DataDrivenGuideLoader] Failed to scan zip for pages: {}", + resourcePackFile.getAbsolutePath(), + e); } - scanPagePathsForNamespace(resourcePackRoot, namespace, folder, pagePaths); } - public static void scanPagePathsForNamespace(File resourcePackRoot, String namespace, String folder, - Set pagePaths) { - if (resourcePackRoot.isDirectory()) { - for (File guideRoot : guideRootCandidates(resourcePackRoot, namespace, folder)) { - scanFolderPagePaths(guideRoot, pagePaths); - } - } else { - scanZipPagePaths(resourcePackRoot, toFolderPrefix(namespace, folder), pagePaths); + public static void collectMarkdownPaths(File directory, String relativePath, Set pagePaths) { + var children = directory.listFiles(); + if (children == null) return; + for (var child : children) { + String childPath = relativePath.isEmpty() ? child.getName() : relativePath + "/" + child.getName(); + if (child.isDirectory()) { + collectMarkdownPaths(child, childPath, pagePaths); + } else if (child.isFile() && child.getName() + .endsWith(".md")) { + pagePaths.add(childPath); + } } } + public static boolean isLanguageFolder(String name) { + return name.startsWith(LANGUAGE_FOLDER_PREFIX) && LangUtil.isLanguageCode(name.substring(1)); + } + + public static String toLanguageCode(String folderName) { + return LangUtil.normalizeLanguage(folderName.substring(LANGUAGE_FOLDER_PREFIX.length())); + } + public static List getActiveResourcePacks() { var resourcePacks = new LinkedHashSet(GuideDevelopmentResourcePacks.getConfiguredPacks()); resourcePacks.addAll(lastResourceManagerResourcePacks); @@ -349,130 +489,17 @@ public static List getLastActiveResourcePacks() { return snapshot.isEmpty() ? getActiveResourcePacks() : snapshot; } - private static void addConfiguredResourcePacks(LinkedHashSet resourcePacks) { - try { - var accessor = (AccessorFMLClientHandler) FMLClientHandler.instance(); - var basePacks = accessor.guidenh$getResourcePackList(); - if (basePacks != null) { - resourcePacks.addAll(basePacks); - } - } catch (RuntimeException e) { - GuideDebugLog.warnAlways( - "[GuideNH] [DataDrivenGuideLoader] Failed to inspect the currently loaded base resource packs", - e); - } - - var repository = Minecraft.getMinecraft() - .getResourcePackRepository(); - for (var entry : repository.getRepositoryEntries()) { - var resourcePack = entry.getResourcePack(); - if (resourcePack != null) { - resourcePacks.add(resourcePack); - } - } - - var serverPack = repository.func_148530_e(); - if (serverPack != null) { - resourcePacks.add(serverPack); - } - } - - private static void addResourceManagerResourcePacks(IResourceManager resourceManager, - LinkedHashSet resourcePacks, - IdentityHashMap> domainsByPack) { - if (!(resourceManager instanceof SimpleReloadableResourceManager)) { - return; - } - - try { - var accessor = (AccessorSimpleReloadableResourceManager) resourceManager; - Map domainManagers = accessor.guidenh$getDomainResourceManagers(); - if (domainManagers == null || domainManagers.isEmpty()) { - return; - } - - for (String domain : resourceManager.getResourceDomains()) { - FallbackResourceManager fallbackResourceManager = domainManagers.get(domain); - if (fallbackResourceManager == null) { - continue; - } - List packs = ((AccessorFallbackResourceManager) fallbackResourceManager) - .guidenh$getResourcePacks(); - if (packs != null) { - for (IResourcePack pack : packs) { - resourcePacks.add(pack); - domainsByPack.computeIfAbsent(pack, ignored -> new LinkedHashSet<>()) - .add(domain); - } - } - } - } catch (RuntimeException e) { - GuideDebugLog.warnAlways( - "[GuideNH] [DataDrivenGuideLoader] Failed to inspect the currently loaded resource manager packs", - e); - } - } - - private static Map> freezeDomainsByPack( - IdentityHashMap> domainsByPack) { - if (domainsByPack.isEmpty()) { - return Map.of(); - } - - var result = new IdentityHashMap>(); - for (var entry : domainsByPack.entrySet()) { - result.put(entry.getKey(), Set.copyOf(entry.getValue())); - } - return Collections.unmodifiableMap(result); - } - - private static Set getResourceDomains(IResourcePack resourcePack) { - Set cachedDomains = lastResourceManagerDomainsByPack.get(resourcePack); - return cachedDomains != null ? cachedDomains : resourcePack.getResourceDomains(); - } - - public static void scanResourcePack(IResourcePack resourcePack, - Map> discoveredLanguages) { - var resourcePackRoot = getLooseResourcePackRoot(resourcePack); - if (resourcePackRoot == null || !resourcePackRoot.exists()) { - return; - } - - if (resourcePackRoot.isDirectory()) { - scanResourcePackFolder(resourcePack, resourcePackRoot, discoveredLanguages); - } else { - scanResourcePackZip(resourcePackRoot, discoveredLanguages); - } - } - - public static void scanPagePaths(IResourcePack resourcePack, String prefix, Set pagePaths) { - var resourcePackRoot = getLooseResourcePackRoot(resourcePack); - if (resourcePackRoot == null || !resourcePackRoot.exists()) { - return; - } - - if (resourcePackRoot.isDirectory()) { - scanFolderPagePaths(new File(resourcePackRoot, prefix.replace('/', File.separatorChar)), pagePaths); - } else { - scanZipPagePaths(resourcePackRoot, prefix, pagePaths); - } - } - public static File getResourcePackFile(IResourcePack resourcePack) { if (resourcePack instanceof DirectoryResourcePack) { return ((DirectoryResourcePack) resourcePack).getRoot() .toFile(); } - - if (!(resourcePack instanceof AbstractResourcePack)) { - return null; - } - + if (!(resourcePack instanceof AbstractResourcePack)) return null; try { return ((AccessorAbstractResourcePack) resourcePack).guidenh$getResourcePackFile(); } catch (RuntimeException e) { GuideDebugLog.warnAlways( - "[GuideNH] [DataDrivenGuideLoader] Failed to resolve the backing file for resource pack {}", + "[GuideNH] [DataDrivenGuideLoader] Failed to resolve backing file for pack {}", resourcePack.getPackName(), e); return null; @@ -481,26 +508,16 @@ public static File getResourcePackFile(IResourcePack resourcePack) { public static File getLooseResourcePackRoot(IResourcePack resourcePack) { File resourcePackFile = getResourcePackFile(resourcePack); - if (resourcePackFile != null) { - return resourcePackFile; - } - + if (resourcePackFile != null) return resourcePackFile; Field field = findLooseRootField(resourcePack.getClass()); - if (field == null) { - return null; - } - + if (field == null) return null; try { Object value = field.get(resourcePack); - if (value instanceof Path path) { - return path.toFile(); - } - if (value instanceof File file) { - return file; - } + if (value instanceof Path path) return path.toFile(); + if (value instanceof File file) return file; } catch (IllegalAccessException e) { GuideDebugLog.warnAlways( - "[GuideNH] [DataDrivenGuideLoader] Failed to resolve the directory root for resource pack {}", + "[GuideNH] [DataDrivenGuideLoader] Failed to resolve directory root for pack {}", resourcePack.getPackName(), e); } @@ -509,10 +526,7 @@ public static File getLooseResourcePackRoot(IResourcePack resourcePack) { private static Field findLooseRootField(Class resourcePackClass) { synchronized (LOOSE_ROOT_FIELDS) { - if (LOOSE_ROOT_FIELDS.containsKey(resourcePackClass)) { - return LOOSE_ROOT_FIELDS.get(resourcePackClass); - } - + if (LOOSE_ROOT_FIELDS.containsKey(resourcePackClass)) return LOOSE_ROOT_FIELDS.get(resourcePackClass); Field field = discoverLooseRootField(resourcePackClass); LOOSE_ROOT_FIELDS.put(resourcePackClass, field); return field; @@ -534,318 +548,109 @@ private static Field discoverLooseRootField(Class resourcePackClass) { return null; } - public static byte[] readBytes(IResourcePack resourcePack, ResourceLocation resourceLocation) { - if (!resourcePack.resourceExists(resourceLocation)) { - return readLooseBytes(resourcePack, resourceLocation); - } - try (var input = resourcePack.getInputStream(resourceLocation)) { - return GuideResourceAccess.readFully(input); - } catch (IOException e) { - GuideDebugLog.warnAlways( - "[GuideNH] [DataDrivenGuideLoader] Failed to read resource {} from resource pack {}", - resourceLocation, - resourcePack.getPackName(), - e); - return null; - } - } - - public static byte[] readLooseBytes(IResourcePack resourcePack, ResourceLocation resourceLocation) { - File looseRoot = getLooseResourcePackRoot(resourcePack); - if (looseRoot == null || !looseRoot.isDirectory()) { - return null; - } - - Path root = looseRoot.toPath() - .toAbsolutePath() - .normalize(); - for (String candidate : resourcePathCandidates(looseRoot, resourceLocation)) { - Path path = root.resolve(candidate.replace('/', File.separatorChar)) - .normalize(); - if (!path.startsWith(root) || !Files.isRegularFile(path)) { - continue; - } - try { - return Files.readAllBytes(path); - } catch (IOException e) { - GuideDebugLog.warnAlways( - "[GuideNH] [DataDrivenGuideLoader] Failed to read loose resource {} from resource pack {}", - path, - resourcePack.getPackName(), - e); - return null; - } - } - return null; - } - - private static List resourcePathCandidates(File resourcePackRoot, ResourceLocation resourceLocation) { - String namespace = resourceLocation.getResourceDomain(); - String path = resourceLocation.getResourcePath(); - var candidates = new LinkedHashSet(); - candidates.add("assets/" + namespace + "/" + path); - for (NamespaceRoot namespaceRoot : discoverNativeNamespaceRoots(resourcePackRoot)) { - if (namespaceRoot.namespace() - .equals(namespace)) { - candidates.add( - namespaceRoot.directory() - .getName() + "/" - + path); - } - } - candidates.add(namespace + "/" + path); - if (path.startsWith(AUTO_GUIDE_FOLDER + "/")) { - candidates.add(path); - } - return List.copyOf(candidates); - } - - public static IResourcePack findResourcePack(ResourceLocation resourceLocation) { - return findResourcePack(resourceLocation, getActiveResourcePacks()); - } - - public static IResourcePack findResourcePack(ResourceLocation resourceLocation, - Iterable resourcePacks) { - GuidePageResourceSelector.SelectedPageResource selected = GuidePageResourceSelector - .select(resourceLocation, resourcePacks); - return selected != null ? selected.resourcePack() : null; - } - - public static void scanResourcePackFolder(File resourcePackRoot, - Map> discoveredLanguages) { - for (NamespaceRoot namespaceRoot : discoverNamespaceRoots(resourcePackRoot)) { - scanResourcePackFolderNamespaceRoot(namespaceRoot, AUTO_GUIDE_FOLDER, discoveredLanguages); - } - } - - private static void scanResourcePackFolder(IResourcePack resourcePack, File resourcePackRoot, - Map> discoveredLanguages) { - var discoveredRoots = discoverNamespaceRoots(resourcePackRoot); - if (!discoveredRoots.isEmpty()) { - for (NamespaceRoot namespaceRoot : discoveredRoots) { - scanResourcePackFolderNamespaceRoot(namespaceRoot, AUTO_GUIDE_FOLDER, discoveredLanguages); - } - return; - } - - for (String domain : getResourceDomains(resourcePack)) { - scanResourcePackFolderNamespace(resourcePackRoot, namespaceFromDirectoryName(domain), discoveredLanguages); - } - } - - private static void scanResourcePackFolderNamespace(File resourcePackRoot, String namespace, - Map> discoveredLanguages) { - if (!isValidNamespace(namespace)) { - return; - } - for (File guideRoot : guideRootCandidates(resourcePackRoot, namespace, AUTO_GUIDE_FOLDER)) { - scanResourcePackFolderNamespaceRoot(namespace, guideRoot, discoveredLanguages); - } - } - - private static void scanResourcePackFolderNamespaceRoot(NamespaceRoot namespaceRoot, String folder, - Map> discoveredLanguages) { - for (File guideRoot : guideRootCandidates(namespaceRoot, folder)) { - scanResourcePackFolderNamespaceRoot(namespaceRoot.namespace(), guideRoot, discoveredLanguages); - } - } - - private static void scanResourcePackFolderNamespaceRoot(String namespace, File guideRootDir, - Map> discoveredLanguages) { - if (!guideRootDir.isDirectory()) { - return; - } - var languageDirs = guideRootDir.listFiles(File::isDirectory); - if (languageDirs == null) { - return; + private static void addConfiguredResourcePacks(LinkedHashSet resourcePacks) { + try { + var accessor = (AccessorFMLClientHandler) FMLClientHandler.instance(); + var basePacks = accessor.guidenh$getResourcePackList(); + if (basePacks != null) resourcePacks.addAll(basePacks); + } catch (RuntimeException e) { + GuideDebugLog.warnAlways("[GuideNH] [DataDrivenGuideLoader] Failed to inspect base resource packs", e); } - for (var languageDir : languageDirs) { - var languageFolder = languageDir.getName(); - if (!isLanguageFolder(languageFolder)) { - continue; - } - - if (!containsMarkdownFiles(languageDir)) { - continue; - } - - var guideId = new ResourceLocation(namespace, AUTO_GUIDE_FOLDER); - discoveredLanguages.computeIfAbsent(guideId, ignored -> new LinkedHashSet<>()) - .add(toLanguageCode(languageFolder)); + var repository = Minecraft.getMinecraft() + .getResourcePackRepository(); + for (var entry : repository.getRepositoryEntries()) { + var pack = entry.getResourcePack(); + if (pack != null) resourcePacks.add(pack); } + var serverPack = repository.func_148530_e(); + if (serverPack != null) resourcePacks.add(serverPack); } - public static void scanResourcePackZip(File resourcePackFile, - Map> discoveredLanguages) { - String assetsPrefix = "assets/"; - try (var zip = new ZipFile(resourcePackFile)) { - var entries = zip.entries(); - while (entries.hasMoreElements()) { - var entry = entries.nextElement(); - if (entry.isDirectory()) { - continue; - } - - var path = entry.getName(); - if (!path.startsWith(assetsPrefix) || !path.endsWith(".md")) { - continue; - } - - var afterAssets = path.substring(assetsPrefix.length()); - var namespaceEnd = afterAssets.indexOf('/'); - if (namespaceEnd <= 0) { - continue; - } - - var namespace = afterAssets.substring(0, namespaceEnd); - var afterNamespace = afterAssets.substring(namespaceEnd + 1); - if (!afterNamespace.startsWith(AUTO_GUIDE_FOLDER + "/")) { - continue; - } - - var afterGuideFolder = afterNamespace.substring(AUTO_GUIDE_FOLDER.length() + 1); - var languageEnd = afterGuideFolder.indexOf('/'); - if (languageEnd <= 0) { - continue; - } - - var languageFolder = afterGuideFolder.substring(0, languageEnd); - if (!isLanguageFolder(languageFolder)) { - continue; + private static void addResourceManagerResourcePacks(IResourceManager resourceManager, + LinkedHashSet resourcePacks, + IdentityHashMap> domainsByPack) { + if (!(resourceManager instanceof SimpleReloadableResourceManager)) return; + try { + var accessor = (AccessorSimpleReloadableResourceManager) resourceManager; + Map domainManagers = accessor.guidenh$getDomainResourceManagers(); + if (domainManagers == null || domainManagers.isEmpty()) return; + for (String domain : resourceManager.getResourceDomains()) { + FallbackResourceManager fallback = domainManagers.get(domain); + if (fallback == null) continue; + var packs = ((AccessorFallbackResourceManager) fallback).guidenh$getResourcePacks(); + if (packs != null) { + for (IResourcePack pack : packs) { + resourcePacks.add(pack); + domainsByPack.computeIfAbsent(pack, ignored -> new LinkedHashSet<>()) + .add(domain); + } } - - discoveredLanguages - .computeIfAbsent( - new ResourceLocation(namespace, AUTO_GUIDE_FOLDER), - ignored -> new LinkedHashSet<>()) - .add(toLanguageCode(languageFolder)); } - } catch (IOException e) { - GuideDebugLog.warnAlways( - "[GuideNH] [DataDrivenGuideLoader] Failed to scan guide languages from resource pack {}", - resourcePackFile.getAbsolutePath(), - e); + } catch (RuntimeException e) { + GuideDebugLog.warnAlways("[GuideNH] [DataDrivenGuideLoader] Failed to inspect resource manager packs", e); } } - public static void scanFolderPagePaths(File guideRoot, Set pagePaths) { - var languageDirs = guideRoot.listFiles(File::isDirectory); - if (languageDirs == null) { - return; - } + private static Set getResourceDomains(IResourcePack resourcePack) { + Set cached = lastResourceManagerDomainsByPack.get(resourcePack); + return cached != null ? cached : resourcePack.getResourceDomains(); + } - for (var languageDir : languageDirs) { - if (!isLanguageFolder(languageDir.getName())) { - continue; - } - collectMarkdownPaths(languageDir, "", pagePaths); + private static Map> freezeDomainsByPack( + IdentityHashMap> domainsByPack) { + if (domainsByPack.isEmpty()) return Map.of(); + var result = new IdentityHashMap>(); + for (var entry : domainsByPack.entrySet()) { + result.put(entry.getKey(), Set.copyOf(entry.getValue())); } + return Collections.unmodifiableMap(result); } - public static void scanZipPagePaths(File resourcePackFile, String prefix, Set pagePaths) { - try (var zip = new ZipFile(resourcePackFile)) { - var entries = zip.entries(); - while (entries.hasMoreElements()) { - var entry = entries.nextElement(); - if (entry.isDirectory()) { - continue; - } - - var path = entry.getName(); - if (!path.startsWith(prefix) || !path.endsWith(".md")) { - continue; - } - - var relative = path.substring(prefix.length()); - var slashIndex = relative.indexOf('/'); - if (slashIndex <= 0) { - continue; - } - - var language = relative.substring(0, slashIndex); - if (!isLanguageFolder(language)) { - continue; - } - - var pagePath = relative.substring(slashIndex + 1); - if (!pagePath.isEmpty()) { - pagePaths.add(pagePath); - } - } + public static byte[] readBytes(IResourcePack resourcePack, ResourceLocation resourceLocation) { + try (var input = resourcePack.getInputStream(resourceLocation)) { + return GuideResourceAccess.readFully(input); } catch (IOException e) { + return null; + } catch (RuntimeException e) { GuideDebugLog.warnAlways( - "[GuideNH] [DataDrivenGuideLoader] Failed to scan guide pages from resource pack {}", - resourcePackFile.getAbsolutePath(), - e); + "[GuideNH] [DataDrivenGuideLoader] readBytes failed for {} from pack {}: {}", + resourceLocation, + resourcePack.getPackName(), + e.toString()); + return null; } } - public static void collectMarkdownPaths(File directory, String relativePath, Set pagePaths) { - var children = directory.listFiles(); - if (children == null) { - return; - } - - for (var child : children) { - String childPath = relativePath.isEmpty() ? child.getName() : relativePath + "/" + child.getName(); - if (child.isDirectory()) { - collectMarkdownPaths(child, childPath, pagePaths); - } else if (child.isFile() && child.getName() - .endsWith(".md")) { - pagePaths.add(childPath); - } - } + public static IResourcePack findResourcePack(ResourceLocation resourceLocation) { + return findResourcePack(resourceLocation, getActiveResourcePacks()); } - public static boolean containsMarkdownFiles(File directory) { - var children = directory.listFiles(); - if (children == null) { - return false; - } - - for (var child : children) { - if (child.isFile() && child.getName() - .endsWith(".md")) { - return true; - } - if (child.isDirectory() && containsMarkdownFiles(child)) { - return true; - } + public static IResourcePack findResourcePack(ResourceLocation resourceLocation, + Iterable resourcePacks) { + var candidates = getCandidatesFor(resourceLocation); + if (candidates != null && !candidates.isEmpty()) return candidates.get(0) + .pack(); + if (indexReady) return null; + for (var pack : resourcePacks) { + try { + pack.getInputStream(resourceLocation) + .close(); + return pack; + } catch (IOException ignored) {} } - - return false; - } - - public static boolean isLanguageFolder(String name) { - return name.startsWith(LANGUAGE_FOLDER_PREFIX) && LangUtil.isLanguageCode(name.substring(1)); - } - - public static String toLanguageCode(String folderName) { - return LangUtil.normalizeLanguage(folderName.substring(LANGUAGE_FOLDER_PREFIX.length())); - } - - public static String autoDiscoveredDefaultLanguage() { - return LangUtil.ENGLISH_LANGUAGE; - } - - public static String toFolderPrefix(String namespace, String folder) { - return "assets/" + namespace + "/" + folder + "/"; - } - - public static String toLooseFolderPrefix(String namespace, String folder) { - return namespace + "/" + folder + "/"; + return null; } private static List guideRootCandidates(File resourcePackRoot, String namespace, String folder) { var candidates = new LinkedHashMap(3); - for (NamespaceRoot namespaceRoot : discoverNamespaceRoots(resourcePackRoot)) { - if (namespaceRoot.namespace() + for (NamespaceRoot nr : discoverNamespaceRoots(resourcePackRoot)) { + if (nr.namespace() .equals(namespace)) { - addGuideRootCandidates(candidates, namespaceRoot, folder); + addGuideRootCandidates(candidates, nr, folder); } } - addGuideRootCandidate(candidates, resourcePackRoot, toFolderPrefix(namespace, folder)); - addGuideRootCandidate(candidates, resourcePackRoot, toLooseFolderPrefix(namespace, folder)); + addGuideRootCandidate(candidates, resourcePackRoot, "assets/" + namespace + "/" + folder + "/"); + addGuideRootCandidate(candidates, resourcePackRoot, namespace + "/" + folder + "/"); if (folder.equals(namespace)) { addGuideRootCandidate(candidates, resourcePackRoot, folder + "/"); } @@ -868,96 +673,73 @@ private static void addGuideRootCandidates(LinkedHashMap candidates, private static void addGuideRootCandidate(LinkedHashMap candidates, File resourcePackRoot, String relativePath) { - var candidate = new File(resourcePackRoot, toNativePath(relativePath)); - if (!candidate.isDirectory()) { - return; + var candidate = new File(resourcePackRoot, relativePath.replace('/', File.separatorChar)); + if (candidate.isDirectory()) { + candidates.putIfAbsent( + candidate.toPath() + .toAbsolutePath() + .normalize(), + candidate); } - candidates.putIfAbsent( - candidate.toPath() - .toAbsolutePath() - .normalize(), - candidate); - } - - private static String toNativePath(String resourcePath) { - return resourcePath.replace('/', File.separatorChar); } private static List discoverNamespaceRoots(File resourcePackRoot) { - var roots = new LinkedHashMap(); + var byPath = new LinkedHashMap(); + var assetsDir = new File(resourcePackRoot, "assets"); - var assetNamespaceDirs = assetsDir.listFiles(File::isDirectory); - if (assetNamespaceDirs != null) { - for (var namespaceDir : assetNamespaceDirs) { - String namespace = namespaceFromDirectoryName(namespaceDir.getName()); - if (isValidNamespace(namespace)) { - addNamespaceRoot(roots, new NamespaceRoot(namespace, namespaceDir, false)); - } + var assetDirs = assetsDir.listFiles(File::isDirectory); + if (assetDirs != null) { + for (var dir : assetDirs) { + addNamespaceRoot(byPath, new NamespaceRoot(namespaceFromDirectoryName(dir.getName()), dir, false)); } } - for (NamespaceRoot namespaceRoot : discoverNativeNamespaceRoots(resourcePackRoot)) { - addNamespaceRoot(roots, namespaceRoot); - } - return List.copyOf(roots.values()); - } - - private static List discoverNativeNamespaceRoots(File resourcePackRoot) { - Path key = resourcePackRoot.toPath() + Path cacheKey = resourcePackRoot.toPath() .toAbsolutePath() .normalize(); - List cached = nativeNamespaceRootsCache.get(key); + List cached = nativeNamespaceRootsCache.get(cacheKey); if (cached != null) { - return cached; + for (var nr : cached) { + addNamespaceRoot(byPath, nr); + } + return List.copyOf(byPath.values()); } - var roots = new LinkedHashMap(); - var nativeNamespaceDirs = resourcePackRoot.listFiles(File::isDirectory); - if (nativeNamespaceDirs != null) { - for (var namespaceDir : nativeNamespaceDirs) { - if ("assets".equals(namespaceDir.getName())) { - continue; - } - String namespace = namespaceFromDirectoryName(namespaceDir.getName()); - if (isValidNamespace(namespace)) { - addNamespaceRoot(roots, new NamespaceRoot(namespace, namespaceDir, true)); - } + var nativeRoots = new ArrayList(); + var nativeDirs = resourcePackRoot.listFiles(File::isDirectory); + if (nativeDirs != null) { + for (var dir : nativeDirs) { + if ("assets".equals(dir.getName())) continue; + var nr = new NamespaceRoot(namespaceFromDirectoryName(dir.getName()), dir, true); + addNamespaceRoot(byPath, nr); + nativeRoots.add(nr); } } - List result = List.copyOf(roots.values()); - nativeNamespaceRootsCache.put(key, result); - return result; + nativeNamespaceRootsCache.put(cacheKey, List.copyOf(nativeRoots)); + return List.copyOf(byPath.values()); } - private static void addNamespaceRoot(LinkedHashMap roots, NamespaceRoot namespaceRoot) { + private static void addNamespaceRoot(LinkedHashMap roots, NamespaceRoot nr) { roots.putIfAbsent( - namespaceRoot.directory() + nr.directory() .toPath() .toAbsolutePath() .normalize(), - namespaceRoot); + nr); } private static String namespaceFromDirectoryName(String directoryName) { - if (isValidNamespace(directoryName)) { - return directoryName; - } + if (isValidNamespace(directoryName)) return directoryName; int openBracket = directoryName.lastIndexOf('['); - if (openBracket < 0 || !directoryName.endsWith("]")) { - return directoryName; - } + if (openBracket < 0 || !directoryName.endsWith("]")) return directoryName; return directoryName.substring(openBracket + 1, directoryName.length() - 1); } private static boolean isValidNamespace(String namespace) { - if (namespace == null || namespace.isEmpty()) { - return false; - } + if (namespace == null || namespace.isEmpty()) return false; for (int i = 0; i < namespace.length(); i++) { char ch = namespace.charAt(i); - if (ch >= 'a' && ch <= 'z' || ch >= '0' && ch <= '9' || ch == '_' || ch == '-' || ch == '.') { - continue; - } + if (ch >= 'a' && ch <= 'z' || ch >= '0' && ch <= '9' || ch == '_' || ch == '-' || ch == '.') continue; return false; } return true; @@ -965,41 +747,57 @@ private static boolean isValidNamespace(String namespace) { private static List toList(Iterable resourcePacks) { var result = new ArrayList(); - for (IResourcePack resourcePack : resourcePacks) { - result.add(resourcePack); - } + for (IResourcePack pack : resourcePacks) result.add(pack); return result; } - public static void clearCaches() { - lastGuideLanguageDiscovery = GuideLanguageDiscoverySnapshot.empty(); - nativeNamespaceRootsCache.clear(); + private static List resolvePackRoots(List packs) { + var roots = new ArrayList(packs.size()); + for (var pack : packs) { + File root = getLooseResourcePackRoot(pack); + if (root != null) roots.add(root); + } + return roots; } - private static Map> freezeDiscoveredLanguages( - Map> discoveredLanguages) { - if (discoveredLanguages.isEmpty()) { - return Map.of(); - } + private static Map> freezeLangKeys( + LinkedHashMap> keys) { + if (keys.isEmpty()) return Map.of(); + var frozen = new LinkedHashMap>(); + for (var entry : keys.entrySet()) frozen.put(entry.getKey(), Map.copyOf(entry.getValue())); + return Collections.unmodifiableMap(frozen); + } - var frozen = new LinkedHashMap>(discoveredLanguages.size()); + private static Map> freezeDiscoveredLanguages( + LinkedHashMap> discoveredLanguages) { + if (discoveredLanguages.isEmpty()) return Map.of(); + var frozen = new LinkedHashMap>(); for (var entry : discoveredLanguages.entrySet()) { frozen.put(entry.getKey(), Set.copyOf(entry.getValue())); } return Collections.unmodifiableMap(frozen); } - private record GuideLanguageDiscoverySnapshot(List resourcePacks, - Map> discoveredLanguages) { + @Deprecated + public static byte[] readLooseBytes(IResourcePack resourcePack, ResourceLocation resourceLocation) { + return null; + } - private static GuideLanguageDiscoverySnapshot empty() { - return new GuideLanguageDiscoverySnapshot(List.of(), Map.of()); - } + @Deprecated + public static void buildPageIndex(String folder) { + scanAndBuildAll(folder); + } - private boolean matches(List otherResourcePacks) { - return !resourcePacks.isEmpty() && resourcePacks.equals(otherResourcePacks); - } + @Deprecated + public static void buildPageIndex(String folder, Iterable packs) { + scanAndBuildAll(folder, packs); } - private record NamespaceRoot(String namespace, File directory, boolean allowDirectoryAsGuideRoot) {} + @Deprecated + public static @Nullable List getPacksFor(ResourceLocation loc) { + var candidates = pagePackIndex.get(loc); + return candidates != null ? candidates.stream() + .map(PackCandidate::pack) + .toList() : null; + } } diff --git a/src/main/java/com/hfstudio/guidenh/guide/internal/datadriven/GuidePageResourceSelector.java b/src/main/java/com/hfstudio/guidenh/guide/internal/datadriven/GuidePageResourceSelector.java index f58a1458..e25a8b65 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/internal/datadriven/GuidePageResourceSelector.java +++ b/src/main/java/com/hfstudio/guidenh/guide/internal/datadriven/GuidePageResourceSelector.java @@ -16,15 +16,52 @@ public class GuidePageResourceSelector { private GuidePageResourceSelector() {} - public static @Nullable SelectedPageResource select(ResourceLocation sourceId) { + /** + * Selects the best resource pack that contains the given resource location. + *

+ * Uses the pre-built reverse index for O(1) lookup. If the index is ready + * but the key is absent, returns null immediately (the resource is guaranteed + * not to exist in any indexed pack). + *

+ * Only falls back to a full scan if the index has not been built yet + * (e.g. during very early init). + */ + public static @Nullable SelectedPack select(ResourceLocation sourceId) { return select(sourceId, DataDrivenGuideLoader.getActiveResourcePacks()); } - public static @Nullable SelectedPageResource select(ResourceLocation sourceId, + public static @Nullable SelectedPack select(ResourceLocation sourceId, Iterable resourcePacks) { - SelectedPageResource winner = null; - int winnerPriority = 0; - boolean winnerPriorityResolved = false; + // O(1) index lookup + List candidates = DataDrivenGuideLoader.getCandidatesFor(sourceId); + if (candidates != null && !candidates.isEmpty()) { + DataDrivenGuideLoader.PackCandidate best = candidates.get(0); + for (int i = 1; i < candidates.size(); i++) { + if (candidates.get(i) + .shouldReplace(best)) { + best = candidates.get(i); + } + } + return new SelectedPack(sourceId, best.pack(), best.loadPriority()); + } + + // Index says it doesn't exist — fast null + if (DataDrivenGuideLoader.isIndexPopulated()) { + return null; + } + + // Index not built yet — emergency full scan + return selectFullScan(sourceId, resourcePacks); + } + + /** + * Full-scan fallback used only when the index hasn't been built yet. + * Reads bytes for comparison (loadPriority requires frontmatter parsing). + */ + private static @Nullable SelectedPack selectFullScan(ResourceLocation sourceId, + Iterable resourcePacks) { + SelectedPack winner = null; + byte[] winnerBytes = null; int order = 0; for (IResourcePack resourcePack : resourcePacks) { byte[] bytes = DataDrivenGuideLoader.readBytes(resourcePack, sourceId); @@ -32,95 +69,87 @@ private GuidePageResourceSelector() {} continue; } int candidateOrder = order++; + int candidatePriority = readLoadPriority(sourceId, bytes); if (winner == null) { - winner = new SelectedPageResource(sourceId, resourcePack, bytes, 0, candidateOrder); + winner = new SelectedPack(sourceId, resourcePack, candidatePriority); + winnerBytes = bytes; continue; } - if (!winnerPriorityResolved) { - winnerPriority = readLoadPriority(winner.sourceId(), winner.bytes()); - winner = winner.withLoadPriority(winnerPriority); - winnerPriorityResolved = true; - } - int candidatePriority = readLoadPriority(sourceId, bytes); - SelectedPageResource candidate = new SelectedPageResource( - sourceId, + DataDrivenGuideLoader.PackCandidate candidate = new DataDrivenGuideLoader.PackCandidate( resourcePack, - bytes, candidatePriority, candidateOrder); - if (candidate.shouldReplace(winner)) { - winner = candidate; - winnerPriority = candidatePriority; - winnerPriorityResolved = true; + DataDrivenGuideLoader.PackCandidate current = new DataDrivenGuideLoader.PackCandidate( + winner.pack(), + winner.loadPriority(), + order - 2); + if (candidate.shouldReplace(current)) { + winner = new SelectedPack(sourceId, resourcePack, candidatePriority); + winnerBytes = bytes; } } - if (winner != null && !winnerPriorityResolved) { - winner = winner.withLoadPriority(readLoadPriority(winner.sourceId(), winner.bytes())); - } return winner; } - public static @Nullable SelectedPageResource selectFirstPresent(Iterable resourcePacks, + /** + * Selects the first resource location found from the given candidates. + * Used by the editor and runtime navigation where the caller has a + * localized → default → raw fallback chain. + *

+ * This does NOT use the index — it does a targeted scan of only the given + * candidate IDs. For bulk page loading during reload, use {@link #select} + * instead. + */ + public static @Nullable SelectedPack selectFirstPresent(Iterable resourcePacks, ResourceLocation... sourceIds) { if (sourceIds == null || sourceIds.length == 0) { return null; } - var winners = new SelectedPageResource[sourceIds.length]; - var winnerPriorities = new int[sourceIds.length]; - var winnerPriorityResolved = new boolean[sourceIds.length]; - var orders = new int[sourceIds.length]; - for (IResourcePack resourcePack : resourcePacks) { - for (int i = 0; i < sourceIds.length; i++) { - ResourceLocation sourceId = sourceIds[i]; - if (sourceId == null) { - continue; - } - byte[] bytes = DataDrivenGuideLoader.readBytes(resourcePack, sourceId); - if (bytes == null) { - continue; - } - int candidateOrder = orders[i]++; - if (winners[i] == null) { - winners[i] = new SelectedPageResource(sourceId, resourcePack, bytes, 0, candidateOrder); - continue; - } - if (!winnerPriorityResolved[i]) { - winnerPriorities[i] = readLoadPriority(winners[i].sourceId(), winners[i].bytes()); - winners[i] = winners[i].withLoadPriority(winnerPriorities[i]); - winnerPriorityResolved[i] = true; - } - int candidatePriority = readLoadPriority(sourceId, bytes); - SelectedPageResource candidate = new SelectedPageResource( - sourceId, - resourcePack, - bytes, - candidatePriority, - candidateOrder); - if (candidate.shouldReplace(winners[i])) { - winners[i] = candidate; - winnerPriorities[i] = candidatePriority; - winnerPriorityResolved[i] = true; + + // Fast path: try index first + if (DataDrivenGuideLoader.isIndexPopulated()) { + for (ResourceLocation sourceId : sourceIds) { + if (sourceId == null) continue; + var candidates = DataDrivenGuideLoader.getCandidatesFor(sourceId); + if (candidates != null && !candidates.isEmpty()) { + return new SelectedPack( + sourceId, + candidates.get(0) + .pack(), + candidates.get(0) + .loadPriority()); } } + return null; } - for (int i = 0; i < winners.length; i++) { - SelectedPageResource winner = winners[i]; - if (winner != null) { - if (!winnerPriorityResolved[i]) { - winner = winner.withLoadPriority(readLoadPriority(winner.sourceId(), winner.bytes())); - winners[i] = winner; + + // Slow path: full scan + return selectFirstPresentFullScan(resourcePacks, sourceIds); + } + + private static @Nullable SelectedPack selectFirstPresentFullScan(Iterable resourcePacks, + ResourceLocation... sourceIds) { + for (IResourcePack resourcePack : resourcePacks) { + for (int i = 0; i < sourceIds.length; i++) { + ResourceLocation sourceId = sourceIds[i]; + if (sourceId == null) continue; + if (DataDrivenGuideLoader.readBytes(resourcePack, sourceId) != null) { + return new SelectedPack(sourceId, resourcePack, 0); } - return winner; } } return null; } - public static @Nullable SelectedPageResource selectFirstPresent(List resourcePacks, + public static @Nullable SelectedPack selectFirstPresent(List resourcePacks, ResourceLocation... sourceIds) { return selectFirstPresent((Iterable) resourcePacks, sourceIds); } + /** + * Parses loadPriority from frontmatter for a given page's bytes. + * Used during full-scan fallback and by MediaWikiSpecialDataIndexer. + */ public static int readLoadPriority(ResourceLocation sourceId, byte[] bytes) { String source = new String(bytes, StandardCharsets.UTF_8); String yamlText = PageCompiler.extractFrontmatterText(PageCompiler.normalizeLineEndings(stripBom(source))); @@ -137,9 +166,23 @@ public static int readLoadPriority(ResourceLocation sourceId, byte[] bytes) { } private static String stripBom(String source) { - return source.startsWith("\uFEFF") ? source.substring(1) : source; + return source.startsWith("") ? source.substring(1) : source; } + /** + * A resource location found in a specific resource pack. + *

+ * Unlike the old {@code SelectedPageResource}, this does NOT carry the page bytes — + * the caller is expected to call {@link DataDrivenGuideLoader#readBytes} separately. + */ + @Desugar + public record SelectedPack(ResourceLocation sourceId, IResourcePack pack, int loadPriority) {} + + /** + * @deprecated Use {@link SelectedPack} instead. Bytes are no longer included; + * read them separately via {@link DataDrivenGuideLoader#readBytes}. + */ + @Deprecated @Desugar public record SelectedPageResource(ResourceLocation sourceId, IResourcePack resourcePack, byte[] bytes, int loadPriority, int order) { diff --git a/src/main/java/com/hfstudio/guidenh/guide/internal/debug/DebugControlPanel.java b/src/main/java/com/hfstudio/guidenh/guide/internal/debug/DebugControlPanel.java index 66439f65..f5e07f90 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/internal/debug/DebugControlPanel.java +++ b/src/main/java/com/hfstudio/guidenh/guide/internal/debug/DebugControlPanel.java @@ -85,6 +85,10 @@ private void initializeMenu() { new DebugMenuItem("guidenh.debug.menu.display_options.show_memory", DebugMenuAction.TOGGLE_MEMORY)); displayOptions.addSubmenuItem( new DebugMenuItem("guidenh.debug.menu.display_options.show_mouse", DebugMenuAction.TOGGLE_MOUSE_POSITION)); + displayOptions.addSubmenuItem( + new DebugMenuItem( + "guidenh.debug.menu.display_options.layout_overlay", + DebugMenuAction.TOGGLE_LAYOUT_OVERLAY)); menuItems.add(displayOptions); DebugMenuItem recompile = new DebugMenuItem( @@ -259,6 +263,7 @@ private void executeAction(DebugMenuAction action) { case TOGGLE_FPS -> ModConfig.debug.showFps = !ModConfig.debug.showFps; case TOGGLE_MEMORY -> ModConfig.debug.showMemory = !ModConfig.debug.showMemory; case TOGGLE_MOUSE_POSITION -> ModConfig.debug.showMousePosition = !ModConfig.debug.showMousePosition; + case TOGGLE_LAYOUT_OVERLAY -> ModConfig.debug.layoutOverlay = !ModConfig.debug.layoutOverlay; case RECOMPILE_PAGE -> recompilePage(); case EXPORT_DEBUG_DATA -> exportDebugData(); } @@ -281,6 +286,7 @@ private boolean getCheckState(DebugMenuAction action) { case TOGGLE_FPS -> ModConfig.debug.showFps; case TOGGLE_MEMORY -> ModConfig.debug.showMemory; case TOGGLE_MOUSE_POSITION -> ModConfig.debug.showMousePosition; + case TOGGLE_LAYOUT_OVERLAY -> ModConfig.debug.layoutOverlay; default -> false; }; } diff --git a/src/main/java/com/hfstudio/guidenh/guide/internal/debug/DebugMenuAction.java b/src/main/java/com/hfstudio/guidenh/guide/internal/debug/DebugMenuAction.java index 5c437c69..2e3da099 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/internal/debug/DebugMenuAction.java +++ b/src/main/java/com/hfstudio/guidenh/guide/internal/debug/DebugMenuAction.java @@ -20,6 +20,7 @@ public enum DebugMenuAction { TOGGLE_FPS, TOGGLE_MEMORY, TOGGLE_MOUSE_POSITION, + TOGGLE_LAYOUT_OVERLAY, RECOMPILE_PAGE, EXPORT_DEBUG_DATA } diff --git a/src/main/java/com/hfstudio/guidenh/guide/internal/editor/guide/GuideScreenEditorFileStore.java b/src/main/java/com/hfstudio/guidenh/guide/internal/editor/guide/GuideScreenEditorFileStore.java index aefc3ef1..2a13a5af 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/internal/editor/guide/GuideScreenEditorFileStore.java +++ b/src/main/java/com/hfstudio/guidenh/guide/internal/editor/guide/GuideScreenEditorFileStore.java @@ -7,7 +7,6 @@ import java.nio.file.Path; import net.minecraft.client.Minecraft; -import net.minecraft.client.resources.IResourcePack; import net.minecraft.util.ResourceLocation; import org.jetbrains.annotations.Nullable; @@ -151,7 +150,7 @@ private Path resolveExistingWritablePagePath(MutableGuide guide, ResourceLocatio private Path resolveExistingWritableSelectedSourcePath(MutableGuide guide, ResourceLocation pageId, String language) { var resourcePacks = DataDrivenGuideLoader.getActiveResourcePacks(); - GuidePageResourceSelector.SelectedPageResource selected = GuidePageResourceSelector.selectFirstPresent( + GuidePageResourceSelector.SelectedPack selected = GuidePageResourceSelector.selectFirstPresent( resourcePacks, toResourcePackPageId(guide, pageId, language), language != null && !language.equals(guide.getDefaultLanguage()) @@ -161,7 +160,7 @@ private Path resolveExistingWritableSelectedSourcePath(MutableGuide guide, Resou if (selected == null) { return null; } - File resourcePackFile = DataDrivenGuideLoader.getResourcePackFile(selected.resourcePack()); + File resourcePackFile = DataDrivenGuideLoader.getResourcePackFile(selected.pack()); if (resourcePackFile == null || !resourcePackFile.isDirectory()) { return null; } @@ -202,13 +201,10 @@ private Path findWritableResourcePackRootContaining(MutableGuide guide, Resource @Nullable private Path findWritableResourcePackRootContainingAsset(ResourceLocation... assetIds) { var resourcePacks = DataDrivenGuideLoader.getActiveResourcePacks(); - GuidePageResourceSelector.SelectedPageResource selected = GuidePageResourceSelector + GuidePageResourceSelector.SelectedPack selected = GuidePageResourceSelector .selectFirstPresent(resourcePacks, assetIds); - if (selected == null) { - return null; - } - IResourcePack resourcePack = selected.resourcePack(); - File resourcePackFile = DataDrivenGuideLoader.getResourcePackFile(resourcePack); + if (selected == null) return null; + File resourcePackFile = DataDrivenGuideLoader.getResourcePackFile(selected.pack()); if (resourcePackFile == null || !resourcePackFile.isDirectory()) { return null; } diff --git a/src/main/java/com/hfstudio/guidenh/guide/internal/extensions/DefaultExtensions.java b/src/main/java/com/hfstudio/guidenh/guide/internal/extensions/DefaultExtensions.java index fc10c43f..3e18350c 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/internal/extensions/DefaultExtensions.java +++ b/src/main/java/com/hfstudio/guidenh/guide/internal/extensions/DefaultExtensions.java @@ -40,6 +40,7 @@ import com.hfstudio.guidenh.guide.compiler.tags.ListItemCompiler; import com.hfstudio.guidenh.guide.compiler.tags.MarkTagCompiler; import com.hfstudio.guidenh.guide.compiler.tags.MermaidCompiler; +import com.hfstudio.guidenh.guide.compiler.tags.NodeContentTagCompiler; import com.hfstudio.guidenh.guide.compiler.tags.ParagraphCompiler; import com.hfstudio.guidenh.guide.compiler.tags.PlayerNameTagCompiler; import com.hfstudio.guidenh.guide.compiler.tags.PreCompiler; @@ -148,6 +149,7 @@ public static List tagCompilers() { new FootnoteListCompiler(), new StructureViewCompiler(), new MermaidCompiler(), + new NodeContentTagCompiler(), new CsvTableCompiler(), new ColumnChartCompiler(), new BarChartCompiler(), diff --git a/src/main/java/com/hfstudio/guidenh/guide/internal/headless/DocumentOffscreenFramebuffer.java b/src/main/java/com/hfstudio/guidenh/guide/internal/headless/DocumentOffscreenFramebuffer.java new file mode 100644 index 00000000..27f56b86 --- /dev/null +++ b/src/main/java/com/hfstudio/guidenh/guide/internal/headless/DocumentOffscreenFramebuffer.java @@ -0,0 +1,289 @@ +package com.hfstudio.guidenh.guide.internal.headless; + +import java.awt.Color; +import java.awt.Graphics2D; +import java.awt.RenderingHints; +import java.awt.image.BufferedImage; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.List; + +import net.minecraft.client.Minecraft; +import net.minecraft.client.shader.Framebuffer; + +import org.lwjgl.BufferUtils; +import org.lwjgl.opengl.GL11; + +import com.hfstudio.guidenh.guide.document.LytRect; +import com.hfstudio.guidenh.guide.render.GuideGlyphAtlas; +import com.hfstudio.guidenh.guide.render.GuideRenderEngine; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.GuidebookSceneRenderer; +import com.hfstudio.guidenh.guide.render.VanillaRenderContext; +import com.hfstudio.guidenh.guide.scene.GuidebookLevelRenderer; + +/** + * Renders a list of already-laid-out document primitives to an offscreen FBO and + * reads back a {@link BufferedImage}. When the total height exceeds + * {@code GL_MAX_TEXTURE_SIZE}, the document is split into tiles and composited. + * + *

This class does not perform layout — the caller is responsible for + * laying out the document at the full render resolution and collecting primitives + * via {@link com.hfstudio.guidenh.guide.render.PrimitiveCollector#result()}. + * Each tile translates the viewport origin (camera pan equivalent) so that + * the portion of the document starting at {@code (tileX, tileY)} is rendered + * into the tile's framebuffer. + */ +public final class DocumentOffscreenFramebuffer { + + private static final int MAX_TILE_SIZE_CAP = 4096; + /** 16384 * 4 */ + private static final int MAX_TOTAL_DIMENSION = 65536; + + private DocumentOffscreenFramebuffer() { + } + + /** + * Renders the given primitives at the specified total dimensions, tiling + * transparently when the document exceeds {@code GL_MAX_TEXTURE_SIZE}. + * + * @param primitives the already-collected primitives in document coordinates. + * @param context the render context whose document origin is adjusted per + * tile (affects HostDraw callbacks). + * @param totalWidth full document width in document units (must be positive). + * @param totalHeight full document height in document units (must be positive). + * @param backgroundRgb opaque background colour packed as 0xRRGGBB. + * @param scale pixel-density multiplier (1-4). Output dimensions are + * totalWidth × scale by totalHeight × scale. + * @return a fully composited opaque {@code BufferedImage} of the document. + * @throws IllegalArgumentException if dimensions are out of range. + * @throws IllegalStateException if the Minecraft client is not ready. + * @throws RuntimeException if any tile fails to render (FBO is cleaned + * up before rethrowing). + */ + public static BufferedImage renderAll( + List primitives, + VanillaRenderContext context, + int totalWidth, + int totalHeight, + int backgroundRgb, + int scale) { + + // ---- dimension validation ------------------------------------------- + if (totalWidth <= 0 || totalHeight <= 0) { + throw new IllegalArgumentException( + "totalWidth and totalHeight must be positive: " + totalWidth + " x " + totalHeight); + } + + // Scale pixel dimensions + int pxWidth = totalWidth * scale; + int pxHeight = totalHeight * scale; + + if (pxWidth > MAX_TOTAL_DIMENSION || pxHeight > MAX_TOTAL_DIMENSION) { + throw new IllegalArgumentException( + "Pixel dimensions exceed maximum " + MAX_TOTAL_DIMENSION + ": " + + pxWidth + " x " + pxHeight); + } + + Minecraft minecraft = Minecraft.getMinecraft(); + if (minecraft == null || minecraft.gameSettings == null) { + throw new IllegalStateException("Minecraft client is not ready for offscreen rendering."); + } + + // ---- tile size ------------------------------------------------------ + int maxFboSize = GL11.glGetInteger(GL11.GL_MAX_TEXTURE_SIZE); + if (maxFboSize <= 0) { + maxFboSize = 8192; // safe fallback + } + int tileSize = Math.min(maxFboSize, MAX_TILE_SIZE_CAP); + + // ---- render engine (shared across tiles) ---------------------------- + GuideRenderEngine engine = new GuideRenderEngine( + GuideGlyphAtlas.instance(), + new GuidebookSceneRenderer()); + + // ---- output image (scaled pixel dimensions) ------------------------- + BufferedImage output = new BufferedImage(pxWidth, pxHeight, BufferedImage.TYPE_INT_ARGB); + Graphics2D outputG = output.createGraphics(); + outputG.setRenderingHint( + RenderingHints.KEY_INTERPOLATION, + RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR); + + boolean prevSkipLightmap = GuidebookLevelRenderer.skipLightmapForOffscreen; + GuidebookLevelRenderer.skipLightmapForOffscreen = true; + + try { + int prevDisplayWidth = minecraft.displayWidth; + int prevDisplayHeight = minecraft.displayHeight; + int prevGuiScale = minecraft.gameSettings.guiScale; + context.setZoom(scale); + + // ---- tile loop (in pixel space, scaled) ------------------------- + for (int tileY = 0; tileY < pxHeight; tileY += tileSize) { + int tileH = Math.min(tileSize, pxHeight - tileY); + for (int tileX = 0; tileX < pxWidth; tileX += tileSize) { + int tileW = Math.min(tileSize, pxWidth - tileX); + + Framebuffer fb = null; + boolean projectionPushed = false; + boolean modelviewPushed = false; + + try { + fb = new Framebuffer(tileW, tileH, true); + fb.setFramebufferColor(0f, 0f, 0f, 0f); + + minecraft.displayWidth = tileW; + minecraft.displayHeight = tileH; + minecraft.gameSettings.guiScale = 1; + + fb.bindFramebuffer(true); + + // Set up 2D orthographic projection for the tile dimensions + // (Vanilla GUI rendering relies on this, just like ItemPreviewService). + GL11.glMatrixMode(GL11.GL_PROJECTION); + GL11.glPushMatrix(); + projectionPushed = true; + GL11.glLoadIdentity(); + GL11.glOrtho(0.0D, tileW, tileH, 0.0D, 1000.0D, 3000.0D); + + GL11.glMatrixMode(GL11.GL_MODELVIEW); + GL11.glPushMatrix(); + modelviewPushed = true; + GL11.glLoadIdentity(); + GL11.glTranslatef(0.0F, 0.0F, -2000.0F); + + // Clear with the opaque background colour + float r = ((backgroundRgb >> 16) & 0xFF) / 255f; + float g = ((backgroundRgb >> 8) & 0xFF) / 255f; + float b = (backgroundRgb & 0xFF) / 255f; + GL11.glClearColor(r, g, b, 1f); + GL11.glClear(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT); + + // Shift document origin so HostDraw callbacks see the tile offset + // Document-origin callback: pixel units (-tileX, -tileY) + context.setDocumentOrigin(-tileX, -tileY); + + // Wrap primitives with scale + tile-offset transforms: + // outer: PushTransform(0, 0, scale) — scales doc coords by N× + // inner: PushTransform(-tileX/scale, -tileY/scale, 1.0f) — tile offset + // in doc space, which after parent-scaling becomes -tileX, -tileY + // Combined: screen = doc * scale + (-tileX, -tileY) + List wrapped = wrapForTile(primitives, tileX, tileY, scale); + + engine.beginFrame(new LytRect(0, 0, tileW, tileH), 1.0f); + engine.execute(wrapped); + engine.endFrame(); + + // Read pixels (Y-flip to Java top-down) + BufferedImage tile = readPixels(tileW, tileH); + outputG.drawImage(tile, tileX, tileY, null); + + } catch (RuntimeException e) { + throw e; + } catch (Exception e) { + throw new RuntimeException("Tile rendering failed at offset (" + tileX + ", " + tileY + ")", e); + } finally { + // Restore matrices in reverse order + if (modelviewPushed) { + GL11.glMatrixMode(GL11.GL_MODELVIEW); + GL11.glPopMatrix(); + } + if (projectionPushed) { + GL11.glMatrixMode(GL11.GL_PROJECTION); + GL11.glPopMatrix(); + GL11.glMatrixMode(GL11.GL_MODELVIEW); + } + // Release FBO resources + if (fb != null) { + fb.unbindFramebuffer(); + fb.deleteFramebuffer(); + } + // Restore original display dimensions + minecraft.displayWidth = prevDisplayWidth; + minecraft.displayHeight = prevDisplayHeight; + minecraft.gameSettings.guiScale = prevGuiScale; + GL11.glViewport(0, 0, prevDisplayWidth, prevDisplayHeight); + } + } + } + } finally { + GuidebookLevelRenderer.skipLightmapForOffscreen = prevSkipLightmap; + outputG.dispose(); + } + + // ---- opaque background composite ------------------------------------ + return compositeOpaque(output, backgroundRgb); + } + + // ---- helper: primitive list wrapping ------------------------------------ + + /** + * Wraps the original primitive list with: + *

    + *
  1. Outer {@link PushTransform}(0, 0, scale) — scales document coordinates + * by N× for pixel-density amplification.
    2. + *
  2. Inner {@link PushTransform}(-tileX/scale, -tileY/scale, 1.0f) — tile + * offset in document space. The engine's composition applies parent + * scale to child translation, yielding effective offset + * {@code (-tileX, -tileY)} in the scaled pixel space.
    3. + *
+ * + *

Combined effective transform: + * {@code screen = doc * scale + (-tileX, -tileY)}. + * + *

Tile coordinates are in pixel (scaled) space; the inner translation + * divides by scale so the tile-border crossing matches document units. + */ + private static List wrapForTile( + List primitives, + int tileX, + int tileY, + int scale) { + List wrapped = new ArrayList<>(primitives.size() + 4); + // Outer: scale document coordinates + wrapped.add(new GuideRenderPrimitive.PushTransform(0f, 0f, (float) scale)); + // Inner: tile offset in document space + wrapped.add(new GuideRenderPrimitive.PushTransform( + (float) -tileX / scale, (float) -tileY / scale, 1.0f)); + wrapped.addAll(primitives); + wrapped.add(new GuideRenderPrimitive.PopTransform()); + wrapped.add(new GuideRenderPrimitive.PopTransform()); + return wrapped; + } + + // ---- helper: read pixels from currently bound FBO ----------------------- + + private static BufferedImage readPixels(int width, int height) { + ByteBuffer buffer = BufferUtils.createByteBuffer(width * height * 4); + GL11.glReadPixels(0, 0, width, height, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, buffer); + + BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB); + for (int y = 0; y < height; y++) { + int flippedY = height - 1 - y; + for (int x = 0; x < width; x++) { + int index = (x + y * width) * 4; + int r = buffer.get(index) & 0xFF; + int g = buffer.get(index + 1) & 0xFF; + int b = buffer.get(index + 2) & 0xFF; + int a = buffer.get(index + 3) & 0xFF; + image.setRGB(x, flippedY, (a << 24) | (r << 16) | (g << 8) | b); + } + } + return image; + } + + // ---- helper: composite onto opaque background --------------------------- + + private static BufferedImage compositeOpaque(BufferedImage source, int backgroundRgb) { + BufferedImage image = new BufferedImage(source.getWidth(), source.getHeight(), BufferedImage.TYPE_INT_RGB); + Graphics2D g = image.createGraphics(); + try { + g.setColor(new Color(backgroundRgb)); + g.fillRect(0, 0, source.getWidth(), source.getHeight()); + g.drawImage(source, 0, 0, null); + } finally { + g.dispose(); + } + return image; + } +} diff --git a/src/main/java/com/hfstudio/guidenh/guide/internal/headless/GuideNhHeadlessRenderDriver.java b/src/main/java/com/hfstudio/guidenh/guide/internal/headless/GuideNhHeadlessRenderDriver.java new file mode 100644 index 00000000..dd686a72 --- /dev/null +++ b/src/main/java/com/hfstudio/guidenh/guide/internal/headless/GuideNhHeadlessRenderDriver.java @@ -0,0 +1,677 @@ +package com.hfstudio.guidenh.guide.internal.headless; + +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.InvalidPathException; +import java.nio.file.Paths; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.List; +import java.util.stream.Collectors; + +import net.minecraft.client.Minecraft; +import net.minecraft.client.gui.GuiMainMenu; +import net.minecraft.util.ResourceLocation; +import net.minecraft.world.WorldSettings; +import net.minecraft.world.WorldType; + +import org.jetbrains.annotations.Nullable; + +import com.hfstudio.guidenh.guide.compiler.ParsedGuidePage; +import com.hfstudio.guidenh.guide.internal.GuideRegistry; +import com.hfstudio.guidenh.guide.internal.MutableGuide; +import com.hfstudio.guidenh.guide.mediawiki.MediaWikiListContext; +import com.hfstudio.guidenh.guide.mediawiki.MediaWikiSpecialDataIndex; +import com.hfstudio.guidenh.guide.scene.support.GuideDebugLog; + +import cpw.mods.fml.common.FMLCommonHandler; +import cpw.mods.fml.common.eventhandler.SubscribeEvent; +import cpw.mods.fml.common.gameevent.TickEvent; + +/** + * Headless screenshot render driver activated by {@code -Dguidenh.headlessRender=true}. + * + *

State machine (driven by {@link TickEvent.ClientTickEvent}): + *

    + *
  1. {@code IDLE} — wait for main menu, then close screen, launch integrated server
    2. + *
  2. {@code LOADING_WORLD} — poll until {@code theWorld / thePlayer / netHandler} are non-null
    3. + *
  3. {@code WORLD_STABLE} — wait 20 ticks, then start rendering
    4. + *
  4. {@code RENDERING} — render page(s): single page or batch loop + *
      + *
    • Single-page mode ({@code --page} / {@code --md}): render + {@code exitJava(0|1)}
      • + *
    • Batch mode ({@code --allPages} / {@code --list}): loop all pages, then summary + {@code exitJava(0|1)}
      • + *
    + *
    5. + *
  5. {@code DONE} — guard against re-entry
    6. + *
+ * + *

Batch mode properties (mutually exclusive with {@code --page} / {@code --md}): + *

    + *
  • {@code -Dguidenh.renderpage.allPages=true} — render every page of the guide in sorted order
    • + *
  • {@code -Dguidenh.renderpage.list=<txt-path>} — one pageId per line; empty lines and + * {@code #}-prefixed lines are skipped
    • + *
+ * + *

Batch summary is printed to stdout and log: {@code total / ok / failed} plus failed-page list. + * Exit code: {@code 0} when all succeeded, {@code 1} on any failure. + * + *

Watchdog: default 360 s timeout for single-page mode; for batch mode the timeout is + * {@code 360 + 120 × pageCount} seconds, computed once when the page list is known. + * Limitation: rendering executes synchronously on the client tick thread. If a single page + * render hangs, the watchdog cannot interrupt it — it can only fire before or after that page + * completes. + * + *

All errors → {@code exitJava(1)}. Never swallow exceptions. + * + * @see RenderPageService + */ +public class GuideNhHeadlessRenderDriver { + + // ---- config -------------------------------------------------------------- + + /** + * Max time (ms) to block before the first headless page render for the MediaWiki + * special-data index warmup (scheduled asynchronously by MutableGuide) to complete. + * Bounded so a stuck warmup worker can never hang the headless render forever; + * on timeout we log a warning and continue. + */ + private static final long MEDIA_WIKI_WARMUP_TIMEOUT_MILLIS = 30_000L; + + /** Poll interval (ms) while waiting for the MediaWiki warmup worker. */ + private static final long MEDIA_WIKI_WARMUP_POLL_MILLIS = 25L; + + /** Immutable snapshot of JVM property configuration. */ + public record HeadlessRenderConfig( + String guideId, + @Nullable String pageId, + @Nullable Path mdFile, + boolean allPages, + @Nullable Path listPath, + int width, + Path outDir, + String language, + boolean emitBoundsJson, + boolean emitDebugOverlay, + String worldName, + int scale, + boolean chrome + ) {} + + // ---- state machine ------------------------------------------------------- + + private enum State { IDLE, LOADING_WORLD, WORLD_STABLE, RENDERING, DONE } + + private State state = State.IDLE; + private final HeadlessRenderConfig config; + private long watchdogDeadlineNanos; + private int stableTickCount = 0; + private boolean renderPending = false; + + // ---- batch state --------------------------------------------------------- + + /** Ordered list of page IDs to render (batch mode). */ + private List batchPageIds = Collections.emptyList(); + private int pageIndex = 0; + private int okCount = 0; + private int failCount = 0; + private final List failedPageIds = new ArrayList<>(); + + // ---- construction -------------------------------------------------------- + + public GuideNhHeadlessRenderDriver(HeadlessRenderConfig config) { + this.config = config; + this.watchdogDeadlineNanos = System.nanoTime() + 360_000_000_000L; + if (config.chrome()) { + GuideDebugLog.infoAlways( + "[GuideNH] [HeadlessRender] chrome pass enabled: nav bar will be appended to page renders"); + } + } + + // ---- property parsing ---------------------------------------------------- + + /** + * Parse all relevant JVM properties into a {@link HeadlessRenderConfig}. + * + * @return parsed config, or {@code null} if any required property is missing or invalid + */ + @Nullable + public static HeadlessRenderConfig parseConfig() { + String guideId = System.getProperty("guidenh.renderpage.guide"); + if (guideId == null || guideId.isEmpty()) { + logError("Missing required property: -Dguidenh.renderpage.guide="); + return null; + } + + String pageId = System.getProperty("guidenh.renderpage.page"); + String mdProp = System.getProperty("guidenh.renderpage.md"); + String allPagesProp = System.getProperty("guidenh.renderpage.allPages"); + String listProp = System.getProperty("guidenh.renderpage.list"); + + boolean hasPage = pageId != null && !pageId.isEmpty(); + boolean hasMd = mdProp != null && !mdProp.isEmpty(); + boolean allPages = "true".equalsIgnoreCase(allPagesProp); + boolean hasList = listProp != null && !listProp.isEmpty(); + + // Mutually exclusive groups: single-page (page/md) vs batch (allPages/list) + int singleModes = (hasPage ? 1 : 0) + (hasMd ? 1 : 0); + int batchModes = (allPages ? 1 : 0) + (hasList ? 1 : 0); + + if (singleModes > 0 && batchModes > 0) { + logError("Batch mode (-Dguidenh.renderpage.allPages / --list) and single-page mode " + + "(-Dguidenh.renderpage.page / --md) are mutually exclusive"); + return null; + } + if (batchModes > 1) { + logError("Only one batch mode allowed: -Dguidenh.renderpage.allPages OR " + + "-Dguidenh.renderpage.list, not both"); + return null; + } + if (batchModes == 0 && singleModes == 0) { + logError("Specify single-page mode (-Dguidenh.renderpage.page= or " + + "-Dguidenh.renderpage.md=) or batch mode " + + "(-Dguidenh.renderpage.allPages=true or -Dguidenh.renderpage.list=)"); + return null; + } + + int width; + try { + width = Integer.parseInt(System.getProperty("guidenh.renderpage.width", "900")); + } catch (NumberFormatException e) { + logError("Invalid width value: " + System.getProperty("guidenh.renderpage.width")); + return null; + } + if (width < 100 || width > 4096) { + logError("Width must be between 100 and 4096, got: " + width); + return null; + } + + String outProp = System.getProperty("guidenh.renderpage.out"); + Path outDir; + if (outProp != null && !outProp.isEmpty()) { + outDir = Paths.get(outProp); + } else { + Minecraft mc = Minecraft.getMinecraft(); + if (mc == null || mc.mcDataDir == null) { + logError("Cannot determine default output directory: Minecraft instance not available"); + return null; + } + outDir = mc.mcDataDir.toPath().resolve("screenshots"); + } + + String lang = System.getProperty("guidenh.renderpage.lang", "en_us"); + boolean bounds = Boolean.parseBoolean(System.getProperty("guidenh.renderpage.bounds", "false")); + boolean overlay = Boolean.parseBoolean(System.getProperty("guidenh.renderpage.overlay", "false")); + String worldName = System.getProperty("guidenh.renderpage.world", "screenshot-world"); + + int scale; + try { + scale = Integer.parseInt(System.getProperty("guidenh.renderpage.scale", "1")); + } catch (NumberFormatException e) { + logError("Invalid scale value: " + System.getProperty("guidenh.renderpage.scale")); + return null; + } + if (scale < 1 || scale > 4) { + logError("Scale must be between 1 and 4, got: " + scale); + return null; + } + + boolean chrome = Boolean.parseBoolean(System.getProperty("guidenh.renderpage.chrome", "false")); + + Path mdPath = null; + Path listPath = null; + try { + mdPath = hasMd ? Paths.get(mdProp) : null; + listPath = hasList ? Paths.get(listProp) : null; + } catch (InvalidPathException e) { + // NOTE: --md / --list expect FILE PATHS (list = file with one pageId per line), + // not page ids. Page ids contain ':' which is an illegal Windows path char and + // previously blew up here as an unlogged InvalidPathException that FML's state + // event dispatch swallowed silently, hanging the client at the main menu. + logError("Invalid file path for -Dguidenh.renderpage.md / --list: " + e.getMessage() + + " (note: --list expects a path to a file containing one pageId per line)"); + return null; + } + + return new HeadlessRenderConfig( + guideId, + hasPage ? pageId : null, + mdPath, + allPages, + listPath, + width, + outDir, + lang, + bounds, + overlay, + worldName, + scale, + chrome + ); + } + + private static void logError(String message) { + GuideDebugLog.error("[GuideNH] [HeadlessRender] {}", message); + System.err.println("[GuideNH] [HeadlessRender] " + message); + } + + // ---- tick handler -------------------------------------------------------- + + @SubscribeEvent + public void onClientTick(TickEvent.ClientTickEvent event) { + if (event.phase != TickEvent.Phase.END) { + return; + } + + // Watchdog: default 360s; batch mode recalculates when page list is known + if (System.nanoTime() > watchdogDeadlineNanos) { + GuideDebugLog.error("[GuideNH] [HeadlessRender] headless render timeout exceeded"); + FMLCommonHandler.instance().exitJava(2, false); + return; + } + + if (state == State.DONE) { + return; + } + + try { + tick(); + } catch (Throwable t) { + GuideDebugLog.error("[GuideNH] [HeadlessRender] Unhandled exception in state machine", t); + System.err.println("[GuideNH] [HeadlessRender] Unhandled exception: " + t.getMessage()); + FMLCommonHandler.instance().exitJava(1, false); + } + } + + private void tick() { + Minecraft mc = Minecraft.getMinecraft(); + if (mc == null) { + return; + } + + switch (state) { + case IDLE -> handleIdle(mc); + case LOADING_WORLD -> handleLoadingWorld(mc); + case WORLD_STABLE -> handleWorldStable(mc); + case RENDERING -> { + // Rendering is performed in onRenderTick; ClientTick only handles watchdog. + } + default -> {} + } + } + + // ---- state handlers ------------------------------------------------------ + + private void handleIdle(Minecraft mc) { + if (!(mc.currentScreen instanceof GuiMainMenu)) { + return; + } + + state = State.LOADING_WORLD; + GuideDebugLog.infoAlways( + "[GuideNH] [HeadlessRender] Starting integrated server (world: {})", + config.worldName()); + + mc.displayGuiScreen(null); + WorldSettings settings = new WorldSettings( + 0L, WorldSettings.GameType.CREATIVE, false, false, WorldType.FLAT); + mc.launchIntegratedServer(config.worldName(), config.worldName(), settings); + } + + private void handleLoadingWorld(Minecraft mc) { + if (mc.theWorld != null && mc.thePlayer != null && mc.getNetHandler() != null) { + state = State.WORLD_STABLE; + stableTickCount = 0; + GuideDebugLog.infoAlways( + "[GuideNH] [HeadlessRender] World loaded, waiting 20 ticks for stability"); + } + } + + private void handleWorldStable(Minecraft mc) { + stableTickCount++; + if (stableTickCount < 20) { + return; + } + + // Both batch and single-page modes must not render before the async MediaWiki + // special-data warmup is ready: Special pages compile against the guide's + // MediaWikiListContext, and a not-yet-warmed guide serves an empty fallback + // (MediaWikiSpecialDataIndex.empty()), which renders as an empty 96 px page. + awaitMediaWikiWarmup(); + + if (config.allPages() || config.listPath() != null) { + // ---- batch mode: prepare, then let handleRendering loop ----------- + List ids; + try { + ids = collectBatchPageIds(); + } catch (Exception e) { + logError("Failed to collect batch page IDs: " + e.getMessage()); + FMLCommonHandler.instance().exitJava(1, false); + return; + } + + if (ids.isEmpty()) { + logError("No pages to render in batch mode"); + FMLCommonHandler.instance().exitJava(1, false); + return; + } + + // One-time watchdog recalculation based on page count + watchdogDeadlineNanos = System.nanoTime() + + 360_000_000_000L + (long) ids.size() * 120_000_000_000L; + + batchPageIds = ids; + pageIndex = 0; + okCount = 0; + failCount = 0; + failedPageIds.clear(); + + state = State.RENDERING; + renderPending = true; + GuideDebugLog.infoAlways( + "[GuideNH] [HeadlessRender] Batch render start: {} pages (watchdog {}s), deferred to RenderTickEvent", + ids.size(), 360L + ids.size() * 120L); + System.out.println("[GuideNH] [HeadlessRender] Batch render start: " + + ids.size() + " pages, deferred to RenderTickEvent"); + + } else { + // ---- single-page mode: defer render to RenderTickEvent ------------ + state = State.RENDERING; + renderPending = true; + GuideDebugLog.infoAlways( + "[GuideNH] [HeadlessRender] Single-page render deferred to RenderTickEvent"); + } + } + + // ---- MediaWiki warmup gate ------------------------------------------------ + + /** + * Block until the target guide's MediaWiki special-data index warmup has completed, + * or until {@link #MEDIA_WIKI_WARMUP_TIMEOUT_MILLIS} elapses (timeout → warning log + * and continue; the affected Special pages may render as empty fallbacks). + * + *

In {@link MutableGuide}, the async warmup is triggered by the first + * {@link MutableGuide#getMediaWikiListContext()} call; until it finishes the guide + * serves a fallback context whose {@link MediaWikiSpecialDataIndex} is the empty + * singleton. Therefore the first call here both schedules the warmup and inspects + * it, and subsequent polls detect completion once the real index replaces the empty + * fallback. When the guide type has no async warmup (or it is already complete) + * this returns immediately. + */ + private void awaitMediaWikiWarmup() { + ResourceLocation guideId = new ResourceLocation(config.guideId()); + MutableGuide guide = GuideRegistry.getById(guideId); + if (guide == null) { + return; + } + MediaWikiListContext context = guide.getMediaWikiListContext(); + if (context == null || context.specialDataIndex() != MediaWikiSpecialDataIndex.empty()) { + return; // no async warmup pending, or already complete + } + GuideDebugLog.infoAlways( + "[GuideNH] [HeadlessRender] Waiting for MediaWiki special-data warmup of guide {} (up to {} ms)", + guideId, MEDIA_WIKI_WARMUP_TIMEOUT_MILLIS); + + long deadlineNanos = System.nanoTime() + MEDIA_WIKI_WARMUP_TIMEOUT_MILLIS * 1_000_000L; + boolean interrupted = false; + while (System.nanoTime() < deadlineNanos) { + try { + Thread.sleep(MEDIA_WIKI_WARMUP_POLL_MILLIS); + } catch (InterruptedException e) { + interrupted = true; + GuideDebugLog.warnAlways( + "[GuideNH] [HeadlessRender] Interrupted while waiting for MediaWiki special-data warmup: {}", + e.getMessage()); + break; + } + context = guide.getMediaWikiListContext(); + if (context != null && context.specialDataIndex() != MediaWikiSpecialDataIndex.empty()) { + long waitedMillis = (MEDIA_WIKI_WARMUP_TIMEOUT_MILLIS * 1_000_000L + - (deadlineNanos - System.nanoTime())) / 1_000_000L; + GuideDebugLog.infoAlways( + "[GuideNH] [HeadlessRender] MediaWiki special-data warmup complete for guide {} " + + "(waited {} ms of {} ms budget)", + guideId, waitedMillis, MEDIA_WIKI_WARMUP_TIMEOUT_MILLIS); + break; + } + } + if (interrupted) { + Thread.currentThread().interrupt(); + return; + } + if (context == null || context.specialDataIndex() == MediaWikiSpecialDataIndex.empty()) { + GuideDebugLog.warnAlways( + "[GuideNH] [HeadlessRender] MediaWiki special-data warmup for guide {} not complete within {} ms; " + + "proceeding — Special pages may render empty fallbacks", + guideId, MEDIA_WIKI_WARMUP_TIMEOUT_MILLIS); + } + } + + // ---- batch rendering ----------------------------------------------------- + + /** + * Collect page IDs for batch mode either from the guide ({@code allPages}) or from the list + * file ({@code listPath}). + */ + private List collectBatchPageIds() { + if (config.allPages()) { + ResourceLocation guideId = new ResourceLocation(config.guideId()); + MutableGuide guide = GuideRegistry.getById(guideId); + if (guide == null) { + throw new IllegalStateException("Guide not found: " + config.guideId()); + } + Collection pages = guide.getPages(); + return pages.stream() + .map(p -> p.getId().toString()) + .sorted() + .collect(Collectors.toList()); + } else { + return readPageIdList(config.listPath()); + } + } + + /** + * Read a page-ID list file: one pageId per line; empty lines and lines starting with + * {@code #} are skipped. Non-empty lines that do not start with {@code #} are treated as + * page IDs without further validation — invalid IDs will fail during render and be + * reported there. + */ + private List readPageIdList(Path listPath) { + List result = new ArrayList<>(); + try { + List lines = Files.readAllLines(listPath, StandardCharsets.UTF_8); + for (String line : lines) { + String trimmed = line.trim(); + if (trimmed.isEmpty() || trimmed.startsWith("#")) { + continue; + } + result.add(trimmed); + } + } catch (IOException e) { + logError("Failed to read page list file: " + listPath + " (" + e.getMessage() + ")"); + } + GuideDebugLog.infoAlways( + "[GuideNH] [HeadlessRender] Read {} page IDs from list file: {}", + result.size(), listPath); + return result; + } + + /** + * Render one page per invocation. Called from {@link #onRenderTick(TickEvent.RenderTickEvent)} + * when {@code state == RENDERING} in batch mode. + */ + private void handleRendering(Minecraft mc) { + if (pageIndex >= batchPageIds.size()) { + finishBatch(); + return; + } + + String pageIdStr = batchPageIds.get(pageIndex); + GuideDebugLog.infoAlways( + "[GuideNH] [HeadlessRender] Rendering page [{}/{}]: {}", + pageIndex + 1, batchPageIds.size(), pageIdStr); + System.out.println("[GuideNH] [HeadlessRender] Rendering page [" + + (pageIndex + 1) + "/" + batchPageIds.size() + "]: " + pageIdStr); + + try { + RenderPageService.ensureFontEngineReady(); + var req = new RenderPageService.RenderPageRequest( + config.guideId(), + pageIdStr, + null, // no mdFile in batch mode + config.language(), + config.width(), + config.outDir(), + config.emitBoundsJson(), + config.emitDebugOverlay(), + config.scale(), + config.chrome() + ); + RenderPageService.RenderPageResult result = RenderPageService.render(req); + + String okMsg = "[GuideNH] [HeadlessRender] Page OK [" + (pageIndex + 1) + "/" + + batchPageIds.size() + "]: " + pageIdStr + + " -> " + result.pngPath() + " (" + result.widthPx() + "x" + result.heightPx() + ")"; + GuideDebugLog.infoAlways(okMsg); + System.out.println(okMsg); + okCount++; + } catch (RenderPageService.RenderPageException e) { + String failMsg = "[GuideNH] [HeadlessRender] Page FAILED [" + (pageIndex + 1) + "/" + + batchPageIds.size() + "]: " + pageIdStr + + " at stage " + e.getStage() + ": " + e.getMessage(); + GuideDebugLog.error(failMsg); + System.err.println(failMsg); + failCount++; + failedPageIds.add(pageIdStr); + } catch (Throwable t) { + String failMsg = "[GuideNH] [HeadlessRender] Page FAILED [" + (pageIndex + 1) + "/" + + batchPageIds.size() + "]: " + pageIdStr + + " with exception: " + t.getMessage(); + GuideDebugLog.error(failMsg, t); + System.err.println(failMsg); + failCount++; + failedPageIds.add(pageIdStr); + } + + pageIndex++; + + if (pageIndex >= batchPageIds.size()) { + finishBatch(); + } + } + + /** + * Print batch summary to stdout and log, then exit with the appropriate code. + */ + private void finishBatch() { + state = State.DONE; + + int total = okCount + failCount; + String summary = "[GuideNH] [HeadlessRender] Batch complete: total=" + total + + " ok=" + okCount + " failed=" + failCount; + GuideDebugLog.infoAlways(summary); + System.out.println(summary); + + if (!failedPageIds.isEmpty()) { + String failedSummary = "[GuideNH] [HeadlessRender] Failed pages (" + failCount + "): " + + String.join(", ", failedPageIds); + GuideDebugLog.error(failedSummary); + System.err.println(failedSummary); + } + + FMLCommonHandler.instance().exitJava(failCount > 0 ? 1 : 0, false); + } + + // ---- render-tick handler (frame rendering cycle) ------------------------- + + /** + * Execute deferred rendering inside the frame rendering cycle (RenderTickEvent.END). + * + *

Angelica's Tessellator mixins route draws through VBO/VAO paths whose internal state + * is tied to the frame rendering pass. Running {@link RenderPageService#render} inside + * {@link TickEvent.ClientTickEvent} (outside frame) caused silent zero-fragment output. + * This handler shifts execution into the frame cycle to validate that hypothesis. + * + *

Both single-page and batch modes are handled here. Batch mode renders all remaining + * pages in one go (equivalent to the original per-tick loop, just inside the frame render + * cycle instead of client tick). + */ + @SubscribeEvent + public void onRenderTick(TickEvent.RenderTickEvent event) { + if (event.phase != TickEvent.Phase.END) { + return; + } + if (!renderPending) { + return; + } + renderPending = false; + + if (state != State.RENDERING) { + return; + } + + Minecraft mc = Minecraft.getMinecraft(); + if (mc == null) { + return; + } + + if (config.allPages() || config.listPath() != null) { + // Batch mode: render all remaining pages in this render frame + while (pageIndex < batchPageIds.size()) { + handleRendering(mc); + } + // finishBatch is called by handleRendering when all pages are done (JVM exits) + } else { + // Single-page mode + renderSinglePage(); + } + } + + /** + * Execute a single-page render and exit the JVM with the appropriate code. + * + *

Extracted from the old {@code handleWorldStable} single-page path. + */ + private void renderSinglePage() { + GuideDebugLog.infoAlways("[GuideNH] [HeadlessRender] Rendering page..."); + try { + RenderPageService.ensureFontEngineReady(); + var req = new RenderPageService.RenderPageRequest( + config.guideId(), + config.pageId(), + config.mdFile(), + config.language(), + config.width(), + config.outDir(), + config.emitBoundsJson(), + config.emitDebugOverlay(), + config.scale(), + config.chrome() + ); + RenderPageService.RenderPageResult result = RenderPageService.render(req); + + String message = "[GuideNH] [HeadlessRender] Screenshot written: " + result.pngPath() + + " (" + result.widthPx() + "x" + result.heightPx() + ")"; + GuideDebugLog.infoAlways(message); + System.out.println(message); + + FMLCommonHandler.instance().exitJava(0, false); + } catch (RenderPageService.RenderPageException e) { + GuideDebugLog.error( + "[GuideNH] [HeadlessRender] Render failed at stage {}: {}", + e.getStage(), e.getMessage()); + System.err.println( + "[GuideNH] [HeadlessRender] Render failed at stage " + e.getStage() + + ": " + e.getMessage()); + FMLCommonHandler.instance().exitJava(1, false); + } catch (Throwable t) { + GuideDebugLog.error( + "[GuideNH] [HeadlessRender] Unhandled exception during render", t); + System.err.println( + "[GuideNH] [HeadlessRender] Unhandled exception: " + t.getMessage()); + FMLCommonHandler.instance().exitJava(1, false); + } + } +} diff --git a/src/main/java/com/hfstudio/guidenh/guide/internal/headless/GuideNhHeadlessWindow.java b/src/main/java/com/hfstudio/guidenh/guide/internal/headless/GuideNhHeadlessWindow.java new file mode 100644 index 00000000..8de41b6e --- /dev/null +++ b/src/main/java/com/hfstudio/guidenh/guide/internal/headless/GuideNhHeadlessWindow.java @@ -0,0 +1,126 @@ +package com.hfstudio.guidenh.guide.internal.headless; + +import java.lang.reflect.InvocationHandler; +import java.lang.reflect.Method; +import java.lang.reflect.Proxy; +import java.util.function.Consumer; + +import com.hfstudio.guidenh.guide.scene.support.GuideDebugLog; + +/** + * Handles hiding the client window for headless rendering (screenshots, etc.). + * + *

Two-tier strategy: + *

    + *
  1. installEarly() — If {@code DisplayEvents} exists (lwjgl3ify ≥ 3.0.21), + * registers a pre-window-create listener that sets + * {@code SDL_PROP_WINDOW_CREATE_HIDDEN_BOOLEAN} so the window is never shown. + *
  2. hideNow() — After {@code Display.create()} has occurred (the 3.0.20 + * fallback, or if the early listener was missed), calls + * {@code SDL_HideWindow(Display.sdlWindow)} directly. + *
+ * + *

All failures are logged as warnings only — window hiding must never crash the + * screenshot pipeline. When JVM property {@code -Dguidenh.headlessRender} is not + * {@code true}, every method returns immediately with zero side effects. + * + *

All LWJGL3 / lwjgl3ify classes are accessed reflectively to avoid compile-time + * dependency on jars that are only present at runtime. + */ +public final class GuideNhHeadlessWindow { + + private static final String PROPERTY_NAME = "guidenh.headlessRender"; + private static final String TAG = "[GuideNhHeadlessWindow]"; + private static final boolean HEADLESS = Boolean.getBoolean(PROPERTY_NAME); + + /** Guard against redundant hide attempts — set to true once SDL_HideWindow succeeds. */ + private static volatile boolean hidden = false; + + private GuideNhHeadlessWindow() {} + + /** + * Earliest hook — call from {@code FMLPreInitializationEvent}. + * + *

If {@code -Dguidenh.headlessRender=true} and the {@code DisplayEvents} API is + * present at runtime (lwjgl3ify ≥ 3.0.21), dynamically registers a + * pre-window-create listener that makes the window invisible from birth. + */ + public static void installEarly() { + if (!HEADLESS) { + return; + } + + try { + Class displayEventsClass = Class.forName("me.eigenraven.lwjgl3ify.api.DisplayEvents"); + Method addListener = displayEventsClass.getMethod("addPreWindowCreateListener", Consumer.class); + + // Resolve SDL bindings reflectively + Class sdlVideo = Class.forName("org.lwjgl.sdl.SDLVideo"); + Class sdlProps = Class.forName("org.lwjgl.sdl.SDLProperties"); + String hiddenKey = (String) sdlVideo.getField("SDL_PROP_WINDOW_CREATE_HIDDEN_BOOLEAN").get(null); + Method setBoolProp = sdlProps.getMethod( + "SDL_SetBooleanProperty", int.class, CharSequence.class, boolean.class); + + Object consumerProxy = Proxy.newProxyInstance( + GuideNhHeadlessWindow.class.getClassLoader(), + new Class[] { Consumer.class }, + new InvocationHandler() { + @Override + public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { + if ("accept".equals(method.getName()) && args != null && args.length == 1) { + Object ctx = args[0]; + int props = (int) ctx.getClass().getMethod("props").invoke(ctx); + setBoolProp.invoke(null, props, hiddenKey, true); + GuideDebugLog.infoAlways( + "{} Set SDL_PROP_WINDOW_CREATE_HIDDEN_BOOLEAN via DisplayEvents listener (props={})", + TAG, props); + } + return null; + } + }); + + addListener.invoke(null, consumerProxy); + GuideDebugLog.infoAlways( + "{} Registered pre-window-create listener via DisplayEvents API", TAG); + } catch (ClassNotFoundException e) { + GuideDebugLog.warnAlways( + "{} DisplayEvents not found (lwjgl3ify <= 3.0.20), will use fallback hideNow()", TAG); + hideNow(); // preInit attempt — sdlWindow already available on MC 1.7.10 + } catch (Exception e) { + GuideDebugLog.warnAlways( + "{} Failed to register pre-window-create listener: {}", TAG, e.getMessage()); + hideNow(); // fallback — try direct hide in case DisplayEvents path partially failed + } + } + + /** + * Fallback / second-chance hook — call after {@code Display.create()} has + * occurred (FML init phase). Hides the SDL window directly. + */ + public static void hideNow() { + if (!HEADLESS) { + return; + } + if (hidden) { + return; + } + + try { + Class displayClass = Class.forName("org.lwjglx.opengl.Display"); + long window = displayClass.getField("sdlWindow").getLong(null); + if (window != 0L) { + Class sdlVideo = Class.forName("org.lwjgl.sdl.SDLVideo"); + sdlVideo.getMethod("SDL_HideWindow", long.class).invoke(null, window); + GuideDebugLog.infoAlways( + "{} Window hidden via SDL_HideWindow (sdlWindow={})", TAG, window); + hidden = true; + } else { + GuideDebugLog.warnAlways( + "{} sdlWindow is 0, cannot hide window", TAG); + } + } catch (Exception e) { + GuideDebugLog.warnAlways( + "{} Failed to hide window: {}", TAG, e.getMessage()); + } + } +} diff --git a/src/main/java/com/hfstudio/guidenh/guide/internal/headless/RenderPageService.java b/src/main/java/com/hfstudio/guidenh/guide/internal/headless/RenderPageService.java new file mode 100644 index 00000000..e8433667 --- /dev/null +++ b/src/main/java/com/hfstudio/guidenh/guide/internal/headless/RenderPageService.java @@ -0,0 +1,982 @@ +package com.hfstudio.guidenh.guide.internal.headless; + +import java.awt.Color; +import java.awt.Graphics2D; +import java.awt.RenderingHints; +import java.awt.image.BufferedImage; +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import java.time.LocalDateTime; +import java.time.format.DateTimeFormatter; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Locale; +import java.util.stream.Collectors; + +import javax.imageio.ImageIO; + +import net.minecraft.client.Minecraft; +import net.minecraft.util.ResourceLocation; + +import com.google.gson.GsonBuilder; +import com.google.gson.JsonArray; +import com.google.gson.JsonObject; +import com.hfstudio.guidenh.guide.GuidePage; +import com.hfstudio.guidenh.guide.compiler.PageCompiler; +import com.hfstudio.guidenh.guide.compiler.ParsedGuidePage; +import com.hfstudio.guidenh.guide.color.LightDarkMode; +import com.hfstudio.guidenh.guide.document.LytRect; +import com.hfstudio.guidenh.guide.document.block.LytBlock; +import com.hfstudio.guidenh.guide.document.block.LytDocument; +import com.hfstudio.guidenh.guide.document.block.LytHeading; +import com.hfstudio.guidenh.guide.document.block.LytMermaidCanvas; +import com.hfstudio.guidenh.guide.document.block.LytNode; +import com.hfstudio.guidenh.guide.document.block.LytParagraph; +import com.hfstudio.guidenh.guide.document.flow.LytFlowContent; +import com.hfstudio.guidenh.guide.color.LightDarkMode; +import com.hfstudio.guidenh.ClientProxy; +import com.hfstudio.guidenh.guide.internal.GuideBookmarkState; +import com.hfstudio.guidenh.guide.internal.GuideRegistry; +import com.hfstudio.guidenh.guide.internal.GuideScreen; +import com.hfstudio.guidenh.guide.internal.MutableGuide; +import com.hfstudio.guidenh.guide.internal.host.LytHost; +import com.hfstudio.guidenh.guide.internal.screen.GuideNavBar; +import com.hfstudio.guidenh.guide.internal.screen.GuideNavBarState; +import com.hfstudio.guidenh.guide.layout.FontProvider; +import com.hfstudio.guidenh.guide.layout.LayoutBridge; +import com.hfstudio.guidenh.guide.layout.LayoutContext; +import com.hfstudio.guidenh.guide.layout.LayoutTreeSerializer; +import com.hfstudio.guidenh.guide.layout.RustFontMetrics; +import com.hfstudio.guidenh.guide.layout.SystemFontProvider; +import com.hfstudio.guidenh.guide.navigation.NavigationTree; +import com.hfstudio.guidenh.guide.render.GuideRenderPrimitive; +import com.hfstudio.guidenh.guide.render.PrimitiveCollector; +import com.hfstudio.guidenh.guide.render.VanillaRenderContext; +import com.hfstudio.guidenh.guide.scene.support.GuideDebugLog; + +/** + * Core orchestration service for "page → long screenshot PNG + optional bounds + * JSON / debug overlay". + * + *

Called inside the real Minecraft client (command or startup hook) after + * fonts, resources, and the Guide registry are ready (post-completeInit). + * Does not depend on {@code Minecraft.theWorld / thePlayer / currentScreen}. + * + *

Layout is performed at {@code guiScale = 1}; the visual scale is fixed at + * {@code 1.0} (no zoom). + */ +public final class RenderPageService { + + private static final DateTimeFormatter FILE_NAME_FORMAT = + DateTimeFormatter.ofPattern("yyyy-MM-dd_HHmmss", Locale.ROOT); + + /** Six cycling colours for overlay borders/labels, keyed by depth % 6. */ + private static final int[] OVERLAY_FILL_COLORS = { + 0x44FF0000, 0x4400FF00, 0x440000FF, 0x44FFFF00, 0x44FF00FF, 0x4400FFFF + }; + private static final int[] OVERLAY_BORDER_COLORS = { + 0xFFFF0000, 0xFF00FF00, 0xFF0000FF, 0xFFFFFF00, 0xFFFF00FF, 0xFF00FFFF + }; + + private RenderPageService() {} + + // ---- data types --------------------------------------------------------- + + /** + * @param guideId host guide identifier (always required, used as resource context) + * @param pageId registered page id (non-null → registered-page path) + * @param mdFile arbitrary markdown file (non-null → raw-md path) + * @param language language code, e.g. "en_us" or "zh_cn" + * @param width layout width in document units (GUI pixels) + * @param outDir output directory for generated files + * @param emitBoundsJson if true, write a block-bounds JSON sidecar + * @param emitDebugOverlay if true, write a debug overlay PNG + * @param scale render pixel-density multiplier (1-4; 1 = 1×, no scaling) + * @param chrome if true, append the GuideNavBar chrome pass to the + * headless render (S2 verification channel). The nav + * bar occupies the left {@link #navBarWidth(int)} + * logical px and the document is shifted right; the + * bounds JSON stays in document coordinates. + */ + public record RenderPageRequest( + String guideId, + String pageId, + Path mdFile, + String language, + int width, + Path outDir, + boolean emitBoundsJson, + boolean emitDebugOverlay, + int scale, + boolean chrome + ) { + + /** Legacy 9-arg construction (in-game command path) — chrome defaults off. */ + public RenderPageRequest( + String guideId, + String pageId, + Path mdFile, + String language, + int width, + Path outDir, + boolean emitBoundsJson, + boolean emitDebugOverlay, + int scale + ) { + this(guideId, pageId, mdFile, language, width, outDir, emitBoundsJson, emitDebugOverlay, scale, false); + } + } + + /** + * @param pngPath path of the written PNG + * @param boundsJsonPath path of the bounds JSON (null when not emitted) + * @param widthPx actual image width in pixels + * @param heightPx actual image height in pixels + * @param blockCount total number of LytBlock instances in the document + */ + public record RenderPageResult( + Path pngPath, + Path boundsJsonPath, + int widthPx, + int heightPx, + int blockCount + ) {} + + /** + * Checked exception that wraps all failures inside {@link #render}. + * The {@link Stage} indicates which phase the error occurred in. + */ + public static final class RenderPageException extends Exception { + public enum Stage { COMPILE, LAYOUT, RENDER, IO } + + private final Stage stage; + + public RenderPageException(Stage stage, String message) { + super(message); + this.stage = stage; + } + + public RenderPageException(Stage stage, String message, Throwable cause) { + super(message, cause); + this.stage = stage; + } + + public Stage getStage() { return stage; } + } + + // ---- public API --------------------------------------------------------- + + /** + * Force-initialise the Rust font engine if not already done. + * + *

Equivalent to the font-initialisation portion of + * {@code GuideScreen.ensureLayout()}: checks {@link LayoutBridge#getFontHandle()}, + * loads system CJK font data via {@link SystemFontProvider}, and calls + * {@link LayoutBridge#init(byte[], String)} followed by + * {@link LayoutBridge#setFontHandle(long)}. + * + *

Idempotent — subsequent calls are no-ops once the font handle is non-zero. + */ + public static void ensureFontEngineReady() { + if (LayoutBridge.getFontHandle() == 0) { + var fontProvider = new SystemFontProvider(); + byte[] fontData = fontProvider.getFontData("zh_CN"); + GuideDebugLog.warnAlways( + "RenderPageService: initializing Rust font system from {} ({} bytes)", + fontProvider.getFontPath(), + fontData.length); + long handle = LayoutBridge.init(fontData, "zh_CN"); + LayoutBridge.setFontHandle(handle); + loadFallbackSymbolFont(fontProvider, handle); + } + } + + /** + * Best-effort fallback symbol font registration (seguisym.ttf covers the + * callout icons ⓘ ✦ ➤ ⚠ ☢ that msyh.ttc lacks). Runs once right after + * font init; empty data and stale native libs are skipped/ignored. + */ + private static void loadFallbackSymbolFont(FontProvider fontProvider, long handle) { + if (handle == 0) return; + byte[] fallbackData = fontProvider.getFallbackFontData("zh_CN"); + if (fallbackData.length == 0) return; + try { + LayoutBridge.loadFallbackFont(handle, fallbackData); + } catch (UnsatisfiedLinkError e) { + GuideDebugLog.warnAlways( + "RenderPageService: loadFallbackFont unavailable (stale native lib?): {}", e.getMessage()); + } + } + + /** + * Orchestrate the full render pipeline. + * + *

    + *
  1. Ensure font engine ready
    2. + *
  2. Compile the page (registered-page or raw-md path)
    3. + *
  3. Layout the document at the requested width
    4. + *
  4. Collect render primitives
    5. + *
  5. Render to offscreen FBO (tiled if necessary)
    6. + *
  6. Write PNG (with collision-safe naming)
    7. + *
  7. Optionally write bounds JSON
    8. + *
  8. Optionally write debug-overlay PNG
    9. + *
+ * + *

Intentional deviation from {@code GuideScreen.renderDocument}: + * This method fixes {@code visualScale = 1.0f} (in the layout context) and + * {@code zoom = 1.0f} (in the render context) to produce a full-resolution + * screenshot. The screenshot is defined as the geometric layout at 1.0× + * scale; it does not simulate the user's current zoom or visual + * scale. {@code GuideScreen.renderDocument} applies the user's dynamic + * {@code currentZoom} and {@code visualScrollY} instead. + */ + public static RenderPageResult render(RenderPageRequest req) throws RenderPageException { + // ---- 1. Font engine ------------------------------------------------- + ensureFontEngineReady(); + + // ---- 2. Resolve host guide ------------------------------------------ + ResourceLocation guideId = new ResourceLocation(req.guideId()); + MutableGuide guide = GuideRegistry.getById(guideId); + if (guide == null) { + throw new RenderPageException( + RenderPageException.Stage.COMPILE, + "Guide not found: " + req.guideId()); + } + + // ---- 3. Compile ----------------------------------------------------- + GuidePage compiledPage; + try { + if (req.pageId() != null && !req.pageId().isEmpty()) { + compiledPage = compileRegisteredPage(guide, req); + } else if (req.mdFile() != null) { + compiledPage = compileMdFile(guide, req); + } else { + throw new RenderPageException( + RenderPageException.Stage.COMPILE, + "Either pageId or mdFile must be provided"); + } + } catch (RenderPageException e) { + throw e; + } catch (Exception e) { + throw new RenderPageException( + RenderPageException.Stage.COMPILE, "Compilation failed", e); + } + + LytDocument document = compiledPage.document(); + + // ---- 3a. Mount document (dispatch MOUNT events for SceneScript etc.) --- + String mountPageId = compiledPage.id().toString(); + LytHost lytHost = ClientProxy.getLytHost(); + try { + lytHost.setCurrentPageId(mountPageId); + lytHost.setCurrentPageCollection(guide); + lytHost.mountDocument(document); + + // Drive async scripts (SceneScript: doInit → doAwaitSnbt → doBuild) + // to convergence using the host's step mechanism. + long deadline = System.nanoTime() + 10_000_000_000L; // 10 seconds + while (lytHost.hasWork() && System.nanoTime() < deadline) { + lytHost.step(deadline); + } + if (lytHost.hasWork()) { + GuideDebugLog.warnAlways( + "RenderPageService: page {} mount timed out after 10s, {} tasks still pending", + mountPageId, lytHost.pendingTaskCount()); + } + } catch (Exception e) { + throw new RenderPageException( + RenderPageException.Stage.LAYOUT, + "Mount failed for page " + mountPageId, e); + } + + // ---- 4+5. Layout + primitive collection ------------------------------ + // Optional headless guiscale injection (-Dguidenh.renderpage.guiscale= + // <1|2|3|4>): temporarily set gameSettings.guiScale so that + // DisplayScale.scaleFactor() — whose cache key includes guiScale — + // drives the Rust glyph rasterization scale like the live client's + // auto render_scale. Without this, headless renders always run at + // scaleFactor=1 (11 ppem glyphs) and can never cover the capacity + // surface that breaks at render_scale=4. The property is read once, + // the value is applied before layout and restored afterwards. Absent + // property = strict no-op (layout stays byte-identical). + int contentHeight; + List primitives; + VanillaRenderContext renderCtx; + Minecraft mc = Minecraft.getMinecraft(); + int guiscaleInjection = parseGuiscaleInjection(); + int previousGuiScale = 0; + if (guiscaleInjection > 0 && mc != null) { + previousGuiScale = mc.gameSettings.guiScale; + mc.gameSettings.guiScale = guiscaleInjection; + GuideDebugLog.infoAlways( + "RenderPageService: guiscale injection active: {} (layout render_scale simulation; " + + "restored after layout/collect)", + guiscaleInjection); + } + try { + try { + var layoutCtx = new LayoutContext(new RustFontMetrics()).withVisualScale(1.0f); + document.updateLayout(layoutCtx, req.width()); + contentHeight = document.getContentHeight(); + if (contentHeight <= 0) { + throw new RenderPageException( + RenderPageException.Stage.LAYOUT, + "Document content height must be positive, got: " + contentHeight); + } + } catch (Exception e) { + throw new RenderPageException( + RenderPageException.Stage.LAYOUT, "Layout failed", e); + } + + try { + var fullViewport = new LytRect(0, 0, req.width(), contentHeight); + renderCtx = new VanillaRenderContext( + LightDarkMode.LIGHT_MODE, fullViewport, contentHeight); + renderCtx.setDocumentOrigin(0, 0); + renderCtx.setScrollOffsetY(0); + renderCtx.setPreciseScrollOffsetY(0); + renderCtx.setZoom(1.0f); + renderCtx.setScreenViewport(fullViewport); + + var pc = new PrimitiveCollector(fullViewport, renderCtx); + applyMermaidInjection(document); + pc.collectFrom(document); + primitives = pc.result(); + // Headless toolbar-title injection (-Dguidenh.renderpage.title=true): + // overlay the page-title glyph run collected through the drawPageTitle + // equivalent path on top of the document primitives. Absent or any + // non-"true" value is a strict no-op — the primitive list stays + // byte-identical, so the default render output is unchanged. + if (isPageTitleInjectionEnabled()) { + List titlePrims = collectToolbarTitlePrimitives( + req, guide, compiledPage); + if (!titlePrims.isEmpty()) { + List merged = new ArrayList<>( + primitives.size() + titlePrims.size()); + merged.addAll(primitives); + merged.addAll(titlePrims); + primitives = merged; + } + } + } catch (Exception e) { + throw new RenderPageException( + RenderPageException.Stage.RENDER, "Primitive collection failed", e); + } + } finally { + if (guiscaleInjection > 0 && mc != null) { + mc.gameSettings.guiScale = previousGuiScale; + } + } + + // ---- 6. Render ------------------------------------------------------ + int scale = req.scale(); + int renderedWidth = req.width(); + BufferedImage image; + try { + if (req.chrome()) { + // Chrome pass: the document renders byte-identically to the + // chrome=false path (own renderAll call), and the GuideNavBar + // renders in a second offscreen pass at the left. The two are + // composited side by side (nav left, document right), mirroring + // the real GuideScreen layout (nav sidebar + content area). + BufferedImage docImage = DocumentOffscreenFramebuffer.renderAll( + primitives, renderCtx, req.width(), contentHeight, 0x121216, scale); + List navPrims = new ArrayList<>(); + VanillaRenderContext navCtx = collectNavBarPrimitives( + req, guide, compiledPage, contentHeight, navPrims); + int navW = navBarWidth(req.width()); + BufferedImage navImage = DocumentOffscreenFramebuffer.renderAll( + navPrims, navCtx, navW, contentHeight, 0x121216, scale); + image = composeChrome(docImage, navImage, navW * scale, 0x121216); + renderedWidth = req.width() + navW; + GuideDebugLog.infoAlways( + "RenderPageService: chrome pass composed {} nav primitives into {}x{} output " + + "(nav width {} logical px, scale {})", + navPrims.size(), image.getWidth(), image.getHeight(), navW, scale); + } else { + image = DocumentOffscreenFramebuffer.renderAll( + primitives, renderCtx, req.width(), contentHeight, 0x121216, scale); + } + } catch (Exception e) { + throw new RenderPageException( + RenderPageException.Stage.RENDER, "Offscreen rendering failed", e); + } finally { + // Reset the document origin as required by DocumentOffscreenFramebuffer's contract + renderCtx.setDocumentOrigin(0, 0); + } + + // ---- 7. Write PNG --------------------------------------------------- + Path pngPath; + try { + Files.createDirectories(req.outDir()); + String baseName = buildBaseName(req); + pngPath = resolveTargetPath(req.outDir(), baseName, "png"); + ImageIO.write(image, "png", pngPath.toFile()); + GuideDebugLog.infoAlways( + "RenderPageService: wrote PNG {} ({}x{})", + pngPath, image.getWidth(), image.getHeight()); + } catch (IOException e) { + throw new RenderPageException( + RenderPageException.Stage.IO, "Failed to write PNG", e); + } + + // ---- 8. Bounds JSON (optional) -------------------------------------- + Path boundsJsonPath = null; + if (req.emitBoundsJson()) { + try { + boundsJsonPath = resolveTargetPath(req.outDir(), buildBaseName(req), "json"); + writeBoundsJson(document, boundsJsonPath); + GuideDebugLog.infoAlways( + "RenderPageService: wrote bounds JSON {}", boundsJsonPath); + } catch (IOException e) { + throw new RenderPageException( + RenderPageException.Stage.IO, "Failed to write bounds JSON", e); + } + } + + // ---- 9. Debug overlay (optional) ------------------------------------ + if (req.emitDebugOverlay()) { + try { + Path overlayPath = req.outDir() + .resolve(buildBaseName(req) + "_overlay.png"); + drawDebugOverlay(image, document, overlayPath, scale); + GuideDebugLog.infoAlways( + "RenderPageService: wrote overlay PNG {}", overlayPath); + } catch (IOException e) { + throw new RenderPageException( + RenderPageException.Stage.IO, "Failed to write overlay PNG", e); + } + } + + // ---- 10. Unmount document from LytHost (avoid document leak on static host) --- + try { + // mountDocument(null) detaches the current doc (setLive(false)) and clears + // the task queue. LytHost has no explicit unmount/release method beyond this. + lytHost.mountDocument(null); + } catch (Exception e) { + GuideDebugLog.warnAlways( + "RenderPageService: cleanup unmount failed for page {}", mountPageId, e); + } + + int blockCount = countBlocks(document); + return new RenderPageResult( + pngPath, boundsJsonPath, renderedWidth * scale, contentHeight * scale, blockCount); + } + + // ---- compilation helpers ------------------------------------------------ + + private static GuidePage compileRegisteredPage(MutableGuide guide, RenderPageRequest req) + throws RenderPageException { + ResourceLocation pageId = new ResourceLocation(req.pageId()); + ParsedGuidePage parsed = guide.getParsedPage(pageId); + if (parsed == null) { + throw new RenderPageException( + RenderPageException.Stage.COMPILE, + buildPageNotFoundMessage(guide, req.pageId())); + } + try { + return PageCompiler.compile(guide, guide.getExtensions(), parsed); + } catch (Exception e) { + throw new RenderPageException( + RenderPageException.Stage.COMPILE, + "Failed to compile registered page " + req.pageId(), e); + } + } + + private static GuidePage compileMdFile(MutableGuide guide, RenderPageRequest req) + throws RenderPageException { + Path mdFile = req.mdFile(); + if (!Files.isRegularFile(mdFile)) { + throw new RenderPageException( + RenderPageException.Stage.COMPILE, + "mdFile does not exist or is not a regular file: " + mdFile); + } + String content; + try { + content = Files.readString(mdFile, StandardCharsets.UTF_8); + } catch (IOException e) { + throw new RenderPageException( + RenderPageException.Stage.COMPILE, + "Failed to read mdFile: " + mdFile, e); + } + + String fileName = mdFile.getFileName().toString(); + if (fileName.endsWith(".md")) { + fileName = fileName.substring(0, fileName.length() - 3); + } + // Replace characters invalid in ResourceLocation path + String safeName = fileName.replaceAll("[^a-zA-Z0-9._-]", "_"); + ResourceLocation syntheticId = new ResourceLocation( + guide.getDefaultNamespace(), safeName); + + String sourcePack = guide.getDefaultNamespace(); + try { + ParsedGuidePage parsed = PageCompiler.parse( + sourcePack, req.language(), syntheticId, content); + return PageCompiler.compile(guide, guide.getExtensions(), parsed); + } catch (Exception e) { + throw new RenderPageException( + RenderPageException.Stage.COMPILE, + "Failed to compile mdFile " + mdFile, e); + } + } + + /** + * Build a descriptive "page not found" message including the list of available page keys. + */ + private static String buildPageNotFoundMessage(MutableGuide guide, String pageId) { + try { + var pages = guide.getPages(); + String keyList = pages.stream() + .limit(30) + .map(p -> p.getId().toString()) + .collect(Collectors.joining(", ", "[", "]")); + return "Page not found: " + pageId + + ". Available pages (" + pages.size() + " total): " + keyList; + } catch (IllegalStateException e) { + // pages collection is not loaded yet + return "Page not found: " + pageId + " (pages not loaded yet)"; + } + } + + // ---- chrome pass helpers (S2 nav bar overlay) -------------------------- + + /** + * Nav bar open width for the headless chrome pass, mirroring + * {@code GuideScreen.resolveNavigationOpenWidth} under the full-width + * assumption (panelX = 0, panelW = page width): 18 % of the page width, + * floored at {@link GuideNavBar#MIN_DYNAMIC_OPEN_WIDTH} and capped by the + * panel minus padding. For the default 900 px page width this yields + * {@code max(110, 162) = 162} logical px. + */ + private static int navBarWidth(int pageWidth) { + int requested = Math.max( + GuideNavBar.MIN_DYNAMIC_OPEN_WIDTH, + pageWidth * GuideNavBar.OPEN_WIDTH_SCREEN_PERCENT / 100); + int maxWidth = Math.max(GuideNavBar.WIDTH_CLOSED, pageWidth - 16 - 40); + return Math.min(requested, maxWidth); + } + + /** + * Build a fresh GuideNavBar for the current guide, drive it to the same + * state the live screen would reach (open/pinned, current page's ancestors + * expanded) and collect its render primitives via + * {@link GuideNavBar#collectPrimitives}. The nav bar spans the full + * document height at x = 0; the returned context backs the second offscreen + * pass. Headless-only — never touches the live GuideScreen's nav bar. + */ + private static VanillaRenderContext collectNavBarPrimitives(RenderPageRequest req, MutableGuide guide, + GuidePage compiledPage, int contentHeight, List target) { + int navW = navBarWidth(req.width()); + GuideNavBar navBar = new GuideNavBar(); + navBar.setBounds(0, 0, contentHeight); + navBar.setOpenWidth(navW); + GuideBookmarkState bookmarkState = GuideBookmarkState.getSharedInstance(); + NavigationTree tree = guide.getNavigationTree(); + navBar.activateGuide( + guide.getId(), + GuideNavBarState.defaultState(), + tree, + bookmarkState, + compiledPage.id(), + Collections.emptySet()); + navBar.setPinned(true); + navBar.update(-1, -1, tree, bookmarkState); + // Headless scroll injection: -Dguidenh.renderpage.navscroll= renders + // this frame at the given scroll offset so the chrome pass can reproduce + // and regression-test the sticky/scroll overlap. Default 0 (absent) + // keeps the existing behaviour byte-identical. + String navScrollProp = System.getProperty("guidenh.renderpage.navscroll"); + if (navScrollProp != null && !navScrollProp.isEmpty()) { + try { + int navScroll = Integer.parseInt(navScrollProp); + navBar.setScrollY(navScroll); + GuideDebugLog.infoAlways( + "RenderPageService: nav bar scroll injected: {} px (guidenh.renderpage.navscroll)", + navScroll); + } catch (NumberFormatException e) { + GuideDebugLog.warnAlways( + "RenderPageService: ignoring invalid -Dguidenh.renderpage.navscroll={}", + navScrollProp); + } + } + VanillaRenderContext navCtx = new VanillaRenderContext( + LightDarkMode.DARK_MODE, new LytRect(0, 0, navW, contentHeight), contentHeight); + var navCollector = new PrimitiveCollector(new LytRect(0, 0, navW, contentHeight), navCtx); + navBar.collectPrimitives(guide.getId(), compiledPage.id(), guide, bookmarkState, false, navCollector); + target.addAll(navCollector.result()); + return navCtx; + } + + /** + * Headless mermaid canvas injection, mirroring the navscroll injection + * pattern above. Reads {@code -Dguidenh.renderpage.mermaidzoom} (double, + * 0 = no zoom injection) and {@code -Dguidenh.renderpage.mermaidoffset} + * ({@code "x,y"}, {@code "0,0"} = no offset injection) and applies them to + * every {@link LytMermaidCanvas} instance in the document before primitive + * collection, so the {@code HEADLESS} render branch can be verified for the + * zoom / drag paths without a live client. Absent or zero values are a + * strict no-op: the canvases keep their historical fit-to-view + centre + * behaviour byte-identical. + */ + private static void applyMermaidInjection(LytDocument document) { + String zoomProp = System.getProperty("guidenh.renderpage.mermaidzoom"); + String offsetProp = System.getProperty("guidenh.renderpage.mermaidoffset"); + boolean zoomAbsent = zoomProp == null || zoomProp.isEmpty(); + boolean offsetAbsent = offsetProp == null || offsetProp.isEmpty(); + if (zoomAbsent && offsetAbsent) { + return; + } + float zoom = 0f; + if (!zoomAbsent) { + try { + zoom = (float) Double.parseDouble(zoomProp); + } catch (NumberFormatException e) { + GuideDebugLog.warnAlways( + "RenderPageService: ignoring invalid -Dguidenh.renderpage.mermaidzoom={}", + zoomProp); + return; + } + } + int offsetX = 0; + int offsetY = 0; + if (!offsetAbsent) { + String[] parts = offsetProp.split(",", -1); + if (parts.length != 2) { + GuideDebugLog.warnAlways( + "RenderPageService: ignoring invalid -Dguidenh.renderpage.mermaidoffset={} (expected x,y)", + offsetProp); + return; + } + try { + offsetX = Integer.parseInt(parts[0].trim()); + offsetY = Integer.parseInt(parts[1].trim()); + } catch (NumberFormatException e) { + GuideDebugLog.warnAlways( + "RenderPageService: ignoring invalid -Dguidenh.renderpage.mermaidoffset={}", + offsetProp); + return; + } + } + if (zoom <= 0f && offsetX == 0 && offsetY == 0) { + return; + } + GuideDebugLog.infoAlways( + "RenderPageService: mermaid canvas injection zoom={} offset=({},{})", + zoom, offsetX, offsetY); + applyMermaidInjectionRecursive(document, zoom, offsetX, offsetY); + } + + private static void applyMermaidInjectionRecursive(LytNode node, float zoom, int offsetX, int offsetY) { + if (node instanceof LytMermaidCanvas canvas) { + canvas.setHeadlessInjection(zoom, offsetX, offsetY); + } + for (var child : node.getChildren()) { + applyMermaidInjectionRecursive(child, zoom, offsetX, offsetY); + } + } + + // ---- toolbar page-title injection (drawPageTitle equivalent) ------------ + + /** + * Headless toolbar page-title injection, mirroring the navscroll / mermaid + * injection pattern above. Reads {@code -Dguidenh.renderpage.title=true} + * (absent or any other value = strict no-op: the collected primitive list + * stays byte-identical) and, when enabled, overlays the toolbar page-title + * glyph run onto the document render via the same layout the live screen + * uses in {@code GuideScreen.drawPageTitle}: ordinary toolbar title placed + * from the toolbar band's left edge (panelX = 0, panelY = 0, panelW = page + * width, narrow-reading inset 0). This gives the toolbar title a headless + * verification channel — X.7's lesson was that the title band previously + * could only be judged by live eyesight. + */ + private static boolean isPageTitleInjectionEnabled() { + return Boolean.parseBoolean(System.getProperty("guidenh.renderpage.title")); + } + + /** + * Build the toolbar title paragraph the same way the live screen does + * ({@code GuideScreen.refreshCurrentPageTitle}'s document-title branch): + * the page's extracted H1 heading flow content when present, otherwise the + * navigation-tree node title, otherwise the page id. The paragraph is + * styled with {@link GuideScreen#TOOLBAR_TITLE_STYLE}. + */ + private static LytParagraph buildToolbarPageTitle(MutableGuide guide, GuidePage page) { + LytParagraph title = new LytParagraph(); + title.setStyle(GuideScreen.TOOLBAR_TITLE_STYLE); + LytHeading extracted = page.titleHeading(); + if (extracted != null) { + for (LytFlowContent flowContent : extracted.getContent()) { + title.append(flowContent); + } + } else { + String resolvedTitle = null; + try { + var node = guide.getNavigationTree().getNodeById(page.id()); + if (node != null) { + resolvedTitle = node.title(); + } + } catch (Throwable ignored) {} + if (resolvedTitle == null || resolvedTitle.isEmpty()) { + resolvedTitle = page.id().toString(); + } + title.appendText(resolvedTitle); + } + return title; + } + + /** + * Collect the toolbar title paragraph as render primitives positioned at + * its live-screen slot. Mirrors {@code GuideScreen.drawPageTitle}: same + * ordinary-toolbar titleX (toolbar band left edge + padding) / titleY + * formulas, same available-width reserve for the toolbar icon row, same + * title-screen viewport for culling. The primitives are emitted under + * {@code pushTransform(titleX, titleY, 1.0f)} so the glyphs land at the + * toolbar-band position in the final output. + * + * @return collected primitives; empty when the page carries no title text + */ + private static List collectToolbarTitlePrimitives( + RenderPageRequest req, MutableGuide guide, GuidePage page) { + LytParagraph titlePara = buildToolbarPageTitle(guide, page); + if (titlePara.isEmpty()) { + return List.of(); + } + + int panelX = 0; + int panelY = 0; + int panelW = req.width(); + // Ordinary toolbar title (mirrors GuideScreen.drawPageTitle after the + // toolbar-title semantic change): placed from the toolbar band's left + // edge, no navbar/content-column avoidance; the reserved right-side + // icon area is kept. + int reservedRight = (16 + GuideScreen.TOOLBAR_GAP) * 5 + GuideScreen.PANEL_PADDING + 4; + int availableW = Math.max( + 20, panelW - GuideScreen.PANEL_PADDING - reservedRight); + int titleX = panelX + GuideScreen.PANEL_PADDING; + + // Single-pass layout at (0, 0): position is applied via the GL + // translate (pushTransform), matching GuideScreen.drawPageTitle. + var layoutCtx = new LayoutContext(new RustFontMetrics()); + titlePara.layout(layoutCtx, 0, 0, availableW); + int titleH = titlePara.getBounds() + .height(); + int titleY = Math.max(0, (GuideScreen.TOOLBAR_H - titleH) / 2) + panelY + 2; + + LytRect titleScreenVp = new LytRect( + titleX, titleY, availableW, Math.max(titleH, GuideScreen.TOOLBAR_H)); + var titleCtx = new VanillaRenderContext( + LightDarkMode.LIGHT_MODE, titleScreenVp, titleY + titleScreenVp.height()); + var pc = new PrimitiveCollector(titleScreenVp, titleCtx); + pc.pushTransform(titleX, titleY, 1.0f); + pc.collectFrom(titlePara); + pc.popTransform(); + GuideDebugLog.infoAlways( + "RenderPageService: toolbar page-title injected: '{}' at ({},{}) h={} availableW={} " + + "(guidenh.renderpage.title)", + titlePara.getTextContent(), titleX, titleY, titleH, availableW); + return pc.result(); + } + + /** + * Parse {@code -Dguidenh.renderpage.guiscale} (1-4) into an int injection + * value, mirroring the navscroll injection pattern. Absent, empty or + * invalid values return 0 (= no injection, layout stays byte-identical); + * invalid values are reported once with a WARN. + */ + private static int parseGuiscaleInjection() { + String prop = System.getProperty("guidenh.renderpage.guiscale"); + if (prop == null || prop.isEmpty()) { + return 0; + } + try { + int v = Integer.parseInt(prop); + if (v >= 1 && v <= 4) { + return v; + } + GuideDebugLog.warnAlways( + "RenderPageService: ignoring invalid -Dguidenh.renderpage.guiscale={} (expected 1-4)", + prop); + } catch (NumberFormatException e) { + GuideDebugLog.warnAlways( + "RenderPageService: ignoring invalid -Dguidenh.renderpage.guiscale={}", + prop); + } + return 0; + } + + /** + * Composite the two offscreen passes side by side: nav image at x = 0, + * document image shifted right by {@code navWidthPx} (scale-scaled nav + * width). The background fills the remaining band gap if the nav image is + * shorter than the document image. + */ + private static BufferedImage composeChrome(BufferedImage docImage, BufferedImage navImage, int navWidthPx, + int backgroundRgb) { + int w = docImage.getWidth() + navWidthPx; + int h = Math.max(docImage.getHeight(), navImage.getHeight()); + BufferedImage out = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB); + Graphics2D g = out.createGraphics(); + try { + g.setColor(new Color(backgroundRgb)); + g.fillRect(0, 0, w, h); + g.drawImage(navImage, 0, 0, null); + g.drawImage(docImage, navWidthPx, 0, null); + } finally { + g.dispose(); + } + return out; + } + + // ---- file naming -------------------------------------------------------- + + private static String buildBaseName(RenderPageRequest req) { + String name; + if (req.pageId() != null && !req.pageId().isEmpty()) { + // Use the path segment after the colon (namespace:path) + String pageId = req.pageId(); + int colon = pageId.indexOf(':'); + if (colon >= 0) { + name = pageId.substring(colon + 1); + } else { + name = pageId; + } + // Replace path separators with underscores + name = name.replace('/', '_').replace(':', '_'); + } else { + name = req.mdFile().getFileName().toString(); + if (name.endsWith(".md")) { + name = name.substring(0, name.length() - 3); + } + } + return name + "_" + LocalDateTime.now().format(FILE_NAME_FORMAT); + } + + /** + * Resolve a non-colliding file path. Appends {@code _2}, {@code _3} … when + * the candidate already exists, matching the pattern used by + * {@code SceneEditorScreenshotExportService.resolveTargetPath}. + */ + private static Path resolveTargetPath(Path dir, String baseName, String extension) + throws IOException { + Path candidate = dir.resolve(baseName + "." + extension); + int collisionIndex = 2; + while (Files.exists(candidate)) { + candidate = dir.resolve(baseName + "_" + collisionIndex + "." + extension); + collisionIndex++; + } + return candidate; + } + + // ---- bounds JSON -------------------------------------------------------- + + private static void writeBoundsJson(LytDocument document, Path target) throws IOException { + var arr = new JsonArray(); + walkBlocksForJson(document, 0, arr); + String json = new GsonBuilder().setPrettyPrinting().create().toJson(arr); + Files.writeString(target, json, StandardCharsets.UTF_8); + } + + private static void walkBlocksForJson(LytNode node, int depth, JsonArray target) { + if (node instanceof LytBlock block && !LayoutTreeSerializer.shouldSkipInBoundsDump(node)) { + LytRect bounds = block.getBounds(); + if (bounds != null) { + var obj = new JsonObject(); + obj.addProperty("i", target.size()); + obj.addProperty("cls", block.getClass().getSimpleName()); + obj.addProperty("x", bounds.x()); + obj.addProperty("y", bounds.y()); + obj.addProperty("w", bounds.width()); + obj.addProperty("h", bounds.height()); + obj.addProperty("depth", depth); + target.add(obj); + } + } + for (var child : node.getChildren()) { + walkBlocksForJson(child, depth + 1, target); + } + } + + // ---- debug overlay ------------------------------------------------------ + + private static void drawDebugOverlay( + BufferedImage source, LytDocument document, Path target, int scale) throws IOException { + int w = source.getWidth(); + int h = source.getHeight(); + BufferedImage overlay = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB); + Graphics2D g = overlay.createGraphics(); + try { + g.setRenderingHint( + RenderingHints.KEY_TEXT_ANTIALIASING, + RenderingHints.VALUE_TEXT_ANTIALIAS_ON); + int[] counter = { 0 }; + drawOverlayBlocks(g, document, 0, counter, scale); + } finally { + g.dispose(); + } + + // Composite the overlay onto a copy of the source image + BufferedImage result = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB); + Graphics2D rg = result.createGraphics(); + try { + rg.drawImage(source, 0, 0, null); + rg.drawImage(overlay, 0, 0, null); + } finally { + rg.dispose(); + } + ImageIO.write(result, "png", target.toFile()); + } + + /** + * Recursively walk the block tree and draw semi-transparent fills, borders, + * and block-index labels. The colour cycles through six colours based on + * nesting depth. + * + * @param counter single-element array carrying the global block index + */ + private static void drawOverlayBlocks( + Graphics2D g, LytNode node, int depth, int[] counter, int scale) { + if (node instanceof LytBlock block) { + LytRect bounds = block.getBounds(); + if (bounds != null && bounds.width() > 0 && bounds.height() > 0) { + int idx = counter[0]++; + int ci = depth % OVERLAY_FILL_COLORS.length; + int bx = bounds.x() * scale; + int by = bounds.y() * scale; + int bw = bounds.width() * scale; + int bh = bounds.height() * scale; + + // Semi-transparent fill + g.setColor(new Color(OVERLAY_FILL_COLORS[ci], true)); + g.fillRect(bx, by, bw, bh); + + // Solid border + g.setColor(new Color(OVERLAY_BORDER_COLORS[ci])); + g.drawRect(bx, by, bw, bh); + + // Block index label near the top-left corner + g.setColor(new Color(OVERLAY_BORDER_COLORS[ci])); + g.drawString(String.valueOf(idx), bx + 2 * scale, by + 12 * scale); + } + } + for (var child : node.getChildren()) { + drawOverlayBlocks(g, child, depth + 1, counter, scale); + } + } + + // ---- block counting ----------------------------------------------------- + + private static int countBlocks(LytNode node) { + int count = 0; + if (node instanceof LytBlock) { + count = 1; + } + for (var child : node.getChildren()) { + count += countBlocks(child); + } + return count; + } +} diff --git a/src/main/java/com/hfstudio/guidenh/guide/internal/host/ScriptContextImpl.java b/src/main/java/com/hfstudio/guidenh/guide/internal/host/ScriptContextImpl.java index bc624fab..fc4869a5 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/internal/host/ScriptContextImpl.java +++ b/src/main/java/com/hfstudio/guidenh/guide/internal/host/ScriptContextImpl.java @@ -59,6 +59,7 @@ public void replace(Object newNode) { // discussion of why Flow and Block trees are separate and how this bridge works. // if (node instanceof LytFlowInlineBlock wrapper && newNode instanceof LytBlock newBlock) { + inheritUid(wrapper, newBlock); wrapper.setBlock(newBlock); document.invalidateLayout(); recordResult(newBlock); diff --git a/src/main/java/com/hfstudio/guidenh/guide/internal/host/scripts/CsvTableScript.java b/src/main/java/com/hfstudio/guidenh/guide/internal/host/scripts/CsvTableScript.java index 02968de1..2738639f 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/internal/host/scripts/CsvTableScript.java +++ b/src/main/java/com/hfstudio/guidenh/guide/internal/host/scripts/CsvTableScript.java @@ -8,8 +8,11 @@ import com.hfstudio.guidenh.guide.Guide; import com.hfstudio.guidenh.guide.PageCollection; import com.hfstudio.guidenh.guide.compiler.PageCompiler; +import com.hfstudio.guidenh.guide.compiler.tags.BlockTagCompiler; import com.hfstudio.guidenh.guide.compiler.tags.CsvTableCompiler; import com.hfstudio.guidenh.guide.compiler.tags.CsvTableCompiler.CsvTablePlaceholder; +import com.hfstudio.guidenh.guide.document.block.ContentAlign; +import com.hfstudio.guidenh.guide.document.block.ContentWrapMode; import com.hfstudio.guidenh.guide.document.block.LytBlock; import com.hfstudio.guidenh.guide.document.block.LytParagraph; import com.hfstudio.guidenh.guide.extensions.ExtensionCollection; @@ -74,7 +77,13 @@ public void onEvent(Object node, LytEvent event, ScriptContext ctx) { ""); LytBlock table = CsvTableCompiler.buildTable(runtimeCompiler, rows, ph.header, ph.widths); if (table != null) { - ctx.replace(table); + if (ph.wrap != null) { + ContentWrapMode wrapMode = ContentWrapMode.fromString(ph.wrap); + ContentAlign align = ContentAlign.fromString(ph.align); + ctx.replace(BlockTagCompiler.embedBlock(table, wrapMode, align)); + } else { + ctx.replace(table); + } } else { ctx.replace(LytParagraph.error("[CsvTable] Failed to parse CSV: " + ph.src)); } diff --git a/src/main/java/com/hfstudio/guidenh/guide/internal/host/scripts/FloatingImageScript.java b/src/main/java/com/hfstudio/guidenh/guide/internal/host/scripts/FloatingImageScript.java index 2e2fb5ba..53c850ab 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/internal/host/scripts/FloatingImageScript.java +++ b/src/main/java/com/hfstudio/guidenh/guide/internal/host/scripts/FloatingImageScript.java @@ -85,6 +85,8 @@ public void onEvent(Object node, LytEvent event, ScriptContext ctx) { image.setMarginLeft(placeholder.getMarginLeft()); image.setMarginRight(placeholder.getMarginRight()); image.setMarginBottom(placeholder.getMarginBottom()); + image.setExplicitWidth(placeholder.getExplicitWidth()); + image.setExplicitHeight(placeholder.getExplicitHeight()); for (ImageRegionAnnotation ann : placeholder.getAnnotations()) { image.addAnnotation(ann); } diff --git a/src/main/java/com/hfstudio/guidenh/guide/internal/host/scripts/ImageScript.java b/src/main/java/com/hfstudio/guidenh/guide/internal/host/scripts/ImageScript.java index 26b0fb43..353645de 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/internal/host/scripts/ImageScript.java +++ b/src/main/java/com/hfstudio/guidenh/guide/internal/host/scripts/ImageScript.java @@ -66,6 +66,9 @@ public void onEvent(Object node, LytEvent event, ScriptContext ctx) { image.addAnnotation(ann); } + // R4-31: Block-level alignment (LytAlignedBlock) is handled at compile time + // by ImageCompiler.compileBlockContext. At script time, just replace the + // placeholder with the loaded image in the appropriate wrapper. if (isWrapped) { LytFlowInlineBlock newWrapper = new LytFlowInlineBlock(); newWrapper.setBlock(image); diff --git a/src/main/java/com/hfstudio/guidenh/guide/internal/host/scripts/ItemGridScript.java b/src/main/java/com/hfstudio/guidenh/guide/internal/host/scripts/ItemGridScript.java index 25a2a688..b1e6d771 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/internal/host/scripts/ItemGridScript.java +++ b/src/main/java/com/hfstudio/guidenh/guide/internal/host/scripts/ItemGridScript.java @@ -2,6 +2,9 @@ import net.minecraft.item.ItemStack; +import org.jetbrains.annotations.Nullable; + +import com.hfstudio.guidenh.guide.compiler.tags.ItemGridCompiler.ItemGridEntry; import com.hfstudio.guidenh.guide.compiler.tags.ItemGridCompiler.ItemGridPlaceholder; import com.hfstudio.guidenh.guide.document.block.LytItemGrid; import com.hfstudio.guidenh.guide.document.block.LytParagraph; @@ -29,8 +32,8 @@ public void onEvent(Object node, LytEvent event, ScriptContext ctx) { if (event.type() == EventType.MOUNT && node instanceof ItemGridPlaceholder ph) { LytItemGrid grid = new LytItemGrid(); int resolved = 0; - for (String itemId : ph.itemIds) { - ItemStack stack = resolveItemId(itemId.trim()); + for (ItemGridEntry entry : ph.entries) { + ItemStack stack = resolveEntry(entry); if (stack != null) { grid.addItem(stack); resolved++; @@ -44,7 +47,18 @@ public void onEvent(Object node, LytEvent event, ScriptContext ctx) { } } - private static ItemStack resolveItemId(String itemId) { - return GuideDisplayItemStacks.resolveItemStack(itemId, "minecraft"); + @Nullable + private static ItemStack resolveEntry(ItemGridEntry entry) { + // Prefer the direct item id; fall back to the ore dictionary name. + if (entry.id() != null && !entry.id().isEmpty()) { + ItemStack stack = GuideDisplayItemStacks.resolveItemStack(entry.id(), "minecraft"); + if (stack != null) { + return stack; + } + } + if (entry.ore() != null && !entry.ore().isEmpty()) { + return GuideDisplayItemStacks.resolveOreStack(entry.ore()); + } + return null; } } diff --git a/src/main/java/com/hfstudio/guidenh/guide/internal/host/scripts/KeyBindScript.java b/src/main/java/com/hfstudio/guidenh/guide/internal/host/scripts/KeyBindScript.java index 934e8011..28558239 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/internal/host/scripts/KeyBindScript.java +++ b/src/main/java/com/hfstudio/guidenh/guide/internal/host/scripts/KeyBindScript.java @@ -1,5 +1,6 @@ package com.hfstudio.guidenh.guide.internal.host.scripts; +import com.hfstudio.guidenh.guide.color.ConstantColor; import com.hfstudio.guidenh.guide.compiler.tags.KeyBindTagCompiler; import com.hfstudio.guidenh.guide.document.flow.LytFlowText; import com.hfstudio.guidenh.guide.internal.host.EventType; @@ -29,7 +30,8 @@ public void onEvent(Object node, LytEvent event, ScriptContext ctx) { var mapping = KeyBindTagCompiler.findMapping(bindId); String display = mapping != null ? KeyBindTagCompiler.describeMapping(mapping) : "[" + bindId + "]"; placeholder.setText(display); - placeholder.setStyle(TextStyle.EMPTY); + placeholder.setStyle( + TextStyle.builder().bold(true).color(new ConstantColor(0xFFE8EDF5)).build()); ctx.replace(placeholder); } } diff --git a/src/main/java/com/hfstudio/guidenh/guide/internal/host/scripts/MermaidScript.java b/src/main/java/com/hfstudio/guidenh/guide/internal/host/scripts/MermaidScript.java index 066c1a09..a7ea562d 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/internal/host/scripts/MermaidScript.java +++ b/src/main/java/com/hfstudio/guidenh/guide/internal/host/scripts/MermaidScript.java @@ -17,6 +17,7 @@ import com.hfstudio.guidenh.guide.internal.host.ScriptContext; import com.hfstudio.guidenh.guide.internal.host.ScriptType; import com.hfstudio.guidenh.guide.internal.mermaid.MermaidDiagramType; +import com.hfstudio.guidenh.guide.internal.mermaid.MermaidLayoutPrecomputer; import com.hfstudio.guidenh.guide.internal.mermaid.MermaidSourceExtractor; import com.hfstudio.guidenh.guide.internal.mermaid.flowchart.FlowchartParser; import com.hfstudio.guidenh.guide.internal.mermaid.mindmap.MindmapParser; @@ -108,6 +109,10 @@ private void renderMindmap(ScriptContext ctx, MermaidPlaceholder ph, String sour } } } + // Pre-compute diagram layout before first Rust layout so the canvas + // gets a correct preferredHeight and the VBox receives its real height + // in the initial layout pass (no second pass needed). + precomputeMindmapLayout(block, ctx); ctx.replace(block); } catch (IllegalArgumentException e) { GuideDebugLog.error("[GuideNH] [MermaidScript] Failed to parse Mermaid source: {}", sourceText, e); @@ -133,6 +138,10 @@ private void renderFlowchart(ScriptContext ctx, String sourceText, MermaidPlaceh } } } + // Pre-compute diagram layout before first Rust layout so the canvas + // gets a correct preferredHeight and the VBox receives its real height + // in the initial layout pass (no second pass needed). + precomputeFlowchartLayout(block, ctx); ctx.replace(block); } catch (IllegalArgumentException e) { GuideDebugLog.error("[GuideNH] [MermaidScript] Failed to parse flowchart source: {}", sourceText, e); @@ -153,6 +162,40 @@ private void renderUnknown(ScriptContext ctx, String sourceText, MermaidPlacehol ctx.replace(codeBlock); } + /** + * Pre-compute the flowchart ELK layout using a GuideText-based fallback + * context, cache the result on the canvas, and set preferredHeight so + * Rust's first layout pass allocates the correct canvas height. + */ + private static void precomputeFlowchartLayout(LytMermaidFlowchart block, ScriptContext ctx) { + int pageWidth = ctx.document().getAvailableWidth(); + if (pageWidth <= 0) { + pageWidth = 480; // fallback: typical page content width + } + GuideDebugLog.debugAlways("[GuideNH-Mermaid] precomputeFlowchartLayout entered pageWidth={}", pageWidth); + MermaidLayoutPrecomputer.precomputeFlowchartLayout(block, pageWidth); + GuideDebugLog.debugAlways( + "[GuideNH-Mermaid] precomputeFlowchartLayout exit explicitHeight={}", + block.getCanvas().getExplicitHeight()); + } + + /** + * Pre-compute the mindmap layout using a GuideText-based fallback context, + * cache the result on the canvas, and set preferredHeight so Rust's first + * layout pass allocates the correct canvas height. + */ + private static void precomputeMindmapLayout(LytMermaidMindmap block, ScriptContext ctx) { + int pageWidth = ctx.document().getAvailableWidth(); + if (pageWidth <= 0) { + pageWidth = 480; // fallback: typical page content width + } + GuideDebugLog.debugAlways("[GuideNH-Mermaid] precomputeMindmapLayout entered pageWidth={}", pageWidth); + MermaidLayoutPrecomputer.precomputeMindmapLayout(block, pageWidth); + GuideDebugLog.debugAlways( + "[GuideNH-Mermaid] precomputeMindmapLayout exit explicitHeight={}", + block.getCanvas().getExplicitHeight()); + } + private void replaceWithError(ScriptContext ctx, String message) { ctx.replace(LytParagraph.error("[Mermaid] " + message)); } diff --git a/src/main/java/com/hfstudio/guidenh/guide/internal/host/scripts/RecipeScript.java b/src/main/java/com/hfstudio/guidenh/guide/internal/host/scripts/RecipeScript.java index 51ec6ae2..25ee8c45 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/internal/host/scripts/RecipeScript.java +++ b/src/main/java/com/hfstudio/guidenh/guide/internal/host/scripts/RecipeScript.java @@ -121,6 +121,7 @@ public List readIngredientSlots(Object h, int ri) { return NeiRecipeLookup.readResultSlot(h, ri); } }; + boolean handlerFilterEliminatedAll = false; List handlers = RecipeCompiler .filterHandlers(rawHandlers, ph.handlerName, ph.handlerId, ph.handlerOrder, metadataReader); if (!handlers.isEmpty()) { @@ -147,19 +148,15 @@ public List readIngredientSlots(Object h, int ri) { return; } } else if (hasHandlerFilter) { - if (ph.fallbackText != null && !ph.fallbackText.isEmpty()) { - String handlerPart = ""; - if (ph.handlerName != null || ph.handlerId != null) { - handlerPart = " with handler " + (ph.handlerName != null ? ph.handlerName : ph.handlerId); - } - showFallback(ctx, ph, "No recipe found for " + ph.idStr + handlerPart); - } else if (GuideDebugLog.isDebugEnabled()) { + handlerFilterEliminatedAll = true; + if (GuideDebugLog.isDebugEnabled()) { GuideDebugLog.debugAlways("Recipe handler filter eliminated all candidates for {}", ph.idStr); } - return; } - // Integration recipe entries + // Integration recipe entries — skip when handler filter eliminated all candidates + // (user explicitly filtered to a non-existent handler, so no recipe content should render) + if (!handlerFilterEliminatedAll) { List recipeEntries = usageQuery ? Collections.emptyList() : GuideNhIntegrationRegistry.global() .findCraftingRecipeEntries(targetStack); @@ -199,11 +196,28 @@ public List readIngredientSlots(Object h, int ri) { return; } } + } // Vanilla recipe fallback + String fallbackMsg; + if (handlerFilterEliminatedAll) { + String filterInfo = ""; + if (ph.handlerName != null || ph.handlerId != null) { + filterInfo = " with handler " + (ph.handlerName != null ? ph.handlerName : ph.handlerId); + } else if (ph.handlerOrder >= 0) { + filterInfo = " (handler order=" + ph.handlerOrder + ")"; + } + fallbackMsg = "No recipe found for " + ph.idStr + filterInfo; + // All handlers were eliminated by the filter — show fallbackText directly, + // skip vanilla recipe fallback entirely. + showFallback(ctx, ph, fallbackMsg); + return; + } else { + fallbackMsg = "No recipe found for " + ph.idStr; + } List entries = usageQuery ? Collections.emptyList() : RecipeLookup.findByOutput(item); if (entries.isEmpty()) { - showFallback(ctx, ph, "No recipe found for " + ph.idStr); + showFallback(ctx, ph, fallbackMsg); return; } @@ -221,7 +235,7 @@ public List readIngredientSlots(Object h, int ri) { ctx.replace(buildResult(boxes)); return; } - showFallback(ctx, ph, "No recipe found for " + ph.idStr); + showFallback(ctx, ph, fallbackMsg); } @SuppressWarnings("unchecked") @@ -233,6 +247,8 @@ private static LytBlock buildResultTyped(List boxes) { if (boxes.size() == 1) return boxes.getFirst(); var row = new LytHBox(); row.setGap(RecipeCompiler.MULTI_GAP); + // Full width so the Rust flex row wraps at the parent's content edge. + row.setFullWidth(true); for (var b : boxes) row.append(b); return row; } diff --git a/src/main/java/com/hfstudio/guidenh/guide/internal/host/scripts/SceneScript.java b/src/main/java/com/hfstudio/guidenh/guide/internal/host/scripts/SceneScript.java index 3ddf5ff4..d3a49653 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/internal/host/scripts/SceneScript.java +++ b/src/main/java/com/hfstudio/guidenh/guide/internal/host/scripts/SceneScript.java @@ -267,7 +267,7 @@ private void doBuild(ScenePlaceholder ph, ScriptContext ctx) { } } - if (level.isEmpty()) { + if (!scene.hasMountableSceneContent()) { ctx.replace(LytParagraph.error("[Scene] Scene has no supported elements")); return; } @@ -281,6 +281,16 @@ private void doBuild(ScenePlaceholder ph, ScriptContext ctx) { finalizeSceneGeometry(ph, scene, level, camera); scene.setInitialLevelSnapshot(GuideSceneStructureSnapshot.capture(level)); scene.clearLoadState(); + // Surface build failures instead of silently mounting an empty level: a structure whose + // format was unsupported or that placed zero blocks must show a visible error, and a scene + // that still ends up empty after a build attempt gets the same feedback through the scene's + // build-error channel (LytGuidebookScene#setBuildError). + if (level.isEmpty()) { + String message = scene.getBuildError() != null + ? scene.getBuildError() + : "Scene has no structure content (empty level)"; + scene.setBuildError(message); + } attachSelectionListeners(scene); scene.initializePonderTimelineBaseline(); scene.captureInitialInteractiveState(); @@ -386,13 +396,11 @@ private void applyCameraAndViewport(ScenePlaceholder ph, LytGuidebookScene scene private void finalizeSceneGeometry(ScenePlaceholder ph, LytGuidebookScene scene, GuidebookLevel level, CameraSettings camera) { - float[] center; + // Rotation center for the explicit-center case is set in applyCameraAndViewport; + // only the auto-center case (level bounds centre) is finalized here. if (!ph.explicitCenter) { - center = level.getCenter(); + float[] center = level.getCenter(); camera.setRotationCenter(center[0], center[1], center[2]); - } else { - center = new float[] { Float.isNaN(ph.centerX) ? 0f : ph.centerX, Float.isNaN(ph.centerY) ? 0f : ph.centerY, - Float.isNaN(ph.centerZ) ? 0f : ph.centerZ }; } boolean explicitOffX = !Float.isNaN(ph.offsetX); @@ -417,8 +425,6 @@ private void finalizeSceneGeometry(ScenePlaceholder ph, LytGuidebookScene scene, camera.setZoom(autoZoom); } } - if (explicitOffX) camera.setOffsetX(ph.offsetX); - if (explicitOffY) camera.setOffsetY(ph.offsetY); } if (!ph.explicitWidth || !ph.explicitHeight) { @@ -442,12 +448,25 @@ private void finalizeSceneGeometry(ScenePlaceholder ph, LytGuidebookScene scene, camera.setOffsetY(savedOffY); } - if (!ph.explicitCenter && !explicitOffX && !explicitOffY) { + // Pan so the structure (level bounds centre) is inside the viewport. This runs even when an + // explicit rotation centre was requested — a rotation centre far from the structure (e.g. + // subnetworks centreY=-15) otherwise leaves the level entirely off-camera and the scene + // silently black. offsetX/offsetY are screen-space pan values (see SceneTagCompiler); the + // camera view matrix applies them in world units, so convert with the projection scale + // s = 0.625 * 16 * zoom = 10 * zoom. + float panScale = 10f * camera.getZoom(); + if (!explicitOffX && !explicitOffY) { camera.setOffsetX(0f); camera.setOffsetY(0f); - var screenCenter = camera.worldToScreen(center[0], center[1], center[2]); - camera.setOffsetX(-screenCenter.x); - camera.setOffsetY(screenCenter.y); + if (!level.isEmpty()) { + float[] levelCenter = level.getCenter(); + var screenCenter = camera.worldToScreen(levelCenter[0], levelCenter[1], levelCenter[2]); + camera.setOffsetX(-screenCenter.x / panScale); + camera.setOffsetY(screenCenter.y / panScale); + } + } else { + if (explicitOffX) camera.setOffsetX(ph.offsetX / panScale); + if (explicitOffY) camera.setOffsetY(ph.offsetY / panScale); } } diff --git a/src/main/java/com/hfstudio/guidenh/guide/internal/host/scripts/SoundLinkScript.java b/src/main/java/com/hfstudio/guidenh/guide/internal/host/scripts/SoundLinkScript.java index be2576a8..16d7af2b 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/internal/host/scripts/SoundLinkScript.java +++ b/src/main/java/com/hfstudio/guidenh/guide/internal/host/scripts/SoundLinkScript.java @@ -1,5 +1,6 @@ package com.hfstudio.guidenh.guide.internal.host.scripts; +import com.hfstudio.guidenh.guide.color.ConstantColor; import com.hfstudio.guidenh.guide.document.flow.LytFlowLink; import com.hfstudio.guidenh.guide.internal.host.EventType; import com.hfstudio.guidenh.guide.internal.host.LytEvent; @@ -26,6 +27,7 @@ public void onEvent(Object node, LytEvent event, ScriptContext ctx) { GuideSoundSpec spec = (GuideSoundSpec) link.getData("soundSpec"); if (spec != null) { link.setClickSoundSpec(spec); + link.modifyStyle(style -> style.color(new ConstantColor(0xFFFFAA00)).underlined(false)); ctx.replace(link); } } diff --git a/src/main/java/com/hfstudio/guidenh/guide/internal/localization/GuideLocalizedFrontmatterMerger.java b/src/main/java/com/hfstudio/guidenh/guide/internal/localization/GuideLocalizedFrontmatterMerger.java index 1508ca60..d928a9bf 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/internal/localization/GuideLocalizedFrontmatterMerger.java +++ b/src/main/java/com/hfstudio/guidenh/guide/internal/localization/GuideLocalizedFrontmatterMerger.java @@ -8,6 +8,7 @@ import org.yaml.snakeyaml.Yaml; import com.hfstudio.guidenh.guide.compiler.PageCompiler; +import com.hfstudio.guidenh.guide.scene.support.GuideDebugLog; public class GuideLocalizedFrontmatterMerger { @@ -16,8 +17,25 @@ public class GuideLocalizedFrontmatterMerger { private GuideLocalizedFrontmatterMerger() {} public static String merge(String fallbackSource, String localizedSource) { + long t0 = System.nanoTime(); + String result = mergeInternal(fallbackSource, localizedSource); + long t1 = System.nanoTime(); + long totalUs = (t1 - t0) / 1000; + if (totalUs > 1_000) { + GuideDebugLog.warnAlways( + "[GuideNH] [FrontmatterMerger] merge() took {}us, fallbackLen={} localizedLen={}", + totalUs, + fallbackSource.length(), + localizedSource.length()); + } + return result; + } + + private static String mergeInternal(String fallbackSource, String localizedSource) { + long t0 = System.nanoTime(); String normalizedFallback = PageCompiler.normalizeLineEndings(fallbackSource); String normalizedLocalized = PageCompiler.normalizeLineEndings(localizedSource); + long t1 = System.nanoTime(); SourceParts fallbackParts = SourceParts.split(normalizedFallback); if (fallbackParts.frontmatter() == null) { return normalizedLocalized; @@ -27,19 +45,35 @@ public static String merge(String fallbackSource, String localizedSource) { if (localizedParts.frontmatter() == null) { return fallbackParts.withBody(normalizedLocalized); } + long t2 = System.nanoTime(); Map fallbackFrontmatter = readMap(fallbackParts.frontmatter()); Map localizedFrontmatter = readMap(localizedParts.frontmatter()); + long t3 = System.nanoTime(); if (fallbackFrontmatter == null || localizedFrontmatter == null) { return normalizedLocalized; } boolean changed = mergeMissingKeys(fallbackFrontmatter, localizedFrontmatter); changed |= mergeNavigation(fallbackFrontmatter, localizedFrontmatter); + long t4 = System.nanoTime(); if (!changed) { return normalizedLocalized; } - return SourceParts.withFrontmatterAndBody(writeMap(localizedFrontmatter), localizedParts.body()); + String result = SourceParts.withFrontmatterAndBody(writeMap(localizedFrontmatter), localizedParts.body()); + long t5 = System.nanoTime(); + long totalUs = (t5 - t0) / 1000; + if (totalUs > 1_000) { + GuideDebugLog.warnAlways( + "[GuideNH] [FrontmatterMerger] mergeInternal normalize={}us split={}us yamlLoad={}us mergeKeys={}us writeMap={}us total={}us", + (t1 - t0) / 1000, + (t2 - t1) / 1000, + (t3 - t2) / 1000, + (t4 - t3) / 1000, + (t5 - t4) / 1000, + totalUs); + } + return result; } private static Yaml createYaml() { diff --git a/src/main/java/com/hfstudio/guidenh/guide/internal/localization/GuideLocalizedPageSourceResolver.java b/src/main/java/com/hfstudio/guidenh/guide/internal/localization/GuideLocalizedPageSourceResolver.java index eb9bbcf8..f6025a13 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/internal/localization/GuideLocalizedPageSourceResolver.java +++ b/src/main/java/com/hfstudio/guidenh/guide/internal/localization/GuideLocalizedPageSourceResolver.java @@ -11,6 +11,7 @@ import com.hfstudio.guidenh.guide.compiler.PageCompiler; import com.hfstudio.guidenh.guide.compiler.ParsedGuidePage; import com.hfstudio.guidenh.guide.internal.util.LangUtil; +import com.hfstudio.guidenh.guide.scene.support.GuideDebugLog; public class GuideLocalizedPageSourceResolver { @@ -38,11 +39,21 @@ public static ParsedGuidePage parse(String sourcePack, String language, String c */ public static ParsedGuidePage parseFrontmatterOnly(String sourcePack, String language, String contentRootFolder, ResourceLocation pageId, byte[] fileBytes) { - return PageCompiler.parseFrontmatterOnly( - sourcePack, - language, - pageId, - resolve(language, contentRootFolder, pageId, fileBytes, null).source()); + long t0 = System.nanoTime(); + String resolvedSource = resolve(language, contentRootFolder, pageId, fileBytes, null).source(); + long t1 = System.nanoTime(); + ParsedGuidePage result = PageCompiler.parseFrontmatterOnly(sourcePack, language, pageId, resolvedSource); + long t2 = System.nanoTime(); + long totalUs = (t2 - t0) / 1000; + if (totalUs > 5_000) { + GuideDebugLog.warnAlways( + "[GuideNH] [PageSourceResolver] parseFrontmatterOnly {} resolve={}us parse={}us total={}us", + pageId, + (t1 - t0) / 1000, + (t2 - t1) / 1000, + totalUs); + } + return result; } public static ParsedGuidePage parse(String sourcePack, String language, ResourceLocation pageId, @@ -57,17 +68,30 @@ public static ResolvedGuidePageSource resolve(String language, String contentRoo public static ResolvedGuidePageSource resolve(String language, String contentRootFolder, ResourceLocation pageId, byte[] fileBytes, @Nullable String localizedSourceOverride) { + long t0 = System.nanoTime(); String langKey = buildLangKey(contentRootFolder, pageId); String localizedSource = hasText(localizedSourceOverride) ? decodeNewlines(localizedSourceOverride) : findLocalizedPageSource(langKey, language); + long t1 = System.nanoTime(); String fallbackSource = new String(fileBytes, StandardCharsets.UTF_8); + long t2 = System.nanoTime(); if (localizedSource == null || localizedSource.isEmpty()) { return new ResolvedGuidePageSource(fallbackSource, false, null); } - return new ResolvedGuidePageSource( - GuideLocalizedFrontmatterMerger.merge(fallbackSource, localizedSource), - true, - langKey); + String merged = GuideLocalizedFrontmatterMerger.merge(fallbackSource, localizedSource); + long t3 = System.nanoTime(); + long totalUs = (t3 - t0) / 1000; + if (totalUs > 2_000) { + GuideDebugLog.warnAlways( + "[GuideNH] [PageSourceResolver] resolve {} i18nLookup={}us newString={}us merge={}us total={}us langKey={}", + pageId, + (t1 - t0) / 1000, + (t2 - t1) / 1000, + (t3 - t2) / 1000, + totalUs, + langKey); + } + return new ResolvedGuidePageSource(merged, true, langKey); } public static String buildLangKey(String contentRootFolder, ResourceLocation pageId) { diff --git a/src/main/java/com/hfstudio/guidenh/guide/internal/localization/GuidePageLanguageIndex.java b/src/main/java/com/hfstudio/guidenh/guide/internal/localization/GuidePageLanguageIndex.java index b5376cb4..8bd0729c 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/internal/localization/GuidePageLanguageIndex.java +++ b/src/main/java/com/hfstudio/guidenh/guide/internal/localization/GuidePageLanguageIndex.java @@ -4,19 +4,16 @@ import java.io.FileInputStream; import java.io.IOException; import java.io.InputStream; -import java.util.Enumeration; import java.util.LinkedHashMap; +import java.util.List; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; -import java.util.zip.ZipEntry; -import java.util.zip.ZipFile; import net.minecraft.client.resources.IResourcePack; import net.minecraft.util.StringTranslate; import org.jetbrains.annotations.Nullable; -import com.hfstudio.guidenh.config.ModConfig; import com.hfstudio.guidenh.guide.internal.datadriven.DataDrivenGuideLoader; import com.hfstudio.guidenh.guide.internal.util.LangUtil; import com.hfstudio.guidenh.guide.scene.support.GuideDebugLog; @@ -26,19 +23,34 @@ public class GuidePageLanguageIndex { private static final String PAGE_LANG_KEY_PREFIX = "guidenh.page."; private static final Map> PAGE_KEYS_BY_LANGUAGE = new ConcurrentHashMap<>(); + private static volatile boolean preloaded = false; private GuidePageLanguageIndex() {} public static void clear() { PAGE_KEYS_BY_LANGUAGE.clear(); + preloaded = false; + } + + /** + * Pre-populates the language index with keys collected during scanAll(). + * After this call, getValue() returns instantly without scanning packs. + */ + public static void preload(Map> keysByLanguage) { + PAGE_KEYS_BY_LANGUAGE.putAll(keysByLanguage); + preloaded = true; } public static @Nullable String getValue(String language, String key) { if (key == null || !key.startsWith(PAGE_LANG_KEY_PREFIX)) { return null; } - return PAGE_KEYS_BY_LANGUAGE - .computeIfAbsent(LangUtil.normalizeLanguage(language), GuidePageLanguageIndex::loadLanguage) + String normalizedLanguage = LangUtil.normalizeLanguage(language); + if (preloaded) { + Map keys = PAGE_KEYS_BY_LANGUAGE.get(normalizedLanguage); + return keys != null ? keys.get(key) : null; + } + return PAGE_KEYS_BY_LANGUAGE.computeIfAbsent(normalizedLanguage, GuidePageLanguageIndex::loadLanguage) .get(key); } @@ -66,18 +78,28 @@ private static Map loadLanguage(String normalizedLanguage) { long startedAt = System.nanoTime(); Map merged = new LinkedHashMap<>(); var activeResourcePacks = DataDrivenGuideLoader.getLastActiveResourcePacks(); + int packIndex = 0; for (IResourcePack resourcePack : activeResourcePacks) { + long packStartedAt = System.nanoTime(); loadResourcePackLanguage(resourcePack, normalizedLanguage, merged); + long packNs = System.nanoTime() - packStartedAt; + if (packNs > 100_000_000) { + GuideDebugLog.warnAlways( + "[GuideNH] [GuidePageLanguageIndex] Slow resource pack [#{}/{}] {} took {} ms", + packIndex, + activeResourcePacks.size(), + resourcePack.getPackName(), + packNs / 1_000_000L); + } + packIndex++; } long totalNs = System.nanoTime() - startedAt; - if (ModConfig.debug.enableDebugMode) { - GuideDebugLog.infoAlways( - "[GuideNH] [GuidePageLanguageIndex] Loaded {} page language keys for language {} from {} resource packs in {} ns", - merged.size(), - normalizedLanguage, - activeResourcePacks.size(), - totalNs); - } + GuideDebugLog.warnAlways( + "[GuideNH] [GuidePageLanguageIndex] Loaded {} page language keys for language {} from {} resource packs in {} ms", + merged.size(), + normalizedLanguage, + activeResourcePacks.size(), + totalNs / 1_000_000L); return merged.isEmpty() ? Map.of() : Map.copyOf(merged); } @@ -91,7 +113,7 @@ private static void loadResourcePackLanguage(IResourcePack resourcePack, String loadDirectoryLanguage(resourcePackFile, normalizedLanguage, target); return; } - loadZipLanguage(resourcePackFile, normalizedLanguage, target); + loadZipLanguage(resourcePack, resourcePackFile, normalizedLanguage, target); } private static void loadDirectoryLanguage(File resourcePackRoot, String normalizedLanguage, @@ -151,34 +173,29 @@ private static void loadDirectoryLanguageEntries(File directory, String normaliz } } - private static void loadZipLanguage(File resourcePackFile, String normalizedLanguage, Map target) { - try (ZipFile zip = new ZipFile(resourcePackFile)) { - Enumeration entries = zip.entries(); - while (entries.hasMoreElements()) { - ZipEntry entry = entries.nextElement(); - if (entry.isDirectory()) { - continue; - } - String path = entry.getName(); - if (!isLangZipPath(path)) { - continue; - } - int fileNameStart = path.lastIndexOf('/') + 1; - if (fileNameStart <= 0 || fileNameStart >= path.length()) { - continue; - } - if (!isMatchingLangFile(path.substring(fileNameStart), normalizedLanguage)) { - continue; - } - try (InputStream input = zip.getInputStream(entry)) { - mergePageKeys(input, target); + /** + * Reads .lang files for the requested language using the cached entry list + * from DataDrivenGuideLoader's single scan, avoiding a redundant zip entry iteration. + */ + private static void loadZipLanguage(IResourcePack resourcePack, File resourcePackFile, String normalizedLanguage, + Map target) { + List langEntryPaths = DataDrivenGuideLoader.getLangFilePaths(resourcePackFile); + for (String path : langEntryPaths) { + int fileNameStart = path.lastIndexOf('/') + 1; + if (fileNameStart <= 0 || fileNameStart >= path.length()) { + continue; + } + if (!isMatchingLangFile(path.substring(fileNameStart), normalizedLanguage)) { + continue; + } + Map entries = DataDrivenGuideLoader.readLangFile(resourcePack, path); + if (!entries.isEmpty()) { + for (var entry : entries.entrySet()) { + if (isPageLangKey(entry.getKey())) { + target.put(entry.getKey(), entry.getValue()); + } } } - } catch (IOException e) { - GuideDebugLog.warnAlways( - "[GuideNH] [GuidePageLanguageIndex] Failed to scan lang entries from resource pack {}", - resourcePackFile.getAbsolutePath(), - e); } } @@ -191,11 +208,7 @@ private static boolean isMatchingLangFile(String fileName, String normalizedLang .equals(normalizedLanguage); } - private static boolean isLangZipPath(String path) { - return path.contains("/lang/"); - } - - private static void mergePageKeys(InputStream input, Map target) { + private static void mergePageKeys(InputStream input, Map target) throws IOException { target.putAll(readPageKeys(input)); } } diff --git a/src/main/java/com/hfstudio/guidenh/guide/internal/localization/GuideResourceLanguageIndex.java b/src/main/java/com/hfstudio/guidenh/guide/internal/localization/GuideResourceLanguageIndex.java index 43b1b648..f8b25350 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/internal/localization/GuideResourceLanguageIndex.java +++ b/src/main/java/com/hfstudio/guidenh/guide/internal/localization/GuideResourceLanguageIndex.java @@ -4,19 +4,16 @@ import java.io.FileInputStream; import java.io.IOException; import java.io.InputStream; -import java.util.Enumeration; import java.util.LinkedHashMap; +import java.util.List; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; -import java.util.zip.ZipEntry; -import java.util.zip.ZipFile; import net.minecraft.client.resources.IResourcePack; import net.minecraft.util.StringTranslate; import org.jetbrains.annotations.Nullable; -import com.hfstudio.guidenh.config.ModConfig; import com.hfstudio.guidenh.guide.internal.datadriven.DataDrivenGuideLoader; import com.hfstudio.guidenh.guide.internal.util.LangUtil; import com.hfstudio.guidenh.guide.scene.support.GuideDebugLog; @@ -44,18 +41,28 @@ private static Map load(String normalizedLanguage) { long startedAt = System.nanoTime(); Map merged = new LinkedHashMap<>(); var activeResourcePacks = DataDrivenGuideLoader.getLastActiveResourcePacks(); + int packIndex = 0; for (IResourcePack resourcePack : activeResourcePacks) { + long packStartedAt = System.nanoTime(); loadResourcePackLanguage(resourcePack, normalizedLanguage, merged); + long packNs = System.nanoTime() - packStartedAt; + if (packNs > 100_000_000) { + GuideDebugLog.warnAlways( + "[GuideNH] [GuideResourceLanguageIndex] Slow resource pack [#{}/{}] {} took {} ms", + packIndex, + activeResourcePacks.size(), + resourcePack.getPackName(), + packNs / 1_000_000L); + } + packIndex++; } long totalNs = System.nanoTime() - startedAt; - if (ModConfig.debug.enableDebugMode) { - GuideDebugLog.infoAlways( - "[GuideNH] [GuideResourceLanguageIndex] Loaded {} lang entries for language {} from {} resource packs in {} ns", - merged.size(), - normalizedLanguage, - activeResourcePacks.size(), - totalNs); - } + GuideDebugLog.warnAlways( + "[GuideNH] [GuideResourceLanguageIndex] Loaded {} lang entries for language {} from {} resource packs in {} ms", + merged.size(), + normalizedLanguage, + activeResourcePacks.size(), + totalNs / 1_000_000L); return merged.isEmpty() ? Map.of() : Map.copyOf(merged); } @@ -69,7 +76,7 @@ private static void loadResourcePackLanguage(IResourcePack resourcePack, String loadDirectoryLanguage(resourcePackFile, normalizedLanguage, target); return; } - loadZipLanguage(resourcePackFile, normalizedLanguage, target); + loadZipLanguage(resourcePack, resourcePackFile, normalizedLanguage, target); } private static void loadDirectoryLanguage(File resourcePackRoot, String normalizedLanguage, @@ -129,34 +136,22 @@ private static void loadDirectoryLanguageEntries(File directory, String normaliz } } - private static void loadZipLanguage(File resourcePackFile, String normalizedLanguage, Map target) { - try (ZipFile zip = new ZipFile(resourcePackFile)) { - Enumeration entries = zip.entries(); - while (entries.hasMoreElements()) { - ZipEntry entry = entries.nextElement(); - if (entry.isDirectory()) { - continue; - } - String path = entry.getName(); - if (!path.contains("/lang/")) { - continue; - } - int fileNameStart = path.lastIndexOf('/') + 1; - if (fileNameStart <= 0 || fileNameStart >= path.length()) { - continue; - } - if (!isMatchingLangFile(path.substring(fileNameStart), normalizedLanguage)) { - continue; - } - try (InputStream input = zip.getInputStream(entry)) { - target.putAll(StringTranslate.parseLangFile(input)); - } + /** + * Reads .lang files for the requested language using the cached entry list + * from DataDrivenGuideLoader's single scan, avoiding a redundant zip entry iteration. + */ + private static void loadZipLanguage(IResourcePack resourcePack, File resourcePackFile, String normalizedLanguage, + Map target) { + List langEntryPaths = DataDrivenGuideLoader.getLangFilePaths(resourcePackFile); + for (String path : langEntryPaths) { + int fileNameStart = path.lastIndexOf('/') + 1; + if (fileNameStart <= 0 || fileNameStart >= path.length()) { + continue; + } + if (!isMatchingLangFile(path.substring(fileNameStart), normalizedLanguage)) { + continue; } - } catch (IOException e) { - GuideDebugLog.warnAlways( - "[GuideNH] [GuideResourceLanguageIndex] Failed to scan lang entries from resource pack {}", - resourcePackFile.getAbsolutePath(), - e); + target.putAll(DataDrivenGuideLoader.readLangFile(resourcePack, path)); } } diff --git a/src/main/java/com/hfstudio/guidenh/guide/internal/markdown/CodeBlockLanguageDetector.java b/src/main/java/com/hfstudio/guidenh/guide/internal/markdown/CodeBlockLanguageDetector.java index 061112fd..76b1aaf0 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/internal/markdown/CodeBlockLanguageDetector.java +++ b/src/main/java/com/hfstudio/guidenh/guide/internal/markdown/CodeBlockLanguageDetector.java @@ -18,6 +18,9 @@ public static CodeBlockLanguage detect(@Nullable String explicitFenceLanguage, S String text = codeText != null ? codeText : ""; String lower = text.toLowerCase(Locale.ROOT); + if (looksLikePython(lower)) { + return require("python"); + } if (looksLikeLua(lower)) { return require("lua"); } @@ -65,6 +68,34 @@ private static CodeBlockLanguage require(String fenceName) { return language != null ? language : PLAIN_TEXT; } + private static boolean looksLikePython(String lower) { + // def and elif are definitive Python indicators not found in Lua + if (lower.contains("def ") || lower.contains("elif ")) { + return true; + } + // from X import Y pattern + if (lower.contains("from ") && lower.contains(" import ")) { + return true; + } + // class definition (Python style with colon) + if (lower.contains("class ") && (lower.contains(":\n") || lower.endsWith(":"))) { + return true; + } + // Python exception handling keywords not in Lua + if (lower.contains("raise ") || lower.contains("except ")) { + return true; + } + // Python-only keywords + if (lower.contains("lambda ") || lower.contains("yield ")) { + return true; + } + // Python f-strings: print(f"...") + if (lower.contains("print(f\"") || lower.contains("print(f'")) { + return true; + } + return false; + } + private static boolean looksLikeLua(String lower) { return lower.contains("local ") || lower.contains("function ") && lower.contains(" end") || lower.contains("print(") diff --git a/src/main/java/com/hfstudio/guidenh/guide/internal/markdown/CodeBlockLanguageRegistry.java b/src/main/java/com/hfstudio/guidenh/guide/internal/markdown/CodeBlockLanguageRegistry.java index 32c0f678..5793e51f 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/internal/markdown/CodeBlockLanguageRegistry.java +++ b/src/main/java/com/hfstudio/guidenh/guide/internal/markdown/CodeBlockLanguageRegistry.java @@ -55,6 +55,7 @@ private static Map buildLanguageMap() { register(result, new CodeBlockLanguage("mermaid", "Mermaid")); register(result, new CodeBlockLanguage("javascript", "JavaScript")); register(result, new CodeBlockLanguage("typescript", "TypeScript")); + register(result, new CodeBlockLanguage("python", "Python")); return Map.copyOf(result); } @@ -77,6 +78,7 @@ private static Map buildNormalizedAliases() { registerAlias(result, "mermaid", "mermaid"); registerAlias(result, "javascript", "javascript", "js"); registerAlias(result, "typescript", "typescript", "ts"); + registerAlias(result, "python", "python", "py"); return Map.copyOf(result); } diff --git a/src/main/java/com/hfstudio/guidenh/guide/internal/markdown/FileTreeCompiler.java b/src/main/java/com/hfstudio/guidenh/guide/internal/markdown/FileTreeCompiler.java index 283bf732..5ab80c30 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/internal/markdown/FileTreeCompiler.java +++ b/src/main/java/com/hfstudio/guidenh/guide/internal/markdown/FileTreeCompiler.java @@ -41,6 +41,7 @@ public static LytFileTree compile(PageCompiler compiler, String source) { LytBlock iconBlock = entry.icon() != null ? buildIconBlock(compiler, entry.icon()) : null; tree.appendRow(entry.slots(), iconBlock, payload); } + tree.finalizeRowGaps(); return tree; } diff --git a/src/main/java/com/hfstudio/guidenh/guide/internal/markdown/FootnotePreprocessor.java b/src/main/java/com/hfstudio/guidenh/guide/internal/markdown/FootnotePreprocessor.java index 0e6577ad..673f914c 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/internal/markdown/FootnotePreprocessor.java +++ b/src/main/java/com/hfstudio/guidenh/guide/internal/markdown/FootnotePreprocessor.java @@ -60,7 +60,8 @@ public static String preprocess(String markdown) { } break; } - definitions.put(id, definition.toString()); + // Keep first definition; ignore subsequent definitions with the same id + definitions.putIfAbsent(id, definition.toString()); } String transformedBody = replaceReferences(body.toString(), definitions); @@ -76,7 +77,7 @@ public static String preprocess(String markdown) { if (!result.isEmpty()) { result.append('\n'); } - result.append("\n\n"); + result.append("\n\n"); result.append("## Footnotes\n\n"); int index = 1; for (var entry : definitions.entrySet()) { @@ -92,29 +93,48 @@ public static String preprocess(String markdown) { } private static String replaceReferences(String body, Map definitions) { - Matcher matcher = REFERENCE.matcher(body); - StringBuilder buffer = new StringBuilder(body.length()); + if (body.isEmpty()) { + return body; + } + + List lines = GuideStringLines.splitLines(body); + StringBuilder result = new StringBuilder(body.length()); int nextNumber = 1; Map numbers = new LinkedHashMap<>(); - while (matcher.find()) { - String id = matcher.group(1) - .trim(); - Integer number = numbers.get(id); - if (number == null) { - number = nextNumber++; - numbers.put(id, number); - } - if (!definitions.containsKey(id)) { - matcher.appendReplacement(buffer, Matcher.quoteReplacement(matcher.group(0))); + for (String line : lines) { + String trimmed = line.trim(); + // Skip Expected: and INVARIANTS lines — they are test/spec documentation, not page content + if (trimmed.startsWith("Expected:") || trimmed.startsWith("INVARIANTS")) { + appendLine(result, line); continue; } - String replacement = "" + definitions.get(id) + ""; - matcher.appendReplacement(buffer, Matcher.quoteReplacement(replacement)); + Matcher matcher = REFERENCE.matcher(line); + StringBuilder sb = new StringBuilder(line.length()); + while (matcher.find()) { + String id = matcher.group(1) + .trim(); + + // Undefined references: leave as-is, consume no number + if (!definitions.containsKey(id)) { + matcher.appendReplacement(sb, Matcher.quoteReplacement(matcher.group(0))); + continue; + } + + Integer number = numbers.get(id); + if (number == null) { + number = nextNumber++; + numbers.put(id, number); + } + + String replacement = "[" + number + "]"; + matcher.appendReplacement(sb, Matcher.quoteReplacement(replacement)); + } + matcher.appendTail(sb); + appendLine(result, sb.toString()); } - matcher.appendTail(buffer); - return buffer.toString(); + return result.toString(); } private static String trimDefinitionIndent(String line) { diff --git a/src/main/java/com/hfstudio/guidenh/guide/internal/markdown/MarkdownLatexShorthand.java b/src/main/java/com/hfstudio/guidenh/guide/internal/markdown/MarkdownLatexShorthand.java index 9421035b..0e9a34fe 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/internal/markdown/MarkdownLatexShorthand.java +++ b/src/main/java/com/hfstudio/guidenh/guide/internal/markdown/MarkdownLatexShorthand.java @@ -19,8 +19,8 @@ import lombok.Getter; /** - * Utility for detecting and splitting {@code $$formula$$} shorthand LaTeX expressions - * inside Markdown text nodes. + * Utility for detecting and splitting {@code $$formula$$} / {@code $formula$} shorthand LaTeX + * expressions inside Markdown text nodes. * *

* A {@code $$formula$$} shorthand always uses default rendering parameters (white colour, @@ -29,12 +29,26 @@ *

* Display-mode detection: if a paragraph's only text content is exactly {@code $$formula$$} * (after trimming whitespace), the formula is rendered as a centred display block. Otherwise - * each {@code $$formula$$} fragment is rendered as an inline block inside the surrounding text. + * each {@code $$formula$$} or {@code $formula$} fragment is rendered as an inline block inside + * the surrounding text. + * + *

Single-dollar inline formulas follow Pandoc-style rules: + * the opening {@code $} must be followed by a non-whitespace character, + * the closing {@code $} must be preceded by a non-whitespace character, + * and the closing {@code $} must not be followed by a digit (to avoid currency false positives). + * Use {@code \$} to escape a dollar sign that should be treated as literal text. */ public class MarkdownLatexShorthand { private static final String PLACEHOLDER_PREFIX = "\uE000GUIDENH_LATEX_"; private static final String PLACEHOLDER_SUFFIX = "_\uE001"; + private static final String ESCAPE_PLACEHOLDER_PREFIX = "\uE000GUIDENH_LATEXESC_"; + + /** + * Sentinel used to temporarily replace {@code $$} after double-dollar masking, + * preventing the single-dollar pattern from matching placeholder wraps. + */ + private static final String DOLLAR_SENTINEL = "\uE004\uE005"; /** * Matches {@code $$...$$} where the content contains no literal {@code $} characters. @@ -42,6 +56,33 @@ public class MarkdownLatexShorthand { */ private static final Pattern DOLLAR_PATTERN = Pattern.compile("\\$\\$([^$]+?)\\$\\$", Pattern.DOTALL); + /** + * Matches {@code \$} escape sequences — a backslash followed by dollar. + */ + private static final Pattern ESCAPED_DOLLAR_PATTERN = Pattern.compile("\\\\[$]"); + + /** + * Single-dollar inline formula pattern (Pandoc rules): + *

    + *
  • Opening {@code $} must be followed by a non-whitespace, non-{@code $} character. + *
  • Closing {@code $} must be preceded by a non-whitespace, non-{@code $} character. + *
  • Closing {@code $} must not be followed by a digit (avoid currency false positives). + *
  • Content must not contain {@code $} or newlines. + *
+ */ + private static final String SINGLE_DOLLAR_REGEX = "\\$([^\\s$](?:[^$\\n]*[^\\s$])?)\\$(?!\\d)"; + private static final Pattern SINGLE_DOLLAR_PATTERN = Pattern.compile(SINGLE_DOLLAR_REGEX); + + /** + * Combined pattern for {@link #split}: {@code $$...$$} branch (priority), then single {@code $...$} branch. + *
    + *
  • Match present → use {@link #formulaFromMatch(Matcher)} to extract the formula content
    • + *
+ */ + private static final Pattern COMBINED_PATTERN = Pattern.compile( + "(\\$\\$([^$]+?)\\$\\$)|(\\$([^\\s$](?:[^$\\n]*[^\\s$])?)\\$(?!\\d))", Pattern.DOTALL + ); + private MarkdownLatexShorthand() {} public static MaskResult mask(String source) { @@ -51,18 +92,64 @@ public static MaskResult mask(String source) { if (!mayContain(source)) { return new MaskResult(source, Map.of()); } - Matcher matcher = DOLLAR_PATTERN.matcher(source); - StringBuilder masked = new StringBuilder(source.length()); Map formulas = new HashMap<>(); int index = 0; - while (matcher.find()) { - String placeholder = PLACEHOLDER_PREFIX + index + PLACEHOLDER_SUFFIX; - formulas.put(placeholder, matcher.group(1)); - matcher.appendReplacement(masked, Matcher.quoteReplacement("$$" + placeholder + "$$")); - index++; - } - matcher.appendTail(masked); - return new MaskResult(masked.toString(), formulas); + + // Step (a): mask $$...$$ — unchanged + { + Matcher matcher = DOLLAR_PATTERN.matcher(source); + StringBuilder sb = new StringBuilder(source.length()); + while (matcher.find()) { + String placeholder = PLACEHOLDER_PREFIX + index + PLACEHOLDER_SUFFIX; + formulas.put(placeholder, matcher.group(1)); + matcher.appendReplacement(sb, Matcher.quoteReplacement("$$" + placeholder + "$$")); + index++; + } + matcher.appendTail(sb); + source = sb.toString(); + } + + // Temporarily protect remaining $$ (placeholder wraps and unmatched pairs) + // so the single-$ pattern in step (c) does not match them. + boolean hasProtected = source.contains("$$"); + if (hasProtected) { + source = source.replace("$$", DOLLAR_SENTINEL); + } + + // Step (b): mask \$ escapes → bare placeholder, restore yields literal $ + { + Matcher matcher = ESCAPED_DOLLAR_PATTERN.matcher(source); + StringBuilder sb = new StringBuilder(source.length()); + while (matcher.find()) { + String placeholder = ESCAPE_PLACEHOLDER_PREFIX + index + PLACEHOLDER_SUFFIX; + formulas.put(placeholder, "$"); + matcher.appendReplacement(sb, Matcher.quoteReplacement(placeholder)); + index++; + } + matcher.appendTail(sb); + source = sb.toString(); + } + + // Step (c): mask single $...$ ($$ are protected so they won't match) + { + Matcher matcher = SINGLE_DOLLAR_PATTERN.matcher(source); + StringBuilder sb = new StringBuilder(source.length()); + while (matcher.find()) { + String placeholder = PLACEHOLDER_PREFIX + index + PLACEHOLDER_SUFFIX; + formulas.put(placeholder, matcher.group(1)); + matcher.appendReplacement(sb, Matcher.quoteReplacement("$" + placeholder + "$")); + index++; + } + matcher.appendTail(sb); + source = sb.toString(); + } + + // Restore protected $$ + if (hasProtected) { + source = source.replace(DOLLAR_SENTINEL, "$$"); + } + + return new MaskResult(source, formulas); } public static void restore(MdAstNode root, MaskResult maskResult) { @@ -73,10 +160,10 @@ public static void restore(MdAstNode root, MaskResult maskResult) { } /** - * Quick pre-check: returns {@code false} if {@code text} cannot contain any {@code $$} pattern. + * Quick pre-check: returns {@code false} if {@code text} cannot contain any {@code $} pattern. */ public static boolean mayContain(String text) { - return text != null && text.contains("$$"); + return text != null && text.contains("$"); } /** @@ -101,6 +188,19 @@ public static String extractSoleDisplayFormula(String text) { return formula.isEmpty() ? null : formula; } + /** + * Extracts the formula content from a {@link #COMBINED_PATTERN} match. + *
    + *
  • Group 2: formula from {@code $$...$$} branch
    • + *
  • Group 4: formula from single {@code $...$} branch
    • + *
+ */ + private static String formulaFromMatch(Matcher m) { + String d = m.group(2); + if (d != null) return d; + return m.group(4); + } + /** * Splits {@code text} into alternating plain-text and LaTeX-formula {@link Segment}s. * Plain-text segments may be empty strings only when the text starts or ends with a formula. @@ -113,13 +213,13 @@ public static List split(String text) { return List.of(); } List result = new ArrayList<>(); - Matcher m = DOLLAR_PATTERN.matcher(text); + Matcher m = COMBINED_PATTERN.matcher(text); int last = 0; while (m.find()) { if (m.start() > last) { result.add(Segment.text(text.substring(last, m.start()))); } - result.add(Segment.formula(m.group(1))); + result.add(Segment.formula(formulaFromMatch(m))); last = m.end(); } if (last < text.length()) { diff --git a/src/main/java/com/hfstudio/guidenh/guide/internal/markdown/MarkdownListSemantics.java b/src/main/java/com/hfstudio/guidenh/guide/internal/markdown/MarkdownListSemantics.java index 4e532cc3..1a5fff52 100644 --- a/src/main/java/com/hfstudio/guidenh/guide/internal/markdown/MarkdownListSemantics.java +++ b/src/main/java/com/hfstudio/guidenh/guide/internal/markdown/MarkdownListSemantics.java @@ -17,28 +17,119 @@ public class MarkdownListSemantics { private MarkdownListSemantics() {} + /** + * Detects whether the given {@code
  • } children contain a GFM task-list + * marker ({@code [x]} / {@code [ ]}) in the first paragraph. + * + *

    This method is PURE DETECTION — it does NOT mutate the AST tree. + * The returned {@link TaskMarker} carries the prefix length so callers + * can strip the prefix for display without permanently altering the AST. + * This is critical because the same {@code ParsedGuidePage} (and its AST) + * may be compiled multiple times (e.g. by {@code CompileWorker} then by + * {@code RenderPageService}); mutation would cause the second compile to + * miss the marker. + * + * @param children the {@code

  • } element's children + * @return a {@link TaskMarker} describing the detected marker, or {@code null} + */ public static @Nullable TaskMarker extractTaskMarker(List children) { - if (children.size() != 1) { + // Find the first

    child (nested

  • may have [

    ,