mirror of
https://github.com/storytold/materialcraft.git
synced 2026-11-20 06:21:05 +01:00
Preserve bounded material dependencies and explicit export options
This commit is contained in:
1 parent
7809a55444
commit
9ff2b18f08
18 files changed
+374
-59
No files matched your search
Generated
+2
@@ -2832,6 +2832,7 @@ dependencies = [
|
||||
"schemars",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"tempfile",
|
||||
"thiserror 2.0.21",
|
||||
"tokio",
|
||||
]
|
||||
@@ -2843,6 +2844,7 @@ dependencies = [
|
||||
"materialcraft-automation",
|
||||
"materialcraft-engine",
|
||||
"serde_json",
|
||||
"tempfile",
|
||||
"tokio",
|
||||
"winresource",
|
||||
]
|
||||
|
||||
@@ -148,6 +148,7 @@ cargo run --release -p materialcraft-cli -- mcp # MCP server (stdi
|
||||
cargo run --release -p materialcraft-cli -- new wood wood.sbs
|
||||
cargo run --release -p materialcraft-cli -- render wood.sbs wood.png --scene sphere --full --hq
|
||||
cargo run --release -p materialcraft-cli -- export wood.sbs textures --format png --depth 16
|
||||
# Given a separate my.sbs with Materials/Oak and an exposed wear parameter:
|
||||
cargo run --release -p materialcraft-cli -- export my.sbs out --set wear=0.7 # with a graph input "wear" set first
|
||||
cargo run --release -p materialcraft-cli -- publish my.sbs my.mcmat --graph Materials/Oak
|
||||
cargo run --release -p materialcraft-cli -- export my.mcmat build/oak --profile materialx --size 2048 --set wear=0.7
|
||||
|
||||
@@ -17,3 +17,6 @@ tokio = { workspace = true }
|
||||
|
||||
[build-dependencies]
|
||||
winresource = "0.1"
|
||||
|
||||
[dev-dependencies]
|
||||
tempfile = "3"
|
||||
@@ -33,7 +33,9 @@ USAGE:
|
||||
[--depth 8|16|32] [--size <px|WxH>] [--pattern <p>] [--profile maps|materialx]
|
||||
[--preset <name>] [--input <id>=<image>]...
|
||||
Write output images, or material.mtlx and its baked textures with --profile materialx.
|
||||
--normal-format opengl|directx declares the input convention for opaque normal maps.
|
||||
--normal-format opengl|directx requires --profile maps|materialx and declares the input convention.
|
||||
--graph-path <SBS path> selects a literal path, including numeric names, instead of --graph.
|
||||
Named profiles choose their own format and filenames; omit --format and --pattern.
|
||||
--displacement-scale <units> scales signed MaterialX displacement (default 1).
|
||||
materialcraft-cli render <input> <out.png> [--size <W>x<H>] [--view 3d|2d] [--scene <id>] [--node <id>]
|
||||
[--yaw <deg>] [--pitch <deg>] [--graph <index>] [--set <input>=<value>]... [--full]
|
||||
@@ -55,17 +57,18 @@ USAGE:
|
||||
/// (name, flags taking a value, bare flags)
|
||||
const SUBCOMMANDS: &[(&str, &[&str], &[&str])] = &[
|
||||
("info", &[], &[]),
|
||||
("publish", &["--graph"], &[]),
|
||||
("publish", &["--graph", "--graph-path"], &[]),
|
||||
("commands", &["--filter"], &[]),
|
||||
("nodes", &["--filter", "--category"], &[]),
|
||||
("run", &["-o"], &[]),
|
||||
("batch", &[], &[]),
|
||||
("new", &["--size", "--name"], &[]),
|
||||
("cook", &["--graph", "--set", "--size", "--input", "--preset"], &["--full"]),
|
||||
("cook", &["--graph", "--graph-path", "--set", "--size", "--input", "--preset"], &["--full"]),
|
||||
(
|
||||
"export",
|
||||
&[
|
||||
"--graph",
|
||||
"--graph-path",
|
||||
"--set",
|
||||
"--format",
|
||||
"--depth",
|
||||
@@ -80,7 +83,11 @@ const SUBCOMMANDS: &[(&str, &[&str], &[&str])] = &[
|
||||
],
|
||||
&[],
|
||||
),
|
||||
("render", &["--size", "--view", "--scene", "--node", "--yaw", "--pitch", "--graph", "--set", "--tiling", "--displacement"], &["--full", "--hq"]),
|
||||
(
|
||||
"render",
|
||||
&["--size", "--view", "--scene", "--node", "--yaw", "--pitch", "--graph", "--graph-path", "--set", "--tiling", "--displacement"],
|
||||
&["--full", "--hq"],
|
||||
),
|
||||
("mcp", &["--bridge", "--token", "--read-root", "--write-root", "--automation-read-root", "--automation-write-root"], &[]),
|
||||
("serve", &["--port", "--read-root", "--write-root", "--automation-read-root", "--automation-write-root"], &[]),
|
||||
];
|
||||
@@ -155,7 +162,7 @@ fn print(v: &Value) {
|
||||
|
||||
/// Open `--graph` and apply every `--set <input>=<value>` (the value is JSON, else a string)
|
||||
fn select_graph(h: &mut Headless, a: &Args) -> Result<(), String> {
|
||||
if let Some(g) = a.get("--graph").map(graph_selector) {
|
||||
if let Some(g) = selected_graph(a)? {
|
||||
h.command_run("graph.open", json!({"graph": g})).map_err(|e| e.to_string())?;
|
||||
}
|
||||
for (_, v) in a.flags.iter().filter(|(f, _)| f == "--set") {
|
||||
@@ -166,6 +173,15 @@ fn select_graph(h: &mut Headless, a: &Args) -> Result<(), String> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn selected_graph(a: &Args) -> Result<Option<Value>, String> {
|
||||
match (a.get("--graph"), a.get("--graph-path")) {
|
||||
(Some(_), Some(_)) => Err("use either --graph or --graph-path, not both".into()),
|
||||
(_, Some(path)) => Ok(Some(json!(path))),
|
||||
(Some(selector), None) => Ok(Some(graph_selector(selector))),
|
||||
(None, None) => Ok(None),
|
||||
}
|
||||
}
|
||||
|
||||
fn graph_selector(selector: &str) -> Value {
|
||||
selector.parse::<u64>().map_or_else(|_| json!(selector), |index| json!(index))
|
||||
}
|
||||
@@ -193,7 +209,7 @@ fn cook_parameters(a: &Args) -> Result<Value, String> {
|
||||
inputs.insert(id.to_string(), json!(value));
|
||||
}
|
||||
}
|
||||
let graph = a.get("--graph").map(graph_selector);
|
||||
let graph = selected_graph(a)?;
|
||||
Ok(json!({"graph":graph,"size":a.get("--size").map(output_size).transpose()?,"preset":a.get("--preset"),"values":values,"inputs":inputs}))
|
||||
}
|
||||
|
||||
@@ -285,8 +301,7 @@ fn run(cmd: &str, a: &Args) -> Result<(), String> {
|
||||
}
|
||||
"publish" => {
|
||||
let mut h = open(a.pos(0, "<project>")?)?;
|
||||
let graph = a.get("--graph").ok_or("publish requires --graph <SBS path or index>")?;
|
||||
let graph = graph_selector(graph);
|
||||
let graph = selected_graph(a)?.ok_or("publish requires --graph <SBS path or index> or --graph-path <SBS path>")?;
|
||||
print(&h.export_material(&json!({"path":a.pos(1,"<out.mcmat>")?, "graph":graph})).map_err(|e| e.to_string())?);
|
||||
}
|
||||
"cook" => {
|
||||
@@ -394,6 +409,16 @@ mod tests {
|
||||
v.iter().map(|s| s.to_string()).collect()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn graph_paths_remain_literal_even_when_numeric() {
|
||||
let a = parse("publish", &strings(&["--graph-path", "1"])).unwrap();
|
||||
assert_eq!(selected_graph(&a).unwrap(), Some(json!("1")));
|
||||
let a = parse("publish", &strings(&["--graph", "1"])).unwrap();
|
||||
assert_eq!(selected_graph(&a).unwrap(), Some(json!(1)));
|
||||
let a = parse("publish", &strings(&["--graph", "1", "--graph-path", "1"])).unwrap();
|
||||
assert!(selected_graph(&a).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn automation_root_flags_are_aliases_of_the_short_ones() {
|
||||
for cmd in ["mcp", "serve"] {
|
||||
|
||||
@@ -13,8 +13,8 @@ fn run(dir: &Path, args: &[&str]) -> Value {
|
||||
|
||||
#[test]
|
||||
fn a_published_graph_bakes_openpbr_variations_after_the_project_is_removed() {
|
||||
let dir = std::env::temp_dir().join(format!("materialcraft-cli-published-{}", std::process::id()));
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
let temporary = tempfile::tempdir().unwrap();
|
||||
let dir = temporary.path().to_path_buf();
|
||||
run(&dir, &["new", "pbr", "source.sbs", "--name", "Oak", "--size", "32"]);
|
||||
run(&dir, &["run", "source.sbs", "graph.exposed.add", r#"{"id":"tint","bind":{"node":1,"param":"color"}}"#, "-o", "studio.mcraft"]);
|
||||
run(&dir, &["publish", "studio.mcraft", "oak.mcmat", "--graph", "Oak"]);
|
||||
@@ -45,13 +45,12 @@ fn a_published_graph_bakes_openpbr_variations_after_the_project_is_removed() {
|
||||
let rectangular = run(&dir, &["cook", "oak.mcmat", "--size", "64x32"]);
|
||||
assert_eq!(rectangular["outputs"][0]["size"], json!([64, 32]));
|
||||
assert_eq!(run(&dir, &["info", "oak.mcmat"]), initial);
|
||||
std::fs::remove_dir_all(&dir).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn failed_materialx_reexport_preserves_the_last_complete_material() {
|
||||
let dir = std::env::temp_dir().join(format!("materialcraft-cli-reexport-{}", std::process::id()));
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
let temporary = tempfile::tempdir().unwrap();
|
||||
let dir = temporary.path().to_path_buf();
|
||||
run(&dir, &["new", "pbr", "source.sbs", "--name", "Oak", "--size", "32"]);
|
||||
let export = |folder, size| run(&dir, &["export", "source.sbs", folder, "--profile", "materialx", "--size", size]);
|
||||
let first = export("material", "32");
|
||||
@@ -85,5 +84,4 @@ fn failed_materialx_reexport_preserves_the_last_complete_material() {
|
||||
for (name, bytes) in original_files {
|
||||
assert_eq!(std::fs::read(material.join(name)).unwrap(), bytes, "{name}");
|
||||
}
|
||||
std::fs::remove_dir_all(dir).unwrap();
|
||||
}
|
||||
@@ -26,4 +26,5 @@ getrandom = { workspace = true }
|
||||
rustix = { workspace = true }
|
||||
|
||||
[dev-dependencies]
|
||||
tempfile = "3"
|
||||
rmcp = { workspace = true, features = ["client"] }
|
||||
@@ -3,6 +3,7 @@ use serde::{Deserialize, Serialize};
|
||||
use serde_json::Value;
|
||||
|
||||
#[derive(Debug, Deserialize, Serialize, JsonSchema)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct MaterialExportParams {
|
||||
/// Forward-slash path relative to the write root (`.mcmat` is appended if missing). The
|
||||
/// parent folder must exist
|
||||
@@ -11,3 +12,19 @@ pub struct MaterialExportParams {
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub graph: Option<Value>,
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use serde_json::json;
|
||||
|
||||
#[test]
|
||||
fn material_publication_rejects_legacy_bake_size() {
|
||||
for size in [json!(256), json!(null)] {
|
||||
let error = serde_json::from_value::<MaterialExportParams>(json!({"path":"material", "size":size})).unwrap_err();
|
||||
assert!(error.to_string().contains("unknown field `size`"));
|
||||
}
|
||||
let params = serde_json::from_value::<MaterialExportParams>(json!({"path":"material", "graph":"Materials/Oak"})).unwrap();
|
||||
assert_eq!(params.graph, Some(json!("Materials/Oak")));
|
||||
}
|
||||
}
|
||||
@@ -4,7 +4,8 @@ use serde_json::json;
|
||||
|
||||
#[test]
|
||||
fn reopening_relative_paths_activates_the_existing_document_and_preserves_edits() {
|
||||
let root = std::env::temp_dir().join(format!("materialcraft-workspace-reopen-{}", std::process::id()));
|
||||
let temporary = tempfile::tempdir().unwrap();
|
||||
let root = temporary.path().to_path_buf();
|
||||
std::fs::create_dir_all(&root).unwrap();
|
||||
|
||||
for extension in ["sbs", "mcraft"] {
|
||||
@@ -42,13 +43,12 @@ fn reopening_relative_paths_activates_the_existing_document_and_preserves_edits(
|
||||
assert!(root.join(&filename).is_file());
|
||||
assert_eq!(reopened.session.path.as_deref(), Some(filename.as_str()));
|
||||
}
|
||||
|
||||
std::fs::remove_dir_all(root).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn both_formats_save_and_reopen_using_separate_workspace_capabilities() {
|
||||
let root = std::env::temp_dir().join(format!("materialcraft-workspace-packages-{}", std::process::id()));
|
||||
let temporary = tempfile::tempdir().unwrap();
|
||||
let root = temporary.path().to_path_buf();
|
||||
let input = root.join("input");
|
||||
let output = root.join("output");
|
||||
std::fs::create_dir_all(&input).unwrap();
|
||||
@@ -83,14 +83,14 @@ fn both_formats_save_and_reopen_using_separate_workspace_capabilities() {
|
||||
|
||||
// Release workspace directory handles before Windows removes the test tree
|
||||
drop(app);
|
||||
std::fs::remove_dir_all(root).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn scoped_publication_resolves_linked_graphs_and_images_using_the_granted_read_root() {
|
||||
use materialcraft_engine::core::{Graph, GraphInstance, GraphPort, Value};
|
||||
use materialcraft_engine::{formats, samples};
|
||||
let dir = std::env::temp_dir().join(format!("materialcraft-publish-workspace-{}", std::process::id()));
|
||||
let temporary = tempfile::tempdir().unwrap();
|
||||
let dir = temporary.path().to_path_buf();
|
||||
let input = dir.join("input");
|
||||
let output = dir.join("published");
|
||||
std::fs::create_dir_all(input.join("parts")).unwrap();
|
||||
@@ -126,6 +126,11 @@ fn scoped_publication_resolves_linked_graphs_and_images_using_the_granted_read_r
|
||||
let (pkg, entry) = formats::material::read_material(&std::fs::read(output.join("surface.sbs.mcmat")).unwrap()).unwrap();
|
||||
assert_eq!(pkg.graph(entry).unwrap().name, "Oak");
|
||||
assert_eq!(pkg.graphs.len(), 2);
|
||||
assert!(pkg.graphs.iter().any(|graph| graph.name == "Finish"));
|
||||
let calls: Vec<_> = pkg.graph(entry).unwrap().instances().collect();
|
||||
assert_eq!(calls.len(), 1);
|
||||
assert!(calls[0].package.is_empty());
|
||||
assert!(pkg.graph_by_name(&calls[0].graph).is_some());
|
||||
|
||||
// Saving under a different granted root rebases links from that actual
|
||||
// destination, not from the process working directory or a relative path.
|
||||
@@ -155,9 +160,12 @@ fn scoped_publication_resolves_linked_graphs_and_images_using_the_granted_read_r
|
||||
assert!(reopened.session.pkg.dependencies.values().any(|dependency| dependency.name == "Helpers"));
|
||||
}
|
||||
} else {
|
||||
assert!(result.is_err());
|
||||
let error = result.unwrap_err().to_string();
|
||||
assert!(error.contains("the instanced graph does not exist"), "{error}");
|
||||
let outside = dir.join("outside.sbs").canonicalize().unwrap().to_string_lossy().into_owned();
|
||||
assert!(!app.session.pkg.dependencies.contains_key(&outside));
|
||||
assert!(!app.session.pkg.dependencies.values().any(|dependency| dependency.name == "Helpers"));
|
||||
assert!(!output.join("missing.sbs.mcmat").exists());
|
||||
}
|
||||
}
|
||||
std::fs::remove_dir_all(dir).unwrap();
|
||||
}
|
||||
@@ -36,7 +36,13 @@ impl ExportRequest {
|
||||
|
||||
/// Read `file.export` params, checking them against the session's package
|
||||
pub fn from_params(s: &Session, p: &J) -> Result<Self> {
|
||||
let graph_index = crate::graph_cmds::graph_index(s, p)?;
|
||||
// Keep file.export's historical numeric selector coercion (including JSON 1.0)
|
||||
// while allowing the new exact SBS path selector without changing other commands.
|
||||
let graph_index = if p.get("graph").is_some_and(J::is_number) {
|
||||
u64p(p, "graph").and_then(|i| usize::try_from(i).ok()).ok_or_else(|| bad(CMD, "`graph` must be a nonnegative index"))?
|
||||
} else {
|
||||
crate::graph_cmds::graph_index(s, p)?
|
||||
};
|
||||
let graph = s.pkg.graph(graph_index)?;
|
||||
|
||||
let format = strp(p, "format").unwrap_or("png").trim_start_matches('.').to_ascii_lowercase();
|
||||
@@ -141,3 +147,24 @@ pub(crate) fn export_size(value: Option<&J>) -> Result<Option<ExportSize>> {
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod selector_tests {
|
||||
use super::*;
|
||||
use serde_json::json;
|
||||
|
||||
#[test]
|
||||
fn file_export_keeps_numeric_coercion_and_exact_graph_paths() {
|
||||
let mut package = materialcraft_core::Package::new("selectors");
|
||||
package.graphs.push(Graph::new("1"));
|
||||
package.graphs.push(Graph::new("Second"));
|
||||
let session = Session::new(package);
|
||||
for selector in [json!(1), json!(1.0), json!(0.6)] {
|
||||
assert_eq!(ExportRequest::from_params(&session, &json!({"graph":selector})).unwrap().graph, 1);
|
||||
}
|
||||
assert_eq!(ExportRequest::from_params(&session, &json!({"graph":"1"})).unwrap().graph, 0);
|
||||
for selector in [json!(-1), json!(2.0), json!(1e100)] {
|
||||
assert!(ExportRequest::from_params(&session, &json!({"graph":selector})).is_err());
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -82,6 +82,7 @@ fn resolve(package: &mut Package, mut pending: Vec<String>, read: &dyn Fn(&str)
|
||||
use std::{collections::BTreeSet, sync::Arc};
|
||||
let mut visited = BTreeSet::new();
|
||||
let mut warnings = Vec::new();
|
||||
let mut reads = 0;
|
||||
while let Some(path) = pending.pop() {
|
||||
if !visited.insert(path.clone()) {
|
||||
continue;
|
||||
@@ -92,10 +93,13 @@ fn resolve(package: &mut Package, mut pending: Vec<String>, read: &dyn Fn(&str)
|
||||
continue;
|
||||
}
|
||||
|
||||
if visited.len() > 4096 {
|
||||
// Cached snapshots need traversal, but must not consume the new-read budget.
|
||||
// Count failed attempts too; visited still prevents repeated reads and cycles.
|
||||
if reads >= 4096 {
|
||||
warnings.push("linked material exceeds the package dependency limit".into());
|
||||
break;
|
||||
}
|
||||
reads += 1;
|
||||
match read(&path) {
|
||||
Ok(read) => {
|
||||
warnings.extend(read.warnings);
|
||||
@@ -112,3 +116,46 @@ fn resolve(package: &mut Package, mut pending: Vec<String>, read: &dyn Fn(&str)
|
||||
|
||||
warnings
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use std::{cell::Cell, sync::Arc};
|
||||
|
||||
#[test]
|
||||
fn cached_paths_do_not_spend_the_new_dependency_read_budget() {
|
||||
for cached_first in [true, false] {
|
||||
let mut package = Package::new("root");
|
||||
let mut pending = vec!["new".to_string()];
|
||||
for i in 0..4096 {
|
||||
let name = format!("cached{i}");
|
||||
package.dependencies.insert(name.clone(), Arc::new(Package::new(&name)));
|
||||
pending.push(name);
|
||||
}
|
||||
if !cached_first {
|
||||
pending.reverse();
|
||||
}
|
||||
let calls = Cell::new(0);
|
||||
let warnings = resolve(&mut package, pending, &|path| {
|
||||
calls.set(calls.get() + 1);
|
||||
assert_eq!(path, "new");
|
||||
Ok(materialcraft_formats::sbs::SbsRead { pkg: Package::new(path), warnings: vec![] })
|
||||
});
|
||||
assert!(warnings.is_empty(), "{warnings:?}");
|
||||
assert_eq!(calls.get(), 1);
|
||||
assert!(package.dependencies.contains_key("new"));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn failed_new_reads_still_spend_the_budget_and_duplicates_do_not() {
|
||||
let calls = Cell::new(0);
|
||||
let pending = (0..4097).flat_map(|i| [format!("missing{i}"), format!("missing{i}")]).collect();
|
||||
let warnings = resolve(&mut Package::new("root"), pending, &|_| {
|
||||
calls.set(calls.get() + 1);
|
||||
Err("missing".into())
|
||||
});
|
||||
assert_eq!(calls.get(), 4096);
|
||||
assert!(warnings.last().unwrap().contains("dependency limit"));
|
||||
}
|
||||
}
|
||||
@@ -89,6 +89,15 @@ pub fn cook(s: &Session, p: &J, read: impl Fn(&str) -> Result<Vec<u8>>) -> Resul
|
||||
/// Encode every file before the caller writes to its destination. Paths in the report are relative.
|
||||
pub fn export(s: &Session, p: &J, read: impl Fn(&str) -> Result<Vec<u8>>) -> Result<(Vec<Exported>, J)> {
|
||||
let request = ExportRequest::from_params(s, p)?;
|
||||
let has = |key| p.get(key).is_some_and(|value| !value.is_null());
|
||||
if has("profile") {
|
||||
if has("format") || has("pattern") {
|
||||
return Err(bad("file.export", "named profiles choose their own format and filenames; omit format and pattern"));
|
||||
}
|
||||
} else if has("normalFormat") || has("displacementScale") {
|
||||
return Err(bad("file.export", "normalFormat and displacementScale require an explicit export profile"));
|
||||
}
|
||||
|
||||
let graph = s.pkg.graph(request.graph)?;
|
||||
let options = MaterialOptions::from_params(graph, p, read)?;
|
||||
let selected = request.outputs.as_deref();
|
||||
@@ -117,7 +126,8 @@ pub fn export(s: &Session, p: &J, read: impl Fn(&str) -> Result<Vec<u8>>) -> Res
|
||||
|
||||
let cooked = options.cook(s, request.graph, selected, None)?;
|
||||
let (files, mut report) = encode_maps(graph, &cooked, &request, materialx, scale, normal_y_down)?;
|
||||
let mut interface = info(s, p)?;
|
||||
// Use the graph already selected by file.export, including its legacy numeric coercion.
|
||||
let mut interface = info(s, &json!({"graph": request.graph}))?;
|
||||
if let Some(params) = interface["parameters"].as_array_mut() {
|
||||
for parameter in params {
|
||||
if let Some(value) = parameter["id"].as_str().and_then(|id| options.values.get(id)) {
|
||||
@@ -209,6 +219,9 @@ fn encode_maps(
|
||||
};
|
||||
|
||||
let float = height || request.depth == Some(Depth::F32) || image.data().iter().any(|value| !(0.0..=1.0).contains(value));
|
||||
if float && request.color_spaces.get(&identifier).is_some_and(|space| space.encodes_srgb()) {
|
||||
return Err(bad("file.export", format!("EXR output `{identifier}` requires linear values; omit the sRGB override or select raw or linear")));
|
||||
}
|
||||
let (ext, depth) = if float {
|
||||
("exr", Depth::F32)
|
||||
} else {
|
||||
|
||||
@@ -405,3 +405,70 @@ fn published_disabled_and_typed_instance_cooks_match_source() {
|
||||
assert_eq!(restored, original);
|
||||
assert!((restored[0] - 0.2).abs() < 0.01, "disabled levels must preserve its input: {restored:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn material_options_ignore_stale_presets_but_validate_explicit_values() {
|
||||
let mut session = fixture();
|
||||
let graph = session.graph_mut().unwrap();
|
||||
graph.presets[0].values.insert("removed".into(), Value::Float(0.5));
|
||||
graph.presets[0].values.insert("tint".into(), Value::Text("old type".into()));
|
||||
let before = graph.clone();
|
||||
let read = |_: &str| -> crate::Result<Vec<u8>> { Err(crate::EngineError::Other("unexpected image read".into())) };
|
||||
let options = MaterialOptions::from_params(graph, &json!({"preset":"Dark"}), read).unwrap();
|
||||
assert!(options.values.is_empty());
|
||||
let options = MaterialOptions::from_params(graph, &json!({"preset":"Dark", "values":{"tint":[0.7,0.6,0.5,1.0]}}), read).unwrap();
|
||||
assert_eq!(options.values.len(), 1);
|
||||
assert_eq!(options.values["tint"], Value::Color([0.7, 0.6, 0.5, 1.0]));
|
||||
assert!(MaterialOptions::from_params(graph, &json!({"values":{"removed":0.5}}), read).is_err());
|
||||
assert!(MaterialOptions::from_params(graph, &json!({"values":{"tint":"wrong"}}), read).is_err());
|
||||
assert_eq!(*graph, before);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn material_options_size_errors_name_the_material_command() {
|
||||
let session = fixture();
|
||||
let parameters = json!({"size":"bad"});
|
||||
let error =
|
||||
MaterialOptions::from_params(session.graph().unwrap(), ¶meters, |_| Err(crate::EngineError::Other("unexpected image read".into()))).unwrap_err();
|
||||
assert!(matches!(error, crate::EngineError::BadParams { cmd, msg } if cmd == "material.cook" && msg.contains("size")));
|
||||
let error = crate::export_request::export_size(parameters.get("size")).unwrap_err();
|
||||
assert!(matches!(error, crate::EngineError::BadParams { cmd, msg } if cmd == "file.export" && msg.contains("size")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn named_profiles_reject_ignored_format_and_pattern() {
|
||||
let session = fixture();
|
||||
for extra in [json!({"format":"jpg"}), json!({"pattern":"oak_$(identifier)"})] {
|
||||
let mut params = json!({"graph":"Materials/Oak","profile":"maps"});
|
||||
params.as_object_mut().unwrap().extend(extra.as_object().unwrap().clone());
|
||||
let err = material_bake::export(&session, ¶ms, |_| panic!("invalid options must precede input reads")).err().expect("invalid export must fail");
|
||||
assert!(err.to_string().contains("omit format and pattern"));
|
||||
}
|
||||
let err =
|
||||
material_bake::export(&session, &json!({"graph":"Materials/Oak","normalFormat":"directx"}), |_| panic!("invalid options must precede input reads"))
|
||||
.err()
|
||||
.expect("invalid export must fail");
|
||||
assert!(err.to_string().contains("require an explicit export profile"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn float_maps_reject_explicit_srgb_instead_of_ignoring_it() {
|
||||
let session = fixture();
|
||||
let params = json!({"graph":"Materials/Oak","profile":"maps","outputs":["albedo"],"depth":32,"colorSpaces":{"albedo":"srgb"}});
|
||||
let err = material_bake::export(&session, ¶ms, material_bake::read_input).err().expect("invalid export must fail");
|
||||
assert!(err.to_string().contains("requires linear values"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn named_profiles_report_the_validated_numeric_graph_selector() {
|
||||
let session = fixture();
|
||||
for profile in ["maps", "materialx"] {
|
||||
for selector in [json!(1.0), json!(0.6)] {
|
||||
let (files, report) =
|
||||
material_bake::export(&session, &json!({"graph":selector,"profile":profile,"outputs":["albedo"],"size":16}), material_bake::read_input)
|
||||
.unwrap();
|
||||
assert!(!files.is_empty());
|
||||
assert_eq!(report["material"]["graph"], "Materials/Oak");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -18,12 +18,23 @@ pub struct MaterialOptions {
|
||||
impl MaterialOptions {
|
||||
pub fn from_params(graph: &Graph, p: &J, read: impl Fn(&str) -> Result<Vec<u8>>) -> Result<Self> {
|
||||
let invalid = |msg| bad("material.cook", msg);
|
||||
let mut options = Self { size: crate::export_request::export_size(p.get("size"))?, ..Default::default() };
|
||||
let size = crate::export_request::export_size(p.get("size")).map_err(|error| match error {
|
||||
crate::EngineError::BadParams { msg, .. } => invalid(msg),
|
||||
other => other,
|
||||
})?;
|
||||
let mut options = Self { size, ..Default::default() };
|
||||
|
||||
if let Some(value) = p.get("preset").filter(|v| !v.is_null()) {
|
||||
let name = value.as_str().ok_or_else(|| invalid("preset must be a name".into()))?;
|
||||
let preset = graph.presets.iter().find(|preset| preset.name == name).ok_or_else(|| invalid(format!("unknown preset `{name}`")))?;
|
||||
options.values.clone_from(&preset.values);
|
||||
// Match preset.apply: stale identifiers and changed parameter types are ignored.
|
||||
options.values.extend(
|
||||
preset
|
||||
.values
|
||||
.iter()
|
||||
.filter(|(id, value)| graph.exposed.iter().any(|parameter| parameter.id == **id && parameter.default.type_name() == value.type_name()))
|
||||
.map(|(id, value)| (id.clone(), value.clone())),
|
||||
);
|
||||
}
|
||||
|
||||
if let Some(value) = p.get("values").filter(|v| !v.is_null()) {
|
||||
|
||||
@@ -27,7 +27,7 @@ type Key = (String, usize);
|
||||
struct SnapshotBuilder<'a> {
|
||||
root: &'a Package,
|
||||
result: Package,
|
||||
paths: BTreeMap<Key, String>,
|
||||
paths: BTreeMap<Key, (String, usize)>,
|
||||
active: BTreeSet<Key>,
|
||||
resources: BTreeMap<(String, String), String>,
|
||||
nodes: usize,
|
||||
@@ -42,24 +42,31 @@ impl<'a> SnapshotBuilder<'a> {
|
||||
self.root.dependencies.get(owner).map(AsRef::as_ref).ok_or_else(|| bad(format!("missing source package `{owner}`")))
|
||||
}
|
||||
|
||||
fn reference(&mut self, owner: &str, name: &str) -> Result<String> {
|
||||
fn reference(&mut self, owner: &str, name: &str, height: &mut usize) -> Result<String> {
|
||||
let (index, _) = self.package(owner)?.graph_by_name(name).ok_or_else(|| bad(format!("missing or ambiguous graph `{name}` in `{owner}`")))?;
|
||||
self.copy_graph(owner, index)
|
||||
let (path, child_height) = self.copy_graph(owner, index)?;
|
||||
*height = (*height).max(child_height + 1);
|
||||
Ok(path)
|
||||
}
|
||||
|
||||
fn copy_graph(&mut self, owner: &str, index: usize) -> Result<String> {
|
||||
fn copy_graph(&mut self, owner: &str, index: usize) -> Result<(String, usize)> {
|
||||
let key = (owner.to_owned(), index);
|
||||
let source = self.package(owner)?.graph(index).map_err(|e| bad(e.to_string()))?;
|
||||
if self.active.contains(&key) {
|
||||
return Err(bad(format!("cyclic graph reference at `{}`", source.sbs_path())));
|
||||
}
|
||||
|
||||
if let Some(path) = self.paths.get(&key) {
|
||||
return Ok(path.clone());
|
||||
// Bound the complete path, including a shared tail copied on an earlier branch.
|
||||
// Active entries are rejected above, so cached heights here are complete.
|
||||
const MAX_DEPENDENCY_DEPTH: usize = 32;
|
||||
if let Some((path, height)) = self.paths.get(&key) {
|
||||
if self.active.len() + height > MAX_DEPENDENCY_DEPTH {
|
||||
return Err(bad("published graph dependencies exceed the depth or graph count limit"));
|
||||
}
|
||||
return Ok((path.clone(), *height));
|
||||
}
|
||||
|
||||
// Bound publishing independently of the cooker's per-function and per-instance limits
|
||||
const MAX_DEPENDENCY_DEPTH: usize = 32;
|
||||
if self.active.len() >= MAX_DEPENDENCY_DEPTH || self.paths.len() >= crate::sbs::MAX_GRAPHS {
|
||||
return Err(bad("published graph dependencies exceed the depth or graph count limit"));
|
||||
}
|
||||
@@ -87,11 +94,12 @@ impl<'a> SnapshotBuilder<'a> {
|
||||
|
||||
graph.folder = if self.paths.is_empty() { String::new() } else { format!("Dependencies/g{}", self.paths.len()) };
|
||||
let path = graph.sbs_path();
|
||||
self.paths.insert(key.clone(), path.clone());
|
||||
self.paths.insert(key.clone(), (path.clone(), 0));
|
||||
let mut height = 1;
|
||||
self.active.insert(key.clone());
|
||||
for instance in graph.instances_mut() {
|
||||
let package = if instance.package.is_empty() { owner } else { &instance.package };
|
||||
instance.graph = self.reference(package, &instance.graph)?;
|
||||
instance.graph = self.reference(package, &instance.graph, &mut height)?;
|
||||
instance.package.clear();
|
||||
}
|
||||
for node in &mut graph.nodes {
|
||||
@@ -103,7 +111,7 @@ impl<'a> SnapshotBuilder<'a> {
|
||||
if let Some(instance) = &node.instance {
|
||||
node.params.insert("graph".into(), Value::Text(instance.graph.clone()));
|
||||
} else if let Some(Value::Text(target)) = node.params.get_mut("graph") {
|
||||
*target = self.reference(owner, target)?;
|
||||
*target = self.reference(owner, target, &mut height)?;
|
||||
} else {
|
||||
return Err(bad(format!("missing graph reference in `{path}`")));
|
||||
}
|
||||
@@ -131,8 +139,9 @@ impl<'a> SnapshotBuilder<'a> {
|
||||
}
|
||||
|
||||
self.active.remove(&key);
|
||||
self.paths.insert(key, (path.clone(), height));
|
||||
self.result.graphs.push(graph);
|
||||
Ok(path)
|
||||
Ok((path, height))
|
||||
}
|
||||
|
||||
fn resource(&mut self, owner: &str, name: &str) -> Result<String> {
|
||||
@@ -163,3 +172,54 @@ pub fn entry_graph(pkg: &Package) -> Result<usize> {
|
||||
_ => Err(bad("source.sbs must have exactly one root material graph; put helper graphs and functions in a dependency folder")),
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn graph(name: &str, children: &[String]) -> Graph {
|
||||
let mut graph = Graph::new(name);
|
||||
if children.is_empty() {
|
||||
let source = graph.add_node("uniform", [0.0; 2]);
|
||||
let output = graph.add_node("output", [0.0; 2]);
|
||||
graph.connect(source, "output", output, "input").unwrap();
|
||||
}
|
||||
for child in children {
|
||||
let source = graph.add_node("graph_instance", [0.0; 2]);
|
||||
graph.node_mut(source).unwrap().params.insert("graph".into(), Value::Text(child.clone()));
|
||||
let output = graph.add_node("output", [0.0; 2]);
|
||||
graph.connect(source, "output", output, "input").unwrap();
|
||||
}
|
||||
graph
|
||||
}
|
||||
|
||||
fn shared_tail(chain: usize, tail: usize, cached_first: bool) -> Package {
|
||||
let mut package = Package::new("depth");
|
||||
let mut children = vec!["tail0".into(), "chain0".into()];
|
||||
if !cached_first {
|
||||
children.reverse();
|
||||
}
|
||||
package.graphs.push(graph("root", &children));
|
||||
for i in 0..chain {
|
||||
let next = if i + 1 == chain { "tail0".into() } else { format!("chain{}", i + 1) };
|
||||
package.graphs.push(graph(&format!("chain{i}"), &[next]));
|
||||
}
|
||||
for i in 0..tail {
|
||||
let children = if i + 1 == tail { vec![] } else { vec![format!("tail{}", i + 1)] };
|
||||
package.graphs.push(graph(&format!("tail{i}"), &children));
|
||||
}
|
||||
package
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cached_graph_depth_is_independent_of_reference_order() {
|
||||
for cached_first in [true, false] {
|
||||
// Root + chain + shared tail: 32 is valid, 33 is not. The cached
|
||||
// tail can itself contain dependencies, not just a leaf.
|
||||
for tail in [1, 5] {
|
||||
assert!(snapshot(&shared_tail(31 - tail, tail, cached_first), 0).is_ok());
|
||||
assert!(snapshot(&shared_tail(32 - tail, tail, cached_first), 0).is_err());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -155,3 +155,29 @@ fn material_dialog_identity_is_not_saved_in_preferences() {
|
||||
let restored: ExportSettings = serde_json::from_value(stored).unwrap();
|
||||
assert_eq!(restored.material.document, None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn folder_graphs_keep_independent_output_selection_and_color_spaces() {
|
||||
let app = app();
|
||||
let mut indoor = app.session.graph().unwrap().clone();
|
||||
indoor.name = "Oak".into();
|
||||
indoor.folder = "Indoor".into();
|
||||
let mut outdoor = indoor.clone();
|
||||
outdoor.folder = "Outdoor".into();
|
||||
let mut settings = ExportSettings::default();
|
||||
settings.include_all(&indoor, false);
|
||||
assert!(settings.selection(&indoor).is_none());
|
||||
assert!(settings.selection(&outdoor).is_some());
|
||||
settings.include_all(&indoor, true);
|
||||
settings.color_spaces.insert(output_key(&indoor.sbs_path(), "base_color"), materialcraft_engine::ColorSpace::Linear);
|
||||
assert_eq!(settings.selection(&indoor).unwrap().1["base_color"], "linear");
|
||||
assert_eq!(settings.selection(&outdoor).unwrap().1["base_color"], "srgb");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn material_export_reports_missing_shader_connections_on_every_platform() {
|
||||
assert_eq!(material_export_message(&Value::Null), tr("Material exported"));
|
||||
let message = material_export_message(&json!({"unmapped":["custom_output"]}));
|
||||
assert!(message.contains(tr("Exported without shader connections")));
|
||||
assert!(message.contains("custom_output"));
|
||||
}
|
||||
@@ -241,7 +241,7 @@ pub(super) fn path_field(ui: &mut Ui, path: &mut String, width: f32) -> bool {
|
||||
|
||||
/// The file name the first checked output of `graph` is written to
|
||||
fn preview_file(settings: &ExportSettings, graph: &Graph) -> Option<String> {
|
||||
let output = outputs::listed(graph).into_iter().find(|output| settings.includes(&graph.name, &output.identifier))?;
|
||||
let output = outputs::listed(graph).into_iter().find(|output| settings.includes(&graph.sbs_path(), &output.identifier))?;
|
||||
let name = materialcraft_engine::formats::output_name(&settings.pattern, &graph.name, &output.identifier, output.usage);
|
||||
Some(format!("{name}.{}", settings.format))
|
||||
}
|
||||
@@ -422,21 +422,25 @@ fn publish(app: &mut MaterialCraftApp, settings: &ExportSettings) -> bool {
|
||||
let result = if command == "file.exportMaterial" {
|
||||
materialcraft_engine::material_cmds::material_bytes(&app.session, index).map_err(|e| e.to_string()).and_then(|bytes| {
|
||||
let name = format!("{}.mcmat", materialcraft_engine::formats::safe_file_name(&graph.name));
|
||||
crate::web_files::download(&name, &bytes)
|
||||
crate::web_files::download(&name, &bytes).map(|()| Value::Null)
|
||||
})
|
||||
} else {
|
||||
materialcraft_engine::material_bake::export(&app.session, ¶ms, materialcraft_engine::material_bake::read_input)
|
||||
.map_err(|e| e.to_string())
|
||||
.and_then(|(files, _)| {
|
||||
.and_then(|(files, report)| {
|
||||
let files = files.into_iter().map(|f| (f.file, f.bytes)).collect::<Vec<_>>();
|
||||
crate::web_files::download(
|
||||
&format!("{}_materialx.zip", materialcraft_engine::formats::safe_file_name(&graph.name)),
|
||||
&crate::web_files::zip_files(&files)?,
|
||||
)
|
||||
.map(|()| report)
|
||||
})
|
||||
};
|
||||
match result {
|
||||
Ok(()) => true,
|
||||
Ok(report) => {
|
||||
app.toast(material_export_message(&report), false);
|
||||
true
|
||||
}
|
||||
Err(error) => {
|
||||
app.toast(error, true);
|
||||
false
|
||||
@@ -459,14 +463,14 @@ pub(crate) fn poll(app: &mut MaterialCraftApp, ctx: &egui::Context) {
|
||||
app.material_export_job = None;
|
||||
match result {
|
||||
Ok(report) => {
|
||||
let unmapped = report["unmapped"].as_array().into_iter().flatten().filter_map(Value::as_str).collect::<Vec<_>>();
|
||||
let message = if unmapped.is_empty() {
|
||||
tr("Material exported").to_string()
|
||||
} else {
|
||||
format!("{}: {}", tr("Exported without shader connections"), unmapped.join(", "))
|
||||
};
|
||||
app.toast(message, false);
|
||||
app.toast(material_export_message(&report), false);
|
||||
}
|
||||
Err(error) => app.toast(error, true),
|
||||
}
|
||||
}
|
||||
|
||||
/// Keep native and browser exports explicit about omitted shader connections.
|
||||
fn material_export_message(report: &Value) -> String {
|
||||
let unmapped = report["unmapped"].as_array().into_iter().flatten().filter_map(Value::as_str).collect::<Vec<_>>();
|
||||
if unmapped.is_empty() { tr("Material exported").to_string() } else { format!("{}: {}", tr("Exported without shader connections"), unmapped.join(", ")) }
|
||||
}
|
||||
@@ -41,7 +41,7 @@ impl ExportSettings {
|
||||
/// Check or uncheck every output of `graph`
|
||||
pub fn include_all(&mut self, graph: &Graph, include: bool) {
|
||||
for output in listed(graph) {
|
||||
let key = output_key(&graph.name, &output.identifier);
|
||||
let key = output_key(&graph.sbs_path(), &output.identifier);
|
||||
if include {
|
||||
self.skipped_outputs.remove(&key);
|
||||
} else {
|
||||
@@ -53,7 +53,7 @@ impl ExportSettings {
|
||||
/// The `file.export` `outputs` and `colorSpaces` for `graph`; `None` when none of its outputs is checked
|
||||
pub fn selection(&self, graph: &Graph) -> Option<(Value, Value)> {
|
||||
let outputs = listed(graph);
|
||||
let included: Vec<&ListedOutput> = outputs.iter().filter(|output| self.includes(&graph.name, &output.identifier)).collect();
|
||||
let included: Vec<&ListedOutput> = outputs.iter().filter(|output| self.includes(&graph.sbs_path(), &output.identifier)).collect();
|
||||
if included.is_empty() {
|
||||
return None;
|
||||
}
|
||||
@@ -61,7 +61,7 @@ impl ExportSettings {
|
||||
let identifiers =
|
||||
if included.len() == outputs.len() { Value::Null } else { json!(included.iter().map(|output| &output.identifier).collect::<Vec<_>>()) };
|
||||
let color_spaces: serde_json::Map<String, Value> =
|
||||
included.iter().map(|output| (output.identifier.clone(), json!(self.color_space(&graph.name, output).id()))).collect();
|
||||
included.iter().map(|output| (output.identifier.clone(), json!(self.color_space(&graph.sbs_path(), output).id()))).collect();
|
||||
Some((identifiers, Value::Object(color_spaces)))
|
||||
}
|
||||
}
|
||||
@@ -77,8 +77,8 @@ pub fn tree(ui: &mut Ui, settings: &mut ExportSettings, graphs: &[&Graph]) {
|
||||
egui::ScrollArea::vertical().id_salt("export-outputs").max_height(240.0).auto_shrink([false, true]).show(ui, |ui| {
|
||||
for graph in graphs {
|
||||
let outputs = listed(graph);
|
||||
let included = outputs.iter().filter(|output| settings.includes(&graph.name, &output.identifier)).count();
|
||||
let id = ui.make_persistent_id(("export-graph", &graph.name));
|
||||
let included = outputs.iter().filter(|output| settings.includes(&graph.sbs_path(), &output.identifier)).count();
|
||||
let id = ui.make_persistent_id(("export-graph", graph.sbs_path()));
|
||||
egui::collapsing_header::CollapsingState::load_with_default_open(ui.ctx(), id, true)
|
||||
.show_header(ui, |ui| {
|
||||
let mut all = !outputs.is_empty() && included == outputs.len();
|
||||
@@ -102,10 +102,10 @@ fn outputs_grid(ui: &mut Ui, settings: &mut ExportSettings, graph: &Graph, outpu
|
||||
return;
|
||||
}
|
||||
|
||||
egui::Grid::new(("export-outputs-grid", &graph.name)).num_columns(2).min_col_width(OUTPUT_COLUMN_WIDTH).spacing([8.0, 4.0]).show(ui, |ui| {
|
||||
egui::Grid::new(("export-outputs-grid", graph.sbs_path())).num_columns(2).min_col_width(OUTPUT_COLUMN_WIDTH).spacing([8.0, 4.0]).show(ui, |ui| {
|
||||
for output in outputs {
|
||||
let key = output_key(&graph.name, &output.identifier);
|
||||
let mut included = settings.includes(&graph.name, &output.identifier);
|
||||
let key = output_key(&graph.sbs_path(), &output.identifier);
|
||||
let mut included = settings.includes(&graph.sbs_path(), &output.identifier);
|
||||
let checkbox = ui.checkbox(&mut included, &output.identifier);
|
||||
crate::widgets::name(&checkbox, egui::Role::CheckBox, &output.identifier);
|
||||
if checkbox.changed() {
|
||||
@@ -116,14 +116,14 @@ fn outputs_grid(ui: &mut Ui, settings: &mut ExportSettings, graph: &Graph, outpu
|
||||
}
|
||||
}
|
||||
|
||||
let mut space = settings.color_space(&graph.name, output);
|
||||
let mut space = settings.color_space(&graph.sbs_path(), output);
|
||||
let combo = egui::ComboBox::from_id_salt(("export-color-space", &key)).width(110.0).selected_text(space.label()).show_ui(ui, |ui| {
|
||||
for choice in ColorSpace::ALL {
|
||||
ui.selectable_value(&mut space, choice, choice.label());
|
||||
}
|
||||
});
|
||||
crate::widgets::name(&combo.response, egui::Role::ComboBox, &format!("{} {}", output.identifier, tr("color space")));
|
||||
if space != settings.color_space(&graph.name, output) {
|
||||
if space != settings.color_space(&graph.sbs_path(), output) {
|
||||
settings.color_spaces.insert(key, space);
|
||||
}
|
||||
ui.end_row();
|
||||
|
||||
@@ -366,6 +366,11 @@ The ZIP contains a version marker (`material.json` with `{"version":3}`), a DEFL
|
||||
|
||||
TextureCraft requests `--profile maps` at its texture set's resolution and supplies mesh maps through repeated `--input identifier=path`. Common identifiers include `ambientOcclusion`, `curvature`, `thickness`, `position`, `worldNormal`, `normal`, `height`, `id`, `bentNormal`, `opacity`, `colorMap` and `worldDirection`. An image override uses the published preview binding’s color space when present. Otherwise the input’s declared usage determines the transfer, with the identifier as a fallback for untagged inputs. The JSON report lists each map's identifier, usage, filename, color space and actual dimensions.
|
||||
|
||||
Named bake profiles select their own output formats and filenames: do not supply `format` or `pattern`.
|
||||
`normalFormat` requires an explicit bake profile. Explicit sRGB overrides are refused for floating-point
|
||||
EXR outputs; omit the override or choose raw/linear. The CLI's `--graph-path` selects a literal SBS path,
|
||||
including a numeric name, while `--graph` retains numeric-index shorthand.
|
||||
|
||||
The `materialx` profile writes `material.mtlx` with relative texture paths and an OpenPBR surface. Color textures default to sRGB PNG, data textures to linear 16-bit PNG, and out-of-range values to floating-point EXR. Both bake profiles write tangent-space Y+ normals. A directly connected Normal node supplies its evaluated convention, including through routing dots. Other normal sources default to Y+. Use `--normal-format directx` for a Y− source or `--normal-format opengl` for Y+. OpenPBR scalar and normal inputs require linear data. Height becomes signed EXR displacement in scene units using `(height - 0.5) × displacementScale`. The CLI accepts `--displacement-scale`. MaterialX texture filenames include a hash of the output name and bytes. Re-export writes the document last and keeps earlier texture versions, so a failed export leaves the previous material usable. Outputs without an OpenPBR connection are written alongside the document and listed in `unmapped`.
|
||||
|
||||
| Command | Params |
|
||||
|
||||
Reference in new issue
Block a user