mirror of
https://github.com/storytold/texturecraft.git
synced 2026-11-19 05:50:43 +01:00
Cook MCMAT v3 linked materials at the texture set resolution (#644)
* Cook MCMAT v3 linked fills through MaterialCraft * Install bounded material bakes at the original drop target
This commit is contained in:
1 parent
92287470e2
commit
68b579f0c8
33 files changed
+1947
-738
No files matched your search
Generated
+79
-12
@@ -578,7 +578,7 @@ dependencies = [
|
||||
"maybe-owned",
|
||||
"rustix 1.1.5",
|
||||
"rustix-linux-procfs",
|
||||
"windows-sys 0.60.2",
|
||||
"windows-sys 0.61.2",
|
||||
"winx",
|
||||
]
|
||||
|
||||
@@ -746,6 +746,12 @@ dependencies = [
|
||||
"libc",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "core_detect"
|
||||
version = "1.0.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7f8f80099a98041a3d1622845c271458a2d73e688351bf3cb999266764b81d48"
|
||||
|
||||
[[package]]
|
||||
name = "cpufeatures"
|
||||
version = "0.2.17"
|
||||
@@ -827,9 +833,9 @@ dependencies = [
|
||||
[[package]]
|
||||
name = "craft-mcmat"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=c376774f15ae7cd3b06a7ac664f01a8645af4b83#c376774f15ae7cd3b06a7ac664f01a8645af4b83"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=7a7a18cb40ac4cd5fca29c0dc224ac5178d40a89#7a7a18cb40ac4cd5fca29c0dc224ac5178d40a89"
|
||||
dependencies = [
|
||||
"craft-zip 0.1.0 (git+https://github.com/storytold/craft-libs?rev=c376774f15ae7cd3b06a7ac664f01a8645af4b83)",
|
||||
"craft-zip 0.1.0 (git+https://github.com/storytold/craft-libs?rev=7a7a18cb40ac4cd5fca29c0dc224ac5178d40a89)",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"thiserror 2.0.21",
|
||||
@@ -978,6 +984,16 @@ dependencies = [
|
||||
"zip",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-zip"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=7a7a18cb40ac4cd5fca29c0dc224ac5178d40a89#7a7a18cb40ac4cd5fca29c0dc224ac5178d40a89"
|
||||
dependencies = [
|
||||
"flate2",
|
||||
"thiserror 2.0.21",
|
||||
"zip",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-zip"
|
||||
version = "0.1.0"
|
||||
@@ -1336,6 +1352,20 @@ dependencies = [
|
||||
"serde",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "encoding_rs"
|
||||
version = "0.8.44"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "89253175e704ab869b04f9db224d38630e0211a53841a79181deae0889e169f5"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"core_detect",
|
||||
"multiversion_no_op",
|
||||
"rustversion",
|
||||
"scopeguard",
|
||||
"simdutf8",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "endi"
|
||||
version = "1.1.1"
|
||||
@@ -1419,7 +1449,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
|
||||
dependencies = [
|
||||
"libc",
|
||||
"windows-sys 0.60.2",
|
||||
"windows-sys 0.61.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -2652,9 +2682,21 @@ dependencies = [
|
||||
"objc2-foundation 0.3.2",
|
||||
"png",
|
||||
"thiserror 2.0.21",
|
||||
"windows-sys 0.60.2",
|
||||
"windows-sys 0.61.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "multiversion_no_op"
|
||||
version = "1.0.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "743fb55ba31b18fb1ecef6bdc9aa2743314978ac084044301a7eee33fb99a20d"
|
||||
|
||||
[[package]]
|
||||
name = "mutants"
|
||||
version = "0.0.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "add0ac067452ff1aca8c5002111bd6b1c895baee6e45fcbc44e0193aea17be56"
|
||||
|
||||
[[package]]
|
||||
name = "naga"
|
||||
version = "30.0.1"
|
||||
@@ -3176,7 +3218,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7d8fae84b431384b68627d0f9b3b1245fcf9f46f6c0e3dc902e9dce64edd1967"
|
||||
dependencies = [
|
||||
"libc",
|
||||
"windows-sys 0.60.2",
|
||||
"windows-sys 0.61.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -3469,6 +3511,23 @@ dependencies = [
|
||||
"unicode-ident",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "processkit"
|
||||
version = "3.3.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "1549b59abbe4fc78aa39860e36c81da89262c1278679b8f7299ef4ad7668c004"
|
||||
dependencies = [
|
||||
"async-trait",
|
||||
"encoding_rs",
|
||||
"libc",
|
||||
"mutants",
|
||||
"thiserror 2.0.21",
|
||||
"tokio",
|
||||
"tokio-stream",
|
||||
"tokio-util",
|
||||
"windows-sys 0.61.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "profiling"
|
||||
version = "1.0.18"
|
||||
@@ -3820,7 +3879,7 @@ dependencies = [
|
||||
"errno",
|
||||
"libc",
|
||||
"linux-raw-sys 0.12.1",
|
||||
"windows-sys 0.60.2",
|
||||
"windows-sys 0.61.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -3887,7 +3946,7 @@ dependencies = [
|
||||
"security-framework",
|
||||
"security-framework-sys",
|
||||
"webpki-root-certs",
|
||||
"windows-sys 0.60.2",
|
||||
"windows-sys 0.61.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -4240,7 +4299,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c3d1e2c7f27f8d4cb10542a02c49005dbd6e93095799d6f3be745fae9f8fedd4"
|
||||
dependencies = [
|
||||
"libc",
|
||||
"windows-sys 0.60.2",
|
||||
"windows-sys 0.61.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -4355,7 +4414,7 @@ dependencies = [
|
||||
"getrandom 0.4.3",
|
||||
"once_cell",
|
||||
"rustix 1.1.5",
|
||||
"windows-sys 0.60.2",
|
||||
"windows-sys 0.61.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -4459,10 +4518,13 @@ version = "0.6.1"
|
||||
dependencies = [
|
||||
"epaint_default_fonts",
|
||||
"image",
|
||||
"processkit",
|
||||
"rayon",
|
||||
"rustix 1.1.5",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"sysinfo",
|
||||
"tempfile",
|
||||
"texturecraft-bake",
|
||||
"texturecraft-compose",
|
||||
"texturecraft-core",
|
||||
@@ -4471,6 +4533,7 @@ dependencies = [
|
||||
"texturecraft-paint",
|
||||
"texturecraft-texel",
|
||||
"thiserror 2.0.21",
|
||||
"tokio",
|
||||
"zip",
|
||||
]
|
||||
|
||||
@@ -4479,6 +4542,7 @@ name = "texturecraft-formats"
|
||||
version = "0.6.1"
|
||||
dependencies = [
|
||||
"base64 0.22.1",
|
||||
"bytemuck",
|
||||
"craft-cms",
|
||||
"craft-materialx",
|
||||
"craft-mcmat",
|
||||
@@ -4493,6 +4557,7 @@ dependencies = [
|
||||
"half",
|
||||
"image",
|
||||
"lz4_flex",
|
||||
"png",
|
||||
"quick-xml 0.41.0",
|
||||
"rayon",
|
||||
"serde",
|
||||
@@ -4710,6 +4775,7 @@ dependencies = [
|
||||
"libc",
|
||||
"mio",
|
||||
"pin-project-lite",
|
||||
"signal-hook-registry",
|
||||
"socket2",
|
||||
"tokio-macros",
|
||||
"windows-sys 0.61.2",
|
||||
@@ -4735,6 +4801,7 @@ dependencies = [
|
||||
"futures-core",
|
||||
"pin-project-lite",
|
||||
"tokio",
|
||||
"tokio-util",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -4879,7 +4946,7 @@ checksum = "f2f6fb2847f6742cd76af783a2a2c49e9375d0a111c7bef6f71cd9e738c72d6e"
|
||||
dependencies = [
|
||||
"memoffset",
|
||||
"tempfile",
|
||||
"windows-sys 0.60.2",
|
||||
"windows-sys 0.61.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -5474,7 +5541,7 @@ version = "0.1.11"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
|
||||
dependencies = [
|
||||
"windows-sys 0.60.2",
|
||||
"windows-sys 0.61.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
|
||||
+1
-1
@@ -74,7 +74,7 @@ craft-tcraft = { git = "https://github.com/storytold/craft-libs", rev = "c376774
|
||||
craft-zip-usdz = { package = "craft-zip", git = "https://github.com/storytold/craft-libs", rev = "5631e99fe126cffb74c673eb458db04299f2bb9b" }
|
||||
craft-zip = { git = "https://github.com/storytold/craft-libs", rev = "c376774f15ae7cd3b06a7ac664f01a8645af4b83" }
|
||||
craft-mesh = { git = "https://github.com/storytold/craft-libs", rev = "70e562aa88436b6b79a997215b4fa4f6a6b1838a", default-features = false, features = ["stl", "ply", "fbx", "obj", "gltf"] }
|
||||
craft-mcmat = { git = "https://github.com/storytold/craft-libs", rev = "c376774f15ae7cd3b06a7ac664f01a8645af4b83" }
|
||||
craft-mcmat = { git = "https://github.com/storytold/craft-libs", rev = "7a7a18cb40ac4cd5fca29c0dc224ac5178d40a89" }
|
||||
# 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 = "390fe98b0dd3fb84db7c3af7cbd958db4e8cc585", features = ["egui"] }
|
||||
# Release checks, the update prompt and the update helper (crates/ui-egui/src/updates_ui.rs).
|
||||
|
||||
@@ -22,6 +22,16 @@ serde = { workspace = true }
|
||||
serde_json = { workspace = true }
|
||||
thiserror = { workspace = true }
|
||||
|
||||
[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
|
||||
tempfile = "3"
|
||||
|
||||
[target.'cfg(any(target_os = "macos", target_os = "freebsd"))'.dependencies]
|
||||
sysinfo = { workspace = true }
|
||||
|
||||
[target.'cfg(windows)'.dependencies]
|
||||
processkit = { version = "3.3.4", default-features = false, features = ["limits"] }
|
||||
tokio = { workspace = true }
|
||||
|
||||
[target.'cfg(unix)'.dependencies]
|
||||
rustix = { workspace = true }
|
||||
|
||||
|
||||
@@ -2,6 +2,8 @@
|
||||
//! web; path-based commands are native only.
|
||||
|
||||
use std::borrow::Cow;
|
||||
use std::collections::BTreeMap;
|
||||
use std::sync::Arc;
|
||||
|
||||
use serde_json::{Value, json};
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
@@ -212,9 +214,20 @@ impl Session {
|
||||
Ok(s)
|
||||
}
|
||||
|
||||
/// The project as a `ProjectFile` (for saving).
|
||||
/// The project with independently owned resource bytes.
|
||||
pub fn project_file(&self) -> ProjectFile {
|
||||
let resources = self.doc.resources.iter().map(|(name, bytes)| (name.clone(), bytes.as_ref().clone())).collect();
|
||||
self.project_with_resources(resources)
|
||||
}
|
||||
|
||||
/// A save snapshot that shares immutable resource payloads with the document.
|
||||
pub fn project_snapshot(&self) -> ProjectFile<Arc<Vec<u8>>> {
|
||||
self.project_with_resources(self.doc.resources.clone())
|
||||
}
|
||||
|
||||
fn project_with_resources<Resource>(&self, resources: BTreeMap<String, Resource>) -> ProjectFile<Resource> {
|
||||
let mut pixels = self.doc.pixels.clone();
|
||||
|
||||
// Drop pixel images whose size no longer matches their texture set
|
||||
let size_of = |id: texturecraft_core::LayerId| {
|
||||
self.doc.project.locate(id).and_then(|(ts, _, _)| self.doc.project.texture_sets.get(ts)).map(TextureSet::size).or_else(|| {
|
||||
@@ -239,13 +252,14 @@ impl Session {
|
||||
cage,
|
||||
bake_paint: self.saved_bake_paint(),
|
||||
thumbnail: None,
|
||||
resources: self.doc.resources.iter().map(|(k, v)| (k.clone(), v.as_ref().clone())).collect(),
|
||||
resources,
|
||||
warnings: Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn to_project_bytes(&self) -> Result<Vec<u8>> {
|
||||
texturecraft_formats::save_project_bytes(&self.project_file()).map_err(fe)
|
||||
let mut reservation = texturecraft_formats::RamReservation::for_save().map_err(fe)?;
|
||||
reservation.save_bytes(&self.project_snapshot()).map_err(fe)
|
||||
}
|
||||
|
||||
/// Render every export file for texture sets `sets` (in memory; works on the web).
|
||||
@@ -405,7 +419,9 @@ mod native {
|
||||
|
||||
pub fn save_to(s: &mut Session, path: &str, adopt: bool) -> Result<Value> {
|
||||
let path = if ext_of(path) == PROJECT_EXT { path.to_string() } else { format!("{path}.{PROJECT_EXT}") };
|
||||
texturecraft_formats::save_project(Path::new(&path), &s.project_file()).map_err(fe)?;
|
||||
let mut reservation = texturecraft_formats::RamReservation::for_save().map_err(fe)?;
|
||||
reservation.save(Path::new(&path), &s.project_snapshot()).map_err(fe)?;
|
||||
|
||||
if adopt {
|
||||
s.path = Some(path.clone());
|
||||
s.modified = false;
|
||||
|
||||
+258
-367
@@ -2,20 +2,37 @@
|
||||
//! channel sources are its cooked maps (image resources) and whose [`MaterialLink`] keeps the
|
||||
//! graph's exposed parameters. Changing one re-cooks the maps through `materialcraft-cli` at the
|
||||
//! texture set's resolution, with the set's baked mesh maps feeding graph inputs of the same name.
|
||||
//! The apps share the file format and the command line, not code.
|
||||
//! Both apps use the shared craft-mcmat container and the public CLI.
|
||||
|
||||
use std::sync::Arc;
|
||||
|
||||
use serde_json::{Map, Value, json};
|
||||
use texturecraft_core::{BakedMap, Channel, Fill, Layer, LayerId, LayerKind, LinkParam, MaterialLink, Source};
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
use texturecraft_formats::mcmat::MCMAT_EXT;
|
||||
use texturecraft_formats::mcmat::{MCRAFT_EXT, PortableMaterial, is_mcraft, read_mcmat};
|
||||
use texturecraft_core::{Channel, Fill, Layer, LayerId, LayerKind, LinkParam, MaterialLink, Source};
|
||||
use texturecraft_formats::RamReservation as CookReservation;
|
||||
use texturecraft_formats::mcmat::{MCRAFT_EXT, is_mcmat, is_mcraft, validate_mcmat_version};
|
||||
|
||||
use crate::commands::{CommandSpec, bad, boolp, has_layer, layer_param, strp};
|
||||
use crate::materials::Place;
|
||||
use crate::{EngineError, Result, Session, cmd};
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
mod cook_report;
|
||||
mod cooked_map;
|
||||
mod cooked_material;
|
||||
mod image_input;
|
||||
mod link_job;
|
||||
mod link_memory_budget;
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
mod map_file;
|
||||
mod material_interface;
|
||||
|
||||
pub use cooked_map::CookedMap;
|
||||
pub use cooked_material::CookedMaterial;
|
||||
pub use image_input::ImageInput;
|
||||
pub use link_job::LinkJob;
|
||||
pub use link_memory_budget::LinkMemoryBudget;
|
||||
pub use material_interface::MaterialInterface;
|
||||
|
||||
/// The undo label of parameter edits and re-cooks (a re-cook merges into the edit before it).
|
||||
const EDIT: &str = "Edit MaterialCraft material";
|
||||
|
||||
@@ -56,7 +73,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
"Save MaterialCraft package",
|
||||
[],
|
||||
None,
|
||||
"{layer?, path} — writes the MaterialCraft source (.mcraft or .sbs) behind a material layer",
|
||||
"{layer?, path} — writes the MaterialCraft source (.mcmat, .mcraft or .sbs) behind a material layer",
|
||||
has_layer,
|
||||
save_source
|
||||
),
|
||||
@@ -64,16 +81,16 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
}
|
||||
|
||||
/// The link of fill layer `id`.
|
||||
fn link_of(s: &Session, cmd: &str, id: LayerId) -> Result<MaterialLink> {
|
||||
match &s.doc.project.layer(id)?.kind {
|
||||
fn link_of(session: &Session, cmd: &str, id: LayerId) -> Result<MaterialLink> {
|
||||
match &session.doc.project.layer(id)?.kind {
|
||||
LayerKind::Fill(Fill { link: Some(link), .. }) => Ok(link.as_ref().clone()),
|
||||
_ => Err(bad(cmd, format!("layer {} is not a MaterialCraft material", id.0))),
|
||||
}
|
||||
}
|
||||
|
||||
/// Value types other apps may set (MaterialCraft's portable inputs), with their component count.
|
||||
fn components(t: &str) -> Option<usize> {
|
||||
Some(match t {
|
||||
fn components(parameter_type: &str) -> Option<usize> {
|
||||
Some(match parameter_type {
|
||||
"float" | "int" | "enum" | "bool" => 1,
|
||||
"float2" | "int2" => 2,
|
||||
"float3" => 3,
|
||||
@@ -82,41 +99,45 @@ fn components(t: &str) -> Option<usize> {
|
||||
})
|
||||
}
|
||||
|
||||
fn type_of(v: &Value) -> &str {
|
||||
v.get("t").and_then(Value::as_str).unwrap_or("")
|
||||
fn type_of(value: &Value) -> &str {
|
||||
value.get("t").and_then(Value::as_str).unwrap_or("")
|
||||
}
|
||||
|
||||
/// `v` (plain or `{t, v}`) as a typed value for `param`, with finite numbers.
|
||||
pub fn typed(param: &LinkParam, v: &Value) -> Option<Value> {
|
||||
let t = type_of(¶m.default);
|
||||
let n = components(t)?;
|
||||
let payload = if v.get("t").is_some() { v.get("v")? } else { v };
|
||||
let num = |x: &Value| x.as_f64().filter(|f| f.is_finite());
|
||||
let payload = match (t, payload) {
|
||||
("bool", Value::Bool(b)) => json!(b),
|
||||
("bool", x) => json!(num(x)? != 0.0),
|
||||
/// Convert a plain or tagged value to the parameter type, rejecting non-finite numbers.
|
||||
pub fn typed(parameter: &LinkParam, value: &Value) -> Option<Value> {
|
||||
let parameter_type = type_of(¶meter.default);
|
||||
let component_count = components(parameter_type)?;
|
||||
let payload = if value.get("t").is_some() { value.get("v")? } else { value };
|
||||
let finite = |value: &Value| value.as_f64().filter(|number| number.is_finite());
|
||||
|
||||
let payload = match (parameter_type, payload) {
|
||||
("bool", Value::Bool(enabled)) => json!(enabled),
|
||||
("bool", value) => json!(finite(value)? != 0.0),
|
||||
("color", Value::String(hex)) => {
|
||||
let h = hex.trim_start_matches('#');
|
||||
if h.len() != 6 || !h.bytes().all(|b| b.is_ascii_hexdigit()) {
|
||||
let digits = hex.trim_start_matches('#');
|
||||
if digits.len() != 6 || !digits.bytes().all(|byte| byte.is_ascii_hexdigit()) {
|
||||
return None;
|
||||
}
|
||||
let c = |i: usize| Some(f64::from(u8::from_str_radix(h.get(i..i + 2)?, 16).ok()?) / 255.0);
|
||||
// Hex colors are sRGB; values are linear.
|
||||
let lin = |x: f64| if x <= 0.04045 { x / 12.92 } else { ((x + 0.055) / 1.055).powf(2.4) };
|
||||
json!([lin(c(0)?), lin(c(2)?), lin(c(4)?), 1.0])
|
||||
|
||||
let component = |index: usize| Some(f64::from(u8::from_str_radix(digits.get(index..index + 2)?, 16).ok()?) / f64::from(u8::MAX));
|
||||
|
||||
// Convert the sRGB hex input to linear parameter values
|
||||
let linear = |value: f64| if value <= 0.04045 { value / 12.92 } else { ((value + 0.055) / 1.055).powf(2.4) };
|
||||
json!([linear(component(0)?), linear(component(2)?), linear(component(4)?), 1.0])
|
||||
}
|
||||
(_, x) if n == 1 => {
|
||||
let f = num(x)?;
|
||||
if matches!(t, "int" | "enum") { json!(f.round() as i64) } else { json!(f) }
|
||||
(_, value) if component_count == 1 => {
|
||||
let number = finite(value)?;
|
||||
if matches!(parameter_type, "int" | "enum") { json!(number.round() as i64) } else { json!(number) }
|
||||
}
|
||||
(_, Value::Array(a)) if a.len() >= n.min(3) => {
|
||||
let mut out: Vec<f64> = a.iter().take(n).map(num).collect::<Option<_>>()?;
|
||||
out.resize(n, 1.0);
|
||||
if t == "int2" { json!(out.iter().map(|f| f.round() as i64).collect::<Vec<_>>()) } else { json!(out) }
|
||||
(_, Value::Array(values)) if values.len() >= component_count.min(3) => {
|
||||
let mut numbers: Vec<f64> = values.iter().take(component_count).map(finite).collect::<Option<_>>()?;
|
||||
numbers.resize(component_count, 1.0);
|
||||
if parameter_type == "int2" { json!(numbers.iter().map(|number| number.round() as i64).collect::<Vec<_>>()) } else { json!(numbers) }
|
||||
}
|
||||
_ => return None,
|
||||
};
|
||||
Some(json!({"t": t, "v": payload}))
|
||||
|
||||
Some(json!({"t": parameter_type, "v": payload}))
|
||||
}
|
||||
|
||||
/// `overrides` checked against the link's parameters.
|
||||
@@ -144,7 +165,8 @@ fn preset(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let name = strp(p, "name").ok_or_else(|| bad(CMD, "`name` is required"))?;
|
||||
let link = link_of(s, CMD, id)?;
|
||||
let values = link.presets.iter().find(|pr| pr.name == name).ok_or_else(|| bad(CMD, format!("`{}` has no preset `{name}`", link.name)))?.values.clone();
|
||||
// Presets may name inputs the painter can't set; those stay as cooked.
|
||||
|
||||
// Leave values the painter cannot set unchanged
|
||||
let values = values.into_iter().filter(|(k, _)| link.params.iter().any(|p| p.id == *k));
|
||||
update(s, CMD, id, values, boolp(p, "cook").unwrap_or(true))
|
||||
}
|
||||
@@ -156,6 +178,7 @@ fn update(s: &mut Session, cmd: &str, id: LayerId, overrides: impl IntoIterator<
|
||||
if cook_now {
|
||||
return cook(s, id, values);
|
||||
}
|
||||
|
||||
s.edit(EDIT, |s| {
|
||||
if let LayerKind::Fill(Fill { link: Some(link), .. }) = &mut s.doc.project.layer_mut(id)?.kind {
|
||||
for p in &mut link.params {
|
||||
@@ -171,8 +194,8 @@ fn update(s: &mut Session, cmd: &str, id: LayerId, overrides: impl IntoIterator<
|
||||
|
||||
fn cook(s: &mut Session, id: LayerId, overrides: Map<String, Value>) -> Result<Value> {
|
||||
let job = s.link_job(id, &overrides)?;
|
||||
let bytes = job.run()?;
|
||||
s.apply_link_cook(id, &bytes, false)?;
|
||||
let material = job.run()?;
|
||||
s.apply_link_cook(id, &material, false)?;
|
||||
Ok(json!({"layer": id.0, "cooked": true, "size": job.size}))
|
||||
}
|
||||
|
||||
@@ -194,33 +217,13 @@ fn save_source(_: &mut Session, _: &Value) -> Result<Value> {
|
||||
Err(EngineError::Other("file paths are not available in the browser".into()))
|
||||
}
|
||||
|
||||
/// A re-cook of a linked layer, to run anywhere (a worker thread) and hand back to
|
||||
/// [`Session::apply_link_cook`].
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct LinkJob {
|
||||
pub layer: LayerId,
|
||||
pub package: Arc<Vec<u8>>,
|
||||
/// The source package extension (`mcraft` or `sbs`).
|
||||
pub source_ext: &'static str,
|
||||
/// The named graph in a linked material; direct package imports use its default.
|
||||
pub graph: Option<String>,
|
||||
/// Pixels across (the texture set's resolution).
|
||||
pub size: u32,
|
||||
/// Every parameter's value, by id, in MaterialCraft's typed form.
|
||||
pub values: Map<String, Value>,
|
||||
/// Graph inputs fed from baked mesh maps: identifier → 16-bit PNG.
|
||||
pub inputs: Vec<(String, Vec<u8>)>,
|
||||
}
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
static NEXT_JOB: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
|
||||
|
||||
/// A MaterialCraft executable: `$<env>`, else next to this program, else `name` on `PATH`.
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
pub fn materialcraft_tool(name: &str, env: &str) -> std::path::PathBuf {
|
||||
if let Some(p) = std::env::var_os(env).filter(|p| !p.is_empty()) {
|
||||
return p.into();
|
||||
}
|
||||
|
||||
let exe = format!("{name}{}", std::env::consts::EXE_SUFFIX);
|
||||
std::env::current_exe().ok().and_then(|e| Some(e.parent()?.join(&exe))).filter(|p| p.is_file()).unwrap_or_else(|| exe.into())
|
||||
}
|
||||
@@ -235,7 +238,7 @@ fn quiet(program: &std::path::Path) -> std::process::Command {
|
||||
c
|
||||
}
|
||||
|
||||
/// Open `package` (a `.mcraft` or `.sbs` file) in the MaterialCraft app (`$MATERIALCRAFT`, next to this
|
||||
/// Open `package` (a published material or authoring package) in the MaterialCraft app (`$MATERIALCRAFT`, next to this
|
||||
/// program, or on `PATH`).
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
pub fn open_in_materialcraft(package: &std::path::Path) -> Result<()> {
|
||||
@@ -247,170 +250,185 @@ pub fn open_in_materialcraft(package: &std::path::Path) -> Result<()> {
|
||||
|
||||
/// Source file extensions are chosen from the linked resource name, never an untrusted path.
|
||||
pub fn source_extension(name: &str) -> &'static str {
|
||||
if name.to_ascii_lowercase().ends_with(".sbs") { "sbs" } else { MCRAFT_EXT }
|
||||
}
|
||||
|
||||
impl LinkJob {
|
||||
/// Cook through `materialcraft-cli` (`$MATERIALCRAFT_CLI`, next to this program, or on
|
||||
/// `PATH`); returns `.mcmat` bytes. Blocks for the cook (about a second at 2K).
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
pub fn run(&self) -> Result<Vec<u8>> {
|
||||
self.run_with_cli(&materialcraft_tool("materialcraft-cli", "MATERIALCRAFT_CLI"))
|
||||
}
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
fn run_with_cli(&self, cli: &std::path::Path) -> Result<Vec<u8>> {
|
||||
let other = |e: String| EngineError::Other(e);
|
||||
let n = NEXT_JOB.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
|
||||
let dir = std::env::temp_dir().join(format!("texturecraft-link-{}-{n}", std::process::id()));
|
||||
std::fs::create_dir_all(&dir).map_err(|e| other(format!("{}: {e}", dir.display())))?;
|
||||
let result = (|| {
|
||||
let utf8 = |p: &std::path::Path| p.to_str().map(str::to_string).ok_or_else(|| other(format!("{} is not a UTF-8 path", p.display())));
|
||||
let write = |name: &str, bytes: &[u8]| {
|
||||
let p = dir.join(name);
|
||||
std::fs::write(&p, bytes).map_err(|e| other(format!("{name}: {e}")))?;
|
||||
utf8(&p)
|
||||
};
|
||||
let ext = if self.source_ext == "sbs" { "sbs" } else { MCRAFT_EXT };
|
||||
let src = write(&format!("source.{ext}"), &self.package)?;
|
||||
let mut inputs = Map::new();
|
||||
for (i, (id, png)) in self.inputs.iter().enumerate() {
|
||||
inputs.insert(id.clone(), json!(write(&format!("input{i}.png"), png)?));
|
||||
}
|
||||
let out = dir.join(format!("out.{MCMAT_EXT}"));
|
||||
let params = json!({"path": utf8(&out)?, "size": self.size, "values": self.values, "inputs": inputs});
|
||||
let mut command = quiet(cli);
|
||||
if let Some(graph) = &self.graph {
|
||||
// Opening the source starts on its first graph; select the graph saved in the link.
|
||||
let script = json!({"open": src, "steps": [
|
||||
{"id": "graph.open", "params": {"graph": graph}},
|
||||
{"id": "file.exportMaterial", "params": params},
|
||||
]});
|
||||
let script_path = write("cook.json", script.to_string().as_bytes())?;
|
||||
command.arg("batch").arg(script_path);
|
||||
} else {
|
||||
command.arg("run").arg(&src).arg("file.exportMaterial").arg(params.to_string());
|
||||
}
|
||||
let run = command.output().map_err(|e| {
|
||||
other(format!(
|
||||
"MaterialCraft's command line ({}) did not start: {e}. Install MaterialCraft next to TextureCraft or set MATERIALCRAFT_CLI",
|
||||
cli.display()
|
||||
))
|
||||
})?;
|
||||
if !run.status.success() {
|
||||
return Err(other(format!("MaterialCraft could not cook the material: {}", String::from_utf8_lossy(&run.stderr).trim())));
|
||||
}
|
||||
std::fs::read(&out).map_err(|e| other(format!("{}: {e}", out.display())))
|
||||
})();
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
result
|
||||
}
|
||||
|
||||
#[cfg(target_arch = "wasm32")]
|
||||
pub fn run(&self) -> Result<Vec<u8>> {
|
||||
Err(EngineError::Other("re-cooking a MaterialCraft material needs its command line, which the browser can't run".into()))
|
||||
if name.to_ascii_lowercase().ends_with(".mcmat") {
|
||||
"mcmat"
|
||||
} else if name.to_ascii_lowercase().ends_with(".sbs") {
|
||||
"sbs"
|
||||
} else {
|
||||
MCRAFT_EXT
|
||||
}
|
||||
}
|
||||
|
||||
/// Most texels one map may have: 8192 x 8192, the largest texture set. Decoded as RGBA f32 that is
|
||||
/// 1 GiB, so without this a single 16384 x 16384 map (a tiny PNG) would decode to 4 GiB.
|
||||
const MAX_MAP_TEXELS: u64 = texturecraft_formats::MAX_RESOURCE_TEXELS;
|
||||
/// Most texels all of a material's maps may decode to together: nine 4096 x 4096 images (151 M texels).
|
||||
/// A decoded texel is an RGBA `f32` (16 bytes) and the decoded maps stay in the session, so this holds one
|
||||
/// `.mcmat` to about 2.25 GiB of pixels however small the file is (a blank 8192 x 8192 PNG is a few hundred
|
||||
/// KiB). This is a per-import memory policy, not the number of supported channels. It fits nine 4K maps,
|
||||
/// or an 8K base colour with five 4K maps; larger imports are refused, never shrunk silently.
|
||||
const MAX_DECODED_TEXELS: u64 = 9 * 4096 * 4096;
|
||||
/// Prepare the first bake without borrowing the paint document. Its original archive is kept for future cooks.
|
||||
fn cook_source(
|
||||
bytes: Vec<u8>,
|
||||
size: u32,
|
||||
baked: Option<texturecraft_compose::BakedMaps>,
|
||||
mut budget: LinkMemoryBudget,
|
||||
canceled: Arc<std::sync::atomic::AtomicBool>,
|
||||
reservation: CookReservation,
|
||||
) -> Result<(LinkJob, CookedMaterial)> {
|
||||
check_source_size(bytes.len())?;
|
||||
budget.reserve(bytes.capacity() as u64)?;
|
||||
|
||||
/// Decode every map of `m` (validating them) with the channel it feeds. A usage listed more than
|
||||
/// once is decoded once (the last listing wins, as it did when each listing was painted over the
|
||||
/// one before), and the maps together stay within [`MAX_DECODED_TEXELS`], so a `.mcmat` can't
|
||||
/// multiply one small image into gigabytes of pixels.
|
||||
fn decoded_maps(m: &PortableMaterial) -> Result<Vec<(Channel, Vec<u8>, texturecraft_formats::DecodedImage)>> {
|
||||
decoded_maps_within(m, MAX_DECODED_TEXELS, MAX_MAP_TEXELS)
|
||||
let source_ext = if is_mcmat(&bytes) {
|
||||
validate_mcmat_version(&bytes, budget.remaining()).map_err(|error| EngineError::Other(error.to_string()))?;
|
||||
"mcmat"
|
||||
} else if is_mcraft(&bytes) {
|
||||
MCRAFT_EXT
|
||||
} else {
|
||||
return Err(EngineError::Other("expected a MaterialCraft material or project archive".into()));
|
||||
};
|
||||
|
||||
let job = LinkJob {
|
||||
layer: LayerId(0),
|
||||
package: Arc::new(bytes),
|
||||
source_ext,
|
||||
graph: None,
|
||||
size,
|
||||
values: Map::new(),
|
||||
input_identifiers: Vec::new(),
|
||||
baked,
|
||||
budget,
|
||||
canceled,
|
||||
};
|
||||
let material = job.run_reserved(reservation)?;
|
||||
Ok((job, material))
|
||||
}
|
||||
|
||||
/// Decode the maps of `m` (one per usage, the last listing wins) within a total budget of `max_texels`,
|
||||
/// each map at most `max_map_texels`. The size of each map is checked from its header before decoding: a
|
||||
/// map over its limit, or one that no longer fits in what is left of the budget, is refused with an error
|
||||
/// that names the map.
|
||||
fn decoded_maps_within(m: &PortableMaterial, max_texels: u64, max_map_texels: u64) -> Result<Vec<(Channel, Vec<u8>, texturecraft_formats::DecodedImage)>> {
|
||||
let listed: Vec<(Channel, &Vec<u8>)> =
|
||||
m.maps.iter().filter_map(|(usage, bytes)| Some((Channel::ALL.into_iter().find(|c| c.id() == usage)?, bytes))).collect();
|
||||
let mut left = max_texels;
|
||||
let mut out = Vec::new();
|
||||
for (i, (c, bytes)) in listed.iter().enumerate() {
|
||||
if listed.iter().skip(i + 1).any(|(later, _)| later == c) {
|
||||
continue;
|
||||
}
|
||||
let img = texturecraft_formats::decode_image_within(bytes, left.min(max_map_texels)).map_err(|e| EngineError::Other(format!("{} map: {e}", c.id())))?;
|
||||
left = left.saturating_sub(u64::from(img.width) * u64::from(img.height));
|
||||
out.push((*c, (*bytes).clone(), img));
|
||||
fn check_source_size(bytes: usize) -> Result<()> {
|
||||
let limit = crate::resource_cmds::MAX_BYTES;
|
||||
if bytes > limit {
|
||||
return Err(EngineError::Other(format!("linked source exceeds the project resource limit of {} MiB", limit >> 20)));
|
||||
}
|
||||
Ok(out)
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// File extensions for initial linked-material imports.
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
pub fn is_link_file(path: &std::path::Path) -> bool {
|
||||
path.extension()
|
||||
.and_then(|extension| extension.to_str())
|
||||
.is_some_and(|extension| extension.eq_ignore_ascii_case("mcmat") || extension.eq_ignore_ascii_case(MCRAFT_EXT))
|
||||
}
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
pub fn cook_link_file(
|
||||
path: &std::path::Path,
|
||||
size: u32,
|
||||
baked: Option<texturecraft_compose::BakedMaps>,
|
||||
budget: LinkMemoryBudget,
|
||||
canceled: Arc<std::sync::atomic::AtomicBool>,
|
||||
) -> Result<(LinkJob, CookedMaterial)> {
|
||||
let reservation = CookReservation::for_cook().map_err(|error| EngineError::Other(error.to_string()))?;
|
||||
let metadata = std::fs::metadata(path).map_err(|error| bad("material.load", format!("cannot read {}: {error}", path.display())))?;
|
||||
budget.check(metadata.len())?;
|
||||
|
||||
let bytes = crate::resource_cmds::read_resource_file("material.load", path, budget.remaining().min(crate::resource_cmds::MAX_BYTES as u64))?;
|
||||
cook_source(bytes, size, baked, budget, canceled, reservation)
|
||||
}
|
||||
|
||||
impl Session {
|
||||
/// Add a MaterialCraft material (`.mcmat` bytes, or a `.mcraft` package cooked first) as a
|
||||
/// fill layer at `place` (one undo step). Returns the new layer.
|
||||
pub fn add_linked_material_bytes_at(&mut self, bytes: &[u8], place: Place) -> Result<LayerId> {
|
||||
let cooked;
|
||||
let bytes = if is_mcraft(bytes) {
|
||||
let ts = self.ts();
|
||||
let size = self.doc.project.texture_set(ts)?.resolution;
|
||||
let job = LinkJob {
|
||||
layer: LayerId(0),
|
||||
package: Arc::new(bytes.to_vec()),
|
||||
source_ext: MCRAFT_EXT,
|
||||
graph: None,
|
||||
size,
|
||||
values: Map::new(),
|
||||
inputs: Vec::new(),
|
||||
};
|
||||
cooked = job.run()?;
|
||||
cooked.as_slice()
|
||||
} else {
|
||||
bytes
|
||||
};
|
||||
let m = read_mcmat(bytes).map_err(|e| EngineError::Other(e.to_string()))?;
|
||||
let maps = decoded_maps(&m)?;
|
||||
if maps.is_empty() {
|
||||
return Err(EngineError::Other(format!("{} has no maps TextureCraft can paint with", m.manifest.name)));
|
||||
check_source_size(bytes.len())?;
|
||||
let ts = self.ts();
|
||||
let size = self.doc.project.texture_set(ts)?.resolution;
|
||||
let reservation = CookReservation::for_cook().map_err(|error| EngineError::Other(error.to_string()))?;
|
||||
let budget = self.link_memory_budget();
|
||||
budget.check(bytes.len() as u64)?;
|
||||
|
||||
let mut source = Vec::new();
|
||||
source.try_reserve_exact(bytes.len()).map_err(|error| EngineError::Other(format!("cannot allocate linked source: {error}")))?;
|
||||
source.extend_from_slice(bytes);
|
||||
let (job, material) = cook_source(source, size, self.doc.baked.get(&ts).cloned(), budget, Arc::default(), reservation)?;
|
||||
self.add_cooked_material(&material, job.package, job.source_ext, place)
|
||||
}
|
||||
|
||||
/// Install validated CLI output in one undo step. Keep the original source for future variations.
|
||||
pub fn add_cooked_material(&mut self, m: &CookedMaterial, source: Arc<Vec<u8>>, source_ext: &str, place: Place) -> Result<LayerId> {
|
||||
self.add_cooked_material_to_set(m, source, source_ext, self.ts(), place)
|
||||
}
|
||||
|
||||
/// Install a background import in the texture set selected when it started.
|
||||
pub fn add_cooked_material_to_set(&mut self, m: &CookedMaterial, source: Arc<Vec<u8>>, source_ext: &str, ts: usize, place: Place) -> Result<LayerId> {
|
||||
check_source_size(source.len())?;
|
||||
self.link_memory_budget().check(material_bytes(m).saturating_add(source.capacity() as u64))?;
|
||||
if m.maps.is_empty() {
|
||||
return Err(EngineError::Other(format!("{} has no maps TextureCraft can paint with", m.interface.name)));
|
||||
}
|
||||
|
||||
let label = format!("Add {}", m.manifest.name);
|
||||
let label = format!("Add {}", m.interface.name);
|
||||
let (id, names) = self.edit(&label, |s| {
|
||||
let ts = s.ts();
|
||||
let stem = texturecraft_formats::sanitize_resource_name(&m.manifest.name);
|
||||
let package = unique(s, &format!("{stem}.{}", source_extension(&m.manifest.source)));
|
||||
s.doc.resources.insert(package.clone(), Arc::new(m.source.clone()));
|
||||
let stem = texturecraft_formats::sanitize_resource_name(&m.interface.name);
|
||||
let ext = match source_ext {
|
||||
"mcmat" | "sbs" | "mcraft" => source_ext,
|
||||
_ => return Err(EngineError::Other("unknown linked source format".into())),
|
||||
};
|
||||
let package = unique(s, &stem, &format!(".{ext}"));
|
||||
s.doc.resources.insert(package.clone(), source);
|
||||
let link = MaterialLink {
|
||||
name: m.manifest.name.clone(),
|
||||
name: m.interface.name.clone(),
|
||||
package,
|
||||
graph: m.manifest.graph.clone(),
|
||||
params: m.manifest.parameters.iter().filter(|p| components(type_of(&p.default)).is_some()).cloned().collect(),
|
||||
presets: m.manifest.presets.clone(),
|
||||
inputs: m.manifest.inputs.iter().map(|i| i.identifier.clone()).collect(),
|
||||
size: m.manifest.size[0],
|
||||
graph: m.interface.graph.clone(),
|
||||
params: m.interface.parameters.iter().filter(|p| components(type_of(&p.default)).is_some()).cloned().collect(),
|
||||
presets: m.interface.presets.clone(),
|
||||
inputs: m.interface.inputs.iter().map(|i| i.identifier.clone()).collect(),
|
||||
size: m.size,
|
||||
};
|
||||
let mut fill = Fill { link: Some(Box::new(link)), ..Fill::default() };
|
||||
let names = put_maps(s, &stem, &maps, &mut fill);
|
||||
let names = put_maps(s, &stem, &m.maps, &mut fill);
|
||||
for c in fill.sources.keys() {
|
||||
crate::set_cmds::add_channel(s, ts, *c)?;
|
||||
}
|
||||
let channels: Vec<Channel> = fill.sources.keys().copied().collect();
|
||||
let lid = s.doc.project.alloc_id();
|
||||
let name = s.doc.project.next_layer_name(ts, &m.manifest.name);
|
||||
let lid = crate::layer_cmds::insert_selected(s, Layer::new(lid, name, LayerKind::Fill(fill), &channels))?;
|
||||
let name = s.doc.project.next_layer_name(ts, &m.interface.name);
|
||||
let layer = Layer::new(lid, name, LayerKind::Fill(fill), &channels);
|
||||
let lid = if ts == s.ts() { crate::layer_cmds::insert_selected(s, layer)? } else { s.doc.project.insert_layer(ts, layer, None, false)? };
|
||||
place.apply(s, lid)?;
|
||||
s.select_one(ts, lid);
|
||||
s.target = crate::session::StackTarget::Content;
|
||||
if ts == s.ts() {
|
||||
s.select_one(ts, lid);
|
||||
s.target = crate::session::StackTarget::Content;
|
||||
}
|
||||
Ok((lid, names))
|
||||
})?;
|
||||
self.cache_decoded(names, maps);
|
||||
self.cache_decoded(names, &m.maps);
|
||||
Ok(id)
|
||||
}
|
||||
|
||||
/// Account for existing encoded resources and decoded images when admitting a linked bake.
|
||||
pub fn link_memory_budget(&self) -> LinkMemoryBudget {
|
||||
#[cfg(target_arch = "wasm32")]
|
||||
let cap_bytes = u64::MAX;
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
let cap_bytes = texturecraft_formats::configured_ram_budget();
|
||||
let mut budget = LinkMemoryBudget::new(cap_bytes);
|
||||
let mut resources = std::collections::HashSet::new();
|
||||
let mut mesh_maps = std::collections::HashSet::new();
|
||||
let documents = std::iter::once(&self.doc).chain(self.undo.iter().chain(&self.redo).map(|(_, document)| document));
|
||||
let mut retained_bytes = 0u64;
|
||||
for document in documents {
|
||||
for bytes in document.resources.values().filter(|bytes| resources.insert(Arc::as_ptr(bytes))) {
|
||||
retained_bytes = retained_bytes.saturating_add(bytes.capacity() as u64);
|
||||
}
|
||||
|
||||
for data in document.baked.values().flat_map(|baked| baked.maps.values()).filter(|data| mesh_maps.insert(Arc::as_ptr(data))) {
|
||||
retained_bytes = retained_bytes.saturating_add(data.capacity() as u64 * std::mem::size_of::<f32>() as u64);
|
||||
}
|
||||
}
|
||||
|
||||
let mut images = std::collections::HashSet::new();
|
||||
for image in self.images.values().filter(|image| images.insert(Arc::as_ptr(image))) {
|
||||
retained_bytes = retained_bytes.saturating_add(image.rgba.capacity() as u64 * std::mem::size_of::<[f32; 4]>() as u64);
|
||||
}
|
||||
|
||||
budget.set_retained(retained_bytes);
|
||||
budget
|
||||
}
|
||||
|
||||
/// The source package behind linked layer `id`.
|
||||
pub fn link_package(&self, id: LayerId) -> Result<Arc<Vec<u8>>> {
|
||||
let link = link_of(self, "material.link", id)?;
|
||||
@@ -429,17 +447,6 @@ impl Session {
|
||||
let mut values = self.link_values(id)?;
|
||||
values.extend(overrides.clone());
|
||||
|
||||
let mut inputs = Vec::new();
|
||||
if let Some(baked) = self.doc.baked.get(&texture_set) {
|
||||
for identifier in &link.inputs {
|
||||
let Some((map, data)) = BakedMap::parse(identifier).and_then(|map| Some((map, baked.maps.get(&map)?))) else { continue };
|
||||
|
||||
let png = texturecraft_formats::mcmat::mesh_map_png(baked.resolution, map.components(), data)
|
||||
.map_err(|error| EngineError::Other(error.to_string()))?;
|
||||
inputs.push((identifier.clone(), png));
|
||||
}
|
||||
}
|
||||
|
||||
// UDIM tiles share one cook at the texture set's base resolution
|
||||
let size = self.doc.project.texture_set(texture_set)?.resolution;
|
||||
Ok(LinkJob {
|
||||
@@ -449,17 +456,18 @@ impl Session {
|
||||
graph: Some(link.graph.clone()),
|
||||
size,
|
||||
values,
|
||||
inputs,
|
||||
input_identifiers: link.inputs,
|
||||
baked: self.doc.baked.get(&texture_set).cloned(),
|
||||
budget: self.link_memory_budget(),
|
||||
canceled: Arc::default(),
|
||||
})
|
||||
}
|
||||
|
||||
/// Swap in maps a [`LinkJob`] cooked (`.mcmat` bytes) and the values they were cooked with.
|
||||
/// Install the maps and exposed values returned by a completed [`LinkJob`].
|
||||
/// With `merge`, this folds into the previous undo step when that was an edit of the same kind
|
||||
/// (a parameter set while the cook ran).
|
||||
pub fn apply_link_cook(&mut self, id: LayerId, bytes: &[u8], merge: bool) -> Result<()> {
|
||||
let material = read_mcmat(bytes).map_err(|error| EngineError::Other(error.to_string()))?;
|
||||
let maps = decoded_maps(&material)?;
|
||||
|
||||
pub fn apply_link_cook(&mut self, id: LayerId, material: &CookedMaterial, merge: bool) -> Result<()> {
|
||||
self.link_memory_budget().check(material_bytes(material))?;
|
||||
let names = self.edit_merging(EDIT, merge, |session| {
|
||||
let LayerKind::Fill(mut fill) = session.doc.project.layer(id)?.kind.clone() else {
|
||||
return Err(EngineError::Other(format!("layer {} is not a fill", id.0)));
|
||||
@@ -467,24 +475,25 @@ impl Session {
|
||||
|
||||
let link = fill.link.as_mut().ok_or_else(|| EngineError::Other(format!("layer {} is not a MaterialCraft material", id.0)))?;
|
||||
for parameter in &mut link.params {
|
||||
if let Some(cooked) = material.manifest.parameters.iter().find(|candidate| candidate.id == parameter.id) {
|
||||
if let Some(cooked) = material.interface.parameters.iter().find(|candidate| candidate.id == parameter.id) {
|
||||
parameter.value = cooked.value.clone();
|
||||
}
|
||||
}
|
||||
link.size = material.manifest.size[0];
|
||||
link.size = material.size;
|
||||
let stem = texturecraft_formats::sanitize_resource_name(&link.name);
|
||||
let old_names: Vec<String> =
|
||||
fill.sources.values().filter_map(|source| if let Source::Image { name, .. } = source { Some(name.clone()) } else { None }).collect();
|
||||
let names = put_maps(session, &stem, &maps, &mut fill);
|
||||
let names = put_maps(session, &stem, &material.maps, &mut fill);
|
||||
session.doc.project.layer_mut(id)?.kind = LayerKind::Fill(fill);
|
||||
|
||||
// Duplicated layers may still use the earlier maps
|
||||
let mut used_names = Vec::new();
|
||||
for set in 0..session.doc.project.texture_sets.len() {
|
||||
for root in session.doc.project.texture_sets.get(set).map(|texture_set| texture_set.stack.clone()).unwrap_or_default() {
|
||||
for texture_set in &session.doc.project.texture_sets {
|
||||
for &root in &texture_set.stack {
|
||||
crate::material_lib::images_used(&session.doc.project, root, &mut used_names, 0);
|
||||
}
|
||||
}
|
||||
|
||||
for name in old_names.iter().filter(|name| !used_names.contains(name)) {
|
||||
session.doc.resources.remove(name);
|
||||
}
|
||||
@@ -493,184 +502,66 @@ impl Session {
|
||||
})?;
|
||||
|
||||
// Reuse the validated maps before synchronization considers decoding missing images
|
||||
self.cache_decoded(names, maps);
|
||||
self.cache_decoded(names, &material.maps);
|
||||
self.sync_images();
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Keep the images decoded while validating maps instead of decoding them again.
|
||||
fn cache_decoded(&mut self, names: Vec<String>, maps: Vec<(Channel, Vec<u8>, texturecraft_formats::DecodedImage)>) {
|
||||
for (name, (_, _, img)) in names.into_iter().zip(maps) {
|
||||
self.images.insert(name, crate::resource_cmds::decoded(img));
|
||||
fn cache_decoded(&mut self, names: Vec<String>, maps: &[CookedMap]) {
|
||||
for (name, map) in names.into_iter().zip(maps) {
|
||||
self.images.insert(name, Arc::clone(&map.image));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A resource name not in use: `name`, else `2_name`, `3_name`…
|
||||
fn unique(s: &Session, name: &str) -> String {
|
||||
(1..).map(|n| if n == 1 { name.to_string() } else { format!("{n}_{name}") }).find(|n| !s.doc.resources.contains_key(n)).unwrap_or_else(|| name.to_string())
|
||||
fn material_bytes(material: &CookedMaterial) -> u64 {
|
||||
material.maps.iter().fold(0u64, |total, map| {
|
||||
total.saturating_add(map.bytes.capacity() as u64).saturating_add(map.image.rgba.capacity() as u64 * std::mem::size_of::<[f32; 4]>() as u64)
|
||||
})
|
||||
}
|
||||
|
||||
/// A resource name that preserves its suffix through a project round trip.
|
||||
fn unique(session: &Session, stem: &str, suffix: &str) -> String {
|
||||
for number in 1.. {
|
||||
let prefix = if number == 1 { String::new() } else { format!("{number}_") };
|
||||
let stem_limit = texturecraft_formats::MAX_RESOURCE_NAME_LEN.saturating_sub(prefix.len() + suffix.len());
|
||||
let stem = stem.get(..stem.len().min(stem_limit)).unwrap_or(stem);
|
||||
let name = format!("{prefix}{stem}{suffix}");
|
||||
if !session.doc.resources.contains_key(&name) {
|
||||
return name;
|
||||
}
|
||||
}
|
||||
|
||||
format!("{stem}{suffix}")
|
||||
}
|
||||
|
||||
/// Store `maps` as new resources (names carry a fresh id, so the decoded-image cache never
|
||||
/// confuses two cooks) and point `fill`'s channels at them. Returns the names, in map order.
|
||||
fn put_maps(s: &mut Session, stem: &str, maps: &[(Channel, Vec<u8>, texturecraft_formats::DecodedImage)], fill: &mut Fill) -> Vec<String> {
|
||||
fn put_maps(s: &mut Session, stem: &str, maps: &[CookedMap], fill: &mut Fill) -> Vec<String> {
|
||||
let cook = s.doc.project.alloc_id().0;
|
||||
let mut names = Vec::new();
|
||||
for (c, bytes, _) in maps {
|
||||
let name = unique(s, &format!("{stem}_{}_{cook}.png", c.id()));
|
||||
s.doc.resources.insert(name.clone(), Arc::new(bytes.clone()));
|
||||
// A normal map the user marked DirectX stays marked through re-cooks.
|
||||
let normal_format = match fill.sources.get(c) {
|
||||
for map in maps {
|
||||
let channel = map.channel;
|
||||
let extension = if map.bytes.starts_with(crate::resource_cmds::EXR_SIGNATURE) { "exr" } else { "png" };
|
||||
let name = unique(s, stem, &format!("_{}_{cook}.{extension}", channel.id()));
|
||||
s.doc.resources.insert(name.clone(), Arc::clone(&map.bytes));
|
||||
|
||||
// Preserve a normal convention the user chose for this layer
|
||||
let normal_format = match fill.sources.get(&channel) {
|
||||
Some(Source::Image { normal_format, .. }) => *normal_format,
|
||||
_ => Default::default(),
|
||||
};
|
||||
fill.sources.insert(*c, Source::Image { name: name.clone(), normal_format });
|
||||
fill.sources.insert(channel, Source::Image { name: name.clone(), normal_format });
|
||||
names.push(name);
|
||||
}
|
||||
|
||||
names
|
||||
}
|
||||
|
||||
#[cfg(all(test, unix))]
|
||||
mod subprocess_tests {
|
||||
use super::*;
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
|
||||
#[test]
|
||||
fn cook_uses_the_saved_graph_and_source_type_without_global_environment() {
|
||||
let id = NEXT_JOB.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
|
||||
let dir = std::env::temp_dir().join(format!("texturecraft-cook-test-{}-{id}", std::process::id()));
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
let cli = dir.join("materialcraft-cli");
|
||||
let script = r#"#!/bin/sh
|
||||
set -eu
|
||||
case "$1" in
|
||||
batch)
|
||||
grep -F '"graph":"Second"' "$2" >/dev/null
|
||||
grep -F '"id":"file.exportMaterial"' "$2" >/dev/null
|
||||
test -f "$(dirname "$2")/source.sbs"
|
||||
test -f "$(dirname "$2")/input0.png"
|
||||
cp "$(dirname "$0")/result.mcmat" "$(dirname "$2")/out.mcmat"
|
||||
;;
|
||||
run)
|
||||
test "$(basename "$2")" = "source.mcraft"
|
||||
cp "$(dirname "$0")/result.mcmat" "$(dirname "$2")/out.mcmat"
|
||||
;;
|
||||
*) exit 1 ;;
|
||||
esac
|
||||
"#;
|
||||
std::fs::write(&cli, script).unwrap();
|
||||
std::fs::set_permissions(&cli, std::fs::Permissions::from_mode(0o700)).unwrap();
|
||||
std::fs::write(dir.join("result.mcmat"), b"cooked").unwrap();
|
||||
let mut job = LinkJob {
|
||||
layer: LayerId(1),
|
||||
package: Arc::new(b"source".to_vec()),
|
||||
source_ext: "sbs",
|
||||
graph: Some("Second".into()),
|
||||
size: 64,
|
||||
values: Map::new(),
|
||||
inputs: vec![("curvature".into(), b"png".to_vec())],
|
||||
};
|
||||
assert_eq!(job.run_with_cli(&cli).unwrap(), b"cooked");
|
||||
job.graph = None;
|
||||
job.source_ext = "mcraft";
|
||||
assert_eq!(job.run_with_cli(&cli).unwrap(), b"cooked");
|
||||
job.graph = Some("wrong".into());
|
||||
assert!(job.run_with_cli(&cli).is_err());
|
||||
assert!(job.run_with_cli(&dir.join("missing")).is_err());
|
||||
let _ = std::fs::remove_dir_all(dir);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use texturecraft_formats::mcmat::{Manifest, MapEntry};
|
||||
|
||||
/// A blank `side` x `side` RGBA PNG, as bytes.
|
||||
fn png(side: u32) -> Vec<u8> {
|
||||
let mut out = Vec::new();
|
||||
image::RgbaImage::new(side, side).write_to(&mut std::io::Cursor::new(&mut out), image::ImageFormat::Png).unwrap();
|
||||
out
|
||||
}
|
||||
|
||||
/// A portable material that lists the given (usage, image bytes) maps in order.
|
||||
fn material(maps: Vec<(&str, Vec<u8>)>) -> PortableMaterial {
|
||||
let manifest = Manifest {
|
||||
format: "craft-material".into(),
|
||||
version: 1,
|
||||
name: "M".into(),
|
||||
graph: "M".into(),
|
||||
size: [4, 4],
|
||||
maps: maps.iter().map(|(usage, _)| MapEntry { usage: usage.to_string(), file: "m.png".into() }).collect(),
|
||||
parameters: vec![],
|
||||
inputs: vec![],
|
||||
presets: vec![],
|
||||
source: "source.mcraft".into(),
|
||||
};
|
||||
PortableMaterial { manifest, maps: maps.into_iter().map(|(u, b)| (u.to_string(), b)).collect(), source: vec![] }
|
||||
}
|
||||
|
||||
/// However many times one usage is listed, it is decoded only once.
|
||||
#[test]
|
||||
fn a_usage_listed_many_times_is_decoded_once() {
|
||||
let m = material((0..64).map(|_| ("baseColor", png(4))).collect());
|
||||
assert_eq!(decoded_maps(&m).unwrap().len(), 1, "64 listings of one usage, one decoded image");
|
||||
}
|
||||
|
||||
/// When a usage is listed twice, the later image is the one that is kept.
|
||||
#[test]
|
||||
fn the_last_listing_of_a_usage_wins() {
|
||||
let m = material(vec![("baseColor", png(4)), ("roughness", png(2)), ("baseColor", png(8))]);
|
||||
let maps = decoded_maps(&m).unwrap();
|
||||
let base = maps.iter().find(|(c, ..)| *c == Channel::BaseColor).unwrap();
|
||||
assert_eq!(base.2.width, 8);
|
||||
assert_eq!(maps.len(), 2);
|
||||
}
|
||||
|
||||
/// A single map over the per-map limit is refused even when the total budget would allow it; one exactly at it is kept.
|
||||
#[test]
|
||||
fn one_map_over_the_per_map_limit_is_refused_though_the_total_would_allow_it() {
|
||||
let m = material(vec![("baseColor", png(5))]);
|
||||
assert!(decoded_maps_within(&m, 1000, 24).is_err(), "25 texels over a per-map limit of 24, total 1000");
|
||||
assert_eq!(decoded_maps_within(&m, 1000, 25).unwrap().len(), 1, "exactly at the per-map limit");
|
||||
// The real limits: one map is at most 8192 x 8192, and the total holds nine maps at 4096 x 4096.
|
||||
assert_eq!(MAX_MAP_TEXELS, 8192 * 8192);
|
||||
assert_eq!(MAX_DECODED_TEXELS, 9 * 4096 * 4096);
|
||||
}
|
||||
|
||||
/// The maps together stay within the total budget, exactly: three 8 x 8 maps fit in 192 texels but not in 191.
|
||||
#[test]
|
||||
fn decoded_pixels_are_bounded_across_maps() {
|
||||
let m = material(vec![("baseColor", png(8)), ("roughness", png(8)), ("metallic", png(8))]);
|
||||
assert_eq!(decoded_maps_within(&m, 192, 64).unwrap().len(), 3, "at the budget");
|
||||
assert!(decoded_maps_within(&m, 191, 64).is_err(), "one texel under: the third map goes over");
|
||||
}
|
||||
/// Shared version-2/SBS parsing retains its behavior before duplicate decode filtering.
|
||||
#[test]
|
||||
fn shared_version_two_archive_keeps_sbs_and_decodes_repeated_usage_once() {
|
||||
use std::io::Write;
|
||||
|
||||
let manifest = serde_json::json!({
|
||||
"format": "craft-material", "version": 2, "name": "M", "graph": "Second", "size": [4, 4],
|
||||
"maps": (0..64).map(|_| serde_json::json!({"usage": "baseColor", "file": "maps/base.png"})).collect::<Vec<_>>(),
|
||||
"source": "source.sbs"
|
||||
});
|
||||
let mut archive = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));
|
||||
for (name, bytes) in [("material.json", manifest.to_string().into_bytes()), ("maps/base.png", png(4)), ("source.sbs", b"source package".to_vec())] {
|
||||
archive.start_file(name, zip::write::SimpleFileOptions::default()).unwrap();
|
||||
archive.write_all(&bytes).unwrap();
|
||||
}
|
||||
let material = read_mcmat(&archive.finish().unwrap().into_inner()).unwrap();
|
||||
assert_eq!(material.manifest.version, 2);
|
||||
assert_eq!(material.manifest.graph, "Second");
|
||||
assert_eq!(material.manifest.source, "source.sbs");
|
||||
assert_eq!(material.source, b"source package");
|
||||
let maps = decoded_maps(&material).unwrap();
|
||||
assert_eq!(maps.len(), 1);
|
||||
assert_eq!((maps[0].2.width, maps[0].2.height), (4, 4));
|
||||
}
|
||||
|
||||
use super::typed;
|
||||
use serde_json::json;
|
||||
use texturecraft_core::layer::LinkParam;
|
||||
|
||||
@@ -0,0 +1,8 @@
|
||||
use super::{MaterialInterface, map_file::MapFile};
|
||||
use serde::Deserialize;
|
||||
|
||||
#[derive(Deserialize)]
|
||||
pub(super) struct CookReport {
|
||||
pub(super) material: MaterialInterface,
|
||||
pub(super) maps: Vec<MapFile>,
|
||||
}
|
||||
@@ -0,0 +1,70 @@
|
||||
use std::sync::Arc;
|
||||
|
||||
use texturecraft_compose::ImageRes;
|
||||
use texturecraft_core::Channel;
|
||||
|
||||
use super::LinkMemoryBudget;
|
||||
use crate::{EngineError, Result};
|
||||
|
||||
/// A validated bake ready to install in the document and decoded-image cache.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct CookedMap {
|
||||
pub channel: Channel,
|
||||
pub bytes: Arc<Vec<u8>>,
|
||||
pub image: Arc<ImageRes>,
|
||||
}
|
||||
|
||||
impl CookedMap {
|
||||
pub(super) fn decoded_bytes(texels: u64) -> u64 {
|
||||
texels.saturating_mul(std::mem::size_of::<[f32; 4]>() as u64)
|
||||
}
|
||||
|
||||
pub(super) fn decoder_peak_bytes(texels: u64) -> u64 {
|
||||
// Native image samples can coexist with the linear-sized float output during expansion
|
||||
Self::decoded_bytes(texels).saturating_mul(2)
|
||||
}
|
||||
|
||||
pub fn decode(channel: Channel, bytes: Vec<u8>, size: [u32; 2], budget: &mut LinkMemoryBudget) -> Result<Self> {
|
||||
let texels = u64::from(size[0]) * u64::from(size[1]);
|
||||
if texels > texturecraft_formats::MAX_RESOURCE_TEXELS {
|
||||
return Err(EngineError::Other(format!("{} map exceeds the project resource limit", channel.id())));
|
||||
}
|
||||
|
||||
let encoded_bytes = bytes.capacity() as u64;
|
||||
let decoder_peak_bytes = Self::decoder_peak_bytes(texels);
|
||||
budget.check(encoded_bytes.saturating_add(decoder_peak_bytes))?;
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
budget.check_available(decoder_peak_bytes)?;
|
||||
|
||||
let decoder_bytes = budget.remaining().saturating_sub(encoded_bytes).saturating_sub(Self::decoded_bytes(texels));
|
||||
let image = texturecraft_formats::decode_cooked_image(&bytes, size, decoder_bytes)
|
||||
.map_err(|error| EngineError::Other(format!("{} map: {error}", channel.id())))?;
|
||||
if [image.width, image.height] != size {
|
||||
return Err(EngineError::Other(format!("{} map dimensions disagree with the export report", channel.id())));
|
||||
}
|
||||
|
||||
budget.reserve(encoded_bytes.saturating_add(Self::decoded_bytes(image.rgba.capacity() as u64)))?;
|
||||
Ok(Self { channel, bytes: Arc::new(bytes), image: crate::resource_cmds::decoded(image) })
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn each_retained_map_reduces_the_next_decoders_budget() {
|
||||
let bytes = texturecraft_formats::gray16_png(4, 4, [0.5; 16].into_iter()).unwrap();
|
||||
let copy = bytes.clone();
|
||||
let size = [4, 4];
|
||||
let first_bytes = copy.capacity() as u64 + CookedMap::decoded_bytes(16);
|
||||
let second_peak = bytes.capacity() as u64 + CookedMap::decoder_peak_bytes(16);
|
||||
let mut budget = LinkMemoryBudget::new(first_bytes + second_peak - 1);
|
||||
|
||||
let first = CookedMap::decode(Channel::Roughness, copy, size, &mut budget).unwrap();
|
||||
let second = CookedMap::decode(Channel::Metallic, bytes, size, &mut budget);
|
||||
|
||||
assert_eq!(first.image.rgba.len(), 16);
|
||||
assert!(second.unwrap_err().to_string().contains("configured cap"));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
use std::sync::Arc;
|
||||
|
||||
use super::{CookReservation, CookedMap, MaterialInterface};
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct CookedMaterial {
|
||||
pub interface: MaterialInterface,
|
||||
pub maps: Vec<CookedMap>,
|
||||
pub size: u32,
|
||||
// A queued result still owns its large buffers
|
||||
_reservation: Option<Arc<CookReservation>>,
|
||||
}
|
||||
|
||||
impl CookedMaterial {
|
||||
/// Assemble decoded maps without holding a CLI worker slot.
|
||||
pub fn new(interface: MaterialInterface, maps: Vec<CookedMap>, size: u32) -> Self {
|
||||
Self { interface, maps, size, _reservation: None }
|
||||
}
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
pub(super) fn with_reservation(mut self, reservation: CookReservation) -> Self {
|
||||
self._reservation = Some(Arc::new(reservation));
|
||||
self
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,4 @@
|
||||
#[derive(Clone, Debug, serde::Deserialize)]
|
||||
pub struct ImageInput {
|
||||
pub identifier: String,
|
||||
}
|
||||
@@ -0,0 +1,308 @@
|
||||
use std::sync::{Arc, atomic::AtomicBool};
|
||||
|
||||
use super::{CookReservation, CookedMaterial, EngineError, LinkMemoryBudget, Result};
|
||||
use serde_json::{Map, Value};
|
||||
use texturecraft_core::LayerId;
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
use {
|
||||
super::{CookedMap, MaterialInterface, cook_report::CookReport, materialcraft_tool, quiet},
|
||||
std::{io::Read, path::Path},
|
||||
texturecraft_core::{BakedMap, Channel},
|
||||
};
|
||||
|
||||
/// A re-cook of a linked layer, to run anywhere (a worker thread) and hand back to
|
||||
/// [`crate::Session::apply_link_cook`].
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct LinkJob {
|
||||
pub layer: LayerId,
|
||||
pub package: Arc<Vec<u8>>,
|
||||
/// The source package extension (`mcmat`, `mcraft` or `sbs`).
|
||||
pub source_ext: &'static str,
|
||||
/// The named graph in a linked material; direct package imports use its default.
|
||||
pub graph: Option<String>,
|
||||
/// Pixels across (the texture set's resolution).
|
||||
pub size: u32,
|
||||
/// Every parameter's value, by id, in MaterialCraft's typed form.
|
||||
pub values: Map<String, Value>,
|
||||
/// Graph inputs matched to mesh maps and encoded one at a time in the worker.
|
||||
pub input_identifiers: Vec<String>,
|
||||
pub(super) baked: Option<texturecraft_compose::BakedMaps>,
|
||||
pub(super) budget: LinkMemoryBudget,
|
||||
pub canceled: Arc<AtomicBool>,
|
||||
}
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
fn io(error: impl std::fmt::Display) -> EngineError {
|
||||
EngineError::Other(error.to_string())
|
||||
}
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
pub(super) fn read_bounded(path: &Path, limit: u64) -> Result<Vec<u8>> {
|
||||
let metadata = std::fs::symlink_metadata(path).map_err(io)?;
|
||||
if !metadata.is_file() || metadata.len() > limit {
|
||||
return Err(io(format!("invalid or oversized cook output: {}", path.display())));
|
||||
}
|
||||
|
||||
let mut bytes = Vec::new();
|
||||
let capacity = usize::try_from(metadata.len()).map_err(io)?;
|
||||
bytes.try_reserve_exact(capacity).map_err(io)?;
|
||||
#[cfg(unix)]
|
||||
let mut file = {
|
||||
use rustix::fs::{Mode, OFlags, open};
|
||||
|
||||
// The generated output must stay a regular file between inspection and open
|
||||
let descriptor = open(path, OFlags::RDONLY | OFlags::NONBLOCK | OFlags::NOFOLLOW | OFlags::CLOEXEC, Mode::empty()).map_err(io)?;
|
||||
std::fs::File::from(descriptor)
|
||||
};
|
||||
|
||||
#[cfg(not(unix))]
|
||||
let mut file = std::fs::File::open(path).map_err(io)?;
|
||||
if !file.metadata().map_err(io)?.is_file() {
|
||||
return Err(io(format!("invalid cook output: {}", path.display())));
|
||||
}
|
||||
|
||||
file.by_ref().take(metadata.len()).read_to_end(&mut bytes).map_err(io)?;
|
||||
if file.read(&mut [0u8]).map_err(io)? != 0 {
|
||||
return Err(io("cook output grew while reading"));
|
||||
}
|
||||
|
||||
if bytes.len() as u64 > limit {
|
||||
return Err(io("cook output exceeds the remaining budget"));
|
||||
}
|
||||
|
||||
Ok(bytes)
|
||||
}
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
const CANCEL_POLL_INTERVAL: std::time::Duration = std::time::Duration::from_millis(20);
|
||||
|
||||
#[cfg(windows)]
|
||||
#[path = "windows_cook.rs"]
|
||||
mod windows_cook;
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
fn invoke(command: std::process::Command, dir: &Path, budget: LinkMemoryBudget, canceled: &AtomicBool) -> Result<Vec<u8>> {
|
||||
use std::sync::atomic::Ordering;
|
||||
|
||||
const MAX_DIAGNOSTIC_BYTES: u64 = 1 << 20;
|
||||
const MAX_REPORT_BYTES: u64 = 8 << 20;
|
||||
if canceled.load(Ordering::Relaxed) {
|
||||
return Err(io("MaterialCraft cook canceled"));
|
||||
}
|
||||
|
||||
let stdout = dir.join("reply.json");
|
||||
let stderr = dir.join("diagnostic.txt");
|
||||
let child_allowance = budget.child_allowance();
|
||||
let (success, status) = run_bounded(&command, &stdout, &stderr, child_allowance, canceled)?;
|
||||
if !success {
|
||||
let diagnostic = read_bounded(&stderr, MAX_DIAGNOSTIC_BYTES.min(budget.remaining()))?;
|
||||
return Err(io(format!(
|
||||
"MaterialCraft cook failed ({status}, {child_allowance} bytes of RAM available within the configured cap): {}",
|
||||
String::from_utf8_lossy(&diagnostic).trim()
|
||||
)));
|
||||
}
|
||||
|
||||
read_bounded(&stdout, MAX_REPORT_BYTES.min(budget.remaining()))
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
use windows_cook::run_bounded;
|
||||
|
||||
#[cfg(not(any(target_arch = "wasm32", windows)))]
|
||||
fn run_bounded(command: &std::process::Command, stdout: &Path, stderr: &Path, remaining_bytes: u64, canceled: &AtomicBool) -> Result<(bool, String)> {
|
||||
use std::sync::atomic::Ordering;
|
||||
|
||||
let mut command = bounded_cook_command(command, remaining_bytes)?;
|
||||
let mut child = command
|
||||
.stdout(std::fs::File::create(stdout).map_err(io)?)
|
||||
.stderr(std::fs::File::create(stderr).map_err(io)?)
|
||||
.spawn()
|
||||
.map_err(|error| io(format!("could not start the MaterialCraft cook: {error}. Install MaterialCraft or set MATERIALCRAFT_CLI")))?;
|
||||
|
||||
loop {
|
||||
if canceled.load(Ordering::Relaxed) {
|
||||
let _ = child.kill();
|
||||
child.wait().map_err(io)?;
|
||||
return Err(io("MaterialCraft cook canceled"));
|
||||
}
|
||||
|
||||
match child.try_wait() {
|
||||
Ok(Some(status)) => return Ok((status.success(), status.to_string())),
|
||||
Ok(None) => std::thread::sleep(CANCEL_POLL_INTERVAL),
|
||||
Err(error) => {
|
||||
let _ = child.kill();
|
||||
let _ = child.wait();
|
||||
return Err(io(error));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(target_os = "linux")]
|
||||
fn bounded_cook_command(command: &std::process::Command, remaining_bytes: u64) -> Result<std::process::Command> {
|
||||
// Cap address space before exec so a large allocation cannot race the parent
|
||||
let mut limited = quiet(Path::new("prlimit"));
|
||||
limited.arg(format!("--as={remaining_bytes}")).arg("--").arg(command.get_program()).args(command.get_args());
|
||||
Ok(limited)
|
||||
}
|
||||
|
||||
#[cfg(any(target_os = "macos", target_os = "freebsd"))]
|
||||
fn bounded_cook_command(command: &std::process::Command, remaining_bytes: u64) -> Result<std::process::Command> {
|
||||
#[cfg(target_os = "macos")]
|
||||
const SHELL: &str = "/bin/bash";
|
||||
#[cfg(target_os = "freebsd")]
|
||||
const SHELL: &str = "/bin/sh";
|
||||
|
||||
// The shell applies the process limit before replacing itself with MaterialCraft
|
||||
let mut limited = quiet(Path::new(SHELL));
|
||||
limited
|
||||
.env_remove("BASH_ENV")
|
||||
.env_remove("ENV")
|
||||
.args(["-c", r#"ulimit -v "$1" || exit 1; shift; exec -- "$@""#, "texturecraft-cook"])
|
||||
.arg((remaining_bytes / 1024).to_string())
|
||||
.arg(command.get_program())
|
||||
.args(command.get_args());
|
||||
Ok(limited)
|
||||
}
|
||||
|
||||
#[cfg(not(any(target_arch = "wasm32", target_os = "linux", target_os = "macos", target_os = "freebsd", windows)))]
|
||||
fn bounded_cook_command(_: &std::process::Command, remaining_bytes: u64) -> Result<std::process::Command> {
|
||||
Err(io(format!("This platform cannot enforce the configured MaterialCraft RAM allowance ({remaining_bytes} bytes remaining)")))
|
||||
}
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
fn channel_for_usage(usage: &str) -> Option<Channel> {
|
||||
if usage == "diffuse" {
|
||||
return Some(Channel::BaseColor);
|
||||
}
|
||||
|
||||
Channel::ALL.into_iter().find(|channel| channel.id() == usage)
|
||||
}
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
impl LinkJob {
|
||||
pub(super) fn run_reserved(&self, reservation: CookReservation) -> Result<CookedMaterial> {
|
||||
use std::sync::atomic::Ordering;
|
||||
|
||||
let mut budget = self.budget;
|
||||
let pixels = u64::from(self.size) * u64::from(self.size);
|
||||
budget.check(CookedMap::decoded_bytes(pixels))?;
|
||||
|
||||
let cli = materialcraft_tool("materialcraft-cli", "MATERIALCRAFT_CLI");
|
||||
let temp = tempfile::Builder::new().prefix("texturecraft-material-").tempdir().map_err(io)?;
|
||||
let dir = temp.path();
|
||||
let ext = match self.source_ext {
|
||||
"mcmat" | "sbs" | "mcraft" => self.source_ext,
|
||||
_ => return Err(io("unknown linked source format")),
|
||||
};
|
||||
|
||||
let source = dir.join(format!("source.{ext}"));
|
||||
std::fs::write(&source, &*self.package).map_err(io)?;
|
||||
|
||||
let out = dir.join("maps");
|
||||
let mut export = quiet(&cli);
|
||||
export.arg("export").arg(&source).arg(&out).args(["--profile", "maps", "--size"]).arg(format!("{}x{}", self.size, self.size));
|
||||
if self.source_ext != "mcmat"
|
||||
&& let Some(graph) = &self.graph
|
||||
{
|
||||
export.arg("--graph-path").arg(graph);
|
||||
}
|
||||
|
||||
for (id, value) in &self.values {
|
||||
export.arg("--set").arg(format!("{id}={value}"));
|
||||
}
|
||||
|
||||
if let Some(bakes) = self.baked.as_ref().filter(|bakes| !bakes.maps.is_empty()) {
|
||||
let mut identifiers = self.input_identifiers.clone();
|
||||
if self.layer == LayerId(0) {
|
||||
let mut inspect = quiet(&cli);
|
||||
if ext == "mcmat" {
|
||||
inspect.arg("info").arg(&source);
|
||||
} else {
|
||||
inspect.arg("run").arg(&source).arg("material.info");
|
||||
}
|
||||
|
||||
let interface: MaterialInterface = serde_json::from_slice(&invoke(inspect, dir, budget, &self.canceled)?).map_err(io)?;
|
||||
identifiers = interface.inputs.into_iter().map(|input| input.identifier).collect();
|
||||
}
|
||||
|
||||
for (index, identifier) in identifiers.iter().enumerate() {
|
||||
let Some((map, data)) = BakedMap::parse(identifier).and_then(|map| Some((map, bakes.maps.get(&map)?))) else {
|
||||
continue;
|
||||
};
|
||||
|
||||
let temporary_bytes = texturecraft_formats::mcmat::mesh_map_png_working_bytes(bakes.resolution, map.components());
|
||||
budget.check(temporary_bytes)?;
|
||||
budget.check_available(temporary_bytes)?;
|
||||
if self.canceled.load(Ordering::Relaxed) {
|
||||
return Err(io("MaterialCraft cook canceled"));
|
||||
}
|
||||
|
||||
let file = dir.join(format!("input{index}.png"));
|
||||
let output = std::fs::File::create(&file).map_err(io)?;
|
||||
texturecraft_formats::mcmat::write_mesh_map_png(output, bakes.resolution, map.components(), data).map_err(io)?;
|
||||
export.arg("--input").arg(format!("{identifier}={}", file.display()));
|
||||
}
|
||||
}
|
||||
|
||||
let reply: CookReport = serde_json::from_slice(&invoke(export, dir, budget, &self.canceled)?).map_err(io)?;
|
||||
let mut maps = Vec::<CookedMap>::new();
|
||||
let mut size = 0;
|
||||
let has_base_color = reply.maps.iter().any(|map| map.usage == Channel::BaseColor.id());
|
||||
for map in reply.maps.into_iter().rev() {
|
||||
if self.canceled.load(Ordering::Relaxed) {
|
||||
return Err(io("MaterialCraft cook canceled"));
|
||||
}
|
||||
|
||||
let Some(channel) = channel_for_usage(&map.usage) else { continue };
|
||||
|
||||
if (map.usage == "diffuse" && has_base_color) || maps.iter().any(|map| map.channel == channel) {
|
||||
continue;
|
||||
}
|
||||
|
||||
let path = Path::new(&map.file);
|
||||
if path.file_name().and_then(|p| p.to_str()) != Some(&map.file) || map.file.contains(['\\', ':']) {
|
||||
return Err(io("invalid map filename in MaterialCraft's export report"));
|
||||
}
|
||||
|
||||
let [width, height] = map.size;
|
||||
let texels = u64::from(width) * u64::from(height);
|
||||
if width == 0 || height == 0 || width > self.size || height > self.size || texels > texturecraft_formats::MAX_RESOURCE_TEXELS {
|
||||
return Err(io(format!(
|
||||
"{} map dimensions {width}x{height} exceed the requested {} px bake or the project resource limit",
|
||||
map.usage, self.size
|
||||
)));
|
||||
}
|
||||
|
||||
let file = out.join(path);
|
||||
let metadata = std::fs::symlink_metadata(&file).map_err(io)?;
|
||||
let temporary_bytes = metadata.len().saturating_add(CookedMap::decoder_peak_bytes(texels));
|
||||
budget.check(temporary_bytes)?;
|
||||
budget.check_available(metadata.len())?;
|
||||
let bytes = read_bounded(&file, metadata.len().min(crate::resource_cmds::MAX_BYTES as u64))?;
|
||||
let decoded = CookedMap::decode(channel, bytes, map.size, &mut budget)?;
|
||||
size = size.max(width).max(height);
|
||||
maps.push(decoded);
|
||||
}
|
||||
|
||||
if maps.is_empty() {
|
||||
return Err(io("MaterialCraft returned no paintable map usages"));
|
||||
}
|
||||
|
||||
Ok(CookedMaterial::new(reply.material, maps, size).with_reservation(reservation))
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(target_arch = "wasm32")]
|
||||
impl LinkJob {
|
||||
pub(super) fn run_reserved(&self, _: CookReservation) -> Result<CookedMaterial> {
|
||||
Err(EngineError::Other("cooking a procedural material requires materialcraft-cli on a desktop".into()))
|
||||
}
|
||||
}
|
||||
|
||||
impl LinkJob {
|
||||
pub fn run(&self) -> Result<CookedMaterial> {
|
||||
self.run_reserved(CookReservation::for_cook().map_err(|error| EngineError::Other(error.to_string()))?)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,129 @@
|
||||
use crate::{EngineError, Result};
|
||||
|
||||
/// Budget shared by retained link data and all phases of one cook.
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub struct LinkMemoryBudget {
|
||||
cap_bytes: u64,
|
||||
retained_bytes: u64,
|
||||
}
|
||||
|
||||
impl LinkMemoryBudget {
|
||||
pub fn new(cap_bytes: u64) -> Self {
|
||||
Self { cap_bytes, retained_bytes: 0 }
|
||||
}
|
||||
|
||||
pub(crate) fn reserve(&mut self, bytes: u64) -> Result<()> {
|
||||
self.retained_bytes = self.checked_total(bytes)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(crate) fn check(self, additional_bytes: u64) -> Result<()> {
|
||||
self.checked_total(additional_bytes).map(|_| ())
|
||||
}
|
||||
|
||||
fn checked_total(self, additional_bytes: u64) -> Result<u64> {
|
||||
let required_bytes = u128::from(self.retained_bytes) + u128::from(additional_bytes);
|
||||
if required_bytes > u128::from(self.cap_bytes) {
|
||||
return Err(EngineError::Other(format!(
|
||||
"MaterialCraft cook requires an estimated {required_bytes} bytes of RAM, exceeding the configured cap of {} bytes",
|
||||
self.cap_bytes
|
||||
)));
|
||||
}
|
||||
|
||||
Ok(required_bytes as u64)
|
||||
}
|
||||
|
||||
pub(super) fn set_retained(&mut self, bytes: u64) {
|
||||
self.retained_bytes = bytes;
|
||||
}
|
||||
|
||||
pub(super) fn remaining(self) -> u64 {
|
||||
self.cap_bytes.saturating_sub(self.retained_bytes)
|
||||
}
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
pub(super) fn child_allowance(self) -> u64 {
|
||||
let allowance = self.remaining().min(texturecraft_formats::available_save_resources().1);
|
||||
#[cfg(any(target_os = "linux", target_os = "macos", target_os = "freebsd"))]
|
||||
let allowance = allowance.min(rustix::process::getrlimit(rustix::process::Resource::As).current.unwrap_or(u64::MAX));
|
||||
|
||||
allowance
|
||||
}
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
pub(super) fn check_available(self, temporary_bytes: u64) -> Result<()> {
|
||||
let available_bytes = texturecraft_formats::available_save_resources().1;
|
||||
#[cfg(any(target_os = "linux", target_os = "macos", target_os = "freebsd"))]
|
||||
let available_bytes = match rustix::process::getrlimit(rustix::process::Resource::As).current {
|
||||
// Physical memory can be plentiful while the host has little address space left
|
||||
Some(limit) => available_bytes.min(limit.saturating_sub(host_virtual_bytes()?)),
|
||||
None => available_bytes,
|
||||
};
|
||||
|
||||
if temporary_bytes > available_bytes {
|
||||
return Err(EngineError::Other(format!(
|
||||
"MaterialCraft cook requires an estimated {temporary_bytes} additional bytes of RAM, with {available_bytes} bytes currently available and a configured cap of {} bytes",
|
||||
self.cap_bytes
|
||||
)));
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(target_os = "linux")]
|
||||
fn host_virtual_bytes() -> Result<u64> {
|
||||
let status = std::fs::read_to_string("/proc/self/status").map_err(|error| EngineError::Other(format!("cannot check host address space: {error}")))?;
|
||||
status
|
||||
.lines()
|
||||
.find_map(|line| line.strip_prefix("VmSize:"))
|
||||
.and_then(|value| value.split_whitespace().next()?.parse::<u64>().ok())
|
||||
.and_then(|kib| kib.checked_mul(1024))
|
||||
.ok_or_else(|| EngineError::Other("cannot determine the memory available under the host address-space limit".into()))
|
||||
}
|
||||
|
||||
#[cfg(any(target_os = "macos", target_os = "freebsd"))]
|
||||
fn host_virtual_bytes() -> Result<u64> {
|
||||
use sysinfo::{Pid, ProcessRefreshKind, ProcessesToUpdate, System};
|
||||
|
||||
let mut system = System::new().map_err(|error| EngineError::Other(format!("cannot check host address space: {error}")))?;
|
||||
let pid = Pid::from_u32(std::process::id());
|
||||
system.refresh_processes_specifics(ProcessesToUpdate::Some(&[pid]), false, ProcessRefreshKind::nothing().with_memory());
|
||||
system
|
||||
.process(pid)
|
||||
.map(|process| process.virtual_memory())
|
||||
.filter(|bytes| *bytes != 0)
|
||||
.ok_or_else(|| EngineError::Other("cannot determine the memory available under the host address-space limit".into()))
|
||||
}
|
||||
|
||||
#[cfg(all(test, target_os = "linux"))]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn inherited_address_limit_restricts_host_and_companion() {
|
||||
const PROCESS_LIMIT_BYTES: u64 = 192 << 20;
|
||||
const CONSTRAINED_TEST: &str = "TC_LINK_TEST_ADDRESS_LIMIT";
|
||||
|
||||
// Isolate the inherited limit from unrelated tests in the parent process
|
||||
if std::env::var_os(CONSTRAINED_TEST).is_none() {
|
||||
let status = std::process::Command::new("prlimit")
|
||||
.arg(format!("--as={PROCESS_LIMIT_BYTES}"))
|
||||
.arg("--")
|
||||
.arg(std::env::current_exe().unwrap())
|
||||
.args(["--exact", std::thread::current().name().unwrap()])
|
||||
.env(CONSTRAINED_TEST, "1")
|
||||
.status()
|
||||
.unwrap();
|
||||
assert!(status.success());
|
||||
return;
|
||||
}
|
||||
|
||||
let budget = LinkMemoryBudget::new(8 << 30);
|
||||
let error = budget.check_available(PROCESS_LIMIT_BYTES).unwrap_err();
|
||||
|
||||
assert!(error.to_string().contains("configured cap"));
|
||||
assert!(budget.child_allowance() <= PROCESS_LIMIT_BYTES);
|
||||
budget.check_available(1).unwrap();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
use serde::Deserialize;
|
||||
|
||||
#[derive(Deserialize)]
|
||||
pub(super) struct MapFile {
|
||||
pub(super) usage: String,
|
||||
pub(super) file: String,
|
||||
pub(super) size: [u32; 2],
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
use super::ImageInput;
|
||||
use texturecraft_core::{LinkParam, LinkPreset};
|
||||
|
||||
#[derive(Clone, Debug, serde::Deserialize)]
|
||||
pub struct MaterialInterface {
|
||||
pub name: String,
|
||||
pub graph: String,
|
||||
pub parameters: Vec<LinkParam>,
|
||||
pub inputs: Vec<ImageInput>,
|
||||
pub presets: Vec<LinkPreset>,
|
||||
}
|
||||
@@ -0,0 +1,43 @@
|
||||
use std::path::Path;
|
||||
use std::process::Command;
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
|
||||
use processkit::{ProcessGroup, ProcessGroupOptions};
|
||||
|
||||
use super::{CANCEL_POLL_INTERVAL, EngineError, Result, io};
|
||||
|
||||
pub(super) fn run_bounded(command: &Command, stdout: &Path, stderr: &Path, remaining_bytes: u64, canceled: &AtomicBool) -> Result<(bool, String)> {
|
||||
// A synchronous engine command may already be running inside a Tokio context
|
||||
std::thread::scope(|scope| {
|
||||
std::thread::Builder::new()
|
||||
.spawn_scoped(scope, || {
|
||||
let runtime = tokio::runtime::Builder::new_current_thread().enable_all().build().map_err(io)?;
|
||||
runtime.block_on(async {
|
||||
let group = ProcessGroup::with_options(ProcessGroupOptions::default().max_memory(remaining_bytes))
|
||||
.map_err(|error| io(format!("could not enforce the MaterialCraft RAM allowance of {remaining_bytes} bytes: {error}")))?;
|
||||
let command =
|
||||
processkit::Command::new(command.get_program()).args(command.get_args()).create_no_window().stdout_file(stdout).stderr_file(stderr);
|
||||
let process = group.start(&command).await.map_err(io)?;
|
||||
let mut wait = std::pin::pin!(process.wait());
|
||||
let cancellation = async {
|
||||
while !canceled.load(Ordering::Relaxed) {
|
||||
tokio::time::sleep(CANCEL_POLL_INTERVAL).await;
|
||||
}
|
||||
};
|
||||
let status = tokio::select! {
|
||||
status = &mut wait => status.map_err(io)?,
|
||||
_ = cancellation => {
|
||||
group.kill_all().map_err(io)?;
|
||||
wait.await.map_err(io)?;
|
||||
return Err(io("MaterialCraft cook canceled"));
|
||||
}
|
||||
};
|
||||
|
||||
Ok((status.code() == Some(0), format!("{status:?}")))
|
||||
})
|
||||
})
|
||||
.map_err(io)?
|
||||
.join()
|
||||
.map_err(|_| EngineError::Other("the MaterialCraft process worker stopped".into()))?
|
||||
})
|
||||
}
|
||||
@@ -81,10 +81,12 @@ impl Session {
|
||||
|
||||
/// The smart material file holding `mini` (a document from [`one_set_document`]) and the images layer `root` of it uses.
|
||||
pub(crate) fn file_bytes(&self, mini: Document, root: LayerId) -> Result<Vec<u8>> {
|
||||
let mut reservation = texturecraft_formats::RamReservation::for_save().map_err(fe)?;
|
||||
let mut used = Vec::new();
|
||||
images_used(&mini.project, root, &mut used, 0);
|
||||
let resources = used.iter().filter_map(|n| self.doc.resources.get(n).map(|b| (n.clone(), b.as_ref().clone()))).collect();
|
||||
let pf = texturecraft_formats::ProjectFile {
|
||||
let resources = used.into_iter().filter_map(|name| self.doc.resources.get(&name).map(|bytes| (name, Arc::clone(bytes)))).collect();
|
||||
|
||||
let snapshot = texturecraft_formats::ProjectFile {
|
||||
project: mini.project,
|
||||
pixels: mini.pixels,
|
||||
baked: BTreeMap::new(),
|
||||
@@ -96,7 +98,7 @@ impl Session {
|
||||
resources,
|
||||
warnings: Vec::new(),
|
||||
};
|
||||
texturecraft_formats::save_project_bytes(&pf).map_err(fe)
|
||||
reservation.save_bytes(&snapshot).map_err(fe)
|
||||
}
|
||||
|
||||
/// Add a smart material file above the selection (one undo step). Returns the new layer.
|
||||
@@ -111,23 +113,26 @@ impl Session {
|
||||
return self.add_linked_material_bytes_at(bytes, place);
|
||||
}
|
||||
|
||||
let pf = texturecraft_formats::load_project_bytes(bytes).map_err(fe)?;
|
||||
let root = pf
|
||||
self.add_smart_material_project(texturecraft_formats::load_project_bytes(bytes).map_err(fe)?, place)
|
||||
}
|
||||
|
||||
fn add_smart_material_project(&mut self, project_file: texturecraft_formats::ProjectFile, place: Place) -> Result<LayerId> {
|
||||
let root = project_file
|
||||
.project
|
||||
.texture_sets
|
||||
.first()
|
||||
.and_then(|t| t.stack.last().copied())
|
||||
.ok_or_else(|| EngineError::Other("the smart material file has no layer".into()))?;
|
||||
let resources: BTreeMap<String, Arc<Vec<u8>>> = pf.resources.into_iter().map(|(k, v)| (k, Arc::new(v))).collect();
|
||||
let src = Document { bake_paint: BTreeMap::new(), project: pf.project, pixels: pf.pixels, baked: BTreeMap::new(), resources: resources.clone() };
|
||||
let resources: BTreeMap<String, Arc<Vec<u8>>> = project_file.resources.into_iter().map(|(k, v)| (k, Arc::new(v))).collect();
|
||||
let source = Document { bake_paint: BTreeMap::new(), project: project_file.project, pixels: project_file.pixels, baked: BTreeMap::new(), resources };
|
||||
let id = self.edit("Add smart material", |s| {
|
||||
for (k, v) in &resources {
|
||||
s.doc.resources.entry(k.clone()).or_insert_with(|| v.clone());
|
||||
for (name, bytes) in &source.resources {
|
||||
s.doc.resources.entry(name.clone()).or_insert_with(|| Arc::clone(bytes));
|
||||
}
|
||||
let ts = s.ts();
|
||||
let sel = s.selected_layer();
|
||||
let inside = sel.and_then(|l| s.doc.project.layer(l).ok()).is_some_and(|l| l.is_group());
|
||||
let id = crate::layer_ops::copy_tree(&src, root, &mut s.doc, ts, sel, inside, 0)?;
|
||||
let id = crate::layer_ops::copy_tree(&source, root, &mut s.doc, ts, sel, inside, 0)?;
|
||||
place.apply(s, id)?;
|
||||
s.select_one(ts, id);
|
||||
s.target = StackTarget::Content;
|
||||
@@ -161,8 +166,23 @@ fn save(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
fn load(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let path = strp(p, "path").ok_or_else(|| bad("material.load", "`path` is required"))?;
|
||||
let bytes = std::fs::read(path).map_err(|e| bad("material.load", format!("cannot read {path}: {e}")))?;
|
||||
let id = s.add_smart_material_bytes_at(&bytes, Place::from_params(p))?;
|
||||
let source = std::path::Path::new(path);
|
||||
let place = Place::from_params(p);
|
||||
let project = if crate::link_cmds::is_link_file(source) {
|
||||
None
|
||||
} else {
|
||||
let file = crate::resource_cmds::open_resource_file("material.load", source)?;
|
||||
texturecraft_formats::project_file::load_smart_material_project(file).map_err(fe)?
|
||||
};
|
||||
|
||||
let id = if let Some(project) = project {
|
||||
s.add_smart_material_project(project, place)?
|
||||
} else {
|
||||
let set = s.ts();
|
||||
let resolution = s.doc.project.texture_set(set)?.resolution;
|
||||
let (source, cooked) = crate::link_cmds::cook_link_file(source, resolution, s.baked(set).cloned(), s.link_memory_budget(), Arc::default())?;
|
||||
s.add_cooked_material(&cooked, source.package, source.source_ext, place)?
|
||||
};
|
||||
Ok(json!({ "layer": id.0 }))
|
||||
}
|
||||
|
||||
|
||||
@@ -844,8 +844,8 @@ pub fn apply_at(s: &mut Session, id: &str, place: Place) -> Result<LayerId> {
|
||||
}
|
||||
|
||||
impl Place {
|
||||
/// From `above` (+ `inside`) or `index` params; the selection by default.
|
||||
pub(crate) fn from_params(p: &serde_json::Value) -> Place {
|
||||
/// Parse a drop position from the command parameters, defaulting to the selection.
|
||||
pub fn from_params(p: &serde_json::Value) -> Place {
|
||||
match (crate::commands::u64p(p, "above"), crate::commands::u64p(p, "below"), crate::commands::u64p(p, "index")) {
|
||||
(Some(above), _, _) => Place::Above(LayerId(above), crate::commands::boolp(p, "inside").unwrap_or(false)),
|
||||
(None, Some(below), _) => Place::Below(LayerId(below)),
|
||||
|
||||
@@ -39,6 +39,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
|
||||
/// Largest accepted resource file.
|
||||
pub(crate) const MAX_BYTES: usize = 512 << 20;
|
||||
pub(crate) const EXR_SIGNATURE: &[u8] = &[0x76, 0x2f, 0x31, 0x01];
|
||||
|
||||
pub(crate) fn decoded(d: texturecraft_formats::DecodedImage) -> Arc<ImageRes> {
|
||||
Arc::new(ImageRes { width: d.width, height: d.height, rgba: d.rgba, srgb: d.srgb })
|
||||
@@ -102,14 +103,34 @@ impl Session {
|
||||
pub fn sync_images(&mut self) {
|
||||
self.images.retain(|name, _| self.doc.resources.contains_key(name));
|
||||
|
||||
// Linked material packages are resources but cannot be decoded as images
|
||||
let package_suffix = format!(".{}", texturecraft_formats::mcmat::MCRAFT_EXT);
|
||||
let mut linked_packages = std::collections::HashSet::new();
|
||||
let mut linked_images = std::collections::HashMap::new();
|
||||
for layer in self.doc.project.layers.values() {
|
||||
let LayerKind::Fill(Fill { link: Some(link), sources, .. }) = &layer.kind else { continue };
|
||||
|
||||
linked_packages.insert(link.package.as_str());
|
||||
for source in sources.values() {
|
||||
if let Source::Image { name, .. } = source {
|
||||
linked_images.entry(name.as_str()).and_modify(|size: &mut u32| *size = (*size).max(link.size)).or_insert(link.size);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (name, bytes) in &self.doc.resources {
|
||||
if self.images.contains_key(name) || name.ends_with(&package_suffix) {
|
||||
if self.images.contains_key(name) || linked_packages.contains(name.as_str()) {
|
||||
continue;
|
||||
}
|
||||
|
||||
match texturecraft_formats::decode_image(bytes) {
|
||||
// EXR may need a full float decode buffer even when encoded project bytes are small
|
||||
let image = match linked_images.get(name.as_str()) {
|
||||
Some(&size) if size > 0 && bytes.starts_with(EXR_SIGNATURE) => {
|
||||
let texels = (u64::from(size) * u64::from(size)).min(texturecraft_formats::MAX_RESOURCE_TEXELS);
|
||||
let decoder_bytes = texels * std::mem::size_of::<[f32; 4]>() as u64;
|
||||
texturecraft_formats::decode_cooked_image(bytes, [size; 2], decoder_bytes).or_else(|_| texturecraft_formats::decode_image(bytes))
|
||||
}
|
||||
_ => texturecraft_formats::decode_image(bytes),
|
||||
};
|
||||
match image {
|
||||
Ok(image) => {
|
||||
self.images.insert(name.clone(), decoded(image));
|
||||
}
|
||||
@@ -143,27 +164,57 @@ fn import(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
/// 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;
|
||||
read_resource_file(cmd, std::path::Path::new(path), max_bytes.min(MAX_BYTES as u64))
|
||||
}
|
||||
|
||||
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)?;
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
pub(crate) fn open_resource_file(cmd: &str, path: &std::path::Path) -> Result<std::fs::File> {
|
||||
let display = path.display();
|
||||
let read_error = |error| bad(cmd, format!("cannot read {display}: {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 !std::fs::metadata(path).map_err(read_error)?.is_file() {
|
||||
return Err(bad(cmd, format!("{display} is not a regular file")));
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
let file = {
|
||||
use rustix::fs::{Mode, OFlags, open};
|
||||
|
||||
// Follow user-selected symlinks without waiting on a substituted pipe
|
||||
let descriptor = open(path, OFlags::RDONLY | OFlags::NONBLOCK | OFlags::CLOEXEC, Mode::empty()).map_err(|error| read_error(error.into()))?;
|
||||
std::fs::File::from(descriptor)
|
||||
};
|
||||
#[cfg(not(unix))]
|
||||
let file = std::fs::File::open(path).map_err(read_error)?;
|
||||
|
||||
if !file.metadata().map_err(read_error)?.is_file() {
|
||||
return Err(bad(cmd, format!("{display} is not a regular file")));
|
||||
}
|
||||
|
||||
Ok(file)
|
||||
}
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
pub(crate) fn read_resource_file(cmd: &str, path: &std::path::Path, max_bytes: u64) -> Result<Vec<u8>> {
|
||||
use std::io::Read;
|
||||
|
||||
let display = path.display();
|
||||
let read_error = |error| bad(cmd, format!("cannot read {display}: {error}"));
|
||||
let too_large = || bad(cmd, format!("{display} is too large (limit {max_bytes} bytes)"));
|
||||
let mut file = open_resource_file(cmd, path)?;
|
||||
let metadata = file.metadata().map_err(read_error)?;
|
||||
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 {
|
||||
let mut bytes = Vec::new();
|
||||
let capacity = usize::try_from(metadata.len()).map_err(|_| too_large())?;
|
||||
bytes.try_reserve_exact(capacity).map_err(|error| bad(cmd, format!("cannot allocate {display}: {error}")))?;
|
||||
|
||||
// A growing file must not trigger allocations beyond the checked size
|
||||
file.by_ref().take(metadata.len()).read_to_end(&mut bytes).map_err(read_error)?;
|
||||
if file.read(&mut [0u8]).map_err(read_error)? != 0 {
|
||||
return Err(too_large());
|
||||
}
|
||||
|
||||
|
||||
@@ -922,6 +922,8 @@ impl Session {
|
||||
}
|
||||
|
||||
fn after_history(&mut self, other: &Document) {
|
||||
// Pending operations may still hold layer IDs from the discarded snapshot
|
||||
self.doc.project.next_id = self.doc.project.next_id.max(other.project.next_id);
|
||||
self.modified = true;
|
||||
|
||||
// Layers picked together belong to the stack they were picked in
|
||||
|
||||
@@ -10,6 +10,7 @@ use texturecraft_engine::compose::BakedMaps;
|
||||
use texturecraft_engine::core::{BakedMap, Channel, LayerId, LayerKind, NormalFormat, Source};
|
||||
use texturecraft_engine::formats::mcmat::mesh_map_png;
|
||||
use texturecraft_engine::geom::primitives;
|
||||
use texturecraft_engine::link_cmds::{CookedMap, CookedMaterial, LinkMemoryBudget};
|
||||
use texturecraft_engine::materials::Place;
|
||||
use texturecraft_engine::{Session, execute};
|
||||
|
||||
@@ -19,21 +20,11 @@ fn session() -> Session {
|
||||
s
|
||||
}
|
||||
|
||||
/// A `.mcmat` as MaterialCraft writes it: uniform maps, one float input `wear` cooked at `wear`.
|
||||
fn mcmat(roughness: f32, wear: f32) -> Vec<u8> {
|
||||
mcmat_version(roughness, wear, 1)
|
||||
}
|
||||
|
||||
fn mcmat_version(roughness: f32, wear: f32, version: u32) -> Vec<u8> {
|
||||
let source = if version == 2 { "source.sbs" } else { "source.mcraft" };
|
||||
/// A CLI bake with known pixels for testing the linked layer independently of the subprocess.
|
||||
fn cooked(roughness: f32, wear: f32) -> CookedMaterial {
|
||||
let gray = |v: f32| mesh_map_png(4, 1, &[v; 16]).unwrap();
|
||||
let manifest = json!({
|
||||
"format": "craft-material", "version": version, "name": "Brick wall", "graph": "Brick_wall", "size": [4, 4],
|
||||
"maps": [
|
||||
{"usage": "baseColor", "file": "maps/baseColor.png", "colorSpace": "srgb"},
|
||||
{"usage": "roughness", "file": "maps/roughness.png", "colorSpace": "linear"},
|
||||
{"usage": "ambientOcclusion", "file": "maps/ambientOcclusion.png", "colorSpace": "linear"}
|
||||
],
|
||||
let interface = json!({
|
||||
"name": "Brick wall", "graph": "Brick_wall",
|
||||
"parameters": [
|
||||
{"id": "wear", "label": "Wear", "default": {"t": "float", "v": 0.5}, "min": 0.0, "max": 1.0, "value": {"t": "float", "v": wear}},
|
||||
{"id": "tint", "label": "Tint", "default": {"t": "color", "v": [1.0, 1.0, 1.0, 1.0]}, "value": {"t": "color", "v": [1.0, 1.0, 1.0, 1.0]}},
|
||||
@@ -47,21 +38,17 @@ fn mcmat_version(roughness: f32, wear: f32, version: u32) -> Vec<u8> {
|
||||
{"identifier": "bentNormal", "kind": "color"}
|
||||
],
|
||||
"presets": [{"name": "Worn", "values": {"wear": {"t": "float", "v": 1.0}, "note": {"t": "text", "v": "x"}}}],
|
||||
"source": source
|
||||
});
|
||||
let mut z = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));
|
||||
let o = zip::write::SimpleFileOptions::default();
|
||||
for (name, bytes) in [
|
||||
("material.json", manifest.to_string().into_bytes()),
|
||||
("maps/baseColor.png", mesh_map_png(4, 3, &[0.5; 48]).unwrap()),
|
||||
("maps/roughness.png", gray(roughness)),
|
||||
("maps/ambientOcclusion.png", gray(1.0)),
|
||||
(source, b"package bytes".to_vec()),
|
||||
] {
|
||||
z.start_file(name, o).unwrap();
|
||||
z.write_all(&bytes).unwrap();
|
||||
}
|
||||
z.finish().unwrap().into_inner()
|
||||
let mut budget = LinkMemoryBudget::new(1 << 20);
|
||||
let maps = [(Channel::BaseColor, mesh_map_png(4, 3, &[0.5; 48]).unwrap()), (Channel::Roughness, gray(roughness)), (Channel::AmbientOcclusion, gray(1.0))]
|
||||
.into_iter()
|
||||
.map(|(channel, bytes)| CookedMap::decode(channel, bytes, [4, 4], &mut budget).unwrap())
|
||||
.collect();
|
||||
CookedMaterial::new(serde_json::from_value(interface).unwrap(), maps, 4)
|
||||
}
|
||||
|
||||
fn install(session: &mut Session) -> LayerId {
|
||||
session.add_cooked_material(&cooked(0.25, 0.5), Arc::new(b"package bytes".to_vec()), "mcmat", Place::Selection).unwrap()
|
||||
}
|
||||
|
||||
fn roughness(s: &mut Session) -> f32 {
|
||||
@@ -86,31 +73,47 @@ fn map_name(s: &Session, id: LayerId, c: Channel) -> String {
|
||||
}
|
||||
}
|
||||
|
||||
// Real cook reservations must be independent of saves in other parallel integration tests
|
||||
fn run_in_private_process() -> bool {
|
||||
const CHILD_TEST: &str = "TC_MATERIALCRAFT_CHILD_TEST";
|
||||
|
||||
let thread = std::thread::current();
|
||||
let name = thread.name().unwrap();
|
||||
if std::env::var(CHILD_TEST).as_deref() == Ok(name) {
|
||||
return false;
|
||||
}
|
||||
|
||||
let status = std::process::Command::new(std::env::current_exe().unwrap())
|
||||
.args(["--exact", name, "--include-ignored", "--nocapture"])
|
||||
.env(CHILD_TEST, name)
|
||||
.status()
|
||||
.unwrap();
|
||||
assert!(status.success(), "{name} returned {status}");
|
||||
true
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn version_two_preserves_the_sbs_source_for_future_cooks() {
|
||||
fn version_two_requires_republishing_before_install() {
|
||||
if run_in_private_process() {
|
||||
return;
|
||||
}
|
||||
|
||||
let mut zip = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));
|
||||
zip.start_file("material.json", zip::write::SimpleFileOptions::default()).unwrap();
|
||||
zip.write_all(br#"{"version":2,"format":"craft-material"}"#).unwrap();
|
||||
let bytes = zip.finish().unwrap().into_inner();
|
||||
let mut session = session();
|
||||
let id = session.add_linked_material_bytes_at(&mcmat_version(0.25, 0.5, 2), Place::Selection).unwrap();
|
||||
let linked = link(&session, id);
|
||||
assert!(linked.package.ends_with(".sbs"));
|
||||
let job = session.link_job(id, &serde_json::Map::new()).unwrap();
|
||||
assert_eq!(job.source_ext, "sbs");
|
||||
assert_eq!(job.graph.as_deref(), Some("Brick_wall"));
|
||||
assert_eq!(job.package.as_slice(), b"package bytes");
|
||||
let base = std::env::temp_dir().join(format!("texturecraft-sbs-source-{}", std::process::id()));
|
||||
let saved = execute(&mut session, "material.link.saveSource", &json!({"layer": id.0, "path": base.to_str().unwrap()})).unwrap();
|
||||
let path = saved["path"].as_str().unwrap();
|
||||
assert!(path.ends_with(".sbs"));
|
||||
assert_eq!(std::fs::read(path).unwrap(), b"package bytes");
|
||||
let _ = std::fs::remove_file(path);
|
||||
assert!(session.add_linked_material_bytes_at(&bytes, Place::Selection).unwrap_err().to_string().contains("Republish"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn imports_as_a_linked_fill_with_its_maps() {
|
||||
let mut s = session();
|
||||
let id = s.add_linked_material_bytes_at(&mcmat(0.25, 0.5), Place::Selection).unwrap();
|
||||
let id = install(&mut s);
|
||||
assert_eq!(s.selected_layer(), Some(id));
|
||||
assert!((roughness(&mut s) - 0.25).abs() < 2e-3);
|
||||
// The material's channels join the texture set; text inputs are not editable here.
|
||||
|
||||
// The fill adds its mapped channels and omits text parameters
|
||||
assert!(s.doc.project.texture_sets[0].has_channel(Channel::AmbientOcclusion));
|
||||
let l = link(&s, id);
|
||||
assert_eq!(l.graph, "Brick_wall");
|
||||
@@ -118,13 +121,15 @@ fn imports_as_a_linked_fill_with_its_maps() {
|
||||
assert_eq!(l.inputs, ["curvature", "normal", "worldNormal", "ambientOcclusion", "bentNormal"]);
|
||||
assert_eq!(s.doc.resources.get(&l.package).map(|b| b.as_slice()), Some(&b"package bytes"[..]));
|
||||
assert!(!s.images.contains_key(&l.package), "the package is not decoded as an image");
|
||||
// Inspect shows the link; one undo removes everything.
|
||||
|
||||
// One undo removes the link exposed through inspect
|
||||
let inspect = execute(&mut s, "project.inspect", &Value::Null).unwrap().to_string();
|
||||
assert!(inspect.contains("Brick_wall"), "{inspect}");
|
||||
let n = s.doc.resources.len();
|
||||
execute(&mut s, "edit.undo", &Value::Null).unwrap();
|
||||
assert!(s.doc.project.layer(id).is_err() && s.doc.resources.len() < n);
|
||||
// Garbage is an error, not a layer.
|
||||
|
||||
// Invalid archives leave the stack untouched
|
||||
assert!(s.add_linked_material_bytes_at(b"PK not really", Place::Selection).is_err());
|
||||
}
|
||||
|
||||
@@ -132,10 +137,10 @@ fn imports_as_a_linked_fill_with_its_maps() {
|
||||
#[test]
|
||||
fn recooks_keep_the_normal_format_of_a_map() {
|
||||
let mut session = session();
|
||||
let id = session.add_linked_material_bytes_at(&mcmat(0.25, 0.5), Place::Selection).unwrap();
|
||||
let id = install(&mut session);
|
||||
execute(&mut session, "layer.fill.set", &json!({"layer": id.0, "channel": "roughness", "normalFormat": "directX"})).unwrap();
|
||||
|
||||
session.apply_link_cook(id, &mcmat(0.75, 0.5), false).unwrap();
|
||||
session.apply_link_cook(id, &cooked(0.75, 0.5), false).unwrap();
|
||||
|
||||
let LayerKind::Fill(fill) = &session.doc.project.layer(id).unwrap().kind else { panic!("a fill") };
|
||||
|
||||
@@ -145,7 +150,7 @@ fn recooks_keep_the_normal_format_of_a_map() {
|
||||
#[test]
|
||||
fn parameters_are_checked_stored_and_recooked_in_one_undo_step() {
|
||||
let mut session = session();
|
||||
let id = session.add_linked_material_bytes_at(&mcmat(0.25, 0.5), Place::Selection).unwrap();
|
||||
let id = install(&mut session);
|
||||
let set = |session: &mut Session, params: Value| execute(session, "material.link.set", ¶ms);
|
||||
|
||||
assert!(set(&mut session, json!({"id": "nope", "value": 1, "cook": false})).is_err());
|
||||
@@ -164,7 +169,7 @@ fn parameters_are_checked_stored_and_recooked_in_one_undo_step() {
|
||||
|
||||
// Merge the cooked maps into the parameter edit
|
||||
let old = map_name(&session, id, Channel::Roughness);
|
||||
session.apply_link_cook(id, &mcmat(0.75, 0.9), true).unwrap();
|
||||
session.apply_link_cook(id, &cooked(0.75, 0.9), true).unwrap();
|
||||
|
||||
assert!((roughness(&mut session) - 0.75).abs() < 2e-3);
|
||||
assert!(!session.doc.resources.contains_key(&old), "old maps are dropped");
|
||||
@@ -185,27 +190,34 @@ fn parameters_are_checked_stored_and_recooked_in_one_undo_step() {
|
||||
#[test]
|
||||
fn duplicates_keep_their_maps_and_mesh_maps_feed_inputs() {
|
||||
let mut session = session();
|
||||
let id = session.add_linked_material_bytes_at(&mcmat(0.25, 0.5), Place::Selection).unwrap();
|
||||
let id = install(&mut session);
|
||||
let duplicate = LayerId(execute(&mut session, "layer.duplicate", &json!({"layer": id.0})).unwrap()["layer"].as_u64().unwrap());
|
||||
let shared = map_name(&session, duplicate, Channel::Roughness);
|
||||
session.apply_link_cook(id, &mcmat(0.75, 0.5), false).unwrap();
|
||||
session.apply_link_cook(id, &cooked(0.75, 0.5), false).unwrap();
|
||||
assert!(session.doc.resources.contains_key(&shared), "the duplicate still shows the first cook");
|
||||
|
||||
let maps = [BakedMap::Curvature, BakedMap::Normal, BakedMap::WorldNormal, BakedMap::AmbientOcclusion, BakedMap::BentNormal];
|
||||
session.doc.baked.insert(0, BakedMaps { resolution: 4, maps: maps.into_iter().map(|map| (map, Arc::new(vec![0.5f32; 16 * map.components()]))).collect() });
|
||||
let job = session.link_job(id, &serde_json::Map::new()).unwrap();
|
||||
assert_eq!(job.inputs.iter().map(|(identifier, _)| identifier.as_str()).collect::<Vec<_>>(), maps.map(BakedMap::id));
|
||||
assert_eq!(job.input_identifiers.iter().map(String::as_str).collect::<Vec<_>>(), maps.map(BakedMap::id));
|
||||
assert_eq!(maps.map(BakedMap::id), ["curvature", "normal", "worldNormal", "ambientOcclusion", "bentNormal"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn projects_save_the_link_and_its_package() {
|
||||
let mut s = session();
|
||||
let id = s.add_linked_material_bytes_at(&mcmat(0.25, 0.5), Place::Selection).unwrap();
|
||||
let back = Session::from_project_bytes(&s.to_project_bytes().unwrap()).unwrap();
|
||||
let id = install(&mut s);
|
||||
let snapshot = s.project_snapshot();
|
||||
assert!(snapshot.resources.iter().all(|(name, bytes)| Arc::ptr_eq(bytes, &s.doc.resources[name])));
|
||||
let owned = s.project_file();
|
||||
let saved = s.to_project_bytes().unwrap();
|
||||
|
||||
assert_eq!(saved, texturecraft_engine::formats::save_project_bytes(&owned).unwrap());
|
||||
let back = Session::from_project_bytes(&saved).unwrap();
|
||||
assert_eq!(link(&back, id), link(&s, id));
|
||||
assert!(back.doc.resources.contains_key(&link(&s, id).package));
|
||||
// Smart materials made from the layer carry the package too.
|
||||
|
||||
// Layer exports also carry the source package
|
||||
let tcmat = s.smart_material_bytes(id, "Bricks").unwrap();
|
||||
let mut other = session();
|
||||
let copy = other.add_smart_material_bytes(&tcmat).unwrap();
|
||||
@@ -219,45 +231,210 @@ fn cooks_through_materialcraft_cli_when_available() {
|
||||
eprintln!("MATERIALCRAFT_CLI is not set: skipping the materialcraft-cli round trip");
|
||||
return;
|
||||
};
|
||||
let dir = std::env::temp_dir().join(format!("tc-mc-link-{}", std::process::id()));
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
|
||||
if run_in_private_process() {
|
||||
return;
|
||||
}
|
||||
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let dir = temp.path();
|
||||
let pkg = dir.join("bricks.mcraft");
|
||||
let ok = std::process::Command::new(&cli).args(["new", "pbr"]).arg(&pkg).args(["--size", "64"]).status().unwrap();
|
||||
assert!(ok.success());
|
||||
let exposed = dir.join("exposed.mcraft");
|
||||
let rectangular = dir.join("rectangular.mcraft");
|
||||
let resize =
|
||||
std::process::Command::new(&cli).arg("run").arg(&pkg).args(["graph.size", r#"{"width":64,"height":32}"#, "-o"]).arg(&rectangular).status().unwrap();
|
||||
assert!(resize.success());
|
||||
let ok = std::process::Command::new(&cli)
|
||||
.arg("run")
|
||||
.arg(&pkg)
|
||||
.arg(&rectangular)
|
||||
.arg("graph.exposed.add")
|
||||
.arg(r#"{"id": "wear", "default": 0.5}"#)
|
||||
.arg(r#"{"id":"wear","bind":{"node":5,"param":"color"}}"#)
|
||||
.arg("-o")
|
||||
.arg(&exposed)
|
||||
.status()
|
||||
.unwrap();
|
||||
assert!(ok.success());
|
||||
|
||||
// Feed metallic from the texture set's baked curvature
|
||||
let with_input = dir.join("with_input.mcraft");
|
||||
let add = std::process::Command::new(&cli)
|
||||
.arg("run")
|
||||
.arg(&exposed)
|
||||
.arg("graph.node.add")
|
||||
.arg(r#"{"def":"input_grayscale","params":{"identifier":"curvature"}}"#)
|
||||
.arg("-o")
|
||||
.arg(&with_input)
|
||||
.output()
|
||||
.unwrap();
|
||||
assert!(add.status.success(), "{}", String::from_utf8_lossy(&add.stderr));
|
||||
let new_node: Value = serde_json::from_slice(&add.stdout).unwrap();
|
||||
let connect = json!({"from":new_node["id"],"to":8,"toPort":"input"});
|
||||
let ok =
|
||||
std::process::Command::new(&cli).arg("run").arg(&with_input).arg("graph.connect").arg(connect.to_string()).arg("-o").arg(&exposed).status().unwrap();
|
||||
assert!(ok.success());
|
||||
let mut s = session();
|
||||
s.doc.baked.insert(0, BakedMaps { resolution: 16, maps: [(BakedMap::Curvature, Arc::new(vec![0.35; 256]))].into() });
|
||||
let id = s.add_linked_material_bytes_at(&std::fs::read(&exposed).unwrap(), Place::Selection).unwrap();
|
||||
assert_eq!(link(&s, id).size, 128, "cooked at the texture set's resolution");
|
||||
let image = &s.images[&map_name(&s, id, Channel::Roughness)];
|
||||
assert_eq!([image.width, image.height], [128, 128]);
|
||||
assert!(link(&s, id).params.iter().any(|p| p.id == "wear"));
|
||||
execute(&mut s, "material.link.set", &json!({"layer": id.0, "id": "wear", "value": 0.8})).unwrap();
|
||||
let wear = link(&s, id).params.iter().find(|p| p.id == "wear").unwrap().value["v"].as_f64().unwrap();
|
||||
assert!((roughness(&mut s) - 0.5).abs() < 0.01);
|
||||
assert!((s.caches[0].composite.value(Channel::Metallic, 64, 64)[0] - 0.35).abs() < 0.01);
|
||||
execute(&mut s, "material.link.set", &json!({"layer": id.0, "id": "wear", "value": [0.8,0.8,0.8,1.0]})).unwrap();
|
||||
let wear = link(&s, id).params.iter().find(|p| p.id == "wear").unwrap().value["v"][0].as_f64().unwrap();
|
||||
assert!((wear - 0.8).abs() < 1e-6);
|
||||
let out = dir.join("back.sbs");
|
||||
assert!((roughness(&mut s) - 0.8).abs() < 0.01);
|
||||
let out = dir.join("back.mcraft");
|
||||
execute(&mut s, "material.link.saveSource", &json!({"layer": id.0, "path": out.to_str().unwrap()})).unwrap();
|
||||
assert!(std::fs::metadata(&out).unwrap().len() > 0);
|
||||
assert_eq!(std::fs::read(&out).unwrap(), std::fs::read(&exposed).unwrap());
|
||||
|
||||
// The portable material can name a graph other than the first in the embedded source.
|
||||
// Publish a graph with distinct pixels to verify graph selection
|
||||
let multi = dir.join("multi.mcraft");
|
||||
let ok = std::process::Command::new(&cli).arg("run").arg(&exposed).arg("graph.duplicate").arg("{}").arg("-o").arg(&multi).status().unwrap();
|
||||
assert!(ok.success());
|
||||
let edited = dir.join("edited.mcraft");
|
||||
let script = dir.join("edit-graph.json");
|
||||
std::fs::write(
|
||||
&script,
|
||||
json!({
|
||||
"open": multi,
|
||||
"steps": [
|
||||
{"id":"graph.open","params":{"graph":1}},
|
||||
{"id":"graph.exposed.set","params":{"id":"wear","value":[0.2,0.2,0.2,1.0]}}
|
||||
],
|
||||
"save": edited
|
||||
})
|
||||
.to_string(),
|
||||
)
|
||||
.unwrap();
|
||||
let changed = std::process::Command::new(&cli).arg("batch").arg(&script).output().unwrap();
|
||||
assert!(changed.status.success(), "{}", String::from_utf8_lossy(&changed.stderr));
|
||||
let info = std::process::Command::new(&cli).arg("run").arg(&edited).args(["material.info", r#"{"graph":1}"#]).output().unwrap();
|
||||
assert!(info.status.success(), "{}", String::from_utf8_lossy(&info.stderr));
|
||||
let interface: Value = serde_json::from_slice(&info.stdout).unwrap();
|
||||
let expected_graph = interface["graph"].as_str().unwrap();
|
||||
let portable = dir.join("second.mcmat");
|
||||
let params = json!({"graph": 1, "size": 64, "path": portable.to_str().unwrap()});
|
||||
let ok = std::process::Command::new(&cli).arg("run").arg(&multi).arg("file.exportMaterial").arg(params.to_string()).status().unwrap();
|
||||
let ok = std::process::Command::new(&cli).arg("publish").arg(&edited).arg(&portable).args(["--graph", "1"]).status().unwrap();
|
||||
assert!(ok.success());
|
||||
let second = s.add_linked_material_bytes_at(&std::fs::read(&portable).unwrap(), Place::Selection).unwrap();
|
||||
let expected_graph = link(&s, second).graph;
|
||||
let renamed = dir.join("second.asset");
|
||||
std::fs::rename(portable, &renamed).unwrap();
|
||||
let loaded = execute(&mut s, "material.load", &json!({"path":renamed})).unwrap();
|
||||
let second = LayerId(loaded["layer"].as_u64().unwrap());
|
||||
assert_eq!(link(&s, second).graph, expected_graph);
|
||||
let second_map = map_name(&s, second, Channel::Roughness);
|
||||
assert!((s.images[&second_map].rgba[0][0] - 0.2).abs() < 0.01);
|
||||
s.update();
|
||||
assert!((s.caches[0].composite.value(Channel::Metallic, 64, 64)[0] - 0.35).abs() < 0.01);
|
||||
let job = s.link_job(second, &serde_json::Map::new()).unwrap();
|
||||
let result = texturecraft_engine::formats::mcmat::read_mcmat(&job.run().unwrap()).unwrap();
|
||||
assert_eq!(result.manifest.graph, expected_graph);
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
assert_eq!(job.source_ext, "mcmat");
|
||||
assert_eq!(job.package.as_slice(), std::fs::read(&renamed).unwrap());
|
||||
let result = job.run().unwrap();
|
||||
assert_eq!(result.interface.graph, expected_graph);
|
||||
assert_eq!(result.size, 128);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn installing_a_bake_reuses_its_encoded_map_buffers() {
|
||||
let material = cooked(0.25, 0.5);
|
||||
let prepared = &material.maps[1];
|
||||
let mut session = session();
|
||||
|
||||
let id = session.add_cooked_material(&material, Arc::new(Vec::new()), "mcmat", Place::Selection).unwrap();
|
||||
let name = map_name(&session, id, Channel::Roughness);
|
||||
|
||||
assert!(Arc::ptr_eq(&session.doc.resources[&name], &prepared.bytes));
|
||||
assert!(Arc::ptr_eq(&session.images[&name], &prepared.image));
|
||||
}
|
||||
|
||||
#[cfg(target_os = "linux")]
|
||||
#[test]
|
||||
#[ignore = "requires MaterialCraft CLI and at least 8 GiB of available memory"]
|
||||
fn three_8k_maps_respect_budget_and_survive_reopen() {
|
||||
use texturecraft_engine::formats::save_ram_budget;
|
||||
use texturecraft_engine::link_cmds::cook_link_file;
|
||||
|
||||
const RESOLUTION: u32 = 8192;
|
||||
const FIXTURE_AVAILABLE_BYTES: u64 = 16 << 30;
|
||||
if run_in_private_process() {
|
||||
return;
|
||||
}
|
||||
|
||||
let cli = std::env::var_os("MATERIALCRAFT_CLI").expect("set MATERIALCRAFT_CLI to the compatible CLI");
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let mut authoring = temp.path().join("pbr.mcraft");
|
||||
assert!(std::process::Command::new(&cli).args(["new", "pbr"]).arg(&authoring).args(["--size", "32"]).status().unwrap().success());
|
||||
|
||||
// Keep base color, roughness and metallic from the PBR fixture
|
||||
for node in [4, 10, 12] {
|
||||
let next = temp.path().join(format!("after-{node}.mcraft"));
|
||||
let args = json!({"to":node,"toPort":"input"}).to_string();
|
||||
let output = std::process::Command::new(&cli).arg("run").arg(&authoring).args(["graph.disconnect", &args, "-o"]).arg(&next).output().unwrap();
|
||||
assert!(output.status.success(), "{}", String::from_utf8_lossy(&output.stderr));
|
||||
authoring = next;
|
||||
}
|
||||
|
||||
let path = temp.path().join("three.mcmat");
|
||||
assert!(std::process::Command::new(&cli).arg("publish").arg(&authoring).arg(&path).args(["--graph", "0"]).status().unwrap().success());
|
||||
let mut session = Session::new_project("Budget", primitives::cube(1.0), "builtin:cube", None, RESOLUTION).unwrap();
|
||||
let original = session.to_project_bytes().unwrap();
|
||||
|
||||
let save = texturecraft_engine::formats::RamReservation::for_save().unwrap();
|
||||
let blocked = cook_link_file(&path, RESOLUTION, None, LinkMemoryBudget::new(FIXTURE_AVAILABLE_BYTES), Arc::default()).unwrap_err();
|
||||
assert!(blocked.to_string().contains("a project save is using the RAM allowance"));
|
||||
drop(save);
|
||||
|
||||
let low = LinkMemoryBudget::new(save_ram_budget(FIXTURE_AVAILABLE_BYTES, 1));
|
||||
let companion_limited = LinkMemoryBudget::new(save_ram_budget(FIXTURE_AVAILABLE_BYTES, 10));
|
||||
|
||||
let error = cook_link_file(&path, RESOLUTION, None, low, Arc::default()).unwrap_err();
|
||||
|
||||
assert!(error.to_string().contains("configured cap"), "{error}");
|
||||
assert_eq!(session.to_project_bytes().unwrap(), original);
|
||||
|
||||
let error = cook_link_file(&path, RESOLUTION, None, companion_limited, Arc::default()).unwrap_err();
|
||||
|
||||
assert!(error.to_string().contains("MaterialCraft cook failed"), "{error}");
|
||||
assert!(error.to_string().contains("configured cap"), "{error}");
|
||||
assert_eq!(session.to_project_bytes().unwrap(), original);
|
||||
|
||||
let high = LinkMemoryBudget::new(save_ram_budget(FIXTURE_AVAILABLE_BYTES, 50));
|
||||
let (source, cook) = cook_link_file(&path, RESOLUTION, None, high, Arc::default()).unwrap();
|
||||
let probes: Vec<_> = cook.maps.iter().map(|map| Arc::downgrade(&map.image)).collect();
|
||||
|
||||
assert_eq!(cook.maps.len(), 3);
|
||||
assert!(cook.maps.iter().all(|map| [map.image.width, map.image.height] == [RESOLUTION; 2]));
|
||||
|
||||
let layer = session.add_cooked_material(&cook, source.package, source.source_ext, Place::Selection).unwrap();
|
||||
let save_blocked = session.to_project_bytes().unwrap_err();
|
||||
assert!(save_blocked.to_string().contains("a MaterialCraft cook is using the RAM allowance"));
|
||||
drop(cook);
|
||||
let encoded = session.to_project_bytes().unwrap();
|
||||
|
||||
assert!(probes.iter().all(|probe| probe.upgrade().is_some()));
|
||||
execute(&mut session, "edit.undo", &Value::Null).unwrap();
|
||||
assert!(probes.iter().all(|probe| probe.upgrade().is_none()));
|
||||
drop(session);
|
||||
|
||||
let reopened = Session::from_project_bytes(&encoded).unwrap();
|
||||
|
||||
assert!(reopened.doc.project.layer(layer).is_ok());
|
||||
for channel in [Channel::BaseColor, Channel::Roughness, Channel::Metallic] {
|
||||
let name = map_name(&reopened, layer, channel);
|
||||
let image = &reopened.images[&name];
|
||||
assert_eq!([image.width, image.height], [RESOLUTION; 2]);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn image_with_material_extension_reopens_as_an_image() {
|
||||
let mut session = session();
|
||||
let bytes = mesh_map_png(2, 1, &[0.5; 4]).unwrap();
|
||||
let name = session.import_resource_bytes("swatch.sbs", bytes).unwrap();
|
||||
|
||||
let reopened = Session::from_project_bytes(&session.to_project_bytes().unwrap()).unwrap();
|
||||
|
||||
assert_eq!(reopened.images[&name].rgba.len(), 4);
|
||||
}
|
||||
@@ -23,6 +23,8 @@ texturecraft-texel = { workspace = true }
|
||||
texturecraft-geom = { workspace = true }
|
||||
texturecraft-compose = { workspace = true }
|
||||
image = { workspace = true }
|
||||
png = "0.18"
|
||||
bytemuck = { workspace = true, features = ["extern_crate_alloc"] }
|
||||
gltf = { workspace = true }
|
||||
flate2 = { workspace = true }
|
||||
lz4_flex = { workspace = true }
|
||||
|
||||
@@ -21,6 +21,20 @@ pub fn decode_image(bytes: &[u8]) -> Result<DecodedImage> {
|
||||
/// [`decode_image`] for an image of at most `max_texels` (width × height), checked from the
|
||||
/// header, before any pixel is decoded or allocated.
|
||||
pub fn decode_image_within(bytes: &[u8], max_texels: u64) -> Result<DecodedImage> {
|
||||
decode_image_with_limits(bytes, max_texels, image::Limits::default())
|
||||
}
|
||||
|
||||
/// Decode a cook output under both its declared dimensions and decoder allocation budget.
|
||||
pub fn decode_cooked_image(bytes: &[u8], size: [u32; 2], max_decoder_bytes: u64) -> Result<DecodedImage> {
|
||||
let mut limits = image::Limits::default();
|
||||
limits.max_alloc = Some(max_decoder_bytes);
|
||||
limits.max_image_width = Some(size[0]);
|
||||
limits.max_image_height = Some(size[1]);
|
||||
let texels = (u64::from(size[0]) * u64::from(size[1])).min(MAX_RESOURCE_TEXELS);
|
||||
decode_image_with_limits(bytes, texels, limits)
|
||||
}
|
||||
|
||||
fn decode_image_with_limits(bytes: &[u8], max_texels: u64, limits: image::Limits) -> Result<DecodedImage> {
|
||||
let mut reader = image::ImageReader::new(std::io::Cursor::new(bytes))
|
||||
.with_guessed_format()
|
||||
.map_err(|error| FormatError::Malformed { kind: "image", msg: error.to_string() })?;
|
||||
@@ -28,8 +42,11 @@ pub fn decode_image_within(bytes: &[u8], max_texels: u64) -> Result<DecodedImage
|
||||
// TGA has no magic signature; its decoder validates the header when no format was recognized
|
||||
let format = reader.format().unwrap_or(image::ImageFormat::Tga);
|
||||
reader.set_format(format);
|
||||
reader.limits(limits);
|
||||
|
||||
let (width, height) = reader.into_dimensions().map_err(|error| FormatError::Malformed { kind: "image", msg: error.to_string() })?;
|
||||
let (width, height) = image::ImageReader::with_format(std::io::Cursor::new(bytes), format)
|
||||
.into_dimensions()
|
||||
.map_err(|error| FormatError::Malformed { kind: "image", msg: error.to_string() })?;
|
||||
if width == 0 || height == 0 || width > MAX_IMAGE_SIZE || height > MAX_IMAGE_SIZE {
|
||||
return Err(FormatError::TooLarge(format!("image is {width}x{height} (limit {MAX_IMAGE_SIZE})")));
|
||||
}
|
||||
@@ -38,13 +55,21 @@ pub fn decode_image_within(bytes: &[u8], max_texels: u64) -> Result<DecodedImage
|
||||
return Err(FormatError::TooLarge(format!("image is {width}x{height}, more than {max_texels} texels")));
|
||||
}
|
||||
|
||||
let image = crate::guard("image", || {
|
||||
image::load_from_memory_with_format(bytes, format).map_err(|error| FormatError::Malformed { kind: "image", msg: error.to_string() })
|
||||
})?;
|
||||
let image = crate::guard("image", || reader.decode().map_err(|error| FormatError::Malformed { kind: "image", msg: error.to_string() }))?;
|
||||
let srgb = !matches!(image, image::DynamicImage::ImageRgb32F(_) | image::DynamicImage::ImageRgba32F(_));
|
||||
let float_image = image.into_rgba32f();
|
||||
let (width, height) = float_image.dimensions();
|
||||
let rgba = float_image.pixels().map(|pixel| pixel.0).collect();
|
||||
|
||||
// Reuse the float buffer when its allocation can be represented as RGBA pixels
|
||||
let rgba = match bytemuck::allocation::try_cast_vec(float_image.into_raw()) {
|
||||
Ok(rgba) => rgba,
|
||||
Err((_, samples)) => {
|
||||
let mut rgba = Vec::new();
|
||||
rgba.try_reserve_exact(samples.len() / 4).map_err(|error| FormatError::TooLarge(error.to_string()))?;
|
||||
rgba.extend_from_slice(samples.as_chunks::<4>().0);
|
||||
rgba
|
||||
}
|
||||
};
|
||||
|
||||
Ok(DecodedImage { width, height, rgba, srgb })
|
||||
}
|
||||
|
||||
@@ -44,15 +44,15 @@ pub mod zip_read;
|
||||
pub use export::{
|
||||
Dest, ExportInput, ExportOptions, ExportPreset, ExportedFile, FileFormat, MapSpec, Padding, PlannedFile, SourceRef, VirtualMap, list_outputs, render_maps,
|
||||
};
|
||||
pub use image_res::{DecodedImage, coverage_png, decode_image, decode_image_within, gray16_png, gray16_resource};
|
||||
pub use image_res::{DecodedImage, coverage_png, decode_cooked_image, decode_image, decode_image_within, gray16_png, gray16_resource};
|
||||
pub use mesh_export::{GlbTextures, NamedFiles, UsdExport, UsdFormat, glb_bytes, glb_export_options, obj_bytes, obj_with_mtl, usd_bytes, usd_export_options};
|
||||
pub use mesh_import::{HighPolyMesh, ImportedMesh, MeshFile, MeshReport, import_high_poly_bytes, import_mesh_bytes, mesh_report, self_contained_mesh};
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
pub use presets::load_preset;
|
||||
pub use presets::{builtin_preset, builtin_presets, preset_from_json, preset_to_json};
|
||||
pub use project_file::{
|
||||
BakePaintData, DEFAULT_PROJECT_OPEN_LIMIT_GIB, MAX_RESOURCE_NAME_LEN, ProjectFile, load_project_bytes, project_open_limit_gib, sanitize_resource_name,
|
||||
save_project_bytes, set_project_open_limit_gib,
|
||||
BakePaintData, DEFAULT_PROJECT_OPEN_LIMIT_GIB, MAX_RESOURCE_NAME_LEN, ProjectFile, RamReservation, load_project_bytes, project_open_limit_gib,
|
||||
sanitize_resource_name, save_project_bytes, set_project_open_limit_gib,
|
||||
};
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
@@ -61,7 +61,8 @@ pub use export::write_files;
|
||||
pub use mesh_import::{import_mesh, read_mesh_file};
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
pub use project_file::{
|
||||
DEFAULT_RAM_PERCENT, DEFAULT_RESERVED_CORES, available_save_resources, load_project, save_project, save_ram_budget, set_save_resources,
|
||||
DEFAULT_RAM_PERCENT, DEFAULT_RESERVED_CORES, available_save_resources, configured_ram_budget, load_project, save_project, save_ram_budget,
|
||||
set_save_resources,
|
||||
};
|
||||
|
||||
#[derive(Debug, thiserror::Error)]
|
||||
|
||||
+121
-202
@@ -1,251 +1,170 @@
|
||||
//! MaterialCraft portable materials (`.mcmat`, read only): a zip with `material.json` (the
|
||||
//! manifest: maps by usage, exposed parameters, image inputs, presets), `maps/<usage>.png`
|
||||
//! (8-bit sRGB for color usages, 16-bit linear otherwise; OpenGL normals) and the
|
||||
//! source package. The shared reader handles the portable container and manifest.
|
||||
//!
|
||||
//! Also the 16-bit PNG encoder that hands baked mesh maps to MaterialCraft as graph inputs.
|
||||
|
||||
use std::io::Cursor;
|
||||
|
||||
use serde::Deserialize;
|
||||
use texturecraft_core::{LinkParam, LinkPreset};
|
||||
|
||||
//! Validate a procedural MCMAT and encode caller-supplied mesh maps for MaterialCraft.
|
||||
use crate::{FormatError, Result};
|
||||
use std::io::Write;
|
||||
|
||||
mod version_marker;
|
||||
use version_marker::VersionMarker;
|
||||
|
||||
/// The portable material extension.
|
||||
pub const MCMAT_EXT: &str = "mcmat";
|
||||
/// MaterialCraft's package extension.
|
||||
pub const MCRAFT_EXT: &str = "mcraft";
|
||||
const VERSION: u32 = 2;
|
||||
/// Largest entry read (maps are at most 8192² × 16 bits, compressed).
|
||||
const MAX_ENTRY: u64 = 512 << 20;
|
||||
/// Most map entries one manifest may name (a material has at most nine usages).
|
||||
const MAX_MAPS: usize = 64;
|
||||
/// Largest total payload read from one `.mcmat`: maps and source together (audit: TextureCraft #4).
|
||||
const MAX_TOTAL: u64 = 1 << 30;
|
||||
const KIND: &str = "MaterialCraft material";
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct Manifest {
|
||||
pub format: String,
|
||||
pub version: u32,
|
||||
pub name: String,
|
||||
pub graph: String,
|
||||
pub size: [u32; 2],
|
||||
pub maps: Vec<MapEntry>,
|
||||
#[serde(default)]
|
||||
pub parameters: Vec<LinkParam>,
|
||||
#[serde(default)]
|
||||
pub inputs: Vec<ImageInput>,
|
||||
#[serde(default)]
|
||||
pub presets: Vec<LinkPreset>,
|
||||
pub source: String,
|
||||
}
|
||||
/// Diagnose old versions before starting the CLI. The shared reader in MaterialCraft
|
||||
/// validates and extracts the full archive.
|
||||
pub fn validate_mcmat_version(bytes: &[u8], manifest_budget_bytes: u64) -> Result<()> {
|
||||
let limits = craft_mcmat::Limits::default();
|
||||
let mut archive = craft_zip::Archive::open(bytes, craft_zip::Limits { max_entries: limits.max_entries, max_total_bytes: manifest_budget_bytes })
|
||||
.map_err(mcmat_archive_error)?;
|
||||
let bytes = archive
|
||||
.read(craft_mcmat::MANIFEST_ENTRY, limits.max_manifest_bytes.min(manifest_budget_bytes))
|
||||
.map_err(mcmat_archive_error)?
|
||||
.ok_or_else(|| mcmat_invalid("missing material.json"))?;
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct MapEntry {
|
||||
/// `baseColor`, `normal`, `roughness`, `metallic`, `height`, `ambientOcclusion`, `emissive`,
|
||||
/// `opacity` or `specular`.
|
||||
pub usage: String,
|
||||
pub file: String,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Deserialize)]
|
||||
pub struct ImageInput {
|
||||
pub identifier: String,
|
||||
}
|
||||
|
||||
/// A read `.mcmat`: the manifest, each map's PNG bytes by usage, the source package.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct PortableMaterial {
|
||||
pub manifest: Manifest,
|
||||
pub maps: Vec<(String, Vec<u8>)>,
|
||||
pub source: Vec<u8>,
|
||||
}
|
||||
|
||||
fn malformed(msg: impl Into<String>) -> FormatError {
|
||||
FormatError::Malformed { kind: KIND, msg: msg.into() }
|
||||
}
|
||||
|
||||
fn shared_error(error: craft_mcmat::Error) -> FormatError {
|
||||
match error {
|
||||
craft_mcmat::Error::Version(version) => FormatError::Unsupported(format!("{KIND} version {version} (this version reads up to {VERSION})")),
|
||||
craft_mcmat::Error::Limit(message) => malformed(message),
|
||||
craft_mcmat::Error::Archive(ref archive) if archive.is_limit() => FormatError::TooLarge(error.to_string()),
|
||||
other => malformed(other.to_string()),
|
||||
// A marker must be an object even though Serde also accepts positional struct fields
|
||||
if !bytes.trim_ascii_start().starts_with(b"{") {
|
||||
return Err(mcmat_invalid("expected a version object"));
|
||||
}
|
||||
|
||||
let marker: VersionMarker = serde_json::from_slice(&bytes).map_err(mcmat_invalid)?;
|
||||
if marker.version != craft_mcmat::VERSION {
|
||||
return Err(FormatError::Unsupported(craft_mcmat::Error::Version(marker.version).to_string()));
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Read `.mcmat` bytes within TextureCraft's existing per-entry and total payload limits.
|
||||
pub fn read_mcmat(bytes: &[u8]) -> Result<PortableMaterial> {
|
||||
let limits = craft_mcmat::Limits {
|
||||
min_version: 0,
|
||||
max_version: VERSION,
|
||||
max_entries: 100_000,
|
||||
max_maps: MAX_MAPS,
|
||||
max_manifest_bytes: MAX_ENTRY,
|
||||
max_entry_bytes: MAX_ENTRY,
|
||||
max_total_bytes: MAX_TOTAL,
|
||||
};
|
||||
let mut archive = craft_mcmat::Material::open(bytes, limits).map_err(shared_error)?;
|
||||
// Consume the JSON values rather than cloning the entire untrusted manifest into a second tree.
|
||||
let parameters = std::mem::take(&mut archive.manifest.parameters)
|
||||
.into_iter()
|
||||
.map(serde_json::from_value)
|
||||
.collect::<std::result::Result<_, _>>()
|
||||
.map_err(|e| malformed(format!("material.json: {e}")))?;
|
||||
let inputs = std::mem::take(&mut archive.manifest.inputs)
|
||||
.into_iter()
|
||||
.map(serde_json::from_value)
|
||||
.collect::<std::result::Result<_, _>>()
|
||||
.map_err(|e| malformed(format!("material.json: {e}")))?;
|
||||
let presets = std::mem::take(&mut archive.manifest.presets)
|
||||
.into_iter()
|
||||
.map(serde_json::from_value)
|
||||
.collect::<std::result::Result<_, _>>()
|
||||
.map_err(|e| malformed(format!("material.json: {e}")))?;
|
||||
let shared = &archive.manifest;
|
||||
let manifest = Manifest {
|
||||
format: shared.format.clone(),
|
||||
version: shared.version,
|
||||
name: shared.name.clone(),
|
||||
graph: shared.graph.clone(),
|
||||
size: shared.size,
|
||||
maps: shared.maps.iter().map(|m| MapEntry { usage: m.usage.clone(), file: m.file.clone() }).collect(),
|
||||
parameters,
|
||||
inputs,
|
||||
presets,
|
||||
source: shared.source.clone(),
|
||||
};
|
||||
let maps = manifest.maps.iter().map(|map| Ok((map.usage.clone(), archive.read(&map.file).map_err(shared_error)?))).collect::<Result<Vec<_>>>()?;
|
||||
let source = archive.read_source().map_err(shared_error)?;
|
||||
Ok(PortableMaterial { manifest, maps, source })
|
||||
fn mcmat_invalid(error: impl std::fmt::Display) -> FormatError {
|
||||
FormatError::Malformed { kind: "MaterialCraft material", msg: error.to_string() }
|
||||
}
|
||||
|
||||
fn mcmat_archive_error(error: craft_zip::Error) -> FormatError {
|
||||
if error.is_limit() {
|
||||
return FormatError::TooLarge(error.to_string());
|
||||
}
|
||||
|
||||
mcmat_invalid(error)
|
||||
}
|
||||
|
||||
/// Whether `bytes` contain a portable material manifest within the ZIP entry limit.
|
||||
pub fn is_mcmat(bytes: &[u8]) -> bool {
|
||||
craft_mcmat::is_material(bytes, 100_000)
|
||||
craft_mcmat::is_material(bytes, craft_mcmat::Limits::default().max_entries)
|
||||
}
|
||||
|
||||
pub fn is_mcraft(bytes: &[u8]) -> bool {
|
||||
let Ok(mut archive) = craft_zip::Archive::open(bytes, craft_zip::Limits { max_entries: 100_000, max_total_bytes: 0 }) else { return false };
|
||||
// A portable material may itself contain source.sbs, so it is not a source archive.
|
||||
if archive.has_duplicate_names() || archive.contains("material.json") {
|
||||
let limits = craft_zip::Limits { max_entries: craft_mcmat::Limits::default().max_entries, max_total_bytes: 0 };
|
||||
let Ok(mut archive) = craft_zip::Archive::open(bytes, limits) else {
|
||||
return false;
|
||||
};
|
||||
|
||||
// A portable material may contain source.sbs inside its envelope
|
||||
if archive.has_duplicate_names() || archive.contains(craft_mcmat::MANIFEST_ENTRY) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if archive.contains("package.json") {
|
||||
return true;
|
||||
}
|
||||
(0..archive.len()).any(|i| archive.entry_name(i).ok().flatten().is_some_and(|name| !name.contains('/') && name.to_ascii_lowercase().ends_with(".sbs")))
|
||||
|
||||
(0..archive.len()).any(|index| archive.entry_name(index).ok().flatten().as_deref().is_some_and(is_root_sbs))
|
||||
}
|
||||
|
||||
pub(crate) fn is_root_sbs(name: &str) -> bool {
|
||||
!name.contains('/') && name.rsplit_once('.').is_some_and(|(_, extension)| extension.eq_ignore_ascii_case("sbs"))
|
||||
}
|
||||
|
||||
/// A baked mesh map (`components` floats per texel, 0..1, rows top first) as a 16-bit PNG
|
||||
/// (grayscale for one component, RGB for three).
|
||||
pub fn mesh_map_png(width: u32, components: usize, data: &[f32]) -> Result<Vec<u8>> {
|
||||
let per_row = (width as usize).saturating_mul(components);
|
||||
let height = data.len().checked_div(per_row).unwrap_or(0) as u32;
|
||||
if height == 0 || !matches!(components, 1 | 3) {
|
||||
return Err(FormatError::Invalid(format!("mesh map of {} values, {width} wide, {components} components", data.len())));
|
||||
let mut encoded = Vec::new();
|
||||
write_mesh_map_png(&mut encoded, width, components, data)?;
|
||||
Ok(encoded)
|
||||
}
|
||||
|
||||
/// Estimated workspace for one quantized row, three encoder rows and the deflate state.
|
||||
pub fn mesh_map_png_working_bytes(width_px: u32, components: usize) -> u64 {
|
||||
const DEFLATE_WORKSPACE_BYTES: u64 = 1 << 20;
|
||||
|
||||
u64::from(width_px).saturating_mul(components as u64).saturating_mul(4 * std::mem::size_of::<u16>() as u64).saturating_add(DEFLATE_WORKSPACE_BYTES)
|
||||
}
|
||||
|
||||
/// Encode a mesh map directly into its destination using one row of quantized samples.
|
||||
pub fn write_mesh_map_png(output: impl Write, width_px: u32, components: usize, data: &[f32]) -> Result<()> {
|
||||
let invalid_size = || FormatError::Invalid(format!("mesh map of {} values, {width_px} wide, {components} components", data.len()));
|
||||
let color = match components {
|
||||
1 => png::ColorType::Grayscale,
|
||||
3 => png::ColorType::Rgb,
|
||||
_ => return Err(invalid_size()),
|
||||
};
|
||||
let samples_per_row = (width_px as usize).checked_mul(components).filter(|&count| count != 0).ok_or_else(invalid_size)?;
|
||||
if data.is_empty() || !data.len().is_multiple_of(samples_per_row) {
|
||||
return Err(invalid_size());
|
||||
}
|
||||
let px: Vec<u16> = data.iter().take(per_row * height as usize).map(|v| (v.clamp(0.0, 1.0) * 65535.0).round() as u16).collect();
|
||||
let img = if components == 1 {
|
||||
image::ImageBuffer::<image::Luma<u16>, _>::from_raw(width, height, px).map(image::DynamicImage::ImageLuma16)
|
||||
} else {
|
||||
image::ImageBuffer::<image::Rgb<u16>, _>::from_raw(width, height, px).map(image::DynamicImage::ImageRgb16)
|
||||
|
||||
let height_px = u32::try_from(data.len() / samples_per_row).map_err(|_| invalid_size())?;
|
||||
let row_bytes = samples_per_row.checked_mul(std::mem::size_of::<u16>()).ok_or_else(invalid_size)?;
|
||||
let mut scanline = Vec::new();
|
||||
scanline.try_reserve_exact(row_bytes).map_err(|error| FormatError::TooLarge(error.to_string()))?;
|
||||
|
||||
let encoding_error = |error: png::EncodingError| FormatError::Invalid(error.to_string());
|
||||
let mut encoder = png::Encoder::new(output, width_px, height_px);
|
||||
encoder.set_color(color);
|
||||
encoder.set_depth(png::BitDepth::Sixteen);
|
||||
|
||||
// The file exists only while the companion reads the input
|
||||
encoder.set_compression(png::Compression::Fast);
|
||||
let mut writer = encoder.write_header().map_err(encoding_error)?;
|
||||
{
|
||||
let mut stream = writer.stream_writer().map_err(encoding_error)?;
|
||||
for row in data.chunks_exact(samples_per_row) {
|
||||
scanline.clear();
|
||||
scanline.extend(row.iter().flat_map(|value| ((value.clamp(0.0, 1.0) * f32::from(u16::MAX)).round() as u16).to_be_bytes()));
|
||||
stream.write_all(&scanline)?;
|
||||
}
|
||||
|
||||
stream.finish().map_err(encoding_error)?;
|
||||
}
|
||||
.ok_or_else(|| FormatError::Invalid("mesh map size".into()))?;
|
||||
let mut out = Vec::new();
|
||||
img.write_to(&mut Cursor::new(&mut out), image::ImageFormat::Png).map_err(|e| FormatError::Invalid(e.to_string()))?;
|
||||
Ok(out)
|
||||
|
||||
writer.finish().map_err(encoding_error)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use std::io::Write;
|
||||
|
||||
/// A `.mcmat` as MaterialCraft writes it (see its `formats/src/material.rs`).
|
||||
pub(crate) fn sample(version: u32) -> Vec<u8> {
|
||||
let source = if version >= 2 { "source.sbs" } else { "source.mcraft" };
|
||||
let manifest = serde_json::json!({
|
||||
"format": "craft-material", "version": version, "name": "Brick wall", "graph": "Brick_wall", "size": [4, 4],
|
||||
"maps": [{"usage": "baseColor", "file": "maps/baseColor.png", "colorSpace": "srgb"}],
|
||||
"parameters": [{"id": "wear", "label": "Wear", "default": {"t": "float", "v": 0.5}, "min": 0.0, "max": 1.0, "value": {"t": "float", "v": 0.25}}],
|
||||
"inputs": [{"identifier": "curvature", "kind": "gray"}],
|
||||
"presets": [{"name": "Worn", "values": {"wear": {"t": "float", "v": 1.0}}}],
|
||||
"source": source, "futureField": true
|
||||
});
|
||||
let mut z = zip::ZipWriter::new(Cursor::new(Vec::new()));
|
||||
let o = zip::write::SimpleFileOptions::default();
|
||||
z.start_file("material.json", o).unwrap();
|
||||
z.write_all(manifest.to_string().as_bytes()).unwrap();
|
||||
z.start_file("maps/baseColor.png", o).unwrap();
|
||||
z.write_all(&mesh_map_png(4, 3, &[0.5; 48]).unwrap()).unwrap();
|
||||
z.start_file(source, o).unwrap();
|
||||
z.write_all(b"pkg").unwrap();
|
||||
z.finish().unwrap().into_inner()
|
||||
}
|
||||
use std::io::Cursor;
|
||||
|
||||
#[test]
|
||||
fn reads_manifest_maps_and_source() {
|
||||
let bytes = sample(1);
|
||||
|
||||
assert!(is_mcmat(&bytes) && !is_mcraft(&bytes));
|
||||
let material = read_mcmat(&bytes).unwrap();
|
||||
|
||||
assert_eq!(material.manifest.graph, "Brick_wall");
|
||||
assert_eq!(material.manifest.parameters[0].id, "wear");
|
||||
assert_eq!(material.manifest.parameters[0].value, serde_json::json!({"t": "float", "v": 0.25}));
|
||||
assert_eq!(material.manifest.presets[0].name, "Worn");
|
||||
assert_eq!(material.manifest.inputs[0].identifier, "curvature");
|
||||
assert_eq!(material.maps[0].0, "baseColor");
|
||||
assert_eq!(crate::decode_image(&material.maps[0].1).unwrap().width, 4);
|
||||
assert_eq!(material.source, b"pkg");
|
||||
let current = read_mcmat(&sample(2)).unwrap();
|
||||
assert_eq!(current.manifest.source, "source.sbs");
|
||||
assert_eq!(current.source, b"pkg");
|
||||
assert!(matches!(read_mcmat(&sample(3)), Err(FormatError::Unsupported(_))));
|
||||
assert!(read_mcmat(b"junk").is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn recognizes_both_generations_of_source_archive_without_confusing_portable_materials() {
|
||||
for entry in ["package.json", "package.sbs"] {
|
||||
fn recognizes_v3_and_directs_older_authors_to_republish() {
|
||||
let source = craft_mcmat::write(b"<package/>", []).unwrap();
|
||||
assert!(is_mcmat(&source) && !is_mcraft(&source));
|
||||
validate_mcmat_version(&source, 1 << 20).unwrap();
|
||||
for version in [1, 2] {
|
||||
let mut zip = zip::ZipWriter::new(Cursor::new(Vec::new()));
|
||||
zip.start_file(entry, zip::write::SimpleFileOptions::default()).unwrap();
|
||||
zip.write_all(b"source").unwrap();
|
||||
let bytes = zip.finish().unwrap().into_inner();
|
||||
assert!(is_mcraft(&bytes), "{entry}");
|
||||
zip.start_file("material.json", zip::write::SimpleFileOptions::default()).unwrap();
|
||||
write!(zip, r#"{{"version":{version}}}"#).unwrap();
|
||||
let err = validate_mcmat_version(&zip.finish().unwrap().into_inner(), 1 << 20).unwrap_err();
|
||||
assert!(err.to_string().contains("Republish"));
|
||||
}
|
||||
assert!(!is_mcraft(&sample(2)), "a portable material contains source.sbs too");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_unbounded_map_list_is_refused() {
|
||||
let maps: Vec<_> = (0..=MAX_MAPS).map(|_| serde_json::json!({"usage": "baseColor", "file": "maps/baseColor.png"})).collect();
|
||||
let manifest = serde_json::json!({"format": craft_mcmat::FORMAT, "version": VERSION, "name": "n", "graph": "g", "size": [4, 4], "maps": maps, "source": "source.mcraft"});
|
||||
let mut archive = zip::ZipWriter::new(Cursor::new(Vec::new()));
|
||||
let options = zip::write::SimpleFileOptions::default();
|
||||
archive.start_file("material.json", options).unwrap();
|
||||
archive.write_all(manifest.to_string().as_bytes()).unwrap();
|
||||
archive.start_file("maps/baseColor.png", options).unwrap();
|
||||
archive.write_all(&mesh_map_png(4, 3, &[0.5; 48]).unwrap()).unwrap();
|
||||
archive.start_file("source.mcraft", options).unwrap();
|
||||
archive.write_all(b"pkg").unwrap();
|
||||
fn version_marker_requires_one_named_version() {
|
||||
for marker in [r#"{"version":2,"version":3}"#, "[3]"] {
|
||||
let mut zip = zip::ZipWriter::new(Cursor::new(Vec::new()));
|
||||
zip.start_file(craft_mcmat::MANIFEST_ENTRY, zip::write::SimpleFileOptions::default()).unwrap();
|
||||
zip.write_all(marker.as_bytes()).unwrap();
|
||||
let bytes = zip.finish().unwrap().into_inner();
|
||||
|
||||
let result = read_mcmat(&archive.finish().unwrap().into_inner());
|
||||
|
||||
assert!(matches!(result, Err(FormatError::Malformed { .. })));
|
||||
assert!(validate_mcmat_version(&bytes, 1 << 20).is_err());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mesh_maps_encode_as_16_bit() {
|
||||
let png = mesh_map_png(2, 1, &[0.0, 0.25, 0.5, 1.0]).unwrap();
|
||||
let d = crate::decode_image(&png).unwrap();
|
||||
assert_eq!((d.width, d.height), (2, 2));
|
||||
assert!((d.rgba[1][0] - 0.25).abs() < 1e-4);
|
||||
let decoded = crate::decode_image(&png).unwrap();
|
||||
|
||||
assert_eq!((decoded.width, decoded.height), (2, 2));
|
||||
assert!((decoded.rgba[1][0] - 0.25).abs() < 1e-4);
|
||||
assert!(mesh_map_png(2, 1, &[0.0; 3]).is_err());
|
||||
assert!(mesh_map_png(0, 1, &[]).is_err());
|
||||
assert!(mesh_map_png(2, 2, &[0.0; 8]).is_err());
|
||||
}
|
||||
|
||||
@@ -0,0 +1,5 @@
|
||||
/// Only the version is needed before handing the full package to MaterialCraft.
|
||||
#[derive(serde::Deserialize)]
|
||||
pub(super) struct VersionMarker {
|
||||
pub(super) version: u32,
|
||||
}
|
||||
@@ -60,7 +60,8 @@ mod limits {
|
||||
pub fn available_ram() -> u64 {
|
||||
let Ok(mut sys) = sysinfo::System::new() else { return FALLBACK_AVAILABLE_RAM_BYTES };
|
||||
sys.refresh_memory();
|
||||
reported_ram(sys.available_memory(), sys.total_memory())
|
||||
let available_bytes = reported_ram(sys.available_memory(), sys.total_memory());
|
||||
sys.cgroup_limits().map_or(available_bytes, |limits| available_bytes.min(limits.free_memory))
|
||||
}
|
||||
|
||||
fn reported_ram(available: u64, total: u64) -> u64 {
|
||||
@@ -109,6 +110,12 @@ pub fn save_ram_budget(available_ram_bytes: u64, ram_percent: u8) -> u64 {
|
||||
u64::try_from(u128::from(available_ram_bytes) * u128::from(ram_percent.clamp(1, 100)) / 100).unwrap_or(u64::MAX)
|
||||
}
|
||||
|
||||
/// The configured Settings share of currently available RAM, in bytes.
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
pub fn configured_ram_budget() -> u64 {
|
||||
save_ram_budget(limits::available_ram(), limits::get().1)
|
||||
}
|
||||
|
||||
/// Worker threads and in-flight byte budget for a save of `entries` entries.
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
pub(super) fn plan(cpus: usize, reserved_cores: usize, entries: usize, available_ram: u64, ram_percent: u8) -> (usize, u64) {
|
||||
|
||||
@@ -18,6 +18,7 @@
|
||||
//! count of 0, followed by `width × height × components` f32 LE. Pixels of a UV-tiled texture
|
||||
//! set cover its whole atlas (`resolution` per tile, see `TileGrid`).
|
||||
|
||||
use std::borrow::Borrow;
|
||||
use std::collections::{BTreeMap, HashSet};
|
||||
use std::io::{Cursor, Read, Seek, Write};
|
||||
use std::sync::Arc;
|
||||
@@ -35,9 +36,12 @@ use crate::{FormatError, MAX_IMAGE_SIZE, Result, malformed};
|
||||
mod entries;
|
||||
mod load_budget;
|
||||
mod project_open_limit;
|
||||
mod ram_operation;
|
||||
mod ram_reservation;
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
pub use entries::{DEFAULT_RAM_PERCENT, DEFAULT_RESERVED_CORES, available_save_resources, save_ram_budget, set_save_resources};
|
||||
pub use entries::{DEFAULT_RAM_PERCENT, DEFAULT_RESERVED_CORES, available_save_resources, configured_ram_budget, save_ram_budget, set_save_resources};
|
||||
pub use project_open_limit::{DEFAULT_PROJECT_OPEN_LIMIT_GIB, project_open_limit_gib, set_project_open_limit_gib};
|
||||
pub use ram_reservation::RamReservation;
|
||||
|
||||
const KIND: &str = "project file";
|
||||
#[cfg(test)]
|
||||
@@ -61,7 +65,7 @@ pub use bake_paint_data::BakePaintData;
|
||||
|
||||
/// Everything a project file holds.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct ProjectFile {
|
||||
pub struct ProjectFile<Resource = Vec<u8>> {
|
||||
pub project: Project,
|
||||
pub pixels: PixelStore,
|
||||
/// Baked mesh maps per texture set index.
|
||||
@@ -76,7 +80,7 @@ pub struct ProjectFile {
|
||||
pub bake_paint: BTreeMap<(usize, BakePaintTarget), BakePaintData>,
|
||||
pub thumbnail: Option<Vec<u8>>,
|
||||
/// Imported resources (images used by fills, alphas, stencils), by name: original bytes.
|
||||
pub resources: BTreeMap<String, Vec<u8>>,
|
||||
pub resources: BTreeMap<String, Resource>,
|
||||
/// Import warnings for the caller's log; never saved in the archive
|
||||
pub warnings: Vec<String>,
|
||||
}
|
||||
@@ -95,14 +99,17 @@ pub fn sanitize_resource_name(name: &str) -> String {
|
||||
// Save.
|
||||
|
||||
pub fn save_project_bytes(pf: &ProjectFile) -> Result<Vec<u8>> {
|
||||
let mut out = Cursor::new(Vec::new());
|
||||
write_project(&mut out, pf)?;
|
||||
Ok(out.into_inner())
|
||||
RamReservation::for_save()?.save_bytes(pf)
|
||||
}
|
||||
|
||||
/// Save atomically through a newly created temporary file beside `path`.
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
pub fn save_project(path: &std::path::Path, project_file: &ProjectFile) -> Result<()> {
|
||||
RamReservation::for_save()?.save(path, project_file)
|
||||
}
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
fn write_project_atomic(path: &std::path::Path, project_file: &ProjectFile<impl Borrow<Vec<u8>>>) -> Result<()> {
|
||||
let (temporary_path, file) = crate::create_temp(path)?;
|
||||
let result = (|| -> Result<()> {
|
||||
let mut file = std::io::BufWriter::new(file);
|
||||
@@ -180,7 +187,7 @@ fn write_baked(w: &mut dyn Write, res: u32, h: u32, comps: usize, data: &[f32])
|
||||
}
|
||||
|
||||
/// The zip entries of a project file, in file order. Bodies run later, possibly on other threads.
|
||||
fn entries(pf: &ProjectFile) -> Result<Vec<Entry<'_>>> {
|
||||
fn entries(pf: &ProjectFile<impl Borrow<Vec<u8>>>) -> Result<Vec<Entry<'_>>> {
|
||||
let deflate = SimpleFileOptions::default().compression_method(CompressionMethod::Deflated).large_file(true);
|
||||
let stored = SimpleFileOptions::default().compression_method(CompressionMethod::Stored);
|
||||
let json = serde_json::to_vec_pretty(&pf.project).map_err(|e| FormatError::Invalid(e.to_string()))?;
|
||||
@@ -206,6 +213,7 @@ fn entries(pf: &ProjectFile) -> Result<Vec<Entry<'_>>> {
|
||||
if map.width == 0 || map.height == 0 || map.values.len() as u64 != u64::from(map.width) * u64::from(map.height) {
|
||||
return Err(FormatError::Invalid("bake paint map dimensions do not match its values".into()));
|
||||
}
|
||||
|
||||
let target_name = match target {
|
||||
BakePaintTarget::Cage => "cage",
|
||||
BakePaintTarget::Skew => "skew",
|
||||
@@ -237,11 +245,12 @@ fn entries(pf: &ProjectFile) -> Result<Vec<Entry<'_>>> {
|
||||
for (ts, maps) in &pf.baked {
|
||||
let r = maps.resolution;
|
||||
for (m, data) in &maps.maps {
|
||||
// A map whose size disagrees with its width cannot be loaded; it can be re-baked.
|
||||
// Skip inconsistent maps so the saved project can reopen and bake them again
|
||||
let h = maps.height(*m);
|
||||
if h == 0 || data.len() != (r as usize) * (h as usize) * m.components() {
|
||||
continue;
|
||||
}
|
||||
|
||||
let comps = m.components();
|
||||
out.push(Entry {
|
||||
name: format!("baked/{ts}_{}.bin", m.id()),
|
||||
@@ -255,7 +264,8 @@ fn entries(pf: &ProjectFile) -> Result<Vec<Entry<'_>>> {
|
||||
out.push(Entry { name: "thumbnail.png".into(), options: stored, weight: png.len() as u64, body: Box::new(move |w| w.write_all(png)) });
|
||||
}
|
||||
used.clear();
|
||||
for (name, bytes) in &pf.resources {
|
||||
for (name, resource) in &pf.resources {
|
||||
let bytes = resource.borrow();
|
||||
out.push(Entry {
|
||||
name: unique_entry_name("resources", name, &mut used),
|
||||
options: stored,
|
||||
@@ -266,7 +276,7 @@ fn entries(pf: &ProjectFile) -> Result<Vec<Entry<'_>>> {
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
fn write_project<W: Write + Seek>(out: W, pf: &ProjectFile) -> Result<()> {
|
||||
fn write_project<W: Write + Seek>(out: W, pf: &ProjectFile<impl Borrow<Vec<u8>>>) -> Result<()> {
|
||||
let mut zip = ZipWriter::new(out);
|
||||
entries::write_entries(&mut zip, entries(pf)?)?;
|
||||
zip.finish().map_err(zip_err)?;
|
||||
@@ -286,6 +296,23 @@ pub fn load_project(path: &std::path::Path) -> Result<ProjectFile> {
|
||||
crate::guard(KIND, || load(std::io::BufReader::new(file)))
|
||||
}
|
||||
|
||||
/// Read a native smart material in place. MaterialCraft packages go to the bounded cook reader.
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
pub fn load_smart_material_project(file: std::fs::File) -> Result<Option<ProjectFile>> {
|
||||
crate::guard(KIND, || {
|
||||
let archive = open_archive(std::io::BufReader::new(file), MAX_ZIP_METADATA_BYTES)?;
|
||||
if archive.index_for_name(craft_mcmat::MANIFEST_ENTRY).is_some()
|
||||
|| archive.index_for_name("package.json").is_some()
|
||||
|| archive.file_names().any(|name| name.is_ok_and(|name| crate::mcmat::is_root_sbs(&name)))
|
||||
{
|
||||
return Ok(None);
|
||||
}
|
||||
|
||||
let budget = LoadBudget::new(u64::from(project_open_limit_gib()) << 30);
|
||||
load_archive(archive, budget).map(Some)
|
||||
})
|
||||
}
|
||||
|
||||
fn read_all(reader: &mut impl Read, cap: u64, budget: &mut LoadBudget, what: &str) -> Result<Vec<u8>> {
|
||||
let mut out = Vec::new();
|
||||
|
||||
@@ -359,8 +386,11 @@ fn open_archive<R: Read + Seek>(reader: R, metadata_bytes: u64) -> Result<ZipArc
|
||||
Ok(archive)
|
||||
}
|
||||
|
||||
fn load_with_budget<R: Read + Seek>(reader: R, mut budget: LoadBudget) -> Result<ProjectFile> {
|
||||
let mut zip = open_archive(reader, MAX_ZIP_METADATA_BYTES)?;
|
||||
fn load_with_budget<R: Read + Seek>(reader: R, budget: LoadBudget) -> Result<ProjectFile> {
|
||||
load_archive(open_archive(reader, MAX_ZIP_METADATA_BYTES)?, budget)
|
||||
}
|
||||
|
||||
fn load_archive<R: Read + Seek>(mut zip: ZipArchive<R>, mut budget: LoadBudget) -> Result<ProjectFile> {
|
||||
check_archive(&mut zip, budget.remaining())?;
|
||||
|
||||
let json = read_all(&mut zip.by_name("project.json").map_err(zip_err)?, MAX_JSON, &mut budget, "project.json")?;
|
||||
@@ -394,6 +424,8 @@ fn load_with_budget<R: Read + Seek>(reader: R, mut budget: LoadBudget) -> Result
|
||||
let declared_bytes = f.size();
|
||||
let name = f.name().map_err(zip_err)?.into_owned();
|
||||
let size_of = |id: LayerId| texture_set_of(&pf.project, id).and_then(|ts| pf.project.texture_sets.get(ts)).map(|t| t.size());
|
||||
|
||||
// Unrecognized entries from newer minor revisions may be skipped
|
||||
if name == "thumbnail.png" {
|
||||
pf.thumbnail = Some(read_all(&mut f, MAX_THUMBNAIL, &mut budget, &name)?);
|
||||
} else if let Some(res_name) = name.strip_prefix("resources/") {
|
||||
@@ -434,6 +466,7 @@ fn load_with_budget<R: Read + Seek>(reader: R, mut budget: LoadBudget) -> Result
|
||||
let (id, chan) = rest.split_once('_').ok_or_else(|| malformed(KIND, format!("bad entry name {name}")))?;
|
||||
let id = LayerId(id.parse().map_err(|_| malformed(KIND, format!("bad entry name {name}")))?);
|
||||
let c = Channel::ALL.into_iter().find(|c| c.id() == chan).ok_or_else(|| malformed(KIND, format!("unknown channel in {name}")))?;
|
||||
|
||||
// Drop pixels of layers that are no longer in any stack
|
||||
let Some(size) = size_of(id) else { continue };
|
||||
|
||||
@@ -464,9 +497,9 @@ fn load_with_budget<R: Read + Seek>(reader: R, mut budget: LoadBudget) -> Result
|
||||
} else if maps.resolution != res || maps.maps.keys().next().is_some_and(|k| maps.height(*k) != height) {
|
||||
return Err(malformed(KIND, format!("{name}: baked maps of one texture set differ in size")));
|
||||
}
|
||||
|
||||
maps.maps.insert(m, Arc::new(data));
|
||||
}
|
||||
// Ignore other entries from newer minor revisions
|
||||
}
|
||||
|
||||
if version < TANGENT_BENT_NORMAL_VERSION {
|
||||
|
||||
@@ -0,0 +1,5 @@
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub(super) enum RamOperation {
|
||||
Cook,
|
||||
Save,
|
||||
}
|
||||
@@ -0,0 +1,84 @@
|
||||
use std::borrow::Borrow;
|
||||
use std::io::Cursor;
|
||||
use std::sync::{Condvar, Mutex};
|
||||
|
||||
use super::{ProjectFile, ram_operation::RamOperation, write_project};
|
||||
use crate::{FormatError, Result};
|
||||
|
||||
static ACTIVE_OPERATION: Mutex<Option<RamOperation>> = Mutex::new(None);
|
||||
static RELEASED: Condvar = Condvar::new();
|
||||
|
||||
/// Shares the Settings allowance between linked cooks and project save workers.
|
||||
#[derive(Debug)]
|
||||
pub struct RamReservation(RamOperation);
|
||||
|
||||
impl RamReservation {
|
||||
/// Reserve the allowance through cooking, decoding and result delivery.
|
||||
pub fn for_cook() -> Result<Self> {
|
||||
let mut active = ACTIVE_OPERATION.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
|
||||
let message = match *active {
|
||||
None => {
|
||||
*active = Some(RamOperation::Cook);
|
||||
return Ok(Self(RamOperation::Cook));
|
||||
}
|
||||
Some(RamOperation::Cook) => "another MaterialCraft cook is still running",
|
||||
Some(RamOperation::Save) => "a project save is using the RAM allowance; retry the cook after saving",
|
||||
};
|
||||
|
||||
Err(FormatError::Invalid(message.into()))
|
||||
}
|
||||
|
||||
/// Serialize saves while giving the UI backpressure if a cook owns the allowance.
|
||||
pub fn for_save() -> Result<Self> {
|
||||
let mut active = ACTIVE_OPERATION.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
|
||||
while *active == Some(RamOperation::Save) {
|
||||
active = RELEASED.wait(active).unwrap_or_else(std::sync::PoisonError::into_inner);
|
||||
}
|
||||
|
||||
if active.is_some() {
|
||||
return Err(FormatError::Invalid("a MaterialCraft cook is using the RAM allowance; retry saving when it finishes".into()));
|
||||
}
|
||||
|
||||
*active = Some(RamOperation::Save);
|
||||
Ok(Self(RamOperation::Save))
|
||||
}
|
||||
|
||||
/// Reserve an autosave before cloning its snapshot without blocking the UI.
|
||||
pub fn try_for_save() -> Option<Self> {
|
||||
let mut active = ACTIVE_OPERATION.try_lock().ok()?;
|
||||
if active.is_some() {
|
||||
return None;
|
||||
}
|
||||
|
||||
*active = Some(RamOperation::Save);
|
||||
Some(Self(RamOperation::Save))
|
||||
}
|
||||
|
||||
pub fn save_bytes(&mut self, project_file: &ProjectFile<impl Borrow<Vec<u8>>>) -> Result<Vec<u8>> {
|
||||
self.check_save()?;
|
||||
let mut out = Cursor::new(Vec::new());
|
||||
write_project(&mut out, project_file)?;
|
||||
Ok(out.into_inner())
|
||||
}
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
pub fn save(&mut self, path: &std::path::Path, project_file: &ProjectFile<impl Borrow<Vec<u8>>>) -> Result<()> {
|
||||
self.check_save()?;
|
||||
super::write_project_atomic(path, project_file)
|
||||
}
|
||||
|
||||
fn check_save(&self) -> Result<()> {
|
||||
if self.0 == RamOperation::Save {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
Err(FormatError::Invalid("saving requires a save reservation".into()))
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for RamReservation {
|
||||
fn drop(&mut self) {
|
||||
*ACTIVE_OPERATION.lock().unwrap_or_else(std::sync::PoisonError::into_inner) = None;
|
||||
RELEASED.notify_all();
|
||||
}
|
||||
}
|
||||
+96
-14
@@ -134,12 +134,27 @@ pub struct ResizeJob {
|
||||
pub rx: std::sync::mpsc::Receiver<texturecraft_engine::Result<texturecraft_engine::ResizeOutput>>,
|
||||
}
|
||||
|
||||
mod link_bake_input;
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
mod link_import;
|
||||
|
||||
/// A MaterialCraft material re-cooking on a worker thread (one per layer at a time).
|
||||
pub struct LinkCook {
|
||||
pub layer: texturecraft_engine::core::LayerId,
|
||||
project: u64,
|
||||
mesh: u64,
|
||||
size: u32,
|
||||
baked_inputs: Vec<link_bake_input::LinkBakeInput>,
|
||||
canceled: std::sync::Arc<std::sync::atomic::AtomicBool>,
|
||||
/// The parameter values it cooks: a result whose values are no longer the layer's is redone.
|
||||
pub values: serde_json::Map<String, Value>,
|
||||
pub rx: std::sync::mpsc::Receiver<texturecraft_engine::Result<Vec<u8>>>,
|
||||
pub rx: std::sync::mpsc::Receiver<texturecraft_engine::Result<texturecraft_engine::link_cmds::CookedMaterial>>,
|
||||
}
|
||||
|
||||
impl Drop for LinkCook {
|
||||
fn drop(&mut self) {
|
||||
self.canceled.store(true, std::sync::atomic::Ordering::Relaxed);
|
||||
}
|
||||
}
|
||||
|
||||
/// The engine's refusal to paint while a bake shows (translated where it is toasted).
|
||||
@@ -175,6 +190,8 @@ pub struct TextureCraftApp {
|
||||
pub pbr_import: Option<pbr_import::PbrDialog>,
|
||||
pub resize: Option<ResizeJob>,
|
||||
pub link_cooks: Vec<LinkCook>,
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
link_imports: Vec<link_import::LinkImport>,
|
||||
pub thumbs: thumbs::Thumbs,
|
||||
/// The Layers panel's thumbnails and folded groups.
|
||||
pub layer_panel: layer_panel::LayerPanel,
|
||||
@@ -284,6 +301,8 @@ impl TextureCraftApp {
|
||||
pbr_import: None,
|
||||
resize: None,
|
||||
link_cooks: Vec::new(),
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
link_imports: Vec::new(),
|
||||
thumbs: thumbs::Thumbs::default(),
|
||||
layer_panel: layer_panel::LayerPanel::default(),
|
||||
viewport_rect: egui::Rect::NOTHING,
|
||||
@@ -347,6 +366,14 @@ impl TextureCraftApp {
|
||||
/// Run an engine command, reporting errors as toasts. Returns the result on success.
|
||||
pub fn run(&mut self, id: &str, params: Value) -> Option<Value> {
|
||||
self.ui.prefs.apply_resource_limits();
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
if id == "material.load"
|
||||
&& self.session.project_open
|
||||
&& let Some(path) = params.get("path").and_then(Value::as_str)
|
||||
&& texturecraft_engine::link_cmds::is_link_file(std::path::Path::new(path))
|
||||
{
|
||||
return self.start_link_import(path, ¶ms);
|
||||
}
|
||||
|
||||
// Going to a saved camera or a fixed view glides there; the control channel and CLI jump straight away
|
||||
let glides = id.starts_with("camera.select") || id.starts_with("camera.bookmark") || id.starts_with("camera.view");
|
||||
@@ -362,6 +389,9 @@ impl TextureCraftApp {
|
||||
if matches!(id, "file.open" | "file.new" | "file.close" | "project.new" | "project.sample") {
|
||||
self.pbr_import = None;
|
||||
self.resize = None;
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
self.link_imports.clear();
|
||||
self.link_cooks.clear();
|
||||
self.layer_panel = Default::default();
|
||||
}
|
||||
|
||||
@@ -448,11 +478,37 @@ impl TextureCraftApp {
|
||||
if self.link_cooks.iter().any(|c| c.layer == layer) {
|
||||
return;
|
||||
}
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
if !self.link_imports.is_empty() || !self.link_cooks.is_empty() {
|
||||
self.toast("Another MaterialCraft cook is still running", true);
|
||||
return;
|
||||
}
|
||||
|
||||
self.ui.prefs.apply_resource_limits();
|
||||
match self.session.link_job(layer, &serde_json::Map::new()) {
|
||||
Ok(job) => {
|
||||
let baked = self.session.doc.project.locate(layer).and_then(|(set, _, _)| self.session.baked(set));
|
||||
let baked_inputs = job
|
||||
.input_identifiers
|
||||
.iter()
|
||||
.filter_map(|identifier| texturecraft_engine::core::BakedMap::parse(identifier))
|
||||
.map(|map| link_bake_input::LinkBakeInput::capture(map, baked))
|
||||
.collect();
|
||||
let values = job.values.clone();
|
||||
let size = job.size;
|
||||
let canceled = std::sync::Arc::clone(&job.canceled);
|
||||
let rx = spawn_worker("texturecraft-link", move || job.run());
|
||||
self.link_cooks.push(LinkCook { layer, values, rx });
|
||||
self.link_cooks.push(LinkCook {
|
||||
layer,
|
||||
project: self.session.project_id,
|
||||
mesh: self.session.mesh_id,
|
||||
size,
|
||||
baked_inputs,
|
||||
canceled,
|
||||
values,
|
||||
rx,
|
||||
});
|
||||
}
|
||||
Err(e) => self.toast(e.to_string(), true),
|
||||
}
|
||||
@@ -462,27 +518,45 @@ impl TextureCraftApp {
|
||||
if self.link_cooks.is_empty() {
|
||||
return;
|
||||
}
|
||||
|
||||
ctx.request_repaint_after(std::time::Duration::from_millis(50));
|
||||
if self.session.stroke_active() {
|
||||
return;
|
||||
}
|
||||
|
||||
self.link_cooks.retain(|cook| {
|
||||
cook.project == self.session.project_id && cook.mesh == self.session.mesh_id && self.session.doc.project.locate(cook.layer).is_some()
|
||||
});
|
||||
let mut done = Vec::new();
|
||||
self.link_cooks.retain(|c| match c.rx.try_recv() {
|
||||
Err(std::sync::mpsc::TryRecvError::Empty) => true,
|
||||
Ok(r) => {
|
||||
done.push((c.layer, c.values.clone(), r));
|
||||
Ok(result) => {
|
||||
let Some((set, _, _)) = self.session.doc.project.locate(c.layer) else {
|
||||
return false;
|
||||
};
|
||||
|
||||
let resized = self.session.doc.project.texture_set(set).is_ok_and(|set| set.resolution != c.size);
|
||||
let baked = self.session.baked(set);
|
||||
let stale = resized || c.baked_inputs.iter().any(|input| !input.is_current(baked));
|
||||
done.push((c.layer, c.values.clone(), stale, result));
|
||||
false
|
||||
}
|
||||
Err(std::sync::mpsc::TryRecvError::Disconnected) => {
|
||||
done.push((c.layer, c.values.clone(), Err(texturecraft_engine::EngineError::Other("the MaterialCraft cook stopped".into()))));
|
||||
done.push((c.layer, c.values.clone(), false, Err(texturecraft_engine::EngineError::Other("the MaterialCraft cook stopped".into()))));
|
||||
false
|
||||
}
|
||||
});
|
||||
for (layer, values, result) in done {
|
||||
for (layer, values, stale, result) in done {
|
||||
let current = self.session.link_values(layer);
|
||||
match (result, current) {
|
||||
// The layer is gone (undone, deleted): nothing to show.
|
||||
// The layer can disappear while a cook is pending
|
||||
(_, Err(_)) => {}
|
||||
(Ok(_), Ok(now)) if now != values => self.cook_link(layer),
|
||||
(Ok(bytes), Ok(_)) => {
|
||||
if let Err(e) = self.session.apply_link_cook(layer, &bytes, true) {
|
||||
(result, Ok(now)) if now != values || stale => {
|
||||
drop(result);
|
||||
self.cook_link(layer);
|
||||
}
|
||||
(Ok(material), Ok(_)) => {
|
||||
if let Err(e) = self.session.apply_link_cook(layer, &material, true) {
|
||||
self.toast(e.to_string(), true);
|
||||
}
|
||||
}
|
||||
@@ -711,6 +785,10 @@ impl TextureCraftApp {
|
||||
return;
|
||||
}
|
||||
|
||||
let Some(mut reservation) = texturecraft_engine::formats::RamReservation::try_for_save() else {
|
||||
return;
|
||||
};
|
||||
|
||||
self.next_autosave = now + period;
|
||||
let dir = user_dir("autosave");
|
||||
let path = dir.join(format!(
|
||||
@@ -718,11 +796,13 @@ impl TextureCraftApp {
|
||||
texturecraft_engine::formats::export::sanitize_file_stem(&self.session.doc.project.name),
|
||||
texturecraft_engine::core::PROJECT_EXT
|
||||
));
|
||||
let pf = self.session.project_file();
|
||||
let snapshot = self.session.project_snapshot();
|
||||
let spawned = std::thread::Builder::new().name("texturecraft-autosave".into()).spawn(move || {
|
||||
let result = std::fs::create_dir_all(&dir)
|
||||
.map_err(|e| e.to_string())
|
||||
.and_then(|_| texturecraft_engine::formats::save_project(&path, &pf).map_err(|e| e.to_string()));
|
||||
let result =
|
||||
std::fs::create_dir_all(&dir).map_err(|e| e.to_string()).and_then(|_| reservation.save(&path, &snapshot).map_err(|error| error.to_string()));
|
||||
drop(snapshot);
|
||||
drop(reservation);
|
||||
|
||||
match result {
|
||||
Ok(()) => log::info!("autosaved {}", path.display()),
|
||||
Err(e) => log::warn!("autosave to {} failed: {e}", path.display()),
|
||||
@@ -828,6 +908,8 @@ impl eframe::App for TextureCraftApp {
|
||||
self.poll_bake(ctx);
|
||||
self.poll_resize(ctx);
|
||||
self.poll_link_cooks(ctx);
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
self.poll_link_imports(ctx);
|
||||
self.thumbs.sync_images(&self.session.images, self.session.revision);
|
||||
|
||||
// The library shelf rescans when the window comes back (MaterialCraft may have sent a material)
|
||||
|
||||
@@ -0,0 +1,52 @@
|
||||
use std::sync::{Arc, Weak};
|
||||
|
||||
use texturecraft_engine::{compose::BakedMaps, core::BakedMap};
|
||||
|
||||
/// The identity of one baked map read by a linked cook.
|
||||
pub(super) struct LinkBakeInput {
|
||||
map: BakedMap,
|
||||
resolution: Option<u32>,
|
||||
pixels: Option<Weak<Vec<f32>>>,
|
||||
}
|
||||
|
||||
impl LinkBakeInput {
|
||||
pub(super) fn capture(map: BakedMap, baked: Option<&BakedMaps>) -> Self {
|
||||
let pixels = baked.and_then(|baked| baked.maps.get(&map)).map(Arc::downgrade);
|
||||
|
||||
Self { map, resolution: baked.filter(|_| pixels.is_some()).map(|baked| baked.resolution), pixels }
|
||||
}
|
||||
|
||||
pub(super) fn is_current(&self, baked: Option<&BakedMaps>) -> bool {
|
||||
let current = Self::capture(self.map, baked);
|
||||
match (&self.pixels, current.pixels) {
|
||||
(Some(previous), Some(now)) => self.resolution == current.resolution && previous.ptr_eq(&now),
|
||||
(None, None) => true,
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn replacing_a_baked_input_at_the_same_resolution_invalidates_its_cook() {
|
||||
let earlier = Arc::new(vec![0.25; 4]);
|
||||
let mut baked = BakedMaps { resolution: 2, maps: [(BakedMap::AmbientOcclusion, Arc::clone(&earlier))].into() };
|
||||
let ambient_occlusion = LinkBakeInput::capture(BakedMap::AmbientOcclusion, Some(&baked));
|
||||
let curvature = LinkBakeInput::capture(BakedMap::Curvature, Some(&baked));
|
||||
|
||||
assert!(ambient_occlusion.is_current(Some(&baked)));
|
||||
assert_eq!(Arc::strong_count(&earlier), 2);
|
||||
|
||||
baked.maps.insert(BakedMap::AmbientOcclusion, Arc::new(vec![0.75; 4]));
|
||||
|
||||
assert!(!ambient_occlusion.is_current(Some(&baked)));
|
||||
assert!(curvature.is_current(Some(&baked)));
|
||||
|
||||
baked.maps.insert(BakedMap::Curvature, Arc::new(vec![0.5; 4]));
|
||||
|
||||
assert!(!curvature.is_current(Some(&baked)));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,159 @@
|
||||
//! The first procedural bake can take as long as a re-cook. Keep the native UI responsive.
|
||||
use std::path::PathBuf;
|
||||
use std::sync::mpsc::{Receiver, TryRecvError};
|
||||
use std::sync::{
|
||||
Arc,
|
||||
atomic::{AtomicBool, Ordering},
|
||||
};
|
||||
|
||||
use crate::TextureCraftApp;
|
||||
use serde_json::{Value, json};
|
||||
use texturecraft_engine::link_cmds::{CookedMaterial, cook_link_file};
|
||||
use texturecraft_engine::materials::Place;
|
||||
|
||||
type ImportedMaterial = (Arc<Vec<u8>>, &'static str, CookedMaterial);
|
||||
|
||||
pub(super) struct LinkImport {
|
||||
project: u64,
|
||||
mesh: u64,
|
||||
canceled: Arc<AtomicBool>,
|
||||
set: usize,
|
||||
resolution: u32,
|
||||
place: Place,
|
||||
result: Receiver<texturecraft_engine::Result<ImportedMaterial>>,
|
||||
}
|
||||
|
||||
impl Drop for LinkImport {
|
||||
fn drop(&mut self) {
|
||||
self.canceled.store(true, Ordering::Relaxed);
|
||||
}
|
||||
}
|
||||
|
||||
impl TextureCraftApp {
|
||||
pub(super) fn start_link_import(&mut self, path: &str, params: &Value) -> Option<Value> {
|
||||
if !self.link_imports.is_empty() || !self.link_cooks.is_empty() {
|
||||
self.toast("Another MaterialCraft cook is still running", true);
|
||||
return None;
|
||||
}
|
||||
|
||||
let set = self.session.ts();
|
||||
let texture_set = match self.session.doc.project.texture_set(set) {
|
||||
Ok(set) => set,
|
||||
Err(error) => {
|
||||
self.toast(error.to_string(), true);
|
||||
return None;
|
||||
}
|
||||
};
|
||||
|
||||
// The artist can select a different layer while this import cooks
|
||||
let place = match Place::from_params(params) {
|
||||
Place::Selection => self.session.selected_layer().map_or_else(
|
||||
|| texture_set.stack.last().map_or(Place::Index(0), |target| Place::Above(*target, false)),
|
||||
|target| Place::Above(target, self.session.doc.project.layer(target).is_ok_and(|layer| layer.is_group())),
|
||||
),
|
||||
explicit => explicit,
|
||||
};
|
||||
let resolution = texture_set.resolution;
|
||||
let baked = self.session.baked(set).cloned();
|
||||
let path = PathBuf::from(path);
|
||||
let canceled = Arc::new(AtomicBool::new(false));
|
||||
let worker_canceled = Arc::clone(&canceled);
|
||||
let budget = self.session.link_memory_budget();
|
||||
let rx = super::spawn_worker("texturecraft-material-import", move || {
|
||||
let (source, cooked) = cook_link_file(&path, resolution, baked, budget, worker_canceled)?;
|
||||
|
||||
// A pending installation only needs its source package and cooked outputs
|
||||
Ok((source.package, source.source_ext, cooked))
|
||||
});
|
||||
self.link_imports.push(LinkImport { project: self.session.project_id, mesh: self.session.mesh_id, canceled, set, resolution, place, result: rx });
|
||||
self.toast("Cooking MaterialCraft material", false);
|
||||
Some(json!({"pending":true}))
|
||||
}
|
||||
|
||||
pub(super) fn poll_link_imports(&mut self, ctx: &egui::Context) {
|
||||
if self.link_imports.is_empty() {
|
||||
return;
|
||||
}
|
||||
|
||||
ctx.request_repaint_after(std::time::Duration::from_millis(50));
|
||||
if self.session.stroke_active() {
|
||||
return;
|
||||
}
|
||||
|
||||
for mut job in std::mem::take(&mut self.link_imports) {
|
||||
if job.project != self.session.project_id
|
||||
|| job.mesh != self.session.mesh_id
|
||||
|| !self.session.doc.project.texture_set(job.set).is_ok_and(|set| set.resolution == job.resolution)
|
||||
{
|
||||
self.toast("Material import canceled because the target texture set changed", true);
|
||||
continue;
|
||||
}
|
||||
|
||||
if let Place::Above(target, _) | Place::Below(target) = job.place
|
||||
&& !self.session.doc.project.locate(target).is_some_and(|(set, _, _)| set == job.set)
|
||||
{
|
||||
self.toast("Material import canceled because the target layer changed", true);
|
||||
continue;
|
||||
}
|
||||
|
||||
let result = match job.result.try_recv() {
|
||||
Err(TryRecvError::Empty) => {
|
||||
self.link_imports.push(job);
|
||||
continue;
|
||||
}
|
||||
Err(TryRecvError::Disconnected) => Err(texturecraft_engine::EngineError::Other("the material import stopped".into())),
|
||||
Ok(result) => result,
|
||||
};
|
||||
|
||||
match result.and_then(|(package, source_ext, cooked)| {
|
||||
self.session.add_cooked_material_to_set(&cooked, package, source_ext, job.set, std::mem::replace(&mut job.place, Place::Selection))
|
||||
}) {
|
||||
Ok(_) => self.toast("Material imported", false),
|
||||
Err(error) => self.toast(error.to_string(), true),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use std::time::Duration;
|
||||
use texturecraft_engine::{Session, execute};
|
||||
|
||||
#[test]
|
||||
fn pending_import_keeps_its_original_layer_position() {
|
||||
let Some(cli) = std::env::var_os("MATERIALCRAFT_CLI") else { return };
|
||||
let path = std::env::temp_dir().join(format!("texturecraft-pending-import-{}.mcraft", std::process::id()));
|
||||
let source = std::process::Command::new(cli).args(["new", "pbr"]).arg(&path).args(["--size", "32"]).output().unwrap();
|
||||
assert!(source.status.success());
|
||||
let session = Session::new_project("Paint", texturecraft_engine::geom::primitives::cube(1.0), "builtin:cube", None, 128).unwrap();
|
||||
let context = eframe::CreationContext::_new_kittest(egui::Context::default());
|
||||
let mut app = TextureCraftApp::new(&context, session);
|
||||
execute(&mut app.session, "layer.add.paint", &json!({"name":"Drop target"})).unwrap();
|
||||
let target = app.session.selected_layer().unwrap();
|
||||
|
||||
let pixels = Arc::new(vec![0.25; 128 * 128]);
|
||||
let replaced = Arc::downgrade(&pixels);
|
||||
let baked = texturecraft_engine::compose::BakedMaps { resolution: 128, maps: [(texturecraft_engine::core::BakedMap::Curvature, pixels)].into() };
|
||||
app.session.doc.baked.insert(0, baked);
|
||||
|
||||
app.start_link_import(path.to_str().unwrap(), &Value::Null).unwrap();
|
||||
app.session.doc.baked.remove(&0);
|
||||
execute(&mut app.session, "layer.add.paint", &json!({"name":"Later selection"})).unwrap();
|
||||
let later = app.session.selected_layer().unwrap();
|
||||
let job = app.link_imports.first_mut().unwrap();
|
||||
let result = job.result.recv_timeout(Duration::from_secs(60)).unwrap().unwrap();
|
||||
assert!(replaced.upgrade().is_none(), "a pending import retained replaced bake pixels");
|
||||
|
||||
let (sender, receiver) = std::sync::mpsc::channel();
|
||||
sender.send(Ok(result)).unwrap();
|
||||
job.result = receiver;
|
||||
app.poll_link_imports(&context.egui_ctx);
|
||||
std::fs::remove_file(path).unwrap();
|
||||
|
||||
let imported = app.session.selected_layer().unwrap();
|
||||
let stack = &app.session.doc.project.texture_sets[0].stack;
|
||||
assert!(stack.ends_with(&[target, imported, later]), "{stack:?}");
|
||||
}
|
||||
}
|
||||
@@ -122,11 +122,7 @@ on the CPU by `render::displace` from the composited height.
|
||||
## MaterialCraft materials
|
||||
|
||||
A fill can carry a `MaterialLink` (`core::layer`): a MaterialCraft graph whose cooked maps are the
|
||||
fill's image sources. `engine::link_cmds` imports `.mcmat` files (`formats::mcmat`), keeps the
|
||||
`.mcraft` or `.sbs` source as a resource, and re-cooks its named graph by running `materialcraft-cli` with the link's
|
||||
values, the texture set's resolution and its baked mesh maps (`LinkJob::run`, on a worker thread
|
||||
in the UI). Every cook stores its maps under fresh resource names, so undo, redo and the decoded
|
||||
image cache never disagree. The apps share the `craft-mcmat` format library and the command line; neither depends on the other app.
|
||||
fill's image sources. `engine::link_cmds` imports a procedural MCMAT v3 by asking MaterialCraft to bake the entry graph. It keeps the archive and the interface reported by the CLI with the layer. Parameter edits can re-cook at the texture set's resolution. After a bake or a resize, run `material.link.cook` to use the new mesh maps or resolution. Each bake installs fresh map resources so duplicates, undo and redo preserve their own results. Both apps use the shared `craft-mcmat` library and communicate through the CLI.
|
||||
|
||||
## Commands and automation
|
||||
|
||||
|
||||
@@ -502,12 +502,11 @@ view, Alt+Shift+left drag orbits in 90° steps.
|
||||
|
||||
## MaterialCraft materials
|
||||
|
||||
A `.mcmat` portable material (MaterialCraft's format, read here by `formats::mcmat`; the manifest is
|
||||
documented in MaterialCraft's `docs/control-protocol.md` § Portable materials) becomes a fill layer
|
||||
whose channel sources are its cooked maps and whose `link` (shown by `project.inspect`) holds the
|
||||
graph's exposed inputs, presets and image inputs. Both apps use the shared `craft-mcmat` container.
|
||||
Versions 1 and 2 are accepted; version 1 contains a legacy JSON `.mcraft` source that current
|
||||
MaterialCraft cannot reopen, so its cooked maps remain usable but re-cooking needs a compatible older version.
|
||||
A v3 `.mcmat` holds a published SBS graph and its source assets. TextureCraft uses the shared `craft-mcmat` reader and cooks the archive through `materialcraft-cli`. The resulting fill stores its channel textures and the original archive in the project. Linked cooks use the Settings percentage of available RAM. A cook that exceeds the estimated budget reports the required and configured byte counts without replacing the current fill. Its exposed values, presets and mesh-map inputs appear in `project.inspect`. Republish older MCMAT files from their original authoring project. Procedural imports and re-cooks require the desktop CLI. Saved projects retain their baked maps for use in the browser.
|
||||
|
||||
Saving and linked cooks share one reservation for the configured RAM allowance. Autosave waits
|
||||
until a cook releases the reservation. An explicit save or cook that conflicts with the other
|
||||
operation returns a busy error and can be retried.
|
||||
|
||||
| Command | Params |
|
||||
|---|---|
|
||||
@@ -515,9 +514,9 @@ MaterialCraft cannot reopen, so its cooked maps remain usable but re-cooking nee
|
||||
| `material.link.set` | `{layer?, id, value, cook?: true}`: a number, `[..]`, a bool, `"#rrggbb"` or a typed `{"t", "v"}`; re-cooks unless `cook: false` |
|
||||
| `material.link.preset` | `{layer?, name, cook?: true}` |
|
||||
| `material.link.cook` | `{layer?}`: re-cook at the texture set's resolution with its baked mesh maps (after a bake or a resize) |
|
||||
| `material.link.saveSource` | `{layer?, path}`: the `.mcraft` or `.sbs` source, to open in MaterialCraft |
|
||||
| `material.link.saveSource` | `{layer?, path}`: the original linked source with its `.mcmat`, `.mcraft` or `.sbs` extension |
|
||||
|
||||
Re-cooks use `materialcraft-cli batch` to open the saved graph by name and run `file.exportMaterial` with its size, values and inputs:
|
||||
For a 1024-pixel texture set, TextureCraft requests `materialcraft-cli export source.mcmat maps --profile maps --size 1024x1024` with repeated `--set` and `--input` arguments. It discovers the published image inputs through `info` when the texture set supplies mesh maps. The desktop worker decodes the returned maps before installing the fill at its original drop target. The executable is resolved from
|
||||
`$MATERIALCRAFT_CLI`, else `materialcraft-cli` next to the TextureCraft executable, else on `PATH`
|
||||
(the app is `$MATERIALCRAFT` / `materialcraft`). Baked maps feed graph input nodes whose identifier
|
||||
matches the map's shared id (`ambientOcclusion`, `curvature`, `thickness`, `position`,
|
||||
|
||||
Reference in new issue
Block a user