Listing all nodes from custom functions.sbs

also fixed library ui with categories
This commit is contained in:
PiJellyPin committed 2026-11-10 00:52:05 +01:00
1 parent 29857f653d
commit 9290c2d906
35 files changed
+2257 -340

No files matched your search

+1
View File
@@ -60,6 +60,7 @@ pub fn command_specs() -> &'static [CommandSpec] {
v.extend(crate::explorer_clipboard_commands::specs());
v.extend(crate::graph_instance_commands::specs());
v.extend(crate::function_library_commands::specs());
v.extend(crate::node_library_commands::specs());
v.extend(crate::node_info_commands::specs());
v.extend(crate::atomic_sample_commands::specs());
v.extend(crate::material_cmds::specs());
+1 -20
View File
@@ -1,21 +1,2 @@
use materialcraft_core::Package;
use std::{collections::BTreeMap, sync::Arc};
/// The bundled function library every session loads (see `node_library`)
pub(crate) const STANDARD_PACKAGE: &str = "sbs://functions.sbs";
pub(crate) struct FunctionLibrary {
pub packages: BTreeMap<String, Arc<Package>>,
pub warnings: Vec<String>,
}
pub(crate) fn load() -> Result<FunctionLibrary, String> {
let bytes = materialcraft_formats::sbs::library::read(STANDARD_PACKAGE)?;
let mut read =
materialcraft_formats::sbs::read_sbs(&bytes, STANDARD_PACKAGE, &crate::file_cmds::linked_files(STANDARD_PACKAGE)).map_err(|error| error.to_string())?;
crate::linked_files::normalize_references(&mut read.pkg, STANDARD_PACKAGE);
read.warnings.extend(crate::linked_files::load(&mut read.pkg));
let mut packages = std::mem::take(&mut read.pkg.dependencies);
packages.insert(STANDARD_PACKAGE.into(), Arc::new(read.pkg));
Ok(FunctionLibrary { packages, warnings: read.warnings })
}
+22 -3
View File
@@ -22,7 +22,15 @@ pub(crate) fn specs() -> Vec<CommandSpec> {
})
}),
cmd!("graph.format", "Output format", [], None, "{format: u8|u16|f16|f32, graph?, document?}", always, format),
cmd!("graph.cook", "Compute graph", [], None, "{full?: bool} cooks now; returns per-node timings and errors", has_graph, cook),
cmd!(
"graph.cook",
"Compute graph",
[],
None,
"{full?: bool, graph?: index (another graph of the package cooks at full size into the cache)} cooks now; returns per-node timings and errors",
has_graph,
cook
),
cmd!("graph.pin.add", "Add Navigation pin", [], None, "{name?, at? [x, y]}", has_graph, pin_add),
cmd!("graph.pin.delete", "Delete pin", [], None, "{id}", has_graph, pin_delete),
cmd!(
@@ -153,8 +161,19 @@ fn format(s: &mut Session, p: &J) -> Result<J> {
}
fn cook(s: &mut Session, p: &J) -> Result<J> {
let cooked = if boolp(p, "full") == Some(true) { s.cook_full(s.graph) } else { s.cook().clone() };
let g = s.graph()?;
let index = match p.get("graph").filter(|graph| !graph.is_null()) {
None => s.graph,
Some(graph) => {
let index = graph.as_u64().and_then(|index| usize::try_from(index).ok()).ok_or_else(|| bad("graph.cook", "`graph` is a graph index"))?;
let graph = s.pkg.graph(index)?;
if graph.function.is_some() {
return Err(bad("graph.cook", "a Function Graph has no outputs to compute"));
}
index
}
};
let cooked = if index != s.graph || boolp(p, "full") == Some(true) { s.cook_full(index) } else { s.cook().clone() };
let g = s.pkg.graph(index)?;
Ok(json!({
"ms": cooked.ms,
"nodes": cooked.nodes.iter().map(|(id, r)| {
+3
View File
@@ -11,6 +11,9 @@ mod folder_property_commands;
pub use explorer_clipboard::ExplorerClipboard;
mod function_library;
mod function_library_commands;
pub mod node_library;
mod node_library_commands;
pub use node_library::{LibraryCanvas, LibraryEntry, LibraryItem, NodeLibrary};
mod function_variable;
mod function_variable_commands;
mod function_variables;
+432
View File
@@ -0,0 +1,432 @@
//! The node library. Every SBS package in the library folder (`assets/sbs`, or the bundled copies)
//! is loaded once per process. A package whose titled frames are library categories ("Filters -
//! Blurs") lays the library out: each node inside a frame becomes an entry in that category.
//! Every other package lends its graphs, which graph instances can use. Native nodes, function
//! operations, FX-Map nodes and graph items fill in what no layout places.
use materialcraft_core::{Package, PatternNodeKind};
use materialcraft_formats::sbs::{LayoutItem, library};
use serde::Serialize;
use std::collections::{BTreeMap, BTreeSet};
use std::sync::{Arc, Mutex};
/// The library tree in display order: top-level categories and their sub-categories. The UI adds
/// Favorites above it
pub const CATEGORIES: &[(&str, &[&str])] = &[
("Graph items", &[]),
("Atomic nodes", &[]),
("FxMap nodes", &[]),
("Function nodes", &["Constant", "Vector", "Variables", "Samplers", "Cast", "Operator", "Logical", "Comparison", "Function", "Control"]),
("Texture generators", &["Noises", "Patterns"]),
("Filters", &["Adjustments", "Blending", "Blurs", "Channels", "Effects", "Normal map", "Tiling", "Transforms"]),
("Material filters", &["1-click", "Effects", "Transforms", "Blending", "PBR utilities", "Scan processing"]),
("Mesh-based generators", &["Mask generators", "Weathering", "Utilities"]),
("Spline & Path tools", &["Spline tools", "Path tools"]),
("MCF functions", &["Primitives", "Operators", "Transforms"]),
("Functions", &["Color", "Comparison", "Constant", "Conversion", "Maths", "Parity", "Random", "Transformation", "Various", "Easings"]),
("3D view", &["HDRI environments", "HDRI tools"]),
("PBR materials", &["Bricks", "Concrete", "Fabric", "Ground", "Metal", "Paper", "Pavement", "Tiles", "Wood", "Stone"]),
("Values", &["Constant"]),
];
/// Older layouts name categories MaterialCraft has renamed: (old, current)
const RENAMED: &[(&str, &str)] = &[("SDF functions", "MCF functions")];
/// Words that place a material in a sub-category when its layout frame names only the top level
const SUB_KEYWORDS: &[(&str, &str, &[&str])] = &[
("PBR materials", "Bricks", &["brick"]),
("PBR materials", "Concrete", &["concrete", "cement"]),
("PBR materials", "Fabric", &["fabric", "cloth", "textile", "leather"]),
("PBR materials", "Ground", &["ground", "gravel", "soil", "sand", "dirt", "grass", "mud"]),
("PBR materials", "Metal", &["metal", "steel", "iron", "copper", "rust"]),
("PBR materials", "Paper", &["paper", "cardboard"]),
("PBR materials", "Pavement", &["pavement", "paving", "cobble", "asphalt"]),
("PBR materials", "Tiles", &["tile"]),
("PBR materials", "Wood", &["wood", "plank", "bark"]),
("PBR materials", "Stone", &["stone", "rock", "marble", "granite"]),
];
/// The graph kind that can take an entry
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub enum LibraryCanvas {
Material,
Function,
Pattern,
}
/// What adding an entry puts in the graph
#[derive(Clone, Debug, PartialEq, Serialize)]
#[serde(tag = "type", rename_all = "camelCase")]
pub enum LibraryItem {
/// A native node, by catalog id
Node {
def: String,
},
Comment,
Frame,
Pin,
/// An instance of a graph from a library package
Instance {
package: String,
graph: String,
},
/// A native function operation
Operation {
operation: String,
},
/// An instance of a function graph from a library package
FunctionInstance {
package: String,
graph: String,
},
/// An FX-Map node
Pattern {
kind: PatternNodeKind,
},
/// An environment image
Bitmap {
resource: String,
},
}
impl LibraryItem {
pub fn canvas(&self) -> LibraryCanvas {
match self {
Self::Operation { .. } | Self::FunctionInstance { .. } => LibraryCanvas::Function,
Self::Pattern { .. } => LibraryCanvas::Pattern,
_ => LibraryCanvas::Material,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize)]
pub struct LibraryEntry {
/// Stable id, e.g. `node:blur`, `function:add`, `sbs://functions.sbs#Functions/Math/Pi`
pub id: String,
pub label: String,
/// `Top` or `Top/Sub`, from [`CATEGORIES`]
pub category: String,
pub description: String,
#[serde(flatten)]
pub item: LibraryItem,
pub canvas: LibraryCanvas,
/// Why the entry can't be added yet (the package it needs is not in MaterialCraft)
#[serde(skip_serializing_if = "Option::is_none")]
pub missing: Option<String>,
/// It can be added, but is incomplete (it uses operations MaterialCraft lacks)
#[serde(skip_serializing_if = "Option::is_none")]
pub warning: Option<String>,
}
/// A layout placement, before it is resolved against the loaded packages
#[derive(Clone, Debug)]
struct Placement {
category: String,
item: LayoutItem,
}
/// Everything loaded from the library folder
#[derive(Debug, Default)]
pub struct NodeLibrary {
/// Library packages (layouts excluded) and their own dependencies, by `sbs://` path
pub packages: BTreeMap<String, Arc<Package>>,
/// The `sbs://` files that laid the library out
pub layouts: Vec<String>,
pub warnings: Vec<String>,
placements: Vec<Placement>,
}
static SHARED: Mutex<Option<Arc<NodeLibrary>>> = Mutex::new(None);
impl NodeLibrary {
/// The process's library, loaded on first use
pub fn shared() -> Arc<NodeLibrary> {
let mut shared = SHARED.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
shared.get_or_insert_with(|| Arc::new(Self::load(&library::files()))).clone()
}
/// Read the library folder again (after packages were added or changed on disk)
pub fn reload() -> Arc<NodeLibrary> {
let library = Arc::new(Self::load(&library::files()));
*SHARED.lock().unwrap_or_else(std::sync::PoisonError::into_inner) = Some(library.clone());
library
}
/// Load `files` (`sbs://` paths)
pub fn load(files: &[String]) -> NodeLibrary {
let mut out = NodeLibrary::default();
for uri in files {
let bytes = match library::read(uri) {
Ok(bytes) => bytes,
Err(error) => {
out.warnings.push(format!("Library package {uri}: {error}"));
continue;
}
};
// A layout's frames name library categories; anything else is a package of graphs
let placements = match materialcraft_formats::sbs::read_layout(&bytes, uri) {
Ok(frames) => placements(&frames),
Err(error) => {
out.warnings.push(format!("Library package {uri}: {error}"));
continue;
}
};
if !placements.is_empty() {
out.placements.extend(placements);
out.layouts.push(uri.clone());
continue;
}
match materialcraft_formats::sbs::read_sbs(&bytes, uri, &crate::file_cmds::linked_files(uri)) {
Ok(mut read) => {
crate::linked_files::normalize_references(&mut read.pkg, uri);
read.warnings.extend(crate::linked_files::load(&mut read.pkg));
out.warnings.extend(read.warnings);
for (path, package) in std::mem::take(&mut read.pkg.dependencies) {
out.packages.entry(path).or_insert(package);
}
out.packages.insert(uri.clone(), Arc::new(read.pkg));
}
Err(error) => out.warnings.push(format!("Library package {uri}: {error}")),
}
}
out
}
/// Every entry, resolved against `dependencies` (a session's loaded packages): layout
/// placements first, then graph items and native nodes no layout placed, then graphs of
/// `sbs://` packages no layout placed
pub fn entries(&self, dependencies: &BTreeMap<String, Arc<Package>>) -> Vec<LibraryEntry> {
let mut out = Vec::new();
let mut ids = BTreeSet::new();
let mut placed_graphs = BTreeSet::new();
let mut push = |out: &mut Vec<LibraryEntry>, mut entry: LibraryEntry| {
// The same node may sit in two categories; the id keeps each placement apart
if !ids.insert(entry.id.clone()) {
entry.id = format!("{}@{}", entry.id, entry.category);
if !ids.insert(entry.id.clone()) {
return;
}
}
out.push(entry);
};
for (item, category) in [(LibraryItem::Comment, "Comment"), (LibraryItem::Frame, "Frame"), (LibraryItem::Pin, "Pin")] {
let id = format!("item:{}", category.to_ascii_lowercase());
push(&mut out, entry(id, category, "Graph items", "", item, None));
}
push(&mut out, entry("node:dot".into(), "Dot node", "Graph items", "A reroute point for wires.", LibraryItem::Node { def: "dot".into() }, None));
for placement in &self.placements {
if let LayoutItem::Instance { package, graph, .. } | LayoutItem::FunctionInstance { package, graph } = &placement.item {
placed_graphs.insert((package.clone(), graph.clone()));
}
if let Some(entry) = resolve(placement, dependencies) {
push(&mut out, entry);
}
}
let listed: BTreeSet<String> = out.iter().map(|entry| entry.id.clone()).collect();
for definition in materialcraft_nodes::catalog() {
let id = format!("node:{}", definition.id);
if definition.id == "graph_instance" || listed.contains(&id) {
continue;
}
let item = LibraryItem::Node { def: definition.id.into() };
push(&mut out, entry(id, definition.label, definition.category, definition.description, item, None));
}
for operation in materialcraft_nodes::function::FUNCTIONS {
let id = format!("function:{}", operation.id);
if listed.contains(&id) {
continue;
}
let category = category_path("Function nodes", Some(operation.category));
push(&mut out, entry(id, operation.label, &category, "", LibraryItem::Operation { operation: operation.id.into() }, None));
}
for kind in PatternNodeKind::ALL {
let id = format!("pattern:{}", kind.native_id());
push(&mut out, entry(id, kind.label(), "FxMap nodes", "", LibraryItem::Pattern { kind }, None));
}
for (path, package) in dependencies.iter().filter(|(path, _)| path.starts_with("sbs://")) {
for graph in &package.graphs {
let name = graph.sbs_path();
if placed_graphs.contains(&(path.clone(), name.clone())) {
continue;
}
let placement = if graph.function.is_some() {
Placement { category: "Functions".into(), item: LayoutItem::FunctionInstance { package: path.clone(), graph: name } }
} else if graph.nodes.iter().any(|node| node.def == "output") {
let category = known_category(&graph.attributes.category).unwrap_or_else(|| "Other".into());
Placement { category, item: LayoutItem::Instance { package: path.clone(), graph: name, outputs: Vec::new() } }
} else {
continue;
};
if let Some(entry) = resolve(&placement, dependencies) {
push(&mut out, entry);
}
}
}
out
}
}
fn entry(id: String, label: &str, category: &str, description: &str, item: LibraryItem, missing: Option<String>) -> LibraryEntry {
let canvas = item.canvas();
LibraryEntry { id, label: label.into(), category: category.into(), description: description.into(), item, canvas, missing, warning: None }
}
/// A layout item as an entry, its label and availability taken from the loaded packages
fn resolve(placement: &Placement, dependencies: &BTreeMap<String, Arc<Package>>) -> Option<LibraryEntry> {
let category = placement.category.as_str();
Some(match &placement.item {
LayoutItem::Atomic { node: Some(def), .. } | LayoutItem::Node(def) => {
let definition = materialcraft_nodes::find(def)?;
entry(format!("node:{def}"), definition.label, category, definition.description, LibraryItem::Node { def: def.to_string() }, None)
}
LayoutItem::Atomic { filter, node: None } => {
let item = LibraryItem::Node { def: filter.clone() };
entry(format!("atomic:{filter}"), &humanize(filter), category, "", item, Some(format!("The atomic `{filter}` node is not in MaterialCraft yet")))
}
LayoutItem::Operation(operation) => {
let definition = materialcraft_nodes::function::FUNCTIONS.iter().find(|definition| definition.id == operation);
let label = definition.map_or_else(|| humanize(operation), |definition| definition.label.to_string());
let missing = definition.is_none().then(|| format!("The `{operation}` function node is not in MaterialCraft yet"));
entry(format!("function:{operation}"), &label, category, "", LibraryItem::Operation { operation: operation.clone() }, missing)
}
LayoutItem::Instance { package, graph, .. } | LayoutItem::FunctionInstance { package, graph } => {
let function = matches!(placement.item, LayoutItem::FunctionInstance { .. });
let source = dependencies.get(package).and_then(|source| source.graph_by_name(graph)).map(|(_, graph)| graph);
let source = source.filter(|source| source.function.is_some() == function);
let label = source.map_or_else(|| humanize(graph), |source| source.display_name().to_string());
let description = source.map(|source| source.attributes.description.clone()).unwrap_or_default();
let missing = source.is_none().then(|| format!("Not in MaterialCraft yet: needs {graph} from {package}"));
let item = if function {
LibraryItem::FunctionInstance { package: package.clone(), graph: graph.clone() }
} else {
LibraryItem::Instance { package: package.clone(), graph: graph.clone() }
};
let mut out = entry(format!("{package}#{graph}"), &label, category, &description, item, missing);
out.category = sub_category(category, graph);
out.warning = source
.and_then(|source| source.function.as_ref())
.filter(|function| function.output.is_none() || function.nodes.iter().any(|node| node.missing.is_some()))
.map(|_| "This function uses nodes MaterialCraft does not have yet".to_string());
out
}
// A bitmap anywhere but the 3D view stands for the atomic Bitmap node, not its image
LayoutItem::Bitmap { .. } if !category.starts_with("3D view") => {
let definition = materialcraft_nodes::find("bitmap")?;
entry("node:bitmap".into(), definition.label, category, definition.description, LibraryItem::Node { def: "bitmap".into() }, None)
}
LayoutItem::Bitmap { resource } => {
let name = resource.rsplit('/').next().unwrap_or(resource);
let missing = Some(format!("Not in MaterialCraft yet: the {} image is not bundled", humanize(name)));
entry(format!("bitmap:{resource}"), &humanize(name), category, "", LibraryItem::Bitmap { resource: resource.clone() }, missing)
}
})
}
/// The categories of a layout's frames, and what each places
fn placements(frames: &[materialcraft_formats::sbs::LayoutFrame]) -> Vec<Placement> {
let mut out = Vec::new();
for frame in frames {
let native = frame.items.iter().any(|item| matches!(item, LayoutItem::Operation(_)));
let Some(category) = frame_category(&frame.title, frame.function, native) else { continue };
out.extend(frame.items.iter().map(|item| Placement { category: category.clone(), item: item.clone() }));
}
out
}
/// Letters and digits, lower case: "Spline &amp; Path Tools", "spline & path tools" and
/// "Spline-and-path tools" differ, but "1 click" and "1-click" match
fn key(text: &str) -> String {
text.chars().filter(char::is_ascii_alphanumeric).map(|c| c.to_ascii_lowercase()).collect()
}
/// `Top/Sub` for a frame title. Graph frames read "Top - Sub" (or "Top"); function frames name
/// only the sub-category, under Function nodes when they hold native operations and Functions
/// otherwise
pub fn frame_category(title: &str, function: bool, native_operations: bool) -> Option<String> {
if function {
let top = if native_operations { "Function nodes" } else { "Functions" };
let (_, subs) = CATEGORIES.iter().find(|(name, _)| *name == top)?;
let sub = subs.iter().find(|sub| key(sub) == key(title))?;
return Some(category_path(top, Some(sub)));
}
let (top, sub) = title.split_once(" - ").map_or((title, None), |(top, sub)| (top, Some(sub)));
let top = RENAMED.iter().find(|(old, _)| key(old) == key(top)).map_or(top, |(_, current)| current);
let (top, subs) = CATEGORIES.iter().find(|(name, _)| key(name) == key(top))?;
match sub {
None => Some((*top).to_string()),
Some(sub) => subs.iter().find(|name| key(name) == key(sub)).map(|sub| category_path(top, Some(sub))),
}
}
/// A category text from a graph's attributes, when it names a library category
fn known_category(text: &str) -> Option<String> {
let mut parts = text.split('/');
let top = parts.next()?;
let (top, subs) = CATEGORIES.iter().find(|(name, _)| key(name) == key(top))?;
let sub = parts.next().and_then(|sub| subs.iter().find(|name| key(name) == key(sub)));
Some(category_path(top, sub.copied()))
}
fn category_path(top: &str, sub: Option<&str>) -> String {
match sub {
Some(sub) => format!("{top}/{sub}"),
None => top.to_string(),
}
}
/// The sub-category a graph's name suggests, for layouts that name only a top level
fn sub_category(category: &str, graph: &str) -> String {
if category.contains('/') {
return category.to_string();
}
let name = graph.rsplit('/').next().unwrap_or(graph).to_ascii_lowercase();
SUB_KEYWORDS
.iter()
.find(|(top, _, words)| *top == category && words.iter().any(|word| name.contains(word)))
.map_or_else(|| category.to_string(), |(top, sub, _)| category_path(top, Some(sub)))
}
/// A readable label from an SBS identifier: `3D_perlin_noise` → "3D Perlin Noise"
pub fn humanize(identifier: &str) -> String {
const WORDS: &[(&str, &str)] = &[
("2d", "2D"),
("3d", "3D"),
("acescg", "ACEScg"),
("ao", "AO"),
("bnw", "BnW"),
("hdr", "HDR"),
("hdri", "HDRI"),
("hq", "HQ"),
("id", "ID"),
("mg", "MG"),
("pbr", "PBR"),
("rgb", "RGB"),
("rgba", "RGBA"),
("rgb-a", "RGB-A"),
("srgb", "sRGB"),
("uv", "UV"),
];
let name = identifier.rsplit('/').next().unwrap_or(identifier);
name.split(['_', ' '])
.filter(|word| !word.is_empty())
.map(|word| {
let lower = word.to_ascii_lowercase();
if let Some((_, known)) = WORDS.iter().find(|(from, _)| *from == lower) {
return (*known).to_string();
}
let mut chars = word.chars();
chars.next().map_or_else(String::new, |first| first.to_uppercase().chain(chars).collect())
})
.collect::<Vec<_>>()
.join(" ")
}
#[cfg(test)]
#[path = "node_library.test.rs"]
mod tests;
+118
View File
@@ -0,0 +1,118 @@
use super::*;
use materialcraft_core::Graph;
#[test]
fn frame_titles_map_to_library_categories() {
assert_eq!(frame_category("Texture Generators - Noises", false, false).as_deref(), Some("Texture generators/Noises"));
assert_eq!(frame_category("Spline & Path tools - Path tools", false, false).as_deref(), Some("Spline & Path tools/Path tools"));
assert_eq!(frame_category("Material Filters - 1 click", false, false).as_deref(), Some("Material filters/1-click"));
assert_eq!(frame_category("Mesh-based generators - Weathering", false, false).as_deref(), Some("Mesh-based generators/Weathering"));
assert_eq!(frame_category("PBR Materials", false, false).as_deref(), Some("PBR materials"));
assert_eq!(frame_category("Atomic Nodes", false, false).as_deref(), Some("Atomic nodes"));
// The category MaterialCraft renamed still reads from older layouts
assert_eq!(frame_category("SDF functions - Primitives", false, false).as_deref(), Some("MCF functions/Primitives"));
assert_eq!(frame_category("Functions Inside", false, false), None);
assert_eq!(frame_category("Filters - Nowhere", false, false), None);
assert_eq!(frame_category("Comparison", true, true).as_deref(), Some("Function nodes/Comparison"));
assert_eq!(frame_category("Comparison", true, false).as_deref(), Some("Functions/Comparison"));
assert_eq!(frame_category("Unknown", true, true), None);
}
#[test]
fn identifiers_read_as_labels() {
assert_eq!(humanize("3D_perlin_noise"), "3D Perlin Noise");
assert_eq!(humanize("bnw_spots_1"), "BnW Spots 1");
assert_eq!(humanize("rgb-a_merge"), "RGB-A Merge");
assert_eq!(humanize("Functions/Math/acescg_to_srgb"), "ACEScg To sRGB");
assert_eq!(humanize("__"), "");
}
#[test]
fn the_bundled_library_fills_every_category_of_the_tree() {
let library = NodeLibrary::shared();
assert_eq!(library.layouts, vec!["sbs://all_nodes.sbs".to_string()]);
assert!(library.packages.contains_key("sbs://functions.sbs"));
assert!(!library.packages.contains_key("sbs://all_nodes.sbs"), "a layout is not a package of graphs");
let entries = library.entries(&library.packages);
let ids: BTreeSet<_> = entries.iter().map(|entry| entry.id.as_str()).collect();
assert_eq!(ids.len(), entries.len(), "ids are unique");
let known = |category: &str| {
let mut parts = category.split('/');
let top = parts.next().unwrap_or("");
CATEGORIES.iter().any(|(name, subs)| *name == top && parts.next().is_none_or(|sub| subs.contains(&sub)))
};
for entry in &entries {
assert!(known(&entry.category), "{} sits in unknown category {}", entry.id, entry.category);
}
let count = |category: &str| entries.iter().filter(|entry| entry.category == category).count();
let find = |id: &str| entries.iter().find(|entry| entry.id == id).unwrap_or_else(|| panic!("no entry {id}"));
// Every top-level category that has sub-categories, except the new ones, has entries
for (top, subs) in CATEGORIES {
for sub in *subs {
let category = format!("{top}/{sub}");
if !matches!(*top, "MCF functions" | "Values") && !matches!(category.as_str(), "PBR materials/Pavement" | "PBR materials/Stone") {
assert!(count(&category) > 0, "{category} is empty");
}
}
}
assert_eq!(count("Texture generators/Noises"), 89);
assert_eq!(
entries.iter().filter(|entry| entry.category == "Graph items").map(|entry| entry.label.as_str()).collect::<Vec<_>>(),
["Comment", "Frame", "Pin", "Dot node"]
);
assert_eq!(find("node:blur").category, "Atomic nodes");
assert_eq!(find("node:output").category, "Atomic nodes");
assert!(find("node:bitmap").missing.is_none(), "the atomic frame's bitmap is the Bitmap node");
assert!(entries.iter().filter(|entry| entry.category == "Atomic nodes").all(|entry| entry.missing.is_none()));
assert!(entries.iter().filter(|entry| entry.category == "3D view/HDRI environments").all(|entry| entry.missing.is_some()));
assert!(find("node:blur").missing.is_none());
assert_eq!(find("function:add").category, "Function nodes/Operator");
assert_eq!(find("pattern:paramset").category, "FxMap nodes");
let pi = find("sbs://functions.sbs#Functions/Math/Pi");
assert_eq!((pi.label.as_str(), pi.category.as_str()), ("Pi", "Functions/Constant"));
assert!(pi.missing.is_none());
assert_eq!(find("sbs://functions.sbs#Functions/Math/Equality_Float2").category, "Functions/Comparison");
let perlin = find("sbs://3d_perlin_noise.sbs#3D_perlin_noise");
assert_eq!((perlin.label.as_str(), perlin.category.as_str()), ("3D Perlin Noise", "Texture generators/Noises"));
assert!(perlin.missing.is_some(), "library packages MaterialCraft lacks are listed but not addable");
assert_eq!(find("sbs://materials/pbr/bricks_001.sbs#bricks_001").category, "PBR materials/Bricks");
assert_eq!(find("sbs://materials/pbr/old_painted_planks.sbs#old_painted_planks").category, "PBR materials/Wood");
// A node that sits in two frames is listed in both
assert!(entries.iter().filter(|entry| entry.id.starts_with("sbs://paths_tools.sbs#path_to_spline")).count() == 2);
}
#[test]
fn a_library_package_makes_its_placed_entry_available() {
let library = NodeLibrary::shared();
let mut dependencies = library.packages.clone();
let mut graph = Graph::new("3D_perlin_noise");
graph.add_node("uniform", [0.0; 2]);
graph.add_node("output", [200.0, 0.0]);
let mut package = Package::new("3d_perlin_noise");
package.graphs.push(graph.clone());
graph.name = "Loose".into();
graph.attributes.category = "Filters/Blurs".into();
package.graphs.push(graph);
dependencies.insert("sbs://3d_perlin_noise.sbs".into(), Arc::new(package));
let entries = library.entries(&dependencies);
let perlin = entries.iter().find(|entry| entry.id == "sbs://3d_perlin_noise.sbs#3D_perlin_noise").unwrap();
assert!(perlin.missing.is_none());
assert_eq!(perlin.category, "Texture generators/Noises");
let loose = entries.iter().find(|entry| entry.id == "sbs://3d_perlin_noise.sbs#Loose").unwrap();
assert_eq!((loose.category.as_str(), loose.canvas), ("Filters/Blurs", LibraryCanvas::Material));
}
#[test]
fn unreadable_library_files_warn_instead_of_failing() {
let library = NodeLibrary::load(&["sbs://does_not_exist.sbs".into(), "sbs://../escape.sbs".into()]);
assert!(library.packages.is_empty() && library.layouts.is_empty());
assert_eq!(library.warnings.len(), 2);
let entries = library.entries(&BTreeMap::new());
assert!(entries.iter().any(|entry| entry.id == "node:blur" && entry.category == "Atomic nodes"));
assert!(entries.iter().any(|entry| entry.id == "function:add" && entry.category == "Function nodes/Operator"));
}
+131
View File
@@ -0,0 +1,131 @@
//! Library commands: list the categorized library, add an entry to the open graph, and read the
//! library folder again
use crate::commands::{CommandSpec, always, bad, boolp, has_graph, point, strp};
use crate::node_library::{CATEGORIES, LibraryCanvas, LibraryEntry, LibraryItem, NodeLibrary};
use crate::{FunctionGraphTarget, Result, Session, cmd};
use serde_json::{Value, json};
use std::collections::BTreeSet;
const ADD: &str = "library.add";
pub(crate) fn specs() -> Vec<CommandSpec> {
vec![
cmd!(
"library.tree",
"Library categories",
[],
None,
"{filter?, category? (Top or Top/Sub), canvas? (material|function|pattern)} the library tree and its entries: id, label, category, type, canvas, missing (not addable yet), warning",
always,
tree
),
cmd!(
"library.add",
"Add library entry",
[],
None,
"{entry (id from library.tree), at? [x, y], snapToGrid?, function?: FunctionGraphTarget} adds a library entry to the open graph (function entries to a Function canvas)",
has_graph,
add
),
cmd!("library.reload", "Reload library", [], None, "{} reads the SBS library folder again", always, reload),
]
}
impl Session {
/// The library's entries, resolved against this session's loaded packages
pub fn library_entries(&self) -> Vec<LibraryEntry> {
self.library.entries(&self.pkg.dependencies)
}
}
fn tree(session: &mut Session, parameters: &Value) -> Result<Value> {
let filter = strp(parameters, "filter").unwrap_or("").to_lowercase();
let category = strp(parameters, "category").unwrap_or("");
let canvas = match strp(parameters, "canvas") {
None => None,
Some("material") => Some(LibraryCanvas::Material),
Some("function") => Some(LibraryCanvas::Function),
Some("pattern") => Some(LibraryCanvas::Pattern),
Some(other) => return Err(bad("library.tree", format!("unknown canvas `{other}`: material, function or pattern"))),
};
let entries: Vec<_> = session
.library_entries()
.into_iter()
.filter(|entry| category.is_empty() || entry.category == category || entry.category.starts_with(&format!("{category}/")))
.filter(|entry| canvas.is_none_or(|canvas| entry.canvas == canvas))
.filter(|entry| filter.is_empty() || entry.label.to_lowercase().contains(&filter) || entry.id.to_lowercase().contains(&filter))
.collect();
let categories: Vec<_> = CATEGORIES.iter().map(|(name, subcategories)| json!({"name": name, "subcategories": subcategories})).collect();
Ok(json!({"categories": categories, "layouts": session.library.layouts, "entries": entries}))
}
fn add(session: &mut Session, parameters: &Value) -> Result<Value> {
let id = strp(parameters, "entry").ok_or_else(|| bad(ADD, "`entry` is required (an id from library.tree)"))?;
let entry = session.library_entries().into_iter().find(|entry| entry.id == id).ok_or_else(|| bad(ADD, format!("no library entry `{id}`")))?;
if let Some(missing) = &entry.missing {
return Err(bad(ADD, format!("{}: {missing}", entry.label)));
}
let at = point(parameters, "at").unwrap_or([0.0, 0.0]);
let snap = boolp(parameters, "snapToGrid").unwrap_or(false);
let function_graph = session.graph()?.function.is_some();
let target = parameters.get("function").cloned().filter(|target| !target.is_null());
if entry.canvas == LibraryCanvas::Function {
let target = match target {
Some(target) => serde_json::from_value::<FunctionGraphTarget>(target).map_err(|error| bad(ADD, error.to_string()))?,
None if function_graph => FunctionGraphTarget::Graph,
None => return Err(bad(ADD, format!("{} goes in a Function canvas: open a Function Graph or pass `function`", entry.label))),
};
let target = serde_json::to_value(target).map_err(|error| bad(ADD, error.to_string()))?;
let result = match &entry.item {
LibraryItem::Operation { operation } => crate::execute(
session,
"graph.function.edit",
&json!({"target": target, "edit": {"action": "add", "operation": operation, "at": at, "snap": snap}}),
)?,
LibraryItem::FunctionInstance { package, graph } => {
crate::execute(session, "library.function.add", &json!({"package": package, "graph": graph, "function": target, "at": at, "snapToGrid": snap}))?
}
_ => return Err(bad(ADD, "unexpected function entry")),
};
return Ok(json!({"entry": entry.id, "result": result}));
}
if entry.canvas == LibraryCanvas::Pattern {
return Err(bad(ADD, format!("{} is an FX-Map node: add it with graph.pattern.edit", entry.label)));
}
if function_graph {
return Err(bad(ADD, format!("{} goes in a material graph, not a Function Graph", entry.label)));
}
let result = match &entry.item {
LibraryItem::Node { def } => crate::execute(session, "graph.node.add", &json!({"def": def, "at": at, "snapToGrid": snap}))?,
LibraryItem::Comment => crate::execute(session, "graph.comment.add", &json!({"at": at}))?,
LibraryItem::Frame => crate::execute(session, "graph.frame.add", &json!({"rect": [at[0], at[1], 400.0, 260.0]}))?,
LibraryItem::Pin => crate::execute(session, "graph.pin.add", &json!({"at": at}))?,
LibraryItem::Instance { package, graph } => {
crate::execute(session, "graph.instance.add", &json!({"package": package, "graph": graph, "at": at, "snapToGrid": snap}))?
}
_ => return Err(bad(ADD, format!("{} can't be added to a graph", entry.label))),
};
Ok(json!({"entry": entry.id, "result": result}))
}
fn reload(session: &mut Session, _: &Value) -> Result<Value> {
let library = NodeLibrary::reload();
let mut changed = BTreeSet::new();
for (path, package) in &library.packages {
if session.linked_sources.get(path).is_none_or(|current| current.graphs != package.graphs || current.resources != package.resources) {
session.linked_sources.insert(path.clone(), package.clone());
changed.insert(path.clone());
}
}
for warning in &library.warnings {
session.warn(warning.clone());
}
session.library = library;
session.refresh_links_from(changed);
let entries = session.library_entries();
Ok(json!({"entries": entries.len(), "available": entries.iter().filter(|entry| entry.missing.is_none()).count(), "layouts": session.library.layouts}))
}
+12 -12
View File
@@ -157,6 +157,8 @@ pub struct Session {
pub cache: Arc<Mutex<Cache>>,
/// A mesh loaded for the 3D view (`scene: "custom"`): its file name and geometry.
pub custom_mesh: Option<(String, Arc<materialcraft_geom::Mesh>)>,
/// The node library loaded from the SBS library folder
pub library: Arc<crate::node_library::NodeLibrary>,
pub(crate) history: crate::document_history::DocumentHistory,
group: Option<(Snapshot, bool)>,
decoded: Arc<Mutex<HashMap<(u64, bool), Image>>>,
@@ -164,11 +166,9 @@ pub struct Session {
impl Session {
pub fn new(mut pkg: Package) -> Session {
let library = crate::function_library::load();
if let Ok(library) = &library {
for (path, package) in &library.packages {
pkg.dependencies.entry(path.clone()).or_insert_with(|| package.clone());
}
let library = crate::node_library::NodeLibrary::shared();
for (path, package) in &library.packages {
pkg.dependencies.entry(path.clone()).or_insert_with(|| package.clone());
}
let mut session = Session {
environment: Default::default(),
@@ -201,19 +201,19 @@ impl Session {
cook_epoch: 0,
cache: Arc::new(Mutex::new(Cache::default())),
custom_mesh: None,
library: Default::default(),
history: Default::default(),
group: None,
decoded: Arc::new(Mutex::new(HashMap::new())),
};
session.refresh_links();
match library {
Ok(library) => {
for warning in library.warnings {
session.warn(warning);
}
}
Err(error) => session.warn(format!("Missing function library: {error}")),
for warning in &library.warnings {
session.warn(warning.clone());
}
if !library.packages.contains_key(crate::function_library::STANDARD_PACKAGE) {
session.warn(format!("Missing function library: {} did not load", crate::function_library::STANDARD_PACKAGE));
}
session.library = library;
session
}
+1
View File
@@ -20,6 +20,7 @@ mod graph_properties;
mod linked_instances;
mod linked_resources;
mod material_preview;
mod node_library;
mod normal_maps;
mod open_documents;
mod optimization_perf;
+82
View File
@@ -0,0 +1,82 @@
use materialcraft_engine::{
Session,
core::{FunctionGraph, Graph, Package},
execute, new_session,
};
use serde_json::{Value, json};
fn entries(session: &mut Session, parameters: Value) -> Vec<Value> {
execute(session, "library.tree", &parameters).unwrap()["entries"].as_array().unwrap().clone()
}
#[test]
fn the_library_tree_lists_categories_and_filters_entries() {
let mut session = new_session();
let tree = execute(&mut session, "library.tree", &json!({})).unwrap();
let names: Vec<_> = tree["categories"].as_array().unwrap().iter().map(|category| category["name"].as_str().unwrap()).collect();
assert_eq!(names[..4], ["Graph items", "Atomic nodes", "FxMap nodes", "Function nodes"]);
assert!(names.contains(&"MCF functions") && !names.contains(&"SDF functions"));
assert_eq!(tree["layouts"], json!(["sbs://all_nodes.sbs"]));
let noises = entries(&mut session, json!({"category": "Texture generators/Noises"}));
assert_eq!(noises.len(), 89);
assert!(noises.iter().all(|entry| entry["missing"].is_string()));
let functions = entries(&mut session, json!({"canvas": "function", "filter": "pi"}));
assert!(functions.iter().any(|entry| entry["id"] == "sbs://functions.sbs#Functions/Math/Pi" && entry["type"] == "functionInstance"));
assert!(functions.iter().all(|entry| entry["canvas"] == "function"));
assert!(execute(&mut session, "library.tree", &json!({"canvas": "teapot"})).is_err());
}
#[test]
fn library_entries_add_to_the_graph_they_fit() {
let mut session = new_session();
let before = session.graph().unwrap().nodes.len();
let added = execute(&mut session, "library.add", &json!({"entry": "node:blur", "at": [32.0, 64.0]})).unwrap();
assert_eq!(added["entry"], "node:blur");
let graph = session.graph().unwrap();
assert_eq!(graph.nodes.len(), before + 1);
assert_eq!(graph.nodes.last().unwrap().def, "blur");
assert_eq!(graph.nodes.last().unwrap().pos, [32.0, 64.0]);
for (entry, check) in [("item:comment", "comments"), ("item:frame", "frames"), ("item:pin", "pins")] {
let count = |session: &Session| serde_json::to_value(session.graph().unwrap()).unwrap()[check].as_array().map_or(0, Vec::len);
let previous = count(&session);
execute(&mut session, "library.add", &json!({"entry": entry})).unwrap();
assert_eq!(count(&session), previous + 1, "{entry}");
}
// Library nodes MaterialCraft lacks are listed but refuse to add, naming what they need
let error = execute(&mut session, "library.add", &json!({"entry": "sbs://3d_perlin_noise.sbs#3D_perlin_noise"})).unwrap_err().to_string();
assert!(error.contains("3d_perlin_noise.sbs"), "{error}");
assert!(execute(&mut session, "library.add", &json!({"entry": "nothing"})).is_err());
assert!(execute(&mut session, "library.add", &json!({})).is_err());
// Function entries need a Function canvas
assert!(execute(&mut session, "library.add", &json!({"entry": "function:add"})).is_err());
assert!(execute(&mut session, "library.add", &json!({"entry": "pattern:paramset"})).is_err());
let mut package = Package::new("Functions");
let mut graph = Graph::new("Caller");
graph.function = Some(FunctionGraph::default());
package.graphs.push(graph);
let mut session = Session::new(package);
execute(&mut session, "library.add", &json!({"entry": "function:add", "at": [0.0, 0.0]})).unwrap();
execute(&mut session, "library.add", &json!({"entry": "sbs://functions.sbs#Functions/Math/Pi", "at": [140.0, 0.0]})).unwrap();
let function = session.graph().unwrap().function.as_ref().unwrap();
assert_eq!(function.nodes.len(), 2);
assert!(function.nodes.iter().any(|node| node.op == "add"));
assert!(function.nodes.iter().any(|node| node.instance.as_ref().is_some_and(|instance| instance.graph == "Functions/Math/Pi")));
assert!(execute(&mut session, "library.add", &json!({"entry": "node:blur"})).is_err());
execute(&mut session, "edit.undo", &json!({})).unwrap();
assert_eq!(session.graph().unwrap().function.as_ref().unwrap().nodes.len(), 1);
}
#[test]
fn reloading_the_library_keeps_open_work_unmodified() {
let mut session = new_session();
let reloaded = execute(&mut session, "library.reload", &json!({})).unwrap();
assert!(reloaded["entries"].as_u64().unwrap() > 500);
assert!(reloaded["available"].as_u64().unwrap() > 200);
assert!(!session.modified);
assert!(session.pkg.dependencies.contains_key("sbs://functions.sbs"));
}
+64
View File
@@ -79,6 +79,70 @@ pub fn read(uri: &str) -> Result<Vec<u8>, String> {
// Installed and browser builds use the same bundled asset when no disk asset root exists
match relative {
"functions.sbs" => Ok(include_bytes!("../../../../assets/sbs/functions.sbs").to_vec()),
"all_nodes.sbs" => Ok(include_bytes!("../../../../assets/sbs/all_nodes.sbs").to_vec()),
_ => Err(format!("Missing library asset {uri}")),
}
}
/// The packages bundled into the binary, for installs and the browser without an asset folder
pub const BUNDLED: &[&str] = &["sbs://all_nodes.sbs", "sbs://functions.sbs"];
/// Bounds for scanning the library folder: how deep, and how many packages
const MAX_DEPTH: usize = 6;
const MAX_FILES: usize = 2048;
/// Every SBS package in the library as `sbs://` paths, sorted: the files under the asset folder
/// (resource folders skipped), or the bundled packages when there is no folder
pub fn files() -> Vec<String> {
#[cfg(not(target_arch = "wasm32"))]
{
let root = root();
if root.is_dir() {
let mut found = Vec::new();
scan(&root, "", 0, &mut found);
found.sort();
return found;
}
}
BUNDLED.iter().map(|uri| uri.to_string()).collect()
}
#[cfg(not(target_arch = "wasm32"))]
fn scan(directory: &std::path::Path, prefix: &str, depth: usize, found: &mut Vec<String>) {
let Ok(entries) = std::fs::read_dir(directory) else { return };
let mut entries: Vec<_> = entries.flatten().collect();
entries.sort_by_key(|entry| entry.file_name());
for entry in entries {
if found.len() >= MAX_FILES {
return;
}
let Some(name) = entry.file_name().to_str().map(str::to_string) else { continue };
let Ok(kind) = entry.file_type() else { continue };
let uri = format!("sbs://{prefix}{name}");
// Symlinks are skipped: `read` refuses files that leave the asset folder anyway
if kind.is_dir() && depth < MAX_DEPTH && !name.ends_with(".resources") && !name.starts_with('.') {
scan(&entry.path(), &format!("{prefix}{name}/"), depth + 1, found);
} else if kind.is_file() && name.to_ascii_lowercase().ends_with(".sbs") && relative_path(&uri).is_ok() {
found.push(uri);
}
}
}
#[cfg(test)]
#[allow(clippy::unwrap_used)]
mod tests {
use super::*;
#[test]
fn the_library_lists_every_package_once_and_bundles_a_fallback() {
let files = files();
for uri in BUNDLED {
assert!(files.iter().any(|file| file == uri), "{uri} in {files:?}");
assert!(!read(uri).unwrap().is_empty());
}
let mut unique = files.clone();
unique.dedup();
assert_eq!(unique, files);
assert!(files.iter().all(|file| relative_path(file).is_ok() && file.ends_with(".sbs")));
}
}
+298
View File
@@ -0,0 +1,298 @@
//! Library layouts. An SBS package can lay out a node library: its graphs group nodes in titled
//! frames ("Filters - Blurs"), and a parameter function groups function nodes the same way. This
//! reads the frames and the nodes inside each one; it does not cook anything. The engine decides
//! which frame titles are library categories.
use super::{
constant::MAX_XML_NODES,
filter_map::FILTERS,
xml::{child_element, child_value, children_named, parse_floats},
};
use crate::{FormatError, Result};
use roxmltree::Node as XmlNode;
use std::collections::HashMap;
/// Bounds for hostile layouts: frames and placed nodes kept per file
const MAX_FRAMES: usize = 4096;
const MAX_ITEMS: usize = 65_536;
/// A titled frame and the nodes inside it, top to bottom
#[derive(Clone, Debug, PartialEq)]
pub struct LayoutFrame {
pub title: String,
/// The frame groups function nodes (it sits in a function graph or a parameter function)
pub function: bool,
pub items: Vec<LayoutItem>,
}
/// One node placed in a layout frame
#[derive(Clone, Debug, PartialEq)]
pub enum LayoutItem {
/// An atomic SBS filter by its SBS name, with the MaterialCraft node it reads as (`None`
/// when MaterialCraft has no counterpart yet)
Atomic { filter: String, node: Option<&'static str> },
/// A graph input (`input_color`, `input_grayscale`, `input_value`) or `output`
Node(&'static str),
/// An instance of graph `graph` from the library package `package`
Instance { package: String, graph: String, outputs: Vec<String> },
/// A native function operation, e.g. `add`
Operation(String),
/// An instance of function graph `graph` from the library package `package`
FunctionInstance { package: String, graph: String },
/// A bitmap showing one of the layout package's own resources, e.g. an environment image
Bitmap { resource: String },
}
/// The frames of every graph and parameter function in `bytes`, in document order
pub fn read_layout(bytes: &[u8], uri: &str) -> Result<Vec<LayoutFrame>> {
let text = std::str::from_utf8(bytes).map_err(|e| FormatError::BadPackage(format!("the SBS file is not UTF-8 text: {e}")))?;
let text = text.trim_start_matches('\u{feff}');
let options = roxmltree::ParsingOptions { allow_dtd: false, nodes_limit: MAX_XML_NODES };
let doc = roxmltree::Document::parse_with_options(text, options).map_err(|e| FormatError::BadPackage(format!("the SBS file is not valid XML: {e}")))?;
let root = doc.root_element();
if root.tag_name().name() != "package" {
return Err(FormatError::BadPackage("not an SBS package (the root element is not <package>)".into()));
}
let mut dependencies = HashMap::new();
for dependency in child_element(root, "dependencies").into_iter().flat_map(|d| children_named(d, "dependency")) {
if let (Some(uid), Some(file)) = (child_value(dependency, "uid"), child_value(dependency, "filename")) {
let file = if file == "?himself" { uri } else { file };
dependencies.insert(uid, file.to_string());
}
}
let mut frames = Vec::new();
let mut items = 0;
for scope in root.descendants().filter(|node| node.is_element()) {
let function = match scope.tag_name().name() {
"graph" if child_element(scope, "compNodes").is_some() => false,
_ if child_element(scope, "paramNodes").is_some() => true,
_ => continue,
};
let mut scope_frames = scope_frames(scope);
if scope_frames.is_empty() {
continue;
}
let nodes: Vec<(XmlNode, [f32; 2])> = if function {
child_element(scope, "paramNodes").into_iter().flat_map(|n| children_named(n, "paramNode")).filter_map(|n| Some((n, position(n)?))).collect()
} else {
child_element(scope, "compNodes").into_iter().flat_map(|n| children_named(n, "compNode")).filter_map(|n| Some((n, position(n)?))).collect()
};
let mut placed: Vec<(usize, [f32; 2], LayoutItem)> = Vec::new();
for (node, at) in nodes {
if items >= MAX_ITEMS {
break;
}
// The smallest frame holding the node wins, so nested frames keep their own nodes
let Some(frame) = scope_frames
.iter()
.enumerate()
.filter(|(_, (_, rect))| at[0] >= rect[0] && at[1] >= rect[1] && at[0] <= rect[0] + rect[2] && at[1] <= rect[1] + rect[3])
.min_by(|a, b| (a.1.1[2] * a.1.1[3]).total_cmp(&(b.1.1[2] * b.1.1[3])))
.map(|(index, _)| index)
else {
continue;
};
let item = if function { function_item(node, &dependencies) } else { graph_item(scope, node, &dependencies) };
if let Some(item) = item {
placed.push((frame, at, item));
items += 1;
}
}
placed.sort_by(|a, b| a.0.cmp(&b.0).then(a.1[1].total_cmp(&b.1[1])).then(a.1[0].total_cmp(&b.1[0])));
let mut grouped: Vec<Vec<LayoutItem>> = vec![Vec::new(); scope_frames.len()];
for (frame, _, item) in placed {
if let Some(list) = grouped.get_mut(frame) {
list.push(item);
}
}
for ((title, _), items) in scope_frames.drain(..).zip(grouped) {
if frames.len() >= MAX_FRAMES {
break;
}
frames.push(LayoutFrame { title, function, items });
}
}
Ok(frames)
}
/// The titled frames of a graph or function: (title, [x, y, width, height])
fn scope_frames(scope: XmlNode) -> Vec<(String, [f32; 4])> {
child_element(scope, "GUIObjects")
.into_iter()
.flat_map(|objects| children_named(objects, "GUIObject"))
.filter(|object| child_value(*object, "type") == Some("COMMENT"))
.filter_map(|object| {
let title = child_value(object, "title")?.trim();
let layout = child_element(object, "GUILayout")?;
let at = parse_floats(child_value(layout, "gpos")?);
let size = parse_floats(child_value(layout, "size")?);
let rect = [*at.first()?, *at.get(1)?, *size.first()?, *size.get(1)?];
(!title.is_empty() && rect[2] > 0.0 && rect[3] > 0.0).then(|| (title.chars().take(256).collect(), rect))
})
.take(MAX_FRAMES)
.collect()
}
fn position(node: XmlNode) -> Option<[f32; 2]> {
let at = parse_floats(child_value(child_element(node, "GUILayout")?, "gpos")?);
Some([*at.first()?, *at.get(1)?])
}
/// `pkg:///Graph/Path?dependency=123` as (graph path, package file)
fn reference(path: &str, dependencies: &HashMap<&str, String>) -> Option<(String, String)> {
let path = path.strip_prefix("pkg:///")?;
let (graph, query) = path.split_once('?').unwrap_or((path, ""));
let uid = query.split('&').find_map(|pair| pair.strip_prefix("dependency="))?;
let package = dependencies.get(uid)?.clone();
let graph = graph.trim_matches('/');
(!graph.is_empty()).then(|| (graph.chars().take(1024).collect(), package))
}
fn graph_item(graph: XmlNode, node: XmlNode, dependencies: &HashMap<&str, String>) -> Option<LayoutItem> {
let implementation = child_element(node, "compImplementation")?.children().find(|c| c.is_element())?;
match implementation.tag_name().name() {
"compFilter" => {
let filter = child_value(implementation, "filter")?;
if filter == "bitmap"
&& let Some(resource) = string_parameter(implementation, "bitmapresourcepath")
{
let resource = resource.strip_prefix("pkg:///").unwrap_or(resource);
let resource = resource.split_once('?').map_or(resource, |(path, _)| path);
return Some(LayoutItem::Bitmap { resource: resource.chars().take(1024).collect() });
}
Some(LayoutItem::Atomic { filter: filter.chars().take(128).collect(), node: FILTERS.iter().find(|f| f.sbs == filter).map(|f| f.def) })
}
"compInstance" => {
let (graph, package) = reference(child_value(implementation, "path")?, dependencies)?;
let outputs = child_element(implementation, "outputBridgings")
.into_iter()
.flat_map(|b| children_named(b, "outputBridging"))
.filter_map(|b| child_value(b, "identifier"))
.take(64)
.map(str::to_string)
.collect();
Some(LayoutItem::Instance { package, graph, outputs })
}
"compInputBridge" => {
let entry = child_value(implementation, "entry")?;
let input = child_element(graph, "paraminputs")
.into_iter()
.flat_map(|inputs| children_named(inputs, "paraminput"))
.find(|input| child_value(*input, "uid") == Some(entry));
Some(LayoutItem::Node(match input.and_then(|input| child_value(input, "type")) {
Some("1") | None => "input_color",
Some("2") => "input_grayscale",
Some(_) => "input_value",
}))
}
"compOutputBridge" => Some(LayoutItem::Node("output")),
_ => None,
}
}
fn function_item(node: XmlNode, dependencies: &HashMap<&str, String>) -> Option<LayoutItem> {
let operation = child_value(node, "function")?;
if operation != "instance" {
return Some(LayoutItem::Operation(operation.chars().take(128).collect()));
}
let path = child_element(node, "funcDatas")
.into_iter()
.flat_map(|datas| children_named(datas, "funcData"))
.find(|data| child_value(*data, "name") == Some("instance"))
.and_then(|data| child_element(data, "constantValue"))
.and_then(|value| child_value(value, "constantValueString"))?;
let (graph, package) = reference(path, dependencies)?;
Some(LayoutItem::FunctionInstance { package, graph })
}
fn string_parameter<'a>(filter: XmlNode<'a, '_>, name: &str) -> Option<&'a str> {
child_element(filter, "parameters")
.into_iter()
.flat_map(|parameters| children_named(parameters, "parameter"))
.find(|parameter| child_value(*parameter, "name") == Some(name))
.and_then(|parameter| child_element(parameter, "paramValue"))
.and_then(|value| child_value(value, "constantValueString"))
}
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used)]
mod tests {
use super::*;
const LAYOUT: &str = r#"<?xml version="1.0"?><package><dependencies>
<dependency><filename v="?himself"/><uid v="1"/></dependency>
<dependency><filename v="sbs://noise.sbs"/><uid v="2"/></dependency>
<dependency><filename v="sbs://functions.sbs"/><uid v="3"/></dependency></dependencies>
<content><graph><identifier v="Graph"/>
<paraminputs><paraminput><identifier v="mask"/><uid v="40"/><type v="2"/></paraminput></paraminputs>
<compNodes>
<compNode><uid v="10"/><GUILayout><gpos v="20 90 0"/></GUILayout><compImplementation><compInstance><path v="pkg:///perlin_noise?dependency=2"/><outputBridgings><outputBridging><uid v="11"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode>
<compNode><uid v="12"/><GUILayout><gpos v="20 40 0"/></GUILayout><compImplementation><compFilter><filter v="blur"/></compFilter></compImplementation></compNode>
<compNode><uid v="13"/><GUILayout><gpos v="20 60 0"/></GUILayout><compImplementation><compInputBridge><entry v="40"/></compInputBridge></compImplementation></compNode>
<compNode><uid v="14"/><GUILayout><gpos v="500 60 0"/></GUILayout><compImplementation><compFilter><filter v="bitmap"/><parameters><parameter><name v="bitmapresourcepath"/><paramValue><constantValueString v="pkg:///Resources/studio?dependency=1"/></paramValue></parameter></parameters></compFilter></compImplementation></compNode>
<compNode><uid v="15"/><GUILayout><gpos v="900 900 0"/></GUILayout><compImplementation><compOutputBridge/></compImplementation></compNode>
<compNode><uid v="16"/><GUILayout><gpos v="30 70 0"/></GUILayout><compImplementation><compFilter><filter v="blend"/><parameters><parameter><name v="opacitymult"/><paramValue><dynamicValue>
<paramNodes>
<paramNode><uid v="1"/><GUILayout><gpos v="0 10 0"/></GUILayout><function v="add"/></paramNode>
<paramNode><uid v="2"/><GUILayout><gpos v="300 10 0"/></GUILayout><function v="instance"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Pi?dependency=3"/></constantValue></funcData></funcDatas></paramNode>
</paramNodes>
<GUIObjects>
<GUIObject><type v="COMMENT"/><GUILayout><gpos v="-10 0 0"/><size v="100 100"/></GUILayout><title v="Operator"/></GUIObject>
<GUIObject><type v="COMMENT"/><GUILayout><gpos v="250 0 0"/><size v="100 100"/></GUILayout><title v="Constant"/></GUIObject>
</GUIObjects></dynamicValue></paramValue></parameter></parameters></compFilter></compImplementation></compNode>
</compNodes>
<GUIObjects>
<GUIObject><type v="COMMENT"/><GUILayout><gpos v="0 0 0"/><size v="160 200"/></GUILayout><title v="Texture Generators - Noises"/></GUIObject>
<GUIObject><type v="COMMENT"/><GUILayout><gpos v="400 0 0"/><size v="160 200"/></GUILayout><title v="3D view - HDRI environments"/></GUIObject>
<GUIObject><type v="COMMENT"/><GUILayout><gpos v="0 0 0"/><size v="10 10"/></GUILayout></GUIObject>
</GUIObjects></graph></content></package>"#;
#[test]
fn frames_list_what_sits_inside_them_top_to_bottom() {
let frames = read_layout(LAYOUT.as_bytes(), "sbs://layout.sbs").unwrap();
let graph: Vec<_> = frames.iter().filter(|frame| !frame.function).collect();
assert_eq!(graph.len(), 2);
assert_eq!(graph[0].title, "Texture Generators - Noises");
assert_eq!(
graph[0].items,
vec![
LayoutItem::Atomic { filter: "blur".into(), node: Some("blur") },
LayoutItem::Node("input_grayscale"),
LayoutItem::Atomic { filter: "blend".into(), node: Some("blend") },
LayoutItem::Instance { package: "sbs://noise.sbs".into(), graph: "perlin_noise".into(), outputs: vec!["output".into()] },
]
);
assert_eq!(graph[1].items, vec![LayoutItem::Bitmap { resource: "Resources/studio".into() }]);
let function: Vec<_> = frames.iter().filter(|frame| frame.function).collect();
assert_eq!(function.len(), 2);
assert_eq!(function[0].items, vec![LayoutItem::Operation("add".into())]);
assert_eq!(function[1].items, vec![LayoutItem::FunctionInstance { package: "sbs://functions.sbs".into(), graph: "Functions/Math/Pi".into() }]);
}
#[test]
fn packages_without_frames_have_no_layout_and_bad_input_errors() {
assert!(read_layout(b"<package><content><graph><compNodes/></graph></content></package>", "sbs://x.sbs").unwrap().is_empty());
assert!(read_layout(b"<nope/>", "sbs://x.sbs").is_err());
assert!(read_layout(b"\xff\xfe", "sbs://x.sbs").is_err());
assert!(read_layout(b"<package><content><graph><compNodes><compNode><GUILayout><gpos v=\"nan\"/></GUILayout></compNode></compNodes><GUIObjects><GUIObject><type v=\"COMMENT\"/><GUILayout><gpos v=\"0 0\"/><size v=\"-5 1e40\"/></GUILayout><title v=\"X\"/></GUIObject></GUIObjects></graph></content></package>", "sbs://x.sbs").unwrap().is_empty());
}
#[test]
fn the_bundled_layout_places_the_whole_library() {
let bytes = super::super::library::read("sbs://all_nodes.sbs").unwrap();
let frames = read_layout(&bytes, "sbs://all_nodes.sbs").unwrap();
let count = |title: &str| frames.iter().filter(|frame| frame.title == title).map(|frame| frame.items.len()).sum::<usize>();
assert_eq!(count("Atomic Nodes"), 28);
assert_eq!(count("Texture Generators - Noises"), 89);
assert_eq!(count("Filters - Blurs"), 14);
assert!(frames.iter().filter(|frame| frame.function).count() >= 20);
assert!(
frames.iter().flat_map(|frame| &frame.items).any(|item| matches!(item, LayoutItem::FunctionInstance { graph, .. } if graph == "Functions/Math/Pi"))
);
}
}
+2
View File
@@ -12,6 +12,7 @@ mod group_layout;
mod image_input;
mod input_bridge;
pub mod library;
mod library_layout;
mod node_identifiers;
mod node_parameter;
mod output;
@@ -29,6 +30,7 @@ mod warnings;
mod xml;
pub use constant::SBS_EXT;
pub use library_layout::{LayoutFrame, LayoutItem, read_layout};
pub use read::{is_sbs, read_sbs};
pub use sbs_read::SbsRead;
pub use write::write_sbs;
+28 -1
View File
@@ -49,11 +49,12 @@ pub fn show(app: &mut MaterialCraftApp, ui: &mut Ui) {
inspected_graph: None,
inspected_folder: None,
};
egui::ScrollArea::vertical().auto_shrink([false, false]).show(ui, |ui| {
let scroll = egui::ScrollArea::vertical().auto_shrink([false, false]).show(ui, |ui| {
for (document, package, path, modified) in tree.session.open_packages() {
ui.push_id(document, |ui| tree.package(ui, document, package, path, modified));
}
});
tree.state.hovered = ui.rect_contains_pointer(scroll.inner_rect);
let action = tree.action;
let opened_node = tree.opened_node;
let assignment = tree.assignment;
@@ -111,6 +112,32 @@ pub fn show(app: &mut MaterialCraftApp, ui: &mut Ui) {
}
}
/// Enter opens, F2 renames and Delete removes the selected graph or folder while the pointer is
/// over the Explorer; elsewhere those keys keep their graph shortcuts. True when a key was used
pub(crate) fn shortcuts(app: &mut MaterialCraftApp, ctx: &egui::Context) -> bool {
if !app.ui.explorer.hovered || app.ui.explorer.rename.is_some() {
return false;
}
let Some(target) = app.ui.explorer.selected.clone() else { return false };
let command = match &target {
ExplorerTarget::Graph { .. } => [(egui::Key::Enter, "graph.open"), (egui::Key::F2, "graph.rename"), (egui::Key::Delete, "graph.delete")]
.into_iter()
.find(|(key, _)| pressed(ctx, *key)),
ExplorerTarget::Folder { .. } if !target.is_resources_root() => {
[(egui::Key::F2, "folder.rename"), (egui::Key::Delete, "folder.remove")].into_iter().find(|(key, _)| pressed(ctx, *key))
}
_ => None,
};
let Some((key, command)) = command else { return false };
ctx.input_mut(|input| input.consume_key(egui::Modifiers::NONE, key));
actions::invoke(app, ctx, target, command);
true
}
fn pressed(ctx: &egui::Context, key: egui::Key) -> bool {
ctx.input(|input| input.modifiers.is_none() && input.key_pressed(key))
}
pub(crate) fn dialogs(app: &mut MaterialCraftApp, ctx: &egui::Context) {
actions::rename_dialog(app, ctx);
}
+73 -1
View File
@@ -55,15 +55,87 @@ pub(super) fn invoke(app: &mut MaterialCraftApp, ctx: &egui::Context, target: Ex
"package.close" | "file.reload" => {
crate::unsaved::guard(app, crate::unsaved::Guarded::Package { document: target.document(), reload: command == "file.reload" })
}
"file.save" | "file.saveAs" | "file.saveCopyAs" => {
"file.save" | "file.saveAs" | "file.saveCopyAs" | "file.exportMaterial" | "file.sendToTextureCraft" => {
crate::windows::file_action(app, ctx, command);
}
crate::menus::EXPLORER_COMPUTE => compute_outputs(app, &target),
crate::menus::EXPLORER_VIEW_OUTPUTS => {
if let ExplorerTarget::Graph { index, .. } = target
&& app.run("view.3d.outputs", json!({"graph": index})).is_some()
{
app.ui.dock.focus(crate::docking::Panel::View3d);
}
}
crate::menus::EXPLORER_EXPORT_OUTPUTS => {
if let ExplorerTarget::Graph { index, .. } = target
&& (index == app.session.graph || app.run("graph.open", json!({"graph": index})).is_some())
{
app.ui.windows.export = true;
}
}
crate::menus::EXPLORER_SHOW_IN_FOLDER => show_in_folder(app),
crate::menus::EXPLORER_OPEN_DEPENDENCIES => open_dependencies(app),
_ => {
app.run(command, target.parameters());
}
}
}
/// A dependency that is another package file on disk (not a library package or an unsaved one)
pub(super) fn is_package_file(path: &str) -> bool {
!path.starts_with("sbs://") && !path.starts_with("unsaved:") && !path.is_empty()
}
/// Cook the graph's outputs, or every graph of the package with outputs, at full size
fn compute_outputs(app: &mut MaterialCraftApp, target: &ExplorerTarget) {
let graphs: Vec<usize> = match target {
ExplorerTarget::Graph { index, .. } => vec![*index],
_ => app.session.pkg.graphs.iter().enumerate().filter(|(_, graph)| graph.function.is_none()).map(|(index, _)| index).collect(),
};
let (mut milliseconds, mut errors) = (0.0, 0);
for index in &graphs {
let Some(result) = app.run("graph.cook", json!({"graph": index, "full": true})) else { return };
milliseconds += result["ms"].as_f64().unwrap_or(0.0);
errors += result["nodes"].as_array().map_or(0, |nodes| nodes.iter().filter(|node| !node["error"].is_null()).count());
}
let summary = crate::i18n::trf("Computed {count} graph(s) in {ms} ms", &[("count", &graphs.len()), ("ms", &format!("{milliseconds:.0}"))]);
if errors > 0 {
app.toast(format!("{summary}; {}", crate::i18n::trf("{count} node(s) failed: see the graph", &[("count", &errors)])), true);
} else {
app.toast(summary, false);
}
}
#[cfg(not(target_arch = "wasm32"))]
fn package_path(app: &MaterialCraftApp) -> Option<String> {
app.session.open_packages().into_iter().find(|entry| entry.0 == app.session.document_id).and_then(|entry| entry.2.map(str::to_string))
}
#[cfg(not(target_arch = "wasm32"))]
fn show_in_folder(app: &mut MaterialCraftApp) {
let Some(path) = package_path(app) else { return };
if let Err(error) = craft_update::process::reveal(std::path::Path::new(&path)) {
app.toast(format!("{}: {error}", tr("Could not show the package file")), true);
}
}
#[cfg(target_arch = "wasm32")]
fn show_in_folder(_: &mut MaterialCraftApp) {}
/// Open every package file the active package links, next to it in the Explorer
#[cfg(not(target_arch = "wasm32"))]
fn open_dependencies(app: &mut MaterialCraftApp) {
let document = app.session.document_id;
let paths: Vec<String> = app.session.pkg.dependencies.keys().filter(|path| is_package_file(path)).cloned().collect();
for path in paths {
crate::windows::open_path(app, &path);
}
activate(app, document);
}
#[cfg(target_arch = "wasm32")]
fn open_dependencies(_: &mut MaterialCraftApp) {}
pub(super) fn rename_dialog(app: &mut MaterialCraftApp, ctx: &egui::Context) {
let Some((target, mut name)) = app.ui.explorer.rename.clone() else { return };
let mut open = true;
+96 -52
View File
@@ -1,64 +1,108 @@
use super::ExplorerTarget;
use crate::{i18n::tr, menus};
use crate::menus::{self, ExplorerRow};
use crate::{i18n::tr, menus::shortcut_label};
pub(super) fn show(ui: &mut egui::Ui, target: &ExplorerTarget, paste: bool, reload: bool) -> Option<&'static str> {
ui.set_min_width(190.0);
/// What the right-clicked item allows right now
#[derive(Clone, Copy, Debug, Default)]
pub(super) struct MenuState {
/// The Explorer clipboard holds something to paste
pub paste: bool,
/// The package has a file on disk (reload, show in folder)
pub saved: bool,
/// The package links other package files
pub dependencies: bool,
/// The graph (or, for a package, one of its graphs) has image outputs
pub outputs: bool,
}
impl MenuState {
fn enabled(&self, command: &str) -> bool {
match command {
"" => false,
"explorer.paste" => self.paste,
"file.reload" | menus::EXPLORER_SHOW_IN_FOLDER => self.saved,
menus::EXPLORER_OPEN_DEPENDENCIES => self.dependencies,
menus::EXPLORER_COMPUTE | menus::EXPLORER_VIEW_OUTPUTS | menus::EXPLORER_EXPORT_OUTPUTS => self.outputs,
_ => true,
}
}
}
/// Rows the browser can't offer: it has no folders to show or package files to open
fn hidden(command: &str) -> bool {
cfg!(target_arch = "wasm32") && matches!(command, menus::EXPLORER_SHOW_IN_FOLDER | menus::EXPLORER_OPEN_DEPENDENCIES)
}
fn item(ui: &mut egui::Ui, label: &str, command: &'static str, shortcut: Option<&str>, enabled: bool, action: &mut Option<&'static str>) {
let mut button = egui::Button::new(tr(label));
if let Some(shortcut) = shortcut {
button = button.shortcut_text(shortcut_label(ui.ctx(), shortcut));
}
let response = ui.add_enabled(enabled, button);
let response = if command.is_empty() { response.on_disabled_hover_text(tr("Not available yet")) } else { response };
if response.clicked() {
*action = Some(command);
ui.close();
}
}
fn rows(ui: &mut egui::Ui, rows: &[ExplorerRow], state: &MenuState, resources: bool, action: &mut Option<&'static str>) {
for row in rows {
match *row {
ExplorerRow::Separator => {
ui.separator();
}
ExplorerRow::Item(label, command, shortcut) if !hidden(command) => item(ui, label, command, shortcut, state.enabled(command), action),
ExplorerRow::Item(..) => {}
ExplorerRow::Sub(label, entries) => {
let available = entries.iter().any(|(_, command)| !command.is_empty());
ui.add_enabled_ui(available, |ui| {
let submenu = ui.menu_button(tr(label), |ui| {
for (entry, command) in entries {
// Resource folders hold folders and resources, not graphs
if resources && label == "New" && *command != "folder.create" {
continue;
}
item(ui, entry, command, None, state.enabled(command), action);
}
});
submenu.response.on_disabled_hover_text(tr("Not available yet"));
});
}
}
}
}
pub(super) fn show(ui: &mut egui::Ui, target: &ExplorerTarget, state: &MenuState) -> Option<&'static str> {
ui.set_min_width(220.0);
let mut action = None;
let resources = target.is_resources();
if matches!(target, ExplorerTarget::Package { .. } | ExplorerTarget::Folder { .. }) {
ui.menu_button(tr("New"), |ui| {
for (label, command) in menus::EXPLORER_NEW {
if resources && *command != "folder.create" {
continue;
}
if ui.button(tr(label)).clicked() {
action = Some(*command);
ui.close();
}
match target {
ExplorerTarget::Package { .. } => rows(ui, menus::EXPLORER_PACKAGE, state, false, &mut action),
ExplorerTarget::Folder { .. } if resources => {
rows(ui, &[ExplorerRow::Sub("New", menus::EXPLORER_NEW), ExplorerRow::Sub("Import", menus::EXPLORER_IMPORT)], state, true, &mut action);
if !target.is_resources_root() {
ui.separator();
rows(
ui,
&[ExplorerRow::Item("Rename", "folder.rename", Some("F2")), ExplorerRow::Item("Remove", "folder.remove", Some("Delete"))],
state,
true,
&mut action,
);
}
});
if matches!(target, ExplorerTarget::Package { .. }) || resources {
ui.menu_button(tr("Import"), |ui| {
for (label, command) in menus::EXPLORER_IMPORT {
if ui.button(tr(label)).clicked() {
action = Some(*command);
ui.close();
}
}
});
}
ui.separator();
}
if resources {
if !target.is_resources_root() {
for (label, command) in [("Rename", "folder.rename"), ("Remove", "folder.remove")] {
if ui.button(tr(label)).clicked() {
action = Some(command);
ui.close();
}
ExplorerTarget::Folder { .. } => {
rows(ui, &[ExplorerRow::Sub("New", menus::EXPLORER_NEW), ExplorerRow::Separator], state, false, &mut action);
rows(ui, menus::EXPLORER_FOLDER, state, false, &mut action);
}
ExplorerTarget::Graph { .. } => rows(ui, menus::EXPLORER_GRAPH, state, false, &mut action),
ExplorerTarget::Resource { .. } => {
for (label, command) in menus::EXPLORER_RESOURCE {
item(ui, label, command, None, true, &mut action);
}
}
return action;
}
let entries = match target {
ExplorerTarget::Package { .. } => menus::EXPLORER_PACKAGE,
ExplorerTarget::Folder { .. } => menus::EXPLORER_FOLDER,
ExplorerTarget::Graph { .. } => menus::EXPLORER_GRAPH,
ExplorerTarget::Resource { .. } => menus::EXPLORER_RESOURCE,
ExplorerTarget::Node { .. } => return None,
};
for (label, command) in entries {
let enabled = match *command {
"explorer.paste" => paste,
"file.reload" => reload,
_ => true,
};
if ui.add_enabled(enabled, egui::Button::new(tr(label))).clicked() {
action = Some(*command);
ui.close();
}
}
action
}
@@ -6,4 +6,7 @@ use serde::{Deserialize, Serialize};
pub struct ExplorerState {
pub selected: Option<ExplorerTarget>,
pub rename: Option<(ExplorerTarget, String)>,
/// The pointer was over the Explorer last frame, so Enter, F2 and Delete act on its selection
#[serde(skip)]
pub hovered: bool,
}
+7 -1
View File
@@ -158,7 +158,13 @@ impl ExplorerTree<'_> {
self.action = Some((target.clone(), "activate"));
}
response.context_menu(|ui| {
if let Some(command) = context_menu::show(ui, target, self.session.explorer_clipboard.is_some(), reload) {
let outputs = match target {
ExplorerTarget::Graph { index, .. } => package.graphs.get(*index).is_some_and(|graph| graph.function.is_none()),
_ => package.graphs.iter().any(|graph| graph.function.is_none()),
};
let dependencies = package.dependencies.keys().any(|path| super::actions::is_package_file(path));
let state = context_menu::MenuState { paste: self.session.explorer_clipboard.is_some(), saved: reload, dependencies, outputs };
if let Some(command) = context_menu::show(ui, target, &state) {
self.action = Some((target.clone(), command));
}
});
@@ -1,4 +1,5 @@
pub(super) enum FunctionLibraryDrag {
/// A library function being dragged onto a Function canvas
pub(crate) enum FunctionLibraryDrag {
Operation(String),
Instance { package: String, graph: String },
}
+16 -68
View File
@@ -1,78 +1,26 @@
use super::function_library_drag::FunctionLibraryDrag;
use crate::{MaterialCraftApp, i18n::tr};
use egui::{Sense, Ui};
pub(crate) use super::function_library_drag::FunctionLibraryDrag;
use crate::MaterialCraftApp;
use materialcraft_engine::FunctionEdit;
pub(crate) fn show(app: &mut MaterialCraftApp, ui: &mut Ui) {
let Some(target) = app.function_editor.as_ref().and_then(|editor| editor.command_target()) else { return };
let operations = target.available_operations(&app.session);
ui.add(egui::TextEdit::singleline(&mut app.ui.library_search).hint_text(tr("Search functions")));
let search = app.ui.library_search.to_ascii_lowercase();
let functions: Vec<_> = app
.session
.pkg
.dependencies
.iter()
.filter(|(path, _)| path.starts_with("sbs://"))
.flat_map(|(path, package)| {
package.graphs.iter().filter(|graph| graph.function.is_some()).map(move |graph| {
(
path.clone(),
graph.sbs_path(),
graph.display_name().to_string(),
graph.attributes.description.clone(),
graph.function.as_ref().is_some_and(|function| function.output.is_none() || function.nodes.iter().any(|node| node.missing.is_some())),
)
})
})
.filter(|(_, path, label, _, _)| path.to_ascii_lowercase().contains(&search) || label.to_ascii_lowercase().contains(&search))
.collect();
let mut add = None;
egui::ScrollArea::vertical().show(ui, |ui| {
ui.strong(tr("SBS functions"));
if !app.session.pkg.dependencies.keys().any(|path| path.starts_with("sbs://")) {
ui.colored_label(egui::Color32::from_rgb(255, 90, 180), tr("Missing SBS function library"));
}
for (package, graph, label, description, missing) in functions {
let text = if missing {
egui::RichText::new(format!("{}: {label}", tr("Missing"))).color(egui::Color32::from_rgb(255, 90, 180))
} else {
egui::RichText::new(&label)
};
let response = ui.add(egui::Label::new(text).selectable(false).sense(Sense::click_and_drag()));
crate::widgets::name(&response, egui::Role::ListItem, &label);
if response.drag_started() {
egui::DragAndDrop::set_payload(ui.ctx(), FunctionLibraryDrag::Instance { package: package.clone(), graph: graph.clone() });
}
if response.double_clicked() {
add = Some(FunctionLibraryDrag::Instance { package: package.clone(), graph: graph.clone() });
}
response.on_hover_text(format!("{description}\n{package}/{graph}"));
}
ui.separator();
ui.strong(tr("Native operations"));
for definition in operations.filter(|definition| definition.label.to_ascii_lowercase().contains(&search)) {
let response = ui.add(egui::Label::new(tr(definition.label)).selectable(false).sense(Sense::click_and_drag()));
crate::widgets::name(&response, egui::Role::ListItem, definition.label);
if response.drag_started() {
egui::DragAndDrop::set_payload(ui.ctx(), FunctionLibraryDrag::Operation(definition.id.into()));
}
if response.double_clicked() {
add = Some(FunctionLibraryDrag::Operation(definition.id.into()));
}
}
});
if let Some(add) = add
&& let Some(mut editor) = app.function_editor.take()
{
/// Add `entry` to the open Function canvas, after its last node
pub(crate) fn add(app: &mut MaterialCraftApp, entry: &FunctionLibraryDrag) {
if let Some(mut editor) = app.function_editor.take() {
let at = editor.current(app).map_or([0.0; 2], |graph| [graph.nodes.len() as f32 * 140.0, 0.0]);
insert(app, &mut editor, &add, at);
insert(app, &mut editor, entry, at);
app.function_editor = Some(editor);
}
}
/// The native operations the open Function canvas can take (processors that only compute a
/// value cannot sample images)
pub(crate) fn available_operations(app: &MaterialCraftApp) -> Vec<&'static str> {
app.function_editor
.as_ref()
.and_then(|editor| editor.command_target())
.map(|target| target.available_operations(&app.session).map(|definition| definition.id).collect())
.unwrap_or_default()
}
pub(super) fn insert(app: &mut MaterialCraftApp, editor: &mut super::FunctionEditor, entry: &FunctionLibraryDrag, at: [f32; 2]) {
match entry {
FunctionLibraryDrag::Operation(operation) => {
+1 -1
View File
@@ -247,7 +247,7 @@ pub(super) fn handle(
{
let graph_position = camera.to_graph(position);
let at = [graph_position.x - NODE_W * 0.5, graph_position.y - 20.0];
app.run("graph.node.add", json!({"def": payload.0, "at": at}));
app.run("library.add", json!({"entry": payload.0, "at": at}));
}
// Keys over the canvas
+1 -1
View File
@@ -1,3 +1,3 @@
/// A library item being dragged onto the canvas
/// A library entry (its `library.tree` id) being dragged onto the canvas
#[derive(Clone, Debug)]
pub struct LibraryDrag(pub String);
+1 -1
View File
@@ -30,7 +30,7 @@ pub(crate) use graph_camera::GraphCamera;
use graph_drag::GraphDrag;
pub use graph_view::GraphView;
pub use library_drag::LibraryDrag;
pub use navigation::add_node_near_selection;
pub use navigation::{add_entry_in_view, add_node_near_selection};
use node_search::NodeSearch;
pub use node_style::{NODE_W, header_color, node_label, node_rect, port_color};
pub use port_hit::PortHit;
+6
View File
@@ -9,6 +9,12 @@ pub(super) fn view_center(app: &MaterialCraftApp) -> Pos2 {
pos2(c.pan[0] + v.width() * 0.5 / c.zoom, c.pan[1] + v.height() * 0.5 / c.zoom)
}
/// Add library entry `id` (a comment, frame, pin or graph instance) in the middle of the view
pub fn add_entry_in_view(app: &mut MaterialCraftApp, id: &str) {
let c = view_center(app);
app.run("library.add", json!({"entry": id, "at": [c.x - NODE_W * 0.5, c.y - 60.0], "snapToGrid": app.ui.prefs.snap_to_grid}));
}
/// Add `def` right of the last selected node (wired from it when it fits), else mid-view
pub fn add_node_near_selection(app: &mut MaterialCraftApp, def: &str) {
let sel = app.session.selection.last().copied();
+413 -142
View File
@@ -1,214 +1,485 @@
//! The library: a category tree on the left, the matching nodes as preview tiles (or a list) on
//! the right, with search. Drag a tile into the graph, or double-click it to add it next to the
//! selection.
//! The library: a category tree on the left (Favorites, then the library's categories and
//! sub-categories), the matching entries as preview tiles (or a list) on the right, with search and
//! filters. Drag an entry into the graph, or double-click it to add it. Entries the open graph
//! can't take, and library nodes MaterialCraft doesn't have yet, are dimmed.
use std::sync::Arc;
use egui::{Color32, Rect, RichText, Sense, Ui, vec2};
use egui_phosphor::regular as icon;
use materialcraft_engine::node_library::CATEGORIES;
use materialcraft_engine::{LibraryCanvas, LibraryEntry, LibraryItem};
use crate::MaterialCraftApp;
use crate::function::library::FunctionLibraryDrag;
use crate::graph::editor_target::EditorTarget;
use crate::graph::{LibraryDrag, header_color};
use crate::i18n::tr;
use crate::theme::Tokens;
/// The tree: (top level, its sub-categories as full category paths).
fn tree() -> Vec<(&'static str, Vec<&'static str>)> {
let mut out: Vec<(&'static str, Vec<&'static str>)> = Vec::new();
for (cat, _) in materialcraft_engine::nodes::categories() {
let top = cat.split('/').next().unwrap_or(cat);
match out.iter_mut().find(|(t, _)| *t == top) {
Some((_, subs)) => {
if cat != top {
subs.push(cat);
}
}
None => out.push((top, if cat != top { vec![cat] } else { Vec::new() })),
}
/// The category key of the Favorites row
pub(crate) const FAVORITES: &str = "@favorites";
/// Function entries that need more nodes than MaterialCraft has are shown in this color
const WARNING: Color32 = Color32::from_rgb(255, 90, 180);
fn category_icon(category: &str) -> &'static str {
match category {
FAVORITES => icon::STAR,
"Graph items" => icon::FLOW_ARROW,
"Atomic nodes" => icon::CUBE,
"FxMap nodes" => icon::SPARKLE,
"Function nodes" => icon::FUNCTION,
"Texture generators" => icon::DICE_FIVE,
"Texture generators/Noises" => icon::CLOUD,
"Texture generators/Patterns" => icon::CHECKERBOARD,
"Filters" => icon::FADERS,
"Filters/Adjustments" => icon::CIRCLE_HALF_TILT,
"Filters/Blending" | "Material filters/Blending" => icon::INTERSECT,
"Filters/Blurs" => icon::DROP,
"Filters/Channels" => icon::STACK,
"Filters/Effects" => icon::MAGIC_WAND,
"Filters/Normal map" => icon::COMPASS,
"Filters/Tiling" => icon::SQUARES_FOUR,
"Filters/Transforms" | "Material filters/Transforms" => icon::BOUNDING_BOX,
"Material filters" => icon::SPHERE,
"Material filters/1-click" => icon::CURSOR_CLICK,
"Material filters/Effects" => icon::SPARKLE,
"Material filters/PBR utilities" => icon::WRENCH,
"Material filters/Scan processing" => icon::SCAN,
"Mesh-based generators" => icon::POLYGON,
"Mesh-based generators/Mask generators" => icon::CUBE_TRANSPARENT,
"Mesh-based generators/Weathering" => icon::CLOUD_RAIN,
"Mesh-based generators/Utilities" => icon::TOOLBOX,
"Spline & Path tools" | "Spline & Path tools/Spline tools" => icon::BEZIER_CURVE,
"Spline & Path tools/Path tools" => icon::PATH,
"MCF functions" => icon::MATH_OPERATIONS,
"Functions" => icon::WAVE_SINE,
"3D view" => icon::GLOBE,
"3D view/HDRI environments" => icon::GLOBE_HEMISPHERE_WEST,
"3D view/HDRI tools" => icon::SUN,
"PBR materials" => icon::CIRCLE_HALF,
"Values" => icon::HASH,
_ => match category.split('/').next().unwrap_or("") {
"Function nodes" | "MCF functions" | "Values" => icon::ARROW_SQUARE_OUT,
"Functions" => icon::WAVE_SINE,
"PBR materials" => icon::CIRCLE,
_ => icon::FOLDER_SIMPLE,
},
}
out
}
fn category_icon(top: &str) -> &'static str {
match top {
"Atomic nodes" => icon::CUBE,
"Graph items" => icon::FLOW_ARROW,
"Texture generators" => icon::DICE_FIVE,
"Filters" => icon::FADERS,
"Material filters" => icon::SPHERE,
_ => icon::FOLDER_OPEN,
/// The graph the library adds to, and which native function operations it can take
pub(crate) struct Here {
canvas: LibraryCanvas,
operations: Vec<&'static str>,
}
impl Here {
pub(crate) fn of(app: &MaterialCraftApp) -> Here {
match EditorTarget::resolve(app) {
EditorTarget::Material => Here { canvas: LibraryCanvas::Material, operations: Vec::new() },
EditorTarget::Pattern => Here { canvas: LibraryCanvas::Pattern, operations: Vec::new() },
EditorTarget::Function => Here { canvas: LibraryCanvas::Function, operations: crate::function::library::available_operations(app) },
}
}
/// Whether `entry` can go into the open graph now
pub(crate) fn takes(&self, entry: &LibraryEntry) -> bool {
entry.missing.is_none()
&& entry.canvas == self.canvas
&& match &entry.item {
LibraryItem::Operation { operation } => self.operations.contains(&operation.as_str()),
_ => true,
}
}
/// Why `entry` can't go into the open graph, when it can't
fn refusal(&self, entry: &LibraryEntry) -> Option<String> {
if let Some(missing) = &entry.missing {
return Some(missing.clone());
}
if entry.canvas != self.canvas {
return Some(
match entry.canvas {
LibraryCanvas::Material => tr("Open a graph to add this"),
LibraryCanvas::Function => tr("Open a function graph or a processor's function to add this"),
LibraryCanvas::Pattern => tr("Open an FX-Map to add this"),
}
.to_string(),
);
}
(!self.takes(entry)).then(|| tr("This function can't use this node").to_string())
}
}
/// The library's entries for the open session, rebuilt when its packages change
fn entries(app: &MaterialCraftApp, ctx: &egui::Context) -> Arc<Vec<LibraryEntry>> {
type Cached = (Vec<(String, usize)>, Arc<Vec<LibraryEntry>>);
let mut key: Vec<(String, usize)> = vec![(String::new(), Arc::as_ptr(&app.session.library) as usize)];
key.extend(
app.session.pkg.dependencies.iter().filter(|(path, _)| path.starts_with("sbs://")).map(|(path, package)| (path.clone(), Arc::as_ptr(package) as usize)),
);
let id = egui::Id::unique("library-entries");
if let Some((cached, list)) = ctx.data(|data| data.get_temp::<Arc<Cached>>(id)).as_deref()
&& *cached == key
{
return list.clone();
}
let list = Arc::new(app.session.library_entries());
ctx.data_mut(|data| data.insert_temp(id, Arc::new((key, list.clone()))));
list
}
pub fn show(app: &mut MaterialCraftApp, ui: &mut Ui) {
match crate::graph::editor_target::EditorTarget::resolve(app) {
crate::graph::editor_target::EditorTarget::Function => {
crate::function::library::show(app, ui);
return;
}
crate::graph::editor_target::EditorTarget::Pattern => {
crate::pattern::library::show(app, ui);
return;
}
crate::graph::editor_target::EditorTarget::Material => {}
}
let tk = Tokens::get(ui.ctx());
let here = Here::of(app);
let all = entries(app, ui.ctx());
ui.horizontal(|ui| {
ui.spacing_mut().item_spacing.x = 2.0;
ui.label(RichText::new(icon::MAGNIFYING_GLASS).color(tk.text_dim));
let r = ui.add(egui::TextEdit::singleline(&mut app.ui.library_search).hint_text(tr("Search")).desired_width((ui.available_width() - 56.0).max(40.0)));
crate::widgets::name(&r, egui::Role::SearchInput, "Search the library");
if crate::widgets::icon_button(ui, icon::SQUARES_FOUR, tr("Icons"), !app.ui.prefs.library_list, 20.0).clicked() {
let hint = match here.canvas {
LibraryCanvas::Function => tr("Search functions"),
LibraryCanvas::Pattern => tr("Search FX-Map nodes"),
LibraryCanvas::Material => tr("Search"),
};
let width = (ui.available_width() - 5.0 * 24.0).max(40.0);
let response = ui.add(egui::TextEdit::singleline(&mut app.ui.library_search).hint_text(hint).desired_width(width));
crate::widgets::name(&response, egui::Role::SearchInput, "Search the library");
filter_menu(app, ui);
let selected = app.ui.library_selected.clone();
let favorite = selected.as_ref().is_some_and(|id| app.ui.library_favorites.contains(id));
let tooltip = if favorite { tr("Remove from Favorites") } else { tr("Add to Favorites") };
let star = ui.add_enabled_ui(selected.is_some(), |ui| crate::widgets::icon_button(ui, icon::STAR, tooltip, favorite, 22.0)).inner;
if star.clicked()
&& let Some(id) = selected
{
toggle_favorite(app, &id);
}
if crate::widgets::icon_button(ui, icon::ARROWS_CLOCKWISE, tr("Reload library"), false, 22.0).clicked() {
app.run("library.reload", serde_json::json!({}));
}
if crate::widgets::icon_button(ui, icon::SQUARES_FOUR, tr("Icons"), !app.ui.prefs.library_list, 22.0).clicked() {
app.ui.prefs.library_list = false;
}
if crate::widgets::icon_button(ui, icon::LIST, tr("List"), app.ui.prefs.library_list, 20.0).clicked() {
if crate::widgets::icon_button(ui, icon::LIST, tr("List"), app.ui.prefs.library_list, 22.0).clicked() {
app.ui.prefs.library_list = true;
}
});
ui.add_space(2.0);
let avail = ui.available_size();
let tree_w = (avail.x * 0.36).clamp(90.0, 170.0);
// The tree takes what the tiles leave: one column of tiles in a narrow panel
let tree_w = (avail.x * 0.6).clamp(120.0, 230.0).min(avail.x - 92.0).max(80.0);
let top_down = egui::Layout::top_down(egui::Align::Min);
ui.horizontal_top(|ui| {
ui.allocate_ui_with_layout(vec2(tree_w, avail.y), top_down, |ui| {
egui::ScrollArea::vertical().id_salt("lib-tree").auto_shrink([false, false]).show(ui, |ui| category_tree(app, ui));
egui::ScrollArea::vertical().id_salt("lib-tree").auto_shrink([false, false]).show(ui, |ui| category_tree(app, ui, &all));
});
ui.separator();
ui.allocate_ui_with_layout(vec2(ui.available_width(), avail.y), top_down, |ui| {
egui::ScrollArea::vertical().id_salt("lib-items").auto_shrink([false, false]).show(ui, |ui| items(app, ui));
egui::ScrollArea::vertical().id_salt("lib-items").auto_shrink([false, false]).show(ui, |ui| items(app, ui, &all, &here));
});
});
}
fn category_tree(app: &mut MaterialCraftApp, ui: &mut Ui) {
fn filter_menu(app: &mut MaterialCraftApp, ui: &mut Ui) {
let filtered = !app.ui.library_show_missing || !app.ui.library_show_other;
let response = crate::widgets::icon_button(ui, icon::FUNNEL, tr("Filter"), filtered, 22.0);
egui::Popup::menu(&response).show(|ui| {
ui.set_min_width(240.0);
ui.checkbox(&mut app.ui.library_show_missing, tr("Show nodes not in MaterialCraft yet"));
ui.checkbox(&mut app.ui.library_show_other, tr("Show nodes for other graph types"));
});
}
fn toggle_favorite(app: &mut MaterialCraftApp, id: &str) {
if let Some(index) = app.ui.library_favorites.iter().position(|favorite| favorite == id) {
app.ui.library_favorites.remove(index);
} else if app.ui.library_favorites.len() < 512 {
app.ui.library_favorites.push(id.to_string());
}
}
/// One tree row: an optional disclosure triangle, the category icon and its name
fn tree_row(app: &mut MaterialCraftApp, ui: &mut Ui, label: &str, category: &str, depth: usize, open: Option<bool>, count: usize) {
let tk = Tokens::get(ui.ctx());
let mut row = |ui: &mut Ui, text: String, path: &str, indent: f32| {
let on = app.ui.library_category == path;
let (r, resp) = ui.allocate_exact_size(vec2(ui.available_width(), 20.0), Sense::click());
crate::widgets::name(&resp, egui::Role::TreeItem, &text);
if on {
ui.painter().rect_filled(r, 4.0, tk.row_selected);
} else if resp.hovered() {
ui.painter().rect_filled(r, 4.0, tk.row_hover);
let selected = app.ui.library_category == category;
let (rect, response) = ui.allocate_exact_size(vec2(ui.available_width(), 20.0), Sense::click());
crate::widgets::name(&response, egui::Role::TreeItem, label);
let response = response.on_hover_text(crate::i18n::trf("{name}: {count} entries", &[("name", &label), ("count", &count)]));
if selected {
ui.painter().rect_filled(rect, 4.0, tk.row_selected);
} else if response.hovered() {
ui.painter().rect_filled(rect, 4.0, tk.row_hover);
}
let indent = 4.0 + depth as f32 * 14.0;
let chevron = Rect::from_min_size(rect.min + vec2(indent, 0.0), vec2(14.0, rect.height()));
if let Some(open) = open {
let symbol = if open { icon::CARET_DOWN } else { icon::CARET_RIGHT };
ui.painter().text(chevron.center(), egui::Align2::CENTER_CENTER, symbol, egui::FontId::proportional(11.0), tk.text_dim);
}
let x = chevron.right() + 2.0;
let color = if selected { tk.text_strong } else { tk.text };
ui.painter().text(egui::pos2(x + 7.0, rect.center().y), egui::Align2::CENTER_CENTER, category_icon(category), egui::FontId::proportional(13.0), color);
let font = if depth == 0 { 12.0 } else { 11.5 };
let galley = crate::widgets::elided(ui.painter(), label.to_string(), font, color, rect.right() - x - 22.0);
ui.painter().galley(egui::pos2(x + 18.0, rect.center().y - galley.size().y * 0.5), galley, color);
if response.clicked() {
let on_chevron = response.interact_pointer_pos().is_some_and(|pointer| chevron.contains(pointer));
if let Some(open) = open
&& (on_chevron || !open || selected)
{
set_open(app, category, !open);
}
let g = crate::widgets::elided(ui.painter(), text, 11.5, if on { tk.text_strong } else { tk.text }, r.width() - indent - 4.0);
ui.painter().galley(r.left_center() + vec2(indent, -g.size().y * 0.5), g, tk.text);
if resp.clicked() {
app.ui.library_category = path.to_string();
}
};
row(ui, format!("{} {}", icon::SQUARES_FOUR, tr("All nodes")), "", 4.0);
for (top, subs) in tree() {
row(ui, format!("{} {}", category_icon(top), tr(top)), top, 4.0);
for sub in subs {
let name = sub.rsplit('/').next().unwrap_or(sub);
row(ui, tr(name).to_string(), sub, 22.0);
if !on_chevron {
app.ui.library_category = category.to_string();
}
}
}
/// Atomic library entries matching the current filter
fn entries(app: &MaterialCraftApp) -> Vec<(String, String, &'static str)> {
let search = app.ui.library_search.to_ascii_lowercase();
fn set_open(app: &mut MaterialCraftApp, category: &str, open: bool) {
if open {
app.ui.library_expanded.insert(category.to_string());
} else {
app.ui.library_expanded.remove(category);
}
}
/// How many entries a category holds, its sub-categories included
fn count(entries: &[LibraryEntry], category: &str) -> usize {
entries.iter().filter(|entry| entry.category == category || entry.category.strip_prefix(category).is_some_and(|rest| rest.starts_with('/'))).count()
}
fn category_tree(app: &mut MaterialCraftApp, ui: &mut Ui, entries: &[LibraryEntry]) {
ui.spacing_mut().item_spacing.y = 1.0;
let favorites = app.ui.library_favorites.len();
tree_row(app, ui, tr("Favorites"), FAVORITES, 0, None, favorites);
for (top, subs) in CATEGORIES {
let open = (!subs.is_empty()).then(|| app.ui.library_expanded.contains(*top));
tree_row(app, ui, tr(top), top, 0, open, count(entries, top));
if open == Some(true) {
for sub in *subs {
let category = format!("{top}/{sub}");
tree_row(app, ui, tr(sub), &category, 1, None, count(entries, &category));
}
}
}
// Packages can name categories the tree doesn't have; they go last
let mut extra: Vec<&str> = Vec::new();
for entry in entries {
let top = entry.category.split('/').next().unwrap_or("");
if !top.is_empty() && !CATEGORIES.iter().any(|(name, _)| *name == top) && !extra.contains(&top) {
extra.push(top);
}
}
for top in extra {
tree_row(app, ui, tr(top), top, 0, None, count(entries, top));
}
}
/// Entries matching the selected category, or the search across the whole library, with what the
/// open graph can take first when searching
pub(crate) fn visible<'a>(app: &MaterialCraftApp, entries: &'a [LibraryEntry], here: &Here) -> Vec<&'a LibraryEntry> {
let search = app.ui.library_search.trim().to_lowercase();
let category = app.ui.library_category.as_str();
let cat = if category == "@package" { "" } else { category };
let mut out = Vec::new();
for d in materialcraft_engine::nodes::catalog() {
if d.id == "graph_instance" {
continue;
}
if !(cat.is_empty() || d.category == cat || d.category.starts_with(&format!("{cat}/"))) {
continue;
}
if !(search.is_empty() || d.label.to_ascii_lowercase().contains(&search) || d.id.contains(&search)) {
continue;
}
out.push((d.id.to_string(), d.label.to_string(), d.category));
}
out
let mut out: Vec<(u8, &LibraryEntry)> = entries
.iter()
.filter(|entry| app.ui.library_show_missing || entry.missing.is_none())
.filter(|entry| app.ui.library_show_other || entry.canvas == here.canvas)
.filter_map(|entry| {
if !search.is_empty() {
let label = entry.label.to_lowercase();
let rank = if label == search {
0
} else if label.starts_with(&search) {
1
} else if label.contains(&search) || entry.id.to_lowercase().contains(&search) {
2
} else {
return None;
};
return Some((rank + if here.takes(entry) { 0 } else { 3 }, entry));
}
let fits = match category {
"" => true,
FAVORITES => app.ui.library_favorites.contains(&entry.id),
category => entry.category == category || entry.category.strip_prefix(category).is_some_and(|rest| rest.starts_with('/')),
};
fits.then_some((0, entry))
})
.collect();
out.sort_by_key(|(rank, _)| *rank);
out.into_iter().map(|(_, entry)| entry).collect()
}
fn items(app: &mut MaterialCraftApp, ui: &mut Ui) {
fn items(app: &mut MaterialCraftApp, ui: &mut Ui, entries: &[LibraryEntry], here: &Here) {
let tk = Tokens::get(ui.ctx());
let ctx = ui.ctx().clone();
let list = entries(app);
let list = visible(app, entries, here);
if list.is_empty() {
ui.label(RichText::new(tr("Nothing matches")).color(tk.text_dim));
let text = match app.ui.library_category.as_str() {
FAVORITES if app.ui.library_search.trim().is_empty() => tr("Select an entry and click the star to add it to Favorites"),
category if app.ui.library_search.trim().is_empty() && !category.is_empty() => tr("Nothing in this category yet"),
_ => tr("Nothing matches"),
};
ui.label(RichText::new(text).color(tk.text_dim));
return;
}
let as_list = app.ui.prefs.library_list;
let tile = vec2(78.0, 98.0);
let tile = vec2(78.0, 100.0);
let cols = if as_list { 1 } else { ((ui.available_width() + 4.0) / (tile.x + 4.0)).floor().max(1.0) as usize };
let mut add = None;
let mut favorite = None;
for chunk in list.chunks(cols) {
ui.horizontal(|ui| {
ui.spacing_mut().item_spacing = vec2(4.0, 4.0);
for (id, label, cat) in chunk {
for entry in chunk {
let size = if as_list { vec2(ui.available_width(), 26.0) } else { tile };
let (r, resp) = ui.allocate_exact_size(size, Sense::click_and_drag());
crate::widgets::name(&resp, egui::Role::ListItem, label);
if resp.hovered() {
ui.painter().rect_filled(r, 6.0, tk.row_hover);
let (rect, response) = ui.allocate_exact_size(size, Sense::click_and_drag());
crate::widgets::name(&response, egui::Role::ListItem, &entry.label);
let takes = here.takes(entry);
let selected = app.ui.library_selected.as_deref() == Some(entry.id.as_str());
if selected {
ui.painter().rect_filled(rect, 6.0, tk.row_selected);
} else if response.hovered() {
ui.painter().rect_filled(rect, 6.0, tk.row_hover);
}
let tex = app.thumbs.library(&ctx, id);
let img_rect = if as_list {
Rect::from_min_size(r.min + vec2(2.0, 2.0), vec2(22.0, 22.0))
let fade = if takes { 1.0 } else { 0.4 };
let image = if as_list {
Rect::from_min_size(rect.min + vec2(2.0, 2.0), vec2(22.0, 22.0))
} else {
Rect::from_min_size(r.min + vec2(5.0, 4.0), vec2(68.0, 68.0))
Rect::from_min_size(rect.min + vec2(5.0, 4.0), vec2(68.0, 68.0))
};
match tex {
Some(t) => {
ui.painter().image(t, img_rect, Rect::from_min_max(egui::Pos2::ZERO, egui::pos2(1.0, 1.0)), Color32::WHITE);
}
None => {
ui.painter().rect_filled(img_rect, 4.0, header_color(id).gamma_multiply(0.7));
ui.painter().text(
img_rect.center(),
egui::Align2::CENTER_CENTER,
icon::CUBE,
egui::FontId::proportional(img_rect.height() * 0.4),
Color32::WHITE,
);
}
}
// The category color as a strip, like the node headers.
let strip = Rect::from_min_size(img_rect.left_bottom() - vec2(0.0, 3.0), vec2(img_rect.width(), 3.0));
ui.painter().rect_filled(strip, 0.0, header_color(id));
preview(app, ui, &ctx, entry, image, fade);
let color = if entry.warning.is_some() { WARNING } else { tk.text };
let color = color.gamma_multiply(if takes { 1.0 } else { 0.55 });
if as_list {
let g = crate::widgets::elided(ui.painter(), label.clone(), 11.5, tk.text, r.width() - 34.0);
ui.painter().galley(r.left_center() + vec2(30.0, -g.size().y * 0.5), g, tk.text);
let galley = crate::widgets::elided(ui.painter(), entry.label.clone(), 11.5, color, rect.width() - 34.0);
ui.painter().galley(rect.left_center() + vec2(30.0, -galley.size().y * 0.5), galley, color);
} else {
let galley = ui.painter().layout(label.clone(), egui::FontId::proportional(10.5), tk.text, tile.x - 4.0);
let pos = egui::pos2(r.center().x - galley.size().x * 0.5, img_rect.bottom() + 3.0);
ui.painter().galley(pos, galley, tk.text);
let galley = ui.painter().layout(entry.label.clone(), egui::FontId::proportional(10.5), color, tile.x - 4.0);
let pos = egui::pos2(rect.center().x - galley.size().x * 0.5, image.bottom() + 3.0);
ui.painter().with_clip_rect(rect).galley(pos, galley, color);
}
let resp = resp.on_hover_text(format!("{label}\n{cat}"));
if resp.drag_started() {
egui::DragAndDrop::set_payload(&ctx, LibraryDrag(id.clone()));
if app.ui.library_favorites.contains(&entry.id) {
ui.painter().text(rect.right_top() + vec2(-8.0, 9.0), egui::Align2::CENTER_CENTER, icon::STAR, egui::FontId::proportional(10.0), tk.accent);
}
if resp.double_clicked() {
add = Some(id.clone());
let mut tip = format!("{}\n{}", entry.label, tr(&entry.category));
if !entry.description.is_empty() {
tip.push_str(&format!("\n\n{}", entry.description));
}
if let Some(reason) = here.refusal(entry).or_else(|| entry.warning.clone()) {
tip.push_str(&format!("\n\n{reason}"));
}
let response = response.on_hover_text(tip);
if response.clicked() || response.secondary_clicked() {
app.ui.library_selected = Some(entry.id.clone());
}
if takes && response.drag_started() {
drag(&ctx, entry);
}
if takes && response.double_clicked() {
add = Some((*entry).clone());
}
response.context_menu(|ui| {
if ui.add_enabled(takes, egui::Button::new(tr("Add to graph"))).clicked() {
add = Some((*entry).clone());
ui.close();
}
let label = if app.ui.library_favorites.contains(&entry.id) { tr("Remove from Favorites") } else { tr("Add to Favorites") };
if ui.button(label).clicked() {
favorite = Some(entry.id.clone());
ui.close();
}
});
}
});
}
if let Some(id) = add {
crate::graph::add_node_near_selection(app, &id);
if let Some(id) = favorite {
toggle_favorite(app, &id);
}
if let Some(entry) = add {
add_entry(app, &entry);
}
}
/// The entry's thumbnail: a cooked preview for native nodes, its category's icon otherwise
fn preview(app: &mut MaterialCraftApp, ui: &Ui, ctx: &egui::Context, entry: &LibraryEntry, rect: Rect, fade: f32) {
let painter = ui.painter();
let (texture, color) = match &entry.item {
LibraryItem::Node { def } if entry.missing.is_none() && def != "dot" => (app.thumbs.library(ctx, def), header_color(def)),
_ => (None, category_color(&entry.category)),
};
match texture {
Some(texture) => {
painter.image(texture, rect, Rect::from_min_max(egui::Pos2::ZERO, egui::pos2(1.0, 1.0)), Color32::WHITE.gamma_multiply(fade));
}
None => {
painter.rect_filled(rect, 4.0, color.gamma_multiply(0.7 * fade));
let symbol = match &entry.item {
LibraryItem::Comment => icon::CHAT_TEXT,
LibraryItem::Frame => icon::FRAME_CORNERS,
LibraryItem::Pin => icon::PUSH_PIN,
LibraryItem::Node { def } if def == "dot" => icon::DOT_OUTLINE,
_ => category_icon(&entry.category),
};
painter.text(
rect.center(),
egui::Align2::CENTER_CENTER,
symbol,
egui::FontId::proportional(rect.height() * 0.42),
Color32::WHITE.gamma_multiply(fade),
);
}
}
let strip = Rect::from_min_size(rect.left_bottom() - vec2(0.0, 3.0), vec2(rect.width(), 3.0));
painter.rect_filled(strip, 0.0, color.gamma_multiply(fade));
if entry.missing.is_some() && rect.height() > 30.0 {
let badge = Rect::from_center_size(rect.right_top() + vec2(-9.0, 9.0), vec2(14.0, 14.0));
painter.circle_filled(badge.center(), 7.0, Color32::from_black_alpha(160));
painter.text(badge.center(), egui::Align2::CENTER_CENTER, icon::CLOCK, egui::FontId::proportional(10.0), Color32::WHITE);
}
}
fn category_color(category: &str) -> Color32 {
match category.split('/').next().unwrap_or("") {
"Graph items" | "Atomic nodes" | "FxMap nodes" => Color32::from_rgb(0x5c, 0x62, 0x6e),
"Function nodes" | "Functions" | "MCF functions" | "Values" => Color32::from_rgb(0x4a, 0x5a, 0x8a),
"Texture generators" if category.ends_with("Patterns") => Color32::from_rgb(0xb3, 0x5a, 0x2c),
"Texture generators" => Color32::from_rgb(0xa8, 0x3c, 0x34),
"Filters" => Color32::from_rgb(0x3b, 0x7f, 0x4c),
"Material filters" | "PBR materials" => Color32::from_rgb(0x3a, 0x66, 0xb0),
"Mesh-based generators" => Color32::from_rgb(0x7a, 0x4f, 0x9e),
"Spline & Path tools" => Color32::from_rgb(0x2f, 0x86, 0x8a),
"3D view" => Color32::from_rgb(0x8a, 0x76, 0x2f),
_ => Color32::from_rgb(0x5c, 0x62, 0x6e),
}
}
fn drag(ctx: &egui::Context, entry: &LibraryEntry) {
match &entry.item {
LibraryItem::Operation { operation } => egui::DragAndDrop::set_payload(ctx, FunctionLibraryDrag::Operation(operation.clone())),
LibraryItem::FunctionInstance { package, graph } => {
egui::DragAndDrop::set_payload(ctx, FunctionLibraryDrag::Instance { package: package.clone(), graph: graph.clone() })
}
LibraryItem::Pattern { .. } => {}
_ => egui::DragAndDrop::set_payload(ctx, LibraryDrag(entry.id.clone())),
}
}
/// Add `entry` to the open graph: native nodes next to the selection, the rest in the view
pub(crate) fn add_entry(app: &mut MaterialCraftApp, entry: &LibraryEntry) {
match &entry.item {
LibraryItem::Operation { operation } => crate::function::library::add(app, &FunctionLibraryDrag::Operation(operation.clone())),
LibraryItem::FunctionInstance { package, graph } => {
crate::function::library::add(app, &FunctionLibraryDrag::Instance { package: package.clone(), graph: graph.clone() })
}
LibraryItem::Pattern { kind } => crate::pattern::library::add(app, *kind),
LibraryItem::Node { def } => crate::graph::add_node_near_selection(app, def),
_ => crate::graph::add_entry_in_view(app, &entry.id),
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn open_package_graphs_are_explorer_resources_not_library_entries() {
let mut app = MaterialCraftApp::headless(materialcraft_engine::new_session(), crate::UiState::default());
let mut graph = materialcraft_engine::core::Graph::new("Reusable source");
graph.add_node("output", [0.0; 2]);
app.session.pkg.graphs.push(graph);
app.ui.library_search = "Reusable source".into();
assert!(entries(&app).is_empty());
app.ui.library_search.clear();
app.ui.library_category = "@package".into();
assert!(entries(&app).iter().any(|entry| entry.0 == "uniform"));
}
}
#[path = "library.test.rs"]
mod tests;
+103
View File
@@ -0,0 +1,103 @@
use super::*;
use materialcraft_engine::core::NodeId;
use serde_json::json;
fn app() -> MaterialCraftApp {
MaterialCraftApp::headless(materialcraft_engine::new_session(), crate::UiState::default())
}
fn labels(app: &MaterialCraftApp) -> Vec<String> {
let entries = app.session.library_entries();
visible(app, &entries, &Here::of(app)).into_iter().map(|entry| entry.label.clone()).collect()
}
#[test]
fn open_package_graphs_are_explorer_resources_not_library_entries() {
let mut app = app();
let mut graph = materialcraft_engine::core::Graph::new("Reusable source");
graph.add_node("output", [0.0; 2]);
app.session.pkg.graphs.push(graph);
app.ui.library_search = "Reusable source".into();
assert!(labels(&app).is_empty());
app.ui.library_search.clear();
app.ui.library_category = "@package".into();
assert!(labels(&app).is_empty(), "an unknown category lists nothing");
app.ui.library_category.clear();
assert!(labels(&app).iter().any(|label| label == "Uniform color"));
}
#[test]
fn categories_include_their_sub_categories_and_favorites_follow_the_star() {
let mut app = app();
app.ui.library_category = "Filters".into();
let filters = labels(&app);
app.ui.library_category = "Filters/Blurs".into();
let blurs = labels(&app);
assert!(!blurs.is_empty() && blurs.len() < filters.len());
assert!(blurs.iter().all(|label| filters.contains(label)));
app.ui.library_category = FAVORITES.into();
assert!(labels(&app).is_empty());
toggle_favorite(&mut app, "node:blur");
toggle_favorite(&mut app, "sbs://functions.sbs#Functions/Math/Pi");
assert_eq!(labels(&app), ["Blur", "Pi"]);
toggle_favorite(&mut app, "node:blur");
assert_eq!(labels(&app), ["Pi"]);
}
#[test]
fn search_puts_what_the_open_graph_takes_first_and_filters_hide_the_rest() {
let mut app = app();
app.ui.library_search = "blur".into();
let found = labels(&app);
assert_eq!(found.first().map(String::as_str), Some("Blur"));
let entries = app.session.library_entries();
let here = Here::of(&app);
let shown = visible(&app, &entries, &here);
let first_refused = shown.iter().position(|entry| !here.takes(entry)).unwrap();
assert!(shown[first_refused..].iter().all(|entry| !here.takes(entry)), "addable entries come first");
app.ui.library_show_missing = false;
app.ui.library_show_other = false;
let entries = app.session.library_entries();
assert!(visible(&app, &entries, &here).iter().all(|entry| here.takes(entry)));
}
#[test]
fn processor_functions_take_operations_their_canvas_allows() {
let mut app = app();
let owner = NodeId(app.run("graph.node.add", json!({"def": "value_processor"})).unwrap()["id"].as_u64().unwrap());
app.function_editor = Some(crate::function::FunctionEditor::new(app.session.graph, owner, crate::function::FunctionTarget::Parameter("function".into())));
let here = Here::of(&app);
let entries = app.session.library_entries();
let find = |id: &str| entries.iter().find(|entry| entry.id == id).unwrap();
assert!(here.takes(find("function:add")));
assert!(here.takes(find("sbs://functions.sbs#Functions/Math/Pi")));
assert!(!here.takes(find("function:samplecol")), "value processors can't sample images");
assert!(!here.takes(find("node:blur")));
assert!(here.refusal(find("node:blur")).is_some());
}
#[test]
fn every_tree_category_has_an_icon_and_double_click_adds() {
for (top, subs) in CATEGORIES {
assert_ne!(category_icon(top), icon::FOLDER_SIMPLE, "{top}");
for sub in *subs {
assert_ne!(category_icon(&format!("{top}/{sub}")), icon::FOLDER_SIMPLE, "{top}/{sub}");
}
}
let mut app = app();
let before = app.session.graph().unwrap().nodes.len();
let entries = app.session.library_entries();
for id in ["node:blur", "sbs://3d_perlin_noise.sbs#3D_perlin_noise"] {
let entry = entries.iter().find(|entry| entry.id == id).unwrap();
if Here::of(&app).takes(entry) {
add_entry(&mut app, entry);
}
}
assert_eq!(app.session.graph().unwrap().nodes.len(), before + 1, "only the available entry is added");
let comments = app.session.graph().unwrap().comments.len();
add_entry(&mut app, entries.iter().find(|entry| entry.id == "item:comment").unwrap());
assert_eq!(app.session.graph().unwrap().comments.len(), comments + 1);
}
+107 -12
View File
@@ -27,19 +27,67 @@ pub const TOP: [&str; 5] = ["File", "Edit", "Tools", "Windows", "Help"];
pub(crate) const EXPLORER_NEW: &[(&str, &str)] = &[("Graph", "ui.newGraph"), ("Function Graph", "ui.newFunctionGraph"), ("Folder", "folder.create")];
pub(crate) const EXPLORER_IMPORT: &[(&str, &str)] = &[("Bitmap", "file.importBitmap"), ("Vector graphics", "file.importVector")];
pub(crate) const EXPLORER_RESOURCE: &[(&str, &str)] = &[("Add to graph", "graph.resource.add")];
pub(crate) const EXPLORER_PACKAGE: &[(&str, &str)] = &[
("Reload", "file.reload"),
("Save", "file.save"),
("Save As", "file.saveAs"),
("Save A Copy As", "file.saveCopyAs"),
("Copy", "explorer.copy"),
("Paste", "explorer.paste"),
("Close", "package.close"),
/// A row of an Explorer context menu
#[derive(Clone, Copy, Debug, PartialEq)]
pub(crate) enum ExplorerRow {
/// A label, the action id (empty: not available yet) and the shortcut shown beside it
Item(&'static str, &'static str, Option<&'static str>),
/// A submenu of (label, action id); an empty id is not available yet
Sub(&'static str, &'static [(&'static str, &'static str)]),
Separator,
}
use ExplorerRow::{Item, Separator, Sub};
/// Linking keeps a resource outside the package; MaterialCraft only embeds resources so far
pub(crate) const EXPLORER_LINK: &[(&str, &str)] = &[("Bitmap", ""), ("Vector graphics", "")];
pub(crate) const EXPLORER_SEND_TO: &[(&str, &str)] = &[("TextureCraft", "file.sendToTextureCraft")];
/// Explorer actions that wrap engine commands or the operating system: computing every output,
/// showing the package file and opening the packages it depends on
pub(crate) const EXPLORER_COMPUTE: &str = "ui.explorer.computeOutputs";
pub(crate) const EXPLORER_SHOW_IN_FOLDER: &str = "ui.explorer.showInFolder";
pub(crate) const EXPLORER_OPEN_DEPENDENCIES: &str = "ui.explorer.openDependencies";
pub(crate) const EXPLORER_VIEW_OUTPUTS: &str = "ui.explorer.viewOutputs";
pub(crate) const EXPLORER_EXPORT_OUTPUTS: &str = "ui.explorer.exportOutputs";
pub(crate) const EXPLORER_PACKAGE: &[ExplorerRow] = &[
Sub("New", EXPLORER_NEW),
Sub("Import", EXPLORER_IMPORT),
Sub("Link", EXPLORER_LINK),
Separator,
Item("Reload", "file.reload", None),
Item("Save", "file.save", Some("Ctrl+S")),
Item("Save as...", "file.saveAs", Some("Ctrl+Shift+S")),
Item("Save a copy as...", "file.saveCopyAs", None),
Separator,
Item("Export material...", "file.exportMaterial", None),
Item("Export with dependencies...", "", None),
Sub("Send to", EXPLORER_SEND_TO),
Separator,
Item("Copy", "explorer.copy", None),
Item("Paste", "explorer.paste", None),
Item("Close package", "package.close", None),
Separator,
Item("Compute outputs", EXPLORER_COMPUTE, None),
Item("Show in folder...", EXPLORER_SHOW_IN_FOLDER, None),
Item("Dependency manager...", "", None),
Item("Open dependencies", EXPLORER_OPEN_DEPENDENCIES, None),
];
pub(crate) const EXPLORER_FOLDER: &[ExplorerRow] = &[
Item("Copy", "explorer.copy", None),
Item("Paste", "explorer.paste", None),
Item("Remove", "folder.remove", Some("Delete")),
Item("Rename", "folder.rename", Some("F2")),
];
pub(crate) const EXPLORER_GRAPH: &[ExplorerRow] = &[
Item("Open", "graph.open", Some("Enter")),
Item("Copy", "explorer.copy", None),
Item("Paste", "explorer.paste", None),
Item("Remove", "graph.delete", Some("Delete")),
Item("Rename", "graph.rename", Some("F2")),
Separator,
Item("View outputs in 3D view", EXPLORER_VIEW_OUTPUTS, None),
Item("Compute outputs", EXPLORER_COMPUTE, None),
Item("Export outputs...", EXPLORER_EXPORT_OUTPUTS, None),
];
pub(crate) const EXPLORER_FOLDER: &[(&str, &str)] =
&[("Copy", "explorer.copy"), ("Paste", "explorer.paste"), ("Rename", "folder.rename"), ("Remove", "folder.remove")];
pub(crate) const EXPLORER_GRAPH: &[(&str, &str)] =
&[("Open", "graph.open"), ("Copy", "explorer.copy"), ("Paste", "explorer.paste"), ("Remove", "graph.delete"), ("Rename", "graph.rename")];
/// The menu catalog (the target menu tree with our ids)
pub const CATALOG: &[MenuItem] = &[
@@ -350,6 +398,9 @@ pub fn shortcuts(app: &mut MaterialCraftApp, ctx: &egui::Context) {
}
let modality = Modality::capture(app, ctx);
if !modality.is_blocked() && crate::explorer::shortcuts(app, ctx) {
return;
}
if !modality.is_blocked() {
crate::graph::wire_actions::shortcuts(app, ctx);
}
@@ -590,6 +641,50 @@ mod tests {
assert!(app.ui.windows.export);
}
#[test]
fn explorer_keys_act_on_its_selection_only_while_hovered() {
use crate::explorer::ExplorerTarget;
let mut app = app();
app.run("file.new", serde_json::json!({"template": "empty", "name": "Second"})).unwrap();
let graphs = app.session.pkg.graphs.len();
let document = app.session.document_id;
app.ui.explorer.selected = Some(ExplorerTarget::Graph { document, index: 0 });
// Away from the Explorer, F2 and Delete keep their graph shortcuts
dispatched(egui::Key::F2, egui::Modifiers::NONE, &mut app);
assert!(app.ui.explorer.rename.is_none());
app.ui.explorer.hovered = true;
dispatched(egui::Key::Enter, egui::Modifiers::NONE, &mut app);
assert_eq!(app.session.graph, 0);
dispatched(egui::Key::F2, egui::Modifiers::NONE, &mut app);
assert!(matches!(app.ui.explorer.rename, Some((ExplorerTarget::Graph { index: 0, .. }, _))));
app.ui.explorer.rename = None;
dispatched(egui::Key::Delete, egui::Modifiers::NONE, &mut app);
assert_eq!(app.session.pkg.graphs.len(), graphs - 1);
dispatched(egui::Key::Z, egui::Modifiers::COMMAND, &mut app);
assert_eq!(app.session.pkg.graphs.len(), graphs, "removing a graph undoes");
}
#[test]
fn explorer_menus_name_only_actions_that_exist() {
for rows in [EXPLORER_PACKAGE, EXPLORER_FOLDER, EXPLORER_GRAPH] {
for row in rows {
let ids: Vec<&str> = match row {
ExplorerRow::Item(_, id, _) => vec![id],
ExplorerRow::Sub(_, entries) => entries.iter().map(|(_, id)| *id).collect(),
ExplorerRow::Separator => Vec::new(),
};
for id in ids.into_iter().filter(|id| !id.is_empty()) {
assert!(implemented(id) || id.starts_with("ui.explorer.") || id.starts_with("explorer."), "{id}");
}
if let ExplorerRow::Item(label, _, Some(shortcut)) = row {
assert!(parse_shortcut(shortcut).is_some(), "{label}: {shortcut}");
}
}
}
}
#[test]
fn the_shortcuts_list_leaves_shortcuts_running() {
let mut app = app();
+7 -12
View File
@@ -1,17 +1,12 @@
use egui::Ui;
use materialcraft_engine::core::PatternNodeKind;
use crate::{MaterialCraftApp, i18n::tr};
use crate::MaterialCraftApp;
pub(crate) fn show(app: &mut MaterialCraftApp, ui: &mut Ui) {
ui.label(tr("FX-Map nodes"));
for kind in PatternNodeKind::ALL {
if ui.selectable_label(false, tr(kind.label())).double_clicked()
&& let Some(mut editor) = app.pattern_editor.take()
{
editor.menu_at = (editor.pan + app.graph.view.size() * 0.5 / editor.zoom).to_pos2();
editor.edit(app, materialcraft_engine::PatternEdit::Add { kind, at: editor.menu_at.into(), snap: app.ui.prefs.snap_to_grid }, false);
app.pattern_editor = Some(editor);
}
/// Add an FX-Map node of `kind` in the middle of the open FX-Map canvas
pub(crate) fn add(app: &mut MaterialCraftApp, kind: PatternNodeKind) {
if let Some(mut editor) = app.pattern_editor.take() {
editor.menu_at = (editor.pan + app.graph.view.size() * 0.5 / editor.zoom).to_pos2();
editor.edit(app, materialcraft_engine::PatternEdit::Add { kind, at: editor.menu_at.into(), snap: app.ui.prefs.snap_to_grid }, false);
app.pattern_editor = Some(editor);
}
}
+15
View File
@@ -16,6 +16,16 @@ pub struct UiState {
/// Library: the selected category path ("" = all) and the search text
pub library_category: String,
pub library_search: String,
/// Library entry ids starred as Favorites, in the order they were added
pub library_favorites: Vec<String>,
/// Expanded library categories
pub library_expanded: std::collections::BTreeSet<String>,
/// Library filters: entries MaterialCraft doesn't have yet, and entries for other graph types
pub library_show_missing: bool,
pub library_show_other: bool,
/// The library entry last clicked
#[serde(skip)]
pub library_selected: Option<String>,
/// Recently opened or saved packages, newest first
pub recent: Vec<String>,
/// New graph dialog fields
@@ -46,6 +56,11 @@ impl Default for UiState {
image_camera: ImageCamera::default(),
library_category: String::new(),
library_search: String::new(),
library_favorites: Vec::new(),
library_expanded: Default::default(),
library_show_missing: true,
library_show_other: true,
library_selected: None,
recent: Vec::new(),
new_graph_kind: materialcraft_engine::core::GraphKind::Material,
new_graph_template: "pbr".into(),
+6 -1
View File
@@ -13,6 +13,9 @@ mod function_variables;
#[path = "snapshot/embedded_graphs.rs"]
mod embedded_graphs;
#[path = "snapshot/library.rs"]
mod library;
use std::time::Duration;
use egui::vec2;
@@ -647,7 +650,9 @@ fn explorer_open_targets_the_clicked_graph() {
settle(&mut h, 5);
h.get_by_label("Export target").click_secondary();
settle(&mut h, 3);
h.get(By::new().role(egui::accesskit::Role::Button).label("Open")).click();
// Explorer menu items name their shortcut after the label
let open = format!("Open {}", materialcraft_ui_egui::menus::shortcut_label(&h.ctx, "Enter"));
h.get(By::new().role(egui::accesskit::Role::Button).label(&open)).click();
settle(&mut h, 3);
assert_eq!(h.state().session.graph, 1);
assert!(!h.state().ui.windows.export);
+48 -8
View File
@@ -13,7 +13,7 @@ fn explorer_can_close_the_last_package_and_all_packages() {
settle(&mut harness, 4);
harness.get(By::new().role(Role::TreeItem).label("Untitled package")).click_secondary();
settle(&mut harness, 3);
harness.get(By::new().role(Role::Button).label("Close")).click();
harness.get(By::new().role(Role::Button).label("Close package")).click();
settle(&mut harness, 4);
assert!(harness.state().session.open_packages().is_empty());
@@ -86,8 +86,8 @@ fn explorer_empty_packages_have_no_disclosure() {
harness.get(By::new().role(Role::TreeItem).label("Empty package")).click_secondary();
settle(&mut harness, 3);
for label in ["Import", "New", "Save As", "Close"] {
assert!(harness.query(By::new().role(Role::Button).label(label)).is_some());
for label in ["Import", "New", "Save as...", "Close package"] {
assert!(harness.query_all(By::new().role(Role::Button).label_contains(label)).next().is_some(), "{label}");
}
harness.key_press(egui::Key::Escape);
settle(&mut harness, 3);
@@ -357,18 +357,58 @@ fn explorer_folder_tree_and_context_menus() {
for (label, expected, screenshot) in [
("Tools", vec!["New", "Copy", "Paste", "Rename", "Remove"], "explorer-folder-menu"),
("Explorer menus*", vec!["Import", "New", "Reload", "Save", "Save As", "Save A Copy As", "Copy", "Paste", "Close"], "explorer-package-menu"),
("Helper", vec!["Open", "Copy", "Paste", "Remove", "Rename"], "explorer-function-menu"),
("Surface", vec!["Open", "Copy", "Paste", "Remove", "Rename"], "explorer-graph-menu"),
(
"Explorer menus*",
vec![
"New",
"Import",
"Link",
"Reload",
"Save",
"Save as...",
"Save a copy as...",
"Export material...",
"Export with dependencies...",
"Send to",
"Copy",
"Paste",
"Close package",
"Compute outputs",
"Show in folder...",
"Dependency manager...",
"Open dependencies",
],
"explorer-package-menu",
),
(
"Helper",
vec!["Open", "Copy", "Paste", "Remove", "Rename", "View outputs in 3D view", "Compute outputs", "Export outputs..."],
"explorer-function-menu",
),
(
"Surface",
vec!["Open", "Copy", "Paste", "Remove", "Rename", "View outputs in 3D view", "Compute outputs", "Export outputs..."],
"explorer-graph-menu",
),
] {
harness.get(tree(label)).click_secondary();
settle(&mut harness, 3);
for label in expected {
assert!(harness.query(By::new().label(label)).is_some(), "{screenshot}: {label}");
assert!(harness.query_all(By::new().label_contains(label)).next().is_some(), "{screenshot}: {label}");
}
for label in ["Duplicate", "Delete", "Link"] {
for label in ["Duplicate", "Delete"] {
assert!(harness.query(button(label)).is_none(), "{screenshot}: unexpected {label}");
}
if screenshot == "explorer-package-menu" {
for unavailable in ["Export with dependencies...", "Dependency manager...", "Show in folder..."] {
assert!(harness.get(button(unavailable)).accesskit_node().is_disabled(), "{unavailable}");
}
}
// A Function Graph has no image outputs to view, compute or export
if matches!(screenshot, "explorer-function-menu" | "explorer-graph-menu") {
let disabled = harness.get(button("Compute outputs")).accesskit_node().is_disabled();
assert_eq!(disabled, screenshot == "explorer-function-menu", "{screenshot}");
}
assert!(harness.get(button("Paste")).accesskit_node().is_disabled());
+119
View File
@@ -0,0 +1,119 @@
use super::{By, MaterialCraftApp, Queryable, UiState, harness, save, settle, vec2};
use egui::accesskit::Role;
fn tree(label: &str) -> By<'_> {
By::new().role(Role::TreeItem).label(label)
}
fn tile(label: &str) -> By<'_> {
By::new().role(Role::ListItem).label(label)
}
#[test]
#[ignore = "requires an offscreen GPU; run explicitly with --ignored"]
fn library_tree_shows_every_category_and_adds_what_the_graph_takes() {
let directory = std::path::PathBuf::from(std::env::var_os("MC_SNAPSHOT_DIR").unwrap());
std::fs::create_dir_all(&directory).unwrap();
let app = MaterialCraftApp::headless(materialcraft_engine::new_session(), UiState::default());
let mut harness = harness(app, 1600.0, 960.0);
settle(&mut harness, 6);
for label in [
"Favorites",
"Graph items",
"Atomic nodes",
"FxMap nodes",
"Function nodes",
"Texture generators",
"Filters",
"Material filters",
"Mesh-based generators",
"Spline & Path tools",
"MCF functions",
"Functions",
"3D view",
"PBR materials",
"Values",
] {
assert!(harness.query(tree(label)).is_some(), "{label}");
}
assert!(harness.query(tree("SDF functions")).is_none(), "the category is MCF functions now");
// Graph items, then the atomic nodes with their previews
harness.get(tree("Graph items")).click();
settle(&mut harness, 3);
for label in ["Comment", "Frame", "Pin", "Dot node"] {
assert!(harness.query(tile(label)).is_some(), "{label}");
}
harness.get(tree("Atomic nodes")).click();
settle(&mut harness, 12);
for label in ["Blend", "Blur", "Levels", "Output", "Input color"] {
assert!(harness.query(tile(label)).is_some(), "{label}");
}
save(&mut harness, &directory, "library-atomic-nodes");
// Dragging a tile adds it where it drops
let before = harness.state().session.graph().unwrap().nodes.len();
let start = harness.get(tile("Blur")).rect().center();
let end = harness.state().graph.view.center() + vec2(120.0, 80.0);
harness.event(egui::Event::PointerMoved(start));
harness.step();
harness.event(egui::Event::PointerButton { pos: start, button: egui::PointerButton::Primary, pressed: true, modifiers: egui::Modifiers::NONE });
harness.step();
for position in [start + vec2(12.0, 0.0), end] {
harness.event(egui::Event::PointerMoved(position));
harness.step();
}
harness.event(egui::Event::PointerButton { pos: end, button: egui::PointerButton::Primary, pressed: false, modifiers: egui::Modifiers::NONE });
settle(&mut harness, 5);
let graph = harness.state().session.graph().unwrap();
assert_eq!(graph.nodes.len(), before + 1);
assert_eq!(graph.nodes.last().unwrap().def, "blur");
// Opening a category shows its sub-categories; library nodes MaterialCraft lacks are dimmed
harness.get(tree("Texture generators")).click();
settle(&mut harness, 3);
harness.get(tree("Noises")).click();
settle(&mut harness, 4);
assert!(harness.query(tile("3D Perlin Noise")).is_some());
save(&mut harness, &directory, "library-texture-generators-noises");
for (top, subs) in [
("Filters", &["Adjustments", "Blending", "Blurs", "Channels", "Effects", "Normal map", "Tiling", "Transforms"][..]),
("Function nodes", &["Constant", "Vector", "Variables", "Samplers", "Cast", "Operator", "Logical", "Comparison", "Function", "Control"][..]),
("MCF functions", &["Primitives", "Operators", "Transforms"][..]),
("PBR materials", &["Bricks", "Concrete", "Fabric", "Ground", "Metal", "Paper", "Pavement", "Tiles", "Wood", "Stone"][..]),
] {
harness.get(tree(top)).click();
settle(&mut harness, 3);
for sub in subs {
assert!(harness.query_all(tree(sub)).next().is_some(), "{top}/{sub}");
}
if top == "PBR materials" {
save(&mut harness, &directory, "library-categories-open");
}
// Clicking the selected, open category closes it again
harness.get(tree(top)).click();
settle(&mut harness, 2);
assert!(!harness.state().ui.library_expanded.contains(top), "{top}");
}
// A selected tile goes into Favorites with the star
harness.get(tree("Atomic nodes")).click();
settle(&mut harness, 3);
harness.get(tile("Blend")).click();
settle(&mut harness, 2);
harness.get(By::new().role(Role::Button).label("Add to Favorites")).click();
settle(&mut harness, 2);
harness.get(tree("Favorites")).click();
settle(&mut harness, 3);
assert!(harness.query(tile("Blend")).is_some());
assert_eq!(harness.state().ui.library_favorites, ["node:blend"]);
save(&mut harness, &directory, "library-favorites");
// Search finds entries across the whole library, what the graph takes first
harness.state_mut().ui.library_search = "noise".into();
settle(&mut harness, 4);
assert!(harness.query(tile("3D Perlin Noise")).is_some());
save(&mut harness, &directory, "library-search");
}
+8
View File
@@ -104,6 +104,14 @@ Resource paths resolve beside their owning package: `resources/tile.png` in
`sbs://resources/tile.png`. Nested packages use their own adjacent `resources/` directory.
Loaded resource bytes are embedded on save; unavailable files keep their reference and missing state.
Every session loads the whole library folder once per process (`engine::node_library`, cached
until `library.reload`). Each `.sbs` there is either a layout or a package of graphs. A layout's
titled frames ("Filters - Blurs") name Library categories and place the nodes inside them
(`formats::sbs::read_layout`); `assets/sbs/all_nodes.sbs` lays out the reference category tree,
with every library node it instances. Packages join every session's dependencies, so their graphs
can be instanced, and a placed instance becomes available as soon as its package is in the folder.
Installed and browser builds embed `all_nodes.sbs` and `functions.sbs`.
Importing a user-supplied function package preserves its graph bodies, connections and positions;
it does not replace them with the bundled library. Redundant legacy instance connectors are retained
on save and evaluated only through the declared inputs. Conflicting obsolete connections remain
+16
View File
@@ -113,6 +113,22 @@ Types: `move`, `down`, `up`, `click`, `doubleClick`, `drag`, `scroll`, `key` (eg
| `view.2d` / `view.3d` | which node the 2D view shows, channel, tiling, histogram; scene, environment, camera, tiling, `heightScale` (how far the height output raises the mesh, in mesh radii) and `heightLevel` (the height that stays on the surface; 0 = the relief rises out of it), `normalYFlip` (interpret DirectX normal maps; default false/OpenGL), `transparency` (see through where the alpha is below one: the opacity output, else the base color's alpha), `alphaView` (show the alpha channel) |
| `view.3d.loadMesh` | `{path}` shows an OBJ, glTF or GLB mesh (scene `custom`) |
| `library.list` | `{filter?, category?}`: every node with ports and parameters |
| `library.tree` | `{filter?, category? (Top or Top/Sub), canvas? (material\|function\|pattern)}`: the Library panel's category tree and its entries. Each entry has `id`, `label`, `category`, `type` (`node`, `comment`, `frame`, `pin`, `instance`, `operation`, `functionInstance`, `pattern`, `bitmap`), the `canvas` that takes it, `missing` when MaterialCraft lacks the library package it needs, and `warning` when it can be added but is incomplete |
| `library.add` | `{entry, at?, snapToGrid?, function?: FunctionGraphTarget}`: add a `library.tree` entry to the open graph (function entries to a Function canvas; FX-Map nodes use `graph.pattern.edit`). Entries with `missing` refuse with the reason |
| `library.reload` | `{}`: read the SBS library folder again |
| `graph.cook` | `{full?, graph?: index}`: cook now and return per-node timings and errors; another material graph of the package cooks at full size into the cache |
## Node library
Every `.sbs` file in the library folder (`assets/sbs`, or `MATERIALCRAFT_SBS_DIR`; installed and
browser builds use the bundled `all_nodes.sbs` and `functions.sbs`) loads once per process. A
package whose graphs group nodes in titled frames lays the library out: a frame titled
`Top - Sub` (or `Top`) is a category of the Library tree, and every node inside it becomes an
entry there. Function frames name only the sub-category: under Function nodes when they hold
native operations, under Functions otherwise. The older category name "SDF functions" reads as
MCF functions. Other packages lend their graphs: a placed instance becomes available as soon as
its package is in the folder, and unplaced graphs go to their attribute category, or Functions
for function graphs.
## Linked packages
+14 -3
View File
@@ -14,9 +14,20 @@ Full numerical equivalence and importing the converted library in the reference
unverified. Redistribution rights for the retained source bodies are not established.
See [architecture.md](architecture.md) for alias resolution and conversion details.
Explorer now displays native SBS folders, including empty groups and nested resources. Its initial
package, folder and graph context menus support creation, copy/paste, rename, removal, and package
save/reload/close actions. Publishing and additional resource creation menus remain outside this scope.
Explorer now displays native SBS folders, including empty groups and nested resources. Its
package, folder and graph context menus follow the reference layout: creation, import, save,
export material, send to TextureCraft, copy/paste, close, compute outputs, show in folder, open
dependencies, view outputs in 3D view and export outputs. Enter, F2 and Delete act on the Explorer
selection while the pointer is over it. Linking resources, exporting with dependencies and the
dependency manager are listed but disabled until MaterialCraft has them; copy and paste have no
Explorer shortcut yet.
The Library panel shows the reference category tree (Favorites, Graph items, Atomic nodes, FxMap
nodes, Function nodes, Texture generators, Filters, Material filters, Mesh-based generators, Spline &
Path tools, MCF functions, Functions, 3D view, PBR materials, Values) filled from the bundled
library layout. 495 of its 787 entries are listed but dimmed: MaterialCraft has no package
for them yet, and each becomes available once its package is in the library folder. MCF functions
and Values have no entries yet; HDRI environment images are not bundled.
> **Last reviewed:** 2026-11-02 · **Last updated:** 2026-11-02 · **Change:** minor (portable `.mcmat` materials closed the published-archive gap) · **Target:** the professional node-based material workflow