mirror of
https://github.com/storytold/texturecraft.git
synced 2026-11-20 06:20:50 +01:00
Merge main and fix path preview issues
This commit is contained in:
commit
6ec769feca
265 files changed
+21576
-2915
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
|
||||
@@ -33,4 +33,9 @@ jobs:
|
||||
uses: storytold/craft-common-actions/.github/workflows/freebsd.yml@main
|
||||
with:
|
||||
craft-fonts-ref: aced4137c022f1f587624d48e81ec77e1914a9cc
|
||||
# The VM's software Vulkan driver crashes (SIGSEGV) when several tests set up a device at
|
||||
# once (photocraft serializes its GPU tests for the same reason), so tests run one at a
|
||||
# time. The whole workspace is tested in one command: excluding packages would change
|
||||
# feature unification and build winit without its X11/Wayland backends.
|
||||
cargo-test-extra-args: "-- --test-threads=1"
|
||||
run-package-check: true
|
||||
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
|
||||
}
|
||||
|
||||
|
||||
+321
-134
@@ -2,19 +2,24 @@
|
||||
//! tile by tile in parallel. This is the reference implementation (the oracle) for the viewport
|
||||
//! and for export.
|
||||
|
||||
pub(crate) mod thumbnail;
|
||||
|
||||
use std::borrow::Cow;
|
||||
use std::collections::{BTreeMap, HashMap};
|
||||
use std::sync::Arc;
|
||||
|
||||
use rayon::prelude::*;
|
||||
use texturecraft_core::{
|
||||
BakedMap, BlendMode, BlockScales, Channel, ChannelKind, CompareOp, Effect, EffectKind, Fill, Filter, Generator, GeneratorKind, HeightMask, Layer, LayerId,
|
||||
LayerKind, Mask, MaskBackground, NormalFormat, Project, Projection, Source, TextureSet, TileGrid, blend1, blend3, lum, mix3, per_unit,
|
||||
BakedMap, BlendMode, BlockScales, Channel, ChannelKind, CompareOp, CurvatureDetail, CurvatureMode, Effect, EffectKind, Fill, Filter, Generator,
|
||||
GeneratorKind, HeightMask, Layer, LayerId, LayerKind, Mask, MaskBackground, NormalFormat, Project, Projection, Source, TextureSet, TileGrid, blend1,
|
||||
blend3, lum, mix3, per_unit,
|
||||
};
|
||||
use texturecraft_geom::glam::{Vec2, Vec3};
|
||||
use texturecraft_geom::{Mesh, NO_TRI, UvGBuffer};
|
||||
use texturecraft_texel::{DilationMap, TILE, TILE_AREA, TileImage, from_u16, noise, to_u16, to_u16_signed};
|
||||
|
||||
use crate::below::{Band, BelowCache, Level};
|
||||
use crate::curvature_sizes::CurvatureSizes;
|
||||
use crate::pattern::{Coords, decal_uv, image_samples, procedural, world_noise};
|
||||
use crate::store::{BakedMaps, ImageStore, PixelStore, decode};
|
||||
|
||||
@@ -204,6 +209,8 @@ struct EffectPlan<'a> {
|
||||
opacity: f32,
|
||||
data: Option<Cow<'a, [u16]>>,
|
||||
preview: bool,
|
||||
/// The curvature detail sizes a generator with detail reads.
|
||||
curvature_sizes: Option<Arc<CurvatureSizes>>,
|
||||
}
|
||||
|
||||
struct MaskPlan<'a> {
|
||||
@@ -304,6 +311,12 @@ fn direction(angle: f32) -> [f32; 2] {
|
||||
[cs, -sn]
|
||||
}
|
||||
|
||||
/// Gain on the curvature map's own deviation from flat (±0.5 reaches black and white).
|
||||
const MAP_GAIN: f32 = 2.0;
|
||||
|
||||
/// Gain per texel of a detail size: blurring spreads an edge over about twice its radius, so wider sizes need proportionally more to reach full strength.
|
||||
const GAIN_PER_DETAIL_TEXEL: f32 = 2.0 * std::f32::consts::SQRT_2;
|
||||
|
||||
/// Samples along a directional or slope blur at most (beyond, samples spread out).
|
||||
const LINE_SAMPLES: i32 = 24;
|
||||
|
||||
@@ -421,17 +434,20 @@ fn gather(op: Op, orig: &[f32], cover: &[f32], comps: usize, (x0, y0, w, h): (u3
|
||||
/// the region it is computed in, so tiles composited in any grouping agree exactly.
|
||||
const FIX: f64 = (1u64 << 24) as f64;
|
||||
|
||||
/// Three running-sum box blurs (≈ Gaussian) of a `w × h` image along rows then along columns.
|
||||
/// Rows (and columns, transposed) blur in parallel.
|
||||
fn blur(data: &mut [f32], w: usize, h: usize, r: usize) {
|
||||
let fix = |v: &f32| if v.is_finite() { (f64::from(v.clamp(-1e6, 1e6)) * FIX).round() as i64 } else { 0 };
|
||||
let mut v: Vec<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 +455,7 @@ fn blur_rows(data: &mut [i64], w: usize, r: usize) {
|
||||
}
|
||||
data.par_chunks_mut(w).for_each(|row| {
|
||||
let mut tmp = vec![0i64; row.len()];
|
||||
for _ in 0..3 {
|
||||
for _ in 0..BLUR_BOX_PASSES {
|
||||
box_line(row, &mut tmp, r);
|
||||
row.copy_from_slice(&tmp);
|
||||
}
|
||||
@@ -760,28 +776,53 @@ fn fields_of(inp: &Inputs, channels: &[Channel], list: &[LayerId], tiles: &[(u32
|
||||
if tiles.is_empty() || inp.gbuf.width == 0 {
|
||||
return out;
|
||||
}
|
||||
let res = inp.gbuf.width;
|
||||
|
||||
let working_width = inp.gbuf.width;
|
||||
let mut order = Vec::new();
|
||||
draw_order(inp.project, list, 0, &mut order);
|
||||
prepare_curvature_sizes(inp, &order);
|
||||
|
||||
for id in order {
|
||||
let Some(layer) = inp.project.content_layer(id) else { continue };
|
||||
if let Some(m) = layer_mask(inp.project, id).filter(|m| m.enabled && neighbourhood(&m.effects, res).is_some())
|
||||
&& let Some(f) = field(inp, channels, &out, id, Job::Mask(m), tiles)
|
||||
|
||||
if let Some(mask) = layer_mask(inp.project, id).filter(|mask| mask.enabled && neighbourhood(&mask.effects, working_width).is_some())
|
||||
&& let Some(filtered) = field(inp, channels, &out, id, Job::Mask(mask), tiles)
|
||||
{
|
||||
out.insert(FieldKey::Mask(id), f);
|
||||
out.insert(FieldKey::Mask(id), filtered);
|
||||
}
|
||||
if layer.is_group() || neighbourhood(&layer.content_effects, res).is_none() {
|
||||
|
||||
if layer.is_group() || neighbourhood(&layer.content_effects, working_width).is_none() {
|
||||
continue;
|
||||
}
|
||||
for ch in channels.iter().filter(|c| layer.channels.contains_key(c)) {
|
||||
if let Some(f) = field(inp, channels, &out, id, Job::Content(*ch), tiles) {
|
||||
out.insert(FieldKey::Content(id, *ch), f);
|
||||
for channel in channels.iter().filter(|channel| layer.channels.contains_key(channel)) {
|
||||
if let Some(filtered) = field(inp, channels, &out, id, Job::Content(*channel), tiles) {
|
||||
out.insert(FieldKey::Content(id, *channel), filtered);
|
||||
}
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Build the curvature detail sizes every visible generator of `layers` reads, once, before tiles composite in parallel.
|
||||
fn prepare_curvature_sizes(inp: &Inputs, layers: &[LayerId]) {
|
||||
let visible = layers.iter().filter(|id| inp.project.layers.get(id).is_some_and(|layer| layer.visible));
|
||||
let masks = visible.filter_map(|id| layer_mask(inp.project, *id)).filter(|mask| mask.enabled);
|
||||
prepare_mask_curvature_sizes(inp, masks);
|
||||
}
|
||||
|
||||
/// Build the curvature detail sizes the visible generators of `masks` read, once, before tiles composite in parallel.
|
||||
fn prepare_mask_curvature_sizes<'a>(inp: &Inputs, masks: impl Iterator<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 +840,26 @@ struct Node<'a> {
|
||||
|
||||
/// Plans of the visible effects of a stack: mask effects (`channel` None) or the content
|
||||
/// effects of one channel (paint effects then read that channel's pixels).
|
||||
fn effect_plans<'a>(inp: &Inputs<'a>, effects: &'a [Effect], tx: u32, ty: u32, channel: Option<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()
|
||||
@@ -1129,131 +1175,183 @@ impl<'a, 'b> Texel<'a, 'b> {
|
||||
w * image.map_or(1.0, |img| img.sample(c.uv.x, c.uv.y)[3].clamp(0.0, 1.0))
|
||||
}
|
||||
|
||||
fn source(&mut self, s: &Source, proj: &Projection, kind: ChannelKind) -> [f32; 3] {
|
||||
match s {
|
||||
Source::Uniform(v) => *v,
|
||||
/// The value `source` gives this texel through `projection`, read as a channel of `kind`
|
||||
fn source(&mut self, source: &Source, projection: &Projection, kind: ChannelKind) -> [f32; 3] {
|
||||
match source {
|
||||
Source::Uniform(value) => *value,
|
||||
Source::Procedural { pattern, low, high } => {
|
||||
let (c, proj, _) = self.projected(proj);
|
||||
let t = procedural(pattern, proj, &c);
|
||||
mix3(*low, *high, t)
|
||||
let (coords, projection, _) = self.projected(projection);
|
||||
let amount = procedural(pattern, projection, &coords);
|
||||
mix3(*low, *high, amount)
|
||||
}
|
||||
Source::Image { name, normal_format } => {
|
||||
let Some(img) = self.inp.images.get(name) else { return [0.5; 3] };
|
||||
let (c, proj, _) = self.projected(proj);
|
||||
let mut acc = [0.0f32; 4];
|
||||
for (uv, w) in image_samples(proj, &c).into_iter().filter(|(_, w)| *w > 0.0) {
|
||||
let s = img.sample(uv.x, uv.y);
|
||||
for k in 0..4 {
|
||||
acc[k] += s[k] * w;
|
||||
let Some(image) = self.inp.images.get(name) else { return [0.5; 3] };
|
||||
|
||||
let (coords, projection, _) = self.projected(projection);
|
||||
let mut sum = [0.0f32; 4];
|
||||
for (uv, weight) in image_samples(projection, &coords).into_iter().filter(|(_, weight)| *weight > 0.0) {
|
||||
for (total, value) in sum.iter_mut().zip(image.sample(uv.x, uv.y)) {
|
||||
*total += value * weight;
|
||||
}
|
||||
}
|
||||
|
||||
let rgb = [sum[0], sum[1], sum[2]];
|
||||
match kind {
|
||||
ChannelKind::Color if img.srgb => [acc[0], acc[1], acc[2]].map(texturecraft_texel::srgb_to_linear),
|
||||
// Normal channels are OpenGL (+Y up the image): a DirectX image's green flips.
|
||||
ChannelKind::NormalMap if *normal_format == NormalFormat::DirectX => [acc[0], 1.0 - acc[1], acc[2]],
|
||||
ChannelKind::Color | ChannelKind::NormalMap => [acc[0], acc[1], acc[2]],
|
||||
ChannelKind::Scalar => [acc[0]; 3],
|
||||
ChannelKind::Signed => [acc[0] * 2.0 - 1.0; 3],
|
||||
ChannelKind::Color if image.srgb => rgb.map(texturecraft_texel::srgb_to_linear),
|
||||
// Normal channels are OpenGL (+Y up the image): a DirectX image's green flips
|
||||
ChannelKind::NormalMap if *normal_format == NormalFormat::DirectX => [rgb[0], 1.0 - rgb[1], rgb[2]],
|
||||
ChannelKind::Color | ChannelKind::NormalMap => rgb,
|
||||
// A one-value channel or mask reads the image's gray, so a color image works as a mask
|
||||
ChannelKind::Scalar => [lum(rgb); 3],
|
||||
ChannelKind::Signed => [lum(rgb) * 2.0 - 1.0; 3],
|
||||
}
|
||||
}
|
||||
Source::Anchor { anchor, channel } => {
|
||||
// An anchor not evaluated yet (above this layer, hidden) reads the channel default.
|
||||
let v = self.anchors.iter().rev().find(|(id, _)| id == anchor).and_then(|(_, acc)| acc.get(channel.index()).copied());
|
||||
let v = v.unwrap_or_else(|| channel.default_value());
|
||||
// An anchor not evaluated yet (above this layer, hidden) reads the channel default
|
||||
let anchored = self.anchors.iter().rev().find(|(id, _)| id == anchor).and_then(|(_, values)| values.get(channel.index()).copied());
|
||||
let value = anchored.unwrap_or_else(|| channel.default_value());
|
||||
let gray = matches!(channel.kind(), ChannelKind::Color | ChannelKind::NormalMap) && matches!(kind, ChannelKind::Scalar | ChannelKind::Signed);
|
||||
if gray { [lum(v); 3] } else { v }
|
||||
if gray { [lum(value); 3] } else { value }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn generator(&mut self, g: &Generator) -> f32 {
|
||||
let c = self.coords();
|
||||
let s = match g.kind {
|
||||
GeneratorKind::EdgeWear => (self.baked(BakedMap::Curvature).unwrap_or(0.5) - 0.5) * 2.0,
|
||||
GeneratorKind::Curvature => self.baked(BakedMap::Curvature).unwrap_or(0.5),
|
||||
GeneratorKind::Dirt => 1.0 - self.baked(BakedMap::AmbientOcclusion).unwrap_or(1.0),
|
||||
GeneratorKind::AmbientOcclusion => self.baked(BakedMap::AmbientOcclusion).unwrap_or(1.0),
|
||||
GeneratorKind::ThinAreas => 1.0 - self.baked(BakedMap::Thickness).unwrap_or(1.0),
|
||||
GeneratorKind::Position => c.pos.dot(Vec3::from(g.direction).try_normalize().unwrap_or(Vec3::Y)) * 0.5 + 0.5,
|
||||
GeneratorKind::Direction => c.nrm.dot(Vec3::from(g.direction).try_normalize().unwrap_or(Vec3::Y)) * 0.5 + 0.5,
|
||||
fn generator(&mut self, generator: &Generator, curvature_sizes: Option<&CurvatureSizes>) -> f32 {
|
||||
let coords = self.coords();
|
||||
let signal = match (generator.kind, &generator.detail) {
|
||||
(GeneratorKind::Curvature | GeneratorKind::EdgeWear, Some(detail)) => self.curvature_detail(detail, curvature_sizes),
|
||||
(GeneratorKind::EdgeWear, None) => (self.baked(BakedMap::Curvature).unwrap_or(0.5) - 0.5) * 2.0,
|
||||
(GeneratorKind::Curvature, None) => self.baked(BakedMap::Curvature).unwrap_or(0.5),
|
||||
(GeneratorKind::Dirt, _) => 1.0 - self.baked(BakedMap::AmbientOcclusion).unwrap_or(1.0),
|
||||
(GeneratorKind::AmbientOcclusion, _) => self.baked(BakedMap::AmbientOcclusion).unwrap_or(1.0),
|
||||
(GeneratorKind::ThinAreas, _) => 1.0 - self.baked(BakedMap::Thickness).unwrap_or(1.0),
|
||||
(GeneratorKind::Position, _) => coords.pos.dot(Vec3::from(generator.direction).try_normalize().unwrap_or(Vec3::Y)) * 0.5 + 0.5,
|
||||
(GeneratorKind::Direction, _) => coords.nrm.dot(Vec3::from(generator.direction).try_normalize().unwrap_or(Vec3::Y)) * 0.5 + 0.5,
|
||||
};
|
||||
let s = if g.noise_amount > 0.0 { s + (world_noise(c.pos, g.noise_scale, g.seed) - 0.5) * g.noise_amount } else { s };
|
||||
let th = 1.0 - g.level.clamp(0.0, 1.0);
|
||||
let soft = g.softness.max(1e-3);
|
||||
let t = ((s - (th - soft)) / (2.0 * soft)).clamp(0.0, 1.0);
|
||||
let v = t * t * (3.0 - 2.0 * t);
|
||||
if g.invert { 1.0 - v } else { v }
|
||||
let signal = if generator.noise_amount > 0.0 {
|
||||
let noise = world_noise(coords.pos, generator.noise_scale, generator.seed);
|
||||
if let (GeneratorKind::Curvature | GeneratorKind::EdgeWear, Some(detail)) = (generator.kind, &generator.detail) {
|
||||
// Break up curvature without inventing edges or cavities on a flat surface
|
||||
let neutral = if detail.mode == CurvatureMode::Raw { 0.5 } else { 0.0 };
|
||||
neutral + (signal - neutral) * (1.0 - noise * generator.noise_amount).max(0.0)
|
||||
} else {
|
||||
signal + (noise - 0.5) * generator.noise_amount
|
||||
}
|
||||
} else {
|
||||
signal
|
||||
};
|
||||
|
||||
// A smooth step from black to white over 2 × softness around 1 − level
|
||||
let threshold = 1.0 - generator.level.clamp(0.0, 1.0);
|
||||
let softness = generator.softness.max(1e-3);
|
||||
let ramp = ((signal - (threshold - softness)) / (2.0 * softness)).clamp(0.0, 1.0);
|
||||
let value = ramp * ramp * (3.0 - 2.0 * ramp);
|
||||
if generator.invert { 1.0 - value } else { value }
|
||||
}
|
||||
|
||||
fn mask(&mut self, m: &MaskPlan) -> f32 {
|
||||
let mut v = m.background;
|
||||
let mut skip = 0;
|
||||
if let Some((k, field)) = m.start
|
||||
&& let Some(f) = field.get(self.x, self.y).and_then(|d| d.first().copied())
|
||||
{
|
||||
v = f;
|
||||
skip = k + 1;
|
||||
/// The curvature of `detail`'s mode at this texel: each detail size's edges and cavities, weighted and combined like a screen blend.
|
||||
fn curvature_detail(&self, detail: &CurvatureDetail, curvature_sizes: Option<&CurvatureSizes>) -> f32 {
|
||||
let combine = |edges: f32, cavities: f32| match detail.mode {
|
||||
CurvatureMode::Edges => edges,
|
||||
CurvatureMode::Cavities => cavities,
|
||||
CurvatureMode::Both => 1.0 - (1.0 - edges) * (1.0 - cavities),
|
||||
CurvatureMode::Raw => 0.5 + 0.5 * (edges - cavities),
|
||||
};
|
||||
|
||||
// Without curvature to read the texel is flat: no edges or cavities
|
||||
let Some(curvature) = self.baked(BakedMap::Curvature) else { return combine(0.0, 0.0) };
|
||||
|
||||
let working_size = (self.res, self.inp.gbuf.height);
|
||||
let texel_uv = [(self.x as f32 + 0.5) / working_size.0.max(1) as f32, (self.y as f32 + 0.5) / working_size.1.max(1) as f32];
|
||||
let Some(baked_uv) = self.inp.block_scales.bake_uv(texel_uv, working_size) else { return combine(0.0, 0.0) };
|
||||
|
||||
let baked_size = (self.inp.baked.resolution, self.inp.baked.height(BakedMap::Curvature));
|
||||
let (baked_x, baked_y) = ((baked_uv[0] * baked_size.0 as f32) as u32, (baked_uv[1] * baked_size.1 as f32) as u32);
|
||||
let blurred = |index: usize| {
|
||||
curvature_sizes.and_then(|sizes| sizes.levels.get(index)).and_then(Option::as_deref).map_or(0.0, |level| level.sample(baked_x, baked_y))
|
||||
};
|
||||
let (mut edges, mut cavities) = (0.0f32, 0.0f32);
|
||||
for (index, (size, weight)) in CurvatureDetail::SIZES.iter().zip(detail.weights).enumerate() {
|
||||
let deviation = if index == 0 { curvature - 0.5 } else { blurred(index - 1) };
|
||||
|
||||
let response = deviation * if *size == 0.0 { MAP_GAIN } else { GAIN_PER_DETAIL_TEXEL * size };
|
||||
let weight = weight.clamp(0.0, 1.0);
|
||||
edges = 1.0 - (1.0 - edges) * (1.0 - weight * response.clamp(0.0, 1.0));
|
||||
cavities = 1.0 - (1.0 - cavities) * (1.0 - weight * (-response).clamp(0.0, 1.0));
|
||||
}
|
||||
for e in m.effects.iter().skip(skip) {
|
||||
let o = e.opacity.clamp(0.0, 1.0);
|
||||
match e.kind {
|
||||
|
||||
combine(edges, cavities)
|
||||
}
|
||||
|
||||
fn mask(&mut self, plan: &MaskPlan) -> f32 {
|
||||
let mut value = plan.background;
|
||||
let mut skip = 0;
|
||||
if let Some((filtered_index, field)) = plan.start
|
||||
&& let Some(filtered) = field.get(self.x, self.y).and_then(|texel| texel.first().copied())
|
||||
{
|
||||
value = filtered;
|
||||
skip = filtered_index + 1;
|
||||
}
|
||||
|
||||
for effect in plan.effects.iter().skip(skip) {
|
||||
let opacity = effect.opacity.clamp(0.0, 1.0);
|
||||
match effect.kind {
|
||||
EffectKind::Paint | EffectKind::Path(_) => {
|
||||
let (mut pv, mut cov) = match e.data.as_deref() {
|
||||
Some(d) => (from_u16(d.get(self.o * 2).copied().unwrap_or(0)), from_u16(d.get(self.o * 2 + 1).copied().unwrap_or(0))),
|
||||
let (mut painted, mut cov) = match effect.data.as_deref() {
|
||||
Some(data) => (from_u16(data.get(self.o * 2).copied().unwrap_or(0)), from_u16(data.get(self.o * 2 + 1).copied().unwrap_or(0))),
|
||||
None => (0.0, 0.0),
|
||||
};
|
||||
if e.preview
|
||||
&& let Some(p) = self.inp.preview
|
||||
if effect.preview
|
||||
&& let Some(preview) = self.inp.preview
|
||||
{
|
||||
let a = (self.stroke * p.opacity).clamp(0.0, 1.0);
|
||||
if p.erase {
|
||||
pv *= 1.0 - a;
|
||||
cov *= 1.0 - a;
|
||||
let stroke = (self.stroke * preview.opacity).clamp(0.0, 1.0);
|
||||
if preview.erase {
|
||||
painted *= 1.0 - stroke;
|
||||
cov *= 1.0 - stroke;
|
||||
} else {
|
||||
pv = p.mask_value * a + pv * (1.0 - a);
|
||||
cov = a + cov * (1.0 - a);
|
||||
painted = preview.mask_value * stroke + painted * (1.0 - stroke);
|
||||
cov = stroke + cov * (1.0 - stroke);
|
||||
}
|
||||
}
|
||||
if cov > 0.0 {
|
||||
let val = pv / cov.max(1e-5);
|
||||
v += (blend1(e.blend, v, val) - v) * cov * o;
|
||||
let layer_value = painted / cov.max(1e-5);
|
||||
value += (blend1(effect.blend, value, layer_value) - value) * cov * opacity;
|
||||
}
|
||||
}
|
||||
EffectKind::Fill { source, projection } => {
|
||||
let val = self.source(source, projection, ChannelKind::Scalar)[0];
|
||||
v += (blend1(e.blend, v, val) - v) * o * self.cover(std::iter::once(source), projection);
|
||||
let fill = self.source(source, projection, ChannelKind::Scalar)[0];
|
||||
value += (blend1(effect.blend, value, fill) - value) * opacity * self.cover(std::iter::once(source), projection);
|
||||
}
|
||||
EffectKind::Generator(g) => {
|
||||
let val = self.generator(g);
|
||||
v += (blend1(e.blend, v, val) - v) * o;
|
||||
EffectKind::Generator(generator) => {
|
||||
let generated = self.generator(generator, effect.curvature_sizes.as_deref());
|
||||
value += (blend1(effect.blend, value, generated) - value) * opacity;
|
||||
}
|
||||
EffectKind::Levels(l) => v += (l.apply(v) - v) * o,
|
||||
EffectKind::Filter(f) => {
|
||||
// A mask is gray (HSL only changes its lightness); neighbourhood filters come
|
||||
// precomputed through `MaskPlan::start`.
|
||||
let val = f.point(ChannelKind::Scalar, [v; 3]).map_or(v, |x| x[0]);
|
||||
v += (val - v) * o;
|
||||
EffectKind::Levels(levels) => value += (levels.apply(value) - value) * opacity,
|
||||
EffectKind::Filter(filter) => {
|
||||
// A mask is gray (HSL only changes its lightness); neighbourhood filters come precomputed through `MaskPlan::start`
|
||||
let filtered = filter.point(ChannelKind::Scalar, [value; 3]).map_or(value, |gray| gray[0]);
|
||||
value += (filtered - value) * opacity;
|
||||
}
|
||||
EffectKind::ColorSelection { colors, tolerance } => {
|
||||
let id = self.baked_color(BakedMap::Id);
|
||||
let hit = id.is_some_and(|c| colors.iter().any(|k| (k[0] - c[0]).abs().max((k[1] - c[1]).abs()).max((k[2] - c[2]).abs()) <= *tolerance));
|
||||
let val = if hit { 1.0 } else { 0.0 };
|
||||
v += (blend1(e.blend, v, val) - v) * o;
|
||||
let within = |picked: &[f32; 3], color: [f32; 3]| (0..3).all(|component| (picked[component] - color[component]).abs() <= *tolerance);
|
||||
let selected = if id.is_some_and(|color| colors.iter().any(|picked| within(picked, color))) { 1.0 } else { 0.0 };
|
||||
value += (blend1(effect.blend, value, selected) - value) * opacity;
|
||||
}
|
||||
EffectKind::Compare { op, value, tolerance } => {
|
||||
EffectKind::Compare { op, value: compared, tolerance } => {
|
||||
let pass = match op {
|
||||
CompareOp::LesserThan => v < *value,
|
||||
CompareOp::GreaterThan => v > *value,
|
||||
CompareOp::WithinTolerance => (v - value).abs() <= *tolerance,
|
||||
CompareOp::LesserThan => value < *compared,
|
||||
CompareOp::GreaterThan => value > *compared,
|
||||
CompareOp::WithinTolerance => (value - compared).abs() <= *tolerance,
|
||||
};
|
||||
let val = if pass { 1.0 } else { 0.0 };
|
||||
v += (val - v) * o;
|
||||
let result = if pass { 1.0 } else { 0.0 };
|
||||
value += (result - value) * opacity;
|
||||
}
|
||||
// Content-only effects.
|
||||
// Content-only effects
|
||||
EffectKind::Material(_) | EffectKind::Anchor => {}
|
||||
}
|
||||
}
|
||||
v.clamp(0.0, 1.0)
|
||||
value.clamp(0.0, 1.0)
|
||||
}
|
||||
|
||||
/// Composite `nodes` over `acc`, recording anchors. Returns true when it reached the `stop`
|
||||
@@ -1898,6 +1996,10 @@ pub fn mask_image(inputs: &Inputs, id: LayerId, size: u32) -> Option<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 +2053,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 +2209,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 +2568,80 @@ mod tests {
|
||||
assert!(blurred_then_warped.iter().zip(&warped).any(|(chained, single)| (chained - single).abs() > 0.1), "the blur under the warp still runs");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn larger_curvature_detail_sizes_reach_further_from_an_edge() {
|
||||
let mut fixture = fixture();
|
||||
fixture.gbuf = UvGBuffer::new(&fixture.mesh, 0, 256, 256);
|
||||
fixture.project.texture_sets[0].resolution = 256;
|
||||
let ridge: Vec<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();
|
||||
|
||||
@@ -0,0 +1,30 @@
|
||||
//! Isolated folder evaluation with the original stack available for anchor inputs.
|
||||
|
||||
use super::{Channel, ChannelKind, Composite, Inputs, LayerId, Texel, all_tiles, neighbourhood_fields, plan, tile_texels, to_u16, to_u16_signed};
|
||||
|
||||
/// Composite one layer over channel defaults, keeping anchors from the stack below it.
|
||||
pub(crate) fn composite_layer(inputs: &Inputs, layer: LayerId, channel: Channel) -> Option<Composite> {
|
||||
let set = inputs.project.texture_set(inputs.ts).ok()?;
|
||||
let channels = set.channel_list();
|
||||
let (width, height) = (inputs.gbuf.width, inputs.gbuf.height);
|
||||
let tiles = all_tiles(width, height);
|
||||
let fields = neighbourhood_fields(inputs, &channels, &tiles);
|
||||
let mut composite = Composite::with_size(&[channel], width, height);
|
||||
let output = composite.channels.get_mut(&channel)?;
|
||||
|
||||
for (tile_x, tile_y) in tiles {
|
||||
let nodes = plan(inputs, &[layer], &channels, tile_x, tile_y, 0, Some(&fields));
|
||||
let full_stack = if set.stack.as_slice() == [layer] { Vec::new() } else { plan(inputs, &set.stack, &channels, tile_x, tile_y, 0, Some(&fields)) };
|
||||
for (x, y, offset) in tile_texels(inputs.gbuf, tile_x, tile_y) {
|
||||
let mut texel = Texel::new(inputs, x, y, offset, 0.0);
|
||||
texel.anchors_below(&full_stack, layer);
|
||||
let mut values = Channel::ALL.map(Channel::default_value);
|
||||
texel.eval(&nodes, &mut values);
|
||||
let value = values.get(channel.index()).copied().unwrap_or_else(|| channel.default_value());
|
||||
let encoded = value.map(|component| if channel.kind() == ChannelKind::Signed { to_u16_signed(component) } else { to_u16(component) });
|
||||
output.set(x, y, &encoded[..channel.components()]);
|
||||
}
|
||||
}
|
||||
|
||||
Some(composite)
|
||||
}
|
||||
@@ -9,10 +9,13 @@
|
||||
|
||||
mod baked_maps;
|
||||
pub mod below;
|
||||
mod curvature_size_level;
|
||||
pub mod curvature_sizes;
|
||||
pub mod display;
|
||||
pub mod eval;
|
||||
pub mod pattern;
|
||||
pub mod store;
|
||||
pub mod thumb;
|
||||
|
||||
pub use below::{BelowCache, StackKey};
|
||||
pub use display::{DisplayKind, tile_bytes};
|
||||
@@ -21,3 +24,4 @@ pub use eval::{
|
||||
mask_at, mask_image, pad_tiles,
|
||||
};
|
||||
pub use store::{BakedMaps, ImageRes, ImageStore, PixelStore};
|
||||
pub use thumb::{THUMB_TEXELS, ThumbImage, ThumbTarget};
|
||||
@@ -0,0 +1,206 @@
|
||||
//! Small previews of one layer's content, one mask, or one effect stage, computed without
|
||||
//! touching the main composite.
|
||||
//!
|
||||
//! Every thumbnail is the ordinary compositor run on a *cut* copy of the project: only the
|
||||
//! requested layer is drawn, forced visible at Normal / 100 %, and
|
||||
//! the layer's effect list is truncated after the effect being previewed. The evaluator is the
|
||||
//! same code the viewport uses (just on a small G-buffer), so a thumbnail always agrees with
|
||||
//! what the stack really computes. Nothing here mutates the caller's project.
|
||||
|
||||
use texturecraft_core::{BlendMode, Channel, ChannelBlend, ChannelKind, LayerId, Project};
|
||||
use texturecraft_texel::{TILE, from_u16, from_u16_signed, linear_to_srgb};
|
||||
|
||||
use crate::eval::{Composite, FlatTile, Inputs, all_tiles, flatten_layer, mask_image};
|
||||
|
||||
/// Edge length (texels) the thumbnails are computed at.
|
||||
pub const THUMB_TEXELS: u32 = 64;
|
||||
|
||||
/// What a thumbnail shows.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
||||
pub enum ThumbTarget {
|
||||
/// The content of a layer (content effects included, mask ignored) in `channel`.
|
||||
Content { layer: LayerId, channel: Channel },
|
||||
/// The mask of a layer (an instance without its own mask shows its source's).
|
||||
Mask { layer: LayerId },
|
||||
/// The result up to and including `effect`, in the layer's content (`channel`) or in its
|
||||
/// mask (the channel is ignored). An effect that is hidden shows the bypassed result.
|
||||
Stage { effect: LayerId, channel: Channel },
|
||||
}
|
||||
|
||||
/// An 8-bit RGBA thumbnail (straight alpha). Alpha is 0 where the mesh does not cover the
|
||||
/// texture and, for a paint or fill layer's content, where the layer has nothing; the view
|
||||
/// paints its own background there.
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub struct ThumbImage {
|
||||
pub width: u32,
|
||||
pub height: u32,
|
||||
pub rgba: Vec<u8>,
|
||||
}
|
||||
|
||||
/// The thumbnail of `target`, computed at `inp.gbuf`'s size, which must be square (use a
|
||||
/// [`THUMB_TEXELS`] G-buffer; None otherwise). None for an unknown layer or effect, a layer without that channel, or a
|
||||
/// mask that does not exist.
|
||||
pub fn render(inp: &Inputs, target: ThumbTarget) -> Option<ThumbImage> {
|
||||
if inp.gbuf.width != inp.gbuf.height {
|
||||
return None;
|
||||
}
|
||||
match target {
|
||||
ThumbTarget::Content { layer, channel } => content(inp, layer, channel, None),
|
||||
ThumbTarget::Mask { layer } => mask(inp, layer, None),
|
||||
ThumbTarget::Stage { effect, channel } => {
|
||||
let (owner, _) = inp.project.effect(effect)?;
|
||||
let in_mask = inp.project.layers.get(&owner)?.mask.as_ref().is_some_and(|m| m.effects.iter().any(|e| e.id == effect));
|
||||
if in_mask { mask(inp, owner, Some(effect)) } else { content(inp, owner, channel, Some(effect)) }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Force the requested layer visible, retaining the stack needed by anchor readers.
|
||||
fn solo(project: &Project, texture_set: usize, id: LayerId, channel: Option<Channel>) -> Option<Project> {
|
||||
let mut cut = project.clone();
|
||||
|
||||
// Ordinary previews need no neighbouring layers or their filter allocations
|
||||
if !project.render_tree(&[id]).iter().any(|layer| crate::eval::reads_anchor(project, *layer)) {
|
||||
cut.texture_sets.get_mut(texture_set)?.stack = vec![id];
|
||||
}
|
||||
|
||||
cut.layers.get_mut(&id)?.visible = true;
|
||||
if let Some(channel) = channel {
|
||||
// Instances inherit channels from their source
|
||||
let owner = cut.content_layer(id)?.id;
|
||||
*cut.layers.get_mut(&owner)?.channels.get_mut(&channel)? = ChannelBlend { mode: BlendMode::Normal, opacity: 1.0 };
|
||||
}
|
||||
|
||||
Some(cut)
|
||||
}
|
||||
|
||||
/// Keep the effects of `list` up to and including `last`.
|
||||
fn truncate_after(list: &mut Vec<texturecraft_core::Effect>, last: LayerId) -> bool {
|
||||
match list.iter().position(|e| e.id == last) {
|
||||
Some(k) => {
|
||||
list.truncate(k + 1);
|
||||
true
|
||||
}
|
||||
None => false,
|
||||
}
|
||||
}
|
||||
|
||||
fn content(inputs: &Inputs, layer: LayerId, channel: Channel, through_effect: Option<LayerId>) -> Option<ThumbImage> {
|
||||
let set = inputs.project.texture_set(inputs.ts).ok()?;
|
||||
if !set.channel_list().contains(&channel) {
|
||||
return None;
|
||||
}
|
||||
|
||||
// An instance draws its source's effects
|
||||
let mut cut = solo(inputs.project, inputs.ts, layer, Some(channel))?;
|
||||
let owner = cut.content_layer(layer)?.id;
|
||||
for id in [layer, owner] {
|
||||
let content = cut.layers.get_mut(&id)?;
|
||||
content.mask = None;
|
||||
content.visible = true;
|
||||
}
|
||||
|
||||
if let Some(effect) = through_effect
|
||||
&& !truncate_after(&mut cut.layers.get_mut(&owner)?.content_effects, effect)
|
||||
{
|
||||
return None;
|
||||
}
|
||||
|
||||
let cut_inputs = Inputs { project: &cut, preview: None, block_scales: inputs.block_scales.clone(), ..*inputs };
|
||||
let (width, height) = (inputs.gbuf.width, inputs.gbuf.height);
|
||||
|
||||
// Paint and fill previews retain coverage; folders composite over channel defaults
|
||||
if !cut.layers.get(&owner)?.is_group() {
|
||||
let flat = flatten_layer(&cut_inputs, layer, &all_tiles(width, height))?;
|
||||
return Some(encode_flat(&flat, channel, width, height));
|
||||
}
|
||||
|
||||
let comp = crate::eval::thumbnail::composite_layer(&cut_inputs, layer, channel)?;
|
||||
Some(encode_channel(&comp, channel, inputs))
|
||||
}
|
||||
|
||||
/// Encode the flattened (premultiplied value, coverage) tiles of `channel`: alpha is coverage.
|
||||
fn encode_flat(flat: &[FlatTile], channel: Channel, w: u32, h: u32) -> ThumbImage {
|
||||
let mut rgba = vec![0u8; (w * h) as usize * 4];
|
||||
let comps = channel.components();
|
||||
let signed = channel.kind() == ChannelKind::Signed;
|
||||
for (c, (tx, ty), buf) in flat {
|
||||
if *c != channel {
|
||||
continue;
|
||||
}
|
||||
for (o, px) in buf.chunks_exact(comps + 1).enumerate() {
|
||||
let (x, y) = (tx * TILE + o as u32 % TILE, ty * TILE + o as u32 / TILE);
|
||||
let a = px.get(comps).map_or(0.0, |v| from_u16(*v));
|
||||
if x >= w || y >= h || a <= 0.0 {
|
||||
continue;
|
||||
}
|
||||
let mut v = [0.0f32; 3];
|
||||
for (k, slot) in v.iter_mut().enumerate() {
|
||||
let raw = px.get(k.min(comps - 1)).copied().unwrap_or(0);
|
||||
*slot = if signed { from_u16_signed(raw) } else { from_u16(raw) } / a;
|
||||
}
|
||||
let p = display(channel, v);
|
||||
let i = ((y * w + x) * 4) as usize;
|
||||
if let Some(d) = rgba.get_mut(i..i + 4) {
|
||||
d.copy_from_slice(&[p[0], p[1], p[2], to_byte(a)]);
|
||||
}
|
||||
}
|
||||
}
|
||||
ThumbImage { width: w, height: h, rgba }
|
||||
}
|
||||
|
||||
/// A channel value as display bytes: colors linear → sRGB, signed values with 0 at mid gray,
|
||||
/// normal maps and scalars as stored.
|
||||
fn display(channel: Channel, v: [f32; 3]) -> [u8; 3] {
|
||||
match channel.kind() {
|
||||
ChannelKind::Color => v.map(|c| to_byte(linear_to_srgb(c.clamp(0.0, 1.0)))),
|
||||
ChannelKind::Signed => v.map(|c| to_byte(c * 0.5 + 0.5)),
|
||||
ChannelKind::Scalar | ChannelKind::NormalMap => v.map(to_byte),
|
||||
}
|
||||
}
|
||||
|
||||
fn mask(inputs: &Inputs, layer: LayerId, through_effect: Option<LayerId>) -> Option<ThumbImage> {
|
||||
let mut cut = solo(inputs.project, inputs.ts, layer, None)?;
|
||||
let owner = cut.mask_owner(layer);
|
||||
let mask = cut.layers.get_mut(&owner)?.mask.as_mut()?;
|
||||
mask.enabled = true;
|
||||
if let Some(effect) = through_effect
|
||||
&& !truncate_after(&mut mask.effects, effect)
|
||||
{
|
||||
return None;
|
||||
}
|
||||
|
||||
let cut_inputs = Inputs { project: &cut, preview: None, block_scales: inputs.block_scales.clone(), ..*inputs };
|
||||
let (width, height) = (inputs.gbuf.width, inputs.gbuf.height);
|
||||
let gray = mask_image(&cut_inputs, layer, width)?;
|
||||
let mut rgba = Vec::with_capacity((width * height) as usize * 4);
|
||||
for y in 0..height {
|
||||
for x in 0..width {
|
||||
let offset = (y * width + x) as usize;
|
||||
let value = gray.get(offset).copied().unwrap_or(0);
|
||||
rgba.extend_from_slice(&[value, value, value, if inputs.gbuf.covered(offset) { 255 } else { 0 }]);
|
||||
}
|
||||
}
|
||||
|
||||
Some(ThumbImage { width, height, rgba })
|
||||
}
|
||||
|
||||
/// Encode the composited `channel` for display: colors linear → sRGB, signed values 0 → mid
|
||||
/// gray, normal maps and scalars as stored (data channels raw).
|
||||
fn encode_channel(comp: &Composite, channel: Channel, inp: &Inputs) -> ThumbImage {
|
||||
let (w, h) = (comp.resolution, comp.height);
|
||||
let mut rgba = Vec::with_capacity((w * h) as usize * 4);
|
||||
for y in 0..h {
|
||||
for x in 0..w {
|
||||
let v = comp.value(channel, x, y);
|
||||
let px = display(channel, v);
|
||||
let covered = inp.gbuf.covered((y * w + x) as usize);
|
||||
rgba.extend_from_slice(&[px[0], px[1], px[2], if covered { 255 } else { 0 }]);
|
||||
}
|
||||
}
|
||||
ThumbImage { width: w, height: h, rgba }
|
||||
}
|
||||
|
||||
fn to_byte(v: f32) -> u8 {
|
||||
if v.is_finite() { (v.clamp(0.0, 1.0) * 255.0 + 0.5) as u8 } else { 0 }
|
||||
}
|
||||
@@ -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());
|
||||
|
||||
+171
-78
@@ -2,12 +2,12 @@
|
||||
//! (a decal fill with a planar projection), as a fill layer with a decal projection.
|
||||
|
||||
use serde_json::{Value, json};
|
||||
use texturecraft_core::{Channel, Decal, Fill, Layer, LayerId, LayerKind, Projection, Source};
|
||||
use texturecraft_core::{Channel, Decal, Effect, EffectKind, Fill, Layer, LayerId, LayerKind, Mask, MaskBackground, Projection, Source};
|
||||
use texturecraft_geom::glam::{Vec2, Vec3};
|
||||
|
||||
use crate::commands::{CommandSpec, always, bad, f32p, has_layer, layer_param, strp};
|
||||
use crate::commands::{CommandSpec, always, bad, channel_param, f32p, has_layer, layer_param, strp, u64p};
|
||||
use crate::tool_cmds::viewport_of;
|
||||
use crate::{Result, Session, cmd};
|
||||
use crate::{Result, Session, StackTarget, cmd};
|
||||
|
||||
pub fn specs() -> Vec<CommandSpec> {
|
||||
vec![
|
||||
@@ -16,7 +16,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
"Add decal",
|
||||
[],
|
||||
None,
|
||||
"{image: resource name, x?, y?: viewport pixels (default: the view center), viewport?: [w,h] | position?: [x,y,z], normal?: [x,y,z], up?: [x,y,z] (the image's up; default the view's up, or the view direction when that is along the normal), size?: height | [w,h] (world units; default a quarter of the mesh), rotation?: degrees, depth?, name?} — a fill layer projecting the image from a frame placed on the surface; seen from the front, the image reads the right way round",
|
||||
"{image: resource name, channel?: a channel id (default baseColor) | \"mask\" (a new fill layer masked by the image's gray), x?, y?: viewport pixels (default: the view center; a point on another texture set selects it), viewport?: [w,h] | position?: [x,y,z], normal?: [x,y,z] (on the selected texture set), up?: [x,y,z] (the image's up; default the view's up, or the view direction when that is along the normal), size?: height | [w,h] (world units; default a quarter of the mesh), rotation?: degrees, depth?, name?} → {layer, decal, maskEffect: the mask fill effect holding the image with channel \"mask\", else null} — a fill layer projecting the image from a frame placed on the surface; seen from the front, the image reads the right way round",
|
||||
always,
|
||||
add
|
||||
),
|
||||
@@ -25,7 +25,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
"Edit decal",
|
||||
[],
|
||||
None,
|
||||
"{layer?, x?, y?, viewport? | position?, normal? (re-place it), up?: [x,y,z], size?: height | [w,h], rotation?: degrees, offset?: [right, up] (world units from where it was placed), depth?, image?, merge?: true continues the previous Edit decal undo step (drags)}",
|
||||
"{layer? | effect?: a mask fill effect id (a decal placed as a mask; with `layer`, it must be in that layer), x?, y?, viewport? | position?, normal? (re-place it on its own texture set), up?: [x,y,z], size?: height | [w,h], rotation?: degrees, offset?: [right, up] (world units from where it was placed), depth?, image?: replaces the image in the channel or mask it was placed in, merge?: true continues the previous Edit decal undo step (drags)}",
|
||||
has_layer,
|
||||
set
|
||||
),
|
||||
@@ -42,43 +42,51 @@ fn vec3(p: &Value, key: &str) -> Option<Vec3> {
|
||||
}
|
||||
}
|
||||
|
||||
/// Where a decal goes: a surface point and its normal, from `x`/`y` (viewport pixels, the view
|
||||
/// center by default) or `position` + `normal`. None when `optional` and neither is given.
|
||||
fn placement(s: &Session, cmd: &str, p: &Value, optional: bool) -> Result<Option<(Vec3, Vec3)>> {
|
||||
if let Some(pos) = vec3(p, "position") {
|
||||
let n = vec3(p, "normal").and_then(Vec3::try_normalize).ok_or_else(|| bad(cmd, "`position` needs a non-zero `normal`"))?;
|
||||
return Ok(Some((pos, n)));
|
||||
/// Resolve a viewport hit or explicit world position, using `texture_set` for explicit positions.
|
||||
/// Returns None when placement is optional and no position or viewport point is given.
|
||||
fn placement(session: &Session, command: &str, params: &Value, texture_set: usize, optional: bool) -> Result<Option<(Vec3, Vec3, usize)>> {
|
||||
if let Some(position) = vec3(params, "position") {
|
||||
let normal = vec3(params, "normal").and_then(Vec3::try_normalize).ok_or_else(|| bad(command, "`position` needs a non-zero `normal`"))?;
|
||||
return Ok(Some((position, normal, texture_set)));
|
||||
}
|
||||
let vp = viewport_of(s, p);
|
||||
let at = match (f32p(p, "x"), f32p(p, "y")) {
|
||||
|
||||
let viewport = viewport_of(session, params);
|
||||
let point = match (f32p(params, "x"), f32p(params, "y")) {
|
||||
(Some(x), Some(y)) => Vec2::new(x, y),
|
||||
_ if optional => return Ok(None),
|
||||
_ => vp * 0.5,
|
||||
_ => viewport * 0.5,
|
||||
};
|
||||
let hit = s.pick(at, vp).ok_or_else(|| bad(cmd, "nothing under that point: place the decal on the mesh"))?;
|
||||
if s.doc.project.texture_set(s.ts()).ok().map(|t| t.material) != Some(hit.material) {
|
||||
return Err(bad(cmd, "that surface belongs to another texture set"));
|
||||
}
|
||||
Ok(Some((hit.pos, hit.nrm)))
|
||||
let hit = session.pick(point, viewport).ok_or_else(|| bad(command, "nothing under that point: place the decal on the mesh"))?;
|
||||
let hit_set = session.texture_set_of_material(hit.material).ok_or_else(|| bad(command, "that surface has no texture set"))?;
|
||||
Ok(Some((hit.pos, hit.nrm, hit_set)))
|
||||
}
|
||||
|
||||
/// A new decal's height, relative to the mesh diagonal
|
||||
const DEFAULT_HEIGHT: f32 = 0.25;
|
||||
|
||||
/// The smallest decal side or depth, relative to the mesh diagonal
|
||||
const MIN_SIZE: f32 = 1e-4;
|
||||
|
||||
/// The largest decal side or depth, relative to the mesh diagonal
|
||||
const MAX_SIZE: f32 = 10.0;
|
||||
|
||||
/// The mesh's diagonal (decal sizes are relative to it).
|
||||
fn mesh_size(s: &Session) -> f32 {
|
||||
let (lo, hi) = s.mesh.bounds();
|
||||
(hi - lo).length().max(1e-3)
|
||||
}
|
||||
|
||||
/// Width and height from a `size` param (a height keeping `aspect`, or `[w, h]`).
|
||||
fn size_param(p: &Value, aspect: f32, diag: f32) -> Option<[f32; 2]> {
|
||||
let v = p.get("size")?;
|
||||
let size = match v.as_array() {
|
||||
Some(a) => [a.first()?.as_f64()? as f32, a.get(1)?.as_f64()? as f32],
|
||||
/// Width and height from a `size` param (a height keeping `aspect`, or `[w, h]`), within the decal size limits
|
||||
fn size_param(p: &Value, aspect: f32, mesh_diagonal: f32) -> Option<[f32; 2]> {
|
||||
let value = p.get("size")?;
|
||||
let size = match value.as_array() {
|
||||
Some(pair) => [pair.first()?.as_f64()? as f32, pair.get(1)?.as_f64()? as f32],
|
||||
None => {
|
||||
let h = v.as_f64()? as f32;
|
||||
[h * aspect, h]
|
||||
let height = value.as_f64()? as f32;
|
||||
[height * aspect, height]
|
||||
}
|
||||
};
|
||||
size.iter().all(|x| x.is_finite()).then(|| size.map(|x| x.clamp(diag * 1e-4, diag * 10.0)))
|
||||
size.iter().all(|side| side.is_finite()).then(|| size.map(|side| side.clamp(mesh_diagonal * MIN_SIZE, mesh_diagonal * MAX_SIZE)))
|
||||
}
|
||||
|
||||
/// The decal's up direction: `up` when given, else the camera's (decals are placed upright on
|
||||
@@ -96,11 +104,25 @@ fn decal_up(s: &Session, cmd: &str, p: &Value, normal: Vec3) -> Result<Vec3> {
|
||||
fn add(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let cmd = "layer.add.decal";
|
||||
let image = strp(p, "image").ok_or_else(|| bad(cmd, "`image` is required"))?.to_string();
|
||||
let img = s.images.get(&image).ok_or_else(|| bad(cmd, format!("no image resource `{image}` (import it first)")))?;
|
||||
let aspect = img.width as f32 / img.height.max(1) as f32;
|
||||
let (center, normal) = placement(s, cmd, p, false)?.ok_or_else(|| bad(cmd, "no placement"))?;
|
||||
let diag = mesh_size(s);
|
||||
let size = size_param(p, aspect, diag).unwrap_or([diag * 0.25 * aspect, diag * 0.25]);
|
||||
let resource = s.images.get(&image).ok_or_else(|| bad(cmd, format!("no image resource `{image}` (import it first)")))?;
|
||||
let aspect = resource.width as f32 / resource.height.max(1) as f32;
|
||||
let (center, normal, ts) = placement(s, cmd, p, s.ts(), false)?.ok_or_else(|| bad(cmd, "no placement"))?;
|
||||
|
||||
// None: the image masks a new fill layer
|
||||
let target = match strp(p, "channel") {
|
||||
Some("mask") => None,
|
||||
_ => Some(channel_param(cmd, p, "channel")?.unwrap_or(Channel::BaseColor)),
|
||||
};
|
||||
let set_channels = s.doc.project.texture_set(ts)?.channel_list();
|
||||
if let Some(channel) = target
|
||||
&& !set_channels.contains(&channel)
|
||||
{
|
||||
return Err(bad(cmd, format!("the texture set has no {} channel", channel.label())));
|
||||
}
|
||||
|
||||
let mesh_diagonal = mesh_size(s);
|
||||
let default_height = mesh_diagonal * DEFAULT_HEIGHT;
|
||||
let size = size_param(p, aspect, mesh_diagonal).unwrap_or([default_height * aspect, default_height]);
|
||||
let decal = Decal {
|
||||
center: center.to_array(),
|
||||
normal: normal.to_array(),
|
||||
@@ -108,68 +130,139 @@ fn add(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
size,
|
||||
rotation: f32p(p, "rotation").unwrap_or(0.0).rem_euclid(360.0),
|
||||
offset: [0.0; 2],
|
||||
depth: f32p(p, "depth").map_or(size[0].max(size[1]) * 0.5, |d| d.clamp(diag * 1e-4, diag * 10.0)),
|
||||
// By default it reaches half its larger side into the surface
|
||||
depth: f32p(p, "depth").map_or(size[0].max(size[1]) * 0.5, |depth| depth.clamp(mesh_diagonal * MIN_SIZE, mesh_diagonal * MAX_SIZE)),
|
||||
};
|
||||
let ts = s.ts();
|
||||
let base =
|
||||
strp(p, "name").map(str::to_string).unwrap_or_else(|| std::path::Path::new(&image).file_stem().and_then(|n| n.to_str()).unwrap_or("Decal").to_string());
|
||||
|
||||
// A decal dropped on another texture set goes there and selects it, as a dropped material does
|
||||
if ts != s.ts() {
|
||||
crate::set_cmds::select_set(s, ts)?;
|
||||
}
|
||||
|
||||
let base = strp(p, "name")
|
||||
.map(str::to_string)
|
||||
.unwrap_or_else(|| std::path::Path::new(&image).file_stem().and_then(|stem| stem.to_str()).unwrap_or("Decal").to_string());
|
||||
let name = s.doc.project.next_layer_name(ts, &base);
|
||||
let id = s.edit("Add decal", |s| {
|
||||
let (id, mask_effect) = s.edit("Add decal", |s| {
|
||||
let id = s.doc.project.alloc_id();
|
||||
let Some(channel) = target else {
|
||||
let effect_id = s.doc.project.alloc_id();
|
||||
let mut layer = Layer::new(id, name, LayerKind::Fill(Fill::default()), &set_channels);
|
||||
let mut mask = Mask::new(MaskBackground::Black);
|
||||
mask.effects.push(Effect::new(effect_id, EffectKind::Fill { source: Source::image(image.clone()), projection: Projection::Decal(decal) }));
|
||||
layer.mask = Some(mask);
|
||||
crate::layer_cmds::insert_selected(s, layer)?;
|
||||
s.target = StackTarget::Effect(effect_id);
|
||||
return Ok((id, Some(effect_id)));
|
||||
};
|
||||
|
||||
let mut fill = Fill { projection: Projection::Decal(decal), ..Fill::default() };
|
||||
fill.sources.insert(Channel::BaseColor, Source::image(image.clone()));
|
||||
crate::layer_cmds::insert_selected(s, Layer::new(id, name, LayerKind::Fill(fill), &[Channel::BaseColor]))
|
||||
fill.sources.insert(channel, Source::image(image.clone()));
|
||||
crate::layer_cmds::insert_selected(s, Layer::new(id, name, LayerKind::Fill(fill), &[channel]))?;
|
||||
Ok((id, None))
|
||||
})?;
|
||||
Ok(json!({ "layer": id.0, "decal": decal }))
|
||||
Ok(json!({ "layer": id.0, "decal": decal, "maskEffect": mask_effect.map(|effect| effect.0) }))
|
||||
}
|
||||
|
||||
/// The decal of fill layer `id`.
|
||||
fn decal_of(s: &Session, cmd: &str, id: LayerId) -> Result<Decal> {
|
||||
/// The decal of fill layer `id`, or of mask fill effect `effect` when given
|
||||
fn decal_of(s: &Session, cmd: &str, id: LayerId, effect: Option<LayerId>) -> Result<Decal> {
|
||||
if let Some(effect) = effect {
|
||||
return match s.doc.project.effect(effect).map(|(_, effect)| &effect.kind) {
|
||||
Some(EffectKind::Fill { projection: Projection::Decal(decal), .. }) => Ok(*decal),
|
||||
_ => Err(bad(cmd, "the effect is not a decal (layer.add.decal with channel mask)")),
|
||||
};
|
||||
}
|
||||
|
||||
match &s.doc.project.layer(id)?.kind {
|
||||
LayerKind::Fill(Fill { projection: Projection::Decal(d), .. }) => Ok(*d),
|
||||
LayerKind::Fill(Fill { projection: Projection::Decal(decal), .. }) => Ok(*decal),
|
||||
_ => Err(bad(cmd, "the layer is not a decal (layer.add.decal)")),
|
||||
}
|
||||
}
|
||||
|
||||
fn set(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let cmd = "layer.decal.set";
|
||||
let id = s.doc.project.content_layer(layer_param(s, cmd, p)?).map(|l| l.id).ok_or_else(|| bad(cmd, "no layer"))?;
|
||||
let mut d = decal_of(s, cmd, id)?;
|
||||
let diag = mesh_size(s);
|
||||
if let Some((center, normal)) = placement(s, cmd, p, true)? {
|
||||
(d.center, d.normal, d.offset) = (center.to_array(), normal.to_array(), [0.0; 2]);
|
||||
}
|
||||
if p.get("up").is_some() {
|
||||
d.up = decal_up(s, cmd, p, Vec3::from(d.normal))?.to_array();
|
||||
}
|
||||
if let Some(size) = size_param(p, d.size[0] / d.size[1].max(1e-6), diag) {
|
||||
d.size = size;
|
||||
}
|
||||
if let Some(r) = f32p(p, "rotation") {
|
||||
d.rotation = r.rem_euclid(360.0);
|
||||
}
|
||||
if let Some(o) = p.get("offset").and_then(Value::as_array) {
|
||||
let v: Vec<f32> = o.iter().filter_map(Value::as_f64).map(|x| x as f32).filter(|x| x.is_finite()).collect();
|
||||
let [x, y] = v.as_slice() else { return Err(bad(cmd, "`offset` must be [right, up]")) };
|
||||
d.offset = [x.clamp(-diag, diag), y.clamp(-diag, diag)];
|
||||
}
|
||||
if let Some(v) = f32p(p, "depth") {
|
||||
d.depth = v.clamp(diag * 1e-4, diag * 10.0);
|
||||
}
|
||||
let image = strp(p, "image").map(str::to_string);
|
||||
if let Some(name) = &image
|
||||
&& !s.doc.resources.contains_key(name)
|
||||
fn set(session: &mut Session, params: &Value) -> Result<Value> {
|
||||
let command = "layer.decal.set";
|
||||
let effect = u64p(params, "effect").map(LayerId);
|
||||
let layer_id = match effect {
|
||||
Some(effect) => session.doc.project.effect(effect).map(|(owner, _)| owner).ok_or_else(|| bad(command, format!("no effect {}", effect.0)))?,
|
||||
None => session.doc.project.content_layer(layer_param(session, command, params)?).map(|layer| layer.id).ok_or_else(|| bad(command, "no layer"))?,
|
||||
};
|
||||
if let (Some(effect), Some(layer)) = (effect, u64p(params, "layer"))
|
||||
&& layer != layer_id.0
|
||||
{
|
||||
return Err(bad(cmd, format!("no image resource `{name}`")));
|
||||
return Err(bad(command, format!("effect {} is not in layer {layer}", effect.0)));
|
||||
}
|
||||
s.edit("Edit decal", |s| {
|
||||
if let LayerKind::Fill(f) = &mut s.doc.project.layer_mut(id)?.kind {
|
||||
f.projection = Projection::Decal(d);
|
||||
if let Some(name) = image {
|
||||
f.sources.insert(Channel::BaseColor, Source::image(name));
|
||||
|
||||
let mut decal = decal_of(session, command, layer_id, effect)?;
|
||||
let texture_set =
|
||||
session.doc.project.locate(layer_id).map(|(texture_set, _, _)| texture_set).ok_or_else(|| bad(command, "the decal has no texture set"))?;
|
||||
let mesh_diagonal = mesh_size(session);
|
||||
if let Some((center, normal, hit_set)) = placement(session, command, params, texture_set, true)? {
|
||||
// Selecting another set must not let this decal leave its layer's stack
|
||||
if hit_set != texture_set {
|
||||
return Err(bad(command, "that surface belongs to another texture set"));
|
||||
}
|
||||
|
||||
(decal.center, decal.normal, decal.offset) = (center.to_array(), normal.to_array(), [0.0; 2]);
|
||||
}
|
||||
if params.get("up").is_some() {
|
||||
decal.up = decal_up(session, command, params, Vec3::from(decal.normal))?.to_array();
|
||||
}
|
||||
if let Some(size) = size_param(params, decal.size[0] / decal.size[1].max(1e-6), mesh_diagonal) {
|
||||
decal.size = size;
|
||||
}
|
||||
if let Some(rotation) = f32p(params, "rotation") {
|
||||
decal.rotation = rotation.rem_euclid(360.0);
|
||||
}
|
||||
if let Some(offset) = params.get("offset").and_then(Value::as_array) {
|
||||
let values: Vec<f32> = offset.iter().filter_map(Value::as_f64).map(|value| value as f32).filter(|value| value.is_finite()).collect();
|
||||
let [right, up] = values.as_slice() else { return Err(bad(command, "`offset` must be [right, up]")) };
|
||||
|
||||
decal.offset = [right.clamp(-mesh_diagonal, mesh_diagonal), up.clamp(-mesh_diagonal, mesh_diagonal)];
|
||||
}
|
||||
if let Some(depth) = f32p(params, "depth") {
|
||||
decal.depth = depth.clamp(mesh_diagonal * MIN_SIZE, mesh_diagonal * MAX_SIZE);
|
||||
}
|
||||
|
||||
let image = strp(params, "image").map(str::to_string);
|
||||
if let Some(name) = &image
|
||||
&& !session.doc.resources.contains_key(name)
|
||||
{
|
||||
return Err(bad(command, format!("no image resource `{name}`")));
|
||||
}
|
||||
|
||||
session.edit("Edit decal", |session| {
|
||||
if let Some(effect) = effect {
|
||||
if let Some(EffectKind::Fill { source, projection }) = session.doc.project.effect_mut(effect).map(|effect| &mut effect.kind) {
|
||||
*projection = Projection::Decal(decal);
|
||||
if let Some(image) = image {
|
||||
*source = Source::image(image);
|
||||
}
|
||||
}
|
||||
} else if let LayerKind::Fill(fill) = &mut session.doc.project.layer_mut(layer_id)?.kind {
|
||||
fill.projection = Projection::Decal(decal);
|
||||
|
||||
// The new image goes where the decal's image is (the channel it was placed in)
|
||||
let placed = fill.sources.values().find_map(|source| match source {
|
||||
Source::Image { name, .. } => Some(name.clone()),
|
||||
_ => None,
|
||||
});
|
||||
match (image, placed) {
|
||||
(Some(image), Some(placed)) => {
|
||||
for source in fill.sources.values_mut() {
|
||||
if let Source::Image { name, .. } = source
|
||||
&& *name == placed
|
||||
{
|
||||
name.clone_from(&image);
|
||||
}
|
||||
}
|
||||
}
|
||||
(Some(image), None) => {
|
||||
fill.sources.insert(Channel::BaseColor, Source::image(image));
|
||||
}
|
||||
(None, _) => {}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
})?;
|
||||
Ok(json!({ "layer": id.0, "decal": d }))
|
||||
Ok(json!({ "layer": layer_id.0, "decal": decal }))
|
||||
}
|
||||
@@ -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,16 +26,21 @@ pub mod layer_cmds;
|
||||
pub mod layer_ops;
|
||||
pub mod link_cmds;
|
||||
pub mod mask_cmds;
|
||||
pub mod mask_preview;
|
||||
mod mask_preview_camera;
|
||||
mod mask_preview_pixel;
|
||||
pub mod material_lib;
|
||||
mod material_preview_pixel;
|
||||
pub mod materials;
|
||||
pub mod materialx_cmds;
|
||||
pub mod meshmap_cmds;
|
||||
mod meshmap_file_name;
|
||||
pub mod meshmap_import_cmds;
|
||||
mod orb_camera;
|
||||
pub mod orb_preview;
|
||||
pub mod painting;
|
||||
mod path_draft;
|
||||
pub mod path_tool;
|
||||
mod polygon_fill;
|
||||
mod polygon_fill_drag;
|
||||
// Mesh reimport reads files: native only.
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
mod preserve;
|
||||
@@ -45,15 +54,21 @@ pub mod set_cmds;
|
||||
pub mod smart_masks;
|
||||
pub mod template_cmds;
|
||||
pub mod text_cmds;
|
||||
pub mod thumbs;
|
||||
pub mod tool_cmds;
|
||||
mod triangle_partition;
|
||||
mod uv_stroke_state;
|
||||
pub mod uv_tile_cmds;
|
||||
pub mod view_cmds;
|
||||
|
||||
pub use bake::{BakeMesh, BakeMeshes, BakeTask};
|
||||
pub use bake::{BakeMesh, BakeMeshes, BakeTask, StreamedBake, StreamedMap};
|
||||
pub use bake_preview::{BakePreview, PreviewShow};
|
||||
pub use commands::{CommandSpec, command_specs, execute, find};
|
||||
pub use fill_hit_test::FillHitTest;
|
||||
pub use fill_mode::FillMode;
|
||||
pub use path_tool::PathState;
|
||||
pub use project_cmds::sample_session;
|
||||
pub use session::{CloneFrom, CloneSource, Document, FillMode, Session, SetCache, StackTarget, StencilState, Tool, ToolState, ViewMode};
|
||||
pub use session::{CloneFrom, CloneSource, Document, Session, SetCache, StackTarget, StencilState, Tool, ToolState, ViewMode};
|
||||
pub use set_cmds::{ResizeOutput, ResizeTask};
|
||||
|
||||
pub use texturecraft_compose as compose;
|
||||
|
||||
+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");
|
||||
}
|
||||
}
|
||||
+241
-37
@@ -64,23 +64,23 @@ pub struct PathState {
|
||||
|
||||
impl PathState {
|
||||
/// Append a control point; a point placed in the other view starts a new path.
|
||||
pub fn push(&mut self, p: Vec3, uv: bool) {
|
||||
pub fn push(&mut self, point: Vec3, uv: bool) {
|
||||
if uv != self.uv {
|
||||
self.points.clear();
|
||||
self.uv = uv;
|
||||
}
|
||||
if self.points.len() < MAX_PATH_POINTS {
|
||||
self.points.push(p);
|
||||
self.points.push(point);
|
||||
}
|
||||
}
|
||||
|
||||
/// Insert a control point before point `at` (on the segment ending there) and select it; None when it can't
|
||||
pub fn insert(&mut self, at: usize, p: Vec3) -> Option<usize> {
|
||||
pub fn insert(&mut self, at: usize, point: Vec3) -> Option<usize> {
|
||||
if at > self.points.len() || self.points.len() >= MAX_PATH_POINTS {
|
||||
return None;
|
||||
}
|
||||
|
||||
self.points.insert(at, p);
|
||||
self.points.insert(at, point);
|
||||
self.selected = Some(at);
|
||||
self.selected
|
||||
}
|
||||
@@ -171,6 +171,7 @@ fn path(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
if s.tool.tool != Tool::Path {
|
||||
set_tool(s, Tool::Path)?;
|
||||
}
|
||||
|
||||
let viewport = viewport_of(s, p);
|
||||
if boolp(p, "clear") == Some(true) {
|
||||
s.cancel_path();
|
||||
@@ -192,6 +193,7 @@ fn path(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
if points.len() > MAX_PATH_POINTS {
|
||||
return Err(bad(CMD, format!("at most {MAX_PATH_POINTS} control points")));
|
||||
}
|
||||
|
||||
s.tool.path.points = points;
|
||||
s.tool.path.uv = uv;
|
||||
}
|
||||
@@ -208,7 +210,7 @@ fn path(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
s.update();
|
||||
report
|
||||
} else {
|
||||
if s.path_live()? {
|
||||
if s.path_live_in_view(viewport)? {
|
||||
s.update();
|
||||
}
|
||||
Value::Null
|
||||
@@ -327,6 +329,7 @@ impl Session {
|
||||
if path.uv {
|
||||
return path.points.iter().map(|p| Some(p.truncate())).collect();
|
||||
}
|
||||
|
||||
let aspect = viewport.x.max(1.0) / viewport.y.max(1.0);
|
||||
path.points.iter().map(|p| self.camera.project(*p, aspect).map(|n| to_pixels(n.truncate(), viewport))).collect()
|
||||
}
|
||||
@@ -360,28 +363,32 @@ impl Session {
|
||||
|
||||
/// Store the Path tool's curve (new, or the path being edited) and repaint its sublayer as one undo step, then clear the tool
|
||||
pub fn commit_path(&mut self, viewport: Vec2) -> Result<Value> {
|
||||
let shape = self.path_shape(self.camera, viewport);
|
||||
if let Some(draft) = self.path_draft.take() {
|
||||
match self.tool.path.editing {
|
||||
// The preview is what applying paints: keep its pixels
|
||||
Some((eid, index)) if self.paths(eid).and_then(|v| v.get(index)) == Some(&shape) => {
|
||||
if let Some((effect, index)) = self.tool.path.editing
|
||||
&& self.paths(effect).and_then(|paths| paths.get(index)).is_some_and(|stored| self.same_as_stored(stored))
|
||||
{
|
||||
// Camera navigation alone must not replace the pixels the user just previewed
|
||||
let mut report = match self.path_draft.take() {
|
||||
Some(draft) => {
|
||||
self.push_step(NEW_PATH_LABEL, draft.base, false);
|
||||
self.target = StackTarget::Effect(eid);
|
||||
self.tool.path.clear();
|
||||
let mut out = draft.painted;
|
||||
out["effect"] = json!(eid.0);
|
||||
out["index"] = json!(index);
|
||||
return Ok(out);
|
||||
draft.painted
|
||||
}
|
||||
// Otherwise it paints again from the document before the preview
|
||||
_ => {
|
||||
let preview = std::mem::replace(&mut self.doc, draft.base);
|
||||
self.changed_without_history(&preview);
|
||||
self.tool.path.editing = None;
|
||||
}
|
||||
}
|
||||
None => json!({}),
|
||||
};
|
||||
report["effect"] = json!(effect.0);
|
||||
report["index"] = json!(index);
|
||||
self.target = StackTarget::Effect(effect);
|
||||
self.cancel_path();
|
||||
return Ok(report);
|
||||
}
|
||||
|
||||
if let Some(draft) = self.path_draft.take() {
|
||||
// Changed settings paint again from the document before the preview
|
||||
let preview = std::mem::replace(&mut self.doc, draft.base);
|
||||
self.changed_without_history(&preview);
|
||||
self.tool.path.editing = None;
|
||||
}
|
||||
|
||||
let shape = self.path_shape(self.camera, viewport);
|
||||
let editing = self.tool.path.editing;
|
||||
let label = editing.map_or(NEW_PATH_LABEL.to_string(), |(_, i)| format!("Edit path {}", i + 1));
|
||||
let out = self.edit_merging(&label, editing.is_some() && self.tool.path.edited, |s| {
|
||||
@@ -396,11 +403,27 @@ impl Session {
|
||||
self.target = StackTarget::Effect(LayerId(eid));
|
||||
}
|
||||
self.tool.path.clear();
|
||||
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// Repaint the edited path (one merged undo step) or a new path's preview (no step) when its points, brush or material changed; called every frame
|
||||
pub fn path_live(&mut self) -> Result<bool> {
|
||||
self.path_live_in_view(self.viewport)
|
||||
}
|
||||
|
||||
/// Compare curve and typed paint settings through the stored camera and viewport
|
||||
fn same_as_stored(&self, stored: &PathShape) -> bool {
|
||||
// JSON round trips can change float representation without changing the paint settings
|
||||
read_paint(stored).is_ok_and(|paint| {
|
||||
let current = self.path_shape(paint.camera, Vec2::from_array(stored.viewport));
|
||||
(¤t.points, current.uv, current.closed, current.fill) == (&stored.points, stored.uv, stored.closed, stored.fill)
|
||||
&& read_paint(¤t).is_ok_and(|current_paint| current_paint == paint)
|
||||
})
|
||||
}
|
||||
|
||||
/// Preview a command's points in its supplied viewport, or the UI's current viewport
|
||||
fn path_live_in_view(&mut self, viewport: Vec2) -> Result<bool> {
|
||||
let stored = match self.tool.path.editing {
|
||||
Some((eid, index)) => match self.paths(eid).and_then(|v| v.get(index)).cloned() {
|
||||
Some(shape) => Some((eid, index, shape)),
|
||||
@@ -412,22 +435,40 @@ impl Session {
|
||||
None => None,
|
||||
};
|
||||
|
||||
if self.tool.tool != Tool::Path || self.stroke.is_some() {
|
||||
return Ok(false);
|
||||
}
|
||||
|
||||
if self.tool.path.points.is_empty() {
|
||||
if let Some((effect, index, _)) = stored {
|
||||
if self.path_draft.is_some() {
|
||||
self.cancel_path();
|
||||
} else {
|
||||
self.edit_merging(&format!("Edit path {}", index + 1), self.tool.path.edited, |session| {
|
||||
if let Some(Effect { kind: EffectKind::Path(paths), .. }) = session.doc.project.effect_mut(effect) {
|
||||
paths.remove(index);
|
||||
}
|
||||
session.render_paths(effect, index)
|
||||
})?;
|
||||
self.cancel_path();
|
||||
}
|
||||
return Ok(true);
|
||||
}
|
||||
return Ok(false);
|
||||
}
|
||||
|
||||
let path = &self.tool.path;
|
||||
if self.tool.tool != Tool::Path || self.stroke.is_some() || path.points.is_empty() || (path.closed && path.fill && path.points.len() < 3) {
|
||||
return Ok(false);
|
||||
}
|
||||
let Some((eid, index, stored)) = stored else { return self.start_path_draft() };
|
||||
|
||||
// Typed comparison: the stored settings went through JSON (f64), maybe a save and load
|
||||
let unchanged = read_paint(&stored).is_ok_and(|p| {
|
||||
let now = self.path_shape(p.camera, Vec2::from_array(stored.viewport));
|
||||
(&now.points, now.uv, now.closed, now.fill) == (&stored.points, stored.uv, stored.closed, stored.fill) && read_paint(&now).is_ok_and(|n| n == p)
|
||||
});
|
||||
if unchanged {
|
||||
if path.closed && path.fill && path.points.len() < 3 {
|
||||
return Ok(false);
|
||||
}
|
||||
|
||||
let shape = self.path_shape(self.camera, self.viewport);
|
||||
let Some((eid, index, stored)) = stored else { return self.start_path_draft(viewport) };
|
||||
|
||||
if self.same_as_stored(&stored) {
|
||||
return Ok(false);
|
||||
}
|
||||
|
||||
let shape = self.path_shape(self.camera, viewport);
|
||||
let (painted, before) = self.repaint_path(eid, index, shape)?;
|
||||
match &mut self.path_draft {
|
||||
Some(draft) => draft.painted = painted,
|
||||
@@ -443,9 +484,9 @@ impl Session {
|
||||
}
|
||||
|
||||
/// Paint a new path's first preview where [`Session::commit_path`] would add it, keeping the document before it for apply and cancel
|
||||
fn start_path_draft(&mut self) -> Result<bool> {
|
||||
fn start_path_draft(&mut self, viewport: Vec2) -> Result<bool> {
|
||||
let base = self.doc.clone();
|
||||
let shape = self.path_shape(self.camera, self.viewport);
|
||||
let shape = self.path_shape(self.camera, viewport);
|
||||
let placed = self.path_effect().and_then(|eid| {
|
||||
let index = self.paths(eid).map_or(0, <[_]>::len);
|
||||
self.put_path(eid, index, shape).map(|painted| ((eid, index), painted))
|
||||
@@ -470,10 +511,81 @@ impl Session {
|
||||
pub fn path_checkpoint(&mut self) {
|
||||
if !self.path_steps.0.last().is_some_and(|s| s.same_curve(&self.tool.path)) {
|
||||
self.path_steps.0.push(self.tool.path.clone());
|
||||
// Each snapshot can contain thousands of points; bound point history like document history
|
||||
let excess = self.path_steps.0.len().saturating_sub(crate::session::MAX_HISTORY);
|
||||
self.path_steps.0.drain(..excess);
|
||||
self.path_steps.1.clear();
|
||||
}
|
||||
}
|
||||
|
||||
/// Select a point without changing its geometry or clearing redo
|
||||
pub fn select_path_point(&mut self, index: usize) {
|
||||
self.tool.path.selected = (index < self.tool.path.points.len()).then_some(index);
|
||||
}
|
||||
|
||||
/// Append and select a point, checkpointing the curve before it changes
|
||||
pub fn append_path_point(&mut self, point: Vec3, uv: bool) -> Option<usize> {
|
||||
if !point.is_finite() || (self.tool.path.uv == uv && self.tool.path.points.len() >= MAX_PATH_POINTS) {
|
||||
return None;
|
||||
}
|
||||
|
||||
self.path_checkpoint();
|
||||
self.tool.path.push(point, uv);
|
||||
self.tool.path.selected = self.tool.path.points.len().checked_sub(1);
|
||||
self.tool.path.selected
|
||||
}
|
||||
|
||||
/// Insert and select a point as one undoable point edit
|
||||
pub fn insert_path_point(&mut self, index: usize, point: Vec3) -> Option<usize> {
|
||||
if !point.is_finite() || index > self.tool.path.points.len() || self.tool.path.points.len() >= MAX_PATH_POINTS {
|
||||
return None;
|
||||
}
|
||||
|
||||
self.path_checkpoint();
|
||||
self.tool.path.insert(index, point)
|
||||
}
|
||||
|
||||
/// Move a point, checkpointing only the first actual movement in a drag
|
||||
pub fn move_path_point(&mut self, index: usize, point: Vec3, begin_drag: bool) -> bool {
|
||||
if !point.is_finite() || self.tool.path.points.get(index).is_none_or(|current| *current == point) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if begin_drag {
|
||||
self.path_checkpoint();
|
||||
}
|
||||
if let Some(current) = self.tool.path.points.get_mut(index) {
|
||||
*current = point;
|
||||
}
|
||||
true
|
||||
}
|
||||
|
||||
/// Remove the selected point, or the last one, as one undoable point edit
|
||||
pub fn remove_selected_path_point(&mut self) {
|
||||
if self.tool.path.points.is_empty() {
|
||||
return;
|
||||
}
|
||||
|
||||
self.path_checkpoint();
|
||||
self.tool.path.remove_selected();
|
||||
}
|
||||
|
||||
/// Change whether the path loops back to its first point, with point undo
|
||||
pub fn set_path_closed(&mut self, closed: bool) {
|
||||
if self.tool.path.closed != closed {
|
||||
self.path_checkpoint();
|
||||
self.tool.path.closed = closed;
|
||||
}
|
||||
}
|
||||
|
||||
/// Change whether a closed path fills its interior, with point undo
|
||||
pub fn set_path_fill(&mut self, fill: bool) {
|
||||
if self.tool.path.fill != fill {
|
||||
self.path_checkpoint();
|
||||
self.tool.path.fill = fill;
|
||||
}
|
||||
}
|
||||
|
||||
/// Whether [`Session::step_path`] would undo (`back`) or redo a point change
|
||||
pub(crate) fn path_step_pending(&self, back: bool) -> bool {
|
||||
let steps = if back { &self.path_steps.0 } else { &self.path_steps.1 };
|
||||
@@ -692,6 +804,7 @@ impl Session {
|
||||
if shape.uv {
|
||||
return None;
|
||||
}
|
||||
|
||||
let (camera, viewport) = paint_view(shape, &read_paint(shape).ok()?);
|
||||
let path = state_of(shape);
|
||||
Some(self.path_surface(&path.points, path.closed, camera, viewport))
|
||||
@@ -787,6 +900,7 @@ impl Session {
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use serde_json::json;
|
||||
|
||||
use crate::{Session, execute};
|
||||
@@ -823,4 +937,94 @@ mod tests {
|
||||
assert_eq!(cached, pixels(&s, eid), "same pixels as painting every path");
|
||||
assert!(!cached.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn point_insertion_and_removal_respect_boundaries() {
|
||||
let mut path = PathState { points: vec![Vec3::ZERO, Vec3::X], ..Default::default() };
|
||||
|
||||
assert_eq!(path.insert(2, Vec3::Y), Some(2));
|
||||
assert_eq!(path.points, vec![Vec3::ZERO, Vec3::X, Vec3::Y]);
|
||||
assert_eq!(path.insert(4, Vec3::Z), None);
|
||||
path.closed = true;
|
||||
path.selected = Some(usize::MAX);
|
||||
path.remove_selected();
|
||||
assert_eq!(path.points, vec![Vec3::ZERO, Vec3::X]);
|
||||
assert!(!path.closed);
|
||||
path.remove_selected();
|
||||
path.remove_selected();
|
||||
path.remove_selected();
|
||||
assert!(path.points.is_empty());
|
||||
assert_eq!(path.selected, None);
|
||||
|
||||
path.points = vec![Vec3::ZERO; MAX_PATH_POINTS];
|
||||
assert_eq!(path.insert(MAX_PATH_POINTS, Vec3::X), None);
|
||||
assert_eq!(path.points.len(), MAX_PATH_POINTS);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn changed_tiles_include_mask_and_channel_creation_and_deletion() {
|
||||
let effect = LayerId(7);
|
||||
let mut before = PixelStore::default();
|
||||
let mut image = TileImage::new(192, 128, 1);
|
||||
image.tile_mut(0, 0, &[1]).unwrap();
|
||||
before.masks.insert(effect, image.clone());
|
||||
before.layers.insert((effect, Channel::Roughness), image.clone());
|
||||
let mut after = before.clone();
|
||||
after.masks.get_mut(&effect).unwrap().set_tile(0, 0, None);
|
||||
after.masks.get_mut(&effect).unwrap().tile_mut(2, 1, &[1]).unwrap();
|
||||
after.layers.remove(&(effect, Channel::Roughness));
|
||||
image.set_tile(0, 0, None);
|
||||
image.tile_mut(1, 0, &[1]).unwrap();
|
||||
after.layers.insert((effect, Channel::Metallic), image);
|
||||
|
||||
assert_eq!(changed_tiles(&before, &before.clone(), effect), BTreeSet::new());
|
||||
assert_eq!(changed_tiles(&before, &after, effect), BTreeSet::from([(0, 0), (1, 0), (2, 1)]));
|
||||
assert_eq!(changed_tiles(&before, &after, LayerId(8)), BTreeSet::new());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn point_checkpoints_skip_noops_and_bound_retained_points() {
|
||||
let mut session = Session::new_project("t", texturecraft_geom::primitives::plane(1.0, 1), "builtin:test", None, 128).unwrap();
|
||||
session.tool.tool = Tool::Path;
|
||||
session.tool.path.points = vec![Vec3::ZERO; MAX_PATH_POINTS];
|
||||
session.path_checkpoint();
|
||||
assert!(!session.path_step_pending(true));
|
||||
assert!(!session.step_path(true));
|
||||
|
||||
for index in 0..crate::session::MAX_HISTORY + 10 {
|
||||
session.path_checkpoint();
|
||||
session.tool.path.points[0].x = index as f32 + 1.0;
|
||||
}
|
||||
|
||||
assert_eq!(session.path_steps.0.len(), crate::session::MAX_HISTORY);
|
||||
assert_eq!(session.path_steps.0.iter().map(|state| state.points.len()).sum::<usize>(), crate::session::MAX_HISTORY * MAX_PATH_POINTS);
|
||||
session.path_checkpoint();
|
||||
assert!(session.step_path(true), "a no-change checkpoint does not consume an undo");
|
||||
assert_eq!(session.tool.path.points[0].x, (crate::session::MAX_HISTORY + 9) as f32);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stored_surface_uses_bounded_viewports_and_skips_uv_paths() {
|
||||
let mut session = Session::new_project("t", texturecraft_geom::primitives::sphere(1.0, 24, 12), "builtin:test", None, 128).unwrap();
|
||||
execute(&mut session, "tool.path", &json!({"uvPoints": [[0.2, 0.5], [0.8, 0.5]], "commit": true})).unwrap();
|
||||
let StackTarget::Effect(effect) = session.target else { panic!("path sublayer") };
|
||||
assert!(session.stored_path_surface(effect, 0).is_none());
|
||||
let shape = session.paths(effect).unwrap()[0].clone();
|
||||
let paint = read_paint(&shape).unwrap();
|
||||
let mut shape = shape;
|
||||
shape.viewport = [-1.0, f32::MAX];
|
||||
assert_eq!(paint_view(&shape, &paint).1, Vec2::new(MIN_PAINT_VIEWPORT_PX, MAX_PAINT_VIEWPORT_PX));
|
||||
|
||||
let points = [Vec3::new(-0.2, 0.0, 1.0), Vec3::new(0.0, 0.2, 1.0), Vec3::new(0.2, 0.0, 1.0)];
|
||||
session.camera.yaw = 0.0;
|
||||
session.camera.pitch = 0.0;
|
||||
let surface = session.path_surface(&points, true, session.camera, Vec2::splat(400.0));
|
||||
assert_eq!(surface.len(), 3);
|
||||
let first = surface.first().unwrap().first().unwrap().unwrap();
|
||||
let last = surface.last().unwrap().last().unwrap().unwrap();
|
||||
assert!(first.distance(last) < 1e-5, "the closed curve returns to its starting surface point");
|
||||
let off_mesh = session.path_surface(&[Vec3::new(10.0, 0.0, 0.0), Vec3::new(11.0, 0.0, 0.0)], false, session.camera, Vec2::splat(400.0));
|
||||
assert!(!off_mesh.is_empty());
|
||||
assert!(off_mesh.iter().flatten().all(Option::is_none));
|
||||
}
|
||||
}
|
||||
@@ -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>,
|
||||
@@ -360,6 +369,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).
|
||||
@@ -381,6 +392,7 @@ impl Session {
|
||||
Ok(Session {
|
||||
doc,
|
||||
mesh_id: next_mesh_id(),
|
||||
project_id: next_mesh_id(),
|
||||
source,
|
||||
mesh,
|
||||
bvh: Arc::new(bvh),
|
||||
@@ -396,6 +408,7 @@ impl Session {
|
||||
target: StackTarget::Content,
|
||||
camera,
|
||||
view: ViewMode::Material,
|
||||
bake_preview: None,
|
||||
viewport: Vec2::new(1280.0, 800.0),
|
||||
stroke: None,
|
||||
clipboard: None,
|
||||
@@ -410,6 +423,7 @@ impl Session {
|
||||
revision: 1,
|
||||
log: Vec::new(),
|
||||
depth_cache: None,
|
||||
polygon_fill_drag: None,
|
||||
export_presets: Default::default(),
|
||||
templates: Default::default(),
|
||||
})
|
||||
@@ -494,22 +508,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)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -537,6 +553,7 @@ impl Session {
|
||||
if !self.painting_paths {
|
||||
self.path_steps = Default::default();
|
||||
}
|
||||
|
||||
self.modified = true;
|
||||
self.revision = self.revision.wrapping_add(1);
|
||||
if !(merge && self.undo.last().is_some_and(|(l, _)| l == label)) {
|
||||
@@ -657,7 +674,9 @@ 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();
|
||||
self.end_polygon_fill_box();
|
||||
|
||||
// While a path is edited, undo steps back through its point changes first
|
||||
if self.step_path(true) {
|
||||
@@ -670,29 +689,31 @@ impl Session {
|
||||
return Ok(crate::path_tool::NEW_PATH_LABEL.to_string());
|
||||
}
|
||||
|
||||
// An edited path would otherwise repaint over the restored document
|
||||
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();
|
||||
self.end_polygon_fill_box();
|
||||
|
||||
if self.step_path(false) {
|
||||
return Ok(crate::path_tool::NEW_PATH_LABEL.to_string());
|
||||
}
|
||||
|
||||
// An edited path would otherwise repaint over the restored document
|
||||
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)
|
||||
}
|
||||
|
||||
@@ -75,7 +75,16 @@ pub(crate) fn ts_param(s: &Session, p: &Value, cmd: &str) -> Result<usize> {
|
||||
}
|
||||
|
||||
fn select(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let ts = u64p(p, "ts").map(|t| t as usize).filter(|t| *t < s.set_count()).ok_or_else(|| bad("textureSet.select", "valid `ts` index required"))?;
|
||||
let ts = u64p(p, "ts")
|
||||
.map(|index| index as usize)
|
||||
.filter(|index| *index < s.set_count())
|
||||
.ok_or_else(|| bad("textureSet.select", "valid `ts` index required"))?;
|
||||
select_set(s, ts)?;
|
||||
Ok(json!({ "ts": ts }))
|
||||
}
|
||||
|
||||
/// Make texture set `ts` the active one, on its content stack
|
||||
pub(crate) fn select_set(s: &mut Session, ts: usize) -> Result<()> {
|
||||
s.cancel_stroke();
|
||||
|
||||
// Paths paint into the active set
|
||||
@@ -86,7 +95,7 @@ fn select(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
s.active_set = ts;
|
||||
s.target = StackTarget::Content;
|
||||
s.revision = s.revision.wrapping_add(1);
|
||||
Ok(json!({ "ts": ts }))
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn resolution(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -0,0 +1,570 @@
|
||||
//! Asynchronous layer-panel thumbnails.
|
||||
//!
|
||||
//! The panel asks for small previews of layer contents, masks and effect stages
|
||||
//! ([`ThumbTarget`]). The work never runs on the UI thread and never touches the main composite:
|
||||
//!
|
||||
//! * A **snapshot** ([`ThumbSnapshot`]) is an immutable copy of what the compositor reads (the
|
||||
//! project, copy-on-write pixel tiles, baked maps, images and the mesh) plus a 64 px G-buffer.
|
||||
//! It is rebuilt only when the document really changed, at most every [`DEBOUNCE`] seconds
|
||||
//! (a slider drag renders at that pace, not once per frame).
|
||||
//! * A **worker thread** evaluates one target at a time from a snapshot with
|
||||
//! [`texturecraft_compose::thumb::render`]. On wasm32 (no threads) one job runs per
|
||||
//! [`ThumbService::poll`] instead.
|
||||
//! * Results are kept in a small LRU **cache** ([`CACHE_ENTRIES`]). A result computed from an
|
||||
//! older snapshot than the current one is dropped, so a slow job can never overwrite a newer
|
||||
//! thumbnail. An entry that is out of date keeps showing until its replacement arrives.
|
||||
//! * Only targets requested during the current frame are rendered: a row that scrolled away
|
||||
//! before its turn is dropped from the queue.
|
||||
|
||||
use std::collections::{HashMap, HashSet, VecDeque};
|
||||
use std::sync::Arc;
|
||||
|
||||
use texturecraft_compose::{BakedMaps, ImageStore, Inputs, PixelStore, THUMB_TEXELS, ThumbImage, ThumbTarget, thumb};
|
||||
use texturecraft_core::Project;
|
||||
use texturecraft_geom::glam::Vec3;
|
||||
use texturecraft_geom::{Mesh, UvGBuffer};
|
||||
|
||||
use crate::Session;
|
||||
|
||||
/// Thumbnails kept.
|
||||
pub const CACHE_ENTRIES: usize = 96;
|
||||
/// Seconds between checks for a changed document while it keeps changing.
|
||||
pub const DEBOUNCE: f64 = 0.12;
|
||||
/// Jobs handed to the worker at once (the rest wait here, where they can still be dropped).
|
||||
const IN_FLIGHT: usize = 2;
|
||||
|
||||
/// An immutable copy of everything the thumbnails of one texture set read.
|
||||
pub struct ThumbSnapshot {
|
||||
ts: usize,
|
||||
mesh_id: u64,
|
||||
project: Project,
|
||||
pixels: PixelStore,
|
||||
baked: BakedMaps,
|
||||
images: ImageStore,
|
||||
mesh: Arc<Mesh>,
|
||||
gbuf: Arc<UvGBuffer>,
|
||||
bounds: (Vec3, Vec3),
|
||||
}
|
||||
|
||||
impl ThumbSnapshot {
|
||||
/// Snapshot texture set `ts` of `s`, with the G-buffer from `gbufs` (built on a miss).
|
||||
pub fn new(s: &Session, ts: usize, gbufs: &mut GbufCache) -> Option<ThumbSnapshot> {
|
||||
let material = s.doc.project.texture_set(ts).ok()?.material;
|
||||
let gbuf = gbufs.get(&s.mesh, s.mesh_id, material);
|
||||
Some(ThumbSnapshot {
|
||||
ts,
|
||||
mesh_id: s.mesh_id,
|
||||
project: s.doc.project.clone(),
|
||||
pixels: s.doc.pixels.clone(),
|
||||
baked: s.doc.baked.get(&ts).cloned().unwrap_or_default(),
|
||||
images: s.images.clone(),
|
||||
mesh: s.mesh.clone(),
|
||||
gbuf,
|
||||
bounds: s.mesh.bounds(),
|
||||
})
|
||||
}
|
||||
|
||||
/// Whether `session` would give the same thumbnails as this snapshot.
|
||||
fn matches(&self, session: &Session, texture_set: usize) -> bool {
|
||||
let same_pixels = self.pixels.layers.len() == session.doc.pixels.layers.len()
|
||||
&& self.pixels.masks.len() == session.doc.pixels.masks.len()
|
||||
&& self.pixels.layers.iter().all(|(key, pixels)| session.doc.pixels.layers.get(key) == Some(pixels))
|
||||
&& self.pixels.masks.iter().all(|(key, pixels)| session.doc.pixels.masks.get(key) == Some(pixels));
|
||||
let empty = BakedMaps::default();
|
||||
let baked = session.doc.baked.get(&texture_set).unwrap_or(&empty);
|
||||
|
||||
// Copy-on-write maps change handles on edits; float equality would scan entire bakes
|
||||
let same_baked = self.baked.resolution == baked.resolution
|
||||
&& self.baked.maps.len() == baked.maps.len()
|
||||
&& self.baked.maps.iter().all(|(map, pixels)| baked.maps.get(map).is_some_and(|current| Arc::ptr_eq(pixels, current)));
|
||||
|
||||
self.ts == texture_set
|
||||
&& self.mesh_id == session.mesh_id
|
||||
&& self.project == session.doc.project
|
||||
&& same_pixels
|
||||
&& same_baked
|
||||
&& self.images.len() == session.images.len()
|
||||
&& self.images.iter().all(|(key, image)| session.images.get(key).is_some_and(|current| Arc::ptr_eq(current, image)))
|
||||
}
|
||||
|
||||
/// Render `target`: the work of one job.
|
||||
pub fn render(&self, target: ThumbTarget) -> Option<ThumbImage> {
|
||||
let inp = Inputs {
|
||||
project: &self.project,
|
||||
ts: self.ts,
|
||||
mesh: &self.mesh,
|
||||
gbuf: &self.gbuf,
|
||||
pixels: &self.pixels,
|
||||
baked: &self.baked,
|
||||
block_scales: self.project.texture_set(self.ts).map(|set| set.block_scales()).unwrap_or_default(),
|
||||
preview: None,
|
||||
images: &self.images,
|
||||
bounds: self.bounds,
|
||||
};
|
||||
thumb::render(&inp, target)
|
||||
}
|
||||
|
||||
/// Whether the layer or effect `target` shows still exists in the snapshot's project.
|
||||
fn has(&self, target: ThumbTarget) -> bool {
|
||||
has_target(&self.project, target)
|
||||
}
|
||||
}
|
||||
|
||||
fn has_target(p: &Project, target: ThumbTarget) -> bool {
|
||||
match target {
|
||||
ThumbTarget::Content { layer, .. } | ThumbTarget::Mask { layer } => p.layers.contains_key(&layer),
|
||||
ThumbTarget::Stage { effect, .. } => p.effect(effect).is_some(),
|
||||
}
|
||||
}
|
||||
|
||||
/// The 64 px G-buffers built so far, per mesh and material (rasterizing is the one part of a
|
||||
/// snapshot that is not just copying handles).
|
||||
#[derive(Default)]
|
||||
pub struct GbufCache {
|
||||
map: HashMap<(u64, usize), Arc<UvGBuffer>>,
|
||||
}
|
||||
|
||||
impl GbufCache {
|
||||
fn get(&mut self, mesh: &Mesh, mesh_id: u64, material: usize) -> Arc<UvGBuffer> {
|
||||
if self.map.len() > 16 {
|
||||
self.map.clear();
|
||||
}
|
||||
self.map.entry((mesh_id, material)).or_insert_with(|| Arc::new(UvGBuffer::new(mesh, material, THUMB_TEXELS, THUMB_TEXELS))).clone()
|
||||
}
|
||||
}
|
||||
|
||||
struct Entry {
|
||||
/// None: the target has nothing to show (a layer without that channel).
|
||||
image: Option<Arc<ThumbImage>>,
|
||||
/// Snapshot generation it was rendered from.
|
||||
generation: u64,
|
||||
/// Changes whenever `image` does (views key their GPU textures on it).
|
||||
version: u64,
|
||||
used: u64,
|
||||
}
|
||||
|
||||
/// What the panel draws for one target.
|
||||
#[derive(Clone)]
|
||||
pub struct ThumbView {
|
||||
pub image: Option<Arc<ThumbImage>>,
|
||||
/// Identifies `image`; changes when a new picture arrives.
|
||||
pub version: u64,
|
||||
/// A newer picture is on its way.
|
||||
pub pending: bool,
|
||||
}
|
||||
|
||||
struct Job {
|
||||
snapshot: Arc<ThumbSnapshot>,
|
||||
generation: u64,
|
||||
target: ThumbTarget,
|
||||
}
|
||||
|
||||
struct Done {
|
||||
generation: u64,
|
||||
target: ThumbTarget,
|
||||
image: Option<ThumbImage>,
|
||||
}
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
struct Worker {
|
||||
tx: std::sync::mpsc::Sender<Job>,
|
||||
rx: std::sync::mpsc::Receiver<Done>,
|
||||
}
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
fn spawn_worker() -> Option<Worker> {
|
||||
let (tx, jobs) = std::sync::mpsc::channel::<Job>();
|
||||
let (done_tx, rx) = std::sync::mpsc::channel::<Done>();
|
||||
std::thread::Builder::new()
|
||||
.name("layer-thumbs".into())
|
||||
.spawn(move || {
|
||||
while let Ok(job) = jobs.recv() {
|
||||
let image = job.snapshot.render(job.target);
|
||||
if done_tx.send(Done { generation: job.generation, target: job.target, image }).is_err() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
})
|
||||
.ok()?;
|
||||
Some(Worker { tx, rx })
|
||||
}
|
||||
|
||||
/// The thumbnail cache and its worker. One lives in the UI; see the module documentation.
|
||||
pub struct ThumbService {
|
||||
snapshot: Option<Arc<ThumbSnapshot>>,
|
||||
/// Bumps whenever the snapshot's content changes; entries and jobs carry it.
|
||||
generation: u64,
|
||||
/// The session revision the snapshot was last compared with.
|
||||
seen: Option<u64>,
|
||||
last_check: f64,
|
||||
cache: HashMap<ThumbTarget, Entry>,
|
||||
tick: u64,
|
||||
versions: u64,
|
||||
queue: VecDeque<ThumbTarget>,
|
||||
in_flight: HashSet<(u64, ThumbTarget)>,
|
||||
wanted: HashSet<ThumbTarget>,
|
||||
gbufs: GbufCache,
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
worker: Option<Worker>,
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
spawned: bool,
|
||||
/// Jobs run inline (wasm32, or no worker thread could start).
|
||||
inline: VecDeque<Job>,
|
||||
/// Pictures computed (tests, benchmarks).
|
||||
pub rendered: u64,
|
||||
}
|
||||
|
||||
impl Default for ThumbService {
|
||||
fn default() -> Self {
|
||||
ThumbService {
|
||||
snapshot: None,
|
||||
generation: 0,
|
||||
seen: None,
|
||||
last_check: f64::NEG_INFINITY,
|
||||
cache: HashMap::new(),
|
||||
tick: 0,
|
||||
versions: 0,
|
||||
queue: VecDeque::new(),
|
||||
in_flight: HashSet::new(),
|
||||
wanted: HashSet::new(),
|
||||
gbufs: GbufCache::default(),
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
worker: None,
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
spawned: false,
|
||||
inline: VecDeque::new(),
|
||||
rendered: 0,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl ThumbService {
|
||||
pub fn new() -> ThumbService {
|
||||
ThumbService::default()
|
||||
}
|
||||
|
||||
/// Start of a frame: forget what the last frame asked for and notice document changes.
|
||||
pub fn begin_frame(&mut self, session: &Session, now: f64) {
|
||||
self.wanted.clear();
|
||||
let texture_set = session.ts();
|
||||
if self.seen == Some(session.revision)
|
||||
&& self.snapshot.as_ref().is_some_and(|snapshot| snapshot.ts == texture_set && snapshot.mesh_id == session.mesh_id)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// Compare at the debounce pace while the document keeps changing
|
||||
if self.snapshot.is_some() && now - self.last_check < DEBOUNCE {
|
||||
return;
|
||||
}
|
||||
|
||||
self.last_check = now;
|
||||
if self.snapshot.as_ref().is_some_and(|snapshot| snapshot.matches(session, texture_set)) {
|
||||
self.seen = Some(session.revision);
|
||||
return;
|
||||
}
|
||||
|
||||
self.snapshot = ThumbSnapshot::new(session, texture_set, &mut self.gbufs).map(Arc::new);
|
||||
self.seen = Some(session.revision);
|
||||
self.generation = self.generation.wrapping_add(1);
|
||||
|
||||
// Keep dispatched jobs counted until they finish, even when their snapshot is stale
|
||||
self.queue.clear();
|
||||
for job in self.inline.drain(..) {
|
||||
self.in_flight.remove(&(job.generation, job.target));
|
||||
}
|
||||
|
||||
if let Some(snapshot) = &self.snapshot {
|
||||
self.cache.retain(|target, _| snapshot.has(*target));
|
||||
} else {
|
||||
self.cache.clear();
|
||||
}
|
||||
}
|
||||
|
||||
/// Whether the displayed pictures wait for a document comparison that is still debounced.
|
||||
fn checked(&self, session: &Session) -> bool {
|
||||
self.seen == Some(session.revision)
|
||||
}
|
||||
|
||||
/// The picture for `target` (call for the rows on screen only). Queues work when the
|
||||
/// picture is missing or out of date.
|
||||
pub fn get(&mut self, session: &Session, target: ThumbTarget) -> ThumbView {
|
||||
self.wanted.insert(target);
|
||||
self.tick = self.tick.wrapping_add(1);
|
||||
let fresh = self.cache.get(&target).is_some_and(|entry| entry.generation == self.generation);
|
||||
let checked = self.checked(session);
|
||||
if !fresh && checked && self.snapshot.is_some() && !self.in_flight.contains(&(self.generation, target)) && !self.queue.contains(&target) {
|
||||
self.queue.push_back(target);
|
||||
}
|
||||
|
||||
match self.cache.get_mut(&target) {
|
||||
Some(entry) => {
|
||||
entry.used = self.tick;
|
||||
ThumbView { image: entry.image.clone(), version: entry.version, pending: !(fresh && checked) }
|
||||
}
|
||||
None => ThumbView { image: None, version: 0, pending: true },
|
||||
}
|
||||
}
|
||||
|
||||
/// End of a frame: collect results, discard unrequested rows, and dispatch new work.
|
||||
/// Returns whether another frame is needed, including to display newly collected pictures.
|
||||
pub fn poll(&mut self, session: &Session) -> bool {
|
||||
let changed = self.collect();
|
||||
self.queue.retain(|target| self.wanted.contains(target));
|
||||
self.dispatch();
|
||||
self.trim();
|
||||
|
||||
changed || !self.queue.is_empty() || !self.in_flight.is_empty() || !self.checked(session)
|
||||
}
|
||||
|
||||
fn dispatch(&mut self) {
|
||||
let Some(snapshot) = self.snapshot.clone() else { return };
|
||||
|
||||
while self.in_flight.len() < IN_FLIGHT {
|
||||
let Some(target) = self.queue.pop_front() else { break };
|
||||
let job = Job { snapshot: snapshot.clone(), generation: self.generation, target };
|
||||
self.in_flight.insert((job.generation, target));
|
||||
self.send(job);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
fn send(&mut self, job: Job) {
|
||||
if !self.spawned {
|
||||
self.spawned = true;
|
||||
self.worker = spawn_worker();
|
||||
}
|
||||
|
||||
match &self.worker {
|
||||
Some(worker) => {
|
||||
if let Err(error) = worker.tx.send(job) {
|
||||
// A stopped worker cannot complete any of its outstanding jobs
|
||||
self.worker = None;
|
||||
self.in_flight.clear();
|
||||
self.in_flight.insert((error.0.generation, error.0.target));
|
||||
self.inline.push_back(error.0);
|
||||
}
|
||||
}
|
||||
None => self.inline.push_back(job),
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(target_arch = "wasm32")]
|
||||
fn send(&mut self, job: Job) {
|
||||
self.inline.push_back(job);
|
||||
}
|
||||
|
||||
fn collect(&mut self) -> bool {
|
||||
let mut completed = Vec::new();
|
||||
let mut changed = false;
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
if let Some(worker) = &self.worker {
|
||||
loop {
|
||||
match worker.rx.try_recv() {
|
||||
Ok(result) => completed.push(result),
|
||||
Err(std::sync::mpsc::TryRecvError::Empty) => break,
|
||||
Err(std::sync::mpsc::TryRecvError::Disconnected) => {
|
||||
// Request another frame so wanted targets retry on the inline fallback
|
||||
self.worker = None;
|
||||
self.in_flight.clear();
|
||||
changed = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Without a thread, bound each poll to one render
|
||||
if let Some(job) = self.inline.pop_front() {
|
||||
let image = job.snapshot.render(job.target);
|
||||
completed.push(Done { generation: job.generation, target: job.target, image });
|
||||
}
|
||||
|
||||
for result in completed {
|
||||
self.rendered = self.rendered.wrapping_add(1);
|
||||
self.in_flight.remove(&(result.generation, result.target));
|
||||
|
||||
// A picture of an older snapshot never replaces a newer one
|
||||
if result.generation != self.generation {
|
||||
continue;
|
||||
}
|
||||
|
||||
if !self.snapshot.as_ref().is_some_and(|snapshot| snapshot.has(result.target)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
self.versions = self.versions.wrapping_add(1);
|
||||
let entry = Entry { image: result.image.map(Arc::new), generation: result.generation, version: self.versions, used: self.tick };
|
||||
self.cache.insert(result.target, entry);
|
||||
changed = true;
|
||||
}
|
||||
|
||||
changed
|
||||
}
|
||||
|
||||
fn trim(&mut self) {
|
||||
while self.cache.len() > CACHE_ENTRIES {
|
||||
let Some(oldest) = self.cache.iter().filter(|(t, _)| !self.wanted.contains(t)).min_by_key(|(_, e)| e.used).map(|(t, _)| *t) else { break };
|
||||
self.cache.remove(&oldest);
|
||||
}
|
||||
}
|
||||
|
||||
/// Entries held (tests).
|
||||
pub fn cached(&self) -> usize {
|
||||
self.cache.len()
|
||||
}
|
||||
|
||||
/// Whether `target` has a picture of the current snapshot (tests).
|
||||
pub fn is_fresh(&self, target: ThumbTarget) -> bool {
|
||||
self.cache.get(&target).is_some_and(|e| e.generation == self.generation)
|
||||
}
|
||||
|
||||
/// Whether any work is queued or running (tests).
|
||||
pub fn busy(&self) -> bool {
|
||||
!self.queue.is_empty() || !self.in_flight.is_empty() || !self.inline.is_empty()
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(all(test, not(target_arch = "wasm32")))]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use texturecraft_core::Channel;
|
||||
use texturecraft_geom::primitives;
|
||||
|
||||
fn test_session() -> crate::Result<Session> {
|
||||
Session::new_project("thumb", primitives::plane(1.0, 1), "builtin:plane", None, 128)
|
||||
}
|
||||
|
||||
fn held_worker() -> (ThumbService, std::sync::mpsc::Receiver<Job>, std::sync::mpsc::Sender<Done>) {
|
||||
let (sender, jobs) = std::sync::mpsc::channel();
|
||||
let (results, receiver) = std::sync::mpsc::channel();
|
||||
let service = ThumbService { worker: Some(Worker { tx: sender, rx: receiver }), spawned: true, ..Default::default() };
|
||||
(service, jobs, results)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unchanged_baked_handles_match_even_with_non_finite_samples() {
|
||||
let mut session = test_session().unwrap();
|
||||
let baked = session.doc.baked.entry(0).or_default();
|
||||
baked.resolution = 1;
|
||||
baked.maps.insert(texturecraft_core::BakedMap::Height, Arc::new(vec![f32::NAN]));
|
||||
let snapshot = ThumbSnapshot::new(&session, 0, &mut GbufCache::default()).unwrap();
|
||||
|
||||
assert!(snapshot.matches(&session, 0), "unchanged shared data must not invalidate every frame");
|
||||
|
||||
let map = session.doc.baked.get_mut(&0).unwrap().maps.get_mut(&texturecraft_core::BakedMap::Height).unwrap();
|
||||
Arc::make_mut(map)[0] = 0.5;
|
||||
assert!(!snapshot.matches(&session, 0), "a copy-on-write edit must invalidate the snapshot");
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore]
|
||||
fn benchmark_unchanged_4k_baked_snapshot() {
|
||||
let mut session = test_session().unwrap();
|
||||
let baked = session.doc.baked.entry(0).or_default();
|
||||
baked.resolution = 4096;
|
||||
baked.maps.insert(texturecraft_core::BakedMap::Normal, Arc::new(vec![0.5; 4096 * 4096 * 3]));
|
||||
baked.maps.insert(texturecraft_core::BakedMap::AmbientOcclusion, Arc::new(vec![0.5; 4096 * 4096]));
|
||||
let snapshot = ThumbSnapshot::new(&session, 0, &mut GbufCache::default()).unwrap();
|
||||
let start = std::time::Instant::now();
|
||||
|
||||
for _ in 0..20 {
|
||||
assert!(std::hint::black_box(&snapshot).matches(std::hint::black_box(&session), 0));
|
||||
}
|
||||
|
||||
eprintln!("20 unchanged snapshot comparisons, 4K normal + AO (256 MiB): {:?}", start.elapsed());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn collecting_the_last_result_requests_a_frame_to_display_it() {
|
||||
let session = test_session().unwrap();
|
||||
let target = ThumbTarget::Content { layer: session.selected_layer().unwrap(), channel: Channel::BaseColor };
|
||||
let (mut service, jobs, results) = held_worker();
|
||||
service.begin_frame(&session, 0.0);
|
||||
service.get(&session, target);
|
||||
assert!(service.poll(&session));
|
||||
let job = jobs.try_recv().unwrap();
|
||||
results.send(Done { generation: job.generation, target, image: job.snapshot.render(target) }).unwrap();
|
||||
|
||||
service.begin_frame(&session, 0.1);
|
||||
assert!(service.get(&session, target).image.is_none());
|
||||
let repaint = service.poll(&session);
|
||||
|
||||
assert!(service.is_fresh(target));
|
||||
assert!(repaint, "the frame drew before collecting the final thumbnail");
|
||||
service.begin_frame(&session, 0.2);
|
||||
assert!(service.get(&session, target).image.is_some());
|
||||
assert!(!service.poll(&session), "an idle cache must stop repainting");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_stopped_worker_retries_visible_targets_inline() {
|
||||
let session = test_session().unwrap();
|
||||
let target = ThumbTarget::Content { layer: session.selected_layer().unwrap(), channel: Channel::BaseColor };
|
||||
let (mut service, jobs, results) = held_worker();
|
||||
service.begin_frame(&session, 0.0);
|
||||
service.get(&session, target);
|
||||
service.poll(&session);
|
||||
|
||||
// Simulate a worker that stops with a dispatched request still outstanding
|
||||
drop(jobs);
|
||||
drop(results);
|
||||
for frame in 1..=4 {
|
||||
service.begin_frame(&session, f64::from(frame));
|
||||
service.get(&session, target);
|
||||
service.poll(&session);
|
||||
}
|
||||
|
||||
assert!(service.get(&session, target).image.is_some());
|
||||
assert!(!service.busy());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn edits_keep_worker_jobs_and_retained_snapshots_bounded() {
|
||||
let mut session = test_session().unwrap();
|
||||
let layer = session.selected_layer().unwrap();
|
||||
let target = ThumbTarget::Content { layer, channel: Channel::BaseColor };
|
||||
let (mut service, jobs, results) = held_worker();
|
||||
let mut snapshots = Vec::new();
|
||||
|
||||
// Hold the worker's receiver still while repeated edits each produce a new snapshot
|
||||
for revision in 0..2_000 {
|
||||
session.doc.pixels.layer_mut(layer, Channel::BaseColor, (128, 128)).set(0, 0, &[revision, 0, 0, u16::MAX]);
|
||||
session.revision += 1;
|
||||
service.begin_frame(&session, f64::from(revision));
|
||||
snapshots.push(Arc::downgrade(service.snapshot.as_ref().unwrap()));
|
||||
service.get(&session, target);
|
||||
service.poll(&session);
|
||||
}
|
||||
|
||||
let queued: Vec<_> = jobs.try_iter().collect();
|
||||
let retained = snapshots.iter().filter(|snapshot| snapshot.strong_count() > 0).count();
|
||||
let retained_pixel_bytes: usize = snapshots.iter().filter_map(std::sync::Weak::upgrade).map(|snapshot| snapshot.pixels.bytes()).sum();
|
||||
eprintln!("2,000 edits: {} queued jobs, {retained} live snapshots, {retained_pixel_bytes} retained pixel bytes", queued.len());
|
||||
assert!(queued.len() <= IN_FLIGHT, "{} queued jobs bypassed the worker limit", queued.len());
|
||||
assert!(retained <= IN_FLIGHT + 1, "{retained} document snapshots retained across edits");
|
||||
assert!(retained_pixel_bytes <= (IN_FLIGHT + 1) * texturecraft_texel::TILE_AREA * 4 * std::mem::size_of::<u16>());
|
||||
|
||||
// Finishing stale work frees a slot for the newest document, without caching old results
|
||||
for job in queued {
|
||||
results.send(Done { generation: job.generation, target: job.target, image: None }).unwrap();
|
||||
}
|
||||
|
||||
assert_eq!(snapshots.iter().filter(|snapshot| snapshot.strong_count() > 0).count(), 1, "completed jobs release stale snapshots");
|
||||
assert!(service.poll(&session));
|
||||
assert!(!service.is_fresh(target));
|
||||
let latest = jobs.try_recv().unwrap();
|
||||
assert_eq!(latest.generation, service.generation);
|
||||
results.send(Done { generation: latest.generation, target, image: latest.snapshot.render(target) }).unwrap();
|
||||
drop(latest);
|
||||
assert!(service.poll(&session));
|
||||
assert!(service.is_fresh(target));
|
||||
|
||||
let image = Arc::downgrade(service.cache.get(&target).unwrap().image.as_ref().unwrap());
|
||||
drop(service);
|
||||
|
||||
assert!(snapshots.iter().all(|snapshot| snapshot.upgrade().is_none()), "dropping the cache releases its last snapshot");
|
||||
assert!(image.upgrade().is_none(), "dropping the cache releases the rendered image");
|
||||
assert!(jobs.try_recv().is_err());
|
||||
}
|
||||
}
|
||||
+116
-20
@@ -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, StackTarget, Tool};
|
||||
use crate::{Result, Session, cmd};
|
||||
|
||||
pub fn specs() -> Vec<CommandSpec> {
|
||||
@@ -51,6 +53,15 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
always,
|
||||
material
|
||||
),
|
||||
cmd!(
|
||||
"tool.swapMaskValue",
|
||||
"Invert mask value",
|
||||
["Tools"],
|
||||
Some("X"),
|
||||
"{} — mask value becomes 1 − value: switch the brush between adding to and removing from the mask",
|
||||
paints_mask,
|
||||
swap_mask_value
|
||||
),
|
||||
cmd!(
|
||||
"tool.stencil",
|
||||
"Projection stencil",
|
||||
@@ -69,7 +80,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 +100,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> {
|
||||
@@ -252,6 +282,30 @@ fn material(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
}))
|
||||
}
|
||||
|
||||
/// Whether strokes paint the selected layer's mask: the mask itself or one of its effects
|
||||
fn paints_mask(session: &Session) -> std::result::Result<(), String> {
|
||||
session.selected_layer().ok_or("no layer selected")?;
|
||||
|
||||
let project = &session.doc.project;
|
||||
let targets_mask = match session.target {
|
||||
StackTarget::Content => false,
|
||||
StackTarget::Mask => true,
|
||||
StackTarget::Effect(effect_id) => project
|
||||
.effect(effect_id)
|
||||
.and_then(|(owner, _)| project.layers.get(&owner))
|
||||
.is_some_and(|owner_layer| !owner_layer.content_effects.iter().any(|effect| effect.id == effect_id)),
|
||||
};
|
||||
|
||||
if targets_mask { Ok(()) } else { Err("select a mask to paint on".into()) }
|
||||
}
|
||||
|
||||
fn swap_mask_value(session: &mut Session, _: &Value) -> Result<Value> {
|
||||
session.tool.mask_value = 1.0 - session.tool.mask_value;
|
||||
session.revision = session.revision.wrapping_add(1);
|
||||
|
||||
Ok(json!({ "maskValue": session.tool.mask_value }))
|
||||
}
|
||||
|
||||
fn stencil(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
if boolp(p, "clear") == Some(true) {
|
||||
s.tool.stencil = None;
|
||||
@@ -319,13 +373,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 +439,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,29 @@
|
||||
//! 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_perf;
|
||||
mod path_tool;
|
||||
mod perf;
|
||||
mod polygon_fill;
|
||||
mod project_recovery;
|
||||
mod sample;
|
||||
mod thumbs;
|
||||
mod tools;
|
||||
mod udim;
|
||||
mod uv_strokes;
|
||||
File renamed without changes.
File renamed without changes.
Loaded 100 of 265 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user