diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index cb4ec50b..7bef15d1 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -25,6 +25,8 @@ jobs:
craft-fonts-ref: aced4137c022f1f587624d48e81ec77e1914a9cc
os: '["ubuntu-24.04","windows-latest"]'
toolchain: "1.96.0"
+ # xtask ci runs cargo test (including doctests), not cargo nextest.
+ tools: ""
packages: >-
libxkbcommon-dev libwayland-dev libx11-dev libxrandr-dev libxi-dev libgl1-mesa-dev
libgtk-3-dev
diff --git a/.github/workflows/freebsd.yml b/.github/workflows/freebsd.yml
index 9f64bbdd..442b9fd7 100644
--- a/.github/workflows/freebsd.yml
+++ b/.github/workflows/freebsd.yml
@@ -33,4 +33,9 @@ jobs:
uses: storytold/craft-common-actions/.github/workflows/freebsd.yml@main
with:
craft-fonts-ref: aced4137c022f1f587624d48e81ec77e1914a9cc
+ # The VM's software Vulkan driver crashes (SIGSEGV) when several tests set up a device at
+ # once (photocraft serializes its GPU tests for the same reason), so tests run one at a
+ # time. The whole workspace is tested in one command: excluding packages would change
+ # feature unification and build winit without its X11/Wayland backends.
+ cargo-test-extra-args: "-- --test-threads=1"
run-package-check: true
diff --git a/Cargo.lock b/Cargo.lock
index 7a9453c3..384c4457 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -412,6 +412,12 @@ version = "0.22.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+[[package]]
+name = "base64"
+version = "0.23.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac07cdecf99051d9a5238b80f35af32cdeba5b336e55d957b318b50137e18da5"
+
[[package]]
name = "bit-set"
version = "0.10.0"
@@ -448,6 +454,15 @@ dependencies = [
"serde_core",
]
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
[[package]]
name = "block2"
version = "0.5.1"
@@ -691,6 +706,16 @@ dependencies = [
"libc",
]
+[[package]]
+name = "core-foundation"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
[[package]]
name = "core-foundation-sys"
version = "0.8.7"
@@ -704,7 +729,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c07782be35f9e1140080c6b96f0d44b739e2278479f64e02fdab4e32dfd8b081"
dependencies = [
"bitflags 1.3.2",
- "core-foundation",
+ "core-foundation 0.9.4",
"core-graphics-types",
"foreign-types",
"libc",
@@ -717,19 +742,41 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "45390e6114f68f718cc7a830514a96f903cccd70d02a8f6d9f643ac4ba45afaf"
dependencies = [
"bitflags 1.3.2",
- "core-foundation",
+ "core-foundation 0.9.4",
"libc",
]
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "craft-dialogs"
+version = "0.1.0"
+source = "git+https://github.com/storytold/craft-libs?rev=1b34eba41e62138fc2438d2734523b302840b45d#1b34eba41e62138fc2438d2734523b302840b45d"
+dependencies = [
+ "block2 0.6.2",
+ "objc2 0.6.5",
+ "objc2-app-kit 0.3.2",
+ "objc2-foundation 0.3.2",
+ "raw-window-handle",
+ "rfd",
+]
+
[[package]]
name = "craft-fonts-build"
version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=f8f8829cc7be65d466d687dae381d1ca60e31242#f8f8829cc7be65d466d687dae381d1ca60e31242"
+source = "git+https://github.com/storytold/craft-libs?rev=1b34eba41e62138fc2438d2734523b302840b45d#1b34eba41e62138fc2438d2734523b302840b45d"
[[package]]
name = "craft-i18n"
version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=f8f8829cc7be65d466d687dae381d1ca60e31242#f8f8829cc7be65d466d687dae381d1ca60e31242"
+source = "git+https://github.com/storytold/craft-libs?rev=1b34eba41e62138fc2438d2734523b302840b45d#1b34eba41e62138fc2438d2734523b302840b45d"
dependencies = [
"fixed_decimal",
"icu_decimal",
@@ -749,10 +796,44 @@ dependencies = [
"writeable",
]
+[[package]]
+name = "craft-keymap"
+version = "0.1.0"
+source = "git+https://github.com/storytold/craft-libs?rev=1b34eba41e62138fc2438d2734523b302840b45d#1b34eba41e62138fc2438d2734523b302840b45d"
+dependencies = [
+ "egui",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "craft-menu"
+version = "0.1.0"
+source = "git+https://github.com/storytold/craft-libs?rev=1b34eba41e62138fc2438d2734523b302840b45d#1b34eba41e62138fc2438d2734523b302840b45d"
+dependencies = [
+ "craft-keymap",
+ "craft-quit",
+ "egui",
+ "muda",
+ "objc2 0.6.5",
+ "objc2-app-kit 0.3.2",
+]
+
+[[package]]
+name = "craft-quit"
+version = "0.1.0"
+source = "git+https://github.com/storytold/craft-libs?rev=1b34eba41e62138fc2438d2734523b302840b45d#1b34eba41e62138fc2438d2734523b302840b45d"
+dependencies = [
+ "dispatch2",
+ "egui",
+ "objc2 0.6.5",
+ "objc2-app-kit 0.3.2",
+]
+
[[package]]
name = "craft-ui"
version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=f8f8829cc7be65d466d687dae381d1ca60e31242#f8f8829cc7be65d466d687dae381d1ca60e31242"
+source = "git+https://github.com/storytold/craft-libs?rev=1b34eba41e62138fc2438d2734523b302840b45d#1b34eba41e62138fc2438d2734523b302840b45d"
dependencies = [
"craft-fonts-build",
"craft-i18n",
@@ -770,10 +851,36 @@ dependencies = [
"web-sys",
]
+[[package]]
+name = "craft-update"
+version = "0.1.0"
+source = "git+https://github.com/storytold/craft-libs?rev=1b34eba41e62138fc2438d2734523b302840b45d#1b34eba41e62138fc2438d2734523b302840b45d"
+dependencies = [
+ "chrono",
+ "dunce",
+ "egui",
+ "flate2",
+ "getrandom 0.3.4",
+ "image",
+ "log",
+ "plist",
+ "semver",
+ "serde",
+ "serde_json",
+ "sha2",
+ "tar",
+ "tempfile",
+ "ureq",
+ "verifysign",
+ "winreg",
+ "winsafe",
+ "zip",
+]
+
[[package]]
name = "craft-window"
version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=f8f8829cc7be65d466d687dae381d1ca60e31242#f8f8829cc7be65d466d687dae381d1ca60e31242"
+source = "git+https://github.com/storytold/craft-libs?rev=1b34eba41e62138fc2438d2734523b302840b45d#1b34eba41e62138fc2438d2734523b302840b45d"
dependencies = [
"egui",
"objc2 0.6.5",
@@ -790,6 +897,15 @@ dependencies = [
"cfg-if",
]
+[[package]]
+name = "crossbeam-channel"
+version = "0.5.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "98b0cc327b5bc766e7fda9c9260cc0fa81b43a8e240440422dff70788e3f9ef1"
+dependencies = [
+ "crossbeam-utils",
+]
+
[[package]]
name = "crossbeam-deque"
version = "0.8.8"
@@ -821,6 +937,16 @@ version = "0.2.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
+[[package]]
+name = "crypto-common"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
[[package]]
name = "cursor-icon"
version = "1.2.0"
@@ -861,6 +987,22 @@ dependencies = [
"syn 3.0.9",
]
+[[package]]
+name = "deranged"
+version = "0.5.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e9de72ce2ad1f90dc62fa25f0f430ef85eb4b0d8fa0be4f30373bc40a21d28e"
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+]
+
[[package]]
name = "dispatch"
version = "0.2.0"
@@ -920,6 +1062,12 @@ version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d8b14ccef22fc6f5a8f4d7d768562a182c04ce9a3b3157b91390b52ddfdf1a76"
+[[package]]
+name = "dunce"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813"
+
[[package]]
name = "dyn-clone"
version = "1.0.20"
@@ -1171,7 +1319,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
dependencies = [
"libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.60.2",
]
[[package]]
@@ -1252,6 +1400,16 @@ version = "0.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b97b65636e5b9ef369943878ac74335ba1c55c1cb6adbf1e2c293c624248d693"
+[[package]]
+name = "filetime"
+version = "0.2.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c287a33c7f0a620c38e641e7f60827713987b3c0f26e8ddc9462cc69cf75759"
+dependencies = [
+ "cfg-if",
+ "libc",
+]
+
[[package]]
name = "find-msvc-tools"
version = "0.1.14"
@@ -1447,6 +1605,16 @@ dependencies = [
"slab",
]
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
[[package]]
name = "gethostname"
version = "1.1.0"
@@ -1457,6 +1625,17 @@ dependencies = [
"windows-link",
]
+[[package]]
+name = "getrandom"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
[[package]]
name = "getrandom"
version = "0.3.4"
@@ -1728,6 +1907,22 @@ version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+[[package]]
+name = "http"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "918d3568bebf352712bc2ef3d46a8bcf1a75b373be6539de198e9105cbbf9ce0"
+dependencies = [
+ "bytes",
+ "itoa",
+]
+
+[[package]]
+name = "httparse"
+version = "1.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
+
[[package]]
name = "iana-time-zone"
version = "0.1.65"
@@ -2103,6 +2298,16 @@ dependencies = [
"wasm-bindgen",
]
+[[package]]
+name = "keyboard-types"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fbe853b403ae61a04233030ae8a79d94975281ed9770a1f9e246732b534b28d"
+dependencies = [
+ "bitflags 2.13.2",
+ "serde",
+]
+
[[package]]
name = "khronos-egl"
version = "6.0.0"
@@ -2322,6 +2527,24 @@ dependencies = [
"pxfm",
]
+[[package]]
+name = "muda"
+version = "0.21.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4340e89c178916e62879c5c36b7f699019369be413e496178a6983ce91b8bc03"
+dependencies = [
+ "crossbeam-channel",
+ "dpi",
+ "keyboard-types",
+ "objc2 0.6.5",
+ "objc2-app-kit 0.3.2",
+ "objc2-core-foundation",
+ "objc2-foundation 0.3.2",
+ "png",
+ "thiserror 2.0.21",
+ "windows-sys 0.60.2",
+]
+
[[package]]
name = "naga"
version = "30.0.1"
@@ -2427,6 +2650,12 @@ dependencies = [
"num-traits",
]
+[[package]]
+name = "num-conv"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "521739c6d2bac4aa25192232afe6841231376b2b26d4d9fae5ecf8ca5772e441"
+
[[package]]
name = "num-traits"
version = "0.2.19"
@@ -2776,6 +3005,12 @@ version = "1.21.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+[[package]]
+name = "openssl-probe"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e036b411754132fd6b74e94b74e9a13c5cf606fa93d1885c35860d3060820b1"
+
[[package]]
name = "orbclient"
version = "0.3.55"
@@ -2812,7 +3047,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7d8fae84b431384b68627d0f9b3b1245fcf9f46f6c0e3dc902e9dce64edd1967"
dependencies = [
"libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.60.2",
]
[[package]]
@@ -2978,6 +3213,19 @@ version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6"
+[[package]]
+name = "plist"
+version = "1.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "327a4cb2ad49dc48adfdc9da89e22c64d488b508c67a044d71ba729e4521a285"
+dependencies = [
+ "base64 0.23.1",
+ "indexmap",
+ "quick-xml 0.42.0",
+ "serde",
+ "time",
+]
+
[[package]]
name = "png"
version = "0.18.1"
@@ -3062,6 +3310,12 @@ dependencies = [
"zerovec",
]
+[[package]]
+name = "powerfmt"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a6394b9e965e73d0a289ee54f589087e2c676aedf60885baf52c76b771e4958"
+
[[package]]
name = "presser"
version = "0.3.1"
@@ -3136,6 +3390,15 @@ dependencies = [
"memchr",
]
+[[package]]
+name = "quick-xml"
+version = "0.42.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41b1177fdf999d2321d3fb46ff47159d9c1fb9ad66a4879f8c50a0b504615e9b"
+dependencies = [
+ "memchr",
+]
+
[[package]]
name = "quote"
version = "1.0.47"
@@ -3320,6 +3583,20 @@ dependencies = [
"windows-sys 0.61.2",
]
+[[package]]
+name = "ring"
+version = "0.17.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7"
+dependencies = [
+ "cc",
+ "cfg-if",
+ "getrandom 0.2.17",
+ "libc",
+ "untrusted",
+ "windows-sys 0.52.0",
+]
+
[[package]]
name = "rmcp"
version = "3.5.1"
@@ -3414,7 +3691,7 @@ dependencies = [
"errno",
"libc",
"linux-raw-sys 0.12.1",
- "windows-sys 0.52.0",
+ "windows-sys 0.60.2",
]
[[package]]
@@ -3427,6 +3704,80 @@ dependencies = [
"rustix 1.1.5",
]
+[[package]]
+name = "rustls"
+version = "0.23.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48e13bd8c0e9365c43cfa5c9e8f9ad49d3c8444926c9aac819e0e4dc503c8fdf"
+dependencies = [
+ "log",
+ "once_cell",
+ "ring",
+ "rustls-pki-types",
+ "rustls-webpki",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "rustls-native-certs"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a073f5dc7469f984c52ad2752b63b0807745133b6de880b7b64c1ac4c48aec4"
+dependencies = [
+ "openssl-probe",
+ "rustls-pki-types",
+ "schannel",
+ "security-framework",
+]
+
+[[package]]
+name = "rustls-pki-types"
+version = "1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f4925028c7eb5d1fcdaf196971378ed9d2c1c4efc7dc5d011256f76c99c0a96"
+dependencies = [
+ "zeroize",
+]
+
+[[package]]
+name = "rustls-platform-verifier"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1167586491e2b18b8bfbb293e8180ec17c201c4f076d7cb3070ca964e7598f98"
+dependencies = [
+ "core-foundation 0.10.1",
+ "core-foundation-sys",
+ "jni",
+ "log",
+ "once_cell",
+ "rustls",
+ "rustls-native-certs",
+ "rustls-platform-verifier-android",
+ "rustls-webpki",
+ "security-framework",
+ "security-framework-sys",
+ "webpki-root-certs",
+ "windows-sys 0.60.2",
+]
+
+[[package]]
+name = "rustls-platform-verifier-android"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eec689c0bc40ff2458a5977b6619cb718087084a18e02a131c599b62d05e1a5f"
+
+[[package]]
+name = "rustls-webpki"
+version = "0.103.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4443b1b6d39d7c663139942cc4558262562d2c84123bb6282ef177009ca8b281"
+dependencies = [
+ "ring",
+ "rustls-pki-types",
+ "untrusted",
+]
+
[[package]]
name = "rustversion"
version = "1.0.23"
@@ -3442,6 +3793,15 @@ dependencies = [
"winapi-util",
]
+[[package]]
+name = "schannel"
+version = "0.1.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9cb23c424d8ee841bb4d813677ca237e2a610067d594fec130f87d6093495ab5"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
[[package]]
name = "schemars"
version = "1.2.3"
@@ -3480,6 +3840,29 @@ version = "1.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+[[package]]
+name = "security-framework"
+version = "3.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7f4bc775c73d9a02cde8bf7b2ec4c9d12743edf609006c7facc23998404cd1d"
+dependencies = [
+ "bitflags 2.13.2",
+ "core-foundation 0.10.1",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
+]
+
+[[package]]
+name = "security-framework-sys"
+version = "2.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce2691df843ecc5d231c0b14ece2acc3efb62c0a398c7e1d875f3983ce020e3"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
[[package]]
name = "self_cell"
version = "1.3.0"
@@ -3491,6 +3874,10 @@ name = "semver"
version = "1.0.28"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
+dependencies = [
+ "serde",
+ "serde_core",
+]
[[package]]
name = "send_wrapper"
@@ -3572,6 +3959,17 @@ dependencies = [
"serde_core",
]
+[[package]]
+name = "sha2"
+version = "0.10.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
[[package]]
name = "shlex"
version = "2.0.1"
@@ -3743,6 +4141,12 @@ version = "0.11.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
+[[package]]
+name = "subtle"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
+
[[package]]
name = "syn"
version = "2.0.119"
@@ -3788,6 +4192,16 @@ dependencies = [
"web-sys",
]
+[[package]]
+name = "tar"
+version = "0.4.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f6221d9a6003c78398e3b239969f352578258df48c8eb051caadae0015bc840"
+dependencies = [
+ "filetime",
+ "libc",
+]
+
[[package]]
name = "tempfile"
version = "3.27.0"
@@ -3795,10 +4209,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
dependencies = [
"fastrand",
- "getrandom 0.3.4",
+ "getrandom 0.4.3",
"once_cell",
"rustix 1.1.5",
- "windows-sys 0.52.0",
+ "windows-sys 0.60.2",
]
[[package]]
@@ -3814,6 +4228,8 @@ dependencies = [
name = "texturecraft"
version = "0.3.1"
dependencies = [
+ "craft-menu",
+ "craft-update",
"eframe",
"egui",
"image",
@@ -3925,7 +4341,7 @@ dependencies = [
"half",
"image",
"lz4_flex",
- "quick-xml",
+ "quick-xml 0.41.0",
"rayon",
"serde",
"serde_json",
@@ -3992,7 +4408,11 @@ name = "texturecraft-ui-egui"
version = "0.3.1"
dependencies = [
"base64 0.22.1",
+ "craft-dialogs",
+ "craft-keymap",
+ "craft-quit",
"craft-ui",
+ "craft-update",
"craft-window",
"eframe",
"egui",
@@ -4084,6 +4504,36 @@ dependencies = [
"zune-jpeg",
]
+[[package]]
+name = "time"
+version = "0.3.55"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdb87b95ec50ddfa440816d227a17b2ccbdda963a316a727fda0fc4334f7d134"
+dependencies = [
+ "deranged",
+ "num-conv",
+ "powerfmt",
+ "serde_core",
+ "time-core",
+ "time-macros",
+]
+
+[[package]]
+name = "time-core"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e1c906769ad99c88eaa54e728060edef082f8e358ff32030cb7c7d315e81109"
+
+[[package]]
+name = "time-macros"
+version = "0.2.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e689342a48d2ea927c87ea50cabf8594854bf940e9310208848d680d668ed85"
+dependencies = [
+ "num-conv",
+ "time-core",
+]
+
[[package]]
name = "tinystr"
version = "0.8.5"
@@ -4266,6 +4716,12 @@ version = "1.0.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bc7d623258602320d5c55d1bc22793b57daff0ec7efc270ea7d55ce1d5f5471c"
+[[package]]
+name = "typenum"
+version = "1.20.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"
+
[[package]]
name = "uds_windows"
version = "1.2.1"
@@ -4313,6 +4769,41 @@ version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
+[[package]]
+name = "untrusted"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
+
+[[package]]
+name = "ureq"
+version = "3.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7be76686bdf7198002062423ca0d8cf9b75a27c8e1de804513b97e97b555d9d"
+dependencies = [
+ "base64 0.23.1",
+ "flate2",
+ "log",
+ "percent-encoding",
+ "rustls",
+ "rustls-pki-types",
+ "rustls-platform-verifier",
+ "ureq-proto",
+ "utf8-zero",
+]
+
+[[package]]
+name = "ureq-proto"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "622dce33c252115466d83f63e9744a18f12b4406aae51a01c15ad8fcf1185eb3"
+dependencies = [
+ "base64 0.23.1",
+ "http",
+ "httparse",
+ "log",
+]
+
[[package]]
name = "urlencoding"
version = "2.1.3"
@@ -4328,6 +4819,12 @@ dependencies = [
"utf_types",
]
+[[package]]
+name = "utf8-zero"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8c0a043c9540bae7c578c88f91dda8bd82e59ae27c21baca69c8b191aaf5a6e"
+
[[package]]
name = "utf8_iter"
version = "1.1.0"
@@ -4382,6 +4879,16 @@ dependencies = [
"vello_common",
]
+[[package]]
+name = "verifysign"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6efd25aadc22c756a9012267fae0b130278d335d6ceb512ec02ce82029b5ca9"
+dependencies = [
+ "core-foundation 0.10.1",
+ "windows-sys 0.61.2",
+]
+
[[package]]
name = "version_check"
version = "0.9.5"
@@ -4562,7 +5069,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "338e30461b3a2b67d70eb30a6d89f8e0c93a833e07d2ae89085cd070c4a00ac0"
dependencies = [
"proc-macro2",
- "quick-xml",
+ "quick-xml 0.41.0",
"quote",
]
@@ -4598,6 +5105,15 @@ dependencies = [
"wasm-bindgen",
]
+[[package]]
+name = "webpki-root-certs"
+version = "1.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e49d0e65abc00c142e8f9428da991da9f1a250c39be97459901eb12b9b49f62a"
+dependencies = [
+ "rustls-pki-types",
+]
+
[[package]]
name = "weezl"
version = "0.1.12"
@@ -4793,7 +5309,7 @@ version = "0.1.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
dependencies = [
- "windows-sys 0.52.0",
+ "windows-sys 0.60.2",
]
[[package]]
@@ -5096,7 +5612,7 @@ dependencies = [
"calloop",
"cfg_aliases",
"concurrent-queue",
- "core-foundation",
+ "core-foundation 0.9.4",
"core-graphics",
"cursor-icon",
"dpi",
@@ -5141,6 +5657,16 @@ dependencies = [
"memchr",
]
+[[package]]
+name = "winreg"
+version = "0.55.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb5a765337c50e9ec252c2069be9bf91c7df47afb103b642ba3a53bf8101be97"
+dependencies = [
+ "cfg-if",
+ "windows-sys 0.59.0",
+]
+
[[package]]
name = "winresource"
version = "0.1.34"
@@ -5457,6 +5983,12 @@ dependencies = [
"synstructure",
]
+[[package]]
+name = "zeroize"
+version = "1.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e13084392c5e4bc371903e2935a5eaeed24905a7511356b883835e18a78f6879"
+
[[package]]
name = "zerotrie"
version = "0.2.5"
diff --git a/Cargo.toml b/Cargo.toml
index 02b5a6dc..73a090c8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -63,9 +63,19 @@ getrandom = "0.3"
rustix = { version = "1", default-features = false, features = ["std", "fs", "process"] }
# Shared Craft egui components (widget palette, icon buttons, panel docking): storytold/craft-libs,
# MIT OR Apache-2.0, pinned to one rev.
-craft-ui = { git = "https://github.com/storytold/craft-libs", rev = "f8f8829cc7be65d466d687dae381d1ca60e31242", features = ["serde"] }
+craft-ui = { git = "https://github.com/storytold/craft-libs", rev = "1b34eba41e62138fc2438d2734523b302840b45d", features = ["serde"] }
# Who draws the window frame, and the app-drawn strip as the title bar (crates/ui-egui/src/titlebar.rs).
-craft-window = { git = "https://github.com/storytold/craft-libs", rev = "f8f8829cc7be65d466d687dae381d1ca60e31242", features = ["egui"] }
+craft-window = { git = "https://github.com/storytold/craft-libs", rev = "1b34eba41e62138fc2438d2734523b302840b45d", features = ["egui"] }
+# Release checks, the update prompt and the update helper (crates/ui-egui/src/updates_ui.rs).
+craft-update = { git = "https://github.com/storytold/craft-libs", rev = "1b34eba41e62138fc2438d2734523b302840b45d", features = ["egui"] }
+# File dialogs that never block the frame (crates/ui-egui/src/file_dialogs.rs).
+craft-dialogs = { git = "https://github.com/storytold/craft-libs", rev = "1b34eba41e62138fc2438d2734523b302840b45d" }
+# Shortcut chords, lookup and dispatch (crates/ui-egui/src/keymap.rs).
+craft-keymap = { git = "https://github.com/storytold/craft-libs", rev = "1b34eba41e62138fc2438d2734523b302840b45d", features = ["egui"] }
+# Quitting the macOS way instead of closing the window (crates/ui-egui/src/windows.rs).
+craft-quit = { git = "https://github.com/storytold/craft-libs", rev = "1b34eba41e62138fc2438d2734523b302840b45d", features = ["egui"] }
+# The macOS app menu whose Quit asks about unsaved changes (apps/texturecraft/src/main.rs).
+craft-menu = { git = "https://github.com/storytold/craft-libs", rev = "1b34eba41e62138fc2438d2734523b302840b45d" }
# egui 0.37 and winit: the suite's forks (storytold/egui, storytold/winit), as craft-libs pins them.
[patch.crates-io]
diff --git a/README.md b/README.md
index 80f807b6..69cd720c 100644
--- a/README.md
+++ b/README.md
@@ -32,6 +32,7 @@
+
diff --git a/apps/texturecraft/Cargo.toml b/apps/texturecraft/Cargo.toml
index 2f80d416..b4a1d57c 100644
--- a/apps/texturecraft/Cargo.toml
+++ b/apps/texturecraft/Cargo.toml
@@ -30,6 +30,12 @@ ron = "0.12"
[target.'cfg(windows)'.dependencies]
winit = { version = "0.30", default-features = false }
winsafe = { version = "0.0.29", default-features = false, features = ["user"] }
+# The update helper is a copy of this program (`main`).
+craft-update = { workspace = true }
+
+# Quit (Cmd+Q) asks about unsaved changes (src/main.rs); winit's own Quit does not.
+[target.'cfg(target_os = "macos")'.dependencies]
+craft-menu = { workspace = true }
[build-dependencies]
winresource = "0.1"
diff --git a/apps/texturecraft/src/main.rs b/apps/texturecraft/src/main.rs
index 377b2e52..4965c438 100644
--- a/apps/texturecraft/src/main.rs
+++ b/apps/texturecraft/src/main.rs
@@ -11,11 +11,17 @@ mod window_frame;
use texturecraft_engine::Session;
use texturecraft_ui_egui::titlebar::TitleBar;
+use texturecraft_ui_egui::ui_state_store;
use texturecraft_ui_egui::{TextureCraftApp, UiState};
/// The app name eframe keeps the settings under (`eframe::storage_dir`).
const APP_NAME: &str = "TextureCraft";
+/// The window's size when it opens, in points.
+const DEFAULT_SIZE: [f32; 2] = [1600.0, 960.0];
+/// The smallest size the window can be resized to, in points.
+const MIN_SIZE: [f32; 2] = [960.0, 600.0];
+
const ICON_PNG: &[u8] = include_bytes!("../../../assets/app-icon/hicolor/256x256/apps/ai.storyteller.texturecraft.png");
fn version() -> String {
@@ -115,13 +121,16 @@ fn set_taskbar_icon(w: &winit::window::Window) {
}
}
-/// Settings › Interface › System title bar, read from the saved settings before the window opens
-/// (eframe hands the app its storage only afterwards). Missing or unreadable: off.
-fn saved_system_title_bar(persistence_path: Option<&std::path::Path>) -> bool {
- let file = persistence_path.map(std::path::Path::to_path_buf).or_else(|| eframe::storage_dir(APP_NAME).map(|d| d.join("app.ron")));
- let saved = file.and_then(|f| std::fs::read_to_string(f).ok());
- let kv = saved.and_then(|s| ron::from_str::>(&s).ok());
- kv.and_then(|kv| ron::from_str::(kv.get("ui")?).ok()).is_some_and(|ui| ui.prefs.system_title_bar)
+/// Settings › Interface › System title bar, read before the window opens from `ui.json`, else as earlier builds saved it; missing or unreadable: off
+fn saved_system_title_bar(ui_file: Option<&std::path::Path>, persistence_path: Option<&std::path::Path>) -> bool {
+ if let Some(ui) = ui_file.and_then(ui_state_store::read) {
+ return ui.prefs.system_title_bar;
+ }
+
+ let file = persistence_path.map(std::path::Path::to_path_buf).or_else(|| eframe::storage_dir(APP_NAME).map(|folder| folder.join("app.ron")));
+ let saved = file.and_then(|file| std::fs::read_to_string(file).ok());
+ let entries = saved.and_then(|text| ron::from_str::>(&text).ok());
+ entries.and_then(|entries| ron::from_str::(entries.get("ui")?).ok()).is_some_and(|ui| ui.prefs.system_title_bar)
}
/// The app with the window chrome that needs the native window: the Windows borderless guard, and
@@ -161,7 +170,17 @@ impl eframe::App for Shell {
}
}
+/// A script driving the app gets no network check and no update prompt over its window.
+fn checks_for_updates_at_start(control: Option) -> bool {
+ control.is_none()
+}
+
fn main() {
+ // Windows: the update helper is a copy of this program started with `--finish-update`.
+ #[cfg(windows)]
+ if let Some(result) = craft_update::self_update::finish(&texturecraft_ui_egui::UPDATE_APP, &std::env::args_os().skip(1).collect::>()) {
+ std::process::exit(i32::from(result.is_err()));
+ }
let args = match parse_args() {
Ok(Some(a)) => a,
Ok(None) => return,
@@ -170,21 +189,25 @@ fn main() {
std::process::exit(2);
}
};
- // Errors before the window opens speak the system's language; the app then applies the saved one.
+ // Errors before the window opens speak the system's language; the app then applies the saved one
texturecraft_ui_egui::i18n::set_language(texturecraft_ui_egui::i18n::os_language());
let prev = std::panic::take_hook();
std::panic::set_hook(Box::new(move |info| {
- // A message box needs the main thread on macOS; other threads' panics are only logged.
+ // A message box needs the main thread on macOS; other threads' panics are only logged
fatal(&format!("internal error: {info}"), std::thread::current().name() == Some("main"));
prev(info);
}));
let session = initial_session(&args);
- // Scripted runs (agents, films, tests) set TEXTURECRAFT_NO_PREFS so they neither read nor
- // overwrite the user's saved UI layout and settings: state goes to a throwaway folder.
+ // Scripted runs (agents, films, tests) set TEXTURECRAFT_NO_PREFS to keep the user's saved settings untouched: state goes to throwaway files
let persistence_path =
std::env::var_os("TEXTURECRAFT_NO_PREFS").map(|_| std::env::temp_dir().join(format!("texturecraft-noprefs-{}.ron", std::process::id())));
- let title_bar = TitleBar::decide(saved_system_title_bar(persistence_path.as_deref()));
- let mut viewport = egui::ViewportBuilder::default().with_title(APP_NAME).with_inner_size([1600.0, 960.0]).with_min_inner_size([960.0, 600.0]);
+ let ui_file =
+ persistence_path.as_ref().map(|path| path.with_extension("json")).or_else(|| eframe::storage_dir(APP_NAME).map(|folder| folder.join("ui.json")));
+ if let Some(file) = &ui_file {
+ let _ = ui_state_store::FILE.set(file.clone());
+ }
+ let title_bar = TitleBar::decide(saved_system_title_bar(ui_file.as_deref(), persistence_path.as_deref()));
+ let mut viewport = egui::ViewportBuilder::default().with_title(APP_NAME).with_inner_size(DEFAULT_SIZE).with_min_inner_size(MIN_SIZE);
if let Some(i) = icon() {
viewport = viewport.with_icon(i);
}
@@ -195,7 +218,7 @@ fn main() {
std::process::exit(2);
}
let control = args.control;
- // The start window offers new, open and recent projects, unless a file was given or a script drives the app.
+ // The start window offers new, open and recent projects, unless a file was given or a script drives the app
let start = args.file.is_none() && control.is_none();
let r = eframe::run_native(
APP_NAME,
@@ -205,10 +228,16 @@ fn main() {
if let Some(w) = cc.winit_window() {
set_taskbar_icon(w);
}
+ // winit's Quit ends the process without asking; this menu's asks like the close button.
+ #[cfg(target_os = "macos")]
+ if let Err(e) = craft_menu::mac::install_app_menu(&cc.egui_ctx, APP_NAME) {
+ log::warn!("the app menu could not be installed: {e}");
+ }
let window_frame = window_frame::service(cc, matches!(title_bar, TitleBar::App(_)));
let mut app = TextureCraftApp::new(cc, session);
app.title_bar = title_bar;
app.ui.windows.start = start && app.ui.prefs.start_window;
+ app.set_startup_update_check(checks_for_updates_at_start(control));
if let Some(port) = control {
app.control = Some(control_server::start(port, cc.egui_ctx.clone()));
}
@@ -274,6 +303,12 @@ mod tests {
assert_eq!(args.gpu.as_deref(), Some("3080"));
}
+ #[test]
+ fn only_a_run_without_a_control_port_checks_for_updates_at_start() {
+ assert!(checks_for_updates_at_start(None));
+ assert!(!checks_for_updates_at_start(Some(9000)));
+ }
+
#[test]
fn rejects_missing_or_invalid_gpu_args() {
assert!(parse_args_from(["--gpu".to_string()]).is_err());
@@ -296,19 +331,27 @@ mod tests {
}
#[test]
- fn the_system_title_bar_setting_is_read_from_eframes_settings_file() {
- let path = std::env::temp_dir().join(format!("texturecraft-titlebar-test-{}.ron", std::process::id()));
+ fn the_system_title_bar_setting_is_read_from_ui_json_else_as_earlier_builds_saved_it() {
+ let ron_path = std::env::temp_dir().join(format!("texturecraft-titlebar-test-{}.ron", std::process::id()));
+ let json_path = ron_path.with_extension("json");
for on in [false, true] {
let mut ui = UiState::default();
ui.prefs.system_title_bar = on;
- // Written as eframe writes it: a pretty RON map of RON strings.
+ // Written as eframe writes it: a pretty RON map of RON strings
let kv = std::collections::HashMap::from([("ui".to_string(), ron::to_string(&ui).unwrap())]);
- std::fs::write(&path, ron::Options::default().to_string_pretty(&kv, Default::default()).unwrap()).unwrap();
- assert_eq!(saved_system_title_bar(Some(&path)), on);
+ std::fs::write(&ron_path, ron::Options::default().to_string_pretty(&kv, Default::default()).unwrap()).unwrap();
+ assert_eq!(saved_system_title_bar(None, Some(&ron_path)), on);
+
+ ui.prefs.system_title_bar = !on;
+ std::fs::write(&json_path, serde_json::to_vec(&ui).unwrap()).unwrap();
+ assert_eq!(saved_system_title_bar(Some(&json_path), Some(&ron_path)), !on, "ui.json comes first");
}
- std::fs::write(&path, "not ron").unwrap();
- assert!(!saved_system_title_bar(Some(&path)));
- std::fs::remove_file(&path).unwrap();
- assert!(!saved_system_title_bar(Some(&path)));
+
+ std::fs::write(&json_path, "not json").unwrap();
+ std::fs::write(&ron_path, "not ron").unwrap();
+ assert!(!saved_system_title_bar(Some(&json_path), Some(&ron_path)));
+ std::fs::remove_file(&json_path).unwrap();
+ std::fs::remove_file(&ron_path).unwrap();
+ assert!(!saved_system_title_bar(Some(&json_path), Some(&ron_path)));
}
}
diff --git a/crates/automation/src/security.rs b/crates/automation/src/security.rs
index 0f5e6ab5..63c12b0e 100644
--- a/crates/automation/src/security.rs
+++ b/crates/automation/src/security.rs
@@ -178,8 +178,11 @@ pub struct ConnectionLimiter(Arc);
pub struct Permit(Arc);
impl ConnectionLimiter {
- pub fn try_acquire(&self, max: usize) -> Option {
- self.0.fetch_update(Ordering::AcqRel, Ordering::Acquire, |n| (n < max).then_some(n + 1)).ok().map(|_| Permit(self.0.clone()))
+ pub fn try_acquire(&self, max_connections: usize) -> Option {
+ self.0
+ .try_update(Ordering::AcqRel, Ordering::Acquire, |connections| (connections < max_connections).then_some(connections + 1))
+ .ok()
+ .map(|_| Permit(self.0.clone()))
}
}
@@ -328,10 +331,12 @@ mod tests {
#[test]
fn limiter_releases() {
- let l = ConnectionLimiter::default();
- let p = l.try_acquire(1).unwrap();
- assert!(l.try_acquire(1).is_none());
- drop(p);
- assert!(l.try_acquire(1).is_some());
+ let limiter = ConnectionLimiter::default();
+
+ let permit = limiter.try_acquire(1).unwrap();
+ assert!(limiter.try_acquire(1).is_none());
+
+ drop(permit);
+ assert!(limiter.try_acquire(1).is_some());
}
}
diff --git a/crates/automation/src/workspace.rs b/crates/automation/src/workspace.rs
index 2015c090..1061db2d 100644
--- a/crates/automation/src/workspace.rs
+++ b/crates/automation/src/workspace.rs
@@ -127,20 +127,20 @@ fn file_error(op: &str, path: &str, e: std::io::Error) -> AutomationError {
AutomationError::Io(format!("{op} `{path}` failed: {e}"))
}
-/// Engine commands that take host paths (`file.open`, `file.exportTextures`, `resource.import`,
-/// `material.save`, …) would bypass the workspace: automation clients use the workspace-scoped
-/// methods instead. Any command given a `path` or `dir` is refused, and every `file.*` command
-/// but `file.close` and `file.removeUnused` (`file.save` even without `path`: a headless session's path is
-/// workspace-relative, not a host path; `file.reimportMesh` without `path` re-reads the
-/// embedded mesh).
+/// Host keys a command reads or writes a file through, at the top level or in each `files` entry
+const HOST_PATH_KEYS: [&str; 2] = ["path", "dir"];
+
+/// Refuses engine commands that would reach host paths around the workspace roots, so clients use the workspace tools
pub fn authorize_command(id: &str, params: &Value) -> Result<(), AutomationError> {
- let has_path = ["path", "dir"].iter().any(|k| params.get(k).is_some_and(|v| !v.is_null()));
- let ok = match id {
+ let has_path = names_host_path(params) || params.get("files").and_then(Value::as_array).is_some_and(|files| files.iter().any(names_host_path));
+
+ // `file.save` is refused even without a path: a headless session's path is workspace-relative, not a host path
+ let allowed = match id {
"file.close" | "file.removeUnused" => true,
"file.reimportMesh" => !has_path,
_ => !id.starts_with("file.") && !has_path,
};
- if ok {
+ if allowed {
Ok(())
} else {
Err(bad(format!(
@@ -149,6 +149,11 @@ pub fn authorize_command(id: &str, params: &Value) -> Result<(), AutomationError
}
}
+/// Whether `params` names a host path or folder at its own top level
+fn names_host_path(params: &Value) -> bool {
+ HOST_PATH_KEYS.iter().any(|key| params.get(key).is_some_and(|value| !value.is_null()))
+}
+
#[cfg(test)]
mod tests {
use super::*;
@@ -243,6 +248,18 @@ mod tests {
assert!(authorize_command("layer.add.fill", &json!({"color": "#ff0000", "path": null})).is_ok());
}
+ #[test]
+ fn nested_file_paths_are_denied() {
+ let outside_file = json!({"files": [{"path": "/etc/x_ao.png", "map": "ao"}]});
+ assert!(authorize_command("textureSet.meshMap.import", &outside_file).is_err());
+
+ let one_of_many = json!({"files": [{"map": "ao"}, {"path": "/etc/x_ao.png"}]});
+ assert!(authorize_command("textureSet.meshMap.import", &one_of_many).is_err());
+
+ let no_paths = json!({"files": [{"map": "ao"}, {"path": null}]});
+ assert!(authorize_command("textureSet.meshMap.import", &no_paths).is_ok());
+ }
+
/// Every registry command documenting a host path must be classified (fails when a new
/// path-taking command is added without an automation policy).
#[test]
diff --git a/crates/bake/src/cage.rs b/crates/bake/src/cage.rs
new file mode 100644
index 00000000..d2c7d7f3
--- /dev/null
+++ b/crates/bake/src/cage.rs
@@ -0,0 +1,15 @@
+//! Where the bake's transfer rays start, shared by the bake and the cage the 3D view draws
+
+mod cage_shell;
+mod high_poly_reach;
+mod ray_frame;
+mod ray_start;
+mod vertex_reach;
+
+#[cfg(test)]
+pub(crate) use cage_shell::CORNERS;
+pub use cage_shell::CageShell;
+pub use high_poly_reach::HighPolyReach;
+pub(crate) use ray_frame::RayFrame;
+pub use ray_start::RayStart;
+pub use vertex_reach::VertexReach;
diff --git a/crates/bake/src/cage/cage_shell.rs b/crates/bake/src/cage/cage_shell.rs
new file mode 100644
index 00000000..e1664219
--- /dev/null
+++ b/crates/bake/src/cage/cage_shell.rs
@@ -0,0 +1,65 @@
+use super::{RayFrame, RayStart};
+use crate::{BakeError, BakeRequest, MeshExtent};
+use rayon::prelude::*;
+use std::collections::{HashMap, HashSet};
+use texturecraft_geom::glam::Vec3;
+use texturecraft_geom::surface_at;
+
+/// Barycentric coordinates of a triangle's three corners
+pub(crate) const CORNERS: [[f32; 2]; 3] = [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]];
+
+/// The cage of one texture set as the bake sees it: where its transfer rays start at each corner of the set's triangles
+#[derive(Clone, Debug, Default)]
+pub struct CageShell {
+ /// Low-poly position of each triangle corner, three per triangle
+ pub positions: Vec,
+ pub starts: Vec,
+ /// Corner pairs along the low poly's polygon edges, for the wireframe
+ pub edges: Vec<[u32; 2]>,
+ /// World units per unit of the max frontal distance setting
+ pub cage_units: f32,
+}
+
+impl CageShell {
+ /// The cage of `request`'s texture set, from the same ray starts the bake uses
+ pub fn new(request: &BakeRequest) -> Result {
+ let ray_frame = RayFrame::new(request, MeshExtent::of(request.mesh)?)?;
+ let (frame, mesh) = (&ray_frame, request.mesh);
+ let triangles: Vec = mesh.triangles_of(request.material).collect();
+ let (positions, starts): (Vec, Vec) = triangles
+ .par_iter()
+ .flat_map_iter(|&triangle| {
+ CORNERS.into_iter().map(move |barycentric| match surface_at(mesh, triangle as u32, barycentric[0], barycentric[1]) {
+ Some(surface) => (surface.pos, frame.start(&surface, barycentric)),
+ None => (Vec3::ZERO, RayStart::Distance { up: Vec3::ZERO, scale: 0.0 }),
+ })
+ })
+ .unzip();
+
+ let wire_edges: HashSet<(u32, u32)> = mesh.wire_edges().into_iter().nth(request.material).unwrap_or_default().into_iter().collect();
+ let mut edge_corners = HashMap::new();
+ for (triangle_index, &triangle) in triangles.iter().enumerate() {
+ let Some(vertices) = mesh.tri(triangle) else { continue };
+
+ for corner in 0..3 {
+ let next = (corner + 1) % 3;
+ let (from, to) = (vertices[corner] as u32, vertices[next] as u32);
+ let key = (from.min(to), from.max(to));
+ if wire_edges.contains(&key) {
+ let first_corner = (triangle_index * 3) as u32;
+ edge_corners.entry(key).or_insert([first_corner + corner as u32, first_corner + next as u32]);
+ }
+ }
+ }
+ let mut edges: Vec<[u32; 2]> = edge_corners.into_values().collect();
+ edges.sort_unstable();
+
+ Ok(CageShell { positions, starts, edges, cage_units: ray_frame.cage_units })
+ }
+
+ /// Each corner's cage position at `max_frontal`, the setting before relative-to-bounding-box scaling
+ pub fn corners(&self, max_frontal: f32) -> Vec {
+ let frontal = max_frontal * self.cage_units;
+ self.positions.par_iter().zip(&self.starts).map(|(position, start)| start.origin(*position, frontal)).collect()
+ }
+}
diff --git a/crates/bake/src/cage/high_poly_reach.rs b/crates/bake/src/cage/high_poly_reach.rs
new file mode 100644
index 00000000..2f461343
--- /dev/null
+++ b/crates/bake/src/cage/high_poly_reach.rs
@@ -0,0 +1,105 @@
+use super::{RayFrame, VertexReach};
+use crate::map::transfer_keys;
+use crate::tracing::ANY;
+use crate::{BakeError, BakeRequest, MeshExtent};
+use rayon::prelude::*;
+use texturecraft_core::MeshMatchMode;
+use texturecraft_geom::glam::Vec3;
+use texturecraft_geom::{Mesh, surface_at};
+
+/// Where each high-poly vertex sits relative to the transfer rays of one texture set, to show which parts its bake misses
+#[derive(Clone, Debug, Default)]
+pub struct HighPolyReach {
+ /// Per high-poly vertex; `None` where another texture set's low poly is nearer or the request has no high poly
+ pub vertices: Vec>,
+ /// World units per unit of the cage distance settings
+ pub cage_units: f32,
+ pub ignore_backface: bool,
+}
+
+impl HighPolyReach {
+ /// The reach of `request`'s transfer rays at the high-poly vertices whose nearest low-poly point is on this set, from the same ray starts the bake uses there
+ pub fn new(request: &BakeRequest) -> Result {
+ let Some(high) = request.high else { return Ok(HighPolyReach::default()) };
+
+ let frame = RayFrame::new(request, MeshExtent::of(request.mesh)?)?;
+ let mut in_set = vec![false; request.mesh.triangle_count()];
+ for triangle in request.mesh.triangles_of(request.material) {
+ if let Some(flag) = in_set.get_mut(triangle) {
+ *flag = true;
+ }
+ }
+
+ let winding_normals = winding_normals(high.mesh);
+ let (low_keys, high_vertex_keys) = match request.settings.high_poly.match_mode {
+ MeshMatchMode::Always => (Vec::new(), Vec::new()),
+ MeshMatchMode::ByMeshName => {
+ let (low_keys, high_keys) = transfer_keys(request);
+ (low_keys, vertex_keys(high.mesh, &high_keys))
+ }
+ };
+ let key = |keys: &[u32], index: usize| keys.get(index).copied().unwrap_or(ANY);
+ let frame = &frame;
+ let vertices = high
+ .mesh
+ .positions
+ .par_iter()
+ .zip(&winding_normals)
+ .enumerate()
+ .map(|(vertex, (&high_position, &high_facing))| {
+ let nearest = request.bvh.nearest(high_position, f32::INFINITY, &|_| true)?;
+ if !in_set.get(nearest.tri as usize).copied().unwrap_or(false) {
+ return None;
+ }
+
+ let surface = surface_at(request.mesh, nearest.tri, nearest.u, nearest.v)?;
+ let ray_key = key(&low_keys, nearest.tri as usize);
+ Some(VertexReach {
+ low_position: surface.pos,
+ start: frame.start(&surface, [nearest.u, nearest.v]),
+ high_position,
+ high_facing,
+ name_matches: ray_key == ANY || key(&high_vertex_keys, vertex) == ray_key,
+ })
+ })
+ .collect();
+
+ Ok(HighPolyReach { vertices, cage_units: frame.cage_units, ignore_backface: request.settings.high_poly.ignore_backface })
+ }
+
+ /// Whether the transfer rays miss high-poly vertex `vertex` at the `max_frontal` and `max_rear` settings; `None` when the vertex isn't this set's
+ pub fn missed(&self, vertex: usize, max_frontal: f32, max_rear: f32) -> Option {
+ let reach = self.vertices.get(vertex).copied().flatten()?;
+ Some(reach.missed(max_frontal * self.cage_units, max_rear * self.cage_units, self.ignore_backface))
+ }
+}
+
+/// Each vertex's mesh-name key, from the first triangle that uses it
+fn vertex_keys(mesh: &Mesh, triangle_keys: &[u32]) -> Vec {
+ let mut keys = vec![ANY; mesh.positions.len()];
+ for (corners, &triangle_key) in mesh.indices.as_chunks::<3>().0.iter().zip(triangle_keys) {
+ for &corner in corners {
+ if let Some(key) = keys.get_mut(corner as usize).filter(|key| **key == ANY) {
+ *key = triangle_key;
+ }
+ }
+ }
+
+ keys
+}
+
+/// Each vertex's sum of its triangles' winding normals, weighted by area: the side the bake's backface test sees as the front
+fn winding_normals(mesh: &Mesh) -> Vec {
+ let mut normals = vec![Vec3::ZERO; mesh.positions.len()];
+ for corners in mesh.indices.as_chunks::<3>().0 {
+ let position = |corner: u32| mesh.positions.get(corner as usize).copied().unwrap_or(Vec3::ZERO);
+ let winding_normal = (position(corners[1]) - position(corners[0])).cross(position(corners[2]) - position(corners[0]));
+ for &corner in corners {
+ if let Some(normal) = normals.get_mut(corner as usize) {
+ *normal += winding_normal;
+ }
+ }
+ }
+
+ normals
+}
diff --git a/crates/bake/src/cage/ray_frame.rs b/crates/bake/src/cage/ray_frame.rs
new file mode 100644
index 00000000..e8692cf2
--- /dev/null
+++ b/crates/bake/src/cage/ray_frame.rs
@@ -0,0 +1,63 @@
+use super::RayStart;
+use crate::MeshExtent;
+use crate::map::{interpolate, welded};
+use crate::skew::PreparedSkew;
+use crate::{BakeError, BakePaintMap, BakeRequest};
+use texturecraft_core::CageType;
+use texturecraft_geom::glam::Vec3;
+use texturecraft_geom::{Mesh, Surface};
+
+/// What decides where transfer rays start: the cage mesh or the averaged normals, skew and painted cage amount
+pub(crate) struct RayFrame<'a> {
+ mesh: &'a Mesh,
+ ray_normals: Vec,
+ cage: Option<&'a Mesh>,
+ skew: Option>,
+ cage_paint: Option<&'a BakePaintMap>,
+ /// Cage-file offsets this short count as none: the ray starts from the distance-based cage instead
+ ray_epsilon: f32,
+ /// World units per unit of the cage distance settings
+ pub(crate) cage_units: f32,
+}
+
+impl<'a> RayFrame<'a> {
+ pub(crate) fn new(request: &BakeRequest<'a>, extent: MeshExtent) -> Result, BakeError> {
+ let settings = request.settings;
+ let ray_normals = match settings.cage.average_normals && request.high.is_some() {
+ true => {
+ let (welded_indices, _, normals) = welded(request.mesh, extent.diagonal);
+ welded_indices.iter().map(|index| normals.get(*index as usize).copied().unwrap_or(Vec3::Y)).collect()
+ }
+ false => Vec::new(),
+ };
+
+ Ok(RayFrame {
+ mesh: request.mesh,
+ ray_normals,
+ cage: if settings.cage.kind == CageType::CustomFile { request.cage } else { None },
+ skew: request.skew.map(|skew_map| PreparedSkew::new(skew_map, request.mesh, extent.scale, settings.skew)).transpose()?,
+ cage_paint: request.cage_paint,
+ ray_epsilon: extent.ray_epsilon(),
+ cage_units: if settings.cage.relative_to_bounding_box { extent.scale } else { 1.0 },
+ })
+ }
+
+ /// Where the transfer ray of the low-poly point `surface` at `barycentric` starts
+ pub(crate) fn start(&self, surface: &Surface, barycentric: [f32; 2]) -> RayStart {
+ let cage_offset = self
+ .cage
+ .and_then(|cage_mesh| interpolate(cage_mesh, &cage_mesh.positions, surface.tri, barycentric))
+ .map(|cage_position| surface.pos - cage_position)
+ .filter(|offset| offset.length() > self.ray_epsilon);
+ if let Some(offset) = cage_offset {
+ return RayStart::CageMesh(offset);
+ }
+
+ let averaged_normal = interpolate(self.mesh, &self.ray_normals, surface.tri, barycentric).and_then(Vec3::try_normalize).unwrap_or(surface.nrm);
+ let up = match &self.skew {
+ Some(skew) => skew.correct(self.mesh, surface, averaged_normal),
+ None => averaged_normal,
+ };
+ RayStart::Distance { up, scale: self.cage_paint.map_or(1.0, |map| map.sample(surface.uv)) }
+ }
+}
diff --git a/crates/bake/src/cage/ray_start.rs b/crates/bake/src/cage/ray_start.rs
new file mode 100644
index 00000000..c0c3923a
--- /dev/null
+++ b/crates/bake/src/cage/ray_start.rs
@@ -0,0 +1,20 @@
+use texturecraft_geom::glam::Vec3;
+
+/// Where the bake's transfer ray for one low-poly point starts
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum RayStart {
+ /// On the cage mesh: the offset from the cage to the low-poly point
+ CageMesh(Vec3),
+ /// Out along `up` by the frontal distance times `scale` (the painted cage amount)
+ Distance { up: Vec3, scale: f32 },
+}
+
+impl RayStart {
+ /// The ray origin for the low-poly point `position` at `frontal` world units of max frontal distance
+ pub fn origin(&self, position: Vec3, frontal: f32) -> Vec3 {
+ match *self {
+ RayStart::CageMesh(offset) => position - offset,
+ RayStart::Distance { up, scale } => position + up * frontal * scale,
+ }
+ }
+}
diff --git a/crates/bake/src/cage/vertex_reach.rs b/crates/bake/src/cage/vertex_reach.rs
new file mode 100644
index 00000000..34adea92
--- /dev/null
+++ b/crates/bake/src/cage/vertex_reach.rs
@@ -0,0 +1,28 @@
+use super::RayStart;
+use texturecraft_geom::glam::Vec3;
+
+/// One high-poly vertex seen from the transfer ray through its nearest low-poly point
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct VertexReach {
+ pub low_position: Vec3,
+ pub start: RayStart,
+ pub high_position: Vec3,
+ /// The side the high poly's triangles face at the vertex, by their winding (not normalized)
+ pub high_facing: Vec3,
+ /// Whether the bake lets this low-poly point's ray hit the vertex's part (always, unless matching by mesh name)
+ pub name_matches: bool,
+}
+
+impl VertexReach {
+ /// Whether the ray misses the vertex (or may not hit its part) at `frontal` and `rear` world units of cage distance; with `ignore_backface` it also misses a vertex whose triangles face away from the ray
+ pub fn missed(&self, frontal: f32, rear: f32, ignore_backface: bool) -> bool {
+ let origin = self.start.origin(self.low_position, frontal);
+ let (direction, front) = match self.start {
+ RayStart::CageMesh(offset) => (offset.normalize_or_zero(), offset.length()),
+ RayStart::Distance { up, scale } => (-up, frontal * scale),
+ };
+ let along_ray = (self.high_position - origin).dot(direction);
+
+ !self.name_matches || !(0.0..=front + rear).contains(&along_ray) || (ignore_backface && self.high_facing.dot(direction) > 0.0)
+ }
+}
diff --git a/crates/bake/src/lib.rs b/crates/bake/src/lib.rs
index a8b087bc..eb8a61de 100644
--- a/crates/bake/src/lib.rs
+++ b/crates/bake/src/lib.rs
@@ -6,13 +6,17 @@
mod bake_error;
mod bake_output;
mod bake_request;
+mod cage;
mod high_poly;
+mod mesh_extent;
mod progress;
pub use bake_error::BakeError;
pub use bake_output::BakeOutput;
pub use bake_request::BakeRequest;
+pub use cage::{CageShell, HighPolyReach, RayStart, VertexReach};
pub use high_poly::HighPoly;
+pub(crate) use mesh_extent::MeshExtent;
pub use progress::Progress;
mod map;
diff --git a/crates/bake/src/map.rs b/crates/bake/src/map.rs
index 384d9d02..c9c30fd6 100644
--- a/crates/bake/src/map.rs
+++ b/crates/bake/src/map.rs
@@ -15,10 +15,13 @@ mod source;
mod texel_grid;
mod traced;
mod transfer;
+mod transfer_keys;
pub(crate) use bake_context::BakeContext;
pub(crate) use normal_curvature::curvature_from_normal;
pub(crate) use sample::Sample;
+pub(crate) use sampling::{interpolate, welded};
pub(crate) use texel_grid::TexelGrid;
pub(crate) use traced::Traced;
pub(crate) use transfer::Transfer;
+pub(crate) use transfer_keys::transfer_keys;
diff --git a/crates/bake/src/map/bake_context.rs b/crates/bake/src/map/bake_context.rs
index 21fed094..f3e35df6 100644
--- a/crates/bake/src/map/bake_context.rs
+++ b/crates/bake/src/map/bake_context.rs
@@ -1,28 +1,22 @@
use super::curvature::Curvature;
-use super::sampling::{interpolate, pack, splitmix64, tangent_normal, welded};
+use super::sampling::{pack, splitmix64, tangent_normal};
use super::{position_projection::PositionProjection, source::Source, traced::Traced, transfer::Transfer};
-use crate::skew::PreparedSkew;
+use crate::cage::{RayFrame, RayStart};
use crate::tracing::{ANY, Hemisphere, Query, Ray, RayKind, RayScene, TraceMesh};
-use crate::{BakeError, BakeRequest};
+use crate::{BakeError, BakeRequest, MeshExtent};
use rayon::prelude::*;
-use std::collections::HashMap;
use texturecraft_core::{
- AmbientOcclusionAttenuation, BackfaceMode, BakeSettings, BakedMap, CageType, CurvatureMethod, MeshMatchMode, RayDistribution, RaySettings, SelfOcclusion,
+ AmbientOcclusionAttenuation, BackfaceMode, BakeSettings, BakedMap, CurvatureMethod, MeshMatchMode, RayDistribution, RaySettings, SelfOcclusion,
};
-use texturecraft_geom::glam::Vec3;
-use texturecraft_geom::{Hit, Mesh, Surface, surface_at};
+use texturecraft_geom::{Hit, Surface, surface_at};
const CURVATURE_CHUNK: usize = 1 << 15;
pub(crate) struct BakeContext<'a> {
low: Source<'a>,
high: Option>,
- cage: Option<&'a Mesh>,
- skew: Option>,
- cage_paint: Option<&'a crate::BakePaintMap>,
- ray_normals: Vec,
+ ray_frame: RayFrame<'a>,
settings: &'a BakeSettings,
- eps: f32,
frontal: f32,
rear: f32,
position: PositionProjection,
@@ -36,36 +30,10 @@ pub(crate) struct BakeContext<'a> {
impl<'a> BakeContext<'a> {
pub(crate) fn new(request: &BakeRequest<'a>) -> Result, BakeError> {
let settings = request.settings;
- let (bounds_min, bounds_max) = request.mesh.bounds();
- let mesh_diagonal = (bounds_max - bounds_min).length().max(1e-6);
- if !mesh_diagonal.is_finite() {
- return Err(BakeError::Invalid("mesh bounds are too large".into()));
- }
-
- let mesh_scale = (bounds_max - bounds_min).max_element().max(1e-6);
- let mut name_keys = HashMap::new();
- let low = Source::new(request.mesh, request.bvh, request.low_base_color, &[], &settings.high_poly.low_suffix, &settings.high_poly, &mut name_keys);
- let high = request.high.map(|high_mesh| {
- Source::new(
- high_mesh.mesh,
- high_mesh.bvh,
- high_mesh.base_color,
- high_mesh.file_ids,
- &settings.high_poly.high_suffix,
- &settings.high_poly,
- &mut name_keys,
- )
- });
- let ray_normals = match settings.cage.average_normals && high.is_some() {
- true => {
- let (welded_indices, _, normals) = welded(request.mesh, mesh_diagonal);
- welded_indices.iter().map(|index| normals.get(*index as usize).copied().unwrap_or(Vec3::Y)).collect()
- }
- false => Vec::new(),
- };
-
- let skew = request.skew.map(|skew_map| PreparedSkew::new(skew_map, request.mesh, mesh_scale, settings.skew)).transpose()?;
- let ray_epsilon = 1e-6 * mesh_diagonal;
+ let extent = MeshExtent::of(request.mesh)?;
+ let (low, high) = Source::of_request(request);
+ let ray_frame = RayFrame::new(request, extent)?;
+ let (mesh_scale, ray_epsilon) = (extent.scale, extent.ray_epsilon());
let pass = |map: BakedMap, ray_settings: &RaySettings, kind: RayKind| {
let half_angle_radians = (ray_settings.spread.clamp(0.0, 180.0) * 0.5).to_radians();
let units = if ray_settings.relative_to_bounding_box { mesh_scale } else { 1.0 };
@@ -91,27 +59,26 @@ impl<'a> BakeContext<'a> {
pass.ignore_backface = parameters.ignore_backface;
pass.same_key = parameters.self_occlusion == SelfOcclusion::SameMeshName;
pass.attenuation = parameters.attenuation;
- pass.ground_height = parameters.ground_plane.enabled.then_some(bounds_min.y - parameters.ground_plane.offset);
+ pass.ground_height = parameters.ground_plane.enabled.then_some(extent.bounds_min.y - parameters.ground_plane.offset);
}
+
let mut bent = pass(BakedMap::BentNormal, &settings.maps.bent_normal.parameters.rays, RayKind::Occlusion);
if let Some(pass) = &mut bent {
pass.ignore_backface = settings.maps.bent_normal.parameters.ignore_backface;
pass.same_key = settings.maps.bent_normal.parameters.self_occlusion == SelfOcclusion::SameMeshName;
}
+
let mut thickness = pass(BakedMap::Thickness, &settings.maps.thickness.parameters.rays, RayKind::Thickness);
if let Some(pass) = &mut thickness {
pass.same_key = settings.maps.thickness.parameters.self_occlusion == SelfOcclusion::SameMeshName;
}
- let cage_units = if settings.cage.relative_to_bounding_box { mesh_scale } else { 1.0 };
+
+ let cage_units = ray_frame.cage_units;
Ok(BakeContext {
low,
high,
- cage: if settings.cage.kind == CageType::CustomFile { request.cage } else { None },
- skew,
- cage_paint: request.cage_paint,
- ray_normals,
+ ray_frame,
settings,
- eps: ray_epsilon,
frontal: settings.cage.max_frontal * cage_units,
rear: settings.cage.max_rear * cage_units,
position: PositionProjection::new(request.mesh, request.material, settings.maps.position.parameters),
@@ -140,22 +107,11 @@ impl<'a> BakeContext<'a> {
}
pub(crate) fn transfer_ray(&self, surface: &Surface, barycentric: [f32; 2]) -> (Ray, f32) {
- let averaged_normal = interpolate(self.low.mesh, &self.ray_normals, surface.tri, barycentric).and_then(Vec3::try_normalize).unwrap_or(surface.nrm);
- let cage = self
- .cage
- .and_then(|cage_mesh| interpolate(cage_mesh, &cage_mesh.positions, surface.tri, barycentric))
- .map(|cage_position| surface.pos - cage_position)
- .filter(|offset| offset.length() > self.eps);
- let cage_scale = self.cage_paint.map_or(1.0, |map| map.sample(surface.uv));
- let (origin, direction, front) = match cage {
- Some(offset) => (surface.pos - offset, offset.normalize(), offset.length()),
- None => {
- let up = match &self.skew {
- Some(skew) => skew.correct(self.low.mesh, surface, averaged_normal),
- None => averaged_normal,
- };
- (surface.pos + up * self.frontal * cage_scale, -up, self.frontal * cage_scale)
- }
+ let start = self.ray_frame.start(surface, barycentric);
+ let origin = start.origin(surface.pos, self.frontal);
+ let (direction, front) = match start {
+ RayStart::CageMesh(offset) => (offset.normalize(), offset.length()),
+ RayStart::Distance { up, scale } => (-up, self.frontal * scale),
};
let key = match self.settings.high_poly.match_mode {
MeshMatchMode::Always => ANY,
diff --git a/crates/bake/src/map/sampling.rs b/crates/bake/src/map/sampling.rs
index d19e4afa..5f2d2677 100644
--- a/crates/bake/src/map/sampling.rs
+++ b/crates/bake/src/map/sampling.rs
@@ -3,34 +3,43 @@ use std::ops::{Add, Mul};
use texturecraft_geom::glam::Vec3;
use texturecraft_geom::{Mesh, Surface};
-pub(super) fn interpolate + Add>(mesh: &Mesh, v: &[T], tri: u32, [b1, b2]: [f32; 2]) -> Option {
- let [a, b, c] = mesh.tri(tri as usize)?;
- Some(*v.get(a)? * (1.0 - b1 - b2) + *v.get(b)? * b1 + *v.get(c)? * b2)
+/// `values` (one per vertex) at `barycentric` in triangle `triangle`
+pub(crate) fn interpolate + Add>(mesh: &Mesh, values: &[T], triangle: u32, barycentric: [f32; 2]) -> Option {
+ let [first, second, third] = mesh.tri(triangle as usize)?;
+ let [second_weight, third_weight] = barycentric;
+
+ Some(*values.get(first)? * (1.0 - second_weight - third_weight) + *values.get(second)? * second_weight + *values.get(third)? * third_weight)
}
-pub(super) fn welded(mesh: &Mesh, diag: f32) -> (Vec, Vec, Vec) {
- let q = diag * 1e-5;
- let mut ids: HashMap<[i64; 3], u32> = HashMap::new();
- let (mut pos, mut nrm) = (Vec::new(), Vec::::new());
- let weld: Vec = mesh
+/// Vertices closer than this fraction of the mesh diagonal count as one when welding
+const WELD_TOLERANCE_PER_DIAGONAL: f32 = 1e-5;
+
+/// Vertices that share a position merged: each vertex's welded index, the welded positions and their averaged normals
+pub(crate) fn welded(mesh: &Mesh, diagonal: f32) -> (Vec, Vec, Vec) {
+ let tolerance = diagonal * WELD_TOLERANCE_PER_DIAGONAL;
+ let mut welded_index_of_cell: HashMap<[i64; 3], u32> = HashMap::new();
+ let (mut positions, mut normal_sums) = (Vec::new(), Vec::::new());
+
+ let welded_indices: Vec = mesh
.positions
.iter()
.zip(&mesh.normals)
- .map(|(p, n)| {
- let key = [p.x, p.y, p.z].map(|c| (c / q).round() as i64);
- let id = *ids.entry(key).or_insert_with(|| {
- pos.push(*p);
- nrm.push(Vec3::ZERO);
- (pos.len() - 1) as u32
+ .map(|(position, normal)| {
+ let cell = [position.x, position.y, position.z].map(|coordinate| (coordinate / tolerance).round() as i64);
+ let welded_index = *welded_index_of_cell.entry(cell).or_insert_with(|| {
+ positions.push(*position);
+ normal_sums.push(Vec3::ZERO);
+ (positions.len() - 1) as u32
});
- if let Some(acc) = nrm.get_mut(id as usize) {
- *acc += *n;
+ if let Some(normal_sum) = normal_sums.get_mut(welded_index as usize) {
+ *normal_sum += *normal;
}
- id
+ welded_index
})
.collect();
- let nrm = nrm.into_iter().map(|n| n.try_normalize().unwrap_or(Vec3::ZERO)).collect();
- (weld, pos, nrm)
+
+ let normals = normal_sums.into_iter().map(|normal_sum| normal_sum.try_normalize().unwrap_or(Vec3::ZERO)).collect();
+ (welded_indices, positions, normals)
}
pub(super) fn splitmix64(x: u64) -> u64 {
diff --git a/crates/bake/src/map/source.rs b/crates/bake/src/map/source.rs
index 0e1f9164..ad057b11 100644
--- a/crates/bake/src/map/source.rs
+++ b/crates/bake/src/map/source.rs
@@ -1,4 +1,5 @@
use super::sampling::{generated_hue, interpolate, splitmix64};
+use crate::BakeRequest;
use crate::tracing::{ANY, TraceMesh};
use std::collections::HashMap;
use std::sync::Arc;
@@ -21,6 +22,18 @@ pub(super) struct Source<'a> {
}
impl<'a> Source<'a> {
+ /// `request`'s low and high poly, their mesh names keyed from one shared table so the bake can match a low-poly part to its high-poly part
+ pub(super) fn of_request(request: &BakeRequest<'a>) -> (Source<'a>, Option>) {
+ let settings = &request.settings.high_poly;
+ let mut name_keys = HashMap::new();
+ let low = Source::new(request.mesh, request.bvh, request.low_base_color, &[], &settings.low_suffix, settings, &mut name_keys);
+ let high = request.high.map(|high_mesh| {
+ Source::new(high_mesh.mesh, high_mesh.bvh, high_mesh.base_color, high_mesh.file_ids, &settings.high_suffix, settings, &mut name_keys)
+ });
+
+ (low, high)
+ }
+
pub(super) fn new(
mesh: &'a Mesh,
bvh: &'a Bvh,
diff --git a/crates/bake/src/map/transfer_keys.rs b/crates/bake/src/map/transfer_keys.rs
new file mode 100644
index 00000000..69e9b12a
--- /dev/null
+++ b/crates/bake/src/map/transfer_keys.rs
@@ -0,0 +1,8 @@
+use super::source::Source;
+use crate::BakeRequest;
+
+/// The bake's mesh-name key of each low-poly and each high-poly triangle: with By Mesh Name a transfer ray from a low-poly triangle only hits high-poly triangles with its key
+pub(crate) fn transfer_keys(request: &BakeRequest) -> (Vec, Vec) {
+ let (low, high) = Source::of_request(request);
+ (low.key, high.map(|high| high.key).unwrap_or_default())
+}
diff --git a/crates/bake/src/mesh_extent.rs b/crates/bake/src/mesh_extent.rs
new file mode 100644
index 00000000..3c6fa48d
--- /dev/null
+++ b/crates/bake/src/mesh_extent.rs
@@ -0,0 +1,35 @@
+use crate::BakeError;
+use texturecraft_geom::Mesh;
+use texturecraft_geom::glam::Vec3;
+
+/// Smallest size a mesh is treated as having, so a flat or empty mesh still gives finite distances
+const MIN_MESH_SIZE: f32 = 1e-6;
+
+/// How far a ray starts past the surface it leaves, as a fraction of the mesh diagonal
+const RAY_EPSILON_PER_DIAGONAL: f32 = 1e-6;
+
+/// The low-poly mesh's size, which scales the bake's relative distances
+#[derive(Clone, Copy, Debug)]
+pub(crate) struct MeshExtent {
+ pub(crate) bounds_min: Vec3,
+ pub(crate) diagonal: f32,
+ /// The bounding box's largest side
+ pub(crate) scale: f32,
+}
+
+impl MeshExtent {
+ pub(crate) fn of(mesh: &Mesh) -> Result {
+ let (bounds_min, bounds_max) = mesh.bounds();
+ let diagonal = (bounds_max - bounds_min).length().max(MIN_MESH_SIZE);
+ if !diagonal.is_finite() {
+ return Err(BakeError::Invalid("mesh bounds are too large".into()));
+ }
+
+ Ok(MeshExtent { bounds_min, diagonal, scale: (bounds_max - bounds_min).max_element().max(MIN_MESH_SIZE) })
+ }
+
+ /// How far a ray starts past the surface it leaves, in world units
+ pub(crate) fn ray_epsilon(&self) -> f32 {
+ RAY_EPSILON_PER_DIAGONAL * self.diagonal
+ }
+}
diff --git a/crates/bake/src/test/cage_shell.rs b/crates/bake/src/test/cage_shell.rs
new file mode 100644
index 00000000..2d114b06
--- /dev/null
+++ b/crates/bake/src/test/cage_shell.rs
@@ -0,0 +1,103 @@
+use super::settings;
+use crate::cage::CORNERS;
+use crate::map::BakeContext;
+use crate::{BakePaintMap, BakeRequest, CageShell, HighPoly};
+use texturecraft_core::{BakedMap, CageType};
+use texturecraft_geom::glam::{Vec2, Vec3};
+use texturecraft_geom::{Bvh, Mesh, primitives, surface_at};
+
+/// A painted map whose values vary over the UV square
+fn painted_map() -> BakePaintMap {
+ let mut map = BakePaintMap::constant(0.25).resized(32, 32).unwrap();
+ map.paint(&[Vec2::new(0.2, 0.3), Vec2::new(0.7, 0.6)], 0.3, 1.0, 0.5, 1.0).unwrap();
+ map
+}
+
+/// Every corner of `request`'s cage equals the origin of the bake's transfer ray at that corner, bit for bit
+fn assert_cage_matches_the_ray_origins(request: &BakeRequest) {
+ let shell = CageShell::new(request).unwrap();
+ let corners = shell.corners(request.settings.cage.max_frontal);
+ let context = BakeContext::new(request).unwrap();
+ let triangles: Vec = request.mesh.triangles_of(request.material).collect();
+ assert_eq!(corners.len(), triangles.len() * 3);
+
+ for (corner_index, corner) in corners.iter().enumerate() {
+ let barycentric = CORNERS[corner_index % 3];
+ let surface = surface_at(request.mesh, triangles[corner_index / 3] as u32, barycentric[0], barycentric[1]).unwrap();
+ let (ray, _) = context.transfer_ray(&surface, barycentric);
+ assert_eq!(*corner, ray.origin, "corner {corner_index}");
+ }
+}
+
+#[test]
+fn the_cage_corners_are_the_bake_ray_origins() {
+ let low = primitives::cube(1.0);
+ let high_mesh = primitives::sphere(0.8, 16, 8);
+ let (low_bvh, high_bvh) = (Bvh::new(&low), Bvh::new(&high_mesh));
+ let high = HighPoly { file_ids: &[], mesh: &high_mesh, bvh: &high_bvh, base_color: &[] };
+ let (skew, cage_paint) = (painted_map(), painted_map());
+ let mut bake_settings = settings(16, &[BakedMap::Normal]);
+ bake_settings.cage.max_frontal = 0.03;
+ bake_settings.skew.edge_protection = true;
+ let request = |settings| BakeRequest {
+ low_base_color: &[],
+ mesh: &low,
+ bvh: &low_bvh,
+ material: 0,
+ settings,
+ high: Some(high),
+ cage: None,
+ skew: Some(&skew),
+ cage_paint: Some(&cage_paint),
+ tiles: (1, 1),
+ };
+
+ assert_cage_matches_the_ray_origins(&request(&bake_settings));
+ let face_normals = {
+ let mut face_normals = bake_settings.clone();
+ face_normals.cage.average_normals = false;
+ face_normals.cage.relative_to_bounding_box = false;
+ face_normals
+ };
+ assert_cage_matches_the_ray_origins(&request(&face_normals));
+}
+
+#[test]
+fn the_cage_follows_the_frontal_distance_and_a_cage_mesh() {
+ let low = primitives::cube(1.0);
+ let low_bvh = Bvh::new(&low);
+ let high = HighPoly { file_ids: &[], mesh: &low, bvh: &low_bvh, base_color: &[] };
+ let mut bake_settings = settings(16, &[BakedMap::Normal]);
+ bake_settings.cage.relative_to_bounding_box = false;
+ let request = BakeRequest {
+ low_base_color: &[],
+ mesh: &low,
+ bvh: &low_bvh,
+ material: 0,
+ settings: &bake_settings,
+ high: Some(high),
+ cage: None,
+ skew: None,
+ cage_paint: None,
+ tiles: (1, 1),
+ };
+ let shell = CageShell::new(&request).unwrap();
+ let distance_from_the_cube = |max_frontal: f32| shell.corners(max_frontal).iter().map(|corner| corner.abs().max_element() - 0.5).fold(0.0, f32::max);
+
+ assert!(distance_from_the_cube(0.0).abs() < 1e-6, "at frontal 0 the cage is the low poly");
+ // Averaged normals point diagonally at the corners, so a corner moves out by at least half the distance along each axis
+ assert!(distance_from_the_cube(0.2) > 0.1 && distance_from_the_cube(0.2) <= 0.2 + 1e-6, "the cage grows with the frontal distance");
+ assert_eq!(shell.edges.len(), low.wire_edges()[0].len(), "one wireframe line per polygon edge");
+
+ let cage_mesh = Mesh { positions: low.positions.iter().map(|position| *position * 1.5).collect(), ..low.clone() };
+ let custom_settings = {
+ let mut custom_settings = bake_settings.clone();
+ custom_settings.cage.kind = CageType::CustomFile;
+ custom_settings
+ };
+ let custom = BakeRequest { settings: &custom_settings, cage: Some(&cage_mesh), ..request };
+ assert_cage_matches_the_ray_origins(&custom);
+ let corners = CageShell::new(&custom).unwrap().corners(0.0);
+ assert!(corners.iter().all(|corner| (corner.abs().max_element() - 0.75).abs() < 1e-6), "the cage mesh is drawn as it is");
+ assert!(corners.iter().all(|corner| corner.is_finite() && *corner != Vec3::ZERO));
+}
diff --git a/crates/bake/src/test/high_poly_reach.rs b/crates/bake/src/test/high_poly_reach.rs
new file mode 100644
index 00000000..8a4f83c4
--- /dev/null
+++ b/crates/bake/src/test/high_poly_reach.rs
@@ -0,0 +1,223 @@
+use super::settings;
+use crate::map::{BakeContext, transfer_keys};
+use crate::tracing::ANY;
+use crate::{BakeRequest, HighPoly, HighPolyReach, RayStart};
+use texturecraft_core::{BakedMap, MeshMatchMode};
+use texturecraft_geom::glam::Vec3;
+use texturecraft_geom::{Bvh, Mesh, primitives, surface_at};
+
+/// Ray distances closer than this to the end of the ray's range are left out: rounding decides them
+const BOUNDARY: f32 = 1e-4;
+
+/// How close the ray's hit must be to the vertex to count as reaching it
+const HIT_TOLERANCE: f32 = 1e-4;
+
+/// A bumpy plane over the flat low poly, with the triangles right of `FLIPPED_FROM_X` wound the other way
+fn bumpy_high_poly() -> (Mesh, Vec) {
+ const FLIPPED_FROM_X: f32 = 0.2;
+
+ let mut mesh = primitives::plane(1.0, 40);
+ for position in &mut mesh.positions {
+ position.y = 0.04 * (position.x * 9.0).sin() * (position.z * 7.0).cos() + 0.005;
+ }
+
+ let mut flipped = vec![false; mesh.positions.len()];
+ let mut unflipped = vec![false; mesh.positions.len()];
+ for corners in mesh.indices.as_chunks_mut::<3>().0 {
+ let center_x = corners.iter().map(|&corner| mesh.positions[corner as usize].x).sum::() / 3.0;
+ if center_x > FLIPPED_FROM_X {
+ corners.swap(1, 2);
+ }
+ for &corner in corners.iter() {
+ if center_x > FLIPPED_FROM_X { flipped[corner as usize] = true } else { unflipped[corner as usize] = true }
+ }
+ }
+
+ // Vertices on the border face both ways: neither answer is right for them
+ let mixed = flipped.iter().zip(&unflipped).map(|(flipped, unflipped)| *flipped && *unflipped).collect();
+ (mesh, mixed)
+}
+
+#[test]
+fn a_vertex_is_missed_exactly_when_the_bake_ray_misses_it() {
+ let low = primitives::plane(1.0, 8);
+ let (high_mesh, mixed) = bumpy_high_poly();
+ let (low_bvh, high_bvh) = (Bvh::new(&low), Bvh::new(&high_mesh));
+ let high = HighPoly { file_ids: &[], mesh: &high_mesh, bvh: &high_bvh, base_color: &[] };
+ let back_facing = |triangle: u32, direction: Vec3| {
+ let [a, b, c] = high_mesh.tri(triangle as usize).unwrap().map(|corner| high_mesh.positions[corner]);
+ (b - a).cross(c - a).dot(direction) > 0.0
+ };
+ let mut checked = [0usize; 2];
+
+ for ignore_backface in [false, true] {
+ for (max_frontal, max_rear) in [(0.0, 0.01), (0.02, 0.0), (0.02, 0.01), (0.05, 0.05)] {
+ let mut bake_settings = settings(16, &[BakedMap::Normal]);
+ bake_settings.cage.relative_to_bounding_box = false;
+ bake_settings.high_poly.ignore_backface = ignore_backface;
+ (bake_settings.cage.max_frontal, bake_settings.cage.max_rear) = (max_frontal, max_rear);
+ let request = BakeRequest {
+ low_base_color: &[],
+ mesh: &low,
+ bvh: &low_bvh,
+ material: 0,
+ settings: &bake_settings,
+ high: Some(high),
+ cage: None,
+ skew: None,
+ cage_paint: None,
+ tiles: (1, 1),
+ };
+ let reach = HighPolyReach::new(&request).unwrap();
+ let context = BakeContext::new(&request).unwrap();
+
+ for (vertex, vertex_reach) in reach.vertices.iter().enumerate() {
+ let (vertex_reach, missed) = (vertex_reach.unwrap(), reach.missed(vertex, max_frontal, max_rear).unwrap());
+ let RayStart::Distance { scale, .. } = vertex_reach.start else { panic!("a distance-based cage") };
+ let height = vertex_reach.high_position.y - vertex_reach.low_position.y;
+ let near_the_range_end = [max_frontal * scale, -max_rear].iter().any(|end| (height - end).abs() < BOUNDARY);
+ if near_the_range_end || mixed[vertex] {
+ continue;
+ }
+
+ let nearest = low_bvh.nearest(vertex_reach.high_position, f32::INFINITY, &|_| true).unwrap();
+ let surface = surface_at(&low, nearest.tri, nearest.u, nearest.v).unwrap();
+ let (ray, _) = context.transfer_ray(&surface, [nearest.u, nearest.v]);
+ let hit = high_bvh
+ .closest_filtered(ray.origin, ray.direction, ray.max_distance, &|triangle| !(ignore_backface && back_facing(triangle, ray.direction)));
+ let reaches_the_vertex = hit.is_some_and(|hit| (ray.origin + ray.direction * hit.t - vertex_reach.high_position).length() < HIT_TOLERANCE);
+ assert_eq!(
+ missed, !reaches_the_vertex,
+ "vertex {vertex}, ignore backface {ignore_backface}, frontal {max_frontal}, rear {max_rear}: height {height}"
+ );
+ checked[usize::from(missed)] += 1;
+ }
+ }
+ }
+ assert!(checked[0] > 100 && checked[1] > 100, "both reached and missed vertices were compared: {checked:?}");
+}
+
+#[test]
+fn a_vertex_belongs_to_the_texture_set_whose_low_poly_is_nearest() {
+ let mut low = primitives::plane(1.0, 4);
+ let mut right = primitives::plane(1.0, 4);
+ for position in &mut right.positions {
+ position.x += 2.0;
+ }
+ low.append(&right);
+ assert_eq!(low.materials.len(), 2, "each plane is its own texture set");
+ let mut high_mesh = primitives::plane(3.0, 30);
+ for position in &mut high_mesh.positions {
+ position.x += 1.0;
+ position.y = 0.3;
+ }
+ let (low_bvh, high_bvh) = (Bvh::new(&low), Bvh::new(&high_mesh));
+ let bake_settings = settings(16, &[BakedMap::Normal]);
+ let request = |material| BakeRequest {
+ low_base_color: &[],
+ mesh: &low,
+ bvh: &low_bvh,
+ material,
+ settings: &bake_settings,
+ high: Some(HighPoly { file_ids: &[], mesh: &high_mesh, bvh: &high_bvh, base_color: &[] }),
+ cage: None,
+ skew: None,
+ cage_paint: None,
+ tiles: (1, 1),
+ };
+ let (left, right) = (HighPolyReach::new(&request(0)).unwrap(), HighPolyReach::new(&request(1)).unwrap());
+
+ for (vertex, position) in high_mesh.positions.iter().enumerate() {
+ let owners = (left.vertices[vertex].is_some(), right.vertices[vertex].is_some());
+ assert!(owners != (true, true), "vertex {vertex} belongs to one set at most");
+ if position.x < 0.9 {
+ assert_eq!(owners, (true, false), "vertex {vertex} at {position} is over the left set");
+ } else if position.x > 1.1 {
+ assert_eq!(owners, (false, true), "vertex {vertex} at {position} is over the right set");
+ }
+ }
+}
+
+#[test]
+fn matching_by_mesh_name_misses_the_parts_with_another_name() {
+ const HEIGHT_INSIDE_THE_CAGE: f32 = 0.01;
+
+ let mut low = primitives::plane(1.0, 8);
+ low.submeshes[0].name = "part_low".into();
+ let mut high_mesh = primitives::plane(0.5, 10);
+ let mut other_part = primitives::plane(0.5, 10);
+ for (mesh, center_x) in [(&mut high_mesh, -0.25), (&mut other_part, 0.25)] {
+ for position in &mut mesh.positions {
+ position.x += center_x;
+ position.y = HEIGHT_INSIDE_THE_CAGE;
+ }
+ }
+ high_mesh.append(&other_part);
+ high_mesh.submeshes[0].name = "part_high".into();
+ high_mesh.submeshes[1].name = "other_high".into();
+ let (low_bvh, high_bvh) = (Bvh::new(&low), Bvh::new(&high_mesh));
+ let mut bake_settings = settings(16, &[BakedMap::Normal]);
+ bake_settings.cage.relative_to_bounding_box = false;
+ bake_settings.cage.max_frontal = 0.02;
+ bake_settings.high_poly.match_mode = MeshMatchMode::ByMeshName;
+ let request = BakeRequest {
+ low_base_color: &[],
+ mesh: &low,
+ bvh: &low_bvh,
+ material: 0,
+ settings: &bake_settings,
+ high: Some(HighPoly { file_ids: &[], mesh: &high_mesh, bvh: &high_bvh, base_color: &[] }),
+ cage: None,
+ skew: None,
+ cage_paint: None,
+ tiles: (1, 1),
+ };
+ let reach = HighPolyReach::new(&request).unwrap();
+ let context = BakeContext::new(&request).unwrap();
+ let (_, high_keys) = transfer_keys(&request);
+
+ for (vertex, vertex_reach) in reach.vertices.iter().enumerate() {
+ let (vertex_reach, missed) = (vertex_reach.unwrap(), reach.missed(vertex, 0.02, 0.01).unwrap());
+ // On the line where the two parts meet, a ray reaches either part's triangles
+ if vertex_reach.high_position.x.abs() < BOUNDARY {
+ continue;
+ }
+
+ let nearest = low_bvh.nearest(vertex_reach.high_position, f32::INFINITY, &|_| true).unwrap();
+ let surface = surface_at(&low, nearest.tri, nearest.u, nearest.v).unwrap();
+ let (ray, _) = context.transfer_ray(&surface, [nearest.u, nearest.v]);
+ let same_name = |triangle: u32| ray.key == ANY || high_keys.get(triangle as usize) == Some(&ray.key);
+ let hit = high_bvh.closest_filtered(ray.origin, ray.direction, ray.max_distance, &same_name);
+ let reaches_the_vertex = hit.is_some_and(|hit| (ray.origin + ray.direction * hit.t - vertex_reach.high_position).length() < HIT_TOLERANCE);
+ assert_eq!(missed, !reaches_the_vertex, "vertex {vertex} at {}", vertex_reach.high_position);
+ assert_eq!(
+ missed,
+ vertex >= high_mesh.positions.len() - other_part.positions.len(),
+ "only the part named like the low poly is reached: vertex {vertex}"
+ );
+ }
+}
+
+#[test]
+fn without_a_high_poly_no_vertex_has_a_reach() {
+ let low = primitives::plane(1.0, 4);
+ let low_bvh = Bvh::new(&low);
+ let bake_settings = settings(16, &[BakedMap::Normal]);
+ let request = BakeRequest {
+ low_base_color: &[],
+ mesh: &low,
+ bvh: &low_bvh,
+ material: 0,
+ settings: &bake_settings,
+ high: None,
+ cage: None,
+ skew: None,
+ cage_paint: None,
+ tiles: (1, 1),
+ };
+
+ let reach = HighPolyReach::new(&request).unwrap();
+ assert!(reach.vertices.is_empty());
+ // Any cage distances: there is no vertex to miss
+ assert_eq!(reach.missed(0, 0.02, 0.01), None);
+}
diff --git a/crates/bake/src/test/setting.rs b/crates/bake/src/test/setting.rs
index b490655d..668338a7 100644
--- a/crates/bake/src/test/setting.rs
+++ b/crates/bake/src/test/setting.rs
@@ -41,13 +41,18 @@ fn matching_skips_a_closer_unrelated_high_mesh_and_backfaces() {
parameters.cage.relative_to_bounding_box = false;
parameters.maps.height.parameters.normalization = HeightNormalization::Manual;
let height = |parameters: &BakeSettings, high: &Mesh| transfer(&low, high, None, parameters).unwrap().maps[&BakedMap::Height][128];
+
assert!((height(¶meters, &high) - 0.54).abs() < 1e-5);
+
parameters.high_poly.match_mode = MeshMatchMode::ByMeshName;
assert!((height(¶meters, &high) - 0.52).abs() < 1e-5);
- for triangle in high.indices.chunks_exact_mut(3) {
+
+ for triangle in high.indices.as_chunks_mut::<3>().0 {
triangle.swap(1, 2);
}
+
assert_eq!(height(¶meters, &high), 0.5);
+
parameters.high_poly.ignore_backface = false;
assert!((height(¶meters, &high) - 0.52).abs() < 1e-5);
}
@@ -159,12 +164,14 @@ fn position_axis_and_material_bounds_change_only_the_requested_space() {
mesh.append(&distant);
let mut parameters = settings(16, &[BakedMap::Position]);
parameters.maps.position.parameters.axis = PositionAxis::X;
+
let global = run(&mesh, ¶meters).unwrap();
parameters.maps.position.parameters.scale = PositionNormalizationScale::PerMaterial;
let local = run(&mesh, ¶meters).unwrap();
+
assert!(global.maps[&BakedMap::Position].iter().all(|value| *value < 0.2));
assert!(local.maps[&BakedMap::Position].iter().any(|value| *value > 0.9));
- assert!(local.maps[&BakedMap::Position].chunks_exact(3).all(|pixel| pixel[0] == pixel[1] && pixel[1] == pixel[2]));
+ assert!(local.maps[&BakedMap::Position].as_chunks::<3>().0.iter().all(|pixel| pixel[0] == pixel[1] && pixel[1] == pixel[2]));
}
#[test]
diff --git a/crates/bake/src/test/vertex_reach.rs b/crates/bake/src/test/vertex_reach.rs
new file mode 100644
index 00000000..7675e8dc
--- /dev/null
+++ b/crates/bake/src/test/vertex_reach.rs
@@ -0,0 +1,51 @@
+use crate::{RayStart, VertexReach};
+use texturecraft_geom::glam::Vec3;
+
+/// Cage distances in world units; every case's ray runs down the Y axis from 0.5 to -0.25
+const FRONTAL: f32 = 0.5;
+const REAR: f32 = 0.25;
+
+/// A frontal distance a cage-mesh start must ignore: its ray starts on the cage
+const IGNORED_FRONTAL: f32 = 9.0;
+
+/// How far past an end of the ray's range a vertex counts as outside it
+const PAST_THE_END: f32 = 1e-3;
+
+/// A vertex at `height` above the low-poly point at the origin, its triangles facing `facing`
+fn vertex(start: RayStart, height: f32, facing: Vec3, name_matches: bool) -> VertexReach {
+ VertexReach { low_position: Vec3::ZERO, start, high_position: Vec3::new(0.0, height, 0.0), high_facing: facing, name_matches }
+}
+
+#[test]
+fn a_vertex_is_missed_outside_the_ray_range_on_another_part_or_facing_away() {
+ // A painted cage amount of 2 doubles the frontal distance
+ let starts = [
+ (RayStart::Distance { up: Vec3::Y, scale: 1.0 }, FRONTAL),
+ (RayStart::Distance { up: Vec3::Y, scale: 2.0 }, FRONTAL / 2.0),
+ (RayStart::CageMesh(Vec3::new(0.0, -FRONTAL, 0.0)), IGNORED_FRONTAL),
+ ];
+ let (top, bottom) = (FRONTAL, -REAR);
+ // Height, facing, name matches, ignore backface: missed
+ let cases = [
+ (top, Vec3::Y, true, false, false),
+ (bottom, Vec3::Y, true, false, false),
+ (0.0, Vec3::Y, true, false, false),
+ (top + PAST_THE_END, Vec3::Y, true, false, true),
+ (bottom - PAST_THE_END, Vec3::Y, true, false, true),
+ (0.0, Vec3::Y, false, false, true),
+ (0.0, Vec3::NEG_Y, true, false, false),
+ (0.0, Vec3::NEG_Y, true, true, true),
+ (0.0, Vec3::Y, true, true, false),
+ ];
+
+ for (start, frontal) in starts {
+ for (height, facing, name_matches, ignore_backface, missed) in cases {
+ let reach = vertex(start, height, facing, name_matches);
+ assert_eq!(
+ reach.missed(frontal, REAR, ignore_backface),
+ missed,
+ "{start:?} at height {height}, facing {facing}, name matches {name_matches}, ignore backface {ignore_backface}"
+ );
+ }
+ }
+}
diff --git a/crates/bake/src/tests.rs b/crates/bake/src/tests.rs
index 26c8665c..0c313462 100644
--- a/crates/bake/src/tests.rs
+++ b/crates/bake/src/tests.rs
@@ -14,6 +14,12 @@ use texturecraft_geom::primitives;
use super::*;
+#[path = "test/cage_shell.rs"]
+mod cage_shell;
+
+#[path = "test/high_poly_reach.rs"]
+mod high_poly_reach;
+
#[path = "test/setting.rs"]
mod setting;
@@ -23,6 +29,9 @@ mod normal_map_curvature;
#[path = "test/tile_selection.rs"]
mod tile_selection;
+#[path = "test/vertex_reach.rs"]
+mod vertex_reach;
+
fn settings(resolution: u32, maps: &[BakedMap]) -> BakeSettings {
with_rays(
{
@@ -91,18 +100,20 @@ fn open_quad_is_unoccluded() {
#[test]
fn inside_of_a_closed_box_is_occluded() {
- let mut m = primitives::cube(2.0);
- for t in m.indices.chunks_exact_mut(3) {
- t.swap(1, 2);
+ let mut mesh = primitives::cube(2.0);
+ for triangle in mesh.indices.as_chunks_mut::<3>().0 {
+ triangle.swap(1, 2);
}
- for n in &mut m.normals {
- *n = -*n;
+ for normal in &mut mesh.normals {
+ *normal = -*normal;
}
- m.compute_tangents();
- let s = with_rays(settings(64, &[BakedMap::AmbientOcclusion]), 64, 4.0);
- let out = run(&m, &s).unwrap();
- let ao = mean(covered_values(&m, &out, BakedMap::AmbientOcclusion).into_iter().map(|v| v.1));
- assert!(ao < 0.3, "{ao}");
+ mesh.compute_tangents();
+ let parameters = with_rays(settings(64, &[BakedMap::AmbientOcclusion]), 64, 4.0);
+
+ let output = run(&mesh, ¶meters).unwrap();
+
+ let mean_occlusion = mean(covered_values(&mesh, &output, BakedMap::AmbientOcclusion).into_iter().map(|v| v.1));
+ assert!(mean_occlusion < 0.3, "{mean_occlusion}");
}
#[test]
diff --git a/crates/compose/src/curvature_size_level.rs b/crates/compose/src/curvature_size_level.rs
new file mode 100644
index 00000000..fcd25492
--- /dev/null
+++ b/crates/compose/src/curvature_size_level.rs
@@ -0,0 +1,50 @@
+/// Deviations of ±0.5 (curvature − 0.5) stored as 16-bit integers.
+pub const DEVIATION_SCALE: f32 = i16::MAX as f32 * 2.0;
+
+/// Curvature blurred at one detail size: deviations from flat, stored `step` times coarser than the map.
+pub struct CurvatureSizeLevel {
+ pub step: u32,
+ pub width: u32,
+ pub height: u32,
+ /// UV tile dimensions in stored texels; interpolation must stay inside one tile
+ pub block: (u32, u32),
+ pub deviation: Vec,
+}
+
+impl CurvatureSizeLevel {
+ /// The deviation at map texel `(x, y)`, interpolated within its UV tile
+ pub fn sample(&self, x: u32, y: u32) -> f32 {
+ if self.width == 0 || self.height == 0 {
+ return 0.0;
+ }
+
+ let step = self.step.max(1);
+ let axis = |texel: u32, block: u32, length: u32| {
+ let block = block.max(1);
+ let first = if block >= length { 0 } else { (texel / block.saturating_mul(step) * block).min(length - 1) };
+ let last = first.saturating_add(block - 1).min(length - 1);
+ let position = ((texel as f32 + 0.5) / step as f32 - 0.5).clamp(first as f32, last as f32);
+ let lower = position.floor() as u32;
+ (lower, (lower + 1).min(last), position - lower as f32)
+ };
+ let (x0, x1, blend_x) = axis(x, self.block.0, self.width);
+ let (y0, y1, blend_y) = axis(y, self.block.1, self.height);
+ let stored = |x: u32, y: u32| self.deviation.get((y * self.width + x) as usize).map_or(0.0, |value| f32::from(*value) / DEVIATION_SCALE);
+ let top = stored(x0, y0) + (stored(x1, y0) - stored(x0, y0)) * blend_x;
+ let bottom = stored(x0, y1) + (stored(x1, y1) - stored(x0, y1)) * blend_x;
+ top + (bottom - top) * blend_y
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn samples_blend_the_stored_texels() {
+ let level = CurvatureSizeLevel { step: 2, width: 2, height: 1, block: (2, 1), deviation: vec![0, (0.25 * DEVIATION_SCALE) as i16] };
+ assert!(level.sample(0, 0).abs() < 1e-4, "the first stored texel covers map texels 0 and 1");
+ assert!((level.sample(3, 0) - 0.25).abs() < 1e-3);
+ assert!(level.sample(2, 0) > 0.0 && level.sample(2, 0) < 0.25, "between stored texels the value blends");
+ }
+}
diff --git a/crates/compose/src/curvature_sizes.rs b/crates/compose/src/curvature_sizes.rs
new file mode 100644
index 00000000..d04e7f62
--- /dev/null
+++ b/crates/compose/src/curvature_sizes.rs
@@ -0,0 +1,447 @@
+//! The baked curvature map at the detail sizes of curvature generators, built once per map and layout.
+
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex, Weak};
+
+use rayon::prelude::*;
+use texturecraft_core::{BakedMap, BlockScales, CurvatureDetail};
+use texturecraft_texel::dilate::{DilationMap, NONE};
+
+use crate::curvature_size_level::{CurvatureSizeLevel, DEVIATION_SCALE};
+use crate::eval::{BLUR_BOX_PASSES, Inputs, blur};
+
+/// The curvature map padded past its UV islands and blurred at each size of [`CurvatureDetail::SIZES`] after the first.
+pub struct CurvatureSizes {
+ /// One per blurred size, built once a generator gives that size a weight above 0.
+ pub levels: Vec>>,
+}
+
+/// The bake map size, its UV tile block and the working texture size a cache entry was built for.
+type CacheKey = ((u32, u32), (u32, u32), (u32, u32));
+
+/// Built sizes by the curvature data they come from, their layout and the tiles' scales.
+type CacheEntry = (Weak>, CacheKey, BlockScales, Arc);
+
+static CACHE: Mutex> = Mutex::new(Vec::new());
+
+// Undo snapshots keep old maps alive; their derived levels must not grow with the history
+const CACHE_BYTES: usize = 256 << 20;
+const CACHE_MAPS: usize = 16;
+
+impl CurvatureSizes {
+ /// The sizes of the texture set `inp` composites, holding at least those `needed` marks (one flag per blurred size); None without a baked curvature map or a needed size.
+ pub fn of(inp: &Inputs, needed: &[bool]) -> Option> {
+ let curvature = inp.baked.maps.get(&BakedMap::Curvature)?;
+ let (width, height) = (inp.baked.resolution, inp.baked.height(BakedMap::Curvature));
+ if !needed.contains(&true) || width == 0 || height == 0 {
+ return None;
+ }
+
+ let grid = inp.project.texture_set(inp.ts).ok().and_then(|set| set.tile_grid());
+ let block = grid.map_or((width, height), |grid| (width / grid.cols.max(1), height / grid.rows.max(1)));
+ let key = ((width, height), block, (inp.gbuf.width, inp.gbuf.height));
+ let built = cached(curvature, key, &inp.block_scales);
+ if let Some(sizes) = built.as_ref().filter(|sizes| sizes.holds(needed)) {
+ return Some(sizes.clone());
+ }
+
+ // Built without the cache locked: the build runs parallel work, and a thread waiting on it may composite a tile that asks the cache again
+ let covered = covered_texels(inp, (width, height));
+ let sizes = CurvatureSizes::build(curvature, (width, height), &covered, block, needed, built.as_deref());
+ Some(store(curvature, key, &inp.block_scales, sizes))
+ }
+
+ /// Whether every size `needed` marks is built.
+ fn holds(&self, needed: &[bool]) -> bool {
+ needed.iter().zip(&self.levels).all(|(needs, level)| !needs || level.is_some())
+ }
+
+ /// Pad and blur each UV tile at the requested sizes, reusing levels already in `built`
+ fn build(
+ curvature: &[f32],
+ (width, height): (u32, u32),
+ covered: &[bool],
+ block: (u32, u32),
+ needed: &[bool],
+ built: Option<&CurvatureSizes>,
+ ) -> CurvatureSizes {
+ let padding = DilationMap::in_rectangular_blocks(covered, width, height, None, block);
+ let deviation: Vec =
+ padding.src.par_iter().map(|&source| if source == NONE { 0.0 } else { curvature.get(source as usize).copied().unwrap_or(0.5) - 0.5 }).collect();
+ let (block_width, block_height) = (block.0.max(1).min(width), block.1.max(1).min(height));
+
+ let levels = CurvatureDetail::SIZES
+ .iter()
+ .skip(1)
+ .enumerate()
+ .map(|(level, size)| {
+ if let Some(existing) = built.and_then(|sizes| sizes.levels.get(level)).and_then(Option::clone) {
+ return Some(existing);
+ }
+ if !needed.get(level).copied().unwrap_or(false) {
+ return None;
+ }
+
+ // Sizes are texels at 2K; a blur this wide holds nothing finer than half its radius, so it is stored that much coarser
+ let radius = (size * block_width as f32 / 2048.0).round().max(1.0) as u32;
+ let mut step = (radius / 2).max(1).next_power_of_two();
+ // A coarse cell must not average curvature from different UV tiles
+ while !block_width.is_multiple_of(step) || !block_height.is_multiple_of(step) {
+ step /= 2;
+ }
+
+ let mut blurred = deviation.clone();
+ for block_y in (0..height).step_by(block_height as usize) {
+ for block_x in (0..width).step_by(block_width as usize) {
+ let region = (block_x, block_y, block_width.min(width - block_x), block_height.min(height - block_y));
+ blur_block(&mut blurred, width, region, radius);
+ }
+ }
+ Some(Arc::new(coarsen(&blurred, (width, height), step, (block_width, block_height))))
+ })
+ .collect();
+ CurvatureSizes { levels }
+ }
+}
+
+/// The cached sizes of `curvature` for layout `key` and tile `scales`, if any
+fn cached(curvature: &Arc>, key: CacheKey, scales: &BlockScales) -> Option> {
+ let mut cache = CACHE.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
+ cache.retain(|(source, ..)| source.strong_count() > 0);
+ let index = cache.iter().position(|entry| is_entry_for(entry, curvature, key, scales))?;
+ let entry = cache.remove(index);
+ let sizes = entry.3.clone();
+ cache.push(entry);
+ Some(sizes)
+}
+
+/// Cache `sizes`, merging any levels another thread stored meanwhile
+fn store(curvature: &Arc>, key: CacheKey, scales: &BlockScales, sizes: CurvatureSizes) -> Arc {
+ let mut cache = CACHE.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
+ let sizes = if let Some((.., cached_sizes)) = cache.iter().find(|entry| is_entry_for(entry, curvature, key, scales)) {
+ let levels = cached_sizes.levels.iter().zip(sizes.levels).map(|(cached, built)| cached.clone().or(built)).collect();
+ CurvatureSizes { levels }
+ } else {
+ sizes
+ };
+
+ // One layout per curvature map, with the most recently used map at the end
+ cache.retain(|(source, ..)| source.strong_count() > 0 && !std::ptr::eq(source.as_ptr(), Arc::as_ptr(curvature)));
+ let sizes = Arc::new(sizes);
+ cache.push((Arc::downgrade(curvature), key, scales.clone(), sizes.clone()));
+ trim_cache(&mut cache, CACHE_BYTES);
+ sizes
+}
+
+/// Evict the least recently used maps, retaining the newest even if it alone exceeds the budget
+fn trim_cache(cache: &mut Vec, budget: usize) {
+ // Keeping the newest prevents a large atlas from rebuilding its levels for every tile
+ let mut bytes = 0usize;
+ let mut keep = 0;
+ for (.., sizes) in cache.iter().rev() {
+ let size = sizes.levels.iter().flatten().map(|level| level.deviation.len().saturating_mul(size_of::())).fold(0usize, usize::saturating_add);
+ bytes = bytes.saturating_add(size);
+ if keep > 0 && (bytes > budget || keep == CACHE_MAPS) {
+ break;
+ }
+ keep += 1;
+ }
+ cache.drain(..cache.len() - keep);
+}
+
+/// Whether cache `entry` holds the sizes of `curvature` for layout `key` and tile `scales`.
+fn is_entry_for((source, cached_key, cached_scales, _): &CacheEntry, curvature: &Arc>, key: CacheKey, scales: &BlockScales) -> bool {
+ source.upgrade().is_some_and(|data| Arc::ptr_eq(&data, curvature)) && *cached_key == key && cached_scales == scales
+}
+
+/// The bake atlas texels (`width × height`) overlapped by covered working texels of `inp`
+fn covered_texels(inp: &Inputs, (width, height): (u32, u32)) -> Vec {
+ let working_size = (inp.gbuf.width, inp.gbuf.height);
+ if working_size == (width, height) && inp.block_scales == BlockScales::default() {
+ return (0..width * height).into_par_iter().map(|texel| inp.gbuf.covered(texel as usize)).collect();
+ }
+
+ let covered: Vec = (0..width * height).map(|_| AtomicBool::new(false)).collect();
+ (0..working_size.0 * working_size.1).into_par_iter().filter(|texel| inp.gbuf.covered(*texel as usize)).for_each(|texel| {
+ let (x, y) = (texel % working_size.0, texel / working_size.0);
+ let uv = [(x as f32 + 0.5) / working_size.0 as f32, (y as f32 + 0.5) / working_size.1 as f32];
+ if let Some(baked_uv) = inp.block_scales.bake_uv(uv, working_size) {
+ // A lower-resolution working texel covers a whole rectangle in the bake, not just its center
+ let scale = inp.block_scales.at(x, y);
+ let footprint = |center: f32, baked: u32, working: u32| {
+ let half_width = 0.5 * baked as f32 / (working as f32 * scale);
+ let center = center * baked as f32;
+ ((center - half_width).floor().max(0.0) as u32)..((center + half_width).ceil() as u32).min(baked)
+ };
+ let columns = footprint(baked_uv[0], width, working_size.0);
+ for baked_y in footprint(baked_uv[1], height, working_size.1) {
+ for baked_x in columns.clone() {
+ if let Some(slot) = covered.get((baked_y * width + baked_x) as usize) {
+ slot.store(true, Ordering::Relaxed);
+ }
+ }
+ }
+ }
+ });
+ covered.into_iter().map(AtomicBool::into_inner).collect()
+}
+
+/// Blur the `(left, top, region_width, region_height)` block of `data` (`width` texels per row) in place, reading nothing outside it.
+fn blur_block(data: &mut [f32], width: u32, (left, top, region_width, region_height): (u32, u32, u32, u32), radius: u32) {
+ let rows = top..top + region_height;
+ let mut block: Vec =
+ rows.flat_map(|y| (left..left + region_width).map(move |x| (y * width + x) as usize)).map(|index| data.get(index).copied().unwrap_or(0.0)).collect();
+ blur(&mut block, region_width as usize, region_height as usize, radius as usize);
+
+ // The blur reads zero past the block's edges; dividing by the share of its window inside the block keeps the edges at full strength
+ let column_weights = window_inside(region_width as usize, radius as usize);
+ let row_weights = window_inside(region_height as usize, radius as usize);
+ for (values, row_weight) in block.chunks_mut(region_width as usize).zip(&row_weights) {
+ for (value, column_weight) in values.iter_mut().zip(&column_weights) {
+ *value /= row_weight * column_weight;
+ }
+ }
+
+ for (row, values) in block.chunks(region_width as usize).enumerate() {
+ let start = ((top + row as u32) * width + left) as usize;
+ if let Some(target) = data.get_mut(start..start + values.len()) {
+ target.copy_from_slice(values);
+ }
+ }
+}
+
+/// The share of the [`blur`] window at each texel of a line `length` long that falls inside it: 1 from three radii in.
+fn window_inside(length: usize, radius: usize) -> Vec {
+ let window = (2 * radius + 1) as f64;
+ let mut weights = vec![1.0f64; length];
+ for _ in 0..BLUR_BOX_PASSES {
+ let running_totals: Vec = std::iter::once(0.0)
+ .chain(weights.iter().scan(0.0, |total, weight| {
+ *total += weight;
+ Some(*total)
+ }))
+ .collect();
+ let total_at = |end: usize| running_totals.get(end.min(length)).copied().unwrap_or(0.0);
+ weights = (0..length).map(|texel| (total_at(texel + radius + 1) - total_at(texel.saturating_sub(radius))) / window).collect();
+ }
+ weights.into_iter().map(|weight| weight as f32).collect()
+}
+
+/// `data` averaged over `step × step` squares, clipping the last cells to the map
+fn coarsen(data: &[f32], (width, height): (u32, u32), step: u32, block: (u32, u32)) -> CurvatureSizeLevel {
+ let (coarse_width, coarse_height) = (width.div_ceil(step), height.div_ceil(step));
+ let deviation = (0..coarse_width * coarse_height)
+ .into_par_iter()
+ .map(|cell| {
+ let (cell_x, cell_y) = (cell % coarse_width, cell / coarse_width);
+ let columns = cell_x * step..((cell_x + 1) * step).min(width);
+ let rows = cell_y * step..((cell_y + 1) * step).min(height);
+ let count = (columns.len() * rows.len()).max(1) as f32;
+ let texels = rows.flat_map(|y| columns.clone().map(move |x| (y * width + x) as usize));
+ let mean = texels.map(|index| data.get(index).copied().unwrap_or(0.0)).sum::() / count;
+ (mean * DEVIATION_SCALE).round().clamp(i16::MIN as f32, i16::MAX as f32) as i16
+ })
+ .collect();
+ CurvatureSizeLevel { step, width: coarse_width, height: coarse_height, block: (block.0.div_ceil(step), block.1.div_ceil(step)), deviation }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn coarse_sizes_do_not_blend_between_uv_tiles() {
+ let (width, height) = (512, 512);
+ let block = (256, 256);
+ let curvature: Vec = (0..width * height).map(|texel| if (texel % width) / block.0 == (texel / width) / block.1 { 0.8 } else { 0.2 }).collect();
+ let covered = vec![true; curvature.len()];
+ let sizes = CurvatureSizes::build(&curvature, (width, height), &covered, block, &[true; CurvatureDetail::BLURRED_SIZES], None);
+
+ for level in sizes.levels.iter().flatten() {
+ for (x, y) in [(255, 128), (256, 128), (128, 255), (128, 256), (255, 255), (256, 256)] {
+ let expected = curvature[(y * width + x) as usize] - 0.5;
+ assert!((level.sample(x, y) - expected).abs() < 0.001, "step {} at ({x}, {y}): {} instead of {expected}", level.step, level.sample(x, y));
+ }
+ }
+ }
+
+ #[test]
+ fn coverage_preserves_bake_texels_above_the_working_resolution() {
+ use texturecraft_core::{Project, TextureSet};
+ use texturecraft_geom::{UvGBuffer, primitives};
+
+ let mesh = primitives::plane(2.0, 1);
+ let mut project = Project::new("Coverage", "builtin:plane");
+ project.texture_sets.push(TextureSet::new("Plane", 0, 64));
+ let gbuf = UvGBuffer::new(&mesh, 0, 64, 64);
+ let pixels = Default::default();
+ let images = Default::default();
+ let baked = Default::default();
+ let inputs = Inputs {
+ project: &project,
+ ts: 0,
+ mesh: &mesh,
+ gbuf: &gbuf,
+ pixels: &pixels,
+ baked: &baked,
+ block_scales: BlockScales::default(),
+ preview: None,
+ images: &images,
+ bounds: mesh.bounds(),
+ };
+
+ for size in [(32, 32), (64, 64), (128, 128), (128, 32)] {
+ let coverage = covered_texels(&inputs, size);
+ assert!(coverage.iter().all(|covered| *covered), "the plane covers the entire {size:?} bake, including between working texel centers");
+ }
+ }
+
+ #[test]
+ fn coverage_expands_scaled_tiles_without_crossing_block_borders() {
+ use texturecraft_core::{Project, TextureSet};
+ use texturecraft_geom::{NO_TRI, UvGBuffer, primitives};
+
+ let mesh = primitives::plane(2.0, 1);
+ let mut project = Project::new("Tile coverage", "builtin:plane");
+ let mut set = TextureSet::new("Tiles", 0, 64);
+ set.uv_tiles = vec![1001, 1002, 1003];
+ set.tile_resolutions.insert(1002, 32);
+ let scales = set.block_scales();
+ project.texture_sets.push(set);
+ let mut gbuf = UvGBuffer::new(&mesh, 0, 192, 64);
+ for (index, triangle) in gbuf.tri.iter_mut().enumerate() {
+ if !(64..96).contains(&(index % 192)) || index / 192 >= 32 {
+ *triangle = NO_TRI;
+ }
+ }
+ let pixels = Default::default();
+ let images = Default::default();
+ let baked = Default::default();
+ let inputs = Inputs {
+ project: &project,
+ ts: 0,
+ mesh: &mesh,
+ gbuf: &gbuf,
+ pixels: &pixels,
+ baked: &baked,
+ block_scales: scales,
+ preview: None,
+ images: &images,
+ bounds: mesh.bounds(),
+ };
+
+ let covered = covered_texels(&inputs, (384, 128));
+ for (index, covered) in covered.iter().enumerate() {
+ assert_eq!(*covered, (128..256).contains(&(index % 384)), "bake texel ({}, {})", index % 384, index / 384);
+ }
+ }
+
+ #[test]
+ fn unused_maps_are_evicted_even_while_undo_keeps_the_sources_alive() {
+ let sources: Vec<_> = (0..=CACHE_MAPS).map(|_| Arc::new(vec![0.5; 16])).collect();
+ let scales = BlockScales::default();
+ let key = ((4, 4), (4, 4), (4, 4));
+ let sizes = store(&sources[0], key, &scales, CurvatureSizes { levels: Vec::new() });
+ let first = Arc::downgrade(&sizes);
+ drop(sizes);
+ for source in sources.iter().skip(1) {
+ store(source, key, &scales, CurvatureSizes { levels: Vec::new() });
+ }
+
+ assert!(first.upgrade().is_none(), "undo history may retain the bake, but not an unlimited number of derived maps");
+ }
+
+ #[test]
+ fn cache_budget_evicts_old_levels_but_keeps_one_large_map() {
+ let source = Arc::new(vec![0.5]);
+ let key = ((1, 1), (1, 1), (1, 1));
+ let entry = || {
+ let level = CurvatureSizeLevel { step: 1, width: 4, height: 1, block: (4, 1), deviation: vec![0; 4] };
+ let sizes = CurvatureSizes { levels: vec![Some(Arc::new(level))] };
+ (Arc::downgrade(&source), key, BlockScales::default(), Arc::new(sizes))
+ };
+ let mut cache = vec![entry(), entry(), entry()];
+ let oldest = Arc::downgrade(&cache[0].3);
+ let newest = cache[2].3.clone();
+
+ trim_cache(&mut cache, 16);
+ assert_eq!(cache.len(), 2);
+ assert!(oldest.upgrade().is_none());
+ trim_cache(&mut cache, 1);
+ assert_eq!(cache.len(), 1, "the active map must not rebuild once per composite tile");
+ assert!(Arc::ptr_eq(&cache[0].3, &newest));
+ }
+
+ #[test]
+ fn padding_keeps_an_island_border_from_reading_flat() {
+ let map_size: u32 = 64;
+ let left_half = |texel: u32| texel % map_size < map_size / 2;
+ let curvature: Vec = (0..map_size * map_size).map(|texel| if left_half(texel) { 1.0 } else { 0.0 }).collect();
+ let covered: Vec = (0..map_size * map_size).map(left_half).collect();
+ let shape = (map_size, map_size);
+ let sizes = CurvatureSizes::build(&curvature, shape, &covered, shape, &[true; CurvatureDetail::BLURRED_SIZES], None);
+
+ // The last covered column, halfway down
+ let (border_x, border_y) = (map_size / 2 - 1, map_size / 2);
+ for level in sizes.levels.iter().flatten() {
+ assert!((level.sample(border_x, border_y) - 0.5).abs() < 0.01, "the border keeps the island's curvature, not the empty texels beside it");
+ }
+ }
+
+ #[test]
+ fn uniform_curvature_keeps_its_strength_at_block_borders() {
+ let (map_width, map_height): (u32, u32) = (256, 256);
+ // Curvature 0.8 reads 0.3 above the neutral 0.5 at every size
+ const CURVATURE: f32 = 0.8;
+ let expected = CURVATURE - 0.5;
+ let curvature = vec![CURVATURE; (map_width * map_height) as usize];
+ let covered = vec![true; curvature.len()];
+ let block = (map_width / 2, map_height);
+ let sizes = CurvatureSizes::build(&curvature, (map_width, map_height), &covered, block, &[true; CurvatureDetail::BLURRED_SIZES], None);
+
+ // The map's corner, then the last texel of the left block and the first of the right one, halfway down
+ let border_texels = [(0, 0), (block.0 - 1, map_height / 2), (block.0, map_height / 2)];
+ for level in sizes.levels.iter().flatten() {
+ for (x, y) in border_texels {
+ assert!((level.sample(x, y) - expected).abs() < 0.01, "texel ({x}, {y}) reads {} instead of the uniform {expected}", level.sample(x, y));
+ }
+ }
+ }
+
+ #[test]
+ fn a_new_layout_replaces_the_sizes_of_the_old_one() {
+ let curvature = Arc::new(vec![0.5; 16]);
+ let scales = BlockScales::default();
+ let entries_for_curvature = || {
+ let cache = CACHE.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
+ cache.iter().filter(|(source, ..)| std::ptr::eq(source.as_ptr(), Arc::as_ptr(&curvature))).count()
+ };
+
+ store(&curvature, ((4, 4), (4, 4), (4, 4)), &scales, CurvatureSizes { levels: Vec::new() });
+ store(&curvature, ((4, 4), (2, 2), (8, 8)), &scales, CurvatureSizes { levels: Vec::new() });
+ assert_eq!(entries_for_curvature(), 1, "only the latest layout of a curvature map stays cached");
+ }
+
+ #[test]
+ fn sizes_built_on_demand_match_a_full_build() {
+ let map_size: u32 = 64;
+ let curvature: Vec =
+ (0..map_size * map_size).map(|texel| 0.5 + 0.4 * ((texel % map_size) as f32 * 0.3).sin() * ((texel / map_size) as f32 * 0.2).cos()).collect();
+ let covered = vec![true; (map_size * map_size) as usize];
+ let shape = (map_size, map_size);
+ let all = vec![true; CurvatureDetail::BLURRED_SIZES];
+ let full = CurvatureSizes::build(&curvature, shape, &covered, shape, &all, None);
+
+ let even: Vec = (0..all.len()).map(|level| level % 2 == 0).collect();
+ let partial = CurvatureSizes::build(&curvature, shape, &covered, shape, &even, None);
+ assert!(partial.levels.iter().zip(&even).all(|(level, needed)| level.is_some() == *needed), "only the needed sizes are built");
+
+ let completed = CurvatureSizes::build(&curvature, shape, &covered, shape, &all, Some(&partial));
+ for ((built, expected), earlier) in completed.levels.iter().zip(&full.levels).zip(&partial.levels) {
+ assert_eq!(built.as_ref().map(|level| &level.deviation), expected.as_ref().map(|level| &level.deviation), "the same values either way");
+ if let (Some(built), Some(earlier)) = (built, earlier) {
+ assert!(Arc::ptr_eq(built, earlier), "sizes already built are kept, not rebuilt");
+ }
+ }
+ }
+}
diff --git a/crates/compose/src/display.rs b/crates/compose/src/display.rs
index ba4b675e..5ebb667b 100644
--- a/crates/compose/src/display.rs
+++ b/crates/compose/src/display.rs
@@ -93,20 +93,21 @@ fn u8_of(v: u16) -> u8 {
(v >> 8) as u8
}
-/// Tile bytes (`TILE × TILE`, row-major) for `kind` from the composite, or None when the tile is
-/// absent in every source (the GPU texture keeps its cleared default).
-pub fn tile_bytes(comp: &Composite, baked: &BakedMaps, kind: DisplayKind, tx: u32, ty: u32) -> Vec {
- let bpt = kind.bytes_per_texel();
- let mut out = vec![0u8; TILE_AREA * bpt];
- let lut = srgb_lut();
- let get = |c: Channel| comp.channels.get(&c).and_then(|img| img.tile(tx, ty));
- let res = comp.resolution;
+/// Tile bytes (`TILE × TILE`, row-major) for `kind`, using channel defaults for absent source tiles.
+pub fn tile_bytes(composite: &Composite, baked: &BakedMaps, kind: DisplayKind, tx: u32, ty: u32) -> Vec {
+ let bytes_per_texel = kind.bytes_per_texel();
+ let mut out = vec![0u8; TILE_AREA * bytes_per_texel];
+ let srgb = srgb_lut();
+ let get = |c: Channel| composite.channels.get(&c).and_then(|img| img.tile(tx, ty));
+ let resolution = composite.resolution;
let default16 = |c: Channel| texturecraft_texel::to_u16(c.default_value()[0]);
- // A scalar channel's texel `i` as 8 bits (its default where the set lacks it).
+
+ // A scalar channel's texel `i` as 8 bits (its default where the set lacks it)
let scalar8 = |c: Channel| {
let (t, d) = (get(c), default16(c));
move |i: usize| u8_of(t.and_then(|t| t.get(i).copied()).unwrap_or(d))
};
+
match kind {
DisplayKind::BaseColor | DisplayKind::Emissive | DisplayKind::Sheen => {
let (c, alpha) = match kind {
@@ -117,81 +118,87 @@ pub fn tile_bytes(comp: &Composite, baked: &BakedMaps, kind: DisplayKind, tx: u3
let (src, alpha) = (get(c), scalar8(alpha));
let d = c.default_value().map(|v| (texturecraft_texel::linear_to_srgb(v) * 255.0 + 0.5) as u8);
for i in 0..TILE_AREA {
- let px = &mut out[i * 4..i * 4 + 4];
+ let pixel = &mut out[i * 4..i * 4 + 4];
match src {
Some(s) => {
for k in 0..3 {
- px[k] = lut[(s.get(i * 3 + k).copied().unwrap_or(0) >> 4) as usize];
+ pixel[k] = srgb[(s.get(i * 3 + k).copied().unwrap_or(0) >> 4) as usize];
}
}
- None => px[..3].copy_from_slice(&d),
+ None => pixel[..3].copy_from_slice(&d),
}
- px[3] = alpha(i);
+ pixel[3] = alpha(i);
}
}
DisplayKind::Lobes => {
let lanes = [Channel::CoatWeight, Channel::CoatRoughness, Channel::AnisotropyLevel, Channel::AnisotropyAngle].map(scalar8);
- for (i, px) in out.chunks_exact_mut(4).enumerate() {
- for (d, lane) in px.iter_mut().zip(&lanes) {
+ for (i, pixel) in out.as_chunks_mut::<4>().0.iter_mut().enumerate() {
+ for (d, lane) in pixel.iter_mut().zip(&lanes) {
*d = lane(i);
}
}
}
DisplayKind::Extra => {
let (n, transmission) = (get(Channel::CoatNormal), scalar8(Channel::Transmission));
- // Signed 8-bit around 128 so the flat normal packs exactly.
- let snorm = |v: u16| (128.0 + 127.0 * (v as f32 / 65535.0 * 2.0 - 1.0)).round().clamp(0.0, 255.0) as u8;
- // A TILE never straddles two atlas blocks.
- let scale = (-32.0 * comp.block_scales.at(tx * TILE, ty * TILE).log2()).round().clamp(0.0, 255.0) as u8;
- for (i, px) in out.chunks_exact_mut(4).enumerate() {
- for (k, d) in px.iter_mut().take(2).enumerate() {
- *d = n.and_then(|t| t.get(i * 3 + k)).map_or(128, |v| snorm(*v));
+
+ // Signed 8-bit around 128 so the flat normal packs exactly
+ let pack_signed_normal = |v: u16| (128.0 + 127.0 * (v as f32 / 65535.0 * 2.0 - 1.0)).round().clamp(0.0, 255.0) as u8;
+
+ // A TILE never straddles two atlas blocks
+ let scale = (-32.0 * composite.block_scales.at(tx * TILE, ty * TILE).log2()).round().clamp(0.0, 255.0) as u8;
+ for (i, pixel) in out.as_chunks_mut::<4>().0.iter_mut().enumerate() {
+ for (k, d) in pixel.iter_mut().take(2).enumerate() {
+ *d = n.and_then(|t| t.get(i * 3 + k)).map_or(128, |v| pack_signed_normal(*v));
}
- px[2] = transmission(i);
- px[3] = scale;
+ pixel[2] = transmission(i);
+ pixel[3] = scale;
}
}
DisplayKind::Orm => {
let (ao, m, s) = (get(Channel::AmbientOcclusion), get(Channel::Metallic), get(Channel::SpecularLevel));
- // Specular/glossiness sets: the viewport shades roughness = 1 − glossiness.
- let gloss = comp.channels.contains_key(&Channel::Glossiness);
+
+ // Specular/glossiness sets: the viewport shades roughness = 1 − glossiness
+ let gloss = composite.channels.contains_key(&Channel::Glossiness);
let (r, r_default) =
if gloss { (get(Channel::Glossiness), default16(Channel::Glossiness)) } else { (get(Channel::Roughness), default16(Channel::Roughness)) };
for i in 0..TILE_AREA {
let (x, y) = (tx * TILE + (i as u32 % TILE), ty * TILE + (i as u32 / TILE));
- let baked_ao = baked.sample_working(BakedMap::AmbientOcclusion, x, y, (res, comp.height), &comp.block_scales).map_or(1.0, |value| value[0]);
+ let baked_ao = baked
+ .sample_working(BakedMap::AmbientOcclusion, x, y, (resolution, composite.height), &composite.block_scales)
+ .map_or(1.0, |value| value[0]);
let ch_ao = ao.and_then(|a| a.get(i)).map(|v| *v as f32 / 65535.0).unwrap_or(1.0);
- let px = &mut out[i * 4..i * 4 + 4];
- px[0] = ((baked_ao * ch_ao).clamp(0.0, 1.0) * 255.0 + 0.5) as u8;
+ let pixel = &mut out[i * 4..i * 4 + 4];
+ pixel[0] = ((baked_ao * ch_ao).clamp(0.0, 1.0) * 255.0 + 0.5) as u8;
let v = r.and_then(|t| t.get(i).copied()).unwrap_or(r_default);
- px[1] = u8_of(if gloss { 65535 - v } else { v });
- px[2] = u8_of(m.and_then(|t| t.get(i).copied()).unwrap_or(0));
- px[3] = u8_of(s.and_then(|t| t.get(i).copied()).unwrap_or(default16(Channel::SpecularLevel)));
+ pixel[1] = u8_of(if gloss { 65535 - v } else { v });
+ pixel[2] = u8_of(m.and_then(|t| t.get(i).copied()).unwrap_or(0));
+ pixel[3] = u8_of(s.and_then(|t| t.get(i).copied()).unwrap_or(default16(Channel::SpecularLevel)));
}
}
DisplayKind::Normal => {
- let (n, sheen_rough) = (get(Channel::Normal), scalar8(Channel::SheenRoughness));
+ let (n, sheen_roughness) = (get(Channel::Normal), scalar8(Channel::SheenRoughness));
for i in 0..TILE_AREA {
- let px = &mut out[i * 4..i * 4 + 4];
- // The baked normal is the base the painted normal details sit on (as in export).
+ let pixel = &mut out[i * 4..i * 4 + 4];
+
+ // The baked normal is the base the painted normal details sit on (as in export)
let (x, y) = (tx * TILE + (i as u32 % TILE), ty * TILE + (i as u32 / TILE));
- let base = baked.sample_working(BakedMap::Normal, x, y, (res, comp.height), &comp.block_scales);
+ let base = baked.sample_working(BakedMap::Normal, x, y, (resolution, composite.height), &composite.block_scales);
match (n, base) {
(Some(t), None) => {
- for (k, d) in px.iter_mut().take(3).enumerate() {
+ for (k, d) in pixel.iter_mut().take(3).enumerate() {
*d = u8_of(t.get(i * 3 + k).copied().unwrap_or(0));
}
}
(detail, Some(base)) => {
let detail = detail.map_or([0.5, 0.5, 1.0], |t| [0, 1, 2].map(|k| t.get(i * 3 + k).map_or(0.0, |v| *v as f32 / 65535.0)));
let v = texturecraft_core::blend::rnm(base, detail);
- for (d, v) in px.iter_mut().zip(v) {
+ for (d, v) in pixel.iter_mut().zip(v) {
*d = (v.clamp(0.0, 1.0) * 255.0 + 0.5) as u8;
}
}
- (None, None) => px[..3].copy_from_slice(&[128, 128, 255]),
+ (None, None) => pixel[..3].copy_from_slice(&[128, 128, 255]),
}
- px[3] = sheen_rough(i);
+ pixel[3] = sheen_roughness(i);
}
}
DisplayKind::Height => {
@@ -206,6 +213,7 @@ pub fn tile_bytes(comp: &Composite, baked: &BakedMaps, kind: DisplayKind, tx: u3
}
}
}
+
out
}
diff --git a/crates/compose/src/eval.rs b/crates/compose/src/eval.rs
index c2287a4b..d3ae712e 100644
--- a/crates/compose/src/eval.rs
+++ b/crates/compose/src/eval.rs
@@ -2,19 +2,24 @@
//! tile by tile in parallel. This is the reference implementation (the oracle) for the viewport
//! and for export.
+pub(crate) mod thumbnail;
+
use std::borrow::Cow;
use std::collections::{BTreeMap, HashMap};
+use std::sync::Arc;
use rayon::prelude::*;
use texturecraft_core::{
- BakedMap, BlendMode, BlockScales, Channel, ChannelKind, CompareOp, Effect, EffectKind, Fill, Filter, Generator, GeneratorKind, HeightMask, Layer, LayerId,
- LayerKind, Mask, MaskBackground, NormalFormat, Project, Projection, Source, TextureSet, TileGrid, blend1, blend3, lum, mix3, per_unit,
+ BakedMap, BlendMode, BlockScales, Channel, ChannelKind, CompareOp, CurvatureDetail, CurvatureMode, Effect, EffectKind, Fill, Filter, Generator,
+ GeneratorKind, HeightMask, Layer, LayerId, LayerKind, Mask, MaskBackground, NormalFormat, Project, Projection, Source, TextureSet, TileGrid, blend1,
+ blend3, lum, mix3, per_unit,
};
use texturecraft_geom::glam::{Vec2, Vec3};
use texturecraft_geom::{Mesh, NO_TRI, UvGBuffer};
use texturecraft_texel::{DilationMap, TILE, TILE_AREA, TileImage, from_u16, noise, to_u16, to_u16_signed};
use crate::below::{Band, BelowCache, Level};
+use crate::curvature_sizes::CurvatureSizes;
use crate::pattern::{Coords, decal_uv, image_samples, procedural, world_noise};
use crate::store::{BakedMaps, ImageStore, PixelStore, decode};
@@ -204,6 +209,8 @@ struct EffectPlan<'a> {
opacity: f32,
data: Option>,
preview: bool,
+ /// The curvature detail sizes a generator with detail reads.
+ curvature_sizes: Option>,
}
struct MaskPlan<'a> {
@@ -304,6 +311,12 @@ fn direction(angle: f32) -> [f32; 2] {
[cs, -sn]
}
+/// Gain on the curvature map's own deviation from flat (±0.5 reaches black and white).
+const MAP_GAIN: f32 = 2.0;
+
+/// Gain per texel of a detail size: blurring spreads an edge over about twice its radius, so wider sizes need proportionally more to reach full strength.
+const GAIN_PER_DETAIL_TEXEL: f32 = 2.0 * std::f32::consts::SQRT_2;
+
/// Samples along a directional or slope blur at most (beyond, samples spread out).
const LINE_SAMPLES: i32 = 24;
@@ -421,17 +434,20 @@ fn gather(op: Op, orig: &[f32], cover: &[f32], comps: usize, (x0, y0, w, h): (u3
/// the region it is computed in, so tiles composited in any grouping agree exactly.
const FIX: f64 = (1u64 << 24) as f64;
-/// Three running-sum box blurs (≈ Gaussian) of a `w × h` image along rows then along columns.
-/// Rows (and columns, transposed) blur in parallel.
-fn blur(data: &mut [f32], w: usize, h: usize, r: usize) {
- let fix = |v: &f32| if v.is_finite() { (f64::from(v.clamp(-1e6, 1e6)) * FIX).round() as i64 } else { 0 };
- let mut v: Vec = data.par_iter().map(fix).collect();
- blur_rows(&mut v, w, r);
- let mut t = transpose(&v, w, h);
- blur_rows(&mut t, h, r);
- data.par_iter_mut().zip(transpose(&t, h, w)).for_each(|(d, s)| *d = (s as f64 / FIX) as f32);
+/// Three running-sum box blurs (≈ Gaussian) of a `width × height` image along its rows, then its columns, each in parallel.
+pub(crate) fn blur(data: &mut [f32], width: usize, height: usize, radius: usize) {
+ let to_fixed = |value: &f32| if value.is_finite() { (f64::from(value.clamp(-1e6, 1e6)) * FIX).round() as i64 } else { 0 };
+ let mut fixed: Vec = data.par_iter().map(to_fixed).collect();
+ blur_rows(&mut fixed, width, radius);
+
+ let mut columns = transpose(&fixed, width, height);
+ blur_rows(&mut columns, height, radius);
+ data.par_iter_mut().zip(transpose(&columns, height, width)).for_each(|(target, blurred)| *target = (blurred as f64 / FIX) as f32);
}
+/// The box blurs `blur` runs along each axis
+pub(crate) const BLUR_BOX_PASSES: usize = 3;
+
/// Three box blurs of radius `r` along every row (`w` long) of `data`.
fn blur_rows(data: &mut [i64], w: usize, r: usize) {
if w == 0 {
@@ -439,7 +455,7 @@ fn blur_rows(data: &mut [i64], w: usize, r: usize) {
}
data.par_chunks_mut(w).for_each(|row| {
let mut tmp = vec![0i64; row.len()];
- for _ in 0..3 {
+ for _ in 0..BLUR_BOX_PASSES {
box_line(row, &mut tmp, r);
row.copy_from_slice(&tmp);
}
@@ -760,28 +776,53 @@ fn fields_of(inp: &Inputs, channels: &[Channel], list: &[LayerId], tiles: &[(u32
if tiles.is_empty() || inp.gbuf.width == 0 {
return out;
}
- let res = inp.gbuf.width;
+
+ let working_width = inp.gbuf.width;
let mut order = Vec::new();
draw_order(inp.project, list, 0, &mut order);
+ prepare_curvature_sizes(inp, &order);
+
for id in order {
let Some(layer) = inp.project.content_layer(id) else { continue };
- if let Some(m) = layer_mask(inp.project, id).filter(|m| m.enabled && neighbourhood(&m.effects, res).is_some())
- && let Some(f) = field(inp, channels, &out, id, Job::Mask(m), tiles)
+
+ if let Some(mask) = layer_mask(inp.project, id).filter(|mask| mask.enabled && neighbourhood(&mask.effects, working_width).is_some())
+ && let Some(filtered) = field(inp, channels, &out, id, Job::Mask(mask), tiles)
{
- out.insert(FieldKey::Mask(id), f);
+ out.insert(FieldKey::Mask(id), filtered);
}
- if layer.is_group() || neighbourhood(&layer.content_effects, res).is_none() {
+
+ if layer.is_group() || neighbourhood(&layer.content_effects, working_width).is_none() {
continue;
}
- for ch in channels.iter().filter(|c| layer.channels.contains_key(c)) {
- if let Some(f) = field(inp, channels, &out, id, Job::Content(*ch), tiles) {
- out.insert(FieldKey::Content(id, *ch), f);
+ for channel in channels.iter().filter(|channel| layer.channels.contains_key(channel)) {
+ if let Some(filtered) = field(inp, channels, &out, id, Job::Content(*channel), tiles) {
+ out.insert(FieldKey::Content(id, *channel), filtered);
}
}
}
out
}
+/// Build the curvature detail sizes every visible generator of `layers` reads, once, before tiles composite in parallel.
+fn prepare_curvature_sizes(inp: &Inputs, layers: &[LayerId]) {
+ let visible = layers.iter().filter(|id| inp.project.layers.get(id).is_some_and(|layer| layer.visible));
+ let masks = visible.filter_map(|id| layer_mask(inp.project, *id)).filter(|mask| mask.enabled);
+ prepare_mask_curvature_sizes(inp, masks);
+}
+
+/// Build the curvature detail sizes the visible generators of `masks` read, once, before tiles composite in parallel.
+fn prepare_mask_curvature_sizes<'a>(inp: &Inputs, masks: impl Iterator- ) {
+ let mut needed = [false; CurvatureDetail::BLURRED_SIZES];
+ for effect in masks.flat_map(|mask| &mask.effects).filter(|effect| effect.visible) {
+ if let EffectKind::Generator(Generator { detail: Some(detail), .. }) = &effect.kind {
+ for (slot, in_use) in needed.iter_mut().zip(detail.blurred_sizes_in_use()) {
+ *slot |= in_use;
+ }
+ }
+ }
+ CurvatureSizes::of(inp, &needed);
+}
+
struct Node<'a> {
id: LayerId,
content: Content<'a>,
@@ -799,21 +840,26 @@ struct Node<'a> {
/// Plans of the visible effects of a stack: mask effects (`channel` None) or the content
/// effects of one channel (paint effects then read that channel's pixels).
-fn effect_plans<'a>(inp: &Inputs<'a>, effects: &'a [Effect], tx: u32, ty: u32, channel: Option
) -> Vec> {
+fn effect_plans<'a>(inp: &Inputs<'a>, effects: &'a [Effect], tile_x: u32, tile_y: u32, channel: Option) -> Vec> {
effects
.iter()
- .filter(|e| e.visible)
- .map(|e| {
- let (img, target) = match channel {
- Some(c) => (inp.pixels.layer(e.id, c), PaintTarget::Layer(e.id)),
- None => (inp.pixels.masks.get(&e.id), PaintTarget::Mask(e.id)),
+ .filter(|effect| effect.visible)
+ .map(|effect| {
+ let (image, target) = match channel {
+ Some(channel) => (inp.pixels.layer(effect.id, channel), PaintTarget::Layer(effect.id)),
+ None => (inp.pixels.masks.get(&effect.id), PaintTarget::Mask(effect.id)),
+ };
+ let curvature_sizes = match &effect.kind {
+ EffectKind::Generator(Generator { detail: Some(detail), .. }) => CurvatureSizes::of(inp, &detail.blurred_sizes_in_use()),
+ _ => None,
};
EffectPlan {
- kind: &e.kind,
- blend: e.blend,
- opacity: e.opacity,
- data: if e.kind.painted() { tile_of(inp, img, tx, ty, channel) } else { None },
+ kind: &effect.kind,
+ blend: effect.blend,
+ opacity: effect.opacity,
+ data: if effect.kind.painted() { tile_of(inp, image, tile_x, tile_y, channel) } else { None },
preview: previews(inp, target),
+ curvature_sizes,
}
})
.collect()
@@ -1129,131 +1175,183 @@ impl<'a, 'b> Texel<'a, 'b> {
w * image.map_or(1.0, |img| img.sample(c.uv.x, c.uv.y)[3].clamp(0.0, 1.0))
}
- fn source(&mut self, s: &Source, proj: &Projection, kind: ChannelKind) -> [f32; 3] {
- match s {
- Source::Uniform(v) => *v,
+ /// The value `source` gives this texel through `projection`, read as a channel of `kind`
+ fn source(&mut self, source: &Source, projection: &Projection, kind: ChannelKind) -> [f32; 3] {
+ match source {
+ Source::Uniform(value) => *value,
Source::Procedural { pattern, low, high } => {
- let (c, proj, _) = self.projected(proj);
- let t = procedural(pattern, proj, &c);
- mix3(*low, *high, t)
+ let (coords, projection, _) = self.projected(projection);
+ let amount = procedural(pattern, projection, &coords);
+ mix3(*low, *high, amount)
}
Source::Image { name, normal_format } => {
- let Some(img) = self.inp.images.get(name) else { return [0.5; 3] };
- let (c, proj, _) = self.projected(proj);
- let mut acc = [0.0f32; 4];
- for (uv, w) in image_samples(proj, &c).into_iter().filter(|(_, w)| *w > 0.0) {
- let s = img.sample(uv.x, uv.y);
- for k in 0..4 {
- acc[k] += s[k] * w;
+ let Some(image) = self.inp.images.get(name) else { return [0.5; 3] };
+
+ let (coords, projection, _) = self.projected(projection);
+ let mut sum = [0.0f32; 4];
+ for (uv, weight) in image_samples(projection, &coords).into_iter().filter(|(_, weight)| *weight > 0.0) {
+ for (total, value) in sum.iter_mut().zip(image.sample(uv.x, uv.y)) {
+ *total += value * weight;
}
}
+
+ let rgb = [sum[0], sum[1], sum[2]];
match kind {
- ChannelKind::Color if img.srgb => [acc[0], acc[1], acc[2]].map(texturecraft_texel::srgb_to_linear),
- // Normal channels are OpenGL (+Y up the image): a DirectX image's green flips.
- ChannelKind::NormalMap if *normal_format == NormalFormat::DirectX => [acc[0], 1.0 - acc[1], acc[2]],
- ChannelKind::Color | ChannelKind::NormalMap => [acc[0], acc[1], acc[2]],
- ChannelKind::Scalar => [acc[0]; 3],
- ChannelKind::Signed => [acc[0] * 2.0 - 1.0; 3],
+ ChannelKind::Color if image.srgb => rgb.map(texturecraft_texel::srgb_to_linear),
+ // Normal channels are OpenGL (+Y up the image): a DirectX image's green flips
+ ChannelKind::NormalMap if *normal_format == NormalFormat::DirectX => [rgb[0], 1.0 - rgb[1], rgb[2]],
+ ChannelKind::Color | ChannelKind::NormalMap => rgb,
+ // A one-value channel or mask reads the image's gray, so a color image works as a mask
+ ChannelKind::Scalar => [lum(rgb); 3],
+ ChannelKind::Signed => [lum(rgb) * 2.0 - 1.0; 3],
}
}
Source::Anchor { anchor, channel } => {
- // An anchor not evaluated yet (above this layer, hidden) reads the channel default.
- let v = self.anchors.iter().rev().find(|(id, _)| id == anchor).and_then(|(_, acc)| acc.get(channel.index()).copied());
- let v = v.unwrap_or_else(|| channel.default_value());
+ // An anchor not evaluated yet (above this layer, hidden) reads the channel default
+ let anchored = self.anchors.iter().rev().find(|(id, _)| id == anchor).and_then(|(_, values)| values.get(channel.index()).copied());
+ let value = anchored.unwrap_or_else(|| channel.default_value());
let gray = matches!(channel.kind(), ChannelKind::Color | ChannelKind::NormalMap) && matches!(kind, ChannelKind::Scalar | ChannelKind::Signed);
- if gray { [lum(v); 3] } else { v }
+ if gray { [lum(value); 3] } else { value }
}
}
}
- fn generator(&mut self, g: &Generator) -> f32 {
- let c = self.coords();
- let s = match g.kind {
- GeneratorKind::EdgeWear => (self.baked(BakedMap::Curvature).unwrap_or(0.5) - 0.5) * 2.0,
- GeneratorKind::Curvature => self.baked(BakedMap::Curvature).unwrap_or(0.5),
- GeneratorKind::Dirt => 1.0 - self.baked(BakedMap::AmbientOcclusion).unwrap_or(1.0),
- GeneratorKind::AmbientOcclusion => self.baked(BakedMap::AmbientOcclusion).unwrap_or(1.0),
- GeneratorKind::ThinAreas => 1.0 - self.baked(BakedMap::Thickness).unwrap_or(1.0),
- GeneratorKind::Position => c.pos.dot(Vec3::from(g.direction).try_normalize().unwrap_or(Vec3::Y)) * 0.5 + 0.5,
- GeneratorKind::Direction => c.nrm.dot(Vec3::from(g.direction).try_normalize().unwrap_or(Vec3::Y)) * 0.5 + 0.5,
+ fn generator(&mut self, generator: &Generator, curvature_sizes: Option<&CurvatureSizes>) -> f32 {
+ let coords = self.coords();
+ let signal = match (generator.kind, &generator.detail) {
+ (GeneratorKind::Curvature | GeneratorKind::EdgeWear, Some(detail)) => self.curvature_detail(detail, curvature_sizes),
+ (GeneratorKind::EdgeWear, None) => (self.baked(BakedMap::Curvature).unwrap_or(0.5) - 0.5) * 2.0,
+ (GeneratorKind::Curvature, None) => self.baked(BakedMap::Curvature).unwrap_or(0.5),
+ (GeneratorKind::Dirt, _) => 1.0 - self.baked(BakedMap::AmbientOcclusion).unwrap_or(1.0),
+ (GeneratorKind::AmbientOcclusion, _) => self.baked(BakedMap::AmbientOcclusion).unwrap_or(1.0),
+ (GeneratorKind::ThinAreas, _) => 1.0 - self.baked(BakedMap::Thickness).unwrap_or(1.0),
+ (GeneratorKind::Position, _) => coords.pos.dot(Vec3::from(generator.direction).try_normalize().unwrap_or(Vec3::Y)) * 0.5 + 0.5,
+ (GeneratorKind::Direction, _) => coords.nrm.dot(Vec3::from(generator.direction).try_normalize().unwrap_or(Vec3::Y)) * 0.5 + 0.5,
};
- let s = if g.noise_amount > 0.0 { s + (world_noise(c.pos, g.noise_scale, g.seed) - 0.5) * g.noise_amount } else { s };
- let th = 1.0 - g.level.clamp(0.0, 1.0);
- let soft = g.softness.max(1e-3);
- let t = ((s - (th - soft)) / (2.0 * soft)).clamp(0.0, 1.0);
- let v = t * t * (3.0 - 2.0 * t);
- if g.invert { 1.0 - v } else { v }
+ let signal = if generator.noise_amount > 0.0 {
+ let noise = world_noise(coords.pos, generator.noise_scale, generator.seed);
+ if let (GeneratorKind::Curvature | GeneratorKind::EdgeWear, Some(detail)) = (generator.kind, &generator.detail) {
+ // Break up curvature without inventing edges or cavities on a flat surface
+ let neutral = if detail.mode == CurvatureMode::Raw { 0.5 } else { 0.0 };
+ neutral + (signal - neutral) * (1.0 - noise * generator.noise_amount).max(0.0)
+ } else {
+ signal + (noise - 0.5) * generator.noise_amount
+ }
+ } else {
+ signal
+ };
+
+ // A smooth step from black to white over 2 × softness around 1 − level
+ let threshold = 1.0 - generator.level.clamp(0.0, 1.0);
+ let softness = generator.softness.max(1e-3);
+ let ramp = ((signal - (threshold - softness)) / (2.0 * softness)).clamp(0.0, 1.0);
+ let value = ramp * ramp * (3.0 - 2.0 * ramp);
+ if generator.invert { 1.0 - value } else { value }
}
- fn mask(&mut self, m: &MaskPlan) -> f32 {
- let mut v = m.background;
- let mut skip = 0;
- if let Some((k, field)) = m.start
- && let Some(f) = field.get(self.x, self.y).and_then(|d| d.first().copied())
- {
- v = f;
- skip = k + 1;
+ /// The curvature of `detail`'s mode at this texel: each detail size's edges and cavities, weighted and combined like a screen blend.
+ fn curvature_detail(&self, detail: &CurvatureDetail, curvature_sizes: Option<&CurvatureSizes>) -> f32 {
+ let combine = |edges: f32, cavities: f32| match detail.mode {
+ CurvatureMode::Edges => edges,
+ CurvatureMode::Cavities => cavities,
+ CurvatureMode::Both => 1.0 - (1.0 - edges) * (1.0 - cavities),
+ CurvatureMode::Raw => 0.5 + 0.5 * (edges - cavities),
+ };
+
+ // Without curvature to read the texel is flat: no edges or cavities
+ let Some(curvature) = self.baked(BakedMap::Curvature) else { return combine(0.0, 0.0) };
+
+ let working_size = (self.res, self.inp.gbuf.height);
+ let texel_uv = [(self.x as f32 + 0.5) / working_size.0.max(1) as f32, (self.y as f32 + 0.5) / working_size.1.max(1) as f32];
+ let Some(baked_uv) = self.inp.block_scales.bake_uv(texel_uv, working_size) else { return combine(0.0, 0.0) };
+
+ let baked_size = (self.inp.baked.resolution, self.inp.baked.height(BakedMap::Curvature));
+ let (baked_x, baked_y) = ((baked_uv[0] * baked_size.0 as f32) as u32, (baked_uv[1] * baked_size.1 as f32) as u32);
+ let blurred = |index: usize| {
+ curvature_sizes.and_then(|sizes| sizes.levels.get(index)).and_then(Option::as_deref).map_or(0.0, |level| level.sample(baked_x, baked_y))
+ };
+ let (mut edges, mut cavities) = (0.0f32, 0.0f32);
+ for (index, (size, weight)) in CurvatureDetail::SIZES.iter().zip(detail.weights).enumerate() {
+ let deviation = if index == 0 { curvature - 0.5 } else { blurred(index - 1) };
+
+ let response = deviation * if *size == 0.0 { MAP_GAIN } else { GAIN_PER_DETAIL_TEXEL * size };
+ let weight = weight.clamp(0.0, 1.0);
+ edges = 1.0 - (1.0 - edges) * (1.0 - weight * response.clamp(0.0, 1.0));
+ cavities = 1.0 - (1.0 - cavities) * (1.0 - weight * (-response).clamp(0.0, 1.0));
}
- for e in m.effects.iter().skip(skip) {
- let o = e.opacity.clamp(0.0, 1.0);
- match e.kind {
+
+ combine(edges, cavities)
+ }
+
+ fn mask(&mut self, plan: &MaskPlan) -> f32 {
+ let mut value = plan.background;
+ let mut skip = 0;
+ if let Some((filtered_index, field)) = plan.start
+ && let Some(filtered) = field.get(self.x, self.y).and_then(|texel| texel.first().copied())
+ {
+ value = filtered;
+ skip = filtered_index + 1;
+ }
+
+ for effect in plan.effects.iter().skip(skip) {
+ let opacity = effect.opacity.clamp(0.0, 1.0);
+ match effect.kind {
EffectKind::Paint | EffectKind::Path(_) => {
- let (mut pv, mut cov) = match e.data.as_deref() {
- Some(d) => (from_u16(d.get(self.o * 2).copied().unwrap_or(0)), from_u16(d.get(self.o * 2 + 1).copied().unwrap_or(0))),
+ let (mut painted, mut cov) = match effect.data.as_deref() {
+ Some(data) => (from_u16(data.get(self.o * 2).copied().unwrap_or(0)), from_u16(data.get(self.o * 2 + 1).copied().unwrap_or(0))),
None => (0.0, 0.0),
};
- if e.preview
- && let Some(p) = self.inp.preview
+ if effect.preview
+ && let Some(preview) = self.inp.preview
{
- let a = (self.stroke * p.opacity).clamp(0.0, 1.0);
- if p.erase {
- pv *= 1.0 - a;
- cov *= 1.0 - a;
+ let stroke = (self.stroke * preview.opacity).clamp(0.0, 1.0);
+ if preview.erase {
+ painted *= 1.0 - stroke;
+ cov *= 1.0 - stroke;
} else {
- pv = p.mask_value * a + pv * (1.0 - a);
- cov = a + cov * (1.0 - a);
+ painted = preview.mask_value * stroke + painted * (1.0 - stroke);
+ cov = stroke + cov * (1.0 - stroke);
}
}
if cov > 0.0 {
- let val = pv / cov.max(1e-5);
- v += (blend1(e.blend, v, val) - v) * cov * o;
+ let layer_value = painted / cov.max(1e-5);
+ value += (blend1(effect.blend, value, layer_value) - value) * cov * opacity;
}
}
EffectKind::Fill { source, projection } => {
- let val = self.source(source, projection, ChannelKind::Scalar)[0];
- v += (blend1(e.blend, v, val) - v) * o * self.cover(std::iter::once(source), projection);
+ let fill = self.source(source, projection, ChannelKind::Scalar)[0];
+ value += (blend1(effect.blend, value, fill) - value) * opacity * self.cover(std::iter::once(source), projection);
}
- EffectKind::Generator(g) => {
- let val = self.generator(g);
- v += (blend1(e.blend, v, val) - v) * o;
+ EffectKind::Generator(generator) => {
+ let generated = self.generator(generator, effect.curvature_sizes.as_deref());
+ value += (blend1(effect.blend, value, generated) - value) * opacity;
}
- EffectKind::Levels(l) => v += (l.apply(v) - v) * o,
- EffectKind::Filter(f) => {
- // A mask is gray (HSL only changes its lightness); neighbourhood filters come
- // precomputed through `MaskPlan::start`.
- let val = f.point(ChannelKind::Scalar, [v; 3]).map_or(v, |x| x[0]);
- v += (val - v) * o;
+ EffectKind::Levels(levels) => value += (levels.apply(value) - value) * opacity,
+ EffectKind::Filter(filter) => {
+ // A mask is gray (HSL only changes its lightness); neighbourhood filters come precomputed through `MaskPlan::start`
+ let filtered = filter.point(ChannelKind::Scalar, [value; 3]).map_or(value, |gray| gray[0]);
+ value += (filtered - value) * opacity;
}
EffectKind::ColorSelection { colors, tolerance } => {
let id = self.baked_color(BakedMap::Id);
- let hit = id.is_some_and(|c| colors.iter().any(|k| (k[0] - c[0]).abs().max((k[1] - c[1]).abs()).max((k[2] - c[2]).abs()) <= *tolerance));
- let val = if hit { 1.0 } else { 0.0 };
- v += (blend1(e.blend, v, val) - v) * o;
+ let within = |picked: &[f32; 3], color: [f32; 3]| (0..3).all(|component| (picked[component] - color[component]).abs() <= *tolerance);
+ let selected = if id.is_some_and(|color| colors.iter().any(|picked| within(picked, color))) { 1.0 } else { 0.0 };
+ value += (blend1(effect.blend, value, selected) - value) * opacity;
}
- EffectKind::Compare { op, value, tolerance } => {
+ EffectKind::Compare { op, value: compared, tolerance } => {
let pass = match op {
- CompareOp::LesserThan => v < *value,
- CompareOp::GreaterThan => v > *value,
- CompareOp::WithinTolerance => (v - value).abs() <= *tolerance,
+ CompareOp::LesserThan => value < *compared,
+ CompareOp::GreaterThan => value > *compared,
+ CompareOp::WithinTolerance => (value - compared).abs() <= *tolerance,
};
- let val = if pass { 1.0 } else { 0.0 };
- v += (val - v) * o;
+ let result = if pass { 1.0 } else { 0.0 };
+ value += (result - value) * opacity;
}
- // Content-only effects.
+ // Content-only effects
EffectKind::Material(_) | EffectKind::Anchor => {}
}
}
- v.clamp(0.0, 1.0)
+ value.clamp(0.0, 1.0)
}
/// Composite `nodes` over `acc`, recording anchors. Returns true when it reached the `stop`
@@ -1898,6 +1996,10 @@ pub fn mask_image(inputs: &Inputs, id: LayerId, size: u32) -> Option> {
let channels = inputs.project.texture_set(inputs.ts).map(|set| set.channel_list()).unwrap_or_default();
let (width, height) = (inputs.gbuf.width, inputs.gbuf.height);
let coordinates = all_tiles(width, height);
+
+ // A hidden layer's mask is left out of the stack's preparation
+ prepare_mask_curvature_sizes(inputs, std::iter::once(mask));
+
let fields = neighbourhood_fields(inputs, &channels, &coordinates);
let tiles: HashMap<(u32, u32), Vec> = coordinates
.par_iter()
@@ -1951,6 +2053,10 @@ pub fn mask_at(inputs: &Inputs, id: LayerId, texels: &[(u32, u32)]) -> Option = requested
@@ -2103,60 +2209,67 @@ pub type FlatTile = (Channel, (u32, u32), Vec);
/// Flatten one paint or fill layer: its content (with content effects) times its mask, as
/// premultiplied (value, coverage) tiles per enabled channel, ready to become a plain paint
/// layer. Groups are not supported (None).
-pub fn flatten_layer(inp: &Inputs, id: LayerId, tiles: &[(u32, u32)]) -> Option> {
- let set = inp.project.texture_set(inp.ts).ok()?;
- if inp.project.content_layer(id)?.is_group() {
+pub fn flatten_layer(inputs: &Inputs, id: LayerId, tiles: &[(u32, u32)]) -> Option> {
+ let set = inputs.project.texture_set(inputs.ts).ok()?;
+ if inputs.project.content_layer(id)?.is_group() {
return None;
}
+
let channels: Vec = set.channel_list();
- // Plan the layer forced visible so hidden layers flatten too.
- let mut solo = inp.project.clone();
+
+ // Plan the layer forced visible so hidden layers flatten too
+ let mut solo = inputs.project.clone();
if let Some(l) = solo.layers.get_mut(&id) {
l.visible = true;
}
- let solo_inp = Inputs { project: &solo, preview: None, block_scales: inp.block_scales.clone(), ..*inp };
- let fields = neighbourhood_fields(&solo_inp, &channels, tiles);
+ let visible_inputs = Inputs { project: &solo, preview: None, block_scales: inputs.block_scales.clone(), ..*inputs };
+ let fields = neighbourhood_fields(&visible_inputs, &channels, tiles);
+
let out: Vec> = tiles
.par_iter()
.map(|&(tx, ty)| {
- let nodes = plan(&solo_inp, &[id], &channels, tx, ty, 0, Some(&fields));
+ let nodes = plan(&visible_inputs, &[id], &channels, tx, ty, 0, Some(&fields));
let Some(n) = nodes.first() else { return Vec::new() };
- let full = anchor_plan(&solo_inp, id, &channels, tx, ty, Some(&fields));
- let mut bufs: Vec<(Channel, Vec, bool)> =
+ let full = anchor_plan(&visible_inputs, id, &channels, tx, ty, Some(&fields));
+ let mut buffers: Vec<(Channel, Vec, bool)> =
n.chans.iter().filter_map(|c| Channel::ALL.get(c.ch).map(|ch| (*ch, vec![0u16; TILE_AREA * (c.comps + 1)], false))).collect();
- for (ch, buf, _) in &mut bufs {
+ for (ch, buffer, _) in &mut buffers {
if ch.kind() == ChannelKind::Signed {
- for px in buf.chunks_exact_mut(2) {
- px[0] = to_u16_signed(0.0);
+ for pixel in buffer.as_chunks_mut::<2>().0 {
+ pixel[0] = to_u16_signed(0.0);
}
}
}
- for (x, y, o) in tile_texels(inp.gbuf, tx, ty) {
- let mut tex = Texel::new(&solo_inp, x, y, o, 0.0);
+
+ for (x, y, o) in tile_texels(inputs.gbuf, tx, ty) {
+ let mut tex = Texel::new(&visible_inputs, x, y, o, 0.0);
if !full.is_empty() {
tex.anchors_below(&full, id);
}
let m = tex.node_mask(n);
- for (c, (ch, buf, any)) in n.chans.iter().zip(bufs.iter_mut()) {
+ for (c, (ch, buffer, any)) in n.chans.iter().zip(buffers.iter_mut()) {
let Some((v, cov)) = tex.content(&n.content, c) else { continue };
let a = (cov * m).clamp(0.0, 1.0);
if a <= 0.0 {
continue;
}
+
*any = true;
let comps = c.comps;
- let Some(px) = buf.get_mut(o * (comps + 1)..(o + 1) * (comps + 1)) else { continue };
- for (slot, pv) in px.iter_mut().zip(v.iter().take(comps)) {
+ let Some(pixel) = buffer.get_mut(o * (comps + 1)..(o + 1) * (comps + 1)) else { continue };
+ for (slot, pv) in pixel.iter_mut().zip(v.iter().take(comps)) {
*slot = if ch.kind() == ChannelKind::Signed { to_u16_signed(pv * a) } else { to_u16(pv * a) };
}
- if let Some(slot) = px.get_mut(comps) {
+ if let Some(slot) = pixel.get_mut(comps) {
*slot = to_u16(a);
}
}
}
- bufs.into_iter().filter(|(_, _, any)| *any).map(|(ch, buf, _)| (ch, (tx, ty), buf)).collect()
+
+ buffers.into_iter().filter(|(_, _, any)| *any).map(|(ch, buffer, _)| (ch, (tx, ty), buffer)).collect()
})
.collect();
+
Some(out.into_iter().flatten().collect())
}
@@ -2455,6 +2568,80 @@ mod tests {
assert!(blurred_then_warped.iter().zip(&warped).any(|(chained, single)| (chained - single).abs() > 0.1), "the blur under the warp still runs");
}
+ #[test]
+ fn larger_curvature_detail_sizes_reach_further_from_an_edge() {
+ let mut fixture = fixture();
+ fixture.gbuf = UvGBuffer::new(&fixture.mesh, 0, 256, 256);
+ fixture.project.texture_sets[0].resolution = 256;
+ let ridge: Vec = (0..256 * 256).map(|texel| if texel % 256 == 128 { 1.0 } else { 0.5 }).collect();
+ fixture.baked = BakedMaps { resolution: 256, maps: [(BakedMap::Curvature, Arc::new(ridge))].into() };
+ let layer = fill_layer(&mut fixture.project, [1.0; 3], 1.0);
+ let row_with = |fixture: &mut Fixture, weights: [f32; 7]| -> Vec {
+ let detail = CurvatureDetail { mode: CurvatureMode::Edges, weights };
+ let generator = Generator { level: 0.5, softness: 0.5, noise_amount: 0.0, detail: Some(detail), ..Generator::new(GeneratorKind::Curvature) };
+ let mut mask = Mask::new(MaskBackground::Black);
+ mask.effects.push(Effect::new(fixture.project.alloc_id(), EffectKind::Generator(generator)));
+ fixture.project.layer_mut(layer).unwrap().mask = Some(mask);
+ let images = Default::default();
+ let inputs = Inputs {
+ project: &fixture.project,
+ ts: 0,
+ mesh: &fixture.mesh,
+ gbuf: &fixture.gbuf,
+ pixels: &fixture.pixels,
+ baked: &fixture.baked,
+ block_scales: BlockScales::default(),
+ preview: None,
+ images: &images,
+ bounds: fixture.mesh.bounds(),
+ };
+ mask_at(&inputs, layer, &(120..137).map(|x| (x, 128)).collect::>()).unwrap()
+ };
+
+ // The row starts at x 120: the ridge is its ninth texel, five texels left of it the fourth
+ let (ridge, five_texels_away) = (8, 3);
+ let finest = row_with(&mut fixture, [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]);
+ let largest = row_with(&mut fixture, [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0]);
+ assert!(finest[ridge] > 0.99 && finest[five_texels_away] < 0.01, "the map itself marks only the ridge: {finest:?}");
+ assert!(largest[ridge] > 0.99 && largest[five_texels_away] > 0.5, "the largest size reaches texels away from it: {largest:?}");
+ }
+
+ #[test]
+ fn curvature_detail_noise_keeps_flat_areas_neutral() {
+ let mut fixture = fixture();
+ fixture.baked = BakedMaps { resolution: 64, maps: [(BakedMap::Curvature, Arc::new(vec![0.5; 64 * 64]))].into() };
+ let layer = fill_layer(&mut fixture.project, [1.0; 3], 1.0);
+ let texels: Vec<_> = (0..64).map(|x| (x, 32)).collect();
+
+ for kind in [GeneratorKind::Curvature, GeneratorKind::EdgeWear] {
+ for mode in CurvatureMode::ALL {
+ let detail = CurvatureDetail { mode, weights: [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0] };
+ let generator = Generator { level: 0.5, softness: 0.5, noise_amount: 2.0, detail: Some(detail), ..Generator::new(kind) };
+ let mut mask = Mask::new(MaskBackground::Black);
+ mask.effects.push(Effect::new(fixture.project.alloc_id(), EffectKind::Generator(generator)));
+ fixture.project.layer_mut(layer).unwrap().mask = Some(mask);
+
+ let values = assert_sparse_mask_matches_image(&fixture, layer, &texels).unwrap();
+ let expected = if mode == CurvatureMode::Raw { 0.5 } else { 0.0 };
+ assert!(values.iter().all(|value| (value - expected).abs() < 0.001), "{kind:?} {mode:?} paints noise on flat curvature: {values:?}");
+ }
+ }
+ }
+
+ #[test]
+ fn raw_curvature_reads_mid_gray_without_a_curvature_map() {
+ let mut fixture = fixture();
+ let layer = fill_layer(&mut fixture.project, [1.0; 3], 1.0);
+ let detail = CurvatureDetail { mode: CurvatureMode::Raw, ..CurvatureDetail::default() };
+ let generator = Generator { level: 0.5, softness: 0.5, noise_amount: 0.0, detail: Some(detail), ..Generator::new(GeneratorKind::Curvature) };
+ let mut mask = Mask::new(MaskBackground::Black);
+ mask.effects.push(Effect::new(fixture.project.alloc_id(), EffectKind::Generator(generator)));
+ fixture.project.layer_mut(layer).unwrap().mask = Some(mask);
+
+ let values = assert_sparse_mask_matches_image(&fixture, layer, &[(32, 32)]).unwrap();
+ assert!(values.iter().all(|value| (value - 0.5).abs() < 0.01), "flat curvature is mid gray in raw mode, not black: {values:?}");
+ }
+
#[test]
fn blur_filter_softens_mask_edges() {
let mut f = fixture();
diff --git a/crates/compose/src/eval/thumbnail.rs b/crates/compose/src/eval/thumbnail.rs
new file mode 100644
index 00000000..92290afe
--- /dev/null
+++ b/crates/compose/src/eval/thumbnail.rs
@@ -0,0 +1,30 @@
+//! Isolated folder evaluation with the original stack available for anchor inputs.
+
+use super::{Channel, ChannelKind, Composite, Inputs, LayerId, Texel, all_tiles, neighbourhood_fields, plan, tile_texels, to_u16, to_u16_signed};
+
+/// Composite one layer over channel defaults, keeping anchors from the stack below it.
+pub(crate) fn composite_layer(inputs: &Inputs, layer: LayerId, channel: Channel) -> Option {
+ let set = inputs.project.texture_set(inputs.ts).ok()?;
+ let channels = set.channel_list();
+ let (width, height) = (inputs.gbuf.width, inputs.gbuf.height);
+ let tiles = all_tiles(width, height);
+ let fields = neighbourhood_fields(inputs, &channels, &tiles);
+ let mut composite = Composite::with_size(&[channel], width, height);
+ let output = composite.channels.get_mut(&channel)?;
+
+ for (tile_x, tile_y) in tiles {
+ let nodes = plan(inputs, &[layer], &channels, tile_x, tile_y, 0, Some(&fields));
+ let full_stack = if set.stack.as_slice() == [layer] { Vec::new() } else { plan(inputs, &set.stack, &channels, tile_x, tile_y, 0, Some(&fields)) };
+ for (x, y, offset) in tile_texels(inputs.gbuf, tile_x, tile_y) {
+ let mut texel = Texel::new(inputs, x, y, offset, 0.0);
+ texel.anchors_below(&full_stack, layer);
+ let mut values = Channel::ALL.map(Channel::default_value);
+ texel.eval(&nodes, &mut values);
+ let value = values.get(channel.index()).copied().unwrap_or_else(|| channel.default_value());
+ let encoded = value.map(|component| if channel.kind() == ChannelKind::Signed { to_u16_signed(component) } else { to_u16(component) });
+ output.set(x, y, &encoded[..channel.components()]);
+ }
+ }
+
+ Some(composite)
+}
diff --git a/crates/compose/src/lib.rs b/crates/compose/src/lib.rs
index 01365a27..46c3c6b5 100644
--- a/crates/compose/src/lib.rs
+++ b/crates/compose/src/lib.rs
@@ -9,10 +9,13 @@
mod baked_maps;
pub mod below;
+mod curvature_size_level;
+pub mod curvature_sizes;
pub mod display;
pub mod eval;
pub mod pattern;
pub mod store;
+pub mod thumb;
pub use below::{BelowCache, StackKey};
pub use display::{DisplayKind, tile_bytes};
@@ -21,3 +24,4 @@ pub use eval::{
mask_at, mask_image, pad_tiles,
};
pub use store::{BakedMaps, ImageRes, ImageStore, PixelStore};
+pub use thumb::{THUMB_TEXELS, ThumbImage, ThumbTarget};
diff --git a/crates/compose/src/thumb.rs b/crates/compose/src/thumb.rs
new file mode 100644
index 00000000..b4c59a15
--- /dev/null
+++ b/crates/compose/src/thumb.rs
@@ -0,0 +1,206 @@
+//! Small previews of one layer's content, one mask, or one effect stage, computed without
+//! touching the main composite.
+//!
+//! Every thumbnail is the ordinary compositor run on a *cut* copy of the project: only the
+//! requested layer is drawn, forced visible at Normal / 100 %, and
+//! the layer's effect list is truncated after the effect being previewed. The evaluator is the
+//! same code the viewport uses (just on a small G-buffer), so a thumbnail always agrees with
+//! what the stack really computes. Nothing here mutates the caller's project.
+
+use texturecraft_core::{BlendMode, Channel, ChannelBlend, ChannelKind, LayerId, Project};
+use texturecraft_texel::{TILE, from_u16, from_u16_signed, linear_to_srgb};
+
+use crate::eval::{Composite, FlatTile, Inputs, all_tiles, flatten_layer, mask_image};
+
+/// Edge length (texels) the thumbnails are computed at.
+pub const THUMB_TEXELS: u32 = 64;
+
+/// What a thumbnail shows.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum ThumbTarget {
+ /// The content of a layer (content effects included, mask ignored) in `channel`.
+ Content { layer: LayerId, channel: Channel },
+ /// The mask of a layer (an instance without its own mask shows its source's).
+ Mask { layer: LayerId },
+ /// The result up to and including `effect`, in the layer's content (`channel`) or in its
+ /// mask (the channel is ignored). An effect that is hidden shows the bypassed result.
+ Stage { effect: LayerId, channel: Channel },
+}
+
+/// An 8-bit RGBA thumbnail (straight alpha). Alpha is 0 where the mesh does not cover the
+/// texture and, for a paint or fill layer's content, where the layer has nothing; the view
+/// paints its own background there.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ThumbImage {
+ pub width: u32,
+ pub height: u32,
+ pub rgba: Vec,
+}
+
+/// The thumbnail of `target`, computed at `inp.gbuf`'s size, which must be square (use a
+/// [`THUMB_TEXELS`] G-buffer; None otherwise). None for an unknown layer or effect, a layer without that channel, or a
+/// mask that does not exist.
+pub fn render(inp: &Inputs, target: ThumbTarget) -> Option {
+ if inp.gbuf.width != inp.gbuf.height {
+ return None;
+ }
+ match target {
+ ThumbTarget::Content { layer, channel } => content(inp, layer, channel, None),
+ ThumbTarget::Mask { layer } => mask(inp, layer, None),
+ ThumbTarget::Stage { effect, channel } => {
+ let (owner, _) = inp.project.effect(effect)?;
+ let in_mask = inp.project.layers.get(&owner)?.mask.as_ref().is_some_and(|m| m.effects.iter().any(|e| e.id == effect));
+ if in_mask { mask(inp, owner, Some(effect)) } else { content(inp, owner, channel, Some(effect)) }
+ }
+ }
+}
+
+/// Force the requested layer visible, retaining the stack needed by anchor readers.
+fn solo(project: &Project, texture_set: usize, id: LayerId, channel: Option) -> Option {
+ let mut cut = project.clone();
+
+ // Ordinary previews need no neighbouring layers or their filter allocations
+ if !project.render_tree(&[id]).iter().any(|layer| crate::eval::reads_anchor(project, *layer)) {
+ cut.texture_sets.get_mut(texture_set)?.stack = vec![id];
+ }
+
+ cut.layers.get_mut(&id)?.visible = true;
+ if let Some(channel) = channel {
+ // Instances inherit channels from their source
+ let owner = cut.content_layer(id)?.id;
+ *cut.layers.get_mut(&owner)?.channels.get_mut(&channel)? = ChannelBlend { mode: BlendMode::Normal, opacity: 1.0 };
+ }
+
+ Some(cut)
+}
+
+/// Keep the effects of `list` up to and including `last`.
+fn truncate_after(list: &mut Vec, last: LayerId) -> bool {
+ match list.iter().position(|e| e.id == last) {
+ Some(k) => {
+ list.truncate(k + 1);
+ true
+ }
+ None => false,
+ }
+}
+
+fn content(inputs: &Inputs, layer: LayerId, channel: Channel, through_effect: Option) -> Option {
+ let set = inputs.project.texture_set(inputs.ts).ok()?;
+ if !set.channel_list().contains(&channel) {
+ return None;
+ }
+
+ // An instance draws its source's effects
+ let mut cut = solo(inputs.project, inputs.ts, layer, Some(channel))?;
+ let owner = cut.content_layer(layer)?.id;
+ for id in [layer, owner] {
+ let content = cut.layers.get_mut(&id)?;
+ content.mask = None;
+ content.visible = true;
+ }
+
+ if let Some(effect) = through_effect
+ && !truncate_after(&mut cut.layers.get_mut(&owner)?.content_effects, effect)
+ {
+ return None;
+ }
+
+ let cut_inputs = Inputs { project: &cut, preview: None, block_scales: inputs.block_scales.clone(), ..*inputs };
+ let (width, height) = (inputs.gbuf.width, inputs.gbuf.height);
+
+ // Paint and fill previews retain coverage; folders composite over channel defaults
+ if !cut.layers.get(&owner)?.is_group() {
+ let flat = flatten_layer(&cut_inputs, layer, &all_tiles(width, height))?;
+ return Some(encode_flat(&flat, channel, width, height));
+ }
+
+ let comp = crate::eval::thumbnail::composite_layer(&cut_inputs, layer, channel)?;
+ Some(encode_channel(&comp, channel, inputs))
+}
+
+/// Encode the flattened (premultiplied value, coverage) tiles of `channel`: alpha is coverage.
+fn encode_flat(flat: &[FlatTile], channel: Channel, w: u32, h: u32) -> ThumbImage {
+ let mut rgba = vec![0u8; (w * h) as usize * 4];
+ let comps = channel.components();
+ let signed = channel.kind() == ChannelKind::Signed;
+ for (c, (tx, ty), buf) in flat {
+ if *c != channel {
+ continue;
+ }
+ for (o, px) in buf.chunks_exact(comps + 1).enumerate() {
+ let (x, y) = (tx * TILE + o as u32 % TILE, ty * TILE + o as u32 / TILE);
+ let a = px.get(comps).map_or(0.0, |v| from_u16(*v));
+ if x >= w || y >= h || a <= 0.0 {
+ continue;
+ }
+ let mut v = [0.0f32; 3];
+ for (k, slot) in v.iter_mut().enumerate() {
+ let raw = px.get(k.min(comps - 1)).copied().unwrap_or(0);
+ *slot = if signed { from_u16_signed(raw) } else { from_u16(raw) } / a;
+ }
+ let p = display(channel, v);
+ let i = ((y * w + x) * 4) as usize;
+ if let Some(d) = rgba.get_mut(i..i + 4) {
+ d.copy_from_slice(&[p[0], p[1], p[2], to_byte(a)]);
+ }
+ }
+ }
+ ThumbImage { width: w, height: h, rgba }
+}
+
+/// A channel value as display bytes: colors linear → sRGB, signed values with 0 at mid gray,
+/// normal maps and scalars as stored.
+fn display(channel: Channel, v: [f32; 3]) -> [u8; 3] {
+ match channel.kind() {
+ ChannelKind::Color => v.map(|c| to_byte(linear_to_srgb(c.clamp(0.0, 1.0)))),
+ ChannelKind::Signed => v.map(|c| to_byte(c * 0.5 + 0.5)),
+ ChannelKind::Scalar | ChannelKind::NormalMap => v.map(to_byte),
+ }
+}
+
+fn mask(inputs: &Inputs, layer: LayerId, through_effect: Option) -> Option {
+ let mut cut = solo(inputs.project, inputs.ts, layer, None)?;
+ let owner = cut.mask_owner(layer);
+ let mask = cut.layers.get_mut(&owner)?.mask.as_mut()?;
+ mask.enabled = true;
+ if let Some(effect) = through_effect
+ && !truncate_after(&mut mask.effects, effect)
+ {
+ return None;
+ }
+
+ let cut_inputs = Inputs { project: &cut, preview: None, block_scales: inputs.block_scales.clone(), ..*inputs };
+ let (width, height) = (inputs.gbuf.width, inputs.gbuf.height);
+ let gray = mask_image(&cut_inputs, layer, width)?;
+ let mut rgba = Vec::with_capacity((width * height) as usize * 4);
+ for y in 0..height {
+ for x in 0..width {
+ let offset = (y * width + x) as usize;
+ let value = gray.get(offset).copied().unwrap_or(0);
+ rgba.extend_from_slice(&[value, value, value, if inputs.gbuf.covered(offset) { 255 } else { 0 }]);
+ }
+ }
+
+ Some(ThumbImage { width, height, rgba })
+}
+
+/// Encode the composited `channel` for display: colors linear → sRGB, signed values 0 → mid
+/// gray, normal maps and scalars as stored (data channels raw).
+fn encode_channel(comp: &Composite, channel: Channel, inp: &Inputs) -> ThumbImage {
+ let (w, h) = (comp.resolution, comp.height);
+ let mut rgba = Vec::with_capacity((w * h) as usize * 4);
+ for y in 0..h {
+ for x in 0..w {
+ let v = comp.value(channel, x, y);
+ let px = display(channel, v);
+ let covered = inp.gbuf.covered((y * w + x) as usize);
+ rgba.extend_from_slice(&[px[0], px[1], px[2], if covered { 255 } else { 0 }]);
+ }
+ }
+ ThumbImage { width: w, height: h, rgba }
+}
+
+fn to_byte(v: f32) -> u8 {
+ if v.is_finite() { (v.clamp(0.0, 1.0) * 255.0 + 0.5) as u8 } else { 0 }
+}
diff --git a/crates/core/src/layer.rs b/crates/core/src/layer.rs
index 551c9803..37ce47e8 100644
--- a/crates/core/src/layer.rs
+++ b/crates/core/src/layer.rs
@@ -6,6 +6,12 @@ use serde::{Deserialize, Serialize};
use crate::{BlendMode, Channel, ChannelKind, lum};
+mod curvature_detail;
+mod curvature_mode;
+
+pub use curvature_detail::CurvatureDetail;
+pub use curvature_mode::CurvatureMode;
+
/// Id of a layer or effect (one id space per project).
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
pub struct LayerId(pub u64);
@@ -540,17 +546,26 @@ pub struct Generator {
/// Direction for `Position` / `Direction` generators (world space).
pub direction: [f32; 3],
pub invert: bool,
+ /// Mode and detail sizes of `Curvature` / `EdgeWear` generators (None: the curvature map as baked, as before detail sizes existed).
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub detail: Option,
}
impl Generator {
pub fn new(kind: GeneratorKind) -> Generator {
let (level, softness, noise_amount) = match kind {
- GeneratorKind::EdgeWear => (0.6, 0.12, 0.5),
+ GeneratorKind::EdgeWear => (0.5, 0.25, 0.3),
+ GeneratorKind::Curvature => (0.5, 0.5, 0.0),
GeneratorKind::Dirt => (0.55, 0.25, 0.35),
GeneratorKind::ThinAreas => (0.3, 0.2, 0.0),
_ => (0.5, 0.25, 0.0),
};
- Generator { kind, level, softness, noise_amount, noise_scale: 8.0, seed: 7, direction: [0.0, 1.0, 0.0], invert: false }
+ let detail = match kind {
+ GeneratorKind::Curvature => Some(CurvatureDetail::default()),
+ GeneratorKind::EdgeWear => Some(CurvatureDetail { mode: CurvatureMode::Edges, weights: CurvatureDetail::EDGE_WEIGHTS }),
+ _ => None,
+ };
+ Generator { kind, level, softness, noise_amount, noise_scale: 8.0, seed: 7, direction: [0.0, 1.0, 0.0], invert: false, detail }
}
}
@@ -1050,6 +1065,17 @@ impl Effect {
mod tests {
use super::*;
+ #[test]
+ fn curvature_generators_saved_before_detail_sizes_load_without_them() {
+ let mut saved = serde_json::to_value(Generator::new(GeneratorKind::Curvature)).unwrap();
+ assert!(saved.get("detail").is_some(), "new curvature generators have detail sizes");
+
+ saved.as_object_mut().unwrap().remove("detail");
+ let loaded: Generator = serde_json::from_value(saved).unwrap();
+ assert_eq!(loaded.detail, None);
+ assert_eq!(Generator::new(GeneratorKind::Dirt).detail, None, "only curvature and edge wear generators have detail sizes");
+ }
+
#[test]
fn levels_map_range_and_gamma() {
let l = Levels { in_low: 0.2, in_high: 0.6, gamma: 1.0, out_low: 0.0, out_high: 1.0 };
diff --git a/crates/core/src/layer/curvature_detail.rs b/crates/core/src/layer/curvature_detail.rs
new file mode 100644
index 00000000..75c9d36a
--- /dev/null
+++ b/crates/core/src/layer/curvature_detail.rs
@@ -0,0 +1,36 @@
+use serde::{Deserialize, Serialize};
+
+use super::curvature_mode::CurvatureMode;
+
+/// How a curvature generator reads the curvature map: its mode and how much each detail size adds.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CurvatureDetail {
+ pub mode: CurvatureMode,
+ /// Weight (0..1) of each size in [`CurvatureDetail::SIZES`], finest first.
+ pub weights: [f32; CurvatureDetail::SIZES.len()],
+}
+
+impl CurvatureDetail {
+ /// Detail sizes as blur radii in texels at 2K: the map itself, then doubling radii.
+ pub const SIZES: [f32; 7] = [0.0, 1.0, 2.0, 4.0, 8.0, 16.0, 32.0];
+
+ /// Weights falling off with size, tuned by eye on hard-surface bakes: sharp edges first, broad shapes lit faintly.
+ pub const BROAD_WEIGHTS: [f32; 7] = [1.0, 0.85, 0.7, 0.55, 0.4, 0.25, 0.15];
+
+ /// Mostly the finer sizes, tuned the same way: worn edges are thin lines.
+ pub const EDGE_WEIGHTS: [f32; 7] = [1.0, 0.8, 0.5, 0.25, 0.1, 0.0, 0.0];
+
+ /// How many sizes are blurred copies of the map (all but the first).
+ pub const BLURRED_SIZES: usize = CurvatureDetail::SIZES.len() - 1;
+
+ /// Which blurred sizes this detail reads: those with a weight above 0.
+ pub fn blurred_sizes_in_use(&self) -> [bool; CurvatureDetail::BLURRED_SIZES] {
+ std::array::from_fn(|blurred| self.weights.get(blurred + 1).is_some_and(|weight| *weight > 0.0))
+ }
+}
+
+impl Default for CurvatureDetail {
+ fn default() -> Self {
+ CurvatureDetail { mode: CurvatureMode::Edges, weights: CurvatureDetail::BROAD_WEIGHTS }
+ }
+}
diff --git a/crates/core/src/layer/curvature_mode.rs b/crates/core/src/layer/curvature_mode.rs
new file mode 100644
index 00000000..a4183e7a
--- /dev/null
+++ b/crates/core/src/layer/curvature_mode.rs
@@ -0,0 +1,34 @@
+use serde::{Deserialize, Serialize};
+
+/// Which side of the curvature map a curvature generator shows.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum CurvatureMode {
+ /// Convex edges white.
+ #[default]
+ Edges,
+ /// Concave cavities white.
+ Cavities,
+ /// Edges and cavities both white.
+ Both,
+ /// Signed curvature around mid gray (cavities dark, edges light).
+ Raw,
+}
+
+impl CurvatureMode {
+ pub const ALL: [CurvatureMode; 4] = [CurvatureMode::Edges, CurvatureMode::Cavities, CurvatureMode::Both, CurvatureMode::Raw];
+
+ pub fn label(self) -> &'static str {
+ match self {
+ CurvatureMode::Edges => "Edges",
+ CurvatureMode::Cavities => "Cavities",
+ CurvatureMode::Both => "Edges and cavities",
+ CurvatureMode::Raw => "Raw curvature",
+ }
+ }
+
+ /// The mode named `name` (its variant or label, any case).
+ pub fn parse(name: &str) -> Option {
+ let normalized = |text: &str| text.to_ascii_lowercase().replace([' ', '_', '-'], "");
+ CurvatureMode::ALL.into_iter().find(|mode| normalized(&format!("{mode:?}")) == normalized(name) || normalized(mode.label()) == normalized(name))
+ }
+}
diff --git a/crates/core/src/lib.rs b/crates/core/src/lib.rs
index 72adf044..75ea2405 100644
--- a/crates/core/src/lib.rs
+++ b/crates/core/src/lib.rs
@@ -24,8 +24,9 @@ pub use bake::{
pub use blend::{BlendMode, blend1, blend3, lum, mix3};
pub use channel::{Channel, ChannelFormat, ChannelKind};
pub use layer::{
- ChannelBlend, CompareOp, Decal, Effect, EffectKind, Fill, Filter, Generator, GeneratorKind, HeightMask, Layer, LayerId, LayerKind, Levels, LinkParam,
- LinkPreset, Mask, MaskBackground, MaterialLink, PathShape, Procedural, ProceduralKind, Projection, Source, gradient, hsl_adjust, per_unit,
+ ChannelBlend, CompareOp, CurvatureDetail, CurvatureMode, Decal, Effect, EffectKind, Fill, Filter, Generator, GeneratorKind, HeightMask, Layer, LayerId,
+ LayerKind, Levels, LinkParam, LinkPreset, Mask, MaskBackground, MaterialLink, PathShape, Procedural, ProceduralKind, Projection, Source, gradient,
+ hsl_adjust, per_unit,
};
pub use project::{
AoMixing, BlockScales, Camera, DepthOfField, DisplaySettings, FORMAT_VERSION, MAX_RESOLUTION, MIN_RESOLUTION, NormalFormat, NormalMixing, Project,
diff --git a/crates/core/src/project.rs b/crates/core/src/project.rs
index 36b5f856..3fe26e04 100644
--- a/crates/core/src/project.rs
+++ b/crates/core/src/project.rs
@@ -395,6 +395,11 @@ pub struct Project {
/// it, so parts the file leaves unnamed get the same name (from it) as on import.
#[serde(default, skip_serializing_if = "String::is_empty")]
pub mesh_file: String,
+ /// Where the mesh file was imported from (the project's "3D mesh path"). Reimport mesh reads
+ /// it again from there, so edits made to the file since are picked up. Empty when unknown
+ /// (built-in meshes, web imports, projects saved before it was kept).
+ #[serde(default, skip_serializing_if = "String::is_empty")]
+ pub mesh_path: String,
pub normal_format: NormalFormat,
pub texture_sets: Vec,
pub layers: BTreeMap,
@@ -412,6 +417,7 @@ impl Project {
name: name.into(),
mesh: mesh.into(),
mesh_file: String::new(),
+ mesh_path: String::new(),
normal_format: NormalFormat::OpenGl,
texture_sets: Vec::new(),
layers: BTreeMap::new(),
diff --git a/crates/engine/src/bake/bake_cage_inputs.rs b/crates/engine/src/bake/bake_cage_inputs.rs
new file mode 100644
index 00000000..ab559beb
--- /dev/null
+++ b/crates/engine/src/bake/bake_cage_inputs.rs
@@ -0,0 +1,45 @@
+use super::MergedHigh;
+use std::sync::Arc;
+use texturecraft_bake::{BakeError, BakePaintMap, BakeRequest, CageShell, HighPoly, HighPolyReach};
+use texturecraft_core::BakeSettings;
+use texturecraft_geom::{Bvh, Mesh};
+
+/// What a texture set's bake reads to place its transfer rays, owned so a worker thread can use it
+#[derive(Clone, Debug)]
+pub struct BakeCageInputs {
+ pub(super) mesh: Arc,
+ pub(super) bvh: Arc,
+ pub(super) material: usize,
+ pub(super) settings: BakeSettings,
+ pub(super) high: MergedHigh,
+ pub(super) cage: Option>,
+ pub(super) skew: Option>,
+ pub(super) cage_paint: Option>,
+}
+
+impl BakeCageInputs {
+ /// The cage the 3D view draws: the bake's ray origins at each triangle corner
+ pub fn cage_shell(&self) -> Result {
+ CageShell::new(&self.request())
+ }
+
+ /// Where each high-poly vertex sits relative to the bake's transfer rays
+ pub fn high_poly_reach(&self) -> Result {
+ HighPolyReach::new(&self.request())
+ }
+
+ fn request(&self) -> BakeRequest<'_> {
+ BakeRequest {
+ low_base_color: &[],
+ mesh: &self.mesh,
+ bvh: &self.bvh,
+ material: self.material,
+ settings: &self.settings,
+ high: Some(HighPoly { file_ids: &self.high.file_ids, mesh: &self.high.mesh, bvh: &self.high.bvh, base_color: &self.high.base_color }),
+ cage: self.cage.as_deref(),
+ skew: self.skew.as_deref(),
+ cage_paint: self.cage_paint.as_deref(),
+ tiles: (1, 1),
+ }
+ }
+}
diff --git a/crates/engine/src/bake/bake_meshes.rs b/crates/engine/src/bake/bake_meshes.rs
index 260002db..da0e4a97 100644
--- a/crates/engine/src/bake/bake_meshes.rs
+++ b/crates/engine/src/bake/bake_meshes.rs
@@ -14,6 +14,11 @@ pub struct BakeMeshes {
}
impl BakeMeshes {
+ /// Every high poly appended into one mesh, as bakes see it
+ pub fn merged_high(&self) -> Option<&MergedHigh> {
+ self.merged.as_ref()
+ }
+
pub(crate) fn rebuild(&mut self) {
self.merged = (!self.high.is_empty()).then(|| {
let (mut mesh, mut base_color, mut file_ids) = (Mesh::default(), Vec::new(), Vec::new());
diff --git a/crates/engine/src/bake/bake_task.rs b/crates/engine/src/bake/bake_task.rs
index 8c942176..24629b56 100644
--- a/crates/engine/src/bake/bake_task.rs
+++ b/crates/engine/src/bake/bake_task.rs
@@ -1,9 +1,9 @@
-use super::MergedHigh;
+use super::{MergedHigh, StreamedBake, StreamedMap};
use crate::{EngineError, Result};
use std::sync::Arc;
use texturecraft_bake::{BakeOutput, BakePaintMap, BakeRequest, HighPoly, Progress, bake_tiles, tracing::Tracer};
use texturecraft_compose::BakedMaps;
-use texturecraft_core::BakeSettings;
+use texturecraft_core::{BakeSettings, BakedMap};
use texturecraft_geom::{Bvh, Mesh};
/// A self-contained bake task that can run on another thread.
@@ -29,7 +29,69 @@ pub struct BakeTask {
}
impl BakeTask {
+ /// The maps this task makes, in the order [`BakeTask::run_streaming`] finishes them
+ pub fn maps(&self) -> Vec {
+ self.settings.maps.enabled().collect()
+ }
+
+ /// Bake the maps one after another, handing each one to `on_map` as soon as it is padded,
+ /// and return all of them together. Each map is a bake of its own, so with a high poly
+ /// the transfer rays are cast once per map: slower than [`BakeTask::run`] with several
+ /// maps, in exchange for showing them as they land. The pixels are the same as `run`'s.
+ /// The handed-over buffers are the returned ones too (no copy is made), so a preview that
+ /// keeps them costs no second set of maps. A cancel or an error leaves the maps already
+ /// handed over whole.
+ pub fn run_streaming(&self, progress: &Progress, on_map: &mut dyn FnMut(StreamedMap)) -> Result {
+ let maps = self.maps();
+ let total = maps.len();
+ let mut combined: Option = None;
+
+ for (index, map) in maps.iter().copied().enumerate() {
+ let mut settings = self.settings.clone();
+ settings.maps.select([map]);
+ let mut output = self.run_with(&settings, progress)?;
+ let Some(data) = output.maps.remove(&map) else { continue };
+ if combined.is_none() {
+ // Retain unchecked maps once, using the full selection rather than this one-map pass.
+ super::preserve_tiles::restore_unchecked(&mut output, &self.previous_maps, &self.excluded_tiles, &maps)?;
+ }
+
+ let data = Arc::new(data);
+ on_map(StreamedMap { map, index, total, resolution: output.resolution, height: output.height, data: data.clone() });
+ match &mut combined {
+ Some(combined) => {
+ combined.maps.insert(map, data);
+ }
+ None => {
+ // A resized partial bake also returns unchecked maps that must survive application
+ let mut retained: std::collections::BTreeMap<_, _> = output.maps.into_iter().map(|(map, pixels)| (map, Arc::new(pixels))).collect();
+ retained.insert(map, data);
+ combined = Some(StreamedBake { resolution: output.resolution, height: output.height, maps: retained, tracer: output.tracer });
+ }
+ }
+ }
+
+ match combined {
+ Some(output) => Ok(output),
+ None => {
+ let output = self.run(progress)?;
+ Ok(StreamedBake {
+ resolution: output.resolution,
+ height: output.height,
+ maps: output.maps.into_iter().map(|(map, pixels)| (map, Arc::new(pixels))).collect(),
+ tracer: output.tracer,
+ })
+ }
+ }
+ }
+
pub fn run(&self, progress: &Progress) -> Result {
+ let mut output = self.run_with(&self.settings, progress)?;
+ super::preserve_tiles::restore_unchecked(&mut output, &self.previous_maps, &self.excluded_tiles, &[])?;
+ Ok(output)
+ }
+
+ fn run_with(&self, settings: &BakeSettings, progress: &Progress) -> Result {
let high =
self.high.as_ref().map(|source| HighPoly { file_ids: &source.file_ids, mesh: &source.mesh, bvh: &source.bvh, base_color: &source.base_color });
let request = BakeRequest {
@@ -37,16 +99,118 @@ impl BakeTask {
mesh: &self.mesh,
bvh: &self.bvh,
material: self.material,
- settings: &self.settings,
+ settings,
high,
cage: self.cage.as_deref(),
skew: self.skew.as_deref(),
cage_paint: self.cage_paint.as_deref(),
tiles: self.tiles,
};
+
let mut output = bake_tiles(&request, progress, &self.excluded_tiles, self.tracer.as_deref())
.map_err(|error| EngineError::Other(format!("bake failed: {error}")))?;
super::preserve_tiles::restore(&mut output, &self.previous_maps, &self.excluded_tiles, self.tiles)?;
Ok(output)
}
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::{Session, execute};
+ use serde_json::json;
+ use texturecraft_geom::primitives;
+
+ const PREVIOUS_MAPS: [BakedMap; 3] = [BakedMap::Normal, BakedMap::AmbientOcclusion, BakedMap::Height];
+ const SELECTED_MAPS: [BakedMap; 2] = [BakedMap::AmbientOcclusion, BakedMap::Height];
+
+ fn partial_task(selected: &[BakedMap], resized: bool, excluded: bool) -> BakeTask {
+ let mut session = Session::new_project("Partial bake", primitives::udim_plane(), "builtin:udim_plane", None, 128).unwrap();
+ execute(&mut session, "bake.settings", &json!({"resolution": 64, "rays": 2})).unwrap();
+ if excluded {
+ execute(&mut session, "bake.tile.set", &json!({"tile": 1002, "enabled": false})).unwrap();
+ }
+ let mut task = session.bake_task(0).unwrap();
+ task.tracer = None;
+ task.settings.maps.select(selected.iter().copied());
+ let (width, height) = if resized { (64, 32) } else { (128, 64) };
+ task.previous_maps = BakedMaps {
+ resolution: width,
+ maps: PREVIOUS_MAPS.into_iter().map(|map| (map, Arc::new(vec![0.25; width as usize * height * map.components()]))).collect(),
+ };
+ task
+ }
+
+ #[test]
+ fn streaming_allocates_only_truly_unchecked_resized_maps_once() {
+ for (selected, resized, excluded) in [
+ (SELECTED_MAPS.as_slice(), true, true),
+ (PREVIOUS_MAPS.as_slice(), true, true),
+ (SELECTED_MAPS.as_slice(), false, true),
+ (SELECTED_MAPS.as_slice(), true, false),
+ ] {
+ let task = partial_task(selected, resized, excluded);
+ let whole = task.run(&Progress::new()).unwrap();
+ super::super::preserve_tiles::take_retained_allocations();
+ let mut allocations = Vec::new();
+ let mut handed_over = Vec::new();
+ let output = task
+ .run_streaming(&Progress::new(), &mut |map| {
+ allocations.extend(super::super::preserve_tiles::take_retained_allocations());
+ assert!(allocations.iter().all(|map| !selected.contains(map)), "maps scheduled to bake must never allocate retained buffers");
+ handed_over.push(map);
+ })
+ .unwrap();
+ allocations.extend(super::super::preserve_tiles::take_retained_allocations());
+ let expected: Vec<_> = PREVIOUS_MAPS.into_iter().filter(|map| resized && excluded && !selected.contains(map)).collect();
+ assert_eq!(allocations, expected, "each truly unchecked resized map must allocate exactly once");
+ assert_eq!(output.maps.keys().collect::>(), whole.maps.keys().collect::>());
+ for (map, pixels) in &whole.maps {
+ assert_eq!(*output.maps[map], *pixels, "{map:?} must preserve the ordinary bake's pixels");
+ }
+ for map in handed_over {
+ assert!(Arc::ptr_eq(&map.data, &output.maps[&map.map]), "streaming must keep sharing the baked buffer");
+ }
+ }
+ }
+
+ #[test]
+ fn cancelling_a_partial_stream_does_not_resample_future_maps() {
+ let task = partial_task(&SELECTED_MAPS, true, true);
+ let whole = task.run(&Progress::new()).unwrap();
+ super::super::preserve_tiles::take_retained_allocations();
+ let progress = Progress::new();
+ let mut handed_over = Vec::new();
+ let result = task.run_streaming(&progress, &mut |map| {
+ handed_over.push(map);
+ progress.cancel();
+ });
+ assert!(result.is_err());
+ assert_eq!(handed_over.len(), 1);
+ for map in handed_over {
+ assert_eq!(*map.data, whole.maps[&map.map], "cancellation leaves the handed-over map whole");
+ }
+ assert_eq!(super::super::preserve_tiles::take_retained_allocations(), [BakedMap::Normal]);
+ }
+
+ #[test]
+ fn an_empty_streaming_selection_keeps_the_ordinary_bake_behavior() {
+ let task = partial_task(&[], true, true);
+ super::super::preserve_tiles::take_retained_allocations();
+ let whole = task.run(&Progress::new());
+ let expected_allocations = super::super::preserve_tiles::take_retained_allocations();
+ let output = task.run_streaming(&Progress::new(), &mut |_| panic!("an empty selection must not stream a map"));
+ assert_eq!(super::super::preserve_tiles::take_retained_allocations(), expected_allocations);
+ match (whole, output) {
+ (Ok(whole), Ok(output)) => {
+ assert_eq!((output.resolution, output.height), (whole.resolution, whole.height));
+ assert_eq!(output.maps.keys().collect::>(), whole.maps.keys().collect::>());
+ for (map, pixels) in whole.maps {
+ assert_eq!(*output.maps[&map], pixels);
+ }
+ }
+ (Err(whole), Err(output)) => assert_eq!(whole.to_string(), output.to_string()),
+ _ => panic!("empty streaming and ordinary bakes must agree"),
+ }
+ }
+}
diff --git a/crates/engine/src/bake/high_poly_missed.rs b/crates/engine/src/bake/high_poly_missed.rs
new file mode 100644
index 00000000..21de6c05
--- /dev/null
+++ b/crates/engine/src/bake/high_poly_missed.rs
@@ -0,0 +1,23 @@
+use rayon::prelude::*;
+use texturecraft_bake::HighPolyReach;
+
+/// Per high-poly vertex: 1.0 if its owning set's bake misses it, otherwise 0.0
+/// Distances are each set's (max frontal, max rear); filtered or unavailable sets leave their vertices unmarked
+/// `vertex_count` is the validated high-poly mesh's vertex count
+pub fn high_poly_missed(reach: &[Option], distances: &[(f32, f32)], only_set: Option, vertex_count: usize) -> Vec {
+ // Ownership is already assigned by HighPolyReach; other sets must not color the vertex
+ let sets: Vec<(&HighPolyReach, f32, f32)> = reach
+ .iter()
+ .zip(distances)
+ .enumerate()
+ .filter(|(texture_set, _)| only_set.is_none_or(|only| only == *texture_set))
+ .filter_map(|(_, (reach, &(max_frontal, max_rear)))| Some((reach.as_ref()?, max_frontal, max_rear)))
+ .collect();
+ (0..vertex_count)
+ .into_par_iter()
+ .map(|vertex| {
+ let missed = sets.iter().find_map(|(reach, max_frontal, max_rear)| reach.missed(vertex, *max_frontal, *max_rear));
+ f32::from(u8::from(missed.unwrap_or(false)))
+ })
+ .collect()
+}
diff --git a/crates/engine/src/bake/mesh_map_command.rs b/crates/engine/src/bake/mesh_map_command.rs
index e5982f18..14248cc3 100644
--- a/crates/engine/src/bake/mesh_map_command.rs
+++ b/crates/engine/src/bake/mesh_map_command.rs
@@ -8,13 +8,15 @@ use std::collections::BTreeMap;
use std::sync::{Arc, OnceLock};
use texturecraft_core::BakePaintTarget;
-use crate::{BakeMesh, BakeTask};
+use super::{BakeCageInputs, MergedHigh};
+use crate::{BakeMesh, BakeTask, StreamedBake};
use serde_json::{Value, json};
use texturecraft_bake::tracing::Tracer;
use texturecraft_bake::{BakeOutput, BakePaintMap, MAX_RAYS, Progress};
use texturecraft_core::{
BackfaceMode, BakeAntialiasing, BakeResolution, BakeSettings, BakedMap, CurvatureMethod, PositionMode, RayDistribution, RaySettings, SelfOcclusion,
};
+use texturecraft_geom::Mesh;
use crate::commands::{CommandSpec, always, bad, boolp, f32p, strp, u64p};
use crate::{EngineError, Result, Session, cmd};
@@ -90,8 +92,8 @@ fn parse_mesh(file_name: &str, bytes: Vec) -> Result {
}
impl Session {
- pub fn bake_task(&self, ts: usize) -> Result {
- let set = self.doc.project.texture_set(ts)?;
+ pub fn bake_task(&self, texture_set: usize) -> Result {
+ let set = self.doc.project.texture_set(texture_set)?;
if !set.has_enabled_bake_tiles() {
return Err(EngineError::Other(format!("texture set {} has no UV tiles selected for baking", set.name)));
}
@@ -112,31 +114,22 @@ impl Session {
} else {
Arc::new(Vec::new())
};
- let high = if set.bake.high_poly.use_low_as_high { None } else { self.bake_meshes.merged.clone() };
- let cage = if high.is_some() && set.bake.cage.kind == texturecraft_core::CageType::CustomFile {
- Some(self.bake_meshes.cage.as_ref().ok_or_else(|| EngineError::Other("Custom File requires a cage mesh".into()))?.mesh.clone())
- } else {
- None
- };
- let painted = |target| high.as_ref().and(self.doc.bake_paint.get(&(ts, target))).map(|map| super::layout::paint_for_bake(map, set)).transpose();
- let skew = painted(BakePaintTarget::Skew)?;
- let cage_paint = painted(BakePaintTarget::Cage)?;
+
+ let high = self.bake_high(texture_set)?;
+ let cage = self.bake_cage(texture_set, high.is_some())?;
+ let skew = self.bake_paint(texture_set, high.is_some(), BakePaintTarget::Skew)?;
+ let cage_paint = self.bake_paint(texture_set, high.is_some(), BakePaintTarget::Cage)?;
+
let grid = set.tile_grid();
let tiles = grid.map_or((1, 1), |grid| (grid.cols, grid.rows));
let excluded_tiles: Vec<_> = set.uv_tiles.iter().filter(|tile| set.bake_excluded_tiles.contains(tile)).filter_map(|tile| grid?.block(*tile)).collect();
- let previous_maps = if excluded_tiles.is_empty() { Default::default() } else { self.doc.baked.get(&ts).cloned().unwrap_or_default() };
+ let previous_maps = if excluded_tiles.is_empty() { Default::default() } else { self.doc.baked.get(&texture_set).cloned().unwrap_or_default() };
+
let tracer = GPU_TRACER.get().cloned();
Ok(BakeTask {
low_base_color,
- ts,
- mesh: match grid.filter(|_| !set.tile_resolutions.is_empty()) {
- Some(grid) => {
- let mut mesh = (*self.source).clone();
- mesh.map_material_uvs(set.material, |uv| texturecraft_geom::glam::Vec2::from_array(grid.to_atlas(uv.to_array())));
- Arc::new(mesh)
- }
- None => self.mesh.clone(),
- },
+ ts: texture_set,
+ mesh: self.bake_mesh(texture_set)?,
bvh: self.bvh.clone(),
material: set.material,
settings: set.bake.clone(),
@@ -151,6 +144,61 @@ impl Session {
})
}
+ /// What texture set `texture_set`'s bake reads to place its transfer rays; `None` when the set bakes without a high poly or misses its cage file
+ pub fn bake_cage_inputs(&self, texture_set: usize) -> Result> {
+ let set = self.doc.project.texture_set(texture_set)?;
+ let Some(high) = self.bake_high(texture_set)? else { return Ok(None) };
+ let Ok(cage) = self.bake_cage(texture_set, true) else { return Ok(None) };
+
+ Ok(Some(BakeCageInputs {
+ mesh: self.bake_mesh(texture_set)?,
+ bvh: self.bvh.clone(),
+ material: set.material,
+ settings: set.bake.clone(),
+ high,
+ cage,
+ skew: self.bake_paint(texture_set, true, BakePaintTarget::Skew)?,
+ cage_paint: self.bake_paint(texture_set, true, BakePaintTarget::Cage)?,
+ }))
+ }
+
+ /// The merged high polys texture set `texture_set` bakes from, unless it bakes from the low poly
+ fn bake_high(&self, texture_set: usize) -> Result > {
+ let set = self.doc.project.texture_set(texture_set)?;
+ Ok(if set.bake.high_poly.use_low_as_high { None } else { self.bake_meshes.merged.clone() })
+ }
+
+ /// Texture set `texture_set`'s cage mesh when it bakes from a high poly with a Custom File cage
+ fn bake_cage(&self, texture_set: usize, has_high: bool) -> Result >> {
+ let set = self.doc.project.texture_set(texture_set)?;
+ if !has_high || set.bake.cage.kind != texturecraft_core::CageType::CustomFile {
+ return Ok(None);
+ }
+
+ let cage = self.bake_meshes.cage.as_ref().ok_or_else(|| EngineError::Other("Custom File requires a cage mesh".into()))?;
+ Ok(Some(cage.mesh.clone()))
+ }
+
+ /// Texture set `texture_set`'s painted skew or cage map, used only when it bakes from a high poly
+ fn bake_paint(&self, texture_set: usize, has_high: bool, target: BakePaintTarget) -> Result >> {
+ let set = self.doc.project.texture_set(texture_set)?;
+ let paint = self.doc.bake_paint.get(&(texture_set, target)).filter(|_| has_high);
+ paint.map(|map| super::layout::paint_for_bake(map, set)).transpose()
+ }
+
+ /// The low poly texture set `texture_set` bakes: UV tiles of mixed resolutions move into its atlas
+ fn bake_mesh(&self, texture_set: usize) -> Result> {
+ let set = self.doc.project.texture_set(texture_set)?;
+ Ok(match set.tile_grid().filter(|_| !set.tile_resolutions.is_empty()) {
+ Some(grid) => {
+ let mut mesh = (*self.source).clone();
+ mesh.map_material_uvs(set.material, |uv| texturecraft_geom::glam::Vec2::from_array(grid.to_atlas(uv.to_array())));
+ Arc::new(mesh)
+ }
+ None => self.mesh.clone(),
+ })
+ }
+
/// Store a finished bake as one undo step
pub fn apply_bake(&mut self, texture_set: usize, output: BakeOutput) -> Result<()> {
let tracer = output.tracer.clone();
@@ -159,15 +207,28 @@ impl Session {
Ok(())
}
+ /// Apply a streamed bake like [`Session::apply_bake`], keeping the maps' shared buffers (the
+ /// preview that showed them holds the same ones)
+ pub fn apply_streamed_bake(&mut self, texture_set: usize, output: StreamedBake) -> Result<()> {
+ let tracer = output.tracer.clone();
+ self.edit("Bake mesh maps", |session| session.store_bake_maps(texture_set, output.resolution, output.height, output.maps))?;
+ self.log.push(format!("Baked texture set {texture_set} ({tracer})"));
+ Ok(())
+ }
+
fn store_bake(&mut self, texture_set: usize, output: BakeOutput) -> Result<()> {
+ let maps = output.maps.into_iter().map(|(map, pixels)| (map, Arc::new(pixels))).collect();
+ self.store_bake_maps(texture_set, output.resolution, output.height, maps)
+ }
+
+ fn store_bake_maps(&mut self, texture_set: usize, resolution: u32, height: u32, maps: std::collections::BTreeMap>>) -> Result<()> {
let entry = self.doc.baked.entry(texture_set).or_default();
- if entry.resolution != output.resolution || entry.maps.keys().any(|map| entry.height(*map) != output.height) {
+ if entry.resolution != resolution || entry.maps.keys().any(|map| entry.height(*map) != height) {
entry.maps.clear();
}
- entry.resolution = output.resolution;
- for (map, pixels) in output.maps {
- entry.maps.insert(map, Arc::new(pixels));
- }
+
+ entry.resolution = resolution;
+ entry.maps.extend(maps);
self.doc.project.texture_set_mut(texture_set)?.baked = entry.maps.keys().copied().collect();
Ok(())
}
diff --git a/crates/engine/src/bake/mod.rs b/crates/engine/src/bake/mod.rs
index 213e1ff6..f06ab265 100644
--- a/crates/engine/src/bake/mod.rs
+++ b/crates/engine/src/bake/mod.rs
@@ -1,22 +1,30 @@
//! Baking tasks, commands, settings helpers, and the mesh-map baking API
+mod bake_cage_inputs;
mod bake_mesh;
mod bake_meshes;
mod bake_task;
+mod high_poly_missed;
mod layout;
mod merged_high;
mod mesh_map_command;
mod model_patch;
mod paint_command;
mod preserve_tiles;
+mod streamed_bake;
+mod streamed_map;
mod tile_command;
+pub use bake_cage_inputs::BakeCageInputs;
pub use bake_mesh::BakeMesh;
pub use bake_meshes::BakeMeshes;
pub use bake_task::BakeTask;
+pub use high_poly_missed::high_poly_missed;
pub use merged_high::MergedHigh;
pub use mesh_map_command::{install_gpu_tracer, meshes_json, settings_params};
pub use model_patch::settings_patch;
+pub use streamed_bake::StreamedBake;
+pub use streamed_map::StreamedMap;
pub use texturecraft_bake::*;
use crate::CommandSpec;
diff --git a/crates/engine/src/bake/preserve_tiles.rs b/crates/engine/src/bake/preserve_tiles.rs
index 27c74ae8..f44a09a4 100644
--- a/crates/engine/src/bake/preserve_tiles.rs
+++ b/crates/engine/src/bake/preserve_tiles.rs
@@ -1,5 +1,6 @@
use texturecraft_bake::BakeOutput;
use texturecraft_compose::BakedMaps;
+use texturecraft_core::BakedMap;
use crate::{EngineError, Result};
@@ -29,9 +30,18 @@ pub(super) fn restore(output: &mut BakeOutput, previous: &BakedMaps, excluded_ti
}
}
- // Keep unchecked map outputs too when a partial bake changes the atlas dimensions
+ Ok(())
+}
+
+/// Retain only maps outside the full task selection, once per completed atlas.
+/// A one-map streaming pass must not resample maps that are still scheduled to bake.
+pub(super) fn restore_unchecked(output: &mut BakeOutput, previous: &BakedMaps, excluded_tiles: &[(u32, u32)], selected: &[BakedMap]) -> Result<()> {
+ if excluded_tiles.is_empty() {
+ return Ok(());
+ }
+ let size = (output.resolution, output.height);
for map in previous.maps.keys() {
- if output.maps.contains_key(map) || (previous.resolution == size.0 && previous.height(*map) == size.1) {
+ if selected.contains(map) || output.maps.contains_key(map) || (previous.resolution == size.0 && previous.height(*map) == size.1) {
continue;
}
@@ -42,6 +52,8 @@ pub(super) fn restore(output: &mut BakeOutput, previous: &BakedMaps, excluded_ti
.ok_or_else(|| EngineError::Other("resized bake map exceeds the addressable size".into()))?;
let mut pixels = Vec::new();
pixels.try_reserve_exact(count).map_err(|error| EngineError::Other(format!("cannot retain mesh map {}: {error}", map.id())))?;
+ #[cfg(test)]
+ RETAINED_ALLOCATIONS.with(|allocations| allocations.borrow_mut().push(*map));
for y in 0..size.1 {
for x in 0..size.0 {
let value = previous.sample(*map, x, y, size).unwrap_or_else(|| map.neutral());
@@ -52,3 +64,15 @@ pub(super) fn restore(output: &mut BakeOutput, previous: &BakedMaps, excluded_ti
}
Ok(())
}
+
+// Restoration is sequential on the calling thread. Record successful retained-buffer allocations
+// only in unit tests, without a global allocator or interference from parallel test threads.
+#[cfg(test)]
+std::thread_local! {
+ static RETAINED_ALLOCATIONS: std::cell::RefCell> = const { std::cell::RefCell::new(Vec::new()) };
+}
+
+#[cfg(test)]
+pub(super) fn take_retained_allocations() -> Vec {
+ RETAINED_ALLOCATIONS.with(|allocations| std::mem::take(&mut *allocations.borrow_mut()))
+}
diff --git a/crates/engine/src/bake/streamed_bake.rs b/crates/engine/src/bake/streamed_bake.rs
new file mode 100644
index 00000000..55aecbca
--- /dev/null
+++ b/crates/engine/src/bake/streamed_bake.rs
@@ -0,0 +1,14 @@
+use std::collections::BTreeMap;
+use std::sync::Arc;
+
+use texturecraft_core::BakedMap;
+
+/// The result of a streamed bake: the finished maps stay shared (`Arc`) with whoever was shown them,
+/// so the preview and the document hold one buffer per map, never two
+#[derive(Clone, Debug)]
+pub struct StreamedBake {
+ pub resolution: u32,
+ pub height: u32,
+ pub maps: BTreeMap>>,
+ pub tracer: String,
+}
diff --git a/crates/engine/src/bake/streamed_map.rs b/crates/engine/src/bake/streamed_map.rs
new file mode 100644
index 00000000..33781099
--- /dev/null
+++ b/crates/engine/src/bake/streamed_map.rs
@@ -0,0 +1,17 @@
+use std::sync::Arc;
+
+use texturecraft_core::BakedMap;
+
+/// One finished map of a streamed bake (see [`crate::BakeTask::run_streaming`]).
+#[derive(Clone, Debug)]
+pub struct StreamedMap {
+ pub map: BakedMap,
+ /// Position among the maps this bake makes, from 0, and how many there are.
+ pub index: usize,
+ pub total: usize,
+ /// Width and height in texels.
+ pub resolution: u32,
+ pub height: u32,
+ /// Row-major, `map.components()` floats per texel, padded.
+ pub data: Arc>,
+}
diff --git a/crates/engine/src/bake_preview.rs b/crates/engine/src/bake_preview.rs
new file mode 100644
index 00000000..878fb276
--- /dev/null
+++ b/crates/engine/src/bake_preview.rs
@@ -0,0 +1,236 @@
+//! Live bake preview: while the app bakes, the 3D view shows each mesh map on the model as soon
+//! as it is finished ([`crate::BakeTask::run_streaming`]). The streamed maps live here, not in
+//! the document: nothing enters the undo history until a texture set's bake is applied
+//! ([`Session::apply_streamed_bake`]). Cancellation leaves the current set unchanged; sets already
+//! applied keep their results and undo steps. The preview shows one map at a time, raw on the
+//! model; maps and texture sets not baked yet show their neutral value.
+
+mod preview_set;
+mod preview_show;
+mod stage;
+
+pub use preview_set::PreviewSet;
+pub use preview_show::PreviewShow;
+pub use stage::Stage;
+
+use std::collections::BTreeMap;
+
+use serde_json::{Value, json};
+use texturecraft_compose::BakedMaps;
+use texturecraft_core::BakedMap;
+
+use crate::bake::StreamedMap;
+use crate::commands::{CommandSpec, always, bad, strp};
+use crate::session::ViewMode;
+use crate::{Result, Session, cmd};
+
+/// What painting says while a bake preview shows (the app translates it).
+pub const PAINTING_PAUSED: &str = "Painting is paused while a bake is shown. Cancel the bake or wait for it to finish.";
+
+pub fn specs() -> Vec {
+ vec![cmd!(
+ "bake.preview",
+ "Bake preview",
+ [],
+ None,
+ "{show?: \"follow\" (the newest finished map) | \"material\" | \"map:\" (pin a map)} → {active, show, shown, newest, stage, sets}. While the app bakes, the 3D view shows the maps as they finish; `show` picks what it shows. With no bake running {active: false} (setting `show` is then an error)",
+ always,
+ preview
+ )]
+}
+
+#[derive(Clone, Debug)]
+pub struct BakePreview {
+ /// The view mode to put back when the preview ends.
+ pub restore: ViewMode,
+ pub show: PreviewShow,
+ pub sets: BTreeMap,
+ /// The texture set being baked.
+ pub current: Option,
+ /// The last map that finished.
+ pub newest: Option,
+}
+
+impl BakePreview {
+ /// The map the view shows, None for the material.
+ pub fn shown(&self) -> Option {
+ match self.show {
+ PreviewShow::Material => None,
+ PreviewShow::Pin(map) => Some(map),
+ PreviewShow::Follow => self
+ .newest
+ .or_else(|| self.current_set().and_then(|set| set.order.first().copied()))
+ .or_else(|| self.sets.values().find_map(|set| set.order.first().copied())),
+ }
+ }
+
+ pub fn current_set(&self) -> Option<&PreviewSet> {
+ self.sets.get(&self.current?)
+ }
+
+ /// The map being baked now (None between sets and once the set's maps are all in).
+ pub fn stage(&self) -> Option {
+ let texture_set = self.current?;
+ let set = self.sets.get(&texture_set)?;
+ let done = set.baked.maps.len();
+ Some(Stage { texture_set, map: *set.order.get(done)?, position: done + 1, total: set.order.len() })
+ }
+}
+
+impl Session {
+ /// Start a preview from each selected texture set's enabled maps, in the same order as
+ /// [`crate::BakeTask::maps`]. Invalid indices return the project's texture-set error before
+ /// changing the preview or view mode. This reads settings without preparing bake geometry.
+ pub fn bake_preview_begin_for(&mut self, sets: &[usize]) -> Result<()> {
+ let orders = sets
+ .iter()
+ .map(|&texture_set| {
+ let set = self.doc.project.texture_set(texture_set)?;
+ Ok((texture_set, set.bake.maps.enabled().collect()))
+ })
+ .collect::>>()?;
+
+ self.bake_preview_begin(orders);
+ Ok(())
+ }
+
+ /// Start showing a bake of `sets` (each with the maps it makes, in order): the 3D view
+ /// follows the newest map and every set shows neutral values until its maps arrive. The
+ /// view mode in use comes back with [`Session::bake_preview_end`]. An active stroke is
+ /// discarded so a later pointer release cannot commit paint during the preview.
+ pub fn bake_preview_begin(&mut self, sets: Vec<(usize, Vec)>) {
+ self.cancel_stroke();
+
+ let restore = self.bake_preview.as_ref().map_or(self.view, |preview| preview.restore);
+ let sets = sets.into_iter().map(|(texture_set, order)| (texture_set, PreviewSet { baked: BakedMaps::default(), order })).collect();
+
+ self.bake_preview = Some(BakePreview { restore, show: PreviewShow::Follow, sets, current: None, newest: None });
+ self.bake_preview_refresh();
+ }
+
+ /// The texture set whose maps stream in now.
+ pub fn bake_preview_set_current(&mut self, texture_set: usize) {
+ if let Some(preview) = &mut self.bake_preview {
+ preview.current = Some(texture_set);
+ }
+
+ self.bake_preview_refresh();
+ }
+
+ /// Install one finished map of set `texture_set`. Returns false when no preview shows.
+ pub fn bake_preview_map(&mut self, texture_set: usize, streamed: StreamedMap) -> bool {
+ let Some(preview) = &mut self.bake_preview else { return false };
+
+ let set = preview.sets.entry(texture_set).or_default();
+
+ // A new bake of the set starts from nothing (the baker never repeats a map)
+ if streamed.index == 0 {
+ set.baked = BakedMaps::default();
+ }
+
+ set.baked.resolution = streamed.resolution;
+ set.baked.maps.insert(streamed.map, streamed.data);
+ preview.newest = Some(streamed.map);
+ self.bake_preview_refresh();
+ true
+ }
+
+ /// Choose what the view shows (Follow, a pinned map or the material).
+ pub fn bake_preview_show(&mut self, show: PreviewShow) -> Result<()> {
+ let Some(preview) = &mut self.bake_preview else { return Err(bad("bake.preview", "no bake is running")) };
+
+ preview.show = show;
+ self.bake_preview_refresh();
+ Ok(())
+ }
+
+ /// The user picked a view mode during a bake: a mesh map pins it, any other mode shows
+ /// the material and is what comes back when the bake ends.
+ pub(crate) fn bake_preview_user_view(&mut self, view: ViewMode) {
+ let Some(preview) = &mut self.bake_preview else { return };
+
+ match view {
+ ViewMode::MeshMap(map) => preview.show = PreviewShow::Pin(map),
+ other => {
+ preview.show = PreviewShow::Material;
+ preview.restore = other;
+ }
+ }
+
+ self.bake_preview_refresh();
+ if !matches!(view, ViewMode::MeshMap(_)) {
+ self.view = view;
+ }
+ }
+
+ /// Drop the displayed maps and restore the previous view mode. This does not stop a
+ /// worker or undo any applied results; the UI also uses it when leaving Bake mode.
+ pub fn bake_preview_end(&mut self) {
+ if let Some(preview) = self.bake_preview.take() {
+ self.view = preview.restore;
+ self.revision = self.revision.wrapping_add(1);
+ }
+ }
+
+ pub fn bake_preview_active(&self) -> bool {
+ self.bake_preview.is_some()
+ }
+
+ /// The streamed maps of set `texture_set` while a preview shows (empty for a set not baked
+ /// yet: neutral values), None when the document's baked maps are what shows.
+ pub fn bake_preview_baked(&self, texture_set: usize) -> Option<&BakedMaps> {
+ self.bake_preview.as_ref()?.sets.get(&texture_set).map(|set| &set.baked)
+ }
+
+ /// Why painting is not possible now, when a bake preview shows.
+ pub fn painting_blocked(&self) -> Option<&'static str> {
+ self.bake_preview.as_ref().map(|_| PAINTING_PAUSED)
+ }
+
+ fn bake_preview_refresh(&mut self) {
+ let Some(preview) = &self.bake_preview else { return };
+
+ self.view = match preview.shown() {
+ Some(map) => ViewMode::MeshMap(map),
+ None => ViewMode::Material,
+ };
+ self.revision = self.revision.wrapping_add(1);
+ }
+}
+
+/// The preview as JSON, for `bake.preview`, `session.inspect` and `ui.inspect`.
+pub fn preview_json(session: &Session) -> Value {
+ let Some(preview) = &session.bake_preview else { return json!({ "active": false }) };
+
+ let stage = preview.stage().map(|stage| json!({ "set": stage.texture_set, "map": stage.map.id(), "n": stage.position, "total": stage.total }));
+ let sets: Vec = preview
+ .sets
+ .iter()
+ .map(|(texture_set, set)| {
+ json!({
+ "set": texture_set,
+ "order": set.order.iter().map(|map| map.id()).collect::>(),
+ "done": set.baked.maps.keys().map(|map| map.id()).collect::>(),
+ })
+ })
+ .collect();
+
+ json!({
+ "active": true,
+ "show": preview.show.id(),
+ "shown": preview.shown().map(|map| map.id()),
+ "newest": preview.newest.map(|map| map.id()),
+ "restore": preview.restore.label(),
+ "stage": stage,
+ "sets": sets,
+ })
+}
+
+fn preview(session: &mut Session, params: &Value) -> Result {
+ if let Some(show) = strp(params, "show") {
+ let show = PreviewShow::parse(show).ok_or_else(|| bad("bake.preview", format!("unknown `show` {show:?}: follow, material or map:")))?;
+ session.bake_preview_show(show)?;
+ }
+
+ Ok(preview_json(session))
+}
diff --git a/crates/engine/src/bake_preview/preview_set.rs b/crates/engine/src/bake_preview/preview_set.rs
new file mode 100644
index 00000000..e1eabef8
--- /dev/null
+++ b/crates/engine/src/bake_preview/preview_set.rs
@@ -0,0 +1,10 @@
+use texturecraft_compose::BakedMaps;
+use texturecraft_core::BakedMap;
+
+/// The maps of one texture set streamed so far.
+#[derive(Clone, Debug, Default)]
+pub struct PreviewSet {
+ pub baked: BakedMaps,
+ /// The maps this set's bake makes, in the order they arrive.
+ pub order: Vec,
+}
diff --git a/crates/engine/src/bake_preview/preview_show.rs b/crates/engine/src/bake_preview/preview_show.rs
new file mode 100644
index 00000000..28a13614
--- /dev/null
+++ b/crates/engine/src/bake_preview/preview_show.rs
@@ -0,0 +1,30 @@
+use texturecraft_core::BakedMap;
+
+/// What the 3D view shows while a bake runs.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum PreviewShow {
+ /// The newest finished map (the first one, still neutral, before any is done).
+ Follow,
+ /// One map, pinned: neutral until it is baked.
+ Pin(BakedMap),
+ /// The lit material.
+ Material,
+}
+
+impl PreviewShow {
+ pub fn id(self) -> String {
+ match self {
+ PreviewShow::Follow => "follow".into(),
+ PreviewShow::Pin(map) => format!("map:{}", map.id()),
+ PreviewShow::Material => "material".into(),
+ }
+ }
+
+ pub fn parse(text: &str) -> Option {
+ match text {
+ "follow" => Some(PreviewShow::Follow),
+ "material" => Some(PreviewShow::Material),
+ _ => text.strip_prefix("map:").and_then(BakedMap::parse).map(PreviewShow::Pin),
+ }
+ }
+}
diff --git a/crates/engine/src/bake_preview/stage.rs b/crates/engine/src/bake_preview/stage.rs
new file mode 100644
index 00000000..d1513ae2
--- /dev/null
+++ b/crates/engine/src/bake_preview/stage.rs
@@ -0,0 +1,11 @@
+use texturecraft_core::BakedMap;
+
+/// The map a bake is working on.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Stage {
+ pub texture_set: usize,
+ pub map: BakedMap,
+ /// 1-based position among the set's maps, and how many there are.
+ pub position: usize,
+ pub total: usize,
+}
diff --git a/crates/engine/src/color_selection_cmds.rs b/crates/engine/src/color_selection_cmds.rs
new file mode 100644
index 00000000..2b9f9eaf
--- /dev/null
+++ b/crates/engine/src/color_selection_cmds.rs
@@ -0,0 +1,160 @@
+//! Color selection effects: the ID colors they select, picked from the ID mesh map
+
+use serde_json::{Value, json};
+use texturecraft_core::{BakedMap, EffectKind, LayerId};
+use texturecraft_geom::glam::Vec2;
+use texturecraft_geom::surface_at;
+
+use crate::commands::{CommandSpec, bad, f32p, has_layer};
+use crate::mask_cmds::effect_id;
+use crate::tool_cmds::viewport_of;
+use crate::{Result, Session, cmd};
+
+/// Most colors one color selection holds; an ID map rarely has more distinct parts
+const MAX_SELECTED_COLORS: usize = 256;
+
+pub fn specs() -> Vec {
+ vec![cmd!(
+ "effect.colorSelection.pick",
+ "Pick ID color",
+ [],
+ None,
+ "{effect?: a color selection (default: the selected effect), x?, y?: viewport pixels, viewport?: [w,h] | uv?: [u,v] texture set atlas UV (the 2D view), index?: replace this color instead of adding one} → {color: [r,g,b] as the ID map stores it, index} — samples the ID mesh map under the point",
+ has_layer,
+ pick
+ )]
+}
+
+/// Applies `effect.set`'s `colors` and `tolerance` params to a color selection
+pub(crate) fn apply_params(params: &Value, colors: &mut Vec<[f32; 3]>, tolerance: &mut f32) -> Result<()> {
+ if let Some(list) = params.get("colors") {
+ *colors = colors_param(list)?;
+ }
+ if let Some(value) = f32p(params, "tolerance") {
+ *tolerance = value.clamp(0.0, 1.0);
+ }
+ Ok(())
+}
+
+/// A non-empty `[[r, g, b], ...]` list of finite values, clamped to 0..1
+fn colors_param(list: &Value) -> Result> {
+ const CMD: &str = "effect.set";
+ let items = list.as_array().ok_or_else(|| bad(CMD, "`colors` must be a list of [r, g, b]"))?;
+ if items.is_empty() || items.len() > MAX_SELECTED_COLORS {
+ return Err(bad(CMD, format!("`colors` needs 1 to {MAX_SELECTED_COLORS} colors")));
+ }
+
+ items
+ .iter()
+ .map(|item| match finite_numbers::<3>(item) {
+ Some(color) => Ok(color.map(|value| value.clamp(0.0, 1.0) as f32)),
+ _ => Err(bad(CMD, "each color must be [r, g, b] with finite numbers")),
+ })
+ .collect()
+}
+
+/// Samples the ID map under a viewport point or at a UV and adds the color to a color selection
+fn pick(session: &mut Session, params: &Value) -> Result {
+ const CMD: &str = "effect.colorSelection.pick";
+ let effect = effect_id(session, params, CMD)?;
+ let (owner, color_count) = match session.doc.project.effect(effect) {
+ Some((owner, found)) => match &found.kind {
+ EffectKind::ColorSelection { colors, .. } => (owner, colors.len()),
+ other => return Err(bad(CMD, format!("{} is not a color selection", other.name()))),
+ },
+ None => return Err(bad(CMD, format!("no effect {}", effect.0))),
+ };
+
+ let index = params
+ .get("index")
+ .filter(|index| !index.is_null())
+ .map(|index| index.as_u64().ok_or_else(|| bad(CMD, "`index` must be a non-negative integer")))
+ .transpose()?;
+ let index = match index {
+ Some(index) => Some(usize::try_from(index).ok().filter(|index| *index < color_count).ok_or_else(|| bad(CMD, format!("no color {index} to replace")))?),
+ None if color_count >= MAX_SELECTED_COLORS => return Err(bad(CMD, format!("a color selection holds at most {MAX_SELECTED_COLORS} colors"))),
+ None => None,
+ };
+
+ let color = id_color_at(session, params, owner)?;
+ session.edit("Pick ID color", |session| {
+ let edited = session.doc.project.effect_mut(effect).ok_or_else(|| bad(CMD, format!("no effect {}", effect.0)))?;
+ if let EffectKind::ColorSelection { colors, .. } = &mut edited.kind {
+ match index.and_then(|index| colors.get_mut(index)) {
+ Some(slot) => *slot = color,
+ None => colors.push(color),
+ }
+ }
+ Ok(())
+ })?;
+ Ok(json!({ "color": color, "index": index.unwrap_or(color_count) }))
+}
+
+/// The ID map color of the texel a color selection on `owner` reads at the picked point
+fn id_color_at(session: &Session, params: &Value, owner: LayerId) -> Result<[f32; 3]> {
+ const CMD: &str = "effect.colorSelection.pick";
+ let (set_index, _, _) = session.doc.project.locate(owner).ok_or_else(|| bad(CMD, "the effect's layer is not in a texture set"))?;
+ let set = session.doc.project.texture_set(set_index)?;
+ let baked = session.baked(set_index).filter(|baked| baked.maps.contains_key(&BakedMap::Id));
+ let Some(baked) = baked else {
+ return Err(bad(CMD, format!("texture set \"{}\" has no ID map: bake one, or set one with textureSet.meshMap.set", set.name)));
+ };
+
+ let uv = match params.get("uv") {
+ Some(uv) => uv_param(uv)?,
+ None => {
+ let (Some(x), Some(y)) = (f32p(params, "x"), f32p(params, "y")) else {
+ return Err(bad(CMD, "give `x` and `y` (viewport pixels) or `uv`"));
+ };
+
+ let (uv, material) = visible_surface(session, Vec2::new(x, y), viewport_of(session, params))
+ .ok_or_else(|| bad(CMD, "nothing under that point: pick on the mesh"))?;
+ if material != set.material {
+ return Err(bad(CMD, "that surface belongs to another texture set"));
+ }
+ uv
+ }
+ };
+
+ // The same texel the mask evaluates, so a picked color always selects where it was picked
+ let size = set.size();
+ let texel = [uv.x * size.0 as f32, uv.y * size.1 as f32];
+ if !texel.iter().zip([size.0, size.1]).all(|(position, extent)| (0.0..extent as f32).contains(position)) {
+ return Err(bad(CMD, "that point is outside the texture set's UV space"));
+ }
+ baked.sample_working(BakedMap::Id, texel[0] as u32, texel[1] as u32, size, &set.block_scales()).ok_or_else(|| bad(CMD, "no ID color there"))
+}
+
+/// The UV and mesh material under viewport pixel `screen`; hidden texture sets don't stop the ray
+fn visible_surface(session: &Session, screen: Vec2, viewport: Vec2) -> Option<(Vec2, usize)> {
+ let viewport = viewport.max(Vec2::ONE);
+ let device = Vec2::new(screen.x / viewport.x * 2.0 - 1.0, 1.0 - screen.y / viewport.y * 2.0);
+ let ray = session.camera.ray(device, viewport.x / viewport.y);
+ let sets = &session.doc.project.texture_sets;
+ let visible = |triangle: u32| {
+ let material = session.mesh.material_of(triangle as usize).unwrap_or(0);
+ sets.iter().find(|set| set.material == material).is_none_or(|set| set.visible)
+ };
+
+ let hit = session.bvh.closest_filtered(ray.origin, ray.dir, f32::MAX, &visible)?;
+ let surface = surface_at(&session.mesh, hit.tri, hit.u, hit.v)?;
+ Some((surface.uv, session.mesh.material_of(hit.tri as usize).unwrap_or(0)))
+}
+
+/// A `[u, v]` param of finite numbers
+fn uv_param(uv: &Value) -> Result {
+ match finite_numbers::<2>(uv) {
+ Some([u, v]) => Ok(Vec2::new(u as f32, v as f32)),
+ _ => Err(bad("effect.colorSelection.pick", "`uv` must be [u, v] with finite numbers")),
+ }
+}
+
+/// Validate the shape before reading components, without allocating for oversized input
+fn finite_numbers(list: &Value) -> Option<[f64; N]> {
+ let items: &[Value; N] = list.as_array()?.as_slice().try_into().ok()?;
+ let mut numbers = [0.0; N];
+ for (number, item) in numbers.iter_mut().zip(items) {
+ *number = item.as_f64().filter(|value| value.is_finite())?;
+ }
+ Some(numbers)
+}
diff --git a/crates/engine/src/commands.rs b/crates/engine/src/commands.rs
index 9f0d126b..072f4071 100644
--- a/crates/engine/src/commands.rs
+++ b/crates/engine/src/commands.rs
@@ -56,6 +56,7 @@ pub fn command_specs() -> &'static [CommandSpec] {
v.extend(crate::layer_ops::specs());
v.extend(crate::instance_cmds::specs());
v.extend(crate::mask_cmds::specs());
+ v.extend(crate::color_selection_cmds::specs());
v.extend(crate::effect_clipboard::specs());
v.extend(crate::tool_cmds::specs());
v.extend(crate::brush_preset_cmds::specs());
@@ -65,10 +66,12 @@ pub fn command_specs() -> &'static [CommandSpec] {
v.extend(crate::quick_mask::specs());
v.extend(crate::set_cmds::specs());
v.extend(crate::meshmap_cmds::specs());
+ v.extend(crate::meshmap_import_cmds::specs());
v.extend(crate::uv_tile_cmds::specs());
v.extend(crate::template_cmds::specs());
v.extend(crate::project_cmds::specs());
v.extend(crate::bake::specs());
+ v.extend(crate::bake_preview::specs());
v.extend(crate::materialx_cmds::specs());
v.extend(crate::file_cmds::specs());
v.extend(crate::preset_cmds::specs());
diff --git a/crates/engine/src/decal_cmds.rs b/crates/engine/src/decal_cmds.rs
index e937b6f5..d929c808 100644
--- a/crates/engine/src/decal_cmds.rs
+++ b/crates/engine/src/decal_cmds.rs
@@ -2,12 +2,12 @@
//! (a decal fill with a planar projection), as a fill layer with a decal projection.
use serde_json::{Value, json};
-use texturecraft_core::{Channel, Decal, Fill, Layer, LayerId, LayerKind, Projection, Source};
+use texturecraft_core::{Channel, Decal, Effect, EffectKind, Fill, Layer, LayerId, LayerKind, Mask, MaskBackground, Projection, Source};
use texturecraft_geom::glam::{Vec2, Vec3};
-use crate::commands::{CommandSpec, always, bad, f32p, has_layer, layer_param, strp};
+use crate::commands::{CommandSpec, always, bad, channel_param, f32p, has_layer, layer_param, strp, u64p};
use crate::tool_cmds::viewport_of;
-use crate::{Result, Session, cmd};
+use crate::{Result, Session, StackTarget, cmd};
pub fn specs() -> Vec {
vec![
@@ -16,7 +16,7 @@ pub fn specs() -> Vec {
"Add decal",
[],
None,
- "{image: resource name, x?, y?: viewport pixels (default: the view center), viewport?: [w,h] | position?: [x,y,z], normal?: [x,y,z], up?: [x,y,z] (the image's up; default the view's up, or the view direction when that is along the normal), size?: height | [w,h] (world units; default a quarter of the mesh), rotation?: degrees, depth?, name?} — a fill layer projecting the image from a frame placed on the surface; seen from the front, the image reads the right way round",
+ "{image: resource name, channel?: a channel id (default baseColor) | \"mask\" (a new fill layer masked by the image's gray), x?, y?: viewport pixels (default: the view center; a point on another texture set selects it), viewport?: [w,h] | position?: [x,y,z], normal?: [x,y,z] (on the selected texture set), up?: [x,y,z] (the image's up; default the view's up, or the view direction when that is along the normal), size?: height | [w,h] (world units; default a quarter of the mesh), rotation?: degrees, depth?, name?} → {layer, decal, maskEffect: the mask fill effect holding the image with channel \"mask\", else null} — a fill layer projecting the image from a frame placed on the surface; seen from the front, the image reads the right way round",
always,
add
),
@@ -25,7 +25,7 @@ pub fn specs() -> Vec {
"Edit decal",
[],
None,
- "{layer?, x?, y?, viewport? | position?, normal? (re-place it), up?: [x,y,z], size?: height | [w,h], rotation?: degrees, offset?: [right, up] (world units from where it was placed), depth?, image?, merge?: true continues the previous Edit decal undo step (drags)}",
+ "{layer? | effect?: a mask fill effect id (a decal placed as a mask; with `layer`, it must be in that layer), x?, y?, viewport? | position?, normal? (re-place it on its own texture set), up?: [x,y,z], size?: height | [w,h], rotation?: degrees, offset?: [right, up] (world units from where it was placed), depth?, image?: replaces the image in the channel or mask it was placed in, merge?: true continues the previous Edit decal undo step (drags)}",
has_layer,
set
),
@@ -42,43 +42,51 @@ fn vec3(p: &Value, key: &str) -> Option {
}
}
-/// Where a decal goes: a surface point and its normal, from `x`/`y` (viewport pixels, the view
-/// center by default) or `position` + `normal`. None when `optional` and neither is given.
-fn placement(s: &Session, cmd: &str, p: &Value, optional: bool) -> Result> {
- if let Some(pos) = vec3(p, "position") {
- let n = vec3(p, "normal").and_then(Vec3::try_normalize).ok_or_else(|| bad(cmd, "`position` needs a non-zero `normal`"))?;
- return Ok(Some((pos, n)));
+/// Resolve a viewport hit or explicit world position, using `texture_set` for explicit positions.
+/// Returns None when placement is optional and no position or viewport point is given.
+fn placement(session: &Session, command: &str, params: &Value, texture_set: usize, optional: bool) -> Result > {
+ if let Some(position) = vec3(params, "position") {
+ let normal = vec3(params, "normal").and_then(Vec3::try_normalize).ok_or_else(|| bad(command, "`position` needs a non-zero `normal`"))?;
+ return Ok(Some((position, normal, texture_set)));
}
- let vp = viewport_of(s, p);
- let at = match (f32p(p, "x"), f32p(p, "y")) {
+
+ let viewport = viewport_of(session, params);
+ let point = match (f32p(params, "x"), f32p(params, "y")) {
(Some(x), Some(y)) => Vec2::new(x, y),
_ if optional => return Ok(None),
- _ => vp * 0.5,
+ _ => viewport * 0.5,
};
- let hit = s.pick(at, vp).ok_or_else(|| bad(cmd, "nothing under that point: place the decal on the mesh"))?;
- if s.doc.project.texture_set(s.ts()).ok().map(|t| t.material) != Some(hit.material) {
- return Err(bad(cmd, "that surface belongs to another texture set"));
- }
- Ok(Some((hit.pos, hit.nrm)))
+ let hit = session.pick(point, viewport).ok_or_else(|| bad(command, "nothing under that point: place the decal on the mesh"))?;
+ let hit_set = session.texture_set_of_material(hit.material).ok_or_else(|| bad(command, "that surface has no texture set"))?;
+ Ok(Some((hit.pos, hit.nrm, hit_set)))
}
+/// A new decal's height, relative to the mesh diagonal
+const DEFAULT_HEIGHT: f32 = 0.25;
+
+/// The smallest decal side or depth, relative to the mesh diagonal
+const MIN_SIZE: f32 = 1e-4;
+
+/// The largest decal side or depth, relative to the mesh diagonal
+const MAX_SIZE: f32 = 10.0;
+
/// The mesh's diagonal (decal sizes are relative to it).
fn mesh_size(s: &Session) -> f32 {
let (lo, hi) = s.mesh.bounds();
(hi - lo).length().max(1e-3)
}
-/// Width and height from a `size` param (a height keeping `aspect`, or `[w, h]`).
-fn size_param(p: &Value, aspect: f32, diag: f32) -> Option<[f32; 2]> {
- let v = p.get("size")?;
- let size = match v.as_array() {
- Some(a) => [a.first()?.as_f64()? as f32, a.get(1)?.as_f64()? as f32],
+/// Width and height from a `size` param (a height keeping `aspect`, or `[w, h]`), within the decal size limits
+fn size_param(p: &Value, aspect: f32, mesh_diagonal: f32) -> Option<[f32; 2]> {
+ let value = p.get("size")?;
+ let size = match value.as_array() {
+ Some(pair) => [pair.first()?.as_f64()? as f32, pair.get(1)?.as_f64()? as f32],
None => {
- let h = v.as_f64()? as f32;
- [h * aspect, h]
+ let height = value.as_f64()? as f32;
+ [height * aspect, height]
}
};
- size.iter().all(|x| x.is_finite()).then(|| size.map(|x| x.clamp(diag * 1e-4, diag * 10.0)))
+ size.iter().all(|side| side.is_finite()).then(|| size.map(|side| side.clamp(mesh_diagonal * MIN_SIZE, mesh_diagonal * MAX_SIZE)))
}
/// The decal's up direction: `up` when given, else the camera's (decals are placed upright on
@@ -96,11 +104,25 @@ fn decal_up(s: &Session, cmd: &str, p: &Value, normal: Vec3) -> Result {
fn add(s: &mut Session, p: &Value) -> Result {
let cmd = "layer.add.decal";
let image = strp(p, "image").ok_or_else(|| bad(cmd, "`image` is required"))?.to_string();
- let img = s.images.get(&image).ok_or_else(|| bad(cmd, format!("no image resource `{image}` (import it first)")))?;
- let aspect = img.width as f32 / img.height.max(1) as f32;
- let (center, normal) = placement(s, cmd, p, false)?.ok_or_else(|| bad(cmd, "no placement"))?;
- let diag = mesh_size(s);
- let size = size_param(p, aspect, diag).unwrap_or([diag * 0.25 * aspect, diag * 0.25]);
+ let resource = s.images.get(&image).ok_or_else(|| bad(cmd, format!("no image resource `{image}` (import it first)")))?;
+ let aspect = resource.width as f32 / resource.height.max(1) as f32;
+ let (center, normal, ts) = placement(s, cmd, p, s.ts(), false)?.ok_or_else(|| bad(cmd, "no placement"))?;
+
+ // None: the image masks a new fill layer
+ let target = match strp(p, "channel") {
+ Some("mask") => None,
+ _ => Some(channel_param(cmd, p, "channel")?.unwrap_or(Channel::BaseColor)),
+ };
+ let set_channels = s.doc.project.texture_set(ts)?.channel_list();
+ if let Some(channel) = target
+ && !set_channels.contains(&channel)
+ {
+ return Err(bad(cmd, format!("the texture set has no {} channel", channel.label())));
+ }
+
+ let mesh_diagonal = mesh_size(s);
+ let default_height = mesh_diagonal * DEFAULT_HEIGHT;
+ let size = size_param(p, aspect, mesh_diagonal).unwrap_or([default_height * aspect, default_height]);
let decal = Decal {
center: center.to_array(),
normal: normal.to_array(),
@@ -108,68 +130,139 @@ fn add(s: &mut Session, p: &Value) -> Result {
size,
rotation: f32p(p, "rotation").unwrap_or(0.0).rem_euclid(360.0),
offset: [0.0; 2],
- depth: f32p(p, "depth").map_or(size[0].max(size[1]) * 0.5, |d| d.clamp(diag * 1e-4, diag * 10.0)),
+ // By default it reaches half its larger side into the surface
+ depth: f32p(p, "depth").map_or(size[0].max(size[1]) * 0.5, |depth| depth.clamp(mesh_diagonal * MIN_SIZE, mesh_diagonal * MAX_SIZE)),
};
- let ts = s.ts();
- let base =
- strp(p, "name").map(str::to_string).unwrap_or_else(|| std::path::Path::new(&image).file_stem().and_then(|n| n.to_str()).unwrap_or("Decal").to_string());
+
+ // A decal dropped on another texture set goes there and selects it, as a dropped material does
+ if ts != s.ts() {
+ crate::set_cmds::select_set(s, ts)?;
+ }
+
+ let base = strp(p, "name")
+ .map(str::to_string)
+ .unwrap_or_else(|| std::path::Path::new(&image).file_stem().and_then(|stem| stem.to_str()).unwrap_or("Decal").to_string());
let name = s.doc.project.next_layer_name(ts, &base);
- let id = s.edit("Add decal", |s| {
+ let (id, mask_effect) = s.edit("Add decal", |s| {
let id = s.doc.project.alloc_id();
+ let Some(channel) = target else {
+ let effect_id = s.doc.project.alloc_id();
+ let mut layer = Layer::new(id, name, LayerKind::Fill(Fill::default()), &set_channels);
+ let mut mask = Mask::new(MaskBackground::Black);
+ mask.effects.push(Effect::new(effect_id, EffectKind::Fill { source: Source::image(image.clone()), projection: Projection::Decal(decal) }));
+ layer.mask = Some(mask);
+ crate::layer_cmds::insert_selected(s, layer)?;
+ s.target = StackTarget::Effect(effect_id);
+ return Ok((id, Some(effect_id)));
+ };
+
let mut fill = Fill { projection: Projection::Decal(decal), ..Fill::default() };
- fill.sources.insert(Channel::BaseColor, Source::image(image.clone()));
- crate::layer_cmds::insert_selected(s, Layer::new(id, name, LayerKind::Fill(fill), &[Channel::BaseColor]))
+ fill.sources.insert(channel, Source::image(image.clone()));
+ crate::layer_cmds::insert_selected(s, Layer::new(id, name, LayerKind::Fill(fill), &[channel]))?;
+ Ok((id, None))
})?;
- Ok(json!({ "layer": id.0, "decal": decal }))
+ Ok(json!({ "layer": id.0, "decal": decal, "maskEffect": mask_effect.map(|effect| effect.0) }))
}
-/// The decal of fill layer `id`.
-fn decal_of(s: &Session, cmd: &str, id: LayerId) -> Result {
+/// The decal of fill layer `id`, or of mask fill effect `effect` when given
+fn decal_of(s: &Session, cmd: &str, id: LayerId, effect: Option) -> Result {
+ if let Some(effect) = effect {
+ return match s.doc.project.effect(effect).map(|(_, effect)| &effect.kind) {
+ Some(EffectKind::Fill { projection: Projection::Decal(decal), .. }) => Ok(*decal),
+ _ => Err(bad(cmd, "the effect is not a decal (layer.add.decal with channel mask)")),
+ };
+ }
+
match &s.doc.project.layer(id)?.kind {
- LayerKind::Fill(Fill { projection: Projection::Decal(d), .. }) => Ok(*d),
+ LayerKind::Fill(Fill { projection: Projection::Decal(decal), .. }) => Ok(*decal),
_ => Err(bad(cmd, "the layer is not a decal (layer.add.decal)")),
}
}
-fn set(s: &mut Session, p: &Value) -> Result {
- let cmd = "layer.decal.set";
- let id = s.doc.project.content_layer(layer_param(s, cmd, p)?).map(|l| l.id).ok_or_else(|| bad(cmd, "no layer"))?;
- let mut d = decal_of(s, cmd, id)?;
- let diag = mesh_size(s);
- if let Some((center, normal)) = placement(s, cmd, p, true)? {
- (d.center, d.normal, d.offset) = (center.to_array(), normal.to_array(), [0.0; 2]);
- }
- if p.get("up").is_some() {
- d.up = decal_up(s, cmd, p, Vec3::from(d.normal))?.to_array();
- }
- if let Some(size) = size_param(p, d.size[0] / d.size[1].max(1e-6), diag) {
- d.size = size;
- }
- if let Some(r) = f32p(p, "rotation") {
- d.rotation = r.rem_euclid(360.0);
- }
- if let Some(o) = p.get("offset").and_then(Value::as_array) {
- let v: Vec = o.iter().filter_map(Value::as_f64).map(|x| x as f32).filter(|x| x.is_finite()).collect();
- let [x, y] = v.as_slice() else { return Err(bad(cmd, "`offset` must be [right, up]")) };
- d.offset = [x.clamp(-diag, diag), y.clamp(-diag, diag)];
- }
- if let Some(v) = f32p(p, "depth") {
- d.depth = v.clamp(diag * 1e-4, diag * 10.0);
- }
- let image = strp(p, "image").map(str::to_string);
- if let Some(name) = &image
- && !s.doc.resources.contains_key(name)
+fn set(session: &mut Session, params: &Value) -> Result {
+ let command = "layer.decal.set";
+ let effect = u64p(params, "effect").map(LayerId);
+ let layer_id = match effect {
+ Some(effect) => session.doc.project.effect(effect).map(|(owner, _)| owner).ok_or_else(|| bad(command, format!("no effect {}", effect.0)))?,
+ None => session.doc.project.content_layer(layer_param(session, command, params)?).map(|layer| layer.id).ok_or_else(|| bad(command, "no layer"))?,
+ };
+ if let (Some(effect), Some(layer)) = (effect, u64p(params, "layer"))
+ && layer != layer_id.0
{
- return Err(bad(cmd, format!("no image resource `{name}`")));
+ return Err(bad(command, format!("effect {} is not in layer {layer}", effect.0)));
}
- s.edit("Edit decal", |s| {
- if let LayerKind::Fill(f) = &mut s.doc.project.layer_mut(id)?.kind {
- f.projection = Projection::Decal(d);
- if let Some(name) = image {
- f.sources.insert(Channel::BaseColor, Source::image(name));
+
+ let mut decal = decal_of(session, command, layer_id, effect)?;
+ let texture_set =
+ session.doc.project.locate(layer_id).map(|(texture_set, _, _)| texture_set).ok_or_else(|| bad(command, "the decal has no texture set"))?;
+ let mesh_diagonal = mesh_size(session);
+ if let Some((center, normal, hit_set)) = placement(session, command, params, texture_set, true)? {
+ // Selecting another set must not let this decal leave its layer's stack
+ if hit_set != texture_set {
+ return Err(bad(command, "that surface belongs to another texture set"));
+ }
+
+ (decal.center, decal.normal, decal.offset) = (center.to_array(), normal.to_array(), [0.0; 2]);
+ }
+ if params.get("up").is_some() {
+ decal.up = decal_up(session, command, params, Vec3::from(decal.normal))?.to_array();
+ }
+ if let Some(size) = size_param(params, decal.size[0] / decal.size[1].max(1e-6), mesh_diagonal) {
+ decal.size = size;
+ }
+ if let Some(rotation) = f32p(params, "rotation") {
+ decal.rotation = rotation.rem_euclid(360.0);
+ }
+ if let Some(offset) = params.get("offset").and_then(Value::as_array) {
+ let values: Vec = offset.iter().filter_map(Value::as_f64).map(|value| value as f32).filter(|value| value.is_finite()).collect();
+ let [right, up] = values.as_slice() else { return Err(bad(command, "`offset` must be [right, up]")) };
+
+ decal.offset = [right.clamp(-mesh_diagonal, mesh_diagonal), up.clamp(-mesh_diagonal, mesh_diagonal)];
+ }
+ if let Some(depth) = f32p(params, "depth") {
+ decal.depth = depth.clamp(mesh_diagonal * MIN_SIZE, mesh_diagonal * MAX_SIZE);
+ }
+
+ let image = strp(params, "image").map(str::to_string);
+ if let Some(name) = &image
+ && !session.doc.resources.contains_key(name)
+ {
+ return Err(bad(command, format!("no image resource `{name}`")));
+ }
+
+ session.edit("Edit decal", |session| {
+ if let Some(effect) = effect {
+ if let Some(EffectKind::Fill { source, projection }) = session.doc.project.effect_mut(effect).map(|effect| &mut effect.kind) {
+ *projection = Projection::Decal(decal);
+ if let Some(image) = image {
+ *source = Source::image(image);
+ }
+ }
+ } else if let LayerKind::Fill(fill) = &mut session.doc.project.layer_mut(layer_id)?.kind {
+ fill.projection = Projection::Decal(decal);
+
+ // The new image goes where the decal's image is (the channel it was placed in)
+ let placed = fill.sources.values().find_map(|source| match source {
+ Source::Image { name, .. } => Some(name.clone()),
+ _ => None,
+ });
+ match (image, placed) {
+ (Some(image), Some(placed)) => {
+ for source in fill.sources.values_mut() {
+ if let Source::Image { name, .. } = source
+ && *name == placed
+ {
+ name.clone_from(&image);
+ }
+ }
+ }
+ (Some(image), None) => {
+ fill.sources.insert(Channel::BaseColor, Source::image(image));
+ }
+ (None, _) => {}
}
}
Ok(())
})?;
- Ok(json!({ "layer": id.0, "decal": d }))
+ Ok(json!({ "layer": layer_id.0, "decal": decal }))
}
diff --git a/crates/engine/src/file_cmds.rs b/crates/engine/src/file_cmds.rs
index f2b95e03..ae2f00b5 100644
--- a/crates/engine/src/file_cmds.rs
+++ b/crates/engine/src/file_cmds.rs
@@ -331,6 +331,11 @@ mod native {
strp(p, key).filter(|s| !s.trim().is_empty()).ok_or_else(|| bad(cmd, format!("`{key}` is required")))
}
+ /// `path` made absolute (as given when that fails), for [`Project::mesh_path`].
+ pub fn absolute(path: &str) -> String {
+ std::path::absolute(Path::new(path)).map_or_else(|_| path.to_string(), |p| p.display().to_string())
+ }
+
/// Mesh file `path` with the files it references next to it folded in (a `.gltf`'s buffers
/// and images, a loose USD layer's textures), ready to import and store in the project.
pub fn read_mesh(cmd: &str, path: &str) -> Result {
@@ -349,6 +354,7 @@ mod native {
} else {
let f = read_mesh("file.open", path)?;
let mut s = Session::from_mesh_bytes(&f.name, &f.bytes, 2048, &stem_of(path))?;
+ s.doc.project.mesh_path = absolute(path);
s.log.extend(f.warnings);
Ok(s)
}
@@ -367,8 +373,10 @@ mod native {
}
#[cfg(not(target_arch = "wasm32"))]
-pub use native::{open_path, read_mesh};
+pub use native::{absolute, open_path, read_mesh};
+/// `file.new {mesh, name?, resolution?, uvTiles?, template?}`: a new project from the mesh file `mesh`,
+/// remembering its path for Reimport mesh.
#[cfg(not(target_arch = "wasm32"))]
fn new_from_mesh(s: &mut Session, p: &Value) -> Result {
let path = native::path_param(p, "mesh", "file.new")?;
@@ -377,6 +385,7 @@ fn new_from_mesh(s: &mut Session, p: &Value) -> Result {
let res = u64p(p, "resolution").or(template.as_ref().map(|t| u64::from(t.resolution))).unwrap_or(2048);
let name = strp(p, "name").map(str::to_string).unwrap_or_else(|| stem_of(path));
let mut next = Session::from_mesh_bytes_tiled(&f.name, &f.bytes, u32::try_from(res).unwrap_or(0), &name, crate::commands::boolp(p, "uvTiles"))?;
+ next.doc.project.mesh_path = native::absolute(path);
next.log.extend(f.warnings);
if let Some(t) = &template {
next.apply_template(t);
@@ -414,14 +423,28 @@ fn save_copy(s: &mut Session, p: &Value) -> Result {
native::save_to(s, &path, false)
}
+/// `file.reimportMesh {path?, preserveStrokes?}`: reimport from `path`, or from the project's own
+/// copy of the mesh when there is none. A path given is remembered as the project's mesh path.
+/// The remembered path is never read implicitly (a project file could point it anywhere on the
+/// host); callers that may read host files pass [`Session::remembered_mesh_path`] as `path`.
#[cfg(not(target_arch = "wasm32"))]
fn reimport(s: &mut Session, p: &Value) -> Result {
- let file = strp(p, "path").map(|path| native::read_mesh("file.reimportMesh", path)).transpose()?;
- s.reimport_mesh(file, crate::commands::boolp(p, "preserveStrokes").unwrap_or(false))
+ let path = strp(p, "path");
+ let file = path.map(|path| native::read_mesh("file.reimportMesh", path)).transpose()?;
+ let reply = s.reimport_mesh(file, crate::commands::boolp(p, "preserveStrokes").unwrap_or(false))?;
+ if let Some(path) = path {
+ s.doc.project.mesh_path = native::absolute(path);
+ }
+ Ok(reply)
}
#[cfg(not(target_arch = "wasm32"))]
impl Session {
+ /// The file the mesh was imported from, when it is still there: what Reimport mesh reads again.
+ pub fn remembered_mesh_path(&self) -> Option<&str> {
+ Some(self.doc.project.mesh_path.as_str()).filter(|m| !m.is_empty() && std::path::Path::new(m).is_file())
+ }
+
/// Replace the mesh with `file` (or re-read the project's own copy) and keep the project:
/// texture sets map by material index. Nothing changes unless the new mesh fits the project.
/// With `preserve_strokes`, painted pixels follow the surface where the UVs changed. Replies
@@ -449,6 +472,7 @@ impl Session {
next.log.extend(warnings);
next.path = self.path.clone();
next.modified = true;
+ next.project_id = self.project_id;
let preserved = preserve_strokes.then(|| crate::preserve::preserve_strokes(self, &mut next));
self.switch_to(next);
Ok(preserved.map_or(Value::Null, |n| json!({ "preserved": n })))
@@ -611,14 +635,57 @@ fn close(s: &mut Session, _: &Value) -> Result {
mod tests {
use super::*;
+ /// Reimport mesh reads the mesh file again from where it was imported, so a change saved to
+ /// the file since shows up (it used to re-read the project's own copy and change nothing).
+ #[test]
+ fn reimport_picks_up_changes_saved_to_the_mesh_file() {
+ let dir = std::env::temp_dir().join(format!("tc_reimport_disk_{}", std::process::id()));
+ std::fs::create_dir_all(&dir).unwrap();
+ let file = dir.join("tri.obj");
+ let obj = |z: f32| {
+ format!(
+ "v -1 -1 {z}
+v 1 -1 0
+v 1 1 0
+vt 0 0
+vt 1 0
+vt 1 1
+f 1/1 2/2 3/3
+"
+ )
+ };
+ std::fs::write(&file, obj(0.0)).unwrap();
+ let path = file.display().to_string();
+ let mut s = Session::new_project("t", primitives::material_ball(), "builtin:material_ball", None, 128).unwrap();
+ crate::execute(&mut s, "file.new", &json!({"mesh": path, "resolution": 128})).unwrap();
+ let low = |s: &Session| s.mesh.positions.iter().map(|p| p.z.abs()).fold(0.0_f32, f32::max);
+ assert_eq!(low(&s), 0.0);
+ // Edit the file, save the project, reopen it, then reimport with no path.
+ std::fs::write(&file, obj(0.5)).unwrap();
+ let mut reopened = Session::from_project_bytes(&s.to_project_bytes().unwrap()).unwrap();
+ assert_eq!(low(&reopened), 0.0, "the project still holds the old copy");
+ // A command without a path never reads the remembered host path (automation allows it).
+ crate::execute(&mut reopened, "file.reimportMesh", &Value::Null).unwrap();
+ assert_eq!(low(&reopened), 0.0, "no path: the project's own copy");
+ let remembered = reopened.remembered_mesh_path().map(str::to_string).expect("the imported file is remembered");
+ crate::execute(&mut reopened, "file.reimportMesh", &json!({ "path": remembered })).unwrap();
+ assert!(low(&reopened) > 0.0, "the edited file must be read again");
+ // The file gone: nothing is remembered, so the UI asks for one.
+ std::fs::remove_file(&file).unwrap();
+ assert!(reopened.remembered_mesh_path().is_none());
+ let _ = std::fs::remove_dir_all(&dir);
+ }
+
#[test]
fn reimporting_a_saved_project_marks_it_modified() {
let obj = b"v -1 -1 0\nv 1 -1 0\nv 1 1 0\nvt 0 0\nvt 1 0\nvt 1 1\nf 1/1 2/2 3/3\n";
let original = Session::from_mesh_bytes("mesh.obj", obj, 128, "mesh").unwrap();
let mut saved = Session::from_project_bytes(&original.to_project_bytes().unwrap()).unwrap();
assert!(!saved.modified);
+ let project = saved.project_id;
crate::execute(&mut saved, "file.reimportMesh", &Value::Null).unwrap();
assert!(saved.modified, "reimport must trigger the unsaved-changes prompt");
+ assert_eq!(saved.project_id, project, "a reimport stays the same project");
}
#[test]
diff --git a/crates/engine/src/fill_hit_test.rs b/crates/engine/src/fill_hit_test.rs
new file mode 100644
index 00000000..b30b2452
--- /dev/null
+++ b/crates/engine/src/fill_hit_test.rs
@@ -0,0 +1,83 @@
+//! Which polygons a polygon fill box selects.
+
+use serde::{Deserialize, Serialize};
+use texturecraft_geom::glam::Vec2;
+
+/// How a polygon fill box decides whether it selects a polygon
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
+pub enum FillHitTest {
+ /// Any part of the polygon inside the box or crossing it
+ #[default]
+ Intersection,
+ /// The polygon's center point inside the box
+ ContainedCenter,
+}
+
+impl FillHitTest {
+ /// Whether the box from `low` to `high` selects the polygon made of `triangles` (their corners)
+ pub fn selects(self, triangles: &[[Vec2; 3]], low: Vec2, high: Vec2) -> bool {
+ match self {
+ FillHitTest::Intersection => triangles.iter().any(|corners| triangle_overlaps_box(*corners, low, high)),
+ FillHitTest::ContainedCenter => center(triangles).is_some_and(|point| point.cmpge(low).all() && point.cmple(high).all()),
+ }
+ }
+}
+
+/// Area-weighted center of the triangles (their corners' mean when they have no area)
+fn center(triangles: &[[Vec2; 3]]) -> Option {
+ if triangles.is_empty() {
+ return None;
+ }
+
+ // One pass: total area, area-weighted centroids and plain centroids
+ let (total_area, weighted, centroids) = triangles.iter().fold((0.0, Vec2::ZERO, Vec2::ZERO), |(total_area, weighted, centroids), corners| {
+ let area = (corners[1] - corners[0]).perp_dot(corners[2] - corners[0]).abs();
+ let centroid = (corners[0] + corners[1] + corners[2]) / 3.0;
+ (total_area + area, weighted + centroid * area, centroids + centroid)
+ });
+ Some(if total_area > 0.0 { weighted / total_area } else { centroids / triangles.len() as f32 })
+}
+
+/// Separating axis test of a triangle against an axis-aligned box
+fn triangle_overlaps_box(corners: [Vec2; 3], low: Vec2, high: Vec2) -> bool {
+ let triangle_low = corners[0].min(corners[1]).min(corners[2]);
+ let triangle_high = corners[0].max(corners[1]).max(corners[2]);
+ if triangle_high.cmplt(low).any() || triangle_low.cmpgt(high).any() {
+ return false;
+ }
+
+ let box_corners = [low, Vec2::new(high.x, low.y), high, Vec2::new(low.x, high.y)];
+ (0..3).all(|edge| {
+ let axis = (corners[(edge + 1) % 3] - corners[edge]).perp();
+ let span = |points: &[Vec2]| points.iter().fold((f32::MAX, f32::MIN), |(min, max), point| (min.min(axis.dot(*point)), max.max(axis.dot(*point))));
+ let (triangle_min, triangle_max) = span(&corners);
+ let (box_min, box_max) = span(&box_corners);
+ triangle_max >= box_min && box_max >= triangle_min
+ })
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ const TRIANGLE: [Vec2; 3] = [Vec2::new(0.0, 0.0), Vec2::new(4.0, 0.0), Vec2::new(0.0, 4.0)];
+
+ #[test]
+ fn intersection_selects_any_overlap() {
+ assert!(FillHitTest::Intersection.selects(&[TRIANGLE], Vec2::splat(1.0), Vec2::splat(6.0)), "a box cutting the triangle");
+ assert!(!FillHitTest::Intersection.selects(&[TRIANGLE], Vec2::splat(3.0), Vec2::splat(5.0)), "inside the bounds, past the long edge");
+ }
+
+ #[test]
+ fn contained_center_selects_only_by_the_center() {
+ assert!(!FillHitTest::ContainedCenter.selects(&[TRIANGLE], Vec2::splat(2.0), Vec2::splat(6.0)), "the center (4/3, 4/3) lies outside");
+ assert!(FillHitTest::ContainedCenter.selects(&[TRIANGLE], Vec2::splat(1.0), Vec2::splat(2.0)));
+ }
+
+ #[test]
+ fn a_polygon_center_weighs_its_triangles_by_area() {
+ let square = [[Vec2::ZERO, Vec2::new(2.0, 0.0), Vec2::new(2.0, 2.0)], [Vec2::ZERO, Vec2::new(2.0, 2.0), Vec2::new(0.0, 2.0)]];
+ assert_eq!(center(&square), Some(Vec2::ONE));
+ assert_eq!(center(&[]), None);
+ }
+}
diff --git a/crates/engine/src/fill_mode.rs b/crates/engine/src/fill_mode.rs
new file mode 100644
index 00000000..f314562e
--- /dev/null
+++ b/crates/engine/src/fill_mode.rs
@@ -0,0 +1,17 @@
+//! What one polygon fill target grows to.
+
+use serde::{Deserialize, Serialize};
+
+/// Polygon fill granularity: what a clicked triangle or a boxed polygon grows to
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
+pub enum FillMode {
+ /// The triangle itself
+ #[default]
+ Triangle,
+ /// The source polygon (quad or n-gon) the importer split into triangles
+ Polygon,
+ /// The UV island: triangles sharing edges in UV space
+ UvIsland,
+ /// The connected geometry: triangles sharing edges by position
+ Mesh,
+}
diff --git a/crates/engine/src/filter_lib.rs b/crates/engine/src/filter_lib.rs
index f3168c9d..7856f565 100644
--- a/crates/engine/src/filter_lib.rs
+++ b/crates/engine/src/filter_lib.rs
@@ -19,6 +19,20 @@ pub struct FilterDef {
pub mask: bool,
}
+impl FilterDef {
+ /// Whether it builds a filter effect (levels and material finishes are effect types of their own)
+ pub fn is_filter_effect(&self) -> bool {
+ matches!(build(self.id, &Value::Null), Ok(EffectKind::Filter(_)))
+ }
+}
+
+/// The library entries that build filter effects, in shelf order, worked out once
+pub fn filter_effects() -> &'static [&'static FilterDef] {
+ static FILTER_EFFECTS: std::sync::LazyLock> =
+ std::sync::LazyLock::new(|| FILTERS.iter().filter(|def| def.is_filter_effect()).collect());
+ &FILTER_EFFECTS
+}
+
const fn def(id: &'static str, label: &'static str, group: &'static str, mask: bool) -> FilterDef {
FilterDef { id, label, group, mask }
}
diff --git a/crates/engine/src/inspect.rs b/crates/engine/src/inspect.rs
index 347b7390..2db27946 100644
--- a/crates/engine/src/inspect.rs
+++ b/crates/engine/src/inspect.rs
@@ -2,7 +2,7 @@
//! without a screenshot.
use serde_json::{Value, json};
-use texturecraft_core::{Effect, EffectKind, Fill, Filter, Layer, LayerKind, NormalFormat, Projection, Source};
+use texturecraft_core::{Effect, EffectKind, Fill, Filter, Generator, Layer, LayerKind, NormalFormat, Projection, Source};
use crate::Session;
use crate::session::StackTarget;
@@ -34,38 +34,49 @@ fn fill_json(f: &Fill) -> Value {
}
/// A mask or content (`content`) effect.
-fn effect_json(s: &Session, e: &Effect, content: bool) -> Value {
- let mut ej = json!({ "id": e.id.0, "name": e.name, "kind": e.kind.name(), "visible": e.visible, "blend": e.blend.label(), "opacity": e.opacity });
- match &e.kind {
- EffectKind::Generator(g) => {
- ej["generator"] = json!({ "type": format!("{:?}", g.kind), "level": g.level, "softness": g.softness, "noise": g.noise_amount, "invert": g.invert })
+fn effect_json(session: &Session, effect: &Effect, content: bool) -> Value {
+ let mut out = json!({ "id": effect.id.0, "name": effect.name, "kind": effect.kind.name(), "visible": effect.visible, "blend": effect.blend.label(), "opacity": effect.opacity });
+ let mask_tiles = || session.doc.pixels.masks.get(&effect.id).map_or(0, |image| image.allocated_count());
+ let content_tiles = || session.doc.pixels.layers.iter().filter(|((id, _), _)| *id == effect.id).map(|(_, image)| image.allocated_count()).sum::();
+
+ match &effect.kind {
+ EffectKind::Generator(generator) => out["generator"] = generator_json(generator),
+ EffectKind::Levels(levels) => out["levels"] = json!([levels.in_low, levels.in_high, levels.gamma, levels.out_low, levels.out_high]),
+ EffectKind::ColorSelection { colors, tolerance } => {
+ out["colors"] = json!(colors);
+ out["tolerance"] = json!(tolerance);
}
- EffectKind::Levels(lv) => ej["levels"] = json!([lv.in_low, lv.in_high, lv.gamma, lv.out_low, lv.out_high]),
EffectKind::Path(paths) => {
- ej["paths"] = json!(paths.iter().map(|p| json!({ "points": p.points.len(), "uv": p.uv, "closed": p.closed, "fill": p.fill })).collect::>());
- ej["tiles"] = json!(if content {
- s.doc.pixels.layers.iter().filter(|((id, _), _)| *id == e.id).map(|(_, img)| img.allocated_count()).sum::()
- } else {
- s.doc.pixels.masks.get(&e.id).map(|i| i.allocated_count()).unwrap_or(0)
- });
+ out["paths"] = json!(
+ paths.iter().map(|path| json!({ "points": path.points.len(), "uv": path.uv, "closed": path.closed, "fill": path.fill })).collect::>()
+ );
+ out["tiles"] = json!(if content { content_tiles() } else { mask_tiles() });
}
- EffectKind::Paint if content => {
- ej["tiles"] = json!(s.doc.pixels.layers.iter().filter(|((id, _), _)| *id == e.id).map(|(_, img)| img.allocated_count()).sum::())
- }
- EffectKind::Paint => ej["tiles"] = json!(s.doc.pixels.masks.get(&e.id).map(|i| i.allocated_count()).unwrap_or(0)),
- EffectKind::Fill { source, .. } => ej["source"] = source_json(source),
- EffectKind::Material(f) => ej["fill"] = fill_json(f),
- EffectKind::Filter(f) => {
- ej["filter"] = json!(f);
- match f {
- Filter::Hsl { hue, saturation, lightness } => ej["hsl"] = json!([hue, saturation, lightness]),
- Filter::Blur { radius } => ej["radius"] = json!(radius),
+ EffectKind::Paint if content => out["tiles"] = json!(content_tiles()),
+ EffectKind::Paint => out["tiles"] = json!(mask_tiles()),
+ EffectKind::Fill { source, .. } => out["source"] = source_json(source),
+ EffectKind::Material(fill) => out["fill"] = fill_json(fill),
+ EffectKind::Filter(filter) => {
+ out["filter"] = json!(filter);
+ match filter {
+ Filter::Hsl { hue, saturation, lightness } => out["hsl"] = json!([hue, saturation, lightness]),
+ Filter::Blur { radius } => out["radius"] = json!(radius),
_ => {}
}
}
_ => {}
}
- ej
+ out
+}
+
+/// A generator's settings, with its curvature mode and detail size weights when it has them.
+fn generator_json(generator: &Generator) -> Value {
+ let mut out = json!({ "type": format!("{:?}", generator.kind), "level": generator.level, "softness": generator.softness, "noise": generator.noise_amount, "invert": generator.invert });
+ if let Some(detail) = &generator.detail {
+ out["mode"] = json!(format!("{:?}", detail.mode));
+ out["sizes"] = json!(detail.weights);
+ }
+ out
}
fn layer_json(s: &Session, l: &Layer, depth: usize) -> Value {
@@ -176,6 +187,7 @@ pub fn session(s: &Session) -> Value {
"layers": stack(s, ts),
"tool": { "tool": s.tool.tool.id(), "brush": crate::tool_cmds::brush_json(s) },
"view": s.view.label(),
+ "bakePreview": crate::bake_preview::preview_json(s),
"camera": crate::view_cmds::camera_json(s),
"display": s.doc.project.display,
"history": { "undo": s.undo_label(), "redo": s.redo_label(), "depth": s.history_labels().len() },
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index bfc3bf9e..a8ea034a 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -9,12 +9,16 @@
#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
pub mod bake;
+pub mod bake_preview;
pub mod brush_preset_cmds;
pub mod camera_cmds;
+pub mod color_selection_cmds;
pub mod commands;
pub mod decal_cmds;
pub mod effect_clipboard;
pub mod file_cmds;
+pub mod fill_hit_test;
+pub mod fill_mode;
pub mod filter_lib;
pub mod inspect;
pub mod instance_cmds;
@@ -22,16 +26,21 @@ pub mod layer_cmds;
pub mod layer_ops;
pub mod link_cmds;
pub mod mask_cmds;
-pub mod mask_preview;
-mod mask_preview_camera;
mod mask_preview_pixel;
pub mod material_lib;
+mod material_preview_pixel;
pub mod materials;
pub mod materialx_cmds;
pub mod meshmap_cmds;
+mod meshmap_file_name;
+pub mod meshmap_import_cmds;
+mod orb_camera;
+pub mod orb_preview;
pub mod painting;
mod path_draft;
pub mod path_tool;
+mod polygon_fill;
+mod polygon_fill_drag;
// Mesh reimport reads files: native only.
#[cfg(not(target_arch = "wasm32"))]
mod preserve;
@@ -45,15 +54,21 @@ pub mod set_cmds;
pub mod smart_masks;
pub mod template_cmds;
pub mod text_cmds;
+pub mod thumbs;
pub mod tool_cmds;
+mod triangle_partition;
+mod uv_stroke_state;
pub mod uv_tile_cmds;
pub mod view_cmds;
-pub use bake::{BakeMesh, BakeMeshes, BakeTask};
+pub use bake::{BakeMesh, BakeMeshes, BakeTask, StreamedBake, StreamedMap};
+pub use bake_preview::{BakePreview, PreviewShow};
pub use commands::{CommandSpec, command_specs, execute, find};
+pub use fill_hit_test::FillHitTest;
+pub use fill_mode::FillMode;
pub use path_tool::PathState;
pub use project_cmds::sample_session;
-pub use session::{CloneFrom, CloneSource, Document, FillMode, Session, SetCache, StackTarget, StencilState, Tool, ToolState, ViewMode};
+pub use session::{CloneFrom, CloneSource, Document, Session, SetCache, StackTarget, StencilState, Tool, ToolState, ViewMode};
pub use set_cmds::{ResizeOutput, ResizeTask};
pub use texturecraft_compose as compose;
diff --git a/crates/engine/src/mask_cmds.rs b/crates/engine/src/mask_cmds.rs
index 2656bd15..b8aad872 100644
--- a/crates/engine/src/mask_cmds.rs
+++ b/crates/engine/src/mask_cmds.rs
@@ -2,8 +2,8 @@
use serde_json::{Value, json};
use texturecraft_core::{
- BlendMode, Channel, CompareOp, Effect, EffectKind, Filter, Generator, GeneratorKind, LayerId, Levels, Mask, MaskBackground, Procedural, ProceduralKind,
- Project, Source,
+ BlendMode, Channel, CompareOp, CurvatureDetail, CurvatureMode, Effect, EffectKind, Filter, Generator, GeneratorKind, LayerId, Levels, Mask, MaskBackground,
+ Procedural, ProceduralKind, Project, Source,
};
use crate::commands::{CommandSpec, always, bad, blend_param, boolp, channel_param, color_param, f32p, has_layer, layer_param, strp, u64p};
@@ -49,7 +49,7 @@ pub fn specs() -> Vec {
"Add generator",
["Layers", "Effects"],
None,
- "{layer?, name?, generator?: edgeWear|dirt|thinAreas|curvature|ambientOcclusion|position|direction, level?, softness?, noise?, invert?}",
+ "{layer?, name?, generator?: edgeWear|dirt|thinAreas|curvature|ambientOcclusion|position|direction, level?, softness?, noise?, invert?, mode?: edges|cavities|both|raw, sizes?: [7 weights 0..1, finest first] (curvature and edgeWear)}",
has_layer,
add_generator
),
@@ -94,7 +94,7 @@ pub fn specs() -> Vec {
"Edit effect",
[],
None,
- "{effect, visible?, blend?, opacity?, name?, level?, softness?, noise?, noiseScale?, invert?, value?, anchor?, anchorChannel?, inLow?, inHigh?, gamma?, outLow?, outHigh?, tolerance?, filter parameters (see effect.add.filter)}",
+ "{effect, visible?, blend?, opacity?, name?, filter?: id from filter.list (a filter effect only: swaps its type, keeping position, blend and opacity; its current id edits it in place), level?, softness?, noise?, noiseScale?, invert?, mode?, sizes?, value?, anchor?, anchorChannel?, inLow?, inHigh?, gamma?, outLow?, outHigh?, tolerance?, colors?: [[r,g,b], ...] (a color selection's ID colors), filter parameters (see effect.add.filter)}",
has_layer,
set
),
@@ -314,39 +314,76 @@ fn add_fill(s: &mut Session, p: &Value) -> Result {
push_effect(s, p, EffectKind::Fill { source, projection }, blend)
}
-fn generator_from(p: &Value, g: &mut Generator) {
- if let Some(v) = f32p(p, "level") {
- g.level = v.clamp(0.0, 1.0);
+/// Apply `params` to `generator`, using `command` in errors
+fn generator_from(command: &str, params: &Value, generator: &mut Generator) -> Result<()> {
+ if let Some(level) = f32p(params, "level") {
+ generator.level = level.clamp(0.0, 1.0);
}
- if let Some(v) = f32p(p, "softness") {
- g.softness = v.clamp(0.0, 1.0);
+ if let Some(softness) = f32p(params, "softness") {
+ generator.softness = softness.clamp(0.0, 1.0);
}
- if let Some(v) = f32p(p, "noise") {
- g.noise_amount = v.clamp(0.0, 2.0);
+ if let Some(noise) = f32p(params, "noise") {
+ generator.noise_amount = noise.clamp(0.0, 2.0);
}
- if let Some(v) = f32p(p, "noiseScale") {
- g.noise_scale = v.clamp(0.01, 1000.0);
+ if let Some(noise_scale) = f32p(params, "noiseScale") {
+ generator.noise_scale = noise_scale.clamp(0.01, 1000.0);
}
- if let Some(v) = u64p(p, "seed") {
- g.seed = v as u32;
+ if let Some(seed) = u64p(params, "seed") {
+ generator.seed = seed as u32;
}
- if let Some(v) = boolp(p, "invert") {
- g.invert = v;
+ if let Some(invert) = boolp(params, "invert") {
+ generator.invert = invert;
}
- if let Some(d) = color_param(p, "direction") {
- g.direction = d;
+ if let Some(direction) = color_param(params, "direction") {
+ generator.direction = direction;
}
+
+ // A mode or sizes also give a curvature generator saved before detail sizes its detail
+ let mode = params
+ .get("mode")
+ .map(|value| {
+ let name = value.as_str().ok_or_else(|| bad(command, "`mode` must be a string"))?;
+ CurvatureMode::parse(name).ok_or_else(|| bad(command, format!("unknown curvature mode `{name}`")))
+ })
+ .transpose()?;
+ let weights = params.get("sizes").map(|value| size_weights(command, value)).transpose()?;
+ if mode.is_none() && weights.is_none() {
+ return Ok(());
+ }
+ if !matches!(generator.kind, GeneratorKind::Curvature | GeneratorKind::EdgeWear) {
+ return Err(bad(command, "only curvature and edge wear generators have a mode and detail sizes"));
+ }
+
+ let detail = generator.detail.get_or_insert_with(CurvatureDetail::default);
+ if let Some(mode) = mode {
+ detail.mode = mode;
+ }
+ if let Some(weights) = weights {
+ detail.weights = weights;
+ }
+ Ok(())
}
-fn add_generator(s: &mut Session, p: &Value) -> Result {
- let kind = match strp(p, "generator") {
- Some(k) => GeneratorKind::parse(k).ok_or_else(|| bad("effect.add.generator", format!("unknown generator `{k}`")))?,
+/// Read one weight (0..1) per size of [`CurvatureDetail::SIZES`], finest first
+fn size_weights(command: &str, value: &Value) -> Result<[f32; CurvatureDetail::SIZES.len()]> {
+ let invalid = || bad(command, format!("`sizes` takes {} numbers, finest first", CurvatureDetail::SIZES.len()));
+ let items = value.as_array().filter(|items| items.len() == CurvatureDetail::SIZES.len()).ok_or_else(invalid)?;
+ let mut weights = [0.0; CurvatureDetail::SIZES.len()];
+ for (weight, item) in weights.iter_mut().zip(items) {
+ *weight = item.as_f64().ok_or_else(invalid)?.clamp(0.0, 1.0) as f32;
+ }
+ Ok(weights)
+}
+
+fn add_generator(session: &mut Session, params: &Value) -> Result {
+ let kind = match strp(params, "generator") {
+ Some(name) => GeneratorKind::parse(name).ok_or_else(|| bad("effect.add.generator", format!("unknown generator `{name}`")))?,
None => GeneratorKind::EdgeWear,
};
- let mut g = Generator::new(kind);
- generator_from(p, &mut g);
- let blend = blend_param("effect.add.generator", p, "blend")?.unwrap_or(BlendMode::Normal);
- push_effect(s, p, EffectKind::Generator(g), blend)
+ let mut generator = Generator::new(kind);
+ generator_from("effect.add.generator", params, &mut generator)?;
+ let blend = blend_param("effect.add.generator", params, "blend")?.unwrap_or(BlendMode::Normal);
+ push_effect(session, params, EffectKind::Generator(generator), blend)
}
pub(crate) fn levels_from(p: &Value, l: &mut Levels) {
@@ -413,55 +450,79 @@ fn histogram(s: &mut Session, p: &Value) -> Result {
Ok(if content { json!({"target": "content", "channel": channel.id(), "bins": counts}) } else { json!({"target": "mask", "bins": counts}) })
}
-fn set(s: &mut Session, p: &Value) -> Result {
- let eid = effect_id(s, p, "effect.set")?;
- let blend = blend_param("effect.set", p, "blend")?;
- // A fill reading an anchor: `anchor` picks the anchor point, `anchorChannel` alone
- // re-targets the current one.
- let anchor = match s.doc.project.effect(eid) {
+/// Edit visibility, blending, name, effect parameters, or a filter's type
+fn set(session: &mut Session, params: &Value) -> Result {
+ const CMD: &str = "effect.set";
+ let effect = effect_id(session, params, CMD)?;
+ let blend = blend_param(CMD, params, "blend")?;
+
+ // `anchor` picks a fill's anchor point, `anchorChannel` alone re-targets the current one
+ let anchor = match session.doc.project.effect(effect) {
Some((owner, Effect { kind: EffectKind::Fill { source, .. }, .. })) => {
let (current, channel) = match source {
Source::Anchor { anchor, channel } => (Some(*anchor), *channel),
_ => (None, Channel::Height),
};
- let channel_param = channel_param("effect.set", p, "anchorChannel")?;
- match u64p(p, "anchor").map(LayerId).or(current.filter(|_| channel_param.is_some())) {
- Some(a) => Some(anchor_source(s, "effect.set", owner, a, channel_param.unwrap_or(channel))?),
+ let channel_param = channel_param(CMD, params, "anchorChannel")?;
+ match u64p(params, "anchor").map(LayerId).or(current.filter(|_| channel_param.is_some())) {
+ Some(anchor) => Some(anchor_source(session, CMD, owner, anchor, channel_param.unwrap_or(channel))?),
None => None,
}
}
_ => None,
};
- s.edit("Edit effect", |s| {
- let e = s.doc.project.effect_mut(eid).ok_or_else(|| bad("effect.set", format!("no effect {}", eid.0)))?;
- if let Some(v) = boolp(p, "visible") {
- e.visible = v;
+
+ // Naming the filter the effect already is edits its parameters like a plain effect.set
+ let swapped = match strp(params, "filter") {
+ Some(filter) if crate::filter_lib::find(filter).is_some_and(|def| current_filter_id(session, effect) == Some(def.id)) => None,
+ Some(filter) => Some(swapped_filter(session, effect, filter, params)?),
+ None => None,
+ };
+ let swaps_filter = swapped.is_some();
+
+ session.edit("Edit effect", |session| {
+ let edited = session.doc.project.effect_mut(effect).ok_or_else(|| bad(CMD, format!("no effect {}", effect.0)))?;
+ if let Some((kind, label)) = swapped {
+ if let EffectKind::Filter(old) = &edited.kind
+ && edited.name == old.label()
+ {
+ edited.name = label.to_string();
+ }
+ edited.kind = kind;
}
- if let Some(b) = blend {
- e.blend = b;
+
+ if let Some(visible) = boolp(params, "visible") {
+ edited.visible = visible;
}
- if let Some(o) = f32p(p, "opacity") {
- e.opacity = o.clamp(0.0, 1.0);
+ if let Some(blend) = blend {
+ edited.blend = blend;
}
- if let Some(n) = name_param(p) {
- e.name = n.to_string();
+ if let Some(opacity) = f32p(params, "opacity") {
+ edited.opacity = opacity.clamp(0.0, 1.0);
}
- match &mut e.kind {
- EffectKind::Generator(g) => generator_from(p, g),
- EffectKind::Levels(l) => levels_from(p, l),
- EffectKind::Filter(f) => crate::filter_lib::apply(p, f, "effect.set")?,
+ if let Some(name) = name_param(params) {
+ edited.name = name.to_string();
+ }
+
+ match &mut edited.kind {
+ EffectKind::Generator(generator) => generator_from(CMD, params, generator)?,
+ EffectKind::Levels(levels) => levels_from(params, levels),
+ // The swapped filter was built with the parameters already
+ EffectKind::Filter(_) if swaps_filter => {}
+ EffectKind::Filter(filter) => crate::filter_lib::apply(params, filter, CMD)?,
EffectKind::Fill { source, .. } => {
- if let Some(a) = anchor {
- *source = a;
- } else if let Some(x) = f32p(p, "value")
+ if let Some(anchor) = anchor {
+ *source = anchor;
+ } else if let Some(value) = f32p(params, "value")
&& matches!(source, Source::Uniform(_) | Source::Anchor { .. })
{
- *source = Source::Uniform([x.clamp(0.0, 1.0); 3]);
+ *source = Source::Uniform([value.clamp(0.0, 1.0); 3]);
}
}
- EffectKind::ColorSelection { tolerance, .. } | EffectKind::Compare { tolerance, .. } => {
- if let Some(x) = f32p(p, "tolerance") {
- *tolerance = x.clamp(0.0, 1.0);
+ EffectKind::ColorSelection { colors, tolerance } => crate::color_selection_cmds::apply_params(params, colors, tolerance)?,
+ EffectKind::Compare { tolerance, .. } => {
+ if let Some(value) = f32p(params, "tolerance") {
+ *tolerance = value.clamp(0.0, 1.0);
}
}
_ => {}
@@ -471,6 +532,38 @@ fn set(s: &mut Session, p: &Value) -> Result {
Ok(Value::Null)
}
+/// The library id of the filter effect `effect` is, if it is one
+fn current_filter_id(s: &Session, effect: LayerId) -> Option<&'static str> {
+ match &s.doc.project.effect(effect)?.1.kind {
+ EffectKind::Filter(filter) => crate::filter_lib::find(filter.label()).map(|def| def.id),
+ _ => None,
+ }
+}
+
+/// Filter `id` built with `p` and its label, to replace filter effect `effect`
+fn swapped_filter(s: &Session, effect: LayerId, id: &str, p: &Value) -> Result<(EffectKind, &'static str)> {
+ const CMD: &str = "effect.set";
+ let (owner, current) = s.doc.project.effect(effect).ok_or_else(|| bad(CMD, format!("no effect {}", effect.0)))?;
+ if !matches!(current.kind, EffectKind::Filter(_)) {
+ return Err(bad(CMD, format!("`filter` changes filter effects only, not {}", current.kind.name().to_ascii_lowercase())));
+ }
+
+ let def = crate::filter_lib::find(id).ok_or_else(|| bad(CMD, format!("unknown filter `{id}` (see filter.list)")))?;
+ let mut kind = crate::filter_lib::build(def.id, &Value::Null)?;
+ let EffectKind::Filter(filter) = &mut kind else {
+ return Err(bad(CMD, format!("{} is its own effect type: add it with effect.add.filter", def.label)));
+ };
+
+ let mask = s.doc.project.layer(owner)?.mask.as_ref();
+ let on_mask = mask.is_some_and(|mask| mask.effects.iter().any(|masked| masked.id == effect));
+ if on_mask && !def.mask {
+ return Err(bad(CMD, format!("{} goes on layer content, not on masks", def.label)));
+ }
+
+ crate::filter_lib::apply(p, filter, CMD)?;
+ Ok((kind, def.label))
+}
+
/// The stack (a mask's or a layer's content effects) holding effect `eid`, and its position there.
fn stack_of(project: &mut Project, eid: LayerId) -> Option<(&mut Vec, usize)> {
project.layers.values_mut().find_map(|l| {
diff --git a/crates/engine/src/mask_preview.rs b/crates/engine/src/mask_preview.rs
deleted file mode 100644
index a44757fc..00000000
--- a/crates/engine/src/mask_preview.rs
+++ /dev/null
@@ -1,161 +0,0 @@
-//! Smart mask previews share one baked [`primitives::preview_orb`]
-//! Presets use `mask.smart.apply` and the compositor, matching document masks
-
-use serde_json::json;
-use texturecraft_core::{BakeResolution, BakedMap, CurvatureMethod, LayerId};
-use texturecraft_geom::glam::Vec3;
-use texturecraft_geom::primitives;
-
-use crate::mask_preview_camera::MaskPreviewCamera;
-pub use crate::mask_preview_pixel::MaskPreviewPixel;
-use crate::{EngineError, Result, Session};
-
-/// Bake resolution in texels; 256 loses the thin edge lines
-const TEXTURE_PX: u32 = 512;
-/// Camera rays per preview pixel along each axis (anti-aliased outline)
-const SUPERSAMPLE: usize = 2;
-/// Bound camera samples and output allocations for shelf previews
-pub const MAX_PREVIEW_SIZE_PX: usize = 512;
-/// AO and thickness rays per texel; thumbnail detail needs fewer than the default
-const OCCLUSION_RAYS: u32 = 12;
-/// Curvature rays per texel; thumbnail detail needs fewer than the default
-const CURVATURE_RAYS: u32 = 12;
-/// Radius relative to the bounding box; isolates panel edges from the round body
-const CURVATURE_RADIUS: f32 = 0.005;
-/// The mesh maps the smart mask generators read
-const MAPS: [BakedMap; 3] = [BakedMap::Curvature, BakedMap::AmbientOcclusion, BakedMap::Thickness];
-/// Keep camera views for the thumbnail and hover preview sizes
-const CAMERAS_KEPT: usize = 2;
-
-/// The baked preview shape and, per preview size, what its camera sees
-pub struct MaskPreview {
- session: Session,
- layer: LayerId,
- /// Cached camera views, least recently used first
- cameras: Vec,
-}
-
-impl MaskPreview {
- /// Bake the preview shape once (previews of any size reuse it)
- pub fn new() -> Result {
- let mut session = Session::new_project("Mask preview", primitives::preview_orb(), "builtin:preview_orb", None, TEXTURE_PX)?;
- let set = session.doc.project.texture_set_mut(0)?;
- set.bake.common.resolution = BakeResolution::from_pixels(TEXTURE_PX).ok_or_else(|| EngineError::Other("invalid bake resolution".into()))?;
- set.bake.high_poly.use_low_as_high = true;
- set.bake.maps.curvature.parameters.method = CurvatureMethod::Mesh;
- set.bake.maps.curvature.parameters.mesh.sampling_radius = CURVATURE_RADIUS;
- set.bake.maps.curvature.parameters.mesh.rays = CURVATURE_RAYS;
- set.bake.maps.ao.parameters.rays.rays = OCCLUSION_RAYS;
- set.bake.maps.thickness.parameters.rays.rays = OCCLUSION_RAYS;
- for map in BakedMap::ALL {
- set.bake.maps.set_enabled(map, MAPS.contains(&map));
- }
- let layer = *set.stack.first().ok_or_else(|| EngineError::Other("the preview has no layer".into()))?;
- session.bake_now(0, false)?;
-
- Ok(MaskPreview { session, layer, cameras: Vec::new() })
- }
-
- /// Row-major `size²` pixels, with None outside the shape
- /// Returns None for unknown masks or sizes outside 1..=[`MAX_PREVIEW_SIZE_PX`]
- pub fn render(&mut self, id: &str, size: usize) -> Option>> {
- if !(1..=MAX_PREVIEW_SIZE_PX).contains(&size) {
- return None;
- }
-
- crate::execute(&mut self.session, "mask.smart.apply", &json!({ "name": id, "layer": self.layer.0 })).ok()?;
- // Previews need no undo history; retaining snapshots grows memory across presets
- self.session.undo.clear();
-
- let camera = camera_for(&mut self.cameras, &self.session, size)?;
- let values = self.session.mask_at(self.layer, &camera.texels)?;
-
- let sub_pixels = (SUPERSAMPLE * SUPERSAMPLE) as f32;
- let pixels = (0..size * size)
- .map(|i| {
- let (x, y) = (i % size, i / size);
- let (mut mask, mut normal, mut hits) = (0.0, Vec3::ZERO, 0.0);
- for sy in 0..SUPERSAMPLE {
- for sx in 0..SUPERSAMPLE {
- let ray = (y * SUPERSAMPLE + sy) * camera.rays_per_side + x * SUPERSAMPLE + sx;
- let Some(&Some((texel, n))) = camera.samples.get(ray) else { continue };
-
- mask += values.get(texel).copied().unwrap_or(0.0);
- normal += n;
- hits += 1.0;
- }
- }
- (hits > 0.0).then(|| MaskPreviewPixel { mask: mask / hits, normal: normal.normalize_or_zero(), coverage: hits / sub_pixels })
- })
- .collect();
- Some(pixels)
- }
-}
-
-/// Cache one camera per preview size, evicting the least recently used view
-fn camera_for<'a>(cameras: &'a mut Vec, session: &Session, size: usize) -> Option<&'a MaskPreviewCamera> {
- let rays_per_side = size * SUPERSAMPLE;
- let camera = match cameras.iter().position(|c| c.rays_per_side == rays_per_side) {
- Some(i) => cameras.remove(i),
- None => MaskPreviewCamera::new(session, TEXTURE_PX, rays_per_side),
- };
- if cameras.len() >= CAMERAS_KEPT {
- cameras.remove(0);
- }
-
- cameras.push(camera);
- cameras.last()
-}
-
-#[cfg(test)]
-mod tests {
- use super::*;
-
- /// Mean absolute difference of the masks of two previews over the pixels both see
- fn difference(a: &[Option], b: &[Option]) -> f32 {
- let pairs: Vec<(f32, f32)> = a.iter().zip(b).filter_map(|(a, b)| Some((a.as_ref()?.mask, b.as_ref()?.mask))).collect();
- pairs.iter().map(|(a, b)| (a - b).abs()).sum::() / pairs.len().max(1) as f32
- }
-
- #[test]
- fn invalid_preview_sizes_are_rejected_before_changing_the_shape() {
- let session = Session::new_project("Mask preview", primitives::cube(2.0), "builtin:cube", None, 128).unwrap();
- let layer = session.doc.project.texture_set(0).unwrap().stack[0];
- let mut preview = MaskPreview { session, layer, cameras: Vec::new() };
- for size in [0, MAX_PREVIEW_SIZE_PX + 1, usize::MAX / 2 + 1, usize::MAX] {
- assert!(preview.render("edges_sharp", size).is_none(), "size {size} should be rejected before rendering");
- assert!(preview.cameras.is_empty(), "invalid sizes must not allocate a camera");
- assert!(preview.session.doc.project.layer(layer).unwrap().mask.is_none(), "invalid sizes must not apply a mask");
- }
- }
-
- #[test]
- fn smart_mask_previews_are_in_range_tell_edges_from_cavities_and_render_at_any_size() {
- let size = 24;
- let mut preview = MaskPreview::new().unwrap();
- for sm in crate::smart_masks::SMART_MASKS {
- let px = preview.render(sm.id, size).unwrap_or_else(|| panic!("{}", sm.id));
- assert_eq!(px.len(), size * size, "{}", sm.id);
- assert!(px[0].is_none(), "{}: the corners are outside the shape", sm.id);
- let seen: Vec<&MaskPreviewPixel> = px.iter().flatten().collect();
- assert!(seen.len() > size * size / 3, "{}: the shape fills the frame", sm.id);
- for p in seen {
- assert!((0.0..=1.0).contains(&p.mask) && (0.0..=1.0).contains(&p.coverage) && p.coverage > 0.0, "{}: {p:?}", sm.id);
- assert!(p.normal.is_finite(), "{}: {p:?}", sm.id);
- }
- }
-
- let (edges, cavities) = (preview.render("edges_sharp", size).unwrap(), preview.render("dirt_cavities", size).unwrap());
- let shows = |px: &[Option]| px.iter().flatten().any(|p| p.mask > 0.5);
- assert!(shows(&edges) && shows(&cavities), "both masks find something on the shape");
- assert!(difference(&edges, &cavities) > 0.05, "edges and cavities differ: {}", difference(&edges, &cavities));
- assert!(preview.render("nope", size).is_none());
-
- let big = preview.render("edges_sharp", size * 3).unwrap();
- let mean = |px: &[Option]| px.iter().flatten().map(|p| p.mask).sum::() / px.iter().flatten().count().max(1) as f32;
- assert_eq!(big.len(), size * size * 9);
- assert!((mean(&big) - mean(&edges)).abs() < 0.05, "{} vs {}", mean(&big), mean(&edges));
- preview.render("edges_sharp", size * 2).unwrap();
- assert_eq!(preview.cameras.len(), CAMERAS_KEPT, "only the most recent sizes keep their camera");
- }
-}
diff --git a/crates/engine/src/mask_preview_pixel.rs b/crates/engine/src/mask_preview_pixel.rs
index bcde5629..14ad5842 100644
--- a/crates/engine/src/mask_preview_pixel.rs
+++ b/crates/engine/src/mask_preview_pixel.rs
@@ -1,4 +1,4 @@
-//! One pixel of a smart mask preview (see [`crate::mask_preview::MaskPreview`]).
+//! One pixel of a smart mask preview (see [`crate::orb_preview::OrbPreview::mask`])
use texturecraft_geom::glam::Vec3;
diff --git a/crates/engine/src/material_preview_pixel.rs b/crates/engine/src/material_preview_pixel.rs
new file mode 100644
index 00000000..7b83422e
--- /dev/null
+++ b/crates/engine/src/material_preview_pixel.rs
@@ -0,0 +1,16 @@
+//! One pixel of a smart material preview (see [`crate::orb_preview::OrbPreview::material`])
+
+use texturecraft_geom::glam::Vec3;
+
+use crate::preview::Sample;
+
+/// The material values seen at a preview pixel, with what a display needs to light the shape
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct MaterialPreviewPixel {
+ /// Linear material values, averaged over the pixel
+ pub sample: Sample,
+ /// Surface normal in view space (+X right, +Y up, +Z towards the viewer)
+ pub normal: Vec3,
+ /// Fraction of the pixel the shape covers (0..=1, anti-aliased outline)
+ pub coverage: f32,
+}
diff --git a/crates/engine/src/meshmap_cmds.rs b/crates/engine/src/meshmap_cmds.rs
index 0fbe1f5b..4524b361 100644
--- a/crates/engine/src/meshmap_cmds.rs
+++ b/crates/engine/src/meshmap_cmds.rs
@@ -38,55 +38,91 @@ fn set(s: &mut Session, p: &Value) -> Result {
let ts = ts_param(s, p, CMD)?;
let map = map_param(p, CMD)?;
let name = strp(p, "image").ok_or_else(|| bad(CMD, "`image` (an image resource name) is required"))?;
- let img = s.images.get(name).cloned().ok_or_else(|| bad(CMD, format!("no image resource `{name}`")))?;
- let set = s.doc.project.texture_set(ts)?.clone();
- let tiles = set.tile_grid().map(|grid| tile_images(&s.images, name, &set.uv_tiles).map(|imgs| (grid, imgs))).transpose()?;
- // Every mesh map of a set shares one size: the other maps', or what a bake would make (a
- // block of the bake resolution per tile of the atlas).
- let (cols, rows) = tiles.as_ref().map_or((1, 1), |(g, _)| (g.cols, g.rows));
- let (res, height) = match s.doc.baked.get(&ts).filter(|b| !b.maps.is_empty()) {
- Some(b) => (b.resolution, b.maps.keys().next().map_or(b.resolution, |m| b.height(*m))),
- None => {
- let (width, height) = set.bake.common.output_size();
- (width.saturating_mul(cols), height.saturating_mul(rows))
- }
+ let image = s.images.get(name).cloned().ok_or_else(|| bad(CMD, format!("no image resource `{name}`")))?;
+ let texture_set = s.doc.project.texture_set(ts)?;
+ let images = match texture_set.tile_grid() {
+ Some(_) => tile_images(&s.images, CMD, name, &texture_set.uv_tiles)?,
+ None => BTreeMap::from([(FIRST_TILE, image)]),
};
- if res == 0 || height == 0 || u64::from(res) * u64::from(height) > texturecraft_bake::MAX_TEXELS || (tiles.is_none() && res > MAX_RESOLUTION) {
- return Err(bad(CMD, format!("mesh map size {res} × {height} is too large or empty")));
- }
- let directx = map == BakedMap::Normal && s.doc.project.normal_format == NormalFormat::DirectX;
- let data = match &tiles {
- None => resample(map.components(), (res, height), directx, |u, v| img.sample(u, v)),
- // An atlas texel reads the image of the tile its mesh UV falls in.
- Some((grid, imgs)) => resample(map.components(), (res, height), directx, |u, v| {
- let uv = grid.from_atlas([u, v]);
- udim_at(uv).and_then(|t| imgs.get(&t)).map_or([0.0; 4], |img| img.sample(uv[0] - uv[0].floor(), uv[1] - uv[1].floor()))
- }),
- };
- s.edit("Use image as mesh map", |s| {
- let entry = s.doc.baked.entry(ts).or_default();
- entry.resolution = res;
- entry.maps.insert(map, Arc::new(data));
- s.doc.project.texture_set_mut(ts)?.baked.insert(map);
- Ok(())
- })?;
- Ok(json!({ "map": map.id(), "resolution": res }))
+
+ let resolution = s.edit("Use image as mesh map", |s| use_images(s, CMD, ts, map, &images))?;
+ Ok(json!({ "map": map.id(), "resolution": resolution }))
}
-/// The image of every UV tile of a set: `name` with its tile number (`ao.1001.png`) swapped for
-/// each tile's.
-fn tile_images(images: &ImageStore, name: &str, tiles: &[u32]) -> Result>> {
- const CMD: &str = "textureSet.meshMap.set";
- let at = udim_in(name).ok_or_else(|| bad(CMD, format!("`{name}` names no UV tile: a UV-tiled set takes one image per tile, named like ao.1001.png")))?;
+/// The tile number a set without UV tiles keys its one image by
+pub(crate) const FIRST_TILE: u32 = *UDIM_RANGE.start();
+
+/// Use `images` (by UV tile; one at [`FIRST_TILE`] without UV tiles) as mesh map `map` of set `ts` in the caller's edit; returns its width
+pub(crate) fn use_images(s: &mut Session, cmd: &str, ts: usize, map: BakedMap, images: &BTreeMap>) -> Result {
+ let texture_set = s.doc.project.texture_set(ts)?;
+ let grid = texture_set.tile_grid();
+ if let Some(tile) = texture_set.uv_tiles.iter().find(|tile| grid.is_some() && !images.contains_key(tile)) {
+ return Err(bad(cmd, format!("no image for UV tile {tile}")));
+ }
+
+ let (width, height) = image_map_size(s, cmd, ts)?;
+
+ let flip_green = map == BakedMap::Normal && s.doc.project.normal_format == NormalFormat::DirectX;
+ let data = match (grid, images.values().next()) {
+ (_, None) => return Err(bad(cmd, "no image to use")),
+ (None, Some(image)) => resample(map.components(), (width, height), flip_green, |u, v| image.sample(u, v)),
+ // An atlas texel reads the image of the tile its mesh UV falls in
+ (Some(grid), Some(_)) => resample(map.components(), (width, height), flip_green, |u, v| {
+ let uv = grid.from_atlas([u, v]);
+ udim_at(uv).and_then(|tile| images.get(&tile)).map_or([0.0; 4], |image| image.sample(uv[0] - uv[0].floor(), uv[1] - uv[1].floor()))
+ }),
+ };
+
+ let entry = s.doc.baked.entry(ts).or_default();
+ entry.resolution = width;
+ entry.maps.insert(map, Arc::new(data));
+ s.doc.project.texture_set_mut(ts)?.baked.insert(map);
+ Ok(width)
+}
+
+/// Dimensions shared by imported mesh maps, checked before allocating the resampled pixels
+pub(crate) fn image_map_size(s: &Session, cmd: &str, ts: usize) -> Result<(u32, u32)> {
+ let texture_set = s.doc.project.texture_set(ts)?;
+ let grid = texture_set.tile_grid();
+
+ // Every mesh map of a set shares one size: the other maps', or a bake's (a bake-size block per atlas tile)
+ let (columns, rows) = grid.map_or((1, 1), |grid| (grid.cols, grid.rows));
+ let (width, height) = match s.doc.baked.get(&ts).filter(|baked| !baked.maps.is_empty()) {
+ Some(baked) => (baked.resolution, baked.maps.keys().next().map_or(baked.resolution, |other| baked.height(*other))),
+ None => {
+ let (width, height) = texture_set.bake.common.output_size();
+ (width.saturating_mul(columns), height.saturating_mul(rows))
+ }
+ };
+ let empty = width == 0 || height == 0;
+ let too_many_texels = u64::from(width) * u64::from(height) > texturecraft_bake::MAX_TEXELS;
+ let too_wide = grid.is_none() && width > MAX_RESOLUTION;
+ if empty || too_many_texels || too_wide {
+ return Err(bad(cmd, format!("mesh map size {width} × {height} is too large or empty")));
+ }
+
+ Ok((width, height))
+}
+
+/// The image of every UV tile of a set: `name` with its tile number (`ao.1001.png`) swapped for each tile's
+fn tile_images(images: &ImageStore, cmd: &str, name: &str, tiles: &[u32]) -> Result>> {
+ let tile_at =
+ udim_in(name).ok_or_else(|| bad(cmd, format!("`{name}` names no UV tile: a UV-tiled set takes one image per tile, named like ao.1001.png")))?;
+ let (before_tile, after_tile) = (name.get(..tile_at).unwrap_or_default(), name.get(tile_at + 4..).unwrap_or_default());
tiles
.iter()
- .map(|&t| {
- let tile_name = format!("{}{t}{}", name.get(..at).unwrap_or_default(), name.get(at + 4..).unwrap_or_default());
- images.get(&tile_name).cloned().map(|img| (t, img)).ok_or_else(|| bad(CMD, format!("no image `{tile_name}` for UV tile {t}")))
+ .map(|&tile| {
+ let tile_name = format!("{before_tile}{tile}{after_tile}");
+ images.get(&tile_name).cloned().map(|image| (tile, image)).ok_or_else(|| bad(cmd, format!("no image `{tile_name}` for UV tile {tile}")))
})
.collect()
}
+/// The UV tile number in a file name (`Body_ao.1002.png` → 1002)
+pub(crate) fn tile_number(file_name: &str) -> Option {
+ udim_in(file_name).and_then(|at| file_name.get(at..at + 4)).and_then(|digits| digits.parse().ok())
+}
+
/// Where the last UDIM tile number (four digits alone, in [`UDIM_RANGE`]) in `name` starts.
fn udim_in(name: &str) -> Option {
let b = name.as_bytes();
diff --git a/crates/engine/src/meshmap_file_name.rs b/crates/engine/src/meshmap_file_name.rs
new file mode 100644
index 00000000..fde32d5e
--- /dev/null
+++ b/crates/engine/src/meshmap_file_name.rs
@@ -0,0 +1,159 @@
+//! Which texture set and mesh map a baked map file is for, by file name (`Body_ao.1001.png` = Body's ambient occlusion)
+
+use std::path::Path;
+
+use texturecraft_core::{BakedMap, UDIM_RANGE};
+
+/// Mesh maps named by two words anywhere in the file name; they win over the one-word names
+const TWO_WORD_NAMES: &[(&str, &[&str], BakedMap)] = &[
+ ("world", &["normal", "normals"], BakedMap::WorldNormal),
+ ("bent", &["normal", "normals"], BakedMap::BentNormal),
+ ("ambient", &["occlusion"], BakedMap::AmbientOcclusion),
+];
+
+/// Mesh maps named by one word, including the two-word names written as one
+const ONE_WORD_NAMES: &[(&str, BakedMap)] = &[
+ ("worldnormal", BakedMap::WorldNormal),
+ ("worldnormals", BakedMap::WorldNormal),
+ ("bentnormal", BakedMap::BentNormal),
+ ("bentnormals", BakedMap::BentNormal),
+ ("ambientocclusion", BakedMap::AmbientOcclusion),
+ ("normal", BakedMap::Normal),
+ ("normals", BakedMap::Normal),
+ ("nrm", BakedMap::Normal),
+ ("occlusion", BakedMap::AmbientOcclusion),
+ ("ao", BakedMap::AmbientOcclusion),
+ ("curvature", BakedMap::Curvature),
+ ("curv", BakedMap::Curvature),
+ ("id", BakedMap::Id),
+ ("position", BakedMap::Position),
+ ("pos", BakedMap::Position),
+ ("thickness", BakedMap::Thickness),
+ ("height", BakedMap::Height),
+ ("displacement", BakedMap::Height),
+ ("opacity", BakedMap::Opacity),
+ ("alpha", BakedMap::Opacity),
+];
+
+fn is_separator(c: char) -> bool {
+ matches!(c, '_' | '-' | '.' | ' ')
+}
+
+/// The lowercase file name without its folder and extension
+fn lowercase_stem(path: &str) -> String {
+ Path::new(path).file_stem().and_then(|stem| stem.to_str()).unwrap_or_default().to_lowercase()
+}
+
+/// What follows `set_name` at the start of a lowercase stem, when a separator follows it
+fn after_set_name<'a>(stem: &'a str, set_name: &str) -> Option<&'a str> {
+ if set_name.is_empty() {
+ return None;
+ }
+
+ stem.strip_prefix(&set_name.to_lowercase()).filter(|rest| rest.starts_with(is_separator))
+}
+
+/// The mesh map a file holds, from the words of its name after `set_name`; the last recognised word wins
+pub(crate) fn baked_map_from_file_name(path: &str, set_name: &str) -> Option {
+ let stem = lowercase_stem(path);
+ let rest = after_set_name(&stem, set_name).unwrap_or(&stem);
+ let is_tile_number = |word: &str| word.len() == 4 && word.parse::().is_ok_and(|number| UDIM_RANGE.contains(&number));
+ let words: Vec<&str> = rest.split(is_separator).filter(|word| !word.is_empty() && !is_tile_number(word)).collect();
+
+ let has = |name: &str| words.contains(&name);
+ TWO_WORD_NAMES
+ .iter()
+ .find(|(first, seconds, _)| has(first) && seconds.iter().any(|second| has(second)))
+ .map(|(_, _, map)| *map)
+ .or_else(|| words.iter().rev().find_map(|word| ONE_WORD_NAMES.iter().find(|(name, _)| name == word).map(|(_, map)| *map)))
+}
+
+/// The set a file is for: the longest set name its name starts with before a separator (any name with one set)
+pub(crate) fn texture_set_from_file_name(path: &str, set_names: &[&str]) -> Option {
+ if set_names.len() == 1 {
+ return Some(0);
+ }
+
+ let stem = lowercase_stem(path);
+ set_names.iter().enumerate().filter(|(_, name)| after_set_name(&stem, name).is_some()).max_by_key(|(_, name)| name.chars().count()).map(|(ts, _)| ts)
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn each_word_names_its_map() {
+ let cases = [
+ ("Body_normal.png", BakedMap::Normal),
+ ("Body_normals.png", BakedMap::Normal),
+ ("Body_nrm.png", BakedMap::Normal),
+ ("Body_world_normal.png", BakedMap::WorldNormal),
+ ("Body_normals_world.png", BakedMap::WorldNormal),
+ ("Body_WorldNormal.png", BakedMap::WorldNormal),
+ ("Body_bent_normals.png", BakedMap::BentNormal),
+ ("Body-ambient-occlusion.png", BakedMap::AmbientOcclusion),
+ ("Body_AmbientOcclusion.png", BakedMap::AmbientOcclusion),
+ ("Body_occlusion.png", BakedMap::AmbientOcclusion),
+ ("Body AO.png", BakedMap::AmbientOcclusion),
+ ("Body_curvature.png", BakedMap::Curvature),
+ ("Body_curv.png", BakedMap::Curvature),
+ ("Body_ID.png", BakedMap::Id),
+ ("Body_position.png", BakedMap::Position),
+ ("Body_pos.png", BakedMap::Position),
+ ("Body_thickness.png", BakedMap::Thickness),
+ ("Body_height.png", BakedMap::Height),
+ ("Body_displacement.png", BakedMap::Height),
+ ("Body_opacity.png", BakedMap::Opacity),
+ ("Body_alpha.png", BakedMap::Opacity),
+ ];
+ for (file, map) in cases {
+ assert_eq!(baked_map_from_file_name(file, "Body"), Some(map), "{file}");
+ }
+ }
+
+ #[test]
+ fn tile_numbers_and_folders_are_ignored() {
+ assert_eq!(baked_map_from_file_name("/bakes/Body_ao.1001.png", "Body"), Some(BakedMap::AmbientOcclusion));
+ assert_eq!(baked_map_from_file_name("Body_normal_1002.tga", "Body"), Some(BakedMap::Normal));
+ assert_eq!(texture_set_from_file_name("/bakes/Body_ao.1001.png", &["Head", "Body"]), Some(1));
+ }
+
+ #[test]
+ fn unknown_words_match_no_map() {
+ assert_eq!(baked_map_from_file_name("Body_diffuse.png", "Body"), None);
+ assert_eq!(baked_map_from_file_name("Body_1001.png", "Body"), None);
+ assert_eq!(baked_map_from_file_name("ambient.png", "Body"), None);
+ assert_eq!(baked_map_from_file_name("", "Body"), None);
+ }
+
+ #[test]
+ fn the_set_name_is_not_read_as_a_map() {
+ assert_eq!(baked_map_from_file_name("World_normal.png", "World"), Some(BakedMap::Normal));
+ assert_eq!(baked_map_from_file_name("ID_diffuse.png", "ID"), None);
+ assert_eq!(baked_map_from_file_name("Body_ao.png", ""), Some(BakedMap::AmbientOcclusion));
+ }
+
+ #[test]
+ fn the_longest_set_name_wins() {
+ let sets = ["Body", "Body_Upper", "Head"];
+ assert_eq!(texture_set_from_file_name("Body_Upper_ao.png", &sets), Some(1));
+ assert_eq!(texture_set_from_file_name("body_ao.png", &sets), Some(0));
+ assert_eq!(texture_set_from_file_name("HEAD-normal.png", &sets), Some(2));
+ }
+
+ #[test]
+ fn a_set_name_must_end_at_a_separator() {
+ let sets = ["Body", "Head"];
+ assert_eq!(texture_set_from_file_name("Bodywork_ao.png", &sets), None);
+ assert_eq!(texture_set_from_file_name("Arm_ao.png", &sets), None);
+ assert_eq!(texture_set_from_file_name("Body.png", &sets), None);
+ }
+
+ #[test]
+ fn one_set_takes_every_file() {
+ assert_eq!(texture_set_from_file_name("ao.png", &["Body"]), Some(0));
+ assert_eq!(texture_set_from_file_name("Head_ao.png", &["Body"]), Some(0));
+ assert_eq!(texture_set_from_file_name("ao.png", &[]), None);
+ }
+}
diff --git a/crates/engine/src/meshmap_import_cmds.rs b/crates/engine/src/meshmap_import_cmds.rs
new file mode 100644
index 00000000..20913de2
--- /dev/null
+++ b/crates/engine/src/meshmap_import_cmds.rs
@@ -0,0 +1,162 @@
+//! Import mesh maps baked in another app: many files at once, each to the set and slot its file name names
+
+use std::collections::BTreeMap;
+use std::path::Path;
+
+use serde_json::{Value, json};
+use texturecraft_core::BakedMap;
+
+use crate::commands::{CommandSpec, always, bad, strp};
+use crate::meshmap_cmds::{FIRST_TILE, image_map_size, tile_number, use_images};
+use crate::meshmap_file_name::{baked_map_from_file_name, texture_set_from_file_name};
+use crate::resource_cmds::read_image_file;
+use crate::{Result, Session, cmd};
+
+const CMD: &str = "textureSet.meshMap.import";
+
+/// Most files one import takes: every mesh map of dozens of sets, each split over a few UV tiles
+const MAX_FILES: usize = 512;
+
+/// Bound retained file bytes, decoded RGBA floats and resampled maps together, before allocating pixels
+const MAX_TOTAL_BYTES: u64 = 2 << 30;
+
+pub fn specs() -> Vec {
+ vec![cmd!(
+ "textureSet.meshMap.import",
+ "Import baked maps",
+ [],
+ None,
+ "{files: [{path, map?: mesh map id}]} → {assigned: [{path, ts, map}], unmatched: [path]} — each image file becomes the mesh map its name names (`Body_ao.png`, `Body_world_normal.png`; or `map`) of the texture set its name starts with (any name when there is one set), read as by textureSet.meshMap.set. A UV-tiled set takes one file per tile, named with the tile number (`Body_ao.1001.png`, `Body_ao.1002.png`). Left out and listed in `unmatched`: files matching no set or map, a second file for one slot or tile, files of a UV-tiled set without one of its tile numbers, and every file of a map missing a tile. One undo step (none when nothing matches); at most 512 files and 2 GiB of file bytes, decoded images and mesh maps; desktop only",
+ always,
+ import
+ )]
+}
+
+fn import(s: &mut Session, p: &Value) -> Result {
+ import_with_budget(s, p, MAX_TOTAL_BYTES)
+}
+
+fn import_with_budget(s: &mut Session, p: &Value, max_bytes: u64) -> Result {
+ let files = p.get("files").and_then(Value::as_array).ok_or_else(|| bad(CMD, "`files` (a list of {path, map?}) is required"))?;
+ if files.len() > MAX_FILES {
+ return Err(bad(CMD, format!("at most {MAX_FILES} files at once")));
+ }
+
+ let set_names: Vec<&str> = s.doc.project.texture_sets.iter().map(|set| set.name.as_str()).collect();
+ let mut slots: BTreeMap<(usize, BakedMap), BTreeMap> = BTreeMap::new();
+ let mut unmatched = Vec::new();
+ for file in files {
+ let path = strp(file, "path").ok_or_else(|| bad(CMD, "every file needs a `path`"))?;
+ let given_map = match file.get("map") {
+ None | Some(Value::Null) => None,
+ Some(Value::String(id)) => Some(BakedMap::parse(id).ok_or_else(|| bad(CMD, format!("unknown mesh map `{id}`")))?),
+ Some(_) => return Err(bad(CMD, "`map` must be a mesh map id string")),
+ };
+
+ match slot_of(s, &set_names, path, given_map) {
+ Some((slot, tile)) if !slots.get(&slot).is_some_and(|tiles| tiles.contains_key(&tile)) => {
+ slots.entry(slot).or_default().insert(tile, path);
+ }
+ _ => unmatched.push(path),
+ }
+ }
+
+ // A UV-tiled map needs a file for every tile of its set
+ slots.retain(|(ts, _), tiles| {
+ let complete =
+ s.doc.project.texture_sets.get(*ts).is_some_and(|set| set.tile_grid().is_none() || set.uv_tiles.iter().all(|tile| tiles.contains_key(tile)));
+ if !complete {
+ unmatched.extend(tiles.values());
+ }
+ complete
+ });
+ if slots.is_empty() {
+ return Ok(json!({ "assigned": [], "unmatched": unmatched }));
+ }
+
+ let result = s.edit("Import baked maps", |s| {
+ let mut assigned = Vec::new();
+ let mut remaining_bytes = max_bytes;
+ for ((ts, map), tiles) in &slots {
+ let (width, height) = image_map_size(s, CMD, *ts)?;
+ let map_bytes = u64::from(width) * u64::from(height) * map.components() as u64 * size_of::() as u64;
+ reserve_bytes(&mut remaining_bytes, map_bytes)?;
+
+ let mut images = BTreeMap::new();
+ for (tile, path) in tiles {
+ let bytes = read_image_file(CMD, path, remaining_bytes)?;
+ reserve_bytes(&mut remaining_bytes, bytes.len() as u64)?;
+
+ let bytes_per_texel = size_of::<[f32; 4]>() as u64;
+ let name = s.add_image_resource(path, bytes, remaining_bytes / bytes_per_texel)?;
+ let image = s.images.get(&name).ok_or_else(|| bad(CMD, format!("no decoded image `{name}`")))?;
+ reserve_bytes(&mut remaining_bytes, u64::from(image.width) * u64::from(image.height) * bytes_per_texel)?;
+ images.insert(*tile, image.clone());
+ assigned.push(json!({"path": path, "ts": ts, "map": map.id()}));
+ }
+ use_images(s, CMD, *ts, *map, &images)?;
+ }
+ Ok(assigned)
+ });
+ // A failed edit leaves the document as it was; forget the images it decoded
+ if result.is_err() {
+ s.sync_images();
+ }
+
+ Ok(json!({ "assigned": result?, "unmatched": unmatched }))
+}
+
+fn reserve_bytes(remaining_bytes: &mut u64, bytes: u64) -> Result<()> {
+ *remaining_bytes = remaining_bytes.checked_sub(bytes).ok_or_else(|| bad(CMD, "the files, decoded images and mesh maps exceed the import memory budget"))?;
+ Ok(())
+}
+
+/// The texture set and mesh map a file is for, and its UV tile ([`FIRST_TILE`] on a set without UV tiles)
+fn slot_of(s: &Session, set_names: &[&str], path: &str, given_map: Option) -> Option<((usize, BakedMap), u32)> {
+ let ts = texture_set_from_file_name(path, set_names)?;
+ let map = given_map.or_else(|| baked_map_from_file_name(path, set_names.get(ts).copied().unwrap_or_default()))?;
+ let texture_set = s.doc.project.texture_sets.get(ts)?;
+ let tile = match texture_set.tile_grid() {
+ Some(_) => tile_number(Path::new(path).file_name()?.to_str()?).filter(|tile| texture_set.uv_tiles.contains(tile))?,
+ None => FIRST_TILE,
+ };
+ Some(((ts, map), tile))
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use texturecraft_core::BakeResolution;
+
+ #[test]
+ fn import_budget_counts_decoded_images_and_resampled_maps() {
+ let dir = std::env::temp_dir().join(format!("texturecraft-import-budget-{}", std::process::id()));
+ std::fs::create_dir_all(&dir).unwrap();
+ let paths = [dir.join("ao.png"), dir.join("height.png")];
+ for path in &paths {
+ image::RgbaImage::from_pixel(16, 16, image::Rgba([128, 128, 128, 255])).save(path).unwrap();
+ }
+ let file_bytes: u64 = paths.iter().map(|path| std::fs::metadata(path).unwrap().len()).sum();
+ let decoded_bytes = 2 * 16 * 16 * 16;
+ let map_bytes = 2 * 16 * 16 * 4;
+ let required_bytes = file_bytes + decoded_bytes + map_bytes;
+ let params = json!({"files": paths.map(|path| json!({"path": path}))});
+ let mut session = Session::new_project("budget", texturecraft_geom::primitives::cube(2.0), "builtin:cube", None, 128).unwrap();
+ session.doc.project.texture_sets[0].bake.common.resolution = BakeResolution::R16;
+ let revision = session.revision;
+
+ for budget in [file_bytes, file_bytes + decoded_bytes, required_bytes - 1] {
+ let result = import_with_budget(&mut session, ¶ms, budget);
+ assert!(result.is_err(), "budget {budget} must cover decoded pixels and mesh maps: {result:?}");
+ assert!(session.doc.resources.is_empty() && session.images.is_empty());
+ assert!(session.doc.baked.values().all(|baked| baked.maps.is_empty()));
+ assert_eq!(session.revision, revision);
+ assert!(!session.modified);
+ assert!(session.undo_label().is_none());
+ }
+
+ let result = import_with_budget(&mut session, ¶ms, required_bytes).unwrap();
+ assert_eq!(result["assigned"].as_array().unwrap().len(), 2);
+ std::fs::remove_dir_all(dir).unwrap();
+ }
+}
diff --git a/crates/engine/src/mask_preview_camera.rs b/crates/engine/src/orb_camera.rs
similarity index 69%
rename from crates/engine/src/mask_preview_camera.rs
rename to crates/engine/src/orb_camera.rs
index ea3d6d1f..d0015361 100644
--- a/crates/engine/src/mask_preview_camera.rs
+++ b/crates/engine/src/orb_camera.rs
@@ -1,4 +1,4 @@
-//! Cached camera rays for one smart mask preview size
+//! Cached camera rays for one preview orb size
use std::collections::HashMap;
@@ -11,11 +11,11 @@ use crate::Session;
const CAMERA_PITCH_DEG: f32 = 35.0;
const CAMERA_YAW_DEG: f32 = -34.4;
-/// Index into [`MaskPreviewCamera::texels`] and view-space normal; None on a miss
+/// Index into [`OrbCamera::texels`] and view-space normal; None on a miss
pub(crate) type CameraSample = Option<(usize, Vec3)>;
-/// What each ray of a square orthographic view of the preview shape sees
-pub(crate) struct MaskPreviewCamera {
+/// What each ray of a square orthographic view of the orb sees
+pub(crate) struct OrbCamera {
/// Rays along each side of the view
pub rays_per_side: usize,
/// The texels (x, y) the camera sees, each once
@@ -24,12 +24,12 @@ pub(crate) struct MaskPreviewCamera {
pub samples: Vec,
}
-impl MaskPreviewCamera {
+impl OrbCamera {
/// Trace a square orthographic view onto a `texture_px²` texture
- pub fn new(session: &Session, texture_px: u32, rays_per_side: usize) -> MaskPreviewCamera {
- let (lo, hi) = session.mesh.bounds();
- let center = (lo + hi) * 0.5;
- let radius = session.mesh.positions.iter().map(|p| p.distance(center)).fold(0.0f32, f32::max);
+ pub fn new(session: &Session, texture_px: u32, rays_per_side: usize) -> OrbCamera {
+ let (min, max) = session.mesh.bounds();
+ let center = (min + max) * 0.5;
+ let radius = session.mesh.positions.iter().map(|position| position.distance(center)).fold(0.0f32, f32::max);
let pitch = CAMERA_PITCH_DEG.to_radians();
let turn = Quat::from_rotation_y(CAMERA_YAW_DEG.to_radians());
let forward = turn * Vec3::new(0.0, -pitch.sin(), -pitch.cos());
@@ -40,9 +40,9 @@ impl MaskPreviewCamera {
let mut texels = Vec::new();
let mut index_of = HashMap::new();
let samples = (0..rays_per_side * rays_per_side)
- .map(|i| {
+ .map(|ray| {
let side = rays_per_side as f32;
- let ndc = Vec2::new(((i % rays_per_side) as f32 + 0.5) / side * 2.0 - 1.0, 1.0 - ((i / rays_per_side) as f32 + 0.5) / side * 2.0);
+ let ndc = Vec2::new(((ray % rays_per_side) as f32 + 0.5) / side * 2.0 - 1.0, 1.0 - ((ray / rays_per_side) as f32 + 0.5) / side * 2.0);
// Start well outside the shape so every ray enters it from the front
let origin = center + (right * ndc.x + up * ndc.y) * radius - forward * radius * 4.0;
let hit = session.bvh.closest(origin, forward, radius * 8.0)?;
@@ -52,10 +52,12 @@ impl MaskPreviewCamera {
texels.push(texel);
texels.len() - 1
});
- let n = surface.nrm;
- Some((index, Vec3::new(n.dot(right), n.dot(up), -n.dot(forward))))
+
+ let normal = surface.nrm;
+ Some((index, Vec3::new(normal.dot(right), normal.dot(up), -normal.dot(forward))))
})
.collect();
- MaskPreviewCamera { rays_per_side, texels, samples }
+
+ OrbCamera { rays_per_side, texels, samples }
}
}
diff --git a/crates/engine/src/orb_preview.rs b/crates/engine/src/orb_preview.rs
new file mode 100644
index 00000000..f29a247d
--- /dev/null
+++ b/crates/engine/src/orb_preview.rs
@@ -0,0 +1,297 @@
+//! Smart mask and smart material previews share one baked [`primitives::preview_orb`]
+//! Presets use `mask.smart.apply`, materials use [`materials::apply`], both read back from the compositor
+
+use std::collections::{BTreeMap, BTreeSet};
+
+use serde_json::json;
+use texturecraft_core::{BakeResolution, BakedMap, Channel, CurvatureMethod, LayerId};
+use texturecraft_geom::glam::Vec3;
+use texturecraft_geom::primitives;
+use texturecraft_texel::TILE;
+
+pub use crate::mask_preview_pixel::MaskPreviewPixel;
+pub use crate::material_preview_pixel::MaterialPreviewPixel;
+use crate::orb_camera::OrbCamera;
+use crate::preview::Sample;
+use crate::session::Document;
+use crate::{EngineError, Result, Session, materials};
+
+/// Bake resolution in texels; 256 loses the thin edge lines
+const TEXTURE_PX: u32 = 512;
+/// Camera rays per preview pixel along each axis (anti-aliased outline)
+const SUPERSAMPLE: usize = 2;
+/// Bound camera samples and output allocations for shelf previews
+pub const MAX_PREVIEW_SIZE_PX: usize = 512;
+/// AO and thickness rays per texel; thumbnail detail needs fewer than the default
+const OCCLUSION_RAYS: u32 = 12;
+/// Curvature rays per texel; thumbnail detail needs fewer than the default
+const CURVATURE_RAYS: u32 = 12;
+/// Radius relative to the bounding box; isolates panel edges from the round body
+const CURVATURE_RADIUS: f32 = 0.005;
+/// The mesh maps the smart mask generators read; smart materials build on the same presets
+const MAPS: [BakedMap; 3] = [BakedMap::Curvature, BakedMap::AmbientOcclusion, BakedMap::Thickness];
+/// Keep camera views for the thumbnail and hover preview sizes
+const CAMERAS_KEPT: usize = 2;
+/// The channels a material preview shows, in [`Sample`] order
+const MATERIAL_CHANNELS: [Channel; 4] = [Channel::BaseColor, Channel::Metallic, Channel::Roughness, Channel::Height];
+/// The orb's only texture set
+const SET: usize = 0;
+
+/// The baked orb and, per preview size, what its camera sees
+pub struct OrbPreview {
+ session: Session,
+ /// The layer smart masks are applied to
+ layer: LayerId,
+ /// The baked document and selection, restored before each material
+ bare: (Document, BTreeMap),
+ /// Cached camera views, least recently used first
+ cameras: Vec,
+}
+
+impl OrbPreview {
+ /// Bake the orb once (previews of any size reuse it)
+ pub fn new() -> Result {
+ let mut session = Session::new_project("Orb preview", primitives::preview_orb(), "builtin:preview_orb", None, TEXTURE_PX)?;
+ let set = session.doc.project.texture_set_mut(SET)?;
+ set.bake.common.resolution = BakeResolution::from_pixels(TEXTURE_PX).ok_or_else(|| EngineError::Other("invalid bake resolution".into()))?;
+ set.bake.high_poly.use_low_as_high = true;
+ set.bake.maps.curvature.parameters.method = CurvatureMethod::Mesh;
+ set.bake.maps.curvature.parameters.mesh.sampling_radius = CURVATURE_RADIUS;
+ set.bake.maps.curvature.parameters.mesh.rays = CURVATURE_RAYS;
+ set.bake.maps.ao.parameters.rays.rays = OCCLUSION_RAYS;
+ set.bake.maps.thickness.parameters.rays.rays = OCCLUSION_RAYS;
+ for map in BakedMap::ALL {
+ set.bake.maps.set_enabled(map, MAPS.contains(&map));
+ }
+ let layer = *set.stack.first().ok_or_else(|| EngineError::Other("the preview has no layer".into()))?;
+ session.bake_now(SET, false)?;
+
+ let bare = (session.doc.clone(), session.selected.clone());
+ Ok(OrbPreview { session, layer, bare, cameras: Vec::new() })
+ }
+
+ /// Row-major `size²` pixels of smart mask `id`, with None outside the shape
+ /// Returns None for unknown masks or sizes outside 1..=[`MAX_PREVIEW_SIZE_PX`]
+ pub fn mask(&mut self, id: &str, size: usize) -> Option>> {
+ if !valid_size(size) {
+ return None;
+ }
+
+ crate::execute(&mut self.session, "mask.smart.apply", &json!({ "name": id, "layer": self.layer.0 })).ok()?;
+ // Previews need no undo history; retaining snapshots grows memory across presets
+ self.session.undo.clear();
+
+ let camera = camera_for(&mut self.cameras, &self.session, size)?;
+ let values = self.session.mask_at(self.layer, &camera.texels)?;
+
+ let sub_pixels = (SUPERSAMPLE * SUPERSAMPLE) as f32;
+ let pixels = (0..size * size)
+ .map(|pixel| {
+ let (mut mask_sum, mut normal_sum, mut hits) = (0.0, Vec3::ZERO, 0.0);
+ for (texel, normal) in pixel_hits(camera, size, pixel) {
+ mask_sum += values.get(texel).copied().unwrap_or(0.0);
+ normal_sum += normal;
+ hits += 1.0;
+ }
+
+ (hits > 0.0).then(|| MaskPreviewPixel { mask: mask_sum / hits, normal: normal_sum.normalize_or_zero(), coverage: hits / sub_pixels })
+ })
+ .collect();
+ Some(pixels)
+ }
+
+ /// Row-major `size²` pixels of built-in material `id`, with None outside the shape
+ /// Returns None for unknown materials or sizes outside 1..=[`MAX_PREVIEW_SIZE_PX`]
+ pub fn material(&mut self, id: &str, size: usize) -> Option>> {
+ if !valid_size(size) {
+ return None;
+ }
+
+ // Each material goes on the bare shape, not over the previous one
+ (self.session.doc, self.session.selected) = self.bare.clone();
+ let applied = materials::apply(&mut self.session, id);
+ // Previews need no undo history; retaining snapshots grows memory across materials
+ self.session.undo.clear();
+ applied.ok()?;
+
+ let camera = camera_for(&mut self.cameras, &self.session, size)?;
+ let values = material_at(&self.session, &camera.texels)?;
+
+ let sub_pixels = (SUPERSAMPLE * SUPERSAMPLE) as f32;
+ let pixels = (0..size * size)
+ .map(|pixel| {
+ let mut sum = Sample { base: [0.0; 3], metallic: 0.0, roughness: 0.0, height: 0.0 };
+ let (mut normal_sum, mut hits) = (Vec3::ZERO, 0.0);
+ for (texel, normal) in pixel_hits(camera, size, pixel) {
+ let Some(value) = values.get(texel) else { continue };
+
+ sum.base = [0, 1, 2].map(|component| sum.base[component] + value.base[component]);
+ sum.metallic += value.metallic;
+ sum.roughness += value.roughness;
+ sum.height += value.height;
+ normal_sum += normal;
+ hits += 1.0;
+ }
+
+ (hits > 0.0).then(|| {
+ let mean = Sample {
+ base: sum.base.map(|component| component / hits),
+ metallic: sum.metallic / hits,
+ roughness: sum.roughness / hits,
+ height: sum.height / hits,
+ };
+ MaterialPreviewPixel { sample: mean, normal: normal_sum.normalize_or_zero(), coverage: hits / sub_pixels }
+ })
+ })
+ .collect();
+ Some(pixels)
+ }
+}
+
+/// Preview sizes the camera may allocate
+fn valid_size(size: usize) -> bool {
+ (1..=MAX_PREVIEW_SIZE_PX).contains(&size)
+}
+
+/// The rays through `pixel` of a `size²` preview that hit the shape, as (texel index, view-space normal)
+fn pixel_hits(camera: &OrbCamera, size: usize, pixel: usize) -> impl Iterator- + '_ {
+ let (x, y) = (pixel % size, pixel / size);
+ (0..SUPERSAMPLE * SUPERSAMPLE).filter_map(move |sub_pixel| {
+ let (sub_x, sub_y) = (sub_pixel % SUPERSAMPLE, sub_pixel / SUPERSAMPLE);
+ let ray = (y * SUPERSAMPLE + sub_y) * camera.rays_per_side + x * SUPERSAMPLE + sub_x;
+ camera.samples.get(ray).copied().flatten()
+ })
+}
+
+/// The material values at `texels`, compositing only the tiles that hold them
+fn material_at(session: &Session, texels: &[(u32, u32)]) -> Option
> {
+ let tiles: BTreeSet<(u32, u32)> = texels.iter().map(|(x, y)| (x / TILE, y / TILE)).collect();
+ let tiles: Vec<(u32, u32)> = tiles.into_iter().collect();
+
+ session.with_inputs(SET, |inputs| {
+ let mut composite = texturecraft_compose::Composite::new(&MATERIAL_CHANNELS, TEXTURE_PX);
+ texturecraft_compose::composite_tiles(inputs, &mut composite, &tiles);
+
+ let samples = texels
+ .iter()
+ .map(|&(x, y)| {
+ let [base, metallic, roughness, height] = MATERIAL_CHANNELS.map(|channel| composite.value(channel, x, y));
+ Sample { base, metallic: metallic[0], roughness: roughness[0], height: height[0] }
+ })
+ .collect();
+ Some(samples)
+ })
+}
+
+/// Cache one camera per preview size, evicting the least recently used view
+fn camera_for<'a>(cameras: &'a mut Vec, session: &Session, size: usize) -> Option<&'a OrbCamera> {
+ let rays_per_side = size * SUPERSAMPLE;
+ let camera = match cameras.iter().position(|camera| camera.rays_per_side == rays_per_side) {
+ Some(index) => cameras.remove(index),
+ None => OrbCamera::new(session, TEXTURE_PX, rays_per_side),
+ };
+ if cameras.len() >= CAMERAS_KEPT {
+ cameras.remove(0);
+ }
+
+ cameras.push(camera);
+ cameras.last()
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ /// Mean absolute difference of the masks of two previews over the pixels both see
+ fn difference(a: &[Option], b: &[Option]) -> f32 {
+ let pairs: Vec<(f32, f32)> = a.iter().zip(b).filter_map(|(a, b)| Some((a.as_ref()?.mask, b.as_ref()?.mask))).collect();
+ pairs.iter().map(|(a, b)| (a - b).abs()).sum::() / pairs.len().max(1) as f32
+ }
+
+ /// Mean mask value over the pixels a preview sees
+ fn mean_mask(pixels: &[Option]) -> f32 {
+ pixels.iter().flatten().map(|pixel| pixel.mask).sum::() / pixels.iter().flatten().count().max(1) as f32
+ }
+
+ #[test]
+ fn invalid_preview_sizes_are_rejected_before_changing_the_shape() {
+ let session = Session::new_project("Orb preview", primitives::cube(2.0), "builtin:cube", None, 128).unwrap();
+ let layer = session.doc.project.texture_set(SET).unwrap().stack[0];
+ let bare = (session.doc.clone(), session.selected.clone());
+ let mut preview = OrbPreview { session, layer, bare, cameras: Vec::new() };
+ let stack_size = preview.session.doc.project.texture_set(SET).unwrap().stack.len();
+ for size in [0, MAX_PREVIEW_SIZE_PX + 1, usize::MAX / 2 + 1, usize::MAX] {
+ assert!(preview.mask("edges_sharp", size).is_none(), "size {size} should be rejected before rendering");
+ assert!(preview.material("steel_painted_worn", size).is_none(), "size {size} should be rejected before rendering");
+ assert!(preview.cameras.is_empty(), "invalid sizes must not allocate a camera");
+ assert!(preview.session.doc.project.layer(layer).unwrap().mask.is_none(), "invalid sizes must not apply a mask");
+ assert_eq!(preview.session.doc.project.texture_set(SET).unwrap().stack.len(), stack_size, "invalid sizes must not apply a material");
+ }
+ }
+
+ #[test]
+ fn smart_mask_previews_are_in_range_tell_edges_from_cavities_and_render_at_any_size() {
+ let size = 24;
+ let mut preview = OrbPreview::new().unwrap();
+ for smart_mask in crate::smart_masks::SMART_MASKS {
+ let id = smart_mask.id;
+ let pixels = preview.mask(id, size).unwrap_or_else(|| panic!("{id}"));
+ assert_eq!(pixels.len(), size * size, "{id}");
+ assert!(pixels[0].is_none(), "{id}: the corners are outside the shape");
+
+ let seen: Vec<&MaskPreviewPixel> = pixels.iter().flatten().collect();
+ assert!(seen.len() > size * size / 3, "{id}: the shape fills the frame");
+ for pixel in seen {
+ assert!((0.0..=1.0).contains(&pixel.mask) && (0.0..=1.0).contains(&pixel.coverage) && pixel.coverage > 0.0, "{id}: {pixel:?}");
+ assert!(pixel.normal.is_finite(), "{id}: {pixel:?}");
+ }
+ }
+
+ let (edges, cavities) = (preview.mask("edges_sharp", size).unwrap(), preview.mask("dirt_cavities", size).unwrap());
+ let shows = |pixels: &[Option]| pixels.iter().flatten().any(|pixel| pixel.mask > 0.5);
+ assert!(shows(&edges) && shows(&cavities), "both masks find something on the shape");
+ assert!(difference(&edges, &cavities) > 0.05, "edges and cavities differ: {}", difference(&edges, &cavities));
+ assert!(preview.mask("nope", size).is_none());
+
+ // The same bake renders other sizes, showing the same mask
+ let big = preview.mask("edges_sharp", size * 3).unwrap();
+ assert_eq!(big.len(), size * size * 9);
+ assert!((mean_mask(&big) - mean_mask(&edges)).abs() < 0.05, "{} vs {}", mean_mask(&big), mean_mask(&edges));
+
+ preview.mask("edges_sharp", size * 2).unwrap();
+ assert_eq!(preview.cameras.len(), CAMERAS_KEPT, "only the most recent sizes keep their camera");
+ }
+
+ #[test]
+ fn smart_materials_render_on_the_orb_and_show_their_wear() {
+ let size = 24;
+ let mut preview = OrbPreview::new().unwrap();
+ for material in materials::MATERIALS.iter().filter(|material| material.smart) {
+ let id = material.id;
+ let pixels = preview.material(id, size).unwrap_or_else(|| panic!("{id}"));
+ assert_eq!(pixels.len(), size * size, "{id}");
+ assert!(pixels[0].is_none(), "{id}: the corners are outside the shape");
+
+ for pixel in pixels.iter().flatten() {
+ let sample = pixel.sample;
+ let values = sample.base.into_iter().chain([sample.metallic, sample.roughness, sample.height]);
+ assert!(values.into_iter().all(f32::is_finite), "{id}: {pixel:?}");
+ assert!(pixel.normal.is_finite() && pixel.coverage > 0.0, "{id}: {pixel:?}");
+ }
+ }
+ assert!(preview.material("nope", size).is_none());
+
+ // Paint chipped at the edges shows the steel under it: the smart material is not its base
+ let (worn, steel) = (preview.material("steel_painted_worn", size).unwrap(), preview.material("steel", size).unwrap());
+ let metallic_pixels = |pixels: &[Option]| pixels.iter().flatten().filter(|pixel| pixel.sample.metallic > 0.5).count();
+ let (worn_metallic, steel_metallic) = (metallic_pixels(&worn), metallic_pixels(&steel));
+ assert!(worn_metallic > 0 && worn_metallic < steel_metallic / 2, "bare steel only at the worn edges: {worn_metallic} of {steel_metallic}");
+
+ let base_colors = |pixels: &[Option]| pixels.iter().flatten().map(|pixel| pixel.sample.base).collect::>();
+ assert_ne!(base_colors(&worn), base_colors(&steel));
+
+ // Each material starts from the bare orb: rendering another one in between changes nothing
+ preview.material("iron_rusted", size).unwrap();
+ assert_eq!(preview.material("steel_painted_worn", size).unwrap(), worn);
+ }
+}
diff --git a/crates/engine/src/painting.rs b/crates/engine/src/painting.rs
index 6f2a74ff..6344311f 100644
--- a/crates/engine/src/painting.rs
+++ b/crates/engine/src/painting.rs
@@ -7,13 +7,23 @@ use texturecraft_compose::PaintTarget;
use texturecraft_core::{Channel, Effect, EffectKind, LayerId, LayerKind, Mask, MaskBackground};
use texturecraft_geom::glam::Vec2;
use texturecraft_paint::{
- CommitSource, EyeDepth, PickCtx, Pickup, PickupMode, RasterCtx, Shape, Staging, Stroke, StrokeCanvas, SurfaceHit, commit_layer, commit_mask,
- fill_triangles, pick, rasterize,
+ CommitSource, EyeDepth, PickCtx, Pickup, PickupMode, RasterCtx, Shape, Staging, Stroke, StrokeCanvas, SurfaceHit, commit_layer, commit_mask, pick,
+ rasterize,
};
-use crate::session::{ActiveStroke, CloneFrom, FillMode, Session, StackTarget, Tool};
+use crate::session::{ActiveStroke, CloneFrom, Session, StackTarget, Tool};
+use crate::uv_stroke_state::UvStrokeState;
use crate::{EngineError, Result};
+/// Shortest distance between 2D view stamps, so a stamp with no radius (a pen at zero pressure) can't stall a stroke.
+const MIN_UV_STAMP_STEP: f32 = 1e-5;
+
+/// 2D view stamps rasterized together, bounding the memory of one batch.
+const UV_STAMP_BATCH: usize = 4096;
+
+/// Covers a UV diagonal at the minimum step (about 142k stamps), including light pen pressure, while bounding hostile coordinates
+const MAX_UV_STAMPS_PER_SAMPLE: usize = 150_000;
+
impl Session {
/// Camera visibility for a stroke at `viewport` (cached until the camera, size or mesh change).
fn eye_depth(&mut self, viewport: Vec2) -> std::sync::Arc {
@@ -145,6 +155,7 @@ impl Session {
/// Common setup of 3D and 2D strokes. `first_uv` is where the stroke starts on the mesh
/// (the Clone tool's destination anchor).
fn start_stroke(&mut self, viewport: Vec2, uv_mode: bool, first_uv: Option) -> Result<()> {
+ self.refuse_while_baking()?;
let tool = self.tool.tool;
let erase = tool == Tool::Eraser;
let quick_mask = self.quick_mask.editing;
@@ -234,7 +245,7 @@ impl Session {
stroke,
canvas,
depth,
- uv: uv_mode.then_some((None, 0.0)),
+ uv: uv_mode.then(UvStrokeState::default),
camera: self.camera,
viewport,
values,
@@ -286,9 +297,18 @@ impl Session {
Some(texturecraft_compose::Stencil { image, view_proj: self.camera.view_proj(aspect), center, half, rotation, tile: st.tile })
}
+ /// Painting is paused while a bake preview shows the baked maps instead of the material.
+ pub(crate) fn refuse_while_baking(&self) -> Result<()> {
+ match self.painting_blocked() {
+ Some(why) => Err(EngineError::Other(why.into())),
+ None => Ok(()),
+ }
+ }
+
/// Start a stroke at `screen` (viewport pixels). Returns false when the cursor misses the
/// mesh (the stroke starts anyway and resumes when the cursor enters the mesh).
pub fn begin_stroke(&mut self, screen: Vec2, viewport: Vec2, pressure: f32) -> Result {
+ self.refuse_while_baking()?;
self.cancel_stroke();
match self.tool.tool {
Tool::PolygonFill => return self.polygon_fill(screen, viewport).map(|_| true),
@@ -301,12 +321,16 @@ impl Session {
Ok(self.continue_stroke(screen, pressure))
}
- /// Start a stroke in the 2D view at texture coordinate `uv`.
+ /// Start a stroke in the 2D view at texture coordinate `uv` (polygon fill fills there).
pub fn begin_stroke_uv(&mut self, uv: Vec2, pressure: f32) -> Result<()> {
+ self.refuse_while_baking()?;
self.cancel_stroke();
- if matches!(self.tool.tool, Tool::PolygonFill | Tool::ColorPicker | Tool::GeometryMask) {
- return Err(EngineError::Other("use this tool in the 3D view".into()));
+ match self.tool.tool {
+ Tool::PolygonFill => return self.polygon_fill_uv(uv).map(|_| ()),
+ Tool::ColorPicker | Tool::GeometryMask => return Err(EngineError::Other("use this tool in the 3D view".into())),
+ _ => {}
}
+
self.start_stroke(self.viewport, true, Some(uv))?;
self.continue_stroke_uv(uv, pressure);
Ok(())
@@ -314,40 +338,49 @@ impl Session {
/// Add a 2D view sample (texture coordinates). Brush size is relative to the UV square.
pub fn continue_stroke_uv(&mut self, uv: Vec2, pressure: f32) {
- let Some(st) = self.stroke.as_mut() else { return };
- let Some((last, carry)) = st.uv.as_mut() else { return };
- let Some(cache) = self.caches.get_mut(st.ts) else { return };
- let b = &st.stroke.settings;
- let p = pressure.clamp(0.0, 1.0);
- let radius = b.size * 2.0 * if p < 1.0 { b.min_size + (1.0 - b.min_size) * p } else { 1.0 };
- let step = (b.spacing * 2.0 * radius).max(1e-5);
- let mut points = Vec::new();
- match *last {
- None => points.push(uv),
- Some(prev) => {
- let seg = uv - prev;
- let len = seg.length();
- let mut t = step - *carry;
- while t <= len && points.len() < 4096 {
- points.push(prev + seg * (t / len.max(1e-9)));
- t += step;
- }
- *carry = len - (t - step);
- }
- }
- // Follow path: turn the stamp with the stroke direction (y up on screen, v grows down).
- let angle = match *last {
- Some(prev) if b.follow_path && uv != prev => b.angle + (prev.y - uv.y).atan2(uv.x - prev.x).to_degrees() - 90.0,
- _ => b.angle,
+ let Some(active) = self.stroke.as_mut() else { return };
+ let Some(progress) = active.uv.as_mut() else { return };
+ let Some(cache) = self.caches.get_mut(active.ts) else { return };
+
+ let settings = &active.stroke.settings;
+ let pressure = pressure.clamp(0.0, 1.0);
+ let size_scale = if pressure < 1.0 { settings.min_size + (1.0 - settings.min_size) * pressure } else { 1.0 };
+ let radius = settings.size * 2.0 * size_scale;
+ let step = (settings.spacing * 2.0 * radius).max(MIN_UV_STAMP_STEP);
+
+ // Follow path: turn the stamp with the stroke direction (y up on screen, v grows down)
+ let angle = match progress.last {
+ Some(previous) if settings.follow_path && uv != previous => settings.angle + (previous.y - uv.y).atan2(uv.x - previous.x).to_degrees() - 90.0,
+ _ => settings.angle,
};
- *last = Some(uv);
- let n0 = st.stroke.stamps.len() as u32;
- let stamps: Vec = points
- .iter()
- .enumerate()
- .map(|(i, c)| texturecraft_paint::UvStamp { center: *c, radius, angle, flow: b.flow, hardness: b.hardness, seed: n0 + i as u32 })
- .collect();
- texturecraft_paint::rasterize_uv(&mut st.canvas, &cache.gbuf, Self::shape(&self.images, b), &stamps);
+
+ // The first sample is one stamp; a later one stamps every `step` along the segment from the previous
+ let (start, segment, mut distance) = match progress.last.replace(uv) {
+ None => (uv, Vec2::ZERO, 0.0),
+ // Pressure can shrink the step below the carry from the preceding sample
+ Some(previous) => (previous, uv - previous, (step - progress.carry).max(0.0)),
+ };
+ let length = segment.length();
+ let shape = Self::shape(&self.images, settings);
+ let mut batch = Vec::new();
+ let mut stamped = 0;
+ while distance <= length && stamped < MAX_UV_STAMPS_PER_SAMPLE {
+ let batch_size = UV_STAMP_BATCH.min(MAX_UV_STAMPS_PER_SAMPLE - stamped);
+ batch.clear();
+ while distance <= length && batch.len() < batch_size {
+ let center = start + segment * (distance / length.max(f32::MIN_POSITIVE));
+ let seed = progress.stamps.wrapping_add((stamped + batch.len()) as u32);
+ batch.push(texturecraft_paint::UvStamp { center, radius, angle, flow: settings.flow, hardness: settings.hardness, seed });
+ distance += step;
+ }
+
+ stamped += batch.len();
+ texturecraft_paint::rasterize_uv(&mut active.canvas, &cache.gbuf, shape, &batch);
+ }
+
+ // At most one step, so a segment cut off at the stamp limit can't push the next one's stamps backwards
+ progress.carry = (length - (distance - step)).min(step);
+ progress.stamps = progress.stamps.wrapping_add(stamped as u32);
self.stroke_painted();
}
@@ -482,21 +515,6 @@ impl Session {
Ok(tiles)
}
- /// Polygon fill: fill the triangle / UV island / whole mesh under `screen`.
- pub fn polygon_fill(&mut self, screen: Vec2, viewport: Vec2) -> Result {
- let hit = self.pick(screen, viewport).ok_or_else(|| EngineError::Other("nothing under the cursor".into()))?;
- let ts = self.ts();
- let material = self.doc.project.texture_set(ts)?.material;
- if hit.material != material {
- return Err(EngineError::Other("that surface belongs to another texture set".into()));
- }
- let tris = self.fill_set(hit.tri, material);
- let (gbuf, mut canvas) = self.fill_canvas(ts)?;
- fill_triangles(&mut canvas, &gbuf, &tris);
- self.commit_fill("Polygon fill", ts, &canvas)?;
- Ok(tris.len())
- }
-
/// The G-buffer of texture set `ts` and an empty canvas for a one-shot fill, limited by the
/// quick mask unless the fill edits it.
pub(crate) fn fill_canvas(&self, ts: usize) -> Result<(std::sync::Arc