mirror of
https://github.com/storytold/texturecraft.git
synced 2026-11-22 15:30:46 +01:00
Merge main and fix brush reset accessibility
This commit is contained in:
commit
a7236149cb
235 files changed
+15941
-2303
No files matched your search
@@ -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
|
||||
Generated
+547
-15
@@ -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"
|
||||
|
||||
+12
-2
@@ -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]
|
||||
|
||||
@@ -32,6 +32,7 @@
|
||||
<img alt="MCP server for agents" src="https://img.shields.io/badge/agents-MCP%20server-555555?style=flat-square">
|
||||
<img alt="License: MIT OR Apache-2.0" src="https://img.shields.io/badge/license-MIT%20OR%20Apache--2.0-555555?style=flat-square">
|
||||
<br>
|
||||
<a href="https://sonarcloud.io/project/overview?id=storytold_texturecraft"><img alt="Scanned by SonarCloud" src="https://img.shields.io/badge/Scanned_by-SonarCloud-4b9fd5?style=flat-square&logo=sonarqubecloud&logoColor=white"></a>
|
||||
<a href="https://coderabbit.ai"><img alt="Reviewed by CodeRabbit" src="https://img.shields.io/coderabbit/prs/github/storytold/texturecraft?style=flat-square&label=Reviewed%20by%20CodeRabbit&logo=coderabbit"></a>
|
||||
</p>
|
||||
|
||||
|
||||
@@ -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"
|
||||
@@ -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::<std::collections::HashMap<String, String>>(&s).ok());
|
||||
kv.and_then(|kv| ron::from_str::<UiState>(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::<std::collections::HashMap<String, String>>(&text).ok());
|
||||
entries.and_then(|entries| ron::from_str::<UiState>(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<u16>) -> 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::<Vec<_>>()) {
|
||||
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)));
|
||||
}
|
||||
}
|
||||
@@ -178,8 +178,11 @@ pub struct ConnectionLimiter(Arc<AtomicUsize>);
|
||||
pub struct Permit(Arc<AtomicUsize>);
|
||||
|
||||
impl ConnectionLimiter {
|
||||
pub fn try_acquire(&self, max: usize) -> Option<Permit> {
|
||||
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<Permit> {
|
||||
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());
|
||||
}
|
||||
}
|
||||
@@ -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]
|
||||
|
||||
@@ -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;
|
||||
@@ -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<Vec3>,
|
||||
pub starts: Vec<RayStart>,
|
||||
/// 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<CageShell, BakeError> {
|
||||
let ray_frame = RayFrame::new(request, MeshExtent::of(request.mesh)?)?;
|
||||
let (frame, mesh) = (&ray_frame, request.mesh);
|
||||
let triangles: Vec<usize> = mesh.triangles_of(request.material).collect();
|
||||
let (positions, starts): (Vec<Vec3>, Vec<RayStart>) = 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<Vec3> {
|
||||
let frontal = max_frontal * self.cage_units;
|
||||
self.positions.par_iter().zip(&self.starts).map(|(position, start)| start.origin(*position, frontal)).collect()
|
||||
}
|
||||
}
|
||||
@@ -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<Option<VertexReach>>,
|
||||
/// 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<HighPolyReach, BakeError> {
|
||||
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<bool> {
|
||||
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<u32> {
|
||||
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<Vec3> {
|
||||
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
|
||||
}
|
||||
@@ -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<Vec3>,
|
||||
cage: Option<&'a Mesh>,
|
||||
skew: Option<PreparedSkew<'a>>,
|
||||
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<RayFrame<'a>, 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)) }
|
||||
}
|
||||
}
|
||||
@@ -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,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
|
||||
@@ -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;
|
||||
@@ -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<Source<'a>>,
|
||||
cage: Option<&'a Mesh>,
|
||||
skew: Option<PreparedSkew<'a>>,
|
||||
cage_paint: Option<&'a crate::BakePaintMap>,
|
||||
ray_normals: Vec<Vec3>,
|
||||
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<BakeContext<'a>, 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,
|
||||
|
||||
@@ -3,34 +3,43 @@ use std::ops::{Add, Mul};
|
||||
use texturecraft_geom::glam::Vec3;
|
||||
use texturecraft_geom::{Mesh, Surface};
|
||||
|
||||
pub(super) fn interpolate<T: Copy + Mul<f32, Output = T> + Add<Output = T>>(mesh: &Mesh, v: &[T], tri: u32, [b1, b2]: [f32; 2]) -> Option<T> {
|
||||
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<T: Copy + Mul<f32, Output = T> + Add<Output = T>>(mesh: &Mesh, values: &[T], triangle: u32, barycentric: [f32; 2]) -> Option<T> {
|
||||
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<u32>, Vec<Vec3>, Vec<Vec3>) {
|
||||
let q = diag * 1e-5;
|
||||
let mut ids: HashMap<[i64; 3], u32> = HashMap::new();
|
||||
let (mut pos, mut nrm) = (Vec::new(), Vec::<Vec3>::new());
|
||||
let weld: Vec<u32> = 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<u32>, Vec<Vec3>, Vec<Vec3>) {
|
||||
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::<Vec3>::new());
|
||||
|
||||
let welded_indices: Vec<u32> = 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 {
|
||||
|
||||
@@ -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<Source<'a>>) {
|
||||
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,
|
||||
|
||||
@@ -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<u32>, Vec<u32>) {
|
||||
let (low, high) = Source::of_request(request);
|
||||
(low.key, high.map(|high| high.key).unwrap_or_default())
|
||||
}
|
||||
@@ -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<MeshExtent, BakeError> {
|
||||
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
|
||||
}
|
||||
}
|
||||
@@ -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<usize> = 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));
|
||||
}
|
||||
@@ -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<bool>) {
|
||||
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::<f32>() / 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);
|
||||
}
|
||||
@@ -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]
|
||||
|
||||
@@ -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}"
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
+21
-10
@@ -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]
|
||||
|
||||
@@ -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<i16>,
|
||||
}
|
||||
|
||||
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");
|
||||
}
|
||||
}
|
||||
@@ -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<Option<Arc<CurvatureSizeLevel>>>,
|
||||
}
|
||||
|
||||
/// 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<Vec<f32>>, CacheKey, BlockScales, Arc<CurvatureSizes>);
|
||||
|
||||
static CACHE: Mutex<Vec<CacheEntry>> = 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<Arc<CurvatureSizes>> {
|
||||
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<f32> =
|
||||
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<Vec<f32>>, key: CacheKey, scales: &BlockScales) -> Option<Arc<CurvatureSizes>> {
|
||||
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<Vec<f32>>, key: CacheKey, scales: &BlockScales, sizes: CurvatureSizes) -> Arc<CurvatureSizes> {
|
||||
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<CacheEntry>, 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::<i16>())).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<Vec<f32>>, 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<bool> {
|
||||
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<AtomicBool> = (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<f32> =
|
||||
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<f32> {
|
||||
let window = (2 * radius + 1) as f64;
|
||||
let mut weights = vec![1.0f64; length];
|
||||
for _ in 0..BLUR_BOX_PASSES {
|
||||
let running_totals: Vec<f64> = 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::<f32>() / 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<f32> = (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<f32> = (0..map_size * map_size).map(|texel| if left_half(texel) { 1.0 } else { 0.0 }).collect();
|
||||
let covered: Vec<bool> = (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<f32> =
|
||||
(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<bool> = (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");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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<u8> {
|
||||
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<u8> {
|
||||
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
|
||||
}
|
||||
|
||||
|
||||
+292
-111
@@ -4,17 +4,20 @@
|
||||
|
||||
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 +207,8 @@ struct EffectPlan<'a> {
|
||||
opacity: f32,
|
||||
data: Option<Cow<'a, [u16]>>,
|
||||
preview: bool,
|
||||
/// The curvature detail sizes a generator with detail reads.
|
||||
curvature_sizes: Option<Arc<CurvatureSizes>>,
|
||||
}
|
||||
|
||||
struct MaskPlan<'a> {
|
||||
@@ -304,6 +309,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 +432,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<i64> = 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<i64> = 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 +453,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 +774,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<Item = &'a Mask>) {
|
||||
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 +838,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<Channel>) -> Vec<EffectPlan<'a>> {
|
||||
fn effect_plans<'a>(inp: &Inputs<'a>, effects: &'a [Effect], tile_x: u32, tile_y: u32, channel: Option<Channel>) -> Vec<EffectPlan<'a>> {
|
||||
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()
|
||||
@@ -1166,94 +1210,142 @@ impl<'a, 'b> Texel<'a, 'b> {
|
||||
}
|
||||
}
|
||||
|
||||
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 +1990,10 @@ pub fn mask_image(inputs: &Inputs, id: LayerId, size: u32) -> Option<Vec<u8>> {
|
||||
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<u8>> = coordinates
|
||||
.par_iter()
|
||||
@@ -1951,6 +2047,10 @@ pub fn mask_at(inputs: &Inputs, id: LayerId, texels: &[(u32, u32)]) -> Option<Ve
|
||||
}
|
||||
|
||||
let channels = inputs.project.texture_set(inputs.ts).map(|set| set.channel_list()).unwrap_or_default();
|
||||
|
||||
// A hidden layer's mask is left out of the stack's preparation
|
||||
prepare_mask_curvature_sizes(inputs, std::iter::once(mask));
|
||||
|
||||
// Filters and anchors can depend on texels outside the requested tiles
|
||||
let fields = neighbourhood_fields(inputs, &channels, &all_tiles(inputs.gbuf.width, inputs.gbuf.height));
|
||||
let values: Vec<(usize, f32)> = requested
|
||||
@@ -2103,60 +2203,67 @@ pub type FlatTile = (Channel, (u32, u32), Vec<u16>);
|
||||
/// 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<Vec<FlatTile>> {
|
||||
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<Vec<FlatTile>> {
|
||||
let set = inputs.project.texture_set(inputs.ts).ok()?;
|
||||
if inputs.project.content_layer(id)?.is_group() {
|
||||
return None;
|
||||
}
|
||||
|
||||
let channels: Vec<Channel> = 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<Vec<FlatTile>> = 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<u16>, bool)> =
|
||||
let full = anchor_plan(&visible_inputs, id, &channels, tx, ty, Some(&fields));
|
||||
let mut buffers: Vec<(Channel, Vec<u16>, 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 +2562,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<f32> = (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<f32> {
|
||||
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::<Vec<_>>()).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();
|
||||
|
||||
@@ -9,6 +9,8 @@
|
||||
|
||||
mod baked_maps;
|
||||
pub mod below;
|
||||
mod curvature_size_level;
|
||||
pub mod curvature_sizes;
|
||||
pub mod display;
|
||||
pub mod eval;
|
||||
pub mod pattern;
|
||||
|
||||
@@ -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<CurvatureDetail>,
|
||||
}
|
||||
|
||||
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 };
|
||||
|
||||
@@ -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 }
|
||||
}
|
||||
}
|
||||
@@ -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<CurvatureMode> {
|
||||
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))
|
||||
}
|
||||
}
|
||||
@@ -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,
|
||||
|
||||
@@ -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<TextureSet>,
|
||||
pub layers: BTreeMap<LayerId, Layer>,
|
||||
@@ -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(),
|
||||
|
||||
@@ -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<Mesh>,
|
||||
pub(super) bvh: Arc<Bvh>,
|
||||
pub(super) material: usize,
|
||||
pub(super) settings: BakeSettings,
|
||||
pub(super) high: MergedHigh,
|
||||
pub(super) cage: Option<Arc<Mesh>>,
|
||||
pub(super) skew: Option<Arc<BakePaintMap>>,
|
||||
pub(super) cage_paint: Option<Arc<BakePaintMap>>,
|
||||
}
|
||||
|
||||
impl BakeCageInputs {
|
||||
/// The cage the 3D view draws: the bake's ray origins at each triangle corner
|
||||
pub fn cage_shell(&self) -> Result<CageShell, BakeError> {
|
||||
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, BakeError> {
|
||||
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),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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());
|
||||
|
||||
@@ -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<BakedMap> {
|
||||
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<StreamedBake> {
|
||||
let maps = self.maps();
|
||||
let total = maps.len();
|
||||
let mut combined: Option<StreamedBake> = 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<BakeOutput> {
|
||||
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<BakeOutput> {
|
||||
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::<Vec<_>>(), whole.maps.keys().collect::<Vec<_>>());
|
||||
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::<Vec<_>>(), whole.maps.keys().collect::<Vec<_>>());
|
||||
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"),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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<HighPolyReach>], distances: &[(f32, f32)], only_set: Option<usize>, vertex_count: usize) -> Vec<f32> {
|
||||
// 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()
|
||||
}
|
||||
@@ -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<u8>) -> Result<BakeMesh> {
|
||||
}
|
||||
|
||||
impl Session {
|
||||
pub fn bake_task(&self, ts: usize) -> Result<BakeTask> {
|
||||
let set = self.doc.project.texture_set(ts)?;
|
||||
pub fn bake_task(&self, texture_set: usize) -> Result<BakeTask> {
|
||||
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<Option<BakeCageInputs>> {
|
||||
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<Option<MergedHigh>> {
|
||||
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<Option<Arc<Mesh>>> {
|
||||
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<Option<Arc<BakePaintMap>>> {
|
||||
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<Arc<Mesh>> {
|
||||
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<BakedMap, Arc<Vec<f32>>>) -> 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(())
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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<Vec<texturecraft_core::BakedMap>> = const { std::cell::RefCell::new(Vec::new()) };
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
pub(super) fn take_retained_allocations() -> Vec<texturecraft_core::BakedMap> {
|
||||
RETAINED_ALLOCATIONS.with(|allocations| std::mem::take(&mut *allocations.borrow_mut()))
|
||||
}
|
||||
@@ -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<BakedMap, Arc<Vec<f32>>>,
|
||||
pub tracer: String,
|
||||
}
|
||||
@@ -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<Vec<f32>>,
|
||||
}
|
||||
@@ -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<CommandSpec> {
|
||||
vec![cmd!(
|
||||
"bake.preview",
|
||||
"Bake preview",
|
||||
[],
|
||||
None,
|
||||
"{show?: \"follow\" (the newest finished map) | \"material\" | \"map:<id>\" (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<usize, PreviewSet>,
|
||||
/// The texture set being baked.
|
||||
pub current: Option<usize>,
|
||||
/// The last map that finished.
|
||||
pub newest: Option<BakedMap>,
|
||||
}
|
||||
|
||||
impl BakePreview {
|
||||
/// The map the view shows, None for the material.
|
||||
pub fn shown(&self) -> Option<BakedMap> {
|
||||
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<Stage> {
|
||||
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::<Result<Vec<_>>>()?;
|
||||
|
||||
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<BakedMap>)>) {
|
||||
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<Value> = preview
|
||||
.sets
|
||||
.iter()
|
||||
.map(|(texture_set, set)| {
|
||||
json!({
|
||||
"set": texture_set,
|
||||
"order": set.order.iter().map(|map| map.id()).collect::<Vec<_>>(),
|
||||
"done": set.baked.maps.keys().map(|map| map.id()).collect::<Vec<_>>(),
|
||||
})
|
||||
})
|
||||
.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<Value> {
|
||||
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:<id>")))?;
|
||||
session.bake_preview_show(show)?;
|
||||
}
|
||||
|
||||
Ok(preview_json(session))
|
||||
}
|
||||
@@ -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<BakedMap>,
|
||||
}
|
||||
@@ -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<PreviewShow> {
|
||||
match text {
|
||||
"follow" => Some(PreviewShow::Follow),
|
||||
"material" => Some(PreviewShow::Material),
|
||||
_ => text.strip_prefix("map:").and_then(BakedMap::parse).map(PreviewShow::Pin),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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,
|
||||
}
|
||||
@@ -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<CommandSpec> {
|
||||
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<Vec<[f32; 3]>> {
|
||||
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<Value> {
|
||||
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<Vec2> {
|
||||
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<const N: usize>(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)
|
||||
}
|
||||
@@ -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());
|
||||
|
||||
@@ -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<texturecraft_formats::MeshFile> {
|
||||
@@ -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<Value> {
|
||||
let path = native::path_param(p, "mesh", "file.new")?;
|
||||
@@ -377,6 +385,7 @@ fn new_from_mesh(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
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<Value> {
|
||||
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<Value> {
|
||||
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<Value> {
|
||||
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]
|
||||
|
||||
@@ -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<Vec2> {
|
||||
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);
|
||||
}
|
||||
}
|
||||
@@ -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,
|
||||
}
|
||||
@@ -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<Vec<&'static FilterDef>> =
|
||||
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 }
|
||||
}
|
||||
|
||||
@@ -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::<usize>();
|
||||
|
||||
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::<Vec<_>>());
|
||||
ej["tiles"] = json!(if content {
|
||||
s.doc.pixels.layers.iter().filter(|((id, _), _)| *id == e.id).map(|(_, img)| img.allocated_count()).sum::<usize>()
|
||||
} 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::<Vec<_>>()
|
||||
);
|
||||
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::<usize>())
|
||||
}
|
||||
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() },
|
||||
|
||||
@@ -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,15 +26,20 @@ 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;
|
||||
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,14 +54,19 @@ pub mod smart_masks;
|
||||
pub mod template_cmds;
|
||||
pub mod text_cmds;
|
||||
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;
|
||||
|
||||
+149
-56
@@ -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<CommandSpec> {
|
||||
"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<CommandSpec> {
|
||||
"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<Value> {
|
||||
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<Value> {
|
||||
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<Value> {
|
||||
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<Value> {
|
||||
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<Value> {
|
||||
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<Value> {
|
||||
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<Value> {
|
||||
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<Effect>, usize)> {
|
||||
project.layers.values_mut().find_map(|l| {
|
||||
|
||||
@@ -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<MaskPreviewCamera>,
|
||||
}
|
||||
|
||||
impl MaskPreview {
|
||||
/// Bake the preview shape once (previews of any size reuse it)
|
||||
pub fn new() -> Result<MaskPreview> {
|
||||
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<Vec<Option<MaskPreviewPixel>>> {
|
||||
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<MaskPreviewCamera>, 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<MaskPreviewPixel>], b: &[Option<MaskPreviewPixel>]) -> 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::<f32>() / 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<MaskPreviewPixel>]| 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<MaskPreviewPixel>]| px.iter().flatten().map(|p| p.mask).sum::<f32>() / 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");
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
|
||||
|
||||
@@ -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,
|
||||
}
|
||||
@@ -38,55 +38,91 @@ fn set(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
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<BTreeMap<u32, Arc<ImageRes>>> {
|
||||
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<u32, Arc<ImageRes>>) -> Result<u32> {
|
||||
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<BTreeMap<u32, Arc<ImageRes>>> {
|
||||
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<u32> {
|
||||
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<usize> {
|
||||
let b = name.as_bytes();
|
||||
|
||||
@@ -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<BakedMap> {
|
||||
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::<u32>().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<usize> {
|
||||
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);
|
||||
}
|
||||
}
|
||||
@@ -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<CommandSpec> {
|
||||
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<Value> {
|
||||
import_with_budget(s, p, MAX_TOTAL_BYTES)
|
||||
}
|
||||
|
||||
fn import_with_budget(s: &mut Session, p: &Value, max_bytes: u64) -> Result<Value> {
|
||||
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<u32, &str>> = 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::<f32>() 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<BakedMap>) -> 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();
|
||||
}
|
||||
}
|
||||
@@ -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<CameraSample>,
|
||||
}
|
||||
|
||||
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 }
|
||||
}
|
||||
}
|
||||
@@ -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<usize, LayerId>),
|
||||
/// Cached camera views, least recently used first
|
||||
cameras: Vec<OrbCamera>,
|
||||
}
|
||||
|
||||
impl OrbPreview {
|
||||
/// Bake the orb once (previews of any size reuse it)
|
||||
pub fn new() -> Result<OrbPreview> {
|
||||
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<Vec<Option<MaskPreviewPixel>>> {
|
||||
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<Vec<Option<MaterialPreviewPixel>>> {
|
||||
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<Item = (usize, Vec3)> + '_ {
|
||||
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<Vec<Sample>> {
|
||||
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<OrbCamera>, 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<MaskPreviewPixel>], b: &[Option<MaskPreviewPixel>]) -> 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::<f32>() / pairs.len().max(1) as f32
|
||||
}
|
||||
|
||||
/// Mean mask value over the pixels a preview sees
|
||||
fn mean_mask(pixels: &[Option<MaskPreviewPixel>]) -> f32 {
|
||||
pixels.iter().flatten().map(|pixel| pixel.mask).sum::<f32>() / 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<MaskPreviewPixel>]| 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<MaterialPreviewPixel>]| 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<MaterialPreviewPixel>]| pixels.iter().flatten().map(|pixel| pixel.sample.base).collect::<Vec<_>>();
|
||||
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);
|
||||
}
|
||||
}
|
||||
+93
-136
@@ -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<EyeDepth> {
|
||||
@@ -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<Vec2>) -> 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<bool> {
|
||||
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<texturecraft_paint::UvStamp> = 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<usize> {
|
||||
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<texturecraft_geom::UvGBuffer>, StrokeCanvas)> {
|
||||
@@ -510,61 +528,31 @@ impl Session {
|
||||
|
||||
/// Commit a one-shot fill with the tool's material (one undo step), or into the quick mask.
|
||||
pub(crate) fn commit_fill(&mut self, label: &str, ts: usize, canvas: &StrokeCanvas) -> Result<()> {
|
||||
let size = (canvas.alpha.width(), canvas.alpha.height());
|
||||
let src = |opacity| CommitSource { alpha: &canvas.alpha, tiles: &canvas.dirty, opacity, erase: false, per_texel: None, carried: None };
|
||||
if self.quick_mask.editing {
|
||||
self.commit_quick_mask(ts, size, src(self.tool.brush.opacity));
|
||||
return Ok(());
|
||||
return self.paint_fill(ts, canvas);
|
||||
}
|
||||
self.edit(label, |s| {
|
||||
let target = s.paint_target()?;
|
||||
let values = s.stroke_values(target);
|
||||
match target {
|
||||
PaintTarget::Layer(id) => commit_layer(&mut s.doc.pixels, id, size, &values, src(s.tool.brush.opacity), &mut Staging::default()),
|
||||
PaintTarget::Mask(eid) => commit_mask(&mut s.doc.pixels, eid, size, s.tool.mask_value, src(s.tool.brush.opacity), &mut Staging::default()),
|
||||
}
|
||||
Ok(())
|
||||
})
|
||||
|
||||
// Each fill is its own step, never merged into a box drag's step of the same label
|
||||
self.edit_merging(label, false, |session| session.paint_fill(ts, canvas))
|
||||
}
|
||||
|
||||
/// Triangles filled by the current fill mode starting from `tri`.
|
||||
fn fill_set(&self, tri: u32, material: usize) -> BTreeSet<u32> {
|
||||
let m = &self.mesh;
|
||||
match self.tool.fill_mode {
|
||||
FillMode::Triangle => [tri].into_iter().collect(),
|
||||
FillMode::Mesh => m.triangles_of(material).map(|t| t as u32).collect(),
|
||||
FillMode::UvIsland => {
|
||||
// Triangles sharing an edge in UV space form a UV island: imported meshes often
|
||||
// split vertices along hard edges (or per face) where the UVs run on, so shared
|
||||
// vertex indices alone break an island into its polygons.
|
||||
let corner = |i: usize| m.uvs.get(i).map(|uv| [(uv.x * 1e5).round() as i64, (uv.y * 1e5).round() as i64]);
|
||||
let edges = |t: usize| match m.tri(t).map(|v| v.map(corner)) {
|
||||
Some([Some(a), Some(b), Some(c)]) => [(a, b), (b, c), (c, a)].map(|(p, q)| (p.min(q), p.max(q))).to_vec(),
|
||||
_ => Vec::new(),
|
||||
};
|
||||
let mut by_edge: BTreeMap<_, Vec<u32>> = BTreeMap::new();
|
||||
for t in m.triangles_of(material) {
|
||||
for e in edges(t) {
|
||||
by_edge.entry(e).or_default().push(t as u32);
|
||||
}
|
||||
}
|
||||
let mut seen = BTreeSet::new();
|
||||
let mut stack = vec![tri];
|
||||
while let Some(t) = stack.pop() {
|
||||
if !seen.insert(t) {
|
||||
continue;
|
||||
}
|
||||
for e in edges(t as usize) {
|
||||
for n in by_edge.get(&e).map(Vec::as_slice).unwrap_or(&[]) {
|
||||
if !seen.contains(n) {
|
||||
stack.push(*n);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
seen
|
||||
}
|
||||
/// Paint a one-shot fill with the tool's material into the paint target, or into the quick mask while it is edited (no undo step)
|
||||
pub(crate) fn paint_fill(&mut self, ts: usize, canvas: &StrokeCanvas) -> Result<()> {
|
||||
let size = (canvas.alpha.width(), canvas.alpha.height());
|
||||
let opacity = self.tool.brush.opacity;
|
||||
let source = CommitSource { alpha: &canvas.alpha, tiles: &canvas.dirty, opacity, erase: false, per_texel: None, carried: None };
|
||||
if self.quick_mask.editing {
|
||||
self.commit_quick_mask(ts, size, source);
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let target = self.paint_target()?;
|
||||
let values = self.stroke_values(target);
|
||||
match target {
|
||||
PaintTarget::Layer(id) => commit_layer(&mut self.doc.pixels, id, size, &values, source, &mut Staging::default()),
|
||||
PaintTarget::Mask(effect) => commit_mask(&mut self.doc.pixels, effect, size, self.tool.mask_value, source, &mut Staging::default()),
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Color picker: copy the material under the cursor into the tool's paint values.
|
||||
@@ -627,34 +615,3 @@ fn with_commit_source<R>(
|
||||
let carried = st.canvas.pickup.as_ref().map(|p| &p.values);
|
||||
f(CommitSource { alpha: &st.canvas.alpha, tiles, opacity: st.stroke.settings.opacity, erase: st.erase, per_texel, carried })
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use texturecraft_geom::glam::{Vec2, Vec3};
|
||||
use texturecraft_geom::mesh::Mesh;
|
||||
use texturecraft_geom::primitives;
|
||||
|
||||
use crate::session::{FillMode, Session};
|
||||
|
||||
#[test]
|
||||
fn uv_island_fill_follows_uvs_across_split_vertices() {
|
||||
// Two copies of a plane, each triangle with its own three vertices (as hard edges or
|
||||
// per-face imports leave a mesh), the second copy apart in UV space.
|
||||
let plane = primitives::plane(2.0, 4);
|
||||
let (mut positions, mut uvs) = (Vec::<Vec3>::new(), Vec::<Vec2>::new());
|
||||
for shift in [0.0, 0.5] {
|
||||
for i in plane.indices.iter().map(|i| *i as usize) {
|
||||
positions.push(plane.positions[i] + Vec3::Y * shift);
|
||||
uvs.push(plane.uvs[i] * 0.5 + shift);
|
||||
}
|
||||
}
|
||||
let indices = (0..positions.len() as u32).collect();
|
||||
let mesh = Mesh::from_parts(positions, None, uvs, indices, "m").unwrap();
|
||||
let n = plane.triangle_count();
|
||||
assert_eq!(mesh.vertex_count(), 6 * n, "no vertex is shared");
|
||||
let mut s = Session::new_project("t", mesh, "test", None, 128).unwrap();
|
||||
s.tool.fill_mode = FillMode::UvIsland;
|
||||
assert_eq!(s.fill_set(0, 0).len(), n, "the whole first island");
|
||||
assert_eq!(s.fill_set(n as u32, 0).len(), n, "only the second island");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,614 @@
|
||||
//! Polygon fill: fill the triangles, polygons, UV islands or connected meshes under a click or inside a dragged box, in either view.
|
||||
|
||||
use std::borrow::Cow;
|
||||
use std::collections::{BTreeSet, HashSet};
|
||||
|
||||
use texturecraft_geom::glam::Vec2;
|
||||
use texturecraft_geom::{Mesh, NO_TRI};
|
||||
use texturecraft_paint::{EyeDepth, fill_triangles, screen_point};
|
||||
|
||||
use crate::fill_mode::FillMode;
|
||||
use crate::polygon_fill_drag::PolygonFillDrag;
|
||||
use crate::session::Session;
|
||||
use crate::triangle_partition::TrianglePartition;
|
||||
use crate::{EngineError, Result};
|
||||
|
||||
/// Corners closer than one step of this grid (per unit of position or UV) count as the same corner
|
||||
const CORNER_GRID_STEPS: f32 = 1e5;
|
||||
|
||||
impl Session {
|
||||
/// Fill the triangle / polygon / UV island / connected mesh under viewport pixel `screen`
|
||||
pub fn polygon_fill(&mut self, screen: Vec2, viewport: Vec2) -> Result<usize> {
|
||||
self.refuse_while_baking()?;
|
||||
let hit = self.pick(screen, viewport).ok_or_else(|| EngineError::Other("nothing under the cursor".into()))?;
|
||||
if hit.material != self.fill_material()? {
|
||||
return Err(EngineError::Other("that surface belongs to another texture set".into()));
|
||||
}
|
||||
|
||||
self.fill_group_of(hit.tri)
|
||||
}
|
||||
|
||||
/// Fill like [`Session::polygon_fill`] at texture coordinate `uv` (the 2D view): the triangle covering that texel's center, so slivers thinner than a texel can't be clicked
|
||||
pub fn polygon_fill_uv(&mut self, uv: Vec2) -> Result<usize> {
|
||||
self.refuse_while_baking()?;
|
||||
let gbuf = self.caches.get(self.ts()).map(|cache| cache.gbuf.clone()).ok_or_else(|| EngineError::Other("texture set not ready".into()))?;
|
||||
let size = Vec2::new(gbuf.width as f32, gbuf.height as f32);
|
||||
let texel = (uv * size).floor();
|
||||
let triangle = (texel.cmpge(Vec2::ZERO).all() && texel.cmplt(size).all())
|
||||
.then(|| gbuf.tri.get(texel.y as usize * gbuf.width as usize + texel.x as usize).copied())
|
||||
.flatten()
|
||||
.filter(|triangle| *triangle != NO_TRI)
|
||||
.ok_or_else(|| EngineError::Other("nothing under the cursor".into()))?;
|
||||
|
||||
self.fill_group_of(triangle)
|
||||
}
|
||||
|
||||
/// Fill what the box between viewport pixels `corner` and `opposite` selects (one undo step)
|
||||
pub fn polygon_fill_box(&mut self, corner: Vec2, opposite: Vec2, viewport: Vec2) -> Result<usize> {
|
||||
self.refuse_while_baking()?;
|
||||
|
||||
// A scripted box stands alone: it finishes any drag under way, and ends even when it fails
|
||||
self.end_polygon_fill_box();
|
||||
let shown = self.drag_polygon_fill_box(corner, opposite, viewport);
|
||||
let filled = self.end_polygon_fill_box();
|
||||
shown.map(|_| filled)
|
||||
}
|
||||
|
||||
/// Fill what the box between texture coordinates `corner` and `opposite` selects (the 2D view, one undo step)
|
||||
pub fn polygon_fill_box_uv(&mut self, corner: Vec2, opposite: Vec2) -> Result<usize> {
|
||||
self.refuse_while_baking()?;
|
||||
|
||||
self.end_polygon_fill_box();
|
||||
let shown = self.drag_polygon_fill_box_uv(corner, opposite);
|
||||
let filled = self.end_polygon_fill_box();
|
||||
shown.map(|_| filled)
|
||||
}
|
||||
|
||||
/// Show the fill of a box being dragged between viewport pixels `corner` and `opposite`
|
||||
pub fn drag_polygon_fill_box(&mut self, corner: Vec2, opposite: Vec2, viewport: Vec2) -> Result<usize> {
|
||||
// Whole pixels, as the visibility buffer is rendered at
|
||||
self.drag_polygon_fill(corner, opposite, Some(viewport.round().max(Vec2::ONE)))
|
||||
}
|
||||
|
||||
/// Show the fill of a box being dragged between texture coordinates `corner` and `opposite` (the 2D view)
|
||||
pub fn drag_polygon_fill_box_uv(&mut self, corner: Vec2, opposite: Vec2) -> Result<usize> {
|
||||
self.drag_polygon_fill(corner, opposite, None)
|
||||
}
|
||||
|
||||
/// Finish the dragged box: what it filled becomes one undo step. Returns the filled triangle count
|
||||
pub fn end_polygon_fill_box(&mut self) -> usize {
|
||||
let Some(drag) = self.polygon_fill_drag.take() else { return 0 };
|
||||
|
||||
let filled = drag.filled.len();
|
||||
// Quick mask edits keep no history, as with its strokes
|
||||
if filled > 0 && drag.quick_mask_before.is_none() {
|
||||
self.push_history("Polygon fill", drag.before);
|
||||
}
|
||||
filled
|
||||
}
|
||||
|
||||
/// Show the fill of a box from `corner` to `opposite` in the 3D view of size `viewport`, or in the 2D view when None
|
||||
fn drag_polygon_fill(&mut self, corner: Vec2, opposite: Vec2, viewport: Option<Vec2>) -> Result<usize> {
|
||||
self.refuse_while_baking()?;
|
||||
if !corner.is_finite() || !opposite.is_finite() {
|
||||
return Err(EngineError::Other("the box corners must be finite".into()));
|
||||
}
|
||||
|
||||
let (low, high) = (corner.min(opposite), corner.max(opposite));
|
||||
self.start_polygon_fill_drag(viewport)?;
|
||||
let Some(drag) = self.polygon_fill_drag.as_mut() else { return Ok(0) };
|
||||
|
||||
if drag.failed || drag.last_box == Some((low, high)) {
|
||||
return Ok(drag.filled.len());
|
||||
}
|
||||
|
||||
drag.last_box = Some((low, high));
|
||||
let selected = self.box_selection(low, high);
|
||||
self.show_box_fill(selected)
|
||||
}
|
||||
|
||||
/// Continue a box drag only while its view, paint target and quick mask state still match
|
||||
fn start_polygon_fill_drag(&mut self, viewport: Option<Vec2>) -> Result<()> {
|
||||
let ts = self.ts();
|
||||
let target = (self.selected_layer(), self.target);
|
||||
let quick_mask = self.quick_mask.editing;
|
||||
// Finish the old target before another preview can restore its earlier document snapshot
|
||||
if let Some(drag) = &self.polygon_fill_drag {
|
||||
if drag.ts == ts && drag.target == target && drag.viewport == viewport && drag.quick_mask_before.is_some() == quick_mask {
|
||||
// A camera move (a wheel zoom mid-drag) keeps the drag, which then sees the mesh from the new camera
|
||||
if drag.camera != self.camera {
|
||||
let (points, depth) = self.box_space(viewport);
|
||||
if let Some(drag) = self.polygon_fill_drag.as_mut() {
|
||||
(drag.points, drag.depth, drag.camera, drag.last_box) = (points, depth, self.camera, None);
|
||||
}
|
||||
}
|
||||
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
self.end_polygon_fill_box();
|
||||
}
|
||||
|
||||
let material = self.fill_material()?;
|
||||
let (points, depth) = self.box_space(viewport);
|
||||
let polygons = match self.tool.fill_mode {
|
||||
FillMode::Triangle | FillMode::Polygon => None,
|
||||
FillMode::UvIsland | FillMode::Mesh => Some(TrianglePartition::new(&self.mesh, material, polygon_edges)),
|
||||
};
|
||||
self.polygon_fill_drag = Some(PolygonFillDrag {
|
||||
ts,
|
||||
target,
|
||||
viewport,
|
||||
camera: self.camera,
|
||||
before: self.doc.clone(),
|
||||
quick_mask_before: quick_mask.then(|| self.quick_mask.masks.clone()),
|
||||
points,
|
||||
depth,
|
||||
fill_groups: self.fill_partition(material),
|
||||
polygons,
|
||||
filled: BTreeSet::new(),
|
||||
last_box: None,
|
||||
failed: false,
|
||||
});
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Each vertex where a box sees it (viewport pixels for a 3D view of size `viewport`, else texture coordinates) and, for visible polygons only in 3D, what the camera sees
|
||||
fn box_space(&self, viewport: Option<Vec2>) -> (Vec<Option<Vec2>>, Option<EyeDepth>) {
|
||||
let Some(size) = viewport else { return (self.mesh.uvs.iter().copied().map(Some).collect(), None) };
|
||||
|
||||
let view_proj = self.camera.view_proj(size.x / size.y);
|
||||
let points = self.mesh.positions.iter().map(|position| screen_point(view_proj, *position, size)).collect();
|
||||
let depth = self.tool.fill_visible_only.then(|| EyeDepth::render_with_triangles(&self.shown_mesh(), &self.camera, size.x as u32, size.y as u32));
|
||||
(points, depth)
|
||||
}
|
||||
|
||||
/// The mesh material of the texture set being painted
|
||||
fn fill_material(&self) -> Result<usize> {
|
||||
Ok(self.doc.project.texture_set(self.ts())?.material)
|
||||
}
|
||||
|
||||
/// The triangles the current fill mode fills together, for `material`
|
||||
fn fill_partition(&self, material: usize) -> TrianglePartition {
|
||||
match self.tool.fill_mode {
|
||||
FillMode::Triangle => TrianglePartition::new(&self.mesh, material, |_, _| Vec::<u32>::new()),
|
||||
FillMode::Polygon => TrianglePartition::new(&self.mesh, material, polygon_edges),
|
||||
FillMode::UvIsland => TrianglePartition::new(&self.mesh, material, uv_edges),
|
||||
FillMode::Mesh => TrianglePartition::new(&self.mesh, material, position_edges),
|
||||
}
|
||||
}
|
||||
|
||||
/// Fill the fill-mode group holding `triangle` (one undo step)
|
||||
fn fill_group_of(&mut self, triangle: u32) -> Result<usize> {
|
||||
let ts = self.ts();
|
||||
let groups = self.fill_partition(self.fill_material()?);
|
||||
let triangles: BTreeSet<u32> = groups.group(triangle).unwrap_or_default().iter().copied().collect();
|
||||
|
||||
let (gbuf, mut canvas) = self.fill_canvas(ts)?;
|
||||
fill_triangles(&mut canvas, &gbuf, &triangles);
|
||||
self.commit_fill("Polygon fill", ts, &canvas)?;
|
||||
Ok(triangles.len())
|
||||
}
|
||||
|
||||
/// The mesh as the 3D view shows it: hidden texture sets' triangles collapse to a point, so nothing behind them counts as hidden
|
||||
fn shown_mesh(&self) -> Cow<'_, Mesh> {
|
||||
let sets = &self.doc.project.texture_sets;
|
||||
if sets.iter().all(|set| set.visible) {
|
||||
return Cow::Borrowed(&self.mesh);
|
||||
}
|
||||
|
||||
let mut mesh = (*self.mesh).clone();
|
||||
for set in sets.iter().filter(|set| !set.visible) {
|
||||
for triangle in self.mesh.triangles_of(set.material) {
|
||||
if let Some(corners) = mesh.indices.get_mut(triangle * 3..triangle * 3 + 3) {
|
||||
let first = corners[0];
|
||||
corners.fill(first);
|
||||
}
|
||||
}
|
||||
}
|
||||
Cow::Owned(mesh)
|
||||
}
|
||||
|
||||
/// Triangles the dragged box from `low` to `high` fills: each polygon the hit-test selects, grown by the fill mode
|
||||
fn box_selection(&self, low: Vec2, high: Vec2) -> BTreeSet<u32> {
|
||||
let Some(drag) = &self.polygon_fill_drag else { return BTreeSet::new() };
|
||||
|
||||
let visible = drag.depth.as_ref().zip(drag.viewport).map(|(depth, viewport)| visible_triangles(depth, viewport, low, high));
|
||||
let point = |vertex: usize| drag.points.get(vertex).copied().flatten();
|
||||
let corners = |triangle: u32| {
|
||||
let [first, second, third] = self.mesh.tri(triangle as usize)?;
|
||||
Some([point(first)?, point(second)?, point(third)?])
|
||||
};
|
||||
let hit_test = self.tool.fill_hit_test;
|
||||
let mut polygon_corners = Vec::new();
|
||||
let mut groups = BTreeSet::new();
|
||||
for polygon in &drag.polygons.as_ref().unwrap_or(&drag.fill_groups).groups {
|
||||
let seen = visible.as_ref().is_none_or(|visible| polygon.iter().any(|triangle| visible.contains(triangle)));
|
||||
if !seen {
|
||||
continue;
|
||||
}
|
||||
|
||||
polygon_corners.clear();
|
||||
polygon_corners.extend(polygon.iter().map_while(|triangle| corners(*triangle)));
|
||||
if polygon_corners.len() == polygon.len() && hit_test.selects(&polygon_corners, low, high) {
|
||||
groups.extend(polygon.iter().filter_map(|triangle| drag.fill_groups.index_of(*triangle)));
|
||||
}
|
||||
}
|
||||
|
||||
groups.iter().filter_map(|group| drag.fill_groups.groups.get(*group)).flatten().copied().collect()
|
||||
}
|
||||
|
||||
/// Show the box drag's fill of `selected`: the document before the drag, refilled when the selection changed
|
||||
fn show_box_fill(&mut self, selected: BTreeSet<u32>) -> Result<usize> {
|
||||
let Some(drag) = self.polygon_fill_drag.as_mut() else { return Ok(0) };
|
||||
if drag.filled == selected {
|
||||
return Ok(selected.len());
|
||||
}
|
||||
|
||||
let ts = drag.ts;
|
||||
let previous = std::mem::replace(&mut self.doc, drag.before.clone());
|
||||
if let Some(masks) = &drag.quick_mask_before {
|
||||
self.quick_mask.masks = masks.clone();
|
||||
self.quick_mask.revision = self.quick_mask.revision.wrapping_add(1);
|
||||
}
|
||||
|
||||
let painted = if selected.is_empty() {
|
||||
Ok(())
|
||||
} else {
|
||||
self.fill_canvas(ts).and_then(|(gbuf, mut canvas)| {
|
||||
fill_triangles(&mut canvas, &gbuf, &selected);
|
||||
self.paint_fill(ts, &canvas)
|
||||
})
|
||||
};
|
||||
self.invalidate_changed(&previous);
|
||||
|
||||
// A failed fill is reported once and leaves the document as before the drag; the rest of the drag fills nothing
|
||||
let selected_count = selected.len();
|
||||
if let Some(drag) = self.polygon_fill_drag.as_mut() {
|
||||
drag.failed = painted.is_err();
|
||||
drag.filled = if drag.failed { BTreeSet::new() } else { selected };
|
||||
}
|
||||
painted.map(|_| selected_count)
|
||||
}
|
||||
}
|
||||
|
||||
/// Triangles `depth` (rendered for a `viewport` pixel view) shows in the viewport pixels from `low` to `high`, both edges included
|
||||
fn visible_triangles(depth: &EyeDepth, viewport: Vec2, low: Vec2, high: Vec2) -> HashSet<u32> {
|
||||
let depth_pixels_per_viewport_pixel = Vec2::new(depth.width as f32, depth.height as f32) / viewport;
|
||||
let (low, high) = (low * depth_pixels_per_viewport_pixel, high * depth_pixels_per_viewport_pixel);
|
||||
let columns = pixel_span(low.x, high.x, depth.width);
|
||||
let rows = pixel_span(low.y, high.y, depth.height);
|
||||
|
||||
rows.flat_map(|row| depth.triangle.get(row * depth.width as usize..).into_iter().flat_map(|pixels| pixels.iter().take(columns.end).skip(columns.start)))
|
||||
.copied()
|
||||
.filter(|triangle| *triangle != NO_TRI)
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// The pixels `0..count` a span from `low` to `high` covers, both edges included (empty when it lies outside)
|
||||
fn pixel_span(low: f32, high: f32, count: u32) -> std::ops::Range<usize> {
|
||||
let first = low.floor().clamp(0.0, count as f32) as usize;
|
||||
let end = (high.floor() + 1.0).clamp(0.0, count as f32) as usize;
|
||||
first..end.max(first)
|
||||
}
|
||||
|
||||
/// Texture coordinates of `triangle`'s corners
|
||||
fn uv_corners(mesh: &Mesh, triangle: usize) -> Option<[Vec2; 3]> {
|
||||
let [first, second, third] = mesh.tri(triangle)?;
|
||||
Some([*mesh.uvs.get(first)?, *mesh.uvs.get(second)?, *mesh.uvs.get(third)?])
|
||||
}
|
||||
|
||||
/// The polygon diagonals of `triangle`: edges the importer added to split a polygon
|
||||
fn polygon_edges(mesh: &Mesh, triangle: usize) -> Vec<(u32, u32)> {
|
||||
let hidden = mesh.diagonals.get(triangle).copied().unwrap_or(0);
|
||||
let Some(vertices) = mesh.indices.get(triangle * 3..triangle * 3 + 3) else { return Vec::new() };
|
||||
|
||||
(0..3)
|
||||
.filter(|edge| hidden >> edge & 1 == 1)
|
||||
.map(|edge| {
|
||||
let (from, to) = (vertices[edge], vertices[(edge + 1) % 3]);
|
||||
(from.min(to), from.max(to))
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// `triangle`'s edges in UV space: imports often split vertices along hard edges where the UVs run on, so vertex indices alone break islands apart
|
||||
fn uv_edges(mesh: &Mesh, triangle: usize) -> Vec<([i64; 2], [i64; 2])> {
|
||||
let corner = |uv: Vec2| (uv * CORNER_GRID_STEPS).round().to_array().map(|step| step as i64);
|
||||
let Some([first, second, third]) = uv_corners(mesh, triangle).map(|uvs| uvs.map(corner)) else { return Vec::new() };
|
||||
|
||||
[(first, second), (second, third), (third, first)].map(|(from, to)| (from.min(to), from.max(to))).to_vec()
|
||||
}
|
||||
|
||||
/// `triangle`'s edges by position: UV seams and hard edges split vertices but leave the geometry connected
|
||||
fn position_edges(mesh: &Mesh, triangle: usize) -> Vec<([i64; 3], [i64; 3])> {
|
||||
let corner = |vertex: usize| mesh.positions.get(vertex).map(|position| (*position * CORNER_GRID_STEPS).round().to_array().map(|step| step as i64));
|
||||
let Some([first, second, third]) = mesh.tri(triangle) else { return Vec::new() };
|
||||
let (Some(first), Some(second), Some(third)) = (corner(first), corner(second), corner(third)) else { return Vec::new() };
|
||||
|
||||
[(first, second), (second, third), (third, first)].map(|(from, to)| (from.min(to), from.max(to))).to_vec()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use texturecraft_core::Channel;
|
||||
use texturecraft_geom::glam::{Vec2, Vec3};
|
||||
use texturecraft_geom::mesh::Mesh;
|
||||
use texturecraft_geom::primitives;
|
||||
|
||||
use crate::fill_hit_test::FillHitTest;
|
||||
use crate::fill_mode::FillMode;
|
||||
use crate::session::{Session, Tool};
|
||||
|
||||
/// The roughness the test fills paint, to tell filled texels apart
|
||||
const FILL_ROUGHNESS: f32 = 0.9;
|
||||
|
||||
/// A polygon fill session on `mesh` painting roughness [`FILL_ROUGHNESS`]
|
||||
fn fill_session(mesh: Mesh) -> Session {
|
||||
let mut session = Session::new_project("t", mesh, "test", None, 128).unwrap();
|
||||
session.viewport = Vec2::new(400.0, 400.0);
|
||||
session.tool.tool = Tool::PolygonFill;
|
||||
session.tool.values.insert(Channel::Roughness, [FILL_ROUGHNESS; 3]);
|
||||
session.update();
|
||||
session
|
||||
}
|
||||
|
||||
/// Whether the texel at texture coordinate `uv` shows the fill's roughness
|
||||
fn filled_at(session: &Session, uv: Vec2) -> bool {
|
||||
let (width, height) = session.caches[0].size;
|
||||
let roughness = session.caches[0].composite.value(Channel::Roughness, (uv.x * width as f32) as u32, (uv.y * height as f32) as u32);
|
||||
(roughness[0] - FILL_ROUGHNESS).abs() < 0.01
|
||||
}
|
||||
|
||||
/// Two copies of a plane apart in space and in UV space, each triangle with its own three vertices (as hard edges or per-face imports leave a mesh)
|
||||
fn split_planes() -> (Mesh, usize) {
|
||||
let plane = primitives::plane(2.0, 4);
|
||||
let (mut positions, mut uvs) = (Vec::<Vec3>::new(), Vec::<Vec2>::new());
|
||||
for shift in [0.0, 0.5] {
|
||||
for vertex in plane.indices.iter().map(|index| *index as usize) {
|
||||
positions.push(plane.positions[vertex] + Vec3::Y * shift);
|
||||
uvs.push(plane.uvs[vertex] * 0.5 + shift);
|
||||
}
|
||||
}
|
||||
let indices = (0..positions.len() as u32).collect();
|
||||
let mesh = Mesh::from_parts(positions, None, uvs, indices, "m").unwrap();
|
||||
assert_eq!(mesh.vertex_count(), 6 * plane.triangle_count(), "no vertex is shared");
|
||||
(mesh, plane.triangle_count())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn uv_island_and_mesh_fills_follow_seams_split_vertices_leave_apart() {
|
||||
let (mesh, per_plane) = split_planes();
|
||||
let mut session = Session::new_project("t", mesh, "test", None, 128).unwrap();
|
||||
|
||||
for fill_mode in [FillMode::UvIsland, FillMode::Mesh] {
|
||||
session.tool.fill_mode = fill_mode;
|
||||
let groups = session.fill_partition(0);
|
||||
assert_eq!(groups.group(0).map(<[u32]>::len), Some(per_plane), "{fill_mode:?}: the whole first plane");
|
||||
assert_eq!(groups.group(per_plane as u32).map(<[u32]>::len), Some(per_plane), "{fill_mode:?}: only the second plane");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn polygon_mode_groups_the_two_triangles_of_each_quad() {
|
||||
let mut session = fill_session(primitives::plane(2.0, 2));
|
||||
|
||||
session.tool.fill_mode = FillMode::Triangle;
|
||||
assert_eq!(session.fill_partition(0).group(0), Some(&[0][..]));
|
||||
|
||||
session.tool.fill_mode = FillMode::Polygon;
|
||||
let mut quad = session.fill_partition(0).group(0).unwrap().to_vec();
|
||||
quad.sort_unstable();
|
||||
assert_eq!(quad, [0, 1], "the quad's two triangles and no other quad");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_uv_box_over_half_a_plane_fills_that_half() {
|
||||
let mut session = fill_session(primitives::plane(2.0, 4));
|
||||
session.tool.fill_hit_test = FillHitTest::ContainedCenter;
|
||||
|
||||
let filled = session.polygon_fill_box_uv(Vec2::new(-0.01, -0.01), Vec2::new(0.5, 1.01)).unwrap();
|
||||
session.update();
|
||||
|
||||
assert_eq!(filled, 16, "the left two columns of quads");
|
||||
assert!(filled_at(&session, Vec2::new(0.1, 0.5)) && filled_at(&session, Vec2::new(0.45, 0.9)));
|
||||
assert!(!filled_at(&session, Vec2::new(0.55, 0.5)) && !filled_at(&session, Vec2::new(0.9, 0.1)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn intersection_and_contained_center_differ_on_a_box_missing_a_quads_center() {
|
||||
let mut session = fill_session(primitives::plane(2.0, 2));
|
||||
session.tool.fill_mode = FillMode::Polygon;
|
||||
let (corner, opposite) = (Vec2::new(0.0, 0.0), Vec2::new(0.2, 0.2));
|
||||
|
||||
session.tool.fill_hit_test = FillHitTest::ContainedCenter;
|
||||
assert_eq!(session.polygon_fill_box_uv(corner, opposite).unwrap(), 0, "the quad's center (0.25, 0.25) is outside");
|
||||
assert_ne!(session.undo_label(), Some("Polygon fill"), "an empty box records no undo step");
|
||||
|
||||
session.tool.fill_hit_test = FillHitTest::Intersection;
|
||||
assert_eq!(session.polygon_fill_box_uv(corner, opposite).unwrap(), 2, "the quad the box cuts");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn visible_only_skips_the_back_of_a_cube() {
|
||||
let mut session = fill_session(primitives::cube(1.0));
|
||||
session.camera.yaw = 0.6;
|
||||
session.camera.pitch = 0.4;
|
||||
let (low, high) = (Vec2::ZERO, session.viewport);
|
||||
let every_triangle = session.mesh.triangle_count();
|
||||
|
||||
session.tool.fill_visible_only = true;
|
||||
assert_eq!(session.polygon_fill_box(low, high, session.viewport).unwrap(), every_triangle / 2, "the three sides the camera sees");
|
||||
|
||||
session.tool.fill_visible_only = false;
|
||||
assert_eq!(session.polygon_fill_box(low, high, session.viewport).unwrap(), every_triangle);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn visible_only_sees_through_a_hidden_texture_set() {
|
||||
let mut session = fill_session(primitives::material_ball());
|
||||
let base = session.doc.project.texture_sets.iter().position(|set| set.name == "Base").unwrap();
|
||||
session.active_set = base;
|
||||
let (low, high) = (Vec2::ZERO, session.viewport);
|
||||
|
||||
let behind_the_ball = session.polygon_fill_box(low, high, session.viewport).unwrap();
|
||||
session.doc.project.texture_sets[0].visible = false;
|
||||
let ball_hidden = session.polygon_fill_box(low, high, session.viewport).unwrap();
|
||||
|
||||
assert!(ball_hidden > behind_the_ball, "hiding the ball shows more of the base: {ball_hidden} vs {behind_the_ball}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_dragged_box_fills_live_and_records_one_step_when_it_ends() {
|
||||
let mut session = fill_session(primitives::plane(2.0, 4));
|
||||
let history = session.history_labels().len();
|
||||
|
||||
assert_eq!(session.drag_polygon_fill_box_uv(Vec2::ZERO, Vec2::ONE).unwrap(), 32);
|
||||
assert_eq!(session.drag_polygon_fill_box_uv(Vec2::ZERO, Vec2::new(0.45, 1.0)).unwrap(), 16, "shrinking the box unfills");
|
||||
session.update();
|
||||
assert!(filled_at(&session, Vec2::new(0.2, 0.5)) && !filled_at(&session, Vec2::new(0.8, 0.5)), "the fill shows while dragging");
|
||||
assert_eq!(session.history_labels().len(), history, "no undo step yet");
|
||||
|
||||
assert_eq!(session.end_polygon_fill_box(), 16);
|
||||
assert_eq!(session.history_labels().len(), history + 1);
|
||||
session.undo().unwrap();
|
||||
session.update();
|
||||
assert!(!filled_at(&session, Vec2::new(0.2, 0.5)), "one undo removes the whole drag");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_failed_box_fill_leaves_no_drag_behind() {
|
||||
let mut session = fill_session(primitives::plane(2.0, 4));
|
||||
let layer = session.selected.remove(&0).unwrap();
|
||||
assert!(session.polygon_fill_box_uv(Vec2::ZERO, Vec2::ONE).is_err(), "no layer to paint on");
|
||||
|
||||
session.selected.insert(0, layer);
|
||||
assert_eq!(session.polygon_fill_box_uv(Vec2::ZERO, Vec2::ONE).unwrap(), 32, "the next box fills again");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn undo_and_tool_changes_finish_a_box_drag_first() {
|
||||
let mut session = fill_session(primitives::plane(2.0, 4));
|
||||
let history = session.history_labels().len();
|
||||
|
||||
session.drag_polygon_fill_box_uv(Vec2::ZERO, Vec2::ONE).unwrap();
|
||||
assert_eq!(session.undo().unwrap(), "Polygon fill", "undo takes back the drag it finished");
|
||||
assert!(session.polygon_fill_drag.is_none());
|
||||
assert_eq!(session.history_labels().len(), history);
|
||||
|
||||
session.drag_polygon_fill_box_uv(Vec2::ZERO, Vec2::ONE).unwrap();
|
||||
crate::tool_cmds::set_tool(&mut session, Tool::Paint).unwrap();
|
||||
assert!(session.polygon_fill_drag.is_none());
|
||||
assert_eq!(session.history_labels().len(), history + 1, "a tool change keeps the fill as one step");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_unmoved_box_keeps_its_fill() {
|
||||
let mut session = fill_session(primitives::plane(2.0, 4));
|
||||
let narrow_box = Vec2::new(0.3, 1.0);
|
||||
assert_eq!(session.drag_polygon_fill_box_uv(Vec2::ZERO, narrow_box).unwrap(), 16, "intersection: the two columns the box touches");
|
||||
|
||||
// Contained center would select one column, so a second selection would show 8
|
||||
session.tool.fill_hit_test = FillHitTest::ContainedCenter;
|
||||
assert_eq!(session.drag_polygon_fill_box_uv(Vec2::ZERO, narrow_box).unwrap(), 16, "the same box selects nothing again");
|
||||
assert_eq!(session.drag_polygon_fill_box_uv(Vec2::ZERO, narrow_box + Vec2::new(0.01, 0.0)).unwrap(), 8, "a moved box selects again");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_uv_box_over_the_second_uv_tile_fills_that_tile_only() {
|
||||
let mut session = fill_session(primitives::udim_plane());
|
||||
assert_eq!(session.doc.project.texture_sets[0].uv_tiles, [1001, 1002]);
|
||||
session.tool.fill_hit_test = FillHitTest::ContainedCenter;
|
||||
|
||||
let every_triangle = session.mesh.triangle_count();
|
||||
assert_eq!(session.polygon_fill_box_uv(Vec2::new(0.5, 0.0), Vec2::ONE).unwrap(), every_triangle / 2, "the atlas's right half is tile 1002");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_2d_click_skips_a_triangle_with_collapsed_uvs() {
|
||||
// A face left unmapped (all corners at UV 0,0) comes first, as imports often leave them
|
||||
let plane = primitives::plane(2.0, 1);
|
||||
let mut positions = vec![Vec3::ZERO, Vec3::X, Vec3::Z];
|
||||
let mut uvs = vec![Vec2::ZERO; 3];
|
||||
positions.extend(&plane.positions);
|
||||
uvs.extend(&plane.uvs);
|
||||
let indices = [0, 1, 2].into_iter().chain(plane.indices.iter().map(|index| index + 3)).collect();
|
||||
let mut session = fill_session(Mesh::from_parts(positions, None, uvs, indices, "m").unwrap());
|
||||
|
||||
assert_eq!(session.polygon_fill_uv(Vec2::new(0.2, 0.7)).unwrap(), 1);
|
||||
session.update();
|
||||
assert!(filled_at(&session, Vec2::new(0.2, 0.7)), "the triangle under the cursor, not the collapsed one");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_failing_drag_reports_once_and_records_nothing() {
|
||||
let mut session = fill_session(primitives::plane(2.0, 4));
|
||||
let history = session.history_labels().len();
|
||||
session.selected.clear();
|
||||
|
||||
assert!(session.drag_polygon_fill_box_uv(Vec2::ZERO, Vec2::new(0.5, 1.0)).is_err());
|
||||
assert_eq!(session.drag_polygon_fill_box_uv(Vec2::ZERO, Vec2::ONE).unwrap(), 0, "the rest of the drag fills nothing");
|
||||
assert_eq!(session.end_polygon_fill_box(), 0);
|
||||
assert_eq!(session.history_labels().len(), history);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_edit_during_a_drag_records_the_fill_first() {
|
||||
let mut session = fill_session(primitives::plane(2.0, 4));
|
||||
session.drag_polygon_fill_box_uv(Vec2::ZERO, Vec2::ONE).unwrap();
|
||||
|
||||
let layers = session.doc.project.layers.len();
|
||||
crate::execute(&mut session, "layer.add.paint", &serde_json::Value::Null).unwrap();
|
||||
assert!(session.polygon_fill_drag.is_none());
|
||||
let labels = session.history_labels();
|
||||
assert_eq!(labels.get(labels.len().wrapping_sub(2)).map(String::as_str), Some("Polygon fill"), "{labels:?}");
|
||||
|
||||
session.drag_polygon_fill_box_uv(Vec2::ZERO, Vec2::new(0.45, 1.0)).unwrap();
|
||||
assert_eq!(session.doc.project.layers.len(), layers + 1, "a later drag move keeps the added layer");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_zero_size_box_on_whole_pixels_selects_what_is_under_it() {
|
||||
let mut session = fill_session(primitives::cube(1.0));
|
||||
let center = (session.viewport * 0.5).floor();
|
||||
|
||||
assert!(session.polygon_fill_box(center, center, session.viewport).unwrap() > 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_camera_move_mid_drag_keeps_one_drag() {
|
||||
let mut session = fill_session(primitives::cube(1.0));
|
||||
let viewport = session.viewport;
|
||||
let history = session.history_labels().len();
|
||||
|
||||
let (corner, opposite) = (viewport * 0.4, viewport * 0.6);
|
||||
|
||||
let before_zoom = session.drag_polygon_fill_box(corner, opposite, viewport).unwrap();
|
||||
session.camera.zoom(0.5);
|
||||
let after_zoom = session.drag_polygon_fill_box(corner, opposite, viewport).unwrap();
|
||||
session.end_polygon_fill_box();
|
||||
|
||||
assert_ne!(before_zoom, after_zoom, "the same box selects again from the new camera");
|
||||
assert_eq!(session.history_labels().len(), history + 1, "a wheel zoom during the drag doesn't split it");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pixel_spans_include_both_edges_and_nothing_outside() {
|
||||
assert_eq!(super::pixel_span(2.0, 2.0, 100), 2..3, "a zero-size span on a whole pixel");
|
||||
assert_eq!(super::pixel_span(-50.0, -10.0, 100), 0..0, "before the first pixel");
|
||||
assert_eq!(super::pixel_span(120.0, 150.0, 100), 100..100, "past the last pixel");
|
||||
assert_eq!(super::pixel_span(-5.0, 500.0, 100), 0..100);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_2d_click_fills_the_triangle_under_it() {
|
||||
let mut session = fill_session(primitives::plane(2.0, 1));
|
||||
|
||||
assert_eq!(session.polygon_fill_uv(Vec2::new(0.2, 0.7)).unwrap(), 1);
|
||||
session.update();
|
||||
|
||||
assert!(filled_at(&session, Vec2::new(0.2, 0.7)));
|
||||
assert!(!filled_at(&session, Vec2::new(0.7, 0.2)), "the quad's other triangle stays");
|
||||
assert!(session.polygon_fill_uv(Vec2::new(1.5, 0.5)).is_err(), "nothing outside the UVs");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,42 @@
|
||||
//! A polygon fill box being dragged: what it filled so far and what it needs to refill each move.
|
||||
|
||||
use std::collections::{BTreeMap, BTreeSet};
|
||||
|
||||
use texturecraft_core::LayerId;
|
||||
use texturecraft_geom::OrbitCamera;
|
||||
use texturecraft_geom::glam::Vec2;
|
||||
use texturecraft_paint::EyeDepth;
|
||||
use texturecraft_texel::TileImage;
|
||||
|
||||
use crate::session::{Document, StackTarget};
|
||||
use crate::triangle_partition::TrianglePartition;
|
||||
|
||||
/// A polygon fill box being dragged: the fill shows live and becomes one undo step when the drag ends
|
||||
pub(crate) struct PolygonFillDrag {
|
||||
/// The texture set it fills
|
||||
pub ts: usize,
|
||||
/// The selected layer and content, mask or effect being filled
|
||||
pub target: (Option<LayerId>, StackTarget),
|
||||
/// The 3D view's size in pixels, or None for a drag in the 2D view
|
||||
pub viewport: Option<Vec2>,
|
||||
/// The camera [`PolygonFillDrag::points`] and [`PolygonFillDrag::depth`] were made with
|
||||
pub camera: OrbitCamera,
|
||||
/// The document before the drag, refilled each time the selection changes
|
||||
pub before: Document,
|
||||
/// The quick mask's coverage before the drag, when the drag paints the quick mask
|
||||
pub quick_mask_before: Option<BTreeMap<usize, TileImage>>,
|
||||
/// Each vertex where the box sees it: viewport pixels in the 3D view (None behind the camera), texture coordinates in the 2D view
|
||||
pub points: Vec<Option<Vec2>>,
|
||||
/// What the camera sees (3D view, visible polygons only)
|
||||
pub depth: Option<EyeDepth>,
|
||||
/// What the fill mode fills together
|
||||
pub fill_groups: TrianglePartition,
|
||||
/// The polygons the box tests, when they differ from the fill groups
|
||||
pub polygons: Option<TrianglePartition>,
|
||||
/// The triangles filled so far
|
||||
pub filled: BTreeSet<u32>,
|
||||
/// The box last shown, lowest corner first: an unmoved box isn't selected again
|
||||
pub last_box: Option<(Vec2, Vec2)>,
|
||||
/// The fill failed (reported once): the rest of the drag fills nothing
|
||||
pub failed: bool,
|
||||
}
|
||||
@@ -1,14 +1,8 @@
|
||||
//! Shelf previews: built-in materials evaluated on a unit sphere seen from +Z, without a mesh or
|
||||
//! baked maps (generators that need mesh maps are approximated with world-space noise), and
|
||||
//! library filters. Cheap enough for lazily rendered thumbnails. Smart masks have their own baked
|
||||
//! preview ([`crate::mask_preview`]).
|
||||
//! Cheap shelf previews on a unit sphere: plain materials and library filters (smart ones use [`crate::orb_preview`])
|
||||
|
||||
use rayon::prelude::*;
|
||||
use texturecraft_compose::pattern::{Coords, procedural, world_noise};
|
||||
use texturecraft_core::{
|
||||
Channel, Effect, EffectKind, Fill, Filter, Generator, GeneratorKind, Layer, LayerKind, Mask, MaskBackground, Procedural, ProceduralKind, Project,
|
||||
Projection, Source, TextureSet, blend1,
|
||||
};
|
||||
use texturecraft_compose::pattern::{Coords, procedural};
|
||||
use texturecraft_core::{Channel, Effect, EffectKind, Fill, Filter, Layer, LayerKind, Procedural, ProceduralKind, Project, Projection, Source, TextureSet};
|
||||
use texturecraft_geom::glam::{Vec2, Vec3};
|
||||
|
||||
use crate::materials::{Builder, build};
|
||||
@@ -50,54 +44,13 @@ fn source(s: &Source, proj: &Projection, c: &Coords) -> Option<[f32; 3]> {
|
||||
}
|
||||
}
|
||||
|
||||
/// Approximate generator: mesh-map signals become world noise (a sphere has no edges or cavities).
|
||||
fn generator(g: &Generator, c: &Coords) -> f32 {
|
||||
let dir = Vec3::from(g.direction).try_normalize().unwrap_or(Vec3::Y);
|
||||
let wear = (world_noise(c.pos, 3.0, 91) - 0.5) * 2.2;
|
||||
let cavity = (world_noise(c.pos, 3.0, 57) - 0.3).clamp(0.0, 1.0) + (1.0 - c.nrm.y) * 0.1;
|
||||
let s = match g.kind {
|
||||
GeneratorKind::Position => c.pos.dot(dir) * 0.5 + 0.5,
|
||||
GeneratorKind::Direction => c.nrm.dot(dir) * 0.5 + 0.5,
|
||||
GeneratorKind::EdgeWear => wear,
|
||||
GeneratorKind::Curvature => 0.5 + wear * 0.5,
|
||||
GeneratorKind::AmbientOcclusion => 1.0 - cavity,
|
||||
_ => cavity,
|
||||
};
|
||||
// Same thresholding as the compositor.
|
||||
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 soft = g.softness.max(1e-3);
|
||||
let t = ((s - (1.0 - g.level.clamp(0.0, 1.0) - 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 }
|
||||
}
|
||||
|
||||
fn mask(m: &Mask, c: &Coords) -> f32 {
|
||||
if !m.enabled {
|
||||
return 1.0;
|
||||
}
|
||||
let mut v = if m.background == MaskBackground::White { 1.0 } else { 0.0 };
|
||||
for e in m.effects.iter().filter(|e| e.visible) {
|
||||
let val = match &e.kind {
|
||||
EffectKind::Fill { source: s, projection } => source(s, projection, c).map(|x| x[0]),
|
||||
EffectKind::Generator(g) => Some(generator(g, c)),
|
||||
EffectKind::Levels(l) => Some(l.apply(v)),
|
||||
EffectKind::Filter(Filter::Invert) => Some(1.0 - v),
|
||||
_ => None,
|
||||
};
|
||||
if let Some(val) = val {
|
||||
let blended = if matches!(e.kind, EffectKind::Levels(_) | EffectKind::Filter(_)) { val } else { blend1(e.blend, v, val) };
|
||||
v += (blended - v) * e.opacity.clamp(0.0, 1.0);
|
||||
}
|
||||
}
|
||||
v.clamp(0.0, 1.0)
|
||||
}
|
||||
|
||||
const CHANNELS: [Channel; 4] = [Channel::BaseColor, Channel::Metallic, Channel::Roughness, Channel::Height];
|
||||
|
||||
/// Preview of built-in material `id` (None for an unknown id).
|
||||
/// Preview of plain material `id` (None for an unknown id or a smart material, whose masks need mesh maps)
|
||||
pub fn material(id: &str, size: usize) -> Option<Vec<Option<Sample>>> {
|
||||
let plain = crate::materials::find(id).filter(|found| !found.smart)?;
|
||||
let mut project = Project::new("preview", "");
|
||||
let layers = build(&mut Builder { p: &mut project, channels: CHANNELS.to_vec() }, id).ok()?;
|
||||
let layers = build(&mut Builder { p: &mut project, channels: CHANNELS.to_vec() }, plain.id).ok()?;
|
||||
|
||||
// Pixels evaluate independently and big previews take long on one core
|
||||
let normals: Vec<_> = sphere_normals(size).collect();
|
||||
@@ -106,23 +59,24 @@ pub fn material(id: &str, size: usize) -> Option<Vec<Option<Sample>>> {
|
||||
.map(|normal| {
|
||||
let at = coords(normal?);
|
||||
let mut values = CHANNELS.map(Channel::default_value);
|
||||
for layer in layers.iter().filter(|l| l.visible) {
|
||||
for layer in layers.iter().filter(|layer| layer.visible) {
|
||||
// Plain materials are unmasked fills
|
||||
let LayerKind::Fill(fill) = &layer.kind else { continue };
|
||||
|
||||
let coverage = layer.mask.as_ref().map_or(1.0, |m| mask(m, &at));
|
||||
for (value, channel) in values.iter_mut().zip(CHANNELS) {
|
||||
let layer_value = fill.sources.get(&channel).and_then(|s| source(s, &fill.projection, &at));
|
||||
let layer_value = fill.sources.get(&channel).and_then(|channel_source| source(channel_source, &fill.projection, &at));
|
||||
if let (Some(blend), Some(layer_value)) = (layer.blend(channel), layer_value) {
|
||||
let weight = coverage * blend.opacity.clamp(0.0, 1.0);
|
||||
*value = [0, 1, 2].map(|k| value[k] + (layer_value[k] - value[k]) * weight);
|
||||
let weight = blend.opacity.clamp(0.0, 1.0);
|
||||
*value = [0, 1, 2].map(|component| value[component] + (layer_value[component] - value[component]) * weight);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let [base, metal, rough, height] = values;
|
||||
Some(Sample { base, metallic: metal[0], roughness: rough[0], height: height[0] })
|
||||
let [base, metallic, roughness, height] = values;
|
||||
Some(Sample { base, metallic: metallic[0], roughness: roughness[0], height: height[0] })
|
||||
})
|
||||
.collect();
|
||||
|
||||
Some(samples)
|
||||
}
|
||||
|
||||
@@ -196,21 +150,40 @@ pub fn filter(id: &str, size: usize) -> Option<Vec<Option<Sample>>> {
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
/// Whether every value of `sample` is finite
|
||||
fn finite(sample: &Sample) -> bool {
|
||||
sample.base.into_iter().chain([sample.metallic, sample.roughness, sample.height]).all(f32::is_finite)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn previews_cover_the_sphere_with_finite_values() {
|
||||
for m in crate::materials::MATERIALS {
|
||||
let px = material(m.id, 16).unwrap_or_else(|| panic!("{}", m.id));
|
||||
let center = px[8 * 16 + 8].unwrap_or_else(|| panic!("{}", m.id));
|
||||
assert!(center.base.iter().chain([¢er.metallic, ¢er.roughness, ¢er.height]).all(|v| v.is_finite()), "{}", m.id);
|
||||
assert!(px[0].is_none(), "corners are outside the sphere");
|
||||
let size = 16;
|
||||
for built_in in crate::materials::MATERIALS {
|
||||
let id = built_in.id;
|
||||
if built_in.smart {
|
||||
assert!(material(id, size).is_none(), "{id}: smart materials preview on the orb");
|
||||
continue;
|
||||
}
|
||||
|
||||
let mut project = Project::new("preview", "");
|
||||
let layers = build(&mut Builder { p: &mut project, channels: CHANNELS.to_vec() }, id).unwrap();
|
||||
assert!(layers.iter().all(|layer| layer.mask.is_none()), "{id}: the sphere preview shows no masks");
|
||||
|
||||
let pixels = material(id, size).unwrap_or_else(|| panic!("{id}"));
|
||||
let center = pixels[size / 2 * size + size / 2].unwrap_or_else(|| panic!("{id}"));
|
||||
assert!(finite(¢er), "{id}");
|
||||
assert!(pixels[0].is_none(), "corners are outside the sphere");
|
||||
}
|
||||
assert!(material("nope", 8).is_none() && filter("nope", 8).is_none());
|
||||
for f in crate::filter_lib::FILTERS {
|
||||
let px = filter(f.id, 24).unwrap_or_else(|| panic!("{}", f.id));
|
||||
let center = px[12 * 24 + 12].unwrap_or_else(|| panic!("{}", f.id));
|
||||
assert!(center.base.iter().chain([¢er.roughness, ¢er.height]).all(|v| v.is_finite()), "{}", f.id);
|
||||
assert!(material("nope", size).is_none() && filter("nope", size).is_none());
|
||||
|
||||
let size = 24;
|
||||
for library_filter in crate::filter_lib::FILTERS {
|
||||
let id = library_filter.id;
|
||||
let pixels = filter(id, size).unwrap_or_else(|| panic!("{id}"));
|
||||
let center = pixels[size / 2 * size + size / 2].unwrap_or_else(|| panic!("{id}"));
|
||||
assert!(finite(¢er), "{id}");
|
||||
}
|
||||
let (plain, warped) = (filter("levels", 24).unwrap(), filter("warp", 24).unwrap());
|
||||
let (plain, warped) = (filter("levels", size).unwrap(), filter("warp", size).unwrap());
|
||||
assert!(plain != warped, "the warp shows in its preview");
|
||||
}
|
||||
}
|
||||
@@ -105,34 +105,37 @@ impl Session {
|
||||
/// Includes the stroke in progress.
|
||||
pub fn quick_mask_rgba(&self, ts: usize, size: u32) -> Option<Vec<u8>> {
|
||||
let cache = self.caches.get(ts)?;
|
||||
let (w, h) = cache.size;
|
||||
let size = size.clamp(1, w.max(h));
|
||||
let (width, height) = cache.size;
|
||||
let size = size.clamp(1, width.max(height));
|
||||
let mask = self.quick_mask_image(ts, cache.size);
|
||||
let live = self.stroke.as_ref().filter(|s| s.ts == ts && s.target.is_none()).map(|s| (&s.canvas.alpha, s.stroke.settings.opacity, s.erase));
|
||||
let base = cache.composite.channels.get(&Channel::BaseColor);
|
||||
let lut = srgb_lut();
|
||||
let srgb = srgb_lut();
|
||||
let inverted = self.quick_mask.inverted;
|
||||
let mut out = vec![255u8; size as usize * size as usize * 4];
|
||||
|
||||
out.par_chunks_mut(size as usize * 4).enumerate().for_each(|(y, row)| {
|
||||
let ty = (y as u64 * u64::from(h) / u64::from(size)) as u32;
|
||||
for (x, px) in row.chunks_exact_mut(4).enumerate() {
|
||||
let tx = (x as u64 * u64::from(w) / u64::from(size)) as u32;
|
||||
let mut m = from_u16(mask.get(tx, ty)[0]);
|
||||
let ty = (y as u64 * u64::from(height) / u64::from(size)) as u32;
|
||||
for (x, pixel) in row.as_chunks_mut::<4>().0.iter_mut().enumerate() {
|
||||
let tx = (x as u64 * u64::from(width) / u64::from(size)) as u32;
|
||||
let mut coverage = from_u16(mask.get(tx, ty)[0]);
|
||||
if let Some((alpha, opacity, erase)) = live {
|
||||
let a = from_u16(alpha.get(tx, ty)[0]) * opacity;
|
||||
m = if erase { m * (1.0 - a) } else { a + m * (1.0 - a) };
|
||||
let stroke_coverage = from_u16(alpha.get(tx, ty)[0]) * opacity;
|
||||
coverage = if erase { coverage * (1.0 - stroke_coverage) } else { stroke_coverage + coverage * (1.0 - stroke_coverage) };
|
||||
}
|
||||
let blocked = if inverted { m } else { 1.0 - m };
|
||||
|
||||
let blocked = if inverted { coverage } else { 1.0 - coverage };
|
||||
let raw = base.map(|b| b.get(tx, ty)).unwrap_or([32768; 4]);
|
||||
let t = 0.55 * blocked;
|
||||
let tint_amount = 0.55 * blocked;
|
||||
for (k, tint) in [0.9, 0.1, 0.15].into_iter().enumerate() {
|
||||
let c = f32::from(lut.get(usize::from(raw[k] >> 4)).copied().unwrap_or(0)) / 255.0;
|
||||
if let Some(slot) = px.get_mut(k) {
|
||||
*slot = ((c + (tint - c) * t).clamp(0.0, 1.0) * 255.0 + 0.5) as u8;
|
||||
let color = f32::from(srgb.get(usize::from(raw[k] >> 4)).copied().unwrap_or(0)) / 255.0;
|
||||
if let Some(slot) = pixel.get_mut(k) {
|
||||
*slot = ((color + (tint - color) * tint_amount).clamp(0.0, 1.0) * 255.0 + 0.5) as u8;
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
Some(out)
|
||||
}
|
||||
}
|
||||
@@ -36,12 +36,18 @@ pub(crate) fn decoded(d: texturecraft_formats::DecodedImage) -> Arc<ImageRes> {
|
||||
}
|
||||
|
||||
impl Session {
|
||||
/// Add an image resource from bytes (one undo step); returns its unique, sanitized name.
|
||||
/// Add an image resource from bytes (one undo step); returns its unique, sanitized name
|
||||
pub fn import_resource_bytes(&mut self, file_name: &str, bytes: Vec<u8>) -> Result<String> {
|
||||
self.edit("Import resource", |s| s.add_image_resource(file_name, bytes, u64::MAX))
|
||||
}
|
||||
|
||||
/// Add an image within a decoded texel budget, inside the caller's edit
|
||||
pub(crate) fn add_image_resource(&mut self, file_name: &str, bytes: Vec<u8>, max_texels: u64) -> Result<String> {
|
||||
if bytes.len() > MAX_BYTES {
|
||||
return Err(EngineError::Other(format!("{file_name} is larger than {} MB", MAX_BYTES >> 20)));
|
||||
}
|
||||
let image = texturecraft_formats::decode_image(&bytes).map_err(|e| EngineError::Other(format!("{file_name}: {e}")))?;
|
||||
|
||||
let image = texturecraft_formats::decode_image_within(&bytes, max_texels).map_err(|e| EngineError::Other(format!("{file_name}: {e}")))?;
|
||||
let leaf = std::path::Path::new(file_name).file_name().and_then(|n| n.to_str()).unwrap_or("image");
|
||||
let base = texturecraft_formats::sanitize_resource_name(leaf);
|
||||
let mut name = base.clone();
|
||||
@@ -50,11 +56,8 @@ impl Session {
|
||||
name = format!("{n}_{base}");
|
||||
n += 1;
|
||||
}
|
||||
let key = name.clone();
|
||||
self.edit("Import resource", |s| {
|
||||
s.doc.resources.insert(key, Arc::new(bytes));
|
||||
Ok(())
|
||||
})?;
|
||||
|
||||
self.doc.resources.insert(name.clone(), Arc::new(bytes));
|
||||
self.images.insert(name.clone(), decoded(image));
|
||||
Ok(name)
|
||||
}
|
||||
@@ -98,15 +101,44 @@ fn list(s: &Session) -> Value {
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
fn import(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let path = strp(p, "path").ok_or_else(|| bad("resource.import", "`path` is required"))?;
|
||||
let meta = std::fs::metadata(path).map_err(|e| bad("resource.import", format!("cannot read {path}: {e}")))?;
|
||||
if meta.len() > MAX_BYTES as u64 {
|
||||
return Err(bad("resource.import", format!("{path} is too large")));
|
||||
}
|
||||
let bytes = std::fs::read(path).map_err(|e| bad("resource.import", format!("cannot read {path}: {e}")))?;
|
||||
let bytes = read_image_file("resource.import", path, MAX_BYTES as u64)?;
|
||||
let name = s.import_resource_bytes(path, bytes)?;
|
||||
Ok(json!({ "name": name }))
|
||||
}
|
||||
|
||||
/// Read a regular image file within both the per-file cap and the caller's remaining byte budget
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
pub(crate) fn read_image_file(cmd: &str, path: &str, max_bytes: u64) -> Result<Vec<u8>> {
|
||||
use std::io::Read;
|
||||
|
||||
let max_bytes = max_bytes.min(MAX_BYTES as u64);
|
||||
let read_error = |error| bad(cmd, format!("cannot read {path}: {error}"));
|
||||
let too_large = || bad(cmd, format!("{path} is too large (limit {max_bytes} bytes)"));
|
||||
let metadata = std::fs::metadata(path).map_err(read_error)?;
|
||||
// Pipes can block on open, and devices may never reach EOF
|
||||
if !metadata.is_file() {
|
||||
return Err(bad(cmd, format!("{path} is not a regular file")));
|
||||
}
|
||||
if metadata.len() > max_bytes {
|
||||
return Err(too_large());
|
||||
}
|
||||
|
||||
// Bound the read even if the file grows after the metadata check
|
||||
let file = std::fs::File::open(path).map_err(read_error)?;
|
||||
let mut bytes = Vec::with_capacity(metadata.len() as usize);
|
||||
file.take(max_bytes + 1).read_to_end(&mut bytes).map_err(read_error)?;
|
||||
if bytes.len() as u64 > max_bytes {
|
||||
return Err(too_large());
|
||||
}
|
||||
|
||||
Ok(bytes)
|
||||
}
|
||||
|
||||
#[cfg(target_arch = "wasm32")]
|
||||
pub(crate) fn read_image_file(cmd: &str, _: &str, _: u64) -> Result<Vec<u8>> {
|
||||
Err(bad(cmd, "file paths are not available in the browser"))
|
||||
}
|
||||
|
||||
#[cfg(target_arch = "wasm32")]
|
||||
fn import(_: &mut Session, _: &Value) -> Result<Value> {
|
||||
Err(EngineError::Other("file paths are not available in the browser; use File > Import resources".into()))
|
||||
@@ -165,3 +197,24 @@ fn add_image_fill(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
})?;
|
||||
Ok(json!({ "layer": id.0 }))
|
||||
}
|
||||
|
||||
#[cfg(all(test, not(target_arch = "wasm32")))]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn file_reads_obey_the_remaining_byte_budget() {
|
||||
let path = std::env::temp_dir().join(format!("texturecraft-read-image-{}.png", std::process::id()));
|
||||
std::fs::write(&path, b"1234").unwrap();
|
||||
let name = path.to_str().unwrap();
|
||||
assert!(read_image_file("test", name, 3).unwrap_err().to_string().contains("too large"));
|
||||
assert_eq!(read_image_file("test", name, 4).unwrap(), b"1234");
|
||||
std::fs::remove_file(path).unwrap();
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn devices_are_rejected_before_reading() {
|
||||
assert!(read_image_file("test", "/dev/null", 16).unwrap_err().to_string().contains("not a regular file"));
|
||||
}
|
||||
}
|
||||
@@ -11,6 +11,7 @@ use texturecraft_geom::{Bvh, Mesh, OrbitCamera, UvGBuffer};
|
||||
use texturecraft_paint::{BrushSettings, EyeDepth, Stroke, StrokeCanvas};
|
||||
use texturecraft_texel::DilationMap;
|
||||
|
||||
use crate::fill_mode::FillMode;
|
||||
use crate::{EngineError, Result};
|
||||
|
||||
/// Padding (texels) applied to composites for display.
|
||||
@@ -160,15 +161,6 @@ impl ViewMode {
|
||||
}
|
||||
}
|
||||
|
||||
/// Polygon fill granularity.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
|
||||
pub enum FillMode {
|
||||
#[default]
|
||||
Triangle,
|
||||
UvIsland,
|
||||
Mesh,
|
||||
}
|
||||
|
||||
/// A screen-pinned image for the Projection tool (a stencil).
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||||
pub struct StencilState {
|
||||
@@ -210,6 +202,12 @@ pub struct ToolState {
|
||||
/// Gray painted into masks.
|
||||
pub mask_value: f32,
|
||||
pub fill_mode: FillMode,
|
||||
/// How a polygon fill box decides which polygons it selects
|
||||
#[serde(default)]
|
||||
pub fill_hit_test: crate::fill_hit_test::FillHitTest,
|
||||
/// Polygon fill boxes in the 3D view select only the polygons the camera sees
|
||||
#[serde(default = "default_fill_visible_only")]
|
||||
pub fill_visible_only: bool,
|
||||
/// Stencil used by the Projection tool.
|
||||
#[serde(default)]
|
||||
pub stencil: Option<StencilState>,
|
||||
@@ -231,6 +229,10 @@ fn default_smudge_strength() -> f32 {
|
||||
0.5
|
||||
}
|
||||
|
||||
fn default_fill_visible_only() -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
/// What the Clone tool copies (the clone source modes).
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
|
||||
pub enum CloneFrom {
|
||||
@@ -260,6 +262,8 @@ impl Default for ToolState {
|
||||
enabled: [Channel::BaseColor, Channel::Metallic, Channel::Roughness, Channel::Height, Channel::Normal].into_iter().collect(),
|
||||
mask_value: 1.0,
|
||||
fill_mode: FillMode::Triangle,
|
||||
fill_hit_test: Default::default(),
|
||||
fill_visible_only: default_fill_visible_only(),
|
||||
stencil: None,
|
||||
smudge_strength: default_smudge_strength(),
|
||||
clone_source: None,
|
||||
@@ -291,8 +295,8 @@ pub(crate) struct ActiveStroke {
|
||||
pub canvas: StrokeCanvas,
|
||||
/// Camera visibility for 3D strokes (None for strokes in the 2D view).
|
||||
pub depth: Option<Arc<EyeDepth>>,
|
||||
/// 2D view strokes: last UV point and the distance carried to the next stamp.
|
||||
pub uv: Option<(Option<Vec2>, f32)>,
|
||||
/// 2D view strokes: where the stroke is between samples.
|
||||
pub uv: Option<crate::uv_stroke_state::UvStrokeState>,
|
||||
pub camera: OrbitCamera,
|
||||
pub viewport: Vec2,
|
||||
pub values: BTreeMap<Channel, [f32; 3]>,
|
||||
@@ -314,6 +318,9 @@ pub struct Session {
|
||||
pub mesh: Arc<Mesh>,
|
||||
/// Unique per loaded mesh and UV layout (GPU caches compare it).
|
||||
pub mesh_id: u64,
|
||||
/// Unique per open project: a mesh reimport or UV layout change keeps it, and opening, closing
|
||||
/// or creating a project replaces it.
|
||||
pub project_id: u64,
|
||||
/// The mesh with its own UVs (`mesh` maps UV-tiled sets into their atlas).
|
||||
pub(crate) source: Arc<Mesh>,
|
||||
pub bvh: Arc<Bvh>,
|
||||
@@ -334,6 +341,8 @@ pub struct Session {
|
||||
pub target: StackTarget,
|
||||
pub camera: OrbitCamera,
|
||||
pub view: ViewMode,
|
||||
/// The live bake preview while the app bakes (see [`crate::bake_preview`]).
|
||||
pub bake_preview: Option<crate::bake_preview::BakePreview>,
|
||||
/// Viewport size (pixels) used by scripted strokes.
|
||||
pub viewport: Vec2,
|
||||
pub(crate) stroke: Option<ActiveStroke>,
|
||||
@@ -356,6 +365,8 @@ pub struct Session {
|
||||
/// The last stroke's camera visibility buffer: reused while the camera, view size and mesh
|
||||
/// are unchanged, so back-to-back dabs start instantly.
|
||||
pub(crate) depth_cache: Option<DepthCache>,
|
||||
/// The polygon fill box being dragged
|
||||
pub(crate) polygon_fill_drag: Option<crate::polygon_fill_drag::PolygonFillDrag>,
|
||||
/// The user's export presets (kept when another project opens).
|
||||
pub export_presets: crate::preset_cmds::UserPresets,
|
||||
/// The user's project templates (kept when another project opens).
|
||||
@@ -378,6 +389,7 @@ impl Session {
|
||||
Ok(Session {
|
||||
doc,
|
||||
mesh_id: next_mesh_id(),
|
||||
project_id: next_mesh_id(),
|
||||
source,
|
||||
mesh,
|
||||
bvh: Arc::new(bvh),
|
||||
@@ -393,6 +405,7 @@ impl Session {
|
||||
target: StackTarget::Content,
|
||||
camera,
|
||||
view: ViewMode::Material,
|
||||
bake_preview: None,
|
||||
viewport: Vec2::new(1280.0, 800.0),
|
||||
stroke: None,
|
||||
clipboard: None,
|
||||
@@ -405,6 +418,7 @@ impl Session {
|
||||
revision: 1,
|
||||
log: Vec::new(),
|
||||
depth_cache: None,
|
||||
polygon_fill_drag: None,
|
||||
export_presets: Default::default(),
|
||||
templates: Default::default(),
|
||||
})
|
||||
@@ -489,22 +503,24 @@ impl Session {
|
||||
self.edit_merging(label, self.merge_edits, f)
|
||||
}
|
||||
|
||||
/// [`Session::edit`] that, with `merge`, continues the previous undo step when it has the
|
||||
/// same label (a drag in the viewport is one step however many updates it makes).
|
||||
pub fn edit_merging<T>(&mut self, label: &str, merge: bool, f: impl FnOnce(&mut Session) -> Result<T>) -> Result<T> {
|
||||
/// [`Session::edit`] that, with `merge`, continues the previous undo step when it has the same label (a viewport drag is one step however many updates it makes).
|
||||
pub fn edit_merging<T>(&mut self, label: &str, merge: bool, change: impl FnOnce(&mut Session) -> Result<T>) -> Result<T> {
|
||||
// A box fill under way becomes its own step first, so this edit isn't written over or folded into it
|
||||
self.end_polygon_fill_box();
|
||||
|
||||
let before = self.doc.clone();
|
||||
let result = f(self).and_then(|v| match self.doc.project.instance_cycle() {
|
||||
let result = change(self).and_then(|value| match self.doc.project.instance_cycle() {
|
||||
Some(id) => Err(EngineError::Other(format!("instance layer {} would draw itself", id.0))),
|
||||
None => Ok(v),
|
||||
None => Ok(value),
|
||||
});
|
||||
match result {
|
||||
Ok(v) => {
|
||||
Ok(value) => {
|
||||
self.record(label, before, merge);
|
||||
Ok(v)
|
||||
Ok(value)
|
||||
}
|
||||
Err(e) => {
|
||||
Err(error) => {
|
||||
self.doc = before;
|
||||
Err(e)
|
||||
Err(error)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -530,7 +546,7 @@ impl Session {
|
||||
|
||||
/// Mark dirty every texture set whose composite differs between `other` and the current
|
||||
/// document (after an edit, undo or redo).
|
||||
fn invalidate_changed(&mut self, other: &Document) {
|
||||
pub(crate) fn invalidate_changed(&mut self, other: &Document) {
|
||||
self.follow_uv_layouts(&other.project);
|
||||
self.sync_caches();
|
||||
let resources = |d: &Document| d.resources.iter().map(|(n, b)| (n.clone(), Arc::as_ptr(b))).collect::<Vec<_>>();
|
||||
@@ -625,25 +641,29 @@ impl Session {
|
||||
}
|
||||
|
||||
pub fn undo(&mut self) -> Result<String> {
|
||||
// A stroke, a box fill or an edited path under way would otherwise write over the restored document
|
||||
self.cancel_stroke();
|
||||
// An edited path would otherwise repaint over the restored document.
|
||||
self.end_polygon_fill_box();
|
||||
self.stop_path_edit();
|
||||
let (label, doc) = self.undo.pop().ok_or_else(|| EngineError::Other("nothing to undo".into()))?;
|
||||
let now = std::mem::replace(&mut self.doc, doc);
|
||||
self.after_history(&now);
|
||||
self.redo.push((label.clone(), now));
|
||||
|
||||
let (label, restored) = self.undo.pop().ok_or_else(|| EngineError::Other("nothing to undo".into()))?;
|
||||
let current = std::mem::replace(&mut self.doc, restored);
|
||||
self.after_history(¤t);
|
||||
self.redo.push((label.clone(), current));
|
||||
self.sync_images();
|
||||
Ok(label)
|
||||
}
|
||||
|
||||
pub fn redo(&mut self) -> Result<String> {
|
||||
// A stroke, a box fill or an edited path under way would otherwise write over the restored document
|
||||
self.cancel_stroke();
|
||||
// An edited path would otherwise repaint over the restored document.
|
||||
self.end_polygon_fill_box();
|
||||
self.stop_path_edit();
|
||||
let (label, doc) = self.redo.pop().ok_or_else(|| EngineError::Other("nothing to redo".into()))?;
|
||||
let now = std::mem::replace(&mut self.doc, doc);
|
||||
self.after_history(&now);
|
||||
self.undo.push((label.clone(), now));
|
||||
|
||||
let (label, restored) = self.redo.pop().ok_or_else(|| EngineError::Other("nothing to redo".into()))?;
|
||||
let current = std::mem::replace(&mut self.doc, restored);
|
||||
self.after_history(¤t);
|
||||
self.undo.push((label.clone(), current));
|
||||
self.sync_images();
|
||||
Ok(label)
|
||||
}
|
||||
|
||||
@@ -62,14 +62,14 @@ pub fn find(name: &str) -> Option<&'static SmartMask> {
|
||||
|
||||
const UP: [f32; 3] = [0.0, 1.0, 0.0];
|
||||
|
||||
/// A mesh-map generator with explicit threshold, softness and noise breakup.
|
||||
/// A mesh-map generator with explicit threshold, softness and noise breakup (curvature as baked, without detail sizes).
|
||||
pub(crate) fn generator(kind: GeneratorKind, level: f32, softness: f32, noise: f32) -> EffectKind {
|
||||
EffectKind::Generator(Generator { level, softness, noise_amount: noise, ..Generator::new(kind) })
|
||||
EffectKind::Generator(Generator { level, softness, noise_amount: noise, detail: None, ..Generator::new(kind) })
|
||||
}
|
||||
|
||||
/// A direction or position generator (`invert` flips the result).
|
||||
pub(crate) fn directional(kind: GeneratorKind, direction: [f32; 3], level: f32, softness: f32, noise: f32, invert: bool) -> EffectKind {
|
||||
EffectKind::Generator(Generator { level, softness, noise_amount: noise, direction, invert, ..Generator::new(kind) })
|
||||
EffectKind::Generator(Generator { level, softness, noise_amount: noise, direction, invert, detail: None, ..Generator::new(kind) })
|
||||
}
|
||||
|
||||
/// A triplanar grayscale pattern fill.
|
||||
|
||||
@@ -7,7 +7,9 @@ use texturecraft_geom::glam::Vec2;
|
||||
use texturecraft_paint::{Alignment, BrushAlpha, alphas};
|
||||
|
||||
use crate::commands::{CommandSpec, always, bad, boolp, channel_param, color_param, f32p, strp};
|
||||
use crate::session::{CloneFrom, CloneSource, FillMode, Tool};
|
||||
use crate::fill_hit_test::FillHitTest;
|
||||
use crate::fill_mode::FillMode;
|
||||
use crate::session::{CloneFrom, CloneSource, Tool};
|
||||
use crate::{Result, Session, cmd};
|
||||
|
||||
pub fn specs() -> Vec<CommandSpec> {
|
||||
@@ -69,7 +71,16 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
always,
|
||||
clone_source
|
||||
),
|
||||
cmd!("tool.fillMode", "Polygon fill mode", [], None, "{mode: triangle|uvIsland|mesh}", always, fill_mode),
|
||||
cmd!("tool.fillMode", "Polygon fill mode", [], None, "{mode: triangle|polygon|uvIsland|mesh}", always, fill_mode),
|
||||
cmd!(
|
||||
"tool.fillSelection",
|
||||
"Polygon fill selection",
|
||||
[],
|
||||
None,
|
||||
"{hitTest?: intersection|containedCenter (a box selects polygons it touches, or whose center it holds), visibleOnly?: bool (3D view boxes select only what the camera sees)}",
|
||||
always,
|
||||
fill_selection
|
||||
),
|
||||
cmd!("tool.stroke", "Paint stroke", [], None, "{points: [[x,y],...] viewport pixels, viewport?: [w,h]} — paints with the current tool", always, stroke),
|
||||
cmd!(
|
||||
"tool.strokeUv",
|
||||
@@ -80,16 +91,26 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
always,
|
||||
stroke_uv
|
||||
),
|
||||
cmd!("tool.click", "Tool click", [], None, "{x, y, viewport?: [w,h]} — polygon fill / color picker / single dab", always, click),
|
||||
cmd!(
|
||||
"tool.click",
|
||||
"Tool click",
|
||||
[],
|
||||
None,
|
||||
"{x, y, viewport?: [w,h]} — polygon fill / color picker / single dab; polygon fill also takes a box {x0, y0, x1, y1, viewport?}, a 2D view point {uv: [u,v]} or a 2D view box {uv0: [u,v], uv1: [u,v]}",
|
||||
always,
|
||||
click
|
||||
),
|
||||
cmd!("tool.state", "Tool state", [], None, "{}", always, |s, _| Ok(serde_json::to_value(&s.tool).unwrap_or(Value::Null))),
|
||||
]
|
||||
}
|
||||
|
||||
pub(crate) fn set_tool(s: &mut Session, t: Tool) -> Result<Value> {
|
||||
s.cancel_stroke();
|
||||
s.tool.tool = t;
|
||||
s.revision = s.revision.wrapping_add(1);
|
||||
Ok(json!({ "tool": t.id() }))
|
||||
pub(crate) fn set_tool(session: &mut Session, tool: Tool) -> Result<Value> {
|
||||
session.cancel_stroke();
|
||||
// A box fill under way keeps what it filled as one undo step
|
||||
session.end_polygon_fill_box();
|
||||
session.tool.tool = tool;
|
||||
session.revision = session.revision.wrapping_add(1);
|
||||
Ok(json!({ "tool": tool.id() }))
|
||||
}
|
||||
|
||||
fn select(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
@@ -319,13 +340,29 @@ fn clone_source(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
Ok(serde_json::to_value(s.tool.clone_source).unwrap_or(Value::Null))
|
||||
}
|
||||
|
||||
fn fill_mode(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
s.tool.fill_mode = match strp(p, "mode").unwrap_or("triangle") {
|
||||
fn fill_mode(session: &mut Session, params: &Value) -> Result<Value> {
|
||||
session.tool.fill_mode = match strp(params, "mode").unwrap_or("triangle") {
|
||||
"triangle" => FillMode::Triangle,
|
||||
"polygon" => FillMode::Polygon,
|
||||
"uvIsland" | "island" => FillMode::UvIsland,
|
||||
"mesh" => FillMode::Mesh,
|
||||
other => return Err(bad("tool.fillMode", format!("unknown fill mode `{other}`"))),
|
||||
};
|
||||
|
||||
Ok(Value::Null)
|
||||
}
|
||||
|
||||
fn fill_selection(session: &mut Session, params: &Value) -> Result<Value> {
|
||||
match strp(params, "hitTest") {
|
||||
None => {}
|
||||
Some("intersection") => session.tool.fill_hit_test = FillHitTest::Intersection,
|
||||
Some("containedCenter") => session.tool.fill_hit_test = FillHitTest::ContainedCenter,
|
||||
Some(other) => return Err(bad("tool.fillSelection", format!("unknown hit-test `{other}` (intersection or containedCenter)"))),
|
||||
}
|
||||
if let Some(visible_only) = boolp(params, "visibleOnly") {
|
||||
session.tool.fill_visible_only = visible_only;
|
||||
}
|
||||
|
||||
Ok(Value::Null)
|
||||
}
|
||||
|
||||
@@ -369,22 +406,48 @@ fn stroke(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
Ok(json!({ "stamps": stamps }))
|
||||
}
|
||||
|
||||
fn click(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let (Some(x), Some(y)) = (f32p(p, "x"), f32p(p, "y")) else { return Err(bad("tool.click", "`x` and `y` are required")) };
|
||||
let vp = viewport_of(s, p);
|
||||
let out = match s.tool.tool {
|
||||
Tool::PolygonFill => json!({ "triangles": s.polygon_fill(Vec2::new(x, y), vp)? }),
|
||||
fn click(session: &mut Session, params: &Value) -> Result<Value> {
|
||||
if session.tool.tool == Tool::PolygonFill
|
||||
&& let Some(triangles) = polygon_fill_click(session, params)?
|
||||
{
|
||||
session.update();
|
||||
return Ok(json!({ "triangles": triangles }));
|
||||
}
|
||||
|
||||
let (Some(x), Some(y)) = (f32p(params, "x"), f32p(params, "y")) else { return Err(bad("tool.click", "`x` and `y` are required")) };
|
||||
|
||||
let point = Vec2::new(x, y);
|
||||
let viewport = viewport_of(session, params);
|
||||
let out = match session.tool.tool {
|
||||
Tool::PolygonFill => json!({ "triangles": session.polygon_fill(point, viewport)? }),
|
||||
Tool::ColorPicker => {
|
||||
let v = s.color_pick(Vec2::new(x, y), vp)?;
|
||||
json!(v.iter().map(|(c, v)| (c.id().to_string(), json!(v))).collect::<serde_json::Map<_, _>>())
|
||||
let picked = session.color_pick(point, viewport)?;
|
||||
json!(picked.iter().map(|(channel, value)| (channel.id().to_string(), json!(value))).collect::<serde_json::Map<_, _>>())
|
||||
}
|
||||
Tool::GeometryMask => crate::instance_cmds::toggle_part_at(s, Vec2::new(x, y), vp)?,
|
||||
_ => json!({ "stamps": s.stroke_points(&[Vec2::new(x, y)], vp)? }),
|
||||
Tool::GeometryMask => crate::instance_cmds::toggle_part_at(session, point, viewport)?,
|
||||
_ => json!({ "stamps": session.stroke_points(&[point], viewport)? }),
|
||||
};
|
||||
s.update();
|
||||
session.update();
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// The polygon fill forms of `tool.click` besides a plain `{x, y}` point: None for that point
|
||||
fn polygon_fill_click(session: &mut Session, params: &Value) -> Result<Option<usize>> {
|
||||
let screen_box = (f32p(params, "x0"), f32p(params, "y0"), f32p(params, "x1"), f32p(params, "y1"));
|
||||
let given = |keys: &[&str]| keys.iter().any(|key| params.get(*key).is_some());
|
||||
let filled = match (pair(params, "uv0"), pair(params, "uv1"), pair(params, "uv"), screen_box) {
|
||||
(Some(corner), Some(opposite), ..) => session.polygon_fill_box_uv(corner.into(), opposite.into())?,
|
||||
_ if given(&["uv0", "uv1"]) => return Err(bad("tool.click", "a UV box needs `uv0` and `uv1` as [u, v]")),
|
||||
(_, _, Some(uv), _) => session.polygon_fill_uv(uv.into())?,
|
||||
_ if given(&["uv"]) => return Err(bad("tool.click", "a 2D view point needs `uv` as [u, v]")),
|
||||
(.., (Some(x0), Some(y0), Some(x1), Some(y1))) => session.polygon_fill_box(Vec2::new(x0, y0), Vec2::new(x1, y1), viewport_of(session, params))?,
|
||||
_ if given(&["x0", "y0", "x1", "y1"]) => return Err(bad("tool.click", "a screen box needs numbers `x0`, `y0`, `x1` and `y1`")),
|
||||
_ => return Ok(None),
|
||||
};
|
||||
|
||||
Ok(Some(filled))
|
||||
}
|
||||
|
||||
fn stroke_uv(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let points = points_param("tool.strokeUv", p, "points")?.ok_or_else(|| bad("tool.strokeUv", "`points` must be an array of [u, v]"))?;
|
||||
let tiles = s.stroke_uv_points(&points)?;
|
||||
|
||||
@@ -0,0 +1,123 @@
|
||||
//! Triangles of one material grouped into the pieces polygon fill selects and fills.
|
||||
|
||||
use std::collections::HashMap;
|
||||
use std::hash::Hash;
|
||||
|
||||
use texturecraft_geom::Mesh;
|
||||
|
||||
/// A material's triangles split into groups joined across shared edges
|
||||
pub struct TrianglePartition {
|
||||
/// The triangles of each group
|
||||
pub groups: Vec<Vec<u32>>,
|
||||
/// The index of each triangle's group
|
||||
group_of: HashMap<u32, usize>,
|
||||
}
|
||||
|
||||
impl TrianglePartition {
|
||||
/// Group `material`'s triangles of `mesh`: two triangles join when `edges` names a key for both
|
||||
pub fn new<K: Eq + Hash + Clone>(mesh: &Mesh, material: usize, edges: impl Fn(&Mesh, usize) -> Vec<K>) -> TrianglePartition {
|
||||
// Each triangle's edges once, in mesh order so the groups come out the same every time
|
||||
let triangles: Vec<u32> = mesh.triangles_of(material).map(|triangle| triangle as u32).collect();
|
||||
let position_of: HashMap<u32, usize> = triangles.iter().enumerate().map(|(position, triangle)| (*triangle, position)).collect();
|
||||
let mut edge_lists: Vec<Vec<K>> = triangles.iter().map(|triangle| edges(mesh, *triangle as usize)).collect();
|
||||
let mut by_edge: HashMap<K, Vec<u32>> = HashMap::new();
|
||||
for (triangle, triangle_edges) in triangles.iter().zip(&edge_lists) {
|
||||
for edge in triangle_edges {
|
||||
by_edge.entry(edge.clone()).or_default().push(*triangle);
|
||||
}
|
||||
}
|
||||
|
||||
let mut groups = Vec::new();
|
||||
let mut group_of = HashMap::with_capacity(triangles.len());
|
||||
for &start in &triangles {
|
||||
if group_of.contains_key(&start) {
|
||||
continue;
|
||||
}
|
||||
|
||||
let mut members = Vec::new();
|
||||
let mut stack = vec![start];
|
||||
group_of.insert(start, groups.len());
|
||||
while let Some(triangle) = stack.pop() {
|
||||
members.push(triangle);
|
||||
let triangle_edges = position_of.get(&triangle).and_then(|position| edge_lists.get_mut(*position)).map(std::mem::take).unwrap_or_default();
|
||||
// Visit a shared edge once, including when many collapsed faces share the same key
|
||||
for neighbour in triangle_edges.iter().flat_map(|edge| by_edge.remove(edge).into_iter().flatten()) {
|
||||
if let std::collections::hash_map::Entry::Vacant(entry) = group_of.entry(neighbour) {
|
||||
entry.insert(groups.len());
|
||||
stack.push(neighbour);
|
||||
}
|
||||
}
|
||||
}
|
||||
groups.push(members);
|
||||
}
|
||||
TrianglePartition { groups, group_of }
|
||||
}
|
||||
|
||||
/// The index in [`TrianglePartition::groups`] of the group holding `triangle` (None for a triangle of another material)
|
||||
pub fn index_of(&self, triangle: u32) -> Option<usize> {
|
||||
self.group_of.get(&triangle).copied()
|
||||
}
|
||||
|
||||
/// The group holding `triangle` (None for a triangle of another material)
|
||||
pub fn group(&self, triangle: u32) -> Option<&[u32]> {
|
||||
self.index_of(triangle).and_then(|group| self.groups.get(group)).map(Vec::as_slice)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use texturecraft_geom::primitives;
|
||||
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn triangles_sharing_a_key_join_one_group() {
|
||||
let mesh = primitives::plane(2.0, 2);
|
||||
let singles = TrianglePartition::new(&mesh, 0, |_, _| Vec::<u32>::new());
|
||||
let pairs = TrianglePartition::new(&mesh, 0, |_, triangle| vec![triangle / 2]);
|
||||
|
||||
assert_eq!(singles.groups.len(), mesh.triangle_count());
|
||||
assert_eq!(pairs.groups.len(), mesh.triangle_count() / 2);
|
||||
assert_eq!(pairs.group(3).map(<[u32]>::len), Some(2));
|
||||
assert_eq!(pairs.group(99), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn shared_edges_keep_transitive_neighbors() {
|
||||
let mesh = primitives::plane(2.0, 4);
|
||||
let groups = TrianglePartition::new(&mesh, 0, |_, triangle| vec![triangle / 4, (triangle + 1) / 4]);
|
||||
|
||||
assert_eq!(groups.groups.len(), 1);
|
||||
assert_eq!(groups.group(0).unwrap().len(), mesh.triangle_count());
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "release performance measurement"]
|
||||
fn benchmark_shared_edges() {
|
||||
use std::hint::black_box;
|
||||
use std::time::Instant;
|
||||
|
||||
for subdivisions in [32, 64] {
|
||||
let mesh = primitives::plane(2.0, subdivisions);
|
||||
for collapsed in [false, true] {
|
||||
let mut times = Vec::new();
|
||||
for _ in 0..5 {
|
||||
let start = Instant::now();
|
||||
let groups = TrianglePartition::new(&mesh, 0, |mesh, triangle| {
|
||||
if collapsed {
|
||||
vec![(0, 0); 3]
|
||||
} else {
|
||||
let [first, second, third] = mesh.tri(triangle).unwrap();
|
||||
[(first, second), (second, third), (third, first)].map(|(from, to)| (from.min(to), from.max(to))).to_vec()
|
||||
}
|
||||
});
|
||||
assert_eq!(groups.groups.len(), 1);
|
||||
black_box(groups);
|
||||
times.push(start.elapsed().as_secs_f64() * 1000.0);
|
||||
}
|
||||
times.sort_by(f64::total_cmp);
|
||||
eprintln!("{} triangles, collapsed={collapsed}, median={:.3} ms, range={:.3}..{:.3} ms", mesh.triangle_count(), times[2], times[0], times[4]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
//! Where a stroke in the 2D view is between pointer samples.
|
||||
|
||||
use texturecraft_geom::glam::Vec2;
|
||||
|
||||
/// A 2D view stroke's progress: its last point, the distance carried to the next stamp and the stamps so far.
|
||||
#[derive(Clone, Copy, Debug, Default)]
|
||||
pub(crate) struct UvStrokeState {
|
||||
/// The last sample's texture coordinates (None before the first sample).
|
||||
pub last: Option<Vec2>,
|
||||
/// Distance from the last stamp to the last sample, at most one stamp step.
|
||||
pub carry: f32,
|
||||
/// Stamps so far: the next stamp's seed, so noise alphas don't repeat from sample to sample.
|
||||
pub stamps: u32,
|
||||
}
|
||||
@@ -88,7 +88,13 @@ fn frame(s: &mut Session, _: &Value) -> Result<Value> {
|
||||
}
|
||||
|
||||
fn set_view(s: &mut Session, v: ViewMode) -> Result<Value> {
|
||||
s.view = v;
|
||||
if s.bake_preview.is_some() {
|
||||
// During a bake the view follows the preview: a mesh map pins it, another mode comes back afterwards
|
||||
s.bake_preview_user_view(v);
|
||||
} else {
|
||||
s.view = v;
|
||||
}
|
||||
let v = s.view;
|
||||
s.revision = s.revision.wrapping_add(1);
|
||||
Ok(json!({ "view": v.label() }))
|
||||
}
|
||||
|
||||
@@ -0,0 +1,428 @@
|
||||
//! Live bake preview: maps stream into the view while a bake runs, the view mode comes back,
|
||||
//! painting is paused, a cancelled bake leaves the set it was baking alone (sets finished before it
|
||||
//! stay applied), the streamed pixels are the ones a single bake makes, and the preview and the
|
||||
//! document share each map's buffer instead of holding two copies.
|
||||
|
||||
use serde_json::{Value, json};
|
||||
use texturecraft_engine::bake::Progress;
|
||||
use texturecraft_engine::core::{BakeResolution, BakedMap, Channel};
|
||||
use texturecraft_engine::geom::glam::Vec2;
|
||||
use texturecraft_engine::{BakeTask, PreviewShow, Session, ViewMode, execute};
|
||||
|
||||
const MAPS: [BakedMap; 4] = [BakedMap::Id, BakedMap::AmbientOcclusion, BakedMap::Curvature, BakedMap::Height];
|
||||
|
||||
fn session() -> Session {
|
||||
let mut session = texturecraft_engine::sample_session(256, 64).unwrap();
|
||||
for texture_set in &mut session.doc.project.texture_sets {
|
||||
texture_set.bake = Default::default();
|
||||
texture_set.bake.common.resolution = BakeResolution::R64;
|
||||
texture_set.bake.maps.ao.parameters.rays.rays = 8;
|
||||
texture_set.bake.maps.select(MAPS);
|
||||
}
|
||||
|
||||
session
|
||||
}
|
||||
|
||||
fn task(session: &Session) -> BakeTask {
|
||||
let mut task = session.bake_task(0).unwrap();
|
||||
task.tracer = None;
|
||||
task
|
||||
}
|
||||
|
||||
fn order(session: &Session) -> Vec<BakedMap> {
|
||||
task(session).maps()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn streamed_maps_are_the_pixels_of_one_bake() {
|
||||
let session = session();
|
||||
let task = task(&session);
|
||||
let whole = task.run(&Progress::new()).unwrap();
|
||||
let mut streamed = Vec::new();
|
||||
|
||||
let combined = task.run_streaming(&Progress::new(), &mut |map| streamed.push(map)).unwrap();
|
||||
|
||||
assert_eq!(streamed.iter().map(|map| map.map).collect::<Vec<_>>(), order(&session));
|
||||
assert_eq!(streamed.iter().map(|map| (map.index, map.total)).collect::<Vec<_>>(), (0..MAPS.len()).map(|index| (index, MAPS.len())).collect::<Vec<_>>());
|
||||
assert_eq!((combined.resolution, combined.height), (whole.resolution, whole.height));
|
||||
assert_eq!(combined.maps.keys().collect::<Vec<_>>(), whole.maps.keys().collect::<Vec<_>>());
|
||||
for (map, pixels) in &whole.maps {
|
||||
assert!(*combined.maps[map] == *pixels, "{map:?} differs between a streamed and a single bake");
|
||||
}
|
||||
for map in &streamed {
|
||||
assert!(*map.data == whole.maps[&map.map], "{:?} handed over differs from the bake", map.map);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_view_follows_each_map_and_the_previous_mode_comes_back() {
|
||||
let mut session = session();
|
||||
session.view = ViewMode::Channel(Channel::Roughness);
|
||||
let before = session.view;
|
||||
let baked_before = session.doc.baked.get(&0).cloned();
|
||||
let maps = order(&session);
|
||||
|
||||
session.bake_preview_begin(vec![(0, maps.clone())]);
|
||||
session.bake_preview_set_current(0);
|
||||
|
||||
// Nothing is baked yet: the first map shows, neutral
|
||||
assert_eq!(session.view, ViewMode::MeshMap(maps[0]));
|
||||
assert!(session.bake_preview_baked(0).is_some_and(|baked| baked.maps.is_empty()));
|
||||
|
||||
let task = task(&session);
|
||||
let mut shown = Vec::new();
|
||||
let mut stages = Vec::new();
|
||||
let output = task
|
||||
.run_streaming(&Progress::new(), &mut |map| {
|
||||
session.bake_preview_map(0, map);
|
||||
shown.push(session.view);
|
||||
stages.push(session.bake_preview.as_ref().and_then(|preview| preview.stage()).map(|stage| (stage.position, stage.total)));
|
||||
})
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(shown, maps.iter().map(|map| ViewMode::MeshMap(*map)).collect::<Vec<_>>(), "the view follows the newest map");
|
||||
assert_eq!(stages, [Some((2, 4)), Some((3, 4)), Some((4, 4)), None], "the stage names the next map");
|
||||
assert_eq!(session.doc.baked.get(&0).cloned(), baked_before, "the document is untouched until the bake is applied");
|
||||
let undo_before = session.undo_label().map(str::to_owned);
|
||||
|
||||
session.apply_streamed_bake(0, output).unwrap();
|
||||
assert_ne!(session.undo_label().map(str::to_owned), undo_before, "applying the bake is one undo step");
|
||||
session.bake_preview_end();
|
||||
|
||||
assert_eq!(session.view, before, "the previous view mode is restored");
|
||||
assert!(!session.bake_preview_active());
|
||||
assert!(maps.iter().all(|map| session.doc.baked[&0].maps.contains_key(map)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pinning_material_and_follow() {
|
||||
let mut session = session();
|
||||
let maps = order(&session);
|
||||
|
||||
session.bake_preview_begin(vec![(0, maps.clone())]);
|
||||
session.bake_preview_set_current(0);
|
||||
let task = task(&session);
|
||||
let mut count = 0;
|
||||
|
||||
task.run_streaming(&Progress::new(), &mut |map| {
|
||||
session.bake_preview_map(0, map);
|
||||
count += 1;
|
||||
match count {
|
||||
// Pin the finished map: later maps do not take the view
|
||||
1 => session.bake_preview_show(PreviewShow::Pin(maps[0])).unwrap(),
|
||||
2 => {
|
||||
assert_eq!(session.view, ViewMode::MeshMap(maps[0]));
|
||||
session.bake_preview_show(PreviewShow::Material).unwrap();
|
||||
}
|
||||
3 => {
|
||||
assert_eq!(session.view, ViewMode::Material);
|
||||
session.bake_preview_show(PreviewShow::Follow).unwrap();
|
||||
assert_eq!(session.view, ViewMode::MeshMap(maps[2]));
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
})
|
||||
.unwrap();
|
||||
|
||||
// A mesh map picked in the viewport pins it; another mode is what comes back at the end
|
||||
execute(&mut session, "viewport.view", &json!({ "mode": "map:height" })).unwrap();
|
||||
assert_eq!(session.bake_preview.as_ref().map(|preview| preview.show), Some(PreviewShow::Pin(BakedMap::Height)));
|
||||
execute(&mut session, "viewport.view", &json!({ "mode": "uvChecker" })).unwrap();
|
||||
assert_eq!(session.view, ViewMode::UvChecker);
|
||||
session.bake_preview_end();
|
||||
|
||||
assert_eq!(session.view, ViewMode::UvChecker);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unbaked_sets_show_neutral_and_the_control_command_reports() {
|
||||
let mut session = session();
|
||||
assert_eq!(execute(&mut session, "bake.preview", &Value::Null).unwrap()["active"], false);
|
||||
assert!(execute(&mut session, "bake.preview", &json!({ "show": "material" })).is_err(), "nothing to show when no bake runs");
|
||||
|
||||
session.bake_preview_begin(vec![(0, order(&session)), (1, order(&session))]);
|
||||
session.bake_preview_set_current(0);
|
||||
|
||||
assert!(session.bake_preview_baked(1).is_some_and(|baked| baked.maps.is_empty()), "a queued set has nothing yet");
|
||||
assert!(session.bake_preview_baked(7).is_none(), "a set outside the bake shows its document maps");
|
||||
let reply = execute(&mut session, "bake.preview", &json!({ "show": "map:ambientOcclusion" })).unwrap();
|
||||
|
||||
assert_eq!(
|
||||
(reply["active"].clone(), reply["show"].clone(), reply["shown"].clone()),
|
||||
(json!(true), json!("map:ambientOcclusion"), json!("ambientOcclusion"))
|
||||
);
|
||||
assert!(execute(&mut session, "bake.preview", &json!({ "show": "nonsense" })).is_err());
|
||||
assert_eq!(texturecraft_engine::inspect::session(&session)["bakePreview"]["active"], true);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn painting_is_refused_while_a_bake_shows() {
|
||||
let mut session = session();
|
||||
session.bake_preview_begin(vec![(0, order(&session))]);
|
||||
|
||||
let error = session.begin_stroke(Vec2::new(10.0, 10.0), Vec2::new(100.0, 100.0), 1.0).unwrap_err().to_string();
|
||||
|
||||
assert_eq!(error, texturecraft_engine::bake_preview::PAINTING_PAUSED);
|
||||
assert!(session.begin_stroke_uv(Vec2::new(0.5, 0.5), 1.0).is_err());
|
||||
assert!(session.polygon_fill(Vec2::new(10.0, 10.0), Vec2::new(100.0, 100.0)).is_err());
|
||||
assert!(!session.stroke_active());
|
||||
session.bake_preview_end();
|
||||
assert!(session.painting_blocked().is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cancelling_mid_bake_leaves_the_document_and_the_shown_maps_whole() {
|
||||
let mut session = session();
|
||||
let before = session.doc.baked.get(&0).cloned();
|
||||
let maps = order(&session);
|
||||
let full = task(&session).run(&Progress::new()).unwrap();
|
||||
session.bake_preview_begin(vec![(0, maps.clone())]);
|
||||
session.bake_preview_set_current(0);
|
||||
let progress = Progress::new();
|
||||
let task = task(&session);
|
||||
|
||||
let result = task.run_streaming(&progress, &mut |map| {
|
||||
if map.index == 1 {
|
||||
progress.cancel();
|
||||
}
|
||||
session.bake_preview_map(0, map);
|
||||
});
|
||||
|
||||
assert!(result.is_err(), "a cancelled bake fails");
|
||||
|
||||
// The two maps that landed are whole and equal to a full bake's; the others are still neutral
|
||||
let shown = session.bake_preview_baked(0).unwrap();
|
||||
assert_eq!(shown.maps.len(), 2);
|
||||
for (map, data) in &shown.maps {
|
||||
assert!(**data == full.maps[map], "{map:?}");
|
||||
}
|
||||
|
||||
// What the app does on cancel: end the preview; the document keeps what it had
|
||||
session.bake_preview_end();
|
||||
|
||||
assert_eq!(session.doc.baked.get(&0).cloned(), before);
|
||||
assert!(session.bake_preview_baked(0).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_preview_and_the_applied_document_share_each_map_buffer() {
|
||||
let mut session = session();
|
||||
let maps = order(&session);
|
||||
|
||||
session.bake_preview_begin(vec![(0, maps)]);
|
||||
session.bake_preview_set_current(0);
|
||||
let mut handed_over = Vec::new();
|
||||
|
||||
let output = task(&session)
|
||||
.run_streaming(&Progress::new(), &mut |map| {
|
||||
handed_over.push((map.map, map.data.clone()));
|
||||
session.bake_preview_map(0, map);
|
||||
})
|
||||
.unwrap();
|
||||
|
||||
// Sharing the streamed buffers keeps preview memory independent of document ownership
|
||||
for (map, data) in &handed_over {
|
||||
assert!(std::sync::Arc::ptr_eq(data, &output.maps[map]), "{map:?} was copied on the way out of the bake");
|
||||
let shown = &session.bake_preview_baked(0).unwrap().maps[map];
|
||||
assert!(std::sync::Arc::ptr_eq(data, shown), "{map:?} is held twice by the preview");
|
||||
}
|
||||
|
||||
// Applying the result must preserve sharing with the preview
|
||||
session.apply_streamed_bake(0, output).unwrap();
|
||||
for (map, data) in &handed_over {
|
||||
assert!(std::sync::Arc::ptr_eq(data, &session.doc.baked[&0].maps[map]), "{map:?} was copied into the document");
|
||||
}
|
||||
session.bake_preview_end();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cancelling_keeps_a_set_that_was_already_applied_as_one_undo_step() {
|
||||
let mut session = session();
|
||||
let before = session.doc.baked.get(&0).cloned();
|
||||
let maps = order(&session);
|
||||
|
||||
// A multi-set bake applies each set when it finishes; a later cancel does not undo it
|
||||
session.bake_preview_begin(vec![(0, maps)]);
|
||||
session.bake_preview_set_current(0);
|
||||
let output = task(&session)
|
||||
.run_streaming(&Progress::new(), &mut |map| {
|
||||
session.bake_preview_map(0, map);
|
||||
})
|
||||
.unwrap();
|
||||
session.apply_streamed_bake(0, output).unwrap();
|
||||
session.bake_preview_end();
|
||||
|
||||
assert!(MAPS.iter().all(|map| session.doc.baked[&0].maps.contains_key(map)), "the finished set stays baked after the cancel");
|
||||
session.undo().unwrap();
|
||||
assert_eq!(session.doc.baked.get(&0).cloned(), before, "applying the set was one undo step");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_resized_partial_streamed_bake_keeps_unchecked_maps() {
|
||||
use std::sync::Arc;
|
||||
use texturecraft_engine::compose::BakedMaps;
|
||||
use texturecraft_engine::geom::primitives;
|
||||
|
||||
let mut session = Session::new_project("Partial bake", primitives::udim_plane(), "builtin:udim_plane", None, 128).unwrap();
|
||||
session.doc.baked.insert(
|
||||
0,
|
||||
BakedMaps {
|
||||
resolution: 64,
|
||||
maps: [
|
||||
(BakedMap::AmbientOcclusion, Arc::new(vec![0.25; 64 * 32])),
|
||||
(BakedMap::Normal, Arc::new(vec![0.4; 64 * 32 * 3])),
|
||||
(BakedMap::Height, Arc::new(vec![0.75; 64 * 32])),
|
||||
]
|
||||
.into(),
|
||||
},
|
||||
);
|
||||
execute(&mut session, "bake.settings", &json!({"resolution": 64, "maps": ["ambientOcclusion", "height"], "rays": 2})).unwrap();
|
||||
execute(&mut session, "bake.tile.set", &json!({"tile": 1002, "enabled": false})).unwrap();
|
||||
let before = session.doc.baked.clone();
|
||||
let task = task(&session);
|
||||
let whole = task.run(&Progress::new()).unwrap();
|
||||
let mut streamed = Vec::new();
|
||||
|
||||
let output = task.run_streaming(&Progress::new(), &mut |map| streamed.push(map)).unwrap();
|
||||
|
||||
assert_eq!((output.resolution, output.height), (128, 64));
|
||||
assert_eq!(output.maps.keys().collect::<Vec<_>>(), whole.maps.keys().collect::<Vec<_>>());
|
||||
for (map, pixels) in &whole.maps {
|
||||
assert_eq!(*output.maps[map], *pixels, "{map:?} must match a whole bake, including retained pixels");
|
||||
}
|
||||
assert_eq!(streamed.iter().map(|map| map.map).collect::<Vec<_>>(), [BakedMap::AmbientOcclusion, BakedMap::Height]);
|
||||
for map in &streamed {
|
||||
assert!(Arc::ptr_eq(&map.data, &output.maps[&map.map]));
|
||||
}
|
||||
|
||||
session.apply_streamed_bake(0, output).unwrap();
|
||||
|
||||
for (map, pixels) in &whole.maps {
|
||||
assert_eq!(*session.doc.baked[&0].maps[map], *pixels);
|
||||
}
|
||||
session.undo().unwrap();
|
||||
assert_eq!(session.doc.baked, before);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn box_fills_are_refused_while_a_bake_shows() {
|
||||
let mut session = session();
|
||||
execute(&mut session, "layer.add.paint", &Value::Null).unwrap();
|
||||
execute(&mut session, "tool.polygonFill", &Value::Null).unwrap();
|
||||
session.bake_preview_begin(vec![(0, order(&session))]);
|
||||
let before = texturecraft_engine::inspect::session(&session);
|
||||
let viewport = Vec2::new(100.0, 100.0);
|
||||
|
||||
for result in [
|
||||
session.drag_polygon_fill_box_uv(Vec2::ZERO, Vec2::ONE),
|
||||
session.drag_polygon_fill_box(Vec2::ZERO, viewport, viewport),
|
||||
session.polygon_fill_box_uv(Vec2::ZERO, Vec2::ONE),
|
||||
session.polygon_fill_box(Vec2::ZERO, viewport, viewport),
|
||||
execute(&mut session, "tool.click", &json!({"uv0": [0, 0], "uv1": [1, 1]})).map(|_| 0),
|
||||
execute(&mut session, "tool.click", &json!({"x0": 0, "y0": 0, "x1": 100, "y1": 100})).map(|_| 0),
|
||||
] {
|
||||
assert_eq!(result.unwrap_err().to_string(), texturecraft_engine::bake_preview::PAINTING_PAUSED);
|
||||
}
|
||||
|
||||
assert_eq!(session.end_polygon_fill_box(), 0);
|
||||
assert_eq!(texturecraft_engine::inspect::session(&session), before);
|
||||
session.bake_preview_end();
|
||||
assert!(session.polygon_fill_box_uv(Vec2::ZERO, Vec2::ONE).unwrap() > 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn preview_order_matches_each_sets_bake_task() {
|
||||
let mut session = session();
|
||||
session.doc.project.texture_sets[1].bake.maps.select([BakedMap::WorldNormal, BakedMap::Height]);
|
||||
let expected: Vec<_> = [0, 1].into_iter().map(|texture_set| session.bake_task(texture_set).unwrap().maps()).collect();
|
||||
|
||||
session.bake_preview_begin_for(&[0, 1]).unwrap();
|
||||
|
||||
let preview = session.bake_preview.as_ref().unwrap();
|
||||
for (texture_set, maps) in expected.iter().enumerate() {
|
||||
assert_eq!(&preview.sets[&texture_set].order, maps);
|
||||
assert!(preview.sets[&texture_set].baked.maps.is_empty());
|
||||
}
|
||||
assert_eq!(session.view, ViewMode::MeshMap(expected[0][0]));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn invalid_preview_sets_preserve_the_existing_preview_and_view() {
|
||||
let mut session = session();
|
||||
session.bake_preview_begin_for(&[0]).unwrap();
|
||||
session.bake_preview_set_current(0);
|
||||
session.bake_preview_show(PreviewShow::Material).unwrap();
|
||||
let before = texturecraft_engine::bake_preview::preview_json(&session);
|
||||
let view = session.view;
|
||||
let revision = session.revision;
|
||||
let invalid_set = session.set_count();
|
||||
let expected_error = session.doc.project.texture_set(invalid_set).unwrap_err().to_string();
|
||||
|
||||
let error = session.bake_preview_begin_for(&[1, invalid_set]).unwrap_err();
|
||||
|
||||
assert!(error.to_string().contains(&expected_error));
|
||||
assert_eq!(texturecraft_engine::bake_preview::preview_json(&session), before);
|
||||
assert_eq!(session.view, view);
|
||||
assert_eq!(session.revision, revision);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn starting_a_bake_preview_discards_an_active_stroke() {
|
||||
for (from_settings, paint_mask) in [(false, false), (true, false), (false, true), (true, true)] {
|
||||
let mut session = session();
|
||||
execute(&mut session, "layer.add.paint", &Value::Null).unwrap();
|
||||
if paint_mask {
|
||||
session.target = texturecraft_engine::StackTarget::Mask;
|
||||
}
|
||||
|
||||
let before = session.doc.clone();
|
||||
let history = session.history_labels();
|
||||
let view = session.view;
|
||||
session.begin_stroke_uv(Vec2::splat(0.5), 1.0).unwrap();
|
||||
assert!(session.stroke_tiles() > 0, "the stroke must contain paint before the preview starts");
|
||||
|
||||
if from_settings {
|
||||
session.bake_preview_begin_for(&[0]).unwrap();
|
||||
} else {
|
||||
session.bake_preview_begin(vec![(0, order(&session))]);
|
||||
}
|
||||
let stroke_survived = session.stroke_active();
|
||||
session.continue_stroke_uv(Vec2::splat(0.6), 1.0);
|
||||
session.end_stroke().unwrap();
|
||||
|
||||
assert_eq!(session.history_labels(), history, "releasing the pointer during a preview must not commit paint");
|
||||
assert!(!stroke_survived, "activation must cancel the stroke immediately");
|
||||
assert_eq!(session.doc.project, before.project);
|
||||
assert_eq!(session.doc.pixels.layers, before.pixels.layers);
|
||||
assert_eq!(session.doc.pixels.masks, before.pixels.masks);
|
||||
assert!(session.bake_preview_active());
|
||||
session.bake_preview_end();
|
||||
|
||||
assert_eq!(session.view, view);
|
||||
session.begin_stroke_uv(Vec2::splat(0.5), 1.0).unwrap();
|
||||
session.end_stroke().unwrap();
|
||||
assert_eq!(session.history_labels().len(), history.len() + 1, "painting resumes after the preview ends");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_rejected_bake_preview_preserves_the_active_stroke() {
|
||||
let mut session = session();
|
||||
execute(&mut session, "layer.add.paint", &Value::Null).unwrap();
|
||||
let history_steps = session.history_labels().len();
|
||||
let view = session.view;
|
||||
session.begin_stroke_uv(Vec2::splat(0.5), 1.0).unwrap();
|
||||
let painted_tiles = session.stroke_tiles();
|
||||
assert!(painted_tiles > 0);
|
||||
|
||||
let result = session.bake_preview_begin_for(&[0, session.set_count()]);
|
||||
|
||||
assert!(result.is_err());
|
||||
assert!(!session.bake_preview_active());
|
||||
assert!(session.stroke_active());
|
||||
assert_eq!(session.stroke_tiles(), painted_tiles);
|
||||
assert_eq!(session.view, view);
|
||||
session.end_stroke().unwrap();
|
||||
|
||||
assert_eq!(session.history_labels().len(), history_steps + 1, "a rejected preview must not discard painting");
|
||||
}
|
||||
@@ -10,17 +10,18 @@ fn plane_session() -> Session {
|
||||
Session::new_project("t", mesh, "builtin:plane", None, 256).unwrap()
|
||||
}
|
||||
|
||||
/// `mesh` as OBJ text, lifted by `dy`, keeping only vertices with x ≤ `max_x` (triangles that
|
||||
/// lose a vertex are dropped), every vertex colored `rgb`.
|
||||
fn obj(mesh: &Mesh, dy: f32, max_x: f32, rgb: [f32; 3]) -> String {
|
||||
let mut s = String::from("o Part_high\n");
|
||||
for p in &mesh.positions {
|
||||
s += &format!("v {} {} {} {} {} {}\n", p.x.min(max_x), p.y + dy, p.z, rgb[0], rgb[1], rgb[2]);
|
||||
/// `mesh` as OBJ text, shifted by `offset_y`, with x clamped to `max_x` and every vertex colored `rgb`.
|
||||
fn obj(mesh: &Mesh, offset_y: f32, max_x: f32, rgb: [f32; 3]) -> String {
|
||||
let mut text = String::from("o Part_high\n");
|
||||
for position in &mesh.positions {
|
||||
text += &format!("v {} {} {} {} {} {}\n", position.x.min(max_x), position.y + offset_y, position.z, rgb[0], rgb[1], rgb[2]);
|
||||
}
|
||||
for t in mesh.indices.chunks_exact(3) {
|
||||
s += &format!("f {} {} {}\n", t[0] + 1, t[1] + 1, t[2] + 1);
|
||||
|
||||
for triangle in mesh.indices.as_chunks::<3>().0 {
|
||||
text += &format!("f {} {} {}\n", triangle[0] + 1, triangle[1] + 1, triangle[2] + 1);
|
||||
}
|
||||
s
|
||||
|
||||
text
|
||||
}
|
||||
|
||||
fn temp_file(name: &str, text: &str) -> String {
|
||||
File renamed without changes.
File renamed without changes.
@@ -53,14 +53,16 @@ fn partial_bake_preserves_unchecked_tiles_and_uses_the_workers_selection() {
|
||||
execute(&mut session, "bake.tile.set", &json!({"tile": 1002, "enabled": true})).unwrap();
|
||||
execute(&mut session, "bake.tile.set", &json!({"tile": 1001, "enabled": false})).unwrap();
|
||||
let before = session.doc.baked.clone();
|
||||
|
||||
let output = task.run(&Progress::new()).unwrap();
|
||||
session.apply_bake(0, output).unwrap();
|
||||
|
||||
let pixels = &session.doc.baked[&0].maps[&BakedMap::AmbientOcclusion];
|
||||
for row in pixels.chunks_exact(64) {
|
||||
for row in pixels.as_chunks::<64>().0 {
|
||||
assert!(row[..32].iter().all(|value| *value > 0.99));
|
||||
assert!(row[32..].iter().all(|value| *value == 0.25));
|
||||
}
|
||||
|
||||
session.undo().unwrap();
|
||||
assert_eq!(session.doc.baked, before);
|
||||
}
|
||||
@@ -76,17 +78,20 @@ fn partial_bake_resizes_retained_tiles_and_unchecked_map_outputs() {
|
||||
},
|
||||
);
|
||||
execute(&mut session, "bake.tile.set", &json!({"tile": 1002, "enabled": false})).unwrap();
|
||||
|
||||
let result = execute(&mut session, "bake.run", &json!({"resolution": 64, "cpu": true})).unwrap();
|
||||
|
||||
assert_eq!(result["baked"], json!([0]));
|
||||
|
||||
let baked = &session.doc.baked[&0];
|
||||
assert_eq!((baked.resolution, baked.height(BakedMap::AmbientOcclusion)), (128, 64));
|
||||
for row in baked.maps[&BakedMap::AmbientOcclusion].chunks_exact(128) {
|
||||
for row in baked.maps[&BakedMap::AmbientOcclusion].as_chunks::<128>().0 {
|
||||
assert!(row[..64].iter().all(|value| *value > 0.99));
|
||||
assert!(row[64..].iter().all(|value| *value == 0.25));
|
||||
}
|
||||
assert_eq!(baked.maps[&BakedMap::Normal].len(), 128 * 64 * 3);
|
||||
assert!(baked.maps[&BakedMap::Normal].iter().all(|value| *value == 0.4));
|
||||
|
||||
let reopened = Session::from_project_bytes(&session.to_project_bytes().unwrap()).unwrap();
|
||||
assert_eq!(reopened.doc.baked, session.doc.baked);
|
||||
}
|
||||
@@ -0,0 +1,309 @@
|
||||
//! Color selection effects: editing their ID colors and picking them from the ID mesh map
|
||||
|
||||
use serde_json::{Value, json};
|
||||
use texturecraft_engine::core::{EffectKind, LayerId};
|
||||
use texturecraft_engine::geom::glam::Vec2;
|
||||
use texturecraft_engine::geom::primitives;
|
||||
use texturecraft_engine::{Session, execute};
|
||||
|
||||
const TOP_LEFT_ID: [u8; 3] = [200, 30, 10];
|
||||
const TOP_RIGHT_ID: [u8; 3] = [10, 200, 30];
|
||||
const BOTTOM_ID: [u8; 3] = [30, 10, 200];
|
||||
const NO_PART: [f32; 3] = [0.0, 0.0, 0.0];
|
||||
|
||||
fn session() -> Session {
|
||||
let mut session = Session::new_project("t", primitives::sphere(1.0, 48, 24), "builtin:sphere", None, 256).unwrap();
|
||||
session.viewport = Vec2::new(400.0, 400.0);
|
||||
session.camera.yaw = 0.0;
|
||||
session.camera.pitch = 0.0;
|
||||
session.update();
|
||||
session
|
||||
}
|
||||
|
||||
/// An 8×8 ID map: two parts on the top half, one on the bottom half
|
||||
fn id_map_png() -> Vec<u8> {
|
||||
let image = image::RgbaImage::from_fn(8, 8, |x, y| {
|
||||
let [red, green, blue] = match (x < 4, y < 4) {
|
||||
(true, true) => TOP_LEFT_ID,
|
||||
(false, true) => TOP_RIGHT_ID,
|
||||
_ => BOTTOM_ID,
|
||||
};
|
||||
image::Rgba([red, green, blue, 255])
|
||||
});
|
||||
let mut bytes = Vec::new();
|
||||
image.write_to(&mut std::io::Cursor::new(&mut bytes), image::ImageFormat::Png).unwrap();
|
||||
bytes
|
||||
}
|
||||
|
||||
fn stored(id: [u8; 3]) -> [f32; 3] {
|
||||
id.map(|channel| channel as f32 / 255.0)
|
||||
}
|
||||
|
||||
fn assert_close(actual: [f32; 3], expected: [f32; 3]) {
|
||||
assert!(actual.iter().zip(expected).all(|(channel, wanted)| (channel - wanted).abs() < 1e-3), "{actual:?} vs {expected:?}");
|
||||
}
|
||||
|
||||
/// A fill layer masked by a color selection that selects no part yet: (layer, effect)
|
||||
fn masked_layer(session: &mut Session, with_id_map: bool) -> (LayerId, LayerId) {
|
||||
if with_id_map {
|
||||
let image = session.import_resource_bytes("id.png", id_map_png()).unwrap();
|
||||
execute(session, "textureSet.meshMap.set", &json!({"map": "id", "image": image})).unwrap();
|
||||
}
|
||||
|
||||
let layer = LayerId(execute(session, "layer.add.fill", &json!({"color": [0.9, 0.1, 0.1]})).unwrap()["layer"].as_u64().unwrap());
|
||||
execute(session, "mask.add.colorSelection", &json!({"color": NO_PART, "tolerance": 0.05})).unwrap();
|
||||
let effect = session.doc.project.layer(layer).unwrap().mask.as_ref().unwrap().effects[0].id;
|
||||
(layer, effect)
|
||||
}
|
||||
|
||||
fn colors(session: &Session, effect: LayerId) -> Vec<[f32; 3]> {
|
||||
match &session.doc.project.effect(effect).unwrap().1.kind {
|
||||
EffectKind::ColorSelection { colors, .. } => colors.clone(),
|
||||
other => panic!("not a color selection: {other:?}"),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_color_picked_on_the_mesh_is_selected_where_it_was_picked() {
|
||||
let mut session = session();
|
||||
let (layer, effect) = masked_layer(&mut session, true);
|
||||
let center = Vec2::new(200.0, 200.0);
|
||||
let hit = session.pick(center, session.viewport).unwrap();
|
||||
let (width, height) = session.caches[0].size;
|
||||
let texel = ((hit.uv.x * width as f32) as u32, (hit.uv.y * height as f32) as u32);
|
||||
assert_eq!(session.mask_at(layer, &[texel]).unwrap(), vec![0.0], "nothing selected before the pick");
|
||||
|
||||
let picked = execute(&mut session, "effect.colorSelection.pick", &json!({"effect": effect.0, "x": center.x, "y": center.y})).unwrap();
|
||||
|
||||
assert_eq!(picked["index"], json!(1));
|
||||
assert_eq!(colors(&session, effect).len(), 2);
|
||||
assert_eq!(session.mask_at(layer, &[texel]).unwrap(), vec![1.0]);
|
||||
execute(&mut session, "edit.undo", &Value::Null).unwrap();
|
||||
assert_eq!(colors(&session, effect), vec![NO_PART], "one undo step");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_uv_pick_adds_the_color_there_or_replaces_one() {
|
||||
let mut session = session();
|
||||
let (_, effect) = masked_layer(&mut session, true);
|
||||
|
||||
execute(&mut session, "effect.colorSelection.pick", &json!({"effect": effect.0, "uv": [0.25, 0.25]})).unwrap();
|
||||
assert_close(colors(&session, effect)[1], stored(TOP_LEFT_ID));
|
||||
|
||||
let replaced = execute(&mut session, "effect.colorSelection.pick", &json!({"effect": effect.0, "uv": [0.75, 0.75], "index": 0})).unwrap();
|
||||
assert_eq!(replaced["index"], json!(0));
|
||||
let picked = colors(&session, effect);
|
||||
assert_eq!(picked.len(), 2);
|
||||
assert_close(picked[0], stored(BOTTOM_ID));
|
||||
execute(&mut session, "edit.undo", &Value::Null).unwrap();
|
||||
assert_eq!(colors(&session, effect)[0], NO_PART, "one undo step");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_colors_param_replaces_the_list_in_one_undo_step() {
|
||||
let mut session = session();
|
||||
let (_, effect) = masked_layer(&mut session, false);
|
||||
let edited = [stored(TOP_LEFT_ID), stored(TOP_RIGHT_ID)];
|
||||
|
||||
execute(&mut session, "effect.set", &json!({"effect": effect.0, "colors": edited, "tolerance": 0.2})).unwrap();
|
||||
assert_eq!(colors(&session, effect), edited.to_vec());
|
||||
let Some((_, found)) = session.doc.project.effect(effect) else { panic!("effect gone") };
|
||||
assert!(matches!(found.kind, EffectKind::ColorSelection { tolerance, .. } if tolerance == 0.2));
|
||||
|
||||
execute(&mut session, "edit.undo", &Value::Null).unwrap();
|
||||
assert_eq!(colors(&session, effect), vec![NO_PART]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bad_colors_are_refused_and_change_nothing() {
|
||||
let mut session = session();
|
||||
let (_, effect) = masked_layer(&mut session, false);
|
||||
let refused = [json!([]), json!([[0.5, 0.5]]), json!([[0.5, "x", 0.5]]), json!([[0.5, null, 0.5]]), json!("red")];
|
||||
|
||||
for colors_param in &refused {
|
||||
assert!(execute(&mut session, "effect.set", &json!({"effect": effect.0, "colors": colors_param})).is_err(), "{colors_param}");
|
||||
}
|
||||
assert_eq!(colors(&session, effect), vec![NO_PART]);
|
||||
execute(&mut session, "effect.set", &json!({"effect": effect.0, "colors": [[1e300, 0.5, 0.5]]})).unwrap();
|
||||
assert_eq!(colors(&session, effect), vec![[1.0, 0.5, 0.5]], "out-of-range values clamp to 0..1");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn picking_explains_what_is_missing() {
|
||||
let mut session = session();
|
||||
let (layer, effect) = masked_layer(&mut session, false);
|
||||
let pick = |session: &mut Session, params: Value| execute(session, "effect.colorSelection.pick", ¶ms).unwrap_err().to_string();
|
||||
|
||||
assert!(pick(&mut session, json!({"effect": effect.0, "uv": [0.5, 0.5]})).contains("no ID map"));
|
||||
let image = session.import_resource_bytes("id.png", id_map_png()).unwrap();
|
||||
execute(&mut session, "textureSet.meshMap.set", &json!({"map": "id", "image": image})).unwrap();
|
||||
assert!(pick(&mut session, json!({"effect": effect.0, "x": 1, "y": 1})).contains("nothing under that point"));
|
||||
assert!(pick(&mut session, json!({"effect": effect.0, "uv": [1.5, 0.5]})).contains("outside"));
|
||||
assert!(pick(&mut session, json!({"effect": effect.0, "uv": [0.5, 0.5], "index": 7})).contains("no color 7"));
|
||||
assert!(pick(&mut session, json!({"effect": effect.0})).contains("`x` and `y`"));
|
||||
|
||||
let fill = execute(&mut session, "effect.add.fill", &json!({"layer": layer.0})).unwrap()["effect"].as_u64().unwrap();
|
||||
assert!(pick(&mut session, json!({"effect": fill, "uv": [0.5, 0.5]})).contains("not a color selection"));
|
||||
assert_eq!(colors(&session, effect), vec![NO_PART]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hostile_params_never_crash_the_color_selection_commands() {
|
||||
let mut session = session();
|
||||
let (_, effect) = masked_layer(&mut session, true);
|
||||
let hostile = [
|
||||
json!({"effect": effect.0, "x": f32::MAX, "y": -1e30, "viewport": [0, 0]}),
|
||||
json!({"effect": effect.0, "uv": [f64::MAX, -1e300], "index": u64::MAX}),
|
||||
json!({"effect": effect.0, "uv": [0.5], "colors": [[f64::MAX, -f64::MAX, 0.0]]}),
|
||||
json!({"effect": effect.0, "uv": "x", "colors": {"r": 1}}),
|
||||
json!({"effect": u64::MAX, "uv": [0.5, 0.5]}),
|
||||
];
|
||||
|
||||
for params in &hostile {
|
||||
let _ = execute(&mut session, "effect.colorSelection.pick", params);
|
||||
let _ = execute(&mut session, "effect.set", params);
|
||||
session.update();
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_hidden_texture_set_does_not_block_a_pick_behind_it() {
|
||||
let mut session = Session::new_project("t", primitives::material_ball(), "builtin:material_ball", None, 256).unwrap();
|
||||
session.viewport = Vec2::new(400.0, 400.0);
|
||||
session.update();
|
||||
let set_named = |name: &str| session.doc.project.texture_sets.iter().position(|set| set.name == name).unwrap();
|
||||
let (base, ball) = (set_named("Base"), set_named("Ball"));
|
||||
execute(&mut session, "textureSet.select", &json!({"ts": base})).unwrap();
|
||||
let (_, effect) = masked_layer(&mut session, true);
|
||||
let pick_at = |session: &mut Session, y: f32| execute(session, "effect.colorSelection.pick", &json!({"effect": effect.0, "x": 200, "y": y}));
|
||||
let ball_in_front = |session: &Session, y: f32| {
|
||||
session.pick(Vec2::new(200.0, y), session.viewport).is_some_and(|hit| session.texture_set_of_material(hit.material) == Some(ball))
|
||||
};
|
||||
|
||||
// Down the middle until a pixel where the hidden ball covers the base: the pick reads the base
|
||||
execute(&mut session, "textureSet.visible", &json!({"ts": ball, "visible": false})).unwrap();
|
||||
let mut covered = None;
|
||||
for y in (200..400).map(|y| y as f32) {
|
||||
if ball_in_front(&session, y) && pick_at(&mut session, y).is_ok() {
|
||||
covered = Some(y);
|
||||
break;
|
||||
}
|
||||
}
|
||||
let y = covered.expect("a pixel where the ball covers the base");
|
||||
assert_eq!(colors(&session, effect).len(), 2);
|
||||
|
||||
execute(&mut session, "textureSet.visible", &json!({"ts": ball, "visible": true})).unwrap();
|
||||
assert!(pick_at(&mut session, y).unwrap_err().to_string().contains("another texture set"), "a shown ball still blocks it");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn malformed_replacement_indices_are_rejected_without_editing() {
|
||||
let mut session = session();
|
||||
let (_, effect) = masked_layer(&mut session, true);
|
||||
let history = session.history_labels();
|
||||
|
||||
for index in [json!(-1), json!(0.4), json!("0"), json!(true), json!([])] {
|
||||
let result = execute(&mut session, "effect.colorSelection.pick", &json!({"effect": effect.0, "uv": [0.25, 0.25], "index": index}));
|
||||
assert!(result.is_err(), "invalid index {index} was accepted: {result:?}");
|
||||
assert_eq!(colors(&session, effect), vec![NO_PART]);
|
||||
assert_eq!(session.history_labels(), history);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_color_limit_rejects_additions_but_allows_replacement() {
|
||||
let mut session = session();
|
||||
let (_, effect) = masked_layer(&mut session, true);
|
||||
let full = vec![NO_PART; 256];
|
||||
execute(&mut session, "effect.set", &json!({"effect": effect.0, "colors": full})).unwrap();
|
||||
let history = session.history_labels();
|
||||
let project = session.doc.project.clone();
|
||||
|
||||
for params in [json!({"effect": effect.0, "uv": [0.25, 0.25]}), json!({"effect": effect.0, "uv": [0.25, 0.25], "index": 256})] {
|
||||
assert!(execute(&mut session, "effect.colorSelection.pick", ¶ms).is_err());
|
||||
assert_eq!(colors(&session, effect), full);
|
||||
assert_eq!(session.history_labels(), history);
|
||||
}
|
||||
assert!(execute(&mut session, "effect.set", &json!({"effect": effect.0, "colors": vec![NO_PART; 257], "name": "Invalid edit"})).is_err());
|
||||
assert_eq!(session.history_labels(), history);
|
||||
assert_eq!(session.doc.project, project, "invalid colors also roll back edits to other fields");
|
||||
|
||||
execute(&mut session, "effect.colorSelection.pick", &json!({"effect": effect.0, "uv": [0.25, 0.25], "index": 255})).unwrap();
|
||||
assert_eq!(colors(&session, effect).len(), 256);
|
||||
assert_close(colors(&session, effect)[255], stored(TOP_LEFT_ID));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn inspect_exposes_the_selected_colors_and_tolerance() {
|
||||
let mut session = session();
|
||||
let (layer, effect) = masked_layer(&mut session, true);
|
||||
execute(&mut session, "effect.colorSelection.pick", &json!({"effect": effect.0, "uv": [0.25, 0.25]})).unwrap();
|
||||
execute(&mut session, "effect.set", &json!({"effect": effect.0, "tolerance": 0.25})).unwrap();
|
||||
|
||||
let inspected = execute(&mut session, "project.inspect", &Value::Null).unwrap();
|
||||
let layer = inspected["layers"].as_array().unwrap().iter().find(|found| found["id"] == layer.0).unwrap();
|
||||
let found = &layer["mask"]["effects"][0];
|
||||
assert_eq!(found["colors"], json!(colors(&session, effect)));
|
||||
assert_eq!(found["tolerance"], json!(0.25));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn picks_use_the_working_texel_on_a_smaller_uv_tile() {
|
||||
let mut session = Session::new_project("UV tiles", primitives::udim_plane(), "builtin:udim_plane", None, 256).unwrap();
|
||||
for tile in [1001, 1002] {
|
||||
session.import_resource_bytes(&format!("id.{tile}.png"), id_map_png()).unwrap();
|
||||
}
|
||||
execute(&mut session, "textureSet.meshMap.set", &json!({"map": "id", "image": "id.1001.png"})).unwrap();
|
||||
let (layer, effect) = masked_layer(&mut session, false);
|
||||
execute(&mut session, "textureSet.tile.resolution", &json!({"tile": 1002, "resolution": 128})).unwrap();
|
||||
execute(&mut session, "effect.set", &json!({"effect": effect.0, "tolerance": 0.0})).unwrap();
|
||||
let size = session.doc.project.texture_sets[0].size();
|
||||
let uv = [0.625, 0.25];
|
||||
let texel = ((uv[0] * size.0 as f32) as u32, (uv[1] * size.1 as f32) as u32);
|
||||
assert_eq!(session.mask_at(layer, &[texel]).unwrap(), vec![0.0]);
|
||||
|
||||
execute(&mut session, "effect.colorSelection.pick", &json!({"effect": effect.0, "uv": uv})).unwrap();
|
||||
assert_eq!(session.mask_at(layer, &[texel]).unwrap(), vec![1.0]);
|
||||
let before = colors(&session, effect);
|
||||
let result = execute(&mut session, "effect.colorSelection.pick", &json!({"effect": effect.0, "uv": [0.9, 0.8]}));
|
||||
assert!(result.unwrap_err().to_string().contains("no ID color"), "unused tile space has no sample");
|
||||
assert_eq!(colors(&session, effect), before);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "release benchmark; run with --ignored --nocapture --test-threads=1"]
|
||||
fn benchmark_color_selection_edits() {
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
const SAMPLES: u32 = 10;
|
||||
for resolution in [256, 1024] {
|
||||
let started = Instant::now();
|
||||
let mut session = Session::new_project("benchmark", primitives::sphere(1.0, 48, 24), "builtin:sphere", None, resolution).unwrap();
|
||||
let (_, effect) = masked_layer(&mut session, true);
|
||||
session.update();
|
||||
let construction = started.elapsed();
|
||||
|
||||
for count in [1, 256] {
|
||||
execute(&mut session, "effect.set", &json!({"effect": effect.0, "colors": vec![NO_PART; count]})).unwrap();
|
||||
session.update();
|
||||
let params = json!({"effect": effect.0, "uv": [0.25, 0.25], "index": count - 1});
|
||||
let (mut command_time, mut composite_time) = (Duration::ZERO, Duration::ZERO);
|
||||
for _ in 0..SAMPLES {
|
||||
let started = Instant::now();
|
||||
execute(&mut session, "effect.colorSelection.pick", ¶ms).unwrap();
|
||||
command_time += started.elapsed();
|
||||
let started = Instant::now();
|
||||
session.update();
|
||||
composite_time += started.elapsed();
|
||||
execute(&mut session, "edit.undo", &Value::Null).unwrap();
|
||||
session.update();
|
||||
}
|
||||
println!(
|
||||
"{resolution}x{resolution}, {count} colors, {SAMPLES} samples: construction {construction:.3?}; pick {:.3?}; composite {:.3?}; session memory {} bytes",
|
||||
command_time / SAMPLES,
|
||||
composite_time / SAMPLES,
|
||||
session.memory().total()
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
File renamed without changes.
File renamed without changes.
@@ -0,0 +1,172 @@
|
||||
//! Swapping a filter effect's type in place through `effect.set {filter}`
|
||||
|
||||
use serde_json::{Value, json};
|
||||
use texturecraft_engine::core::{BlendMode, Effect, EffectKind, Filter, LayerId};
|
||||
use texturecraft_engine::geom::primitives;
|
||||
use texturecraft_engine::{Session, StackTarget, execute};
|
||||
|
||||
/// A sphere project with its default layer selected
|
||||
fn session() -> Session {
|
||||
Session::new_project("t", primitives::sphere(1.0, 16, 8), "builtin:sphere", None, 256).unwrap()
|
||||
}
|
||||
|
||||
/// Runs effect-adding `command` and returns the new effect, which it selects
|
||||
fn add(s: &mut Session, command: &str, params: Value) -> LayerId {
|
||||
execute(s, command, ¶ms).unwrap();
|
||||
let StackTarget::Effect(added) = s.target else { panic!("adding an effect selects it: {:?}", s.target) };
|
||||
|
||||
added
|
||||
}
|
||||
|
||||
/// A copy of effect `id`
|
||||
fn effect(s: &Session, id: LayerId) -> Effect {
|
||||
s.doc.project.effect(id).unwrap().1.clone()
|
||||
}
|
||||
|
||||
/// Ids of the selected layer's content effects, bottom first
|
||||
fn content_order(s: &Session) -> Vec<LayerId> {
|
||||
let layer = s.selected_layer().unwrap();
|
||||
s.doc.project.layer(layer).unwrap().content_effects.iter().map(|effect| effect.id).collect()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn swapping_a_filter_keeps_its_place_blend_opacity_and_visibility() {
|
||||
let mut s = session();
|
||||
let below = add(&mut s, "effect.add.filter", json!({"filter": "invert", "target": "content"}));
|
||||
let swapped = add(&mut s, "effect.add.filter", json!({"filter": "invert", "target": "content"}));
|
||||
let above = add(&mut s, "effect.add.filter", json!({"filter": "grayscale", "target": "content"}));
|
||||
execute(&mut s, "effect.set", &json!({"effect": swapped.0, "blend": "Multiply", "opacity": 0.4, "visible": false})).unwrap();
|
||||
|
||||
execute(&mut s, "effect.set", &json!({"effect": swapped.0, "filter": "blur", "radius": 5.0})).unwrap();
|
||||
|
||||
let blur = effect(&s, swapped);
|
||||
assert!(matches!(blur.kind, EffectKind::Filter(Filter::Blur { radius }) if radius == 5.0), "{:?}", blur.kind);
|
||||
assert_eq!(blur.name, "Blur", "a default name follows the new filter");
|
||||
assert_eq!((blur.blend, blur.opacity, blur.visible), (BlendMode::Multiply, 0.4, false));
|
||||
assert_eq!(content_order(&s), vec![below, swapped, above]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn swapping_a_filter_keeps_a_name_the_user_chose() {
|
||||
let mut s = session();
|
||||
let id = add(&mut s, "effect.add.filter", json!({"filter": "invert", "target": "content", "name": "Flip"}));
|
||||
|
||||
execute(&mut s, "effect.set", &json!({"effect": id.0, "filter": "threshold"})).unwrap();
|
||||
|
||||
assert_eq!(effect(&s, id).name, "Flip");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn one_undo_restores_the_old_filter() {
|
||||
let mut s = session();
|
||||
let id = add(&mut s, "effect.add.filter", json!({"filter": "threshold", "target": "content", "level": 0.3}));
|
||||
|
||||
execute(&mut s, "effect.set", &json!({"effect": id.0, "filter": "sharpen"})).unwrap();
|
||||
execute(&mut s, "edit.undo", &Value::Null).unwrap();
|
||||
|
||||
let restored = effect(&s, id);
|
||||
assert!(matches!(restored.kind, EffectKind::Filter(Filter::Threshold { level }) if level == 0.3), "{:?}", restored.kind);
|
||||
assert_eq!(restored.name, "Threshold");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_mask_refuses_a_content_only_filter() {
|
||||
let mut s = session();
|
||||
let id = add(&mut s, "effect.add.filter", json!({"filter": "invert", "target": "mask"}));
|
||||
|
||||
let err = execute(&mut s, "effect.set", &json!({"effect": id.0, "filter": "grayscale"})).unwrap_err();
|
||||
|
||||
assert!(err.to_string().contains("not on masks"), "{err}");
|
||||
assert!(matches!(effect(&s, id).kind, EffectKind::Filter(Filter::Invert)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_mask_filter_swaps_in_place_on_the_mask() {
|
||||
let mut s = session();
|
||||
let below = add(&mut s, "effect.add.filter", json!({"filter": "invert", "target": "mask"}));
|
||||
let swapped = add(&mut s, "effect.add.filter", json!({"filter": "invert", "target": "mask"}));
|
||||
let above = add(&mut s, "effect.add.filter", json!({"filter": "invert", "target": "mask"}));
|
||||
execute(&mut s, "effect.set", &json!({"effect": swapped.0, "blend": "Multiply", "opacity": 0.4})).unwrap();
|
||||
|
||||
execute(&mut s, "effect.set", &json!({"effect": swapped.0, "filter": "blur"})).unwrap();
|
||||
|
||||
let blur = effect(&s, swapped);
|
||||
assert!(matches!(blur.kind, EffectKind::Filter(Filter::Blur { .. })), "{:?}", blur.kind);
|
||||
assert_eq!((blur.name.as_str(), blur.blend, blur.opacity), ("Blur", BlendMode::Multiply, 0.4));
|
||||
let layer = s.selected_layer().unwrap();
|
||||
let mask_order: Vec<LayerId> = s.doc.project.layer(layer).unwrap().mask.as_ref().unwrap().effects.iter().map(|effect| effect.id).collect();
|
||||
assert_eq!(mask_order, vec![below, swapped, above]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn naming_the_current_filter_edits_it_in_place() {
|
||||
let mut s = session();
|
||||
let id = add(&mut s, "effect.add.filter", json!({"filter": "blur", "target": "content", "radius": 5.0}));
|
||||
|
||||
execute(&mut s, "effect.set", &json!({"effect": id.0, "filter": "blur", "radius": 9.0})).unwrap();
|
||||
execute(&mut s, "effect.set", &json!({"effect": id.0, "filter": "blur"})).unwrap();
|
||||
|
||||
let blur = effect(&s, id);
|
||||
assert!(matches!(blur.kind, EffectKind::Filter(Filter::Blur { radius }) if radius == 9.0), "the radius is kept, not reset: {:?}", blur.kind);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_name_given_with_the_swap_wins() {
|
||||
let mut s = session();
|
||||
let id = add(&mut s, "effect.add.filter", json!({"filter": "invert", "target": "content"}));
|
||||
|
||||
execute(&mut s, "effect.set", &json!({"effect": id.0, "filter": "threshold", "name": "Edges"})).unwrap();
|
||||
|
||||
let swapped = effect(&s, id);
|
||||
assert!(matches!(swapped.kind, EffectKind::Filter(Filter::Threshold { .. })), "{:?}", swapped.kind);
|
||||
assert_eq!(swapped.name, "Edges");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_refused_swap_changes_nothing_and_adds_no_undo_step() {
|
||||
let mut s = session();
|
||||
let id = add(&mut s, "effect.add.filter", json!({"filter": "invert", "target": "mask"}));
|
||||
execute(&mut s, "effect.set", &json!({"effect": id.0, "blend": "Multiply", "opacity": 0.4, "name": "Flip"})).unwrap();
|
||||
let before = effect(&s, id);
|
||||
|
||||
for refused in [
|
||||
json!({"effect": id.0, "filter": "grayscale"}),
|
||||
json!({"effect": id.0, "filter": "nope"}),
|
||||
json!({"effect": id.0, "filter": "levels"}),
|
||||
json!({"effect": id.0, "filter": "colorBalance", "shadows": "not a color"}),
|
||||
] {
|
||||
assert!(execute(&mut s, "effect.set", &refused).is_err(), "{refused}");
|
||||
}
|
||||
|
||||
assert_eq!(effect(&s, id), before);
|
||||
// The last step is still the blend, opacity and name edit
|
||||
execute(&mut s, "edit.undo", &Value::Null).unwrap();
|
||||
assert_eq!(effect(&s, id).name, "Invert");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn only_filter_effects_swap_and_only_to_filters() {
|
||||
let mut s = session();
|
||||
let levels = add(&mut s, "effect.add.levels", json!({"target": "content"}));
|
||||
let filter = add(&mut s, "effect.add.filter", json!({"filter": "invert", "target": "content"}));
|
||||
|
||||
assert!(execute(&mut s, "effect.set", &json!({"effect": levels.0, "filter": "blur"})).is_err(), "levels is not a filter effect");
|
||||
assert!(execute(&mut s, "effect.set", &json!({"effect": levels.0, "filter": "nope"})).is_err(), "an unknown filter on levels");
|
||||
assert!(execute(&mut s, "effect.set", &json!({"effect": filter.0, "filter": "matFinishGrind"})).is_err(), "a material finish is a fill");
|
||||
assert!(execute(&mut s, "effect.set", &json!({"effect": filter.0, "filter": "nope"})).is_err());
|
||||
assert!(matches!(effect(&s, filter).kind, EffectKind::Filter(Filter::Invert)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn invalid_swap_parameters_report_effect_set_and_preserve_history() {
|
||||
let mut s = session();
|
||||
let id = add(&mut s, "effect.add.filter", json!({"filter": "invert", "target": "content"}));
|
||||
let before = effect(&s, id);
|
||||
let history = s.history_labels();
|
||||
|
||||
let error = execute(&mut s, "effect.set", &json!({"effect": id.0, "filter": "colorBalance", "shadows": "invalid", "name": "Changed"})).unwrap_err();
|
||||
|
||||
assert!(matches!(error, texturecraft_engine::EngineError::BadParams { ref cmd, .. } if cmd == "effect.set"), "{error}");
|
||||
assert_eq!(effect(&s, id), before);
|
||||
assert_eq!(s.history_labels(), history);
|
||||
}
|
||||
File renamed without changes.
@@ -0,0 +1,57 @@
|
||||
use texturecraft_engine::bake::{HighPolyReach, RayStart, VertexReach, high_poly_missed};
|
||||
use texturecraft_engine::geom::glam::Vec3;
|
||||
|
||||
fn vertex(height: f32) -> Option<VertexReach> {
|
||||
Some(VertexReach {
|
||||
low_position: Vec3::ZERO,
|
||||
start: RayStart::Distance { up: Vec3::Y, scale: 1.0 },
|
||||
high_position: Vec3::new(0.0, height, 0.0),
|
||||
high_facing: Vec3::Y,
|
||||
name_matches: true,
|
||||
})
|
||||
}
|
||||
|
||||
fn reach(vertices: Vec<Option<VertexReach>>) -> Option<HighPolyReach> {
|
||||
Some(HighPolyReach { vertices, cage_units: 1.0, ignore_backface: false })
|
||||
}
|
||||
|
||||
fn sets() -> Vec<Option<HighPolyReach>> {
|
||||
vec![None, reach(vec![vertex(0.5), vertex(-0.25), None, None, None]), reach(vec![None, None, vertex(0.5), vertex(-0.25), None])]
|
||||
}
|
||||
|
||||
const DISTANCES: [(f32, f32); 3] = [(9.0, 9.0), (0.25, 0.25), (0.5, 0.125)];
|
||||
|
||||
#[test]
|
||||
fn each_owning_set_uses_its_own_frontal_and_rear_distances() {
|
||||
let reaches = sets();
|
||||
assert_eq!(high_poly_missed(&reaches, &DISTANCES, None, 6), vec![1.0, 0.0, 0.0, 1.0, 0.0, 0.0]);
|
||||
let expanded = [(9.0, 9.0), (0.5, 0.25), (0.5, 0.25)];
|
||||
assert_eq!(high_poly_missed(&reaches, &expanded, None, 6), vec![0.0; 6]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn selected_set_filter_leaves_other_sets_unmarked() {
|
||||
let reaches = sets();
|
||||
assert_eq!(high_poly_missed(&reaches, &DISTANCES, Some(1), 6), vec![1.0, 0.0, 0.0, 0.0, 0.0, 0.0]);
|
||||
assert_eq!(high_poly_missed(&reaches, &DISTANCES, Some(2), 6), vec![0.0, 0.0, 0.0, 1.0, 0.0, 0.0]);
|
||||
for only_set in [0, reaches.len(), usize::MAX] {
|
||||
assert_eq!(high_poly_missed(&reaches, &DISTANCES, Some(only_set), 6), vec![0.0; 6]);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn missing_reach_or_distances_leave_vertices_unmarked() {
|
||||
assert_eq!(high_poly_missed(&[], &DISTANCES, None, 6), vec![0.0; 6]);
|
||||
assert_eq!(high_poly_missed(&sets(), &[], None, 6), vec![0.0; 6]);
|
||||
assert_eq!(high_poly_missed(&sets(), &DISTANCES[..2], None, 6), vec![1.0, 0.0, 0.0, 0.0, 0.0, 0.0]);
|
||||
assert_eq!(high_poly_missed(&sets(), &DISTANCES, None, 1), vec![1.0]);
|
||||
assert!(high_poly_missed(&sets(), &DISTANCES, None, 0).is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_reached_vertex_is_not_overridden_by_a_later_set() {
|
||||
let reaches = [reach(vec![vertex(0.5)]), reach(vec![vertex(0.5)])];
|
||||
let distances = [(0.5, 0.0), (0.25, 0.0)];
|
||||
assert_eq!(high_poly_missed(&reaches, &distances, None, 1), vec![0.0]);
|
||||
assert_eq!(high_poly_missed(&reaches, &distances, Some(1), 1), vec![1.0]);
|
||||
}
|
||||
File renamed without changes.
@@ -0,0 +1,27 @@
|
||||
//! One integration-test executable avoids linking the same dependencies for every feature.
|
||||
//! Keep feature tests in their own modules; the standalone session.rs target remains available.
|
||||
|
||||
mod bake;
|
||||
mod bake_resolution;
|
||||
mod bake_settings;
|
||||
mod bake_tiles;
|
||||
mod color_selection;
|
||||
mod content_effects;
|
||||
mod export_colour_space;
|
||||
mod filter_swap;
|
||||
mod filters;
|
||||
mod high_poly_missed;
|
||||
mod instances;
|
||||
mod materialcraft_link;
|
||||
mod materialx;
|
||||
mod materialx_import;
|
||||
mod meshmap_import;
|
||||
mod painter_gaps;
|
||||
mod path_tool;
|
||||
mod perf;
|
||||
mod polygon_fill;
|
||||
mod project_recovery;
|
||||
mod sample;
|
||||
mod tools;
|
||||
mod udim;
|
||||
mod uv_strokes;
|
||||
File renamed without changes.
File renamed without changes.
File renamed without changes.
@@ -0,0 +1,298 @@
|
||||
//! Importing baked map files at once: each lands in the texture set and mesh map its name names
|
||||
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use serde_json::{Value, json};
|
||||
use texturecraft_engine::core::BakedMap;
|
||||
use texturecraft_engine::geom::primitives;
|
||||
use texturecraft_engine::{Session, execute};
|
||||
|
||||
/// The material ball: texture sets "Ball" and "Base"
|
||||
fn session() -> Session {
|
||||
Session::new_project("t", primitives::material_ball(), "builtin:material_ball", None, 128).unwrap()
|
||||
}
|
||||
|
||||
/// A folder of 4×4 gray PNGs named `files`, each with its own gray level
|
||||
fn bake_folder(test: &str, files: &[&str]) -> PathBuf {
|
||||
let dir = std::env::temp_dir().join(format!("texturecraft-meshmap-import-{test}-{}", std::process::id()));
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
for (index, file) in files.iter().enumerate() {
|
||||
let gray = u8::try_from(20 + 20 * index).unwrap_or(u8::MAX);
|
||||
image::RgbaImage::from_pixel(4, 4, image::Rgba([gray, gray, gray, 255])).save(dir.join(file)).unwrap();
|
||||
}
|
||||
dir
|
||||
}
|
||||
|
||||
fn import(s: &mut Session, dir: &Path, files: &[(&str, Option<&str>)]) -> Value {
|
||||
let files: Vec<Value> = files
|
||||
.iter()
|
||||
.map(|(file, map)| {
|
||||
let path = dir.join(file).display().to_string();
|
||||
match map {
|
||||
Some(map) => json!({"path": path, "map": map}),
|
||||
None => json!({"path": path}),
|
||||
}
|
||||
})
|
||||
.collect();
|
||||
execute(s, "textureSet.meshMap.import", &json!({ "files": files })).unwrap()
|
||||
}
|
||||
|
||||
fn file_names(list: &Value) -> Vec<String> {
|
||||
list.as_array()
|
||||
.unwrap()
|
||||
.iter()
|
||||
.map(|entry| entry.as_str().unwrap_or_else(|| entry["path"].as_str().unwrap()))
|
||||
.map(|path| path.rsplit(['/', '\\']).next().unwrap().to_string())
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn has_map(s: &Session, ts: usize, map: BakedMap) -> bool {
|
||||
s.doc.baked.get(&ts).is_some_and(|baked| baked.maps.contains_key(&map)) && s.doc.project.texture_sets[ts].baked.contains(&map)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn files_go_to_the_set_and_map_their_names_name() {
|
||||
let files = ["Ball_normal.png", "Ball_world_normal.png", "base-AO.png", "Base_curvature.png", "Ball_diffuse.png", "Head_ao.png", "Base_id.png"];
|
||||
let dir = bake_folder("sets", &files);
|
||||
let mut s = session();
|
||||
let label_before = s.undo_label().map(str::to_string);
|
||||
|
||||
let result = import(&mut s, &dir, &files.map(|file| (file, None)));
|
||||
|
||||
let assigned = &result["assigned"];
|
||||
assert_eq!(file_names(assigned).len(), 5, "{result}");
|
||||
for (ts, map) in [(0, BakedMap::Normal), (0, BakedMap::WorldNormal), (1, BakedMap::AmbientOcclusion), (1, BakedMap::Curvature), (1, BakedMap::Id)] {
|
||||
assert!(has_map(&s, ts, map), "set {ts} lacks {}", map.id());
|
||||
assert!(assigned.as_array().unwrap().iter().any(|entry| entry["ts"] == ts && entry["map"] == map.id()), "{result}");
|
||||
}
|
||||
assert_eq!(file_names(&result["unmatched"]), ["Ball_diffuse.png", "Head_ao.png"]);
|
||||
assert_eq!(s.undo_label(), Some("Import baked maps"));
|
||||
|
||||
execute(&mut s, "edit.undo", &Value::Null).unwrap();
|
||||
assert_eq!(s.undo_label().map(str::to_string), label_before, "one undo step");
|
||||
assert!(s.doc.baked.values().all(|baked| baked.maps.is_empty()), "undo removes every imported map");
|
||||
assert!(s.doc.resources.is_empty(), "undo removes the imported image resources");
|
||||
std::fs::remove_dir_all(dir).ok();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_given_map_overrides_the_name() {
|
||||
let dir = bake_folder("override", &["Ball_bake3.png", "Base_normal.png"]);
|
||||
let mut s = session();
|
||||
|
||||
let result = import(&mut s, &dir, &[("Ball_bake3.png", Some("thickness")), ("Base_normal.png", Some("height"))]);
|
||||
|
||||
assert_eq!(file_names(&result["assigned"]).len(), 2, "{result}");
|
||||
assert!(has_map(&s, 0, BakedMap::Thickness));
|
||||
assert!(has_map(&s, 1, BakedMap::Height));
|
||||
assert!(!has_map(&s, 1, BakedMap::Normal));
|
||||
std::fs::remove_dir_all(dir).ok();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_second_file_for_one_slot_is_left_out() {
|
||||
let dir = bake_folder("twice", &["Ball_ao.png", "Ball_occlusion.png"]);
|
||||
let mut s = session();
|
||||
|
||||
let result = import(&mut s, &dir, &[("Ball_ao.png", None), ("Ball_occlusion.png", None)]);
|
||||
|
||||
assert_eq!(file_names(&result["assigned"]), ["Ball_ao.png"]);
|
||||
assert_eq!(file_names(&result["unmatched"]), ["Ball_occlusion.png"]);
|
||||
assert_eq!(s.doc.resources.len(), 1, "the left-out file is not imported");
|
||||
std::fs::remove_dir_all(dir).ok();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_undecodable_file_imports_nothing() {
|
||||
let dir = bake_folder("undecodable", &["Ball_ao.png"]);
|
||||
std::fs::write(dir.join("Base_ao.png"), b"not an image").unwrap();
|
||||
let mut s = session();
|
||||
let label_before = s.undo_label().map(str::to_string);
|
||||
let files = json!({"files": [{"path": dir.join("Ball_ao.png").display().to_string()}, {"path": dir.join("Base_ao.png").display().to_string()}]});
|
||||
|
||||
let error = execute(&mut s, "textureSet.meshMap.import", &files).unwrap_err().to_string();
|
||||
|
||||
assert!(error.contains("Base_ao.png"), "{error}");
|
||||
assert!(s.doc.baked.values().all(|baked| baked.maps.is_empty()));
|
||||
assert!(s.doc.resources.is_empty() && s.images.is_empty());
|
||||
assert_eq!(s.undo_label().map(str::to_string), label_before);
|
||||
std::fs::remove_dir_all(dir).ok();
|
||||
}
|
||||
|
||||
/// The UV tile plane: one texture set "Plane" on tiles 1001 and 1002
|
||||
fn tiled_session() -> Session {
|
||||
Session::new_project("t", primitives::udim_plane(), "builtin:udim_plane", None, 128).unwrap()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_uv_tiled_set_takes_one_file_per_tile_however_each_is_written() {
|
||||
let files = ["Plane_ao.1001.png", "plane-AO-1002.png"];
|
||||
let dir = bake_folder("tiles", &files);
|
||||
let mut s = tiled_session();
|
||||
|
||||
let result = import(&mut s, &dir, &files.map(|file| (file, None)));
|
||||
|
||||
assert_eq!(file_names(&result["assigned"]).len(), 2, "{result}");
|
||||
let baked = &s.doc.baked[&0];
|
||||
let ao = &baked.maps[&BakedMap::AmbientOcclusion];
|
||||
let width = baked.resolution as usize;
|
||||
let middle_row = ao.len() / width / 2 * width;
|
||||
assert!(ao[middle_row + width / 4] < ao[middle_row + 3 * width / 4], "each tile reads its own file");
|
||||
std::fs::remove_dir_all(dir).ok();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tiled_files_without_their_tiles_are_left_out_alone() {
|
||||
let files = ["Plane_ao.1001.png", "Plane_ao.1002.png", "Plane_normal.png", "Plane_curvature.1001.png", "Plane_id.1005.png"];
|
||||
let dir = bake_folder("partial-tiles", &files);
|
||||
let mut s = tiled_session();
|
||||
|
||||
let result = import(&mut s, &dir, &files.map(|file| (file, None)));
|
||||
|
||||
assert_eq!(file_names(&result["assigned"]), ["Plane_ao.1001.png", "Plane_ao.1002.png"]);
|
||||
assert_eq!(file_names(&result["unmatched"]), ["Plane_normal.png", "Plane_id.1005.png", "Plane_curvature.1001.png"]);
|
||||
assert!(has_map(&s, 0, BakedMap::AmbientOcclusion));
|
||||
assert_eq!(s.doc.resources.len(), 2, "left-out files are not imported");
|
||||
std::fs::remove_dir_all(dir).ok();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn nothing_matched_makes_no_undo_step() {
|
||||
let dir = bake_folder("none", &["Head_ao.png", "Ball_diffuse.png"]);
|
||||
let mut s = session();
|
||||
let label_before = s.undo_label().map(str::to_string);
|
||||
|
||||
let result = import(&mut s, &dir, &[("Head_ao.png", None), ("Ball_diffuse.png", None)]);
|
||||
|
||||
assert_eq!(file_names(&result["assigned"]), Vec::<String>::new());
|
||||
assert_eq!(file_names(&result["unmatched"]).len(), 2);
|
||||
assert_eq!(s.undo_label().map(str::to_string), label_before);
|
||||
assert!(!s.modified);
|
||||
std::fs::remove_dir_all(dir).ok();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_invalid_map_override_does_not_fall_back_to_the_file_name() {
|
||||
let dir = bake_folder("invalid-map", &["Ball_ao.png"]);
|
||||
let mut session = session();
|
||||
for map in [json!(true), json!(42), json!([]), json!({}), json!("unknown")] {
|
||||
let params = json!({"files": [{"path": dir.join("Ball_ao.png"), "map": map}]});
|
||||
let result = execute(&mut session, "textureSet.meshMap.import", ¶ms);
|
||||
assert!(result.is_err(), "invalid map {map} must be rejected: {result:?}");
|
||||
assert!(session.doc.resources.is_empty());
|
||||
assert!(!session.modified);
|
||||
}
|
||||
std::fs::remove_dir_all(dir).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "release benchmark; run with --ignored --nocapture --test-threads=1"]
|
||||
fn benchmark_baked_map_import() {
|
||||
use std::time::Instant;
|
||||
use texturecraft_engine::core::BakeResolution;
|
||||
|
||||
let dir = std::env::temp_dir().join(format!("texturecraft-import-benchmark-{}", std::process::id()));
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
for (size, tiled) in [(1024, false), (2048, false), (1024, true)] {
|
||||
let mut files = Vec::new();
|
||||
let mut encoded_bytes = 0;
|
||||
for map in ["normal", "ao", "curvature"] {
|
||||
for tile in 1001..=if tiled { 1002 } else { 1001 } {
|
||||
let path = dir.join(format!("mesh_{map}.{tile}.png"));
|
||||
image::RgbaImage::from_fn(size, size, |x, y| {
|
||||
let value = (x.wrapping_mul(73) ^ y.wrapping_mul(151) ^ tile) as u8;
|
||||
image::Rgba([value, value.wrapping_add(37), 255, 255])
|
||||
})
|
||||
.save(&path)
|
||||
.unwrap();
|
||||
encoded_bytes += std::fs::metadata(&path).unwrap().len();
|
||||
files.push(json!({"path": path}));
|
||||
}
|
||||
}
|
||||
let params = json!({"files": files});
|
||||
let mut milliseconds = Vec::new();
|
||||
for iteration in 0..6 {
|
||||
let mesh = if tiled { primitives::udim_plane() } else { primitives::cube(2.0) };
|
||||
let mut session = Session::new_project("benchmark", mesh, "builtin:cube", None, 128).unwrap();
|
||||
session.doc.project.texture_sets[0].bake.common.resolution = BakeResolution::from_pixels(size).unwrap();
|
||||
let started = Instant::now();
|
||||
let result = execute(&mut session, "textureSet.meshMap.import", ¶ms).unwrap();
|
||||
let elapsed = started.elapsed().as_secs_f64() * 1000.0;
|
||||
assert_eq!(result["assigned"].as_array().unwrap().len(), files.len());
|
||||
assert_eq!(session.doc.baked[&0].maps.len(), 3);
|
||||
if iteration > 0 {
|
||||
milliseconds.push(elapsed);
|
||||
}
|
||||
}
|
||||
milliseconds.sort_by(f64::total_cmp);
|
||||
eprintln!(
|
||||
"import size={size} tiles={} files={} encoded_bytes={encoded_bytes} median_ms={:.3} min_ms={:.3} max_ms={:.3}",
|
||||
if tiled { 2 } else { 1 },
|
||||
files.len(),
|
||||
milliseconds[2],
|
||||
milliseconds[0],
|
||||
milliseconds[4]
|
||||
);
|
||||
}
|
||||
std::fs::remove_dir_all(dir).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tiled_import_uses_new_images_when_resource_names_collide() {
|
||||
let files = ["Plane_ao.1001.png", "Plane_ao.1002.png"];
|
||||
let dir = bake_folder("collisions", &files);
|
||||
let mut session = tiled_session();
|
||||
let old_bytes = std::fs::read(dir.join(files[0])).unwrap();
|
||||
for name in files {
|
||||
session.import_resource_bytes(name, old_bytes.clone()).unwrap();
|
||||
}
|
||||
let revision_before = session.revision;
|
||||
|
||||
import(&mut session, &dir, &files.map(|file| (file, None)));
|
||||
|
||||
let baked = &session.doc.baked[&0];
|
||||
let ao = &baked.maps[&BakedMap::AmbientOcclusion];
|
||||
let width = baked.resolution as usize;
|
||||
let row = ao.len() / width / 2 * width;
|
||||
assert!((ao[row + width / 4] - 20.0 / 255.0).abs() < 1e-5);
|
||||
assert!((ao[row + 3 * width / 4] - 40.0 / 255.0).abs() < 1e-5);
|
||||
assert_eq!(session.revision, revision_before + 1);
|
||||
assert_eq!(session.doc.resources.len(), 4);
|
||||
|
||||
session.undo().unwrap();
|
||||
assert_eq!(session.doc.resources.len(), 2);
|
||||
assert_eq!(session.images.len(), 2);
|
||||
session.redo().unwrap();
|
||||
assert_eq!(session.images.len(), 4);
|
||||
assert!(has_map(&session, 0, BakedMap::AmbientOcclusion));
|
||||
std::fs::remove_dir_all(dir).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn too_many_files_are_rejected_before_reading_any() {
|
||||
let mut session = session();
|
||||
let files = vec![json!({"path": "Ball_ao.png"}); 513];
|
||||
let error = execute(&mut session, "textureSet.meshMap.import", &json!({"files": files})).unwrap_err().to_string();
|
||||
assert!(error.contains("at most 512 files"), "{error}");
|
||||
assert!(session.doc.resources.is_empty());
|
||||
assert!(!session.modified);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tga_maps_survive_undo_redo_and_project_reload() {
|
||||
let dir = bake_folder("tga", &["Ball_normal.tga", "Base_ao.png"]);
|
||||
let mut session = session();
|
||||
let result = import(&mut session, &dir, &[("Ball_normal.tga", None), ("Base_ao.png", None)]);
|
||||
assert_eq!(result["assigned"].as_array().unwrap().len(), 2);
|
||||
assert!(has_map(&session, 0, BakedMap::Normal));
|
||||
let image = session.images["Ball_normal.tga"].clone();
|
||||
|
||||
session.undo().unwrap();
|
||||
assert!(session.images.is_empty());
|
||||
session.redo().unwrap();
|
||||
assert_eq!(session.images["Ball_normal.tga"].rgba, image.rgba);
|
||||
let reloaded = Session::from_project_bytes(&session.to_project_bytes().unwrap()).unwrap();
|
||||
assert_eq!(reloaded.images["Ball_normal.tga"].rgba, image.rgba);
|
||||
assert_eq!(reloaded.doc.baked, session.doc.baked);
|
||||
std::fs::remove_dir_all(dir).unwrap();
|
||||
}
|
||||
File renamed without changes.
File renamed without changes.
File renamed without changes.
@@ -0,0 +1,88 @@
|
||||
//! Polygon fill drag transitions preserve already painted targets
|
||||
|
||||
use serde_json::json;
|
||||
use texturecraft_engine::core::Channel;
|
||||
use texturecraft_engine::geom::{glam::Vec2, primitives};
|
||||
use texturecraft_engine::{Session, execute};
|
||||
|
||||
#[test]
|
||||
fn changing_layers_during_a_box_drag_preserves_the_first_fill() {
|
||||
let mut session = Session::new_project("t", primitives::plane(2.0, 4), "test", None, 128).unwrap();
|
||||
let first = session.selected_layer().unwrap();
|
||||
execute(&mut session, "layer.add.paint", &json!({})).unwrap();
|
||||
let second = session.selected_layer().unwrap();
|
||||
execute(&mut session, "layer.select", &json!({"layer": first.0})).unwrap();
|
||||
let history = session.history_labels().len();
|
||||
|
||||
session.drag_polygon_fill_box_uv(Vec2::ZERO, Vec2::ONE).unwrap();
|
||||
execute(&mut session, "layer.select", &json!({"layer": second.0})).unwrap();
|
||||
session.drag_polygon_fill_box_uv(Vec2::ZERO, Vec2::new(0.4, 1.0)).unwrap();
|
||||
session.end_polygon_fill_box();
|
||||
|
||||
assert!(session.doc.pixels.layer(first, Channel::BaseColor).is_some(), "the first layer keeps its fill");
|
||||
assert!(session.doc.pixels.layer(second, Channel::BaseColor).is_some(), "the new target receives the next fill");
|
||||
assert_eq!(session.history_labels().len(), history + 2, "each target has its own undo step");
|
||||
session.undo().unwrap();
|
||||
assert!(session.doc.pixels.layer(first, Channel::BaseColor).is_some());
|
||||
assert!(session.doc.pixels.layer(second, Channel::BaseColor).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn changing_from_content_to_mask_during_a_box_drag_preserves_content() {
|
||||
let mut session = Session::new_project("t", primitives::plane(2.0, 4), "test", None, 128).unwrap();
|
||||
let layer = session.selected_layer().unwrap();
|
||||
execute(&mut session, "mask.add.black", &json!({})).unwrap();
|
||||
execute(&mut session, "layer.select", &json!({"layer": layer.0, "target": "content"})).unwrap();
|
||||
let history = session.history_labels().len();
|
||||
|
||||
session.drag_polygon_fill_box_uv(Vec2::ZERO, Vec2::ONE).unwrap();
|
||||
execute(&mut session, "layer.select", &json!({"layer": layer.0, "target": "mask"})).unwrap();
|
||||
session.drag_polygon_fill_box_uv(Vec2::ZERO, Vec2::new(0.4, 1.0)).unwrap();
|
||||
session.end_polygon_fill_box();
|
||||
|
||||
assert!(session.doc.pixels.layer(layer, Channel::BaseColor).is_some(), "switching to the mask keeps the content fill");
|
||||
assert_eq!(session.history_labels().len(), history + 2);
|
||||
session.undo().unwrap();
|
||||
assert!(session.doc.pixels.layer(layer, Channel::BaseColor).is_some());
|
||||
assert!(session.doc.project.layer(layer).unwrap().mask.as_ref().unwrap().effects.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "release performance measurement"]
|
||||
fn benchmark_live_box_fill() {
|
||||
use std::hint::black_box;
|
||||
use std::time::Instant;
|
||||
|
||||
for (name, mesh) in [("ball", primitives::material_ball()), ("sphere", primitives::sphere(1.0, 512, 256))] {
|
||||
let triangles = mesh.triangle_count();
|
||||
let mut session = Session::new_project("benchmark", mesh, "test", None, 1024).unwrap();
|
||||
let viewport = Vec2::new(1920.0, 1080.0);
|
||||
let start = Instant::now();
|
||||
session.drag_polygon_fill_box(viewport * 0.4, viewport * 0.6, viewport).unwrap();
|
||||
let first_ms = start.elapsed().as_secs_f64() * 1000.0;
|
||||
let mut times = Vec::new();
|
||||
for step in 1..=12 {
|
||||
let radius = 0.1 + step as f32 * 0.02;
|
||||
let start = Instant::now();
|
||||
black_box(session.drag_polygon_fill_box(viewport * (0.5 - radius), viewport * (0.5 + radius), viewport).unwrap());
|
||||
times.push(start.elapsed().as_secs_f64() * 1000.0);
|
||||
}
|
||||
let (corner, opposite) = (viewport * 0.16, viewport * 0.84);
|
||||
session.drag_polygon_fill_box(corner, opposite, viewport).unwrap();
|
||||
let start = Instant::now();
|
||||
for _ in 0..1000 {
|
||||
black_box(session.drag_polygon_fill_box(corner, opposite, viewport).unwrap());
|
||||
}
|
||||
let unchanged_us = start.elapsed().as_secs_f64() * 1000.0;
|
||||
session.end_polygon_fill_box();
|
||||
let start = Instant::now();
|
||||
session.update();
|
||||
let composite_ms = start.elapsed().as_secs_f64() * 1000.0;
|
||||
times.sort_by(f64::total_cmp);
|
||||
let memory = session.memory();
|
||||
eprintln!(
|
||||
"{name}: {triangles} triangles, first={first_ms:.3} ms, growing median={:.3} ms max={:.3} ms, unchanged mean={unchanged_us:.3} us, composite={composite_ms:.3} ms, pixels={} bytes composites={} bytes cache={} bytes",
|
||||
times[6], times[11], memory.pixels, memory.composites, memory.cache
|
||||
);
|
||||
}
|
||||
}
|
||||
File renamed without changes.
Loaded 100 of 235 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user