From 9290c2d9060d2d80a98c20ffe01ee2c747dc17ac Mon Sep 17 00:00:00 2001 From: PiJellyPin Date: Tue, 10 Nov 2026 00:52:05 +0100 Subject: [PATCH 1/5] Listing all nodes from custom functions.sbs also fixed library ui with categories --- crates/engine/src/commands.rs | 1 + crates/engine/src/function_library.rs | 21 +- crates/engine/src/graph_cmds.rs | 25 +- crates/engine/src/lib.rs | 3 + crates/engine/src/node_library.rs | 432 ++++++++++++++ crates/engine/src/node_library.test.rs | 118 ++++ crates/engine/src/node_library_commands.rs | 131 +++++ crates/engine/src/session.rs | 24 +- crates/engine/tests/it/main.rs | 1 + crates/engine/tests/it/node_library.rs | 82 +++ crates/formats/src/sbs/library.rs | 64 ++ crates/formats/src/sbs/library_layout.rs | 298 ++++++++++ crates/formats/src/sbs/mod.rs | 2 + crates/ui-egui/src/explorer.rs | 29 +- crates/ui-egui/src/explorer/actions.rs | 74 ++- crates/ui-egui/src/explorer/context_menu.rs | 148 +++-- crates/ui-egui/src/explorer/explorer_state.rs | 3 + crates/ui-egui/src/explorer/explorer_tree.rs | 8 +- .../src/function/function_library_drag.rs | 3 +- crates/ui-egui/src/function/library.rs | 84 +-- crates/ui-egui/src/graph/input.rs | 2 +- crates/ui-egui/src/graph/library_drag.rs | 2 +- crates/ui-egui/src/graph/mod.rs | 2 +- crates/ui-egui/src/graph/navigation.rs | 6 + crates/ui-egui/src/library.rs | 555 +++++++++++++----- crates/ui-egui/src/library.test.rs | 103 ++++ crates/ui-egui/src/menus.rs | 119 +++- crates/ui-egui/src/pattern/library.rs | 19 +- crates/ui-egui/src/state/ui_state.rs | 15 + crates/ui-egui/tests/snapshot.rs | 7 +- crates/ui-egui/tests/snapshot/explorer.rs | 56 +- crates/ui-egui/tests/snapshot/library.rs | 119 ++++ docs/architecture.md | 8 + docs/control-protocol.md | 16 + docs/gaps.md | 17 +- 35 files changed, 2257 insertions(+), 340 deletions(-) create mode 100644 crates/engine/src/node_library.rs create mode 100644 crates/engine/src/node_library.test.rs create mode 100644 crates/engine/src/node_library_commands.rs create mode 100644 crates/engine/tests/it/node_library.rs create mode 100644 crates/formats/src/sbs/library_layout.rs create mode 100644 crates/ui-egui/src/library.test.rs create mode 100644 crates/ui-egui/tests/snapshot/library.rs diff --git a/crates/engine/src/commands.rs b/crates/engine/src/commands.rs index acc9729..84321f3 100644 --- a/crates/engine/src/commands.rs +++ b/crates/engine/src/commands.rs @@ -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()); diff --git a/crates/engine/src/function_library.rs b/crates/engine/src/function_library.rs index ad55a8b..072707f 100644 --- a/crates/engine/src/function_library.rs +++ b/crates/engine/src/function_library.rs @@ -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>, - pub warnings: Vec, -} - -pub(crate) fn load() -> Result { - 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 }) -} diff --git a/crates/engine/src/graph_cmds.rs b/crates/engine/src/graph_cmds.rs index 9f0954e..3c4356e 100644 --- a/crates/engine/src/graph_cmds.rs +++ b/crates/engine/src/graph_cmds.rs @@ -22,7 +22,15 @@ pub(crate) fn specs() -> Vec { }) }), 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 { } fn cook(s: &mut Session, p: &J) -> Result { - 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)| { diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs index bacdf62..0862a4c 100644 --- a/crates/engine/src/lib.rs +++ b/crates/engine/src/lib.rs @@ -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; diff --git a/crates/engine/src/node_library.rs b/crates/engine/src/node_library.rs new file mode 100644 index 0000000..80c4dfb --- /dev/null +++ b/crates/engine/src/node_library.rs @@ -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, + /// It can be added, but is incomplete (it uses operations MaterialCraft lacks) + #[serde(skip_serializing_if = "Option::is_none")] + pub warning: Option, +} + +/// 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>, + /// The `sbs://` files that laid the library out + pub layouts: Vec, + pub warnings: Vec, + placements: Vec, +} + +static SHARED: Mutex>> = Mutex::new(None); + +impl NodeLibrary { + /// The process's library, loaded on first use + pub fn shared() -> Arc { + 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 { + 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>) -> Vec { + let mut out = Vec::new(); + let mut ids = BTreeSet::new(); + let mut placed_graphs = BTreeSet::new(); + let mut push = |out: &mut Vec, 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 = 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) -> 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>) -> Option { + 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 { + 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 & 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 { + 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 { + 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::>() + .join(" ") +} + +#[cfg(test)] +#[path = "node_library.test.rs"] +mod tests; diff --git a/crates/engine/src/node_library.test.rs b/crates/engine/src/node_library.test.rs new file mode 100644 index 0000000..c37f571 --- /dev/null +++ b/crates/engine/src/node_library.test.rs @@ -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::>(), + ["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")); +} diff --git a/crates/engine/src/node_library_commands.rs b/crates/engine/src/node_library_commands.rs new file mode 100644 index 0000000..29d6709 --- /dev/null +++ b/crates/engine/src/node_library_commands.rs @@ -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 { + 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 { + self.library.entries(&self.pkg.dependencies) + } +} + +fn tree(session: &mut Session, parameters: &Value) -> Result { + 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 { + 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::(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 { + 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})) +} diff --git a/crates/engine/src/session.rs b/crates/engine/src/session.rs index d295571..03517e8 100644 --- a/crates/engine/src/session.rs +++ b/crates/engine/src/session.rs @@ -157,6 +157,8 @@ pub struct Session { pub cache: Arc>, /// A mesh loaded for the 3D view (`scene: "custom"`): its file name and geometry. pub custom_mesh: Option<(String, Arc)>, + /// The node library loaded from the SBS library folder + pub library: Arc, pub(crate) history: crate::document_history::DocumentHistory, group: Option<(Snapshot, bool)>, decoded: Arc>>, @@ -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 } diff --git a/crates/engine/tests/it/main.rs b/crates/engine/tests/it/main.rs index 4d8f199..a1e6be5 100644 --- a/crates/engine/tests/it/main.rs +++ b/crates/engine/tests/it/main.rs @@ -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; diff --git a/crates/engine/tests/it/node_library.rs b/crates/engine/tests/it/node_library.rs new file mode 100644 index 0000000..26062ca --- /dev/null +++ b/crates/engine/tests/it/node_library.rs @@ -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 { + execute(session, "library.tree", ¶meters).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")); +} diff --git a/crates/formats/src/sbs/library.rs b/crates/formats/src/sbs/library.rs index 99c1559..bd3a41a 100644 --- a/crates/formats/src/sbs/library.rs +++ b/crates/formats/src/sbs/library.rs @@ -79,6 +79,70 @@ pub fn read(uri: &str) -> Result, 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 { + #[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) { + 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"))); + } +} diff --git a/crates/formats/src/sbs/library_layout.rs b/crates/formats/src/sbs/library_layout.rs new file mode 100644 index 0000000..337a86b --- /dev/null +++ b/crates/formats/src/sbs/library_layout.rs @@ -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, +} + +/// 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 }, + /// 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> { + 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 )".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![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 { + 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 { + 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#" + + + + + + + + + + + + + + + + + + </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")) + ); + } +} diff --git a/crates/formats/src/sbs/mod.rs b/crates/formats/src/sbs/mod.rs index b86db61..ea54381 100644 --- a/crates/formats/src/sbs/mod.rs +++ b/crates/formats/src/sbs/mod.rs @@ -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; diff --git a/crates/ui-egui/src/explorer.rs b/crates/ui-egui/src/explorer.rs index 55b44fd..81cbcdb 100644 --- a/crates/ui-egui/src/explorer.rs +++ b/crates/ui-egui/src/explorer.rs @@ -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); } diff --git a/crates/ui-egui/src/explorer/actions.rs b/crates/ui-egui/src/explorer/actions.rs index bc8af38..b04b908 100644 --- a/crates/ui-egui/src/explorer/actions.rs +++ b/crates/ui-egui/src/explorer/actions.rs @@ -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; diff --git a/crates/ui-egui/src/explorer/context_menu.rs b/crates/ui-egui/src/explorer/context_menu.rs index 7b6ef47..0ef8253 100644 --- a/crates/ui-egui/src/explorer/context_menu.rs +++ b/crates/ui-egui/src/explorer/context_menu.rs @@ -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 } diff --git a/crates/ui-egui/src/explorer/explorer_state.rs b/crates/ui-egui/src/explorer/explorer_state.rs index 57ccb89..73028d2 100644 --- a/crates/ui-egui/src/explorer/explorer_state.rs +++ b/crates/ui-egui/src/explorer/explorer_state.rs @@ -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, } diff --git a/crates/ui-egui/src/explorer/explorer_tree.rs b/crates/ui-egui/src/explorer/explorer_tree.rs index 54555ec..5c80cbe 100644 --- a/crates/ui-egui/src/explorer/explorer_tree.rs +++ b/crates/ui-egui/src/explorer/explorer_tree.rs @@ -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)); } }); diff --git a/crates/ui-egui/src/function/function_library_drag.rs b/crates/ui-egui/src/function/function_library_drag.rs index c16f4cf..71a9011 100644 --- a/crates/ui-egui/src/function/function_library_drag.rs +++ b/crates/ui-egui/src/function/function_library_drag.rs @@ -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 }, } diff --git a/crates/ui-egui/src/function/library.rs b/crates/ui-egui/src/function/library.rs index 2bc4ab2..5c6a63a 100644 --- a/crates/ui-egui/src/function/library.rs +++ b/crates/ui-egui/src/function/library.rs @@ -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) => { diff --git a/crates/ui-egui/src/graph/input.rs b/crates/ui-egui/src/graph/input.rs index b964a73..9e2a5bb 100644 --- a/crates/ui-egui/src/graph/input.rs +++ b/crates/ui-egui/src/graph/input.rs @@ -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 diff --git a/crates/ui-egui/src/graph/library_drag.rs b/crates/ui-egui/src/graph/library_drag.rs index 18bfea4..ae9a149 100644 --- a/crates/ui-egui/src/graph/library_drag.rs +++ b/crates/ui-egui/src/graph/library_drag.rs @@ -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); diff --git a/crates/ui-egui/src/graph/mod.rs b/crates/ui-egui/src/graph/mod.rs index cde9113..08076b3 100644 --- a/crates/ui-egui/src/graph/mod.rs +++ b/crates/ui-egui/src/graph/mod.rs @@ -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; diff --git a/crates/ui-egui/src/graph/navigation.rs b/crates/ui-egui/src/graph/navigation.rs index 6769ee4..98033c6 100644 --- a/crates/ui-egui/src/graph/navigation.rs +++ b/crates/ui-egui/src/graph/navigation.rs @@ -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(); diff --git a/crates/ui-egui/src/library.rs b/crates/ui-egui/src/library.rs index 30c51c9..5227ff3 100644 --- a/crates/ui-egui/src/library.rs +++ b/crates/ui-egui/src/library.rs @@ -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; diff --git a/crates/ui-egui/src/library.test.rs b/crates/ui-egui/src/library.test.rs new file mode 100644 index 0000000..63e2233 --- /dev/null +++ b/crates/ui-egui/src/library.test.rs @@ -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); +} diff --git a/crates/ui-egui/src/menus.rs b/crates/ui-egui/src/menus.rs index cdec828..cc70356 100644 --- a/crates/ui-egui/src/menus.rs +++ b/crates/ui-egui/src/menus.rs @@ -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(); diff --git a/crates/ui-egui/src/pattern/library.rs b/crates/ui-egui/src/pattern/library.rs index b7b1d1e..ed76b92 100644 --- a/crates/ui-egui/src/pattern/library.rs +++ b/crates/ui-egui/src/pattern/library.rs @@ -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); } } diff --git a/crates/ui-egui/src/state/ui_state.rs b/crates/ui-egui/src/state/ui_state.rs index 93ffb92..8ec7965 100644 --- a/crates/ui-egui/src/state/ui_state.rs +++ b/crates/ui-egui/src/state/ui_state.rs @@ -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(), diff --git a/crates/ui-egui/tests/snapshot.rs b/crates/ui-egui/tests/snapshot.rs index 088f97c..afede05 100644 --- a/crates/ui-egui/tests/snapshot.rs +++ b/crates/ui-egui/tests/snapshot.rs @@ -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); diff --git a/crates/ui-egui/tests/snapshot/explorer.rs b/crates/ui-egui/tests/snapshot/explorer.rs index 2a6ac4b..d4ae9c7 100644 --- a/crates/ui-egui/tests/snapshot/explorer.rs +++ b/crates/ui-egui/tests/snapshot/explorer.rs @@ -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()); diff --git a/crates/ui-egui/tests/snapshot/library.rs b/crates/ui-egui/tests/snapshot/library.rs new file mode 100644 index 0000000..30e60b0 --- /dev/null +++ b/crates/ui-egui/tests/snapshot/library.rs @@ -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"); +} diff --git a/docs/architecture.md b/docs/architecture.md index 7f2e62c..6b184fa 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -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 diff --git a/docs/control-protocol.md b/docs/control-protocol.md index 2276d21..22ec6ec 100644 --- a/docs/control-protocol.md +++ b/docs/control-protocol.md @@ -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 diff --git a/docs/gaps.md b/docs/gaps.md index 61dfd61..32d3135 100644 --- a/docs/gaps.md +++ b/docs/gaps.md @@ -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 From 7ec846cf274d1c6207253ee509b3ad0564513979 Mon Sep 17 00:00:00 2001 From: PiJellyPin <pijellypin@outlook.com> Date: Tue, 10 Nov 2026 02:51:07 +0100 Subject: [PATCH 2/5] Fixed Library UI --- assets/sbs/all_nodes.sbs | 1 - crates/engine/src/node_library.rs | 67 +++++++++++++++++--- crates/engine/src/node_library.test.rs | 81 +++++++++++++++--------- crates/engine/tests/it/node_library.rs | 18 +++--- crates/formats/src/sbs/library.rs | 3 +- crates/formats/src/sbs/library_layout.rs | 14 ---- crates/ui-egui/src/library.test.rs | 23 ++++--- crates/ui-egui/tests/snapshot/library.rs | 28 ++++++-- docs/architecture.md | 13 ++-- docs/control-protocol.md | 15 ++--- docs/file-format-parity.md | 2 +- docs/gaps.md | 10 +-- 12 files changed, 177 insertions(+), 98 deletions(-) delete mode 100644 assets/sbs/all_nodes.sbs diff --git a/assets/sbs/all_nodes.sbs b/assets/sbs/all_nodes.sbs deleted file mode 100644 index dbb7cdb..0000000 --- a/assets/sbs/all_nodes.sbs +++ /dev/null @@ -1 +0,0 @@ -<?xml version="1.0" encoding="UTF-8"?><package><identifier v="Unsaved Package"/><formatVersion v="1.1.0.202401"/><updaterVersion v="1.1.0.202401"/><fileUID v="{d761218c-6535-4012-a000-21216d08e74e}"/><versionUID v="0"/><dependencies><dependency><filename v="?himself"/><uid v="1584632780"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://3d_perlin_noise.sbs"/><uid v="1437570156"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://3d_simplex_noise.sbs"/><uid v="1311275138"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_voronoi.sbs"/><uid v="1440766644"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://3d_worley_noise.sbs"/><uid v="1217378548"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_anisotropic_noise.sbs"/><uid v="1584639338"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://blue_noise.sbs"/><uid v="1584639858"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_bnw_spots_1.sbs"/><uid v="1584639913"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_bnw_spots_2.sbs"/><uid v="1584640143"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_bnw_spots_3.sbs"/><uid v="1299276443"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_cells_1.sbs"/><uid v="1584642533"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_cells_2.sbs"/><uid v="1584642645"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_cells_3.sbs"/><uid v="1584643037"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_cells_4.sbs"/><uid v="1299276447"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_clouds_1.sbs"/><uid v="1584643174"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_clouds_2.sbs"/><uid v="1584643519"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_clouds_3.sbs"/><uid v="1584643869"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_creased.sbs"/><uid v="1584644203"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_crystal_1.sbs"/><uid v="1584644394"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_crystal_2.sbs"/><uid v="1584644622"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_directional_noise_1.sbs"/><uid v="1584645560"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_directional_noise_2.sbs"/><uid v="1584646017"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_directional_noise_3.sbs"/><uid v="1584646196"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_directional_noise_4.sbs"/><uid v="1584646656"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_directional_scratches.sbs"/><uid v="1584646818"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_dirt_1.sbs"/><uid v="1299276460"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_dirt_2.sbs"/><uid v="1584646981"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_dirt_3.sbs"/><uid v="1584647143"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_dirt_4.sbs"/><uid v="1584647426"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_dirt_5.sbs"/><uid v="1584647603"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_dirt_gradient.sbs"/><uid v="1584647753"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_fluid.sbs"/><uid v="1584648733"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_fractal_sum_1.sbs"/><uid v="1584648924"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_fractal_sum_2.sbs"/><uid v="1584650329"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_fractal_sum_3.sbs"/><uid v="1584650336"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_fractal_sum_4.sbs"/><uid v="1584650343"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_fractal_sum_base.sbs"/><uid v="1299276471"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_fur_1.sbs"/><uid v="1584651925"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_fur_2.sbs"/><uid v="1584652074"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_fur_3.sbs"/><uid v="1584652238"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_gaussian_noise.sbs"/><uid v="1584652549"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_gaussian_spots_1.sbs"/><uid v="1584652663"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_gaussian_spots_2.sbs"/><uid v="1584652796"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://grunge_concrete.sbs"/><uid v="1584653196"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://grunge_damas.sbs"/><uid v="1584656003"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://grunge_galvanic_large.sbs"/><uid v="1584656093"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://grunge_galvanic_small.sbs"/><uid v="1584656142"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://grunge_leaks.sbs"/><uid v="1584656218"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://grunge_leaky_paint.sbs"/><uid v="1584657378"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_grunge_map_001.sbs"/><uid v="1584657405"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_grunge_map_002.sbs"/><uid v="1584657590"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_grunge_map_003.sbs"/><uid v="1584657667"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_grunge_map_004.sbs"/><uid v="1584657828"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_grunge_map_005.sbs"/><uid v="1584657939"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_grunge_map_006.sbs"/><uid v="1584658048"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_grunge_map_007.sbs"/><uid v="1584658179"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_grunge_map_008.sbs"/><uid v="1584658386"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_grunge_map_009.sbs"/><uid v="1584658597"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_grunge_map_010.sbs"/><uid v="1584658787"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_grunge_map_011.sbs"/><uid v="1584659113"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_grunge_map_012.sbs"/><uid v="1584659350"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_grunge_map_013.sbs"/><uid v="1584659549"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_grunge_map_014.sbs"/><uid v="1584659688"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_grunge_map_015.sbs"/><uid v="1584659892"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://grunge_rough_dirty.sbs"/><uid v="1584660734"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://grunge_rust_fine.sbs"/><uid v="1584661084"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://grunge_scratches_dirty.sbs"/><uid v="1584661268"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://grunge_scratches_fine.sbs"/><uid v="1584663445"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://grunge_scratches_rough.sbs"/><uid v="1584663575"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://grunge_shavings.sbs"/><uid v="1584663754"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://grunge_splashes_dusty.sbs"/><uid v="1584663817"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://grunge_spots.sbs"/><uid v="1584664353"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://grunge_spots_dirty.sbs"/><uid v="1584664376"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_liquid.sbs"/><uid v="1300576745"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_messy_fibers_1.sbs"/><uid v="1439741058"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_messy_fibers_2.sbs"/><uid v="1584665181"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_messy_fibers_3.sbs"/><uid v="1584665329"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_microscope_view.sbs"/><uid v="1584665471"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_moisture_noise.sbs"/><uid v="1439297100"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_perlin_noise.sbs"/><uid v="1584666054"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_plasma.sbs"/><uid v="1584666365"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://rt_caustics.sbs"/><uid v="1400391215"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://waveform_1.sbs"/><uid v="1584685599"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://white_noise.sbs"/><uid v="1146345729"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://3d_gradient.sbs"/><uid v="1584635741"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://3d_volume_mask.sbs"/><uid v="1584637151"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://pattern_alveolus.sbs"/><uid v="1584639259"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://pattern_arc_pavement.sbs"/><uid v="1584639528"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://pattern_brick_1.sbs"/><uid v="1584640941"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://pattern_brick_2.sbs"/><uid v="1584641083"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://pattern_brick_generator.sbs"/><uid v="1299369593"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://pattern_checker_1.sbs"/><uid v="1584643093"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://pattern_cube_3d.sbs"/><uid v="1311189968"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://pattern_fibers_1.sbs"/><uid v="1584648509"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://pattern_fibers_2.sbs"/><uid v="1584648609"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://pattern_gaussian_1.sbs"/><uid v="1584652394"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://pattern_gaussian_2.sbs"/><uid v="1584652470"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://gradient_axial.sbs"/><uid v="1584652945"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://gradient_circular.sbs"/><uid v="1584653012"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://gradient_linear_1.sbs"/><uid v="1584653053"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://gradient_linear_2.sbs"/><uid v="1584653087"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://gradient_linear_3.sbs"/><uid v="1584653134"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://gradient_radial.sbs"/><uid v="1584653155"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://height_extrude.sbs"/><uid v="1349526162"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://pattern_mesh_1.sbs"/><uid v="1584665017"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://pattern_mesh_2.sbs"/><uid v="1584665098"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://panorama_shape.sbs"/><uid v="1358902059"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://pattern_polygon_1.sbs"/><uid v="1584666596"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://pattern_polygon_2.sbs"/><uid v="1357227353"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://pattern_scratches_generator.sbs"/><uid v="1301400394"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://pattern_shape.sbs"/><uid v="1311189026"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://shape_extrude.sbs"/><uid v="1324885430"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://shape_mapper.sbs"/><uid v="1280489006"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://shape_splatter.sbs"/><uid v="1508371125"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://splatter.sbs"/><uid v="1584671756"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://pattern_splatter_circular.sbs"/><uid v="1584671933"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://splatter_color.sbs"/><uid v="1584673176"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://pattern_star.sbs"/><uid v="1584673379"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://starburst.sbs"/><uid v="1584673434"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://pattern_stripes.sbs"/><uid v="1584673498"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://pattern_tile_generator.sbs"/><uid v="1386931028"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://pattern_tile_random.sbs"/><uid v="1508386588"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://pattern_tile_random_2.sbs"/><uid v="1439203372"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://pattern_tile_sampler.sbs"/><uid v="1584681877"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://pattern_triangle_grid.sbs"/><uid v="1440702706"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://pattern_weave_1.sbs"/><uid v="1584685657"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://pattern_weave_2.sbs"/><uid v="1584685737"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://pattern_weave_generator.sbs"/><uid v="1584685870"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://color_space_conversion.sbs"/><uid v="1584633171"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://quantize_color.sbs"/><uid v="1512837926"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://auto_levels.sbs"/><uid v="1345231453"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://channel_mixer.sbs"/><uid v="1584688016"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://chrominance_extract.sbs"/><uid v="1584688656"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://clamp.sbs"/><uid v="1584688664"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://color_match.sbs"/><uid v="1584688701"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://color_to_mask.sbs"/><uid v="1584688835"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://contrast_luminosity.sbs"/><uid v="1344255853"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://value_get_size.sbs"/><uid v="1584689073"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://grayscale_conversion_advanced.sbs"/><uid v="1584689082"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://hald_clut.sbs"/><uid v="1584689108"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://hdr_range_viewer.sbs"/><uid v="1584689158"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://height_map_frequencies_mapper.sbs"/><uid v="1584689233"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://highpass.sbs"/><uid v="1584689247"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://histogram_tools.sbs"/><uid v="1523648409"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://histogram_range.sbs"/><uid v="1584689526"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://histogram_scan.sbs"/><uid v="1149349207"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://histogram_scan_non_uniform.sbs"/><uid v="1584689833"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://histogram_select.sbs"/><uid v="1434230932"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://histogram_shift.sbs"/><uid v="1584689883"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://id_to_mask.sbs"/><uid v="1584689913"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://invert.sbs"/><uid v="1177447620"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://lighting_cancel_hf.sbs"/><uid v="1584689953"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://lighting_cancel_lf.sbs"/><uid v="1584689961"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://luminance_highpass.sbs"/><uid v="1584690009"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://min_max.sbs"/><uid v="1584690031"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://pow.sbs"/><uid v="1584690777"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://quantize.sbs"/><uid v="1584690828"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://quantize_2.sbs"/><uid v="1584693598"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://replace_color.sbs"/><uid v="1290776969"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://threshold.sbs"/><uid v="1584693773"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://blend.sbs"/><uid v="1290776863"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://blend_switch.sbs"/><uid v="1299239600"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://anisotropic_blur.sbs"/><uid v="1584694204"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://blur_hq.sbs"/><uid v="1296927904"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://median_filter.sbs"/><uid v="1521441579"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://mean_of_least_variance.sbs"/><uid v="1519504554"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://non_uniform_blur.sbs"/><uid v="1502209989"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://radial_blur.sbs"/><uid v="1312483850"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://slope_blur.sbs"/><uid v="1149349542"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://pre_multiply_straight.sbs"/><uid v="1511708294"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://rgb-a_merge.sbs"/><uid v="1278679669"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://rgb-a_split.sbs"/><uid v="1278965594"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://rgba_merge.sbs"/><uid v="1147283951"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://rgba_split.sbs"/><uid v="1584706046"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://3d_texture_position.sbs"/><uid v="1584740921"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://3d_texture_jump_flood.sbs"/><uid v="1441169042"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://3d_texture_render.sbs"/><uid v="1441883675"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://anisotropic_kuwahara.sbs"/><uid v="1511719455"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://bevel.sbs"/><uid v="1584752933"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://bevel_smooth.sbs"/><uid v="1506716929"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://cross_section.sbs"/><uid v="1387487152"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://curvature.sbs"/><uid v="1584754549"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://curvature_smooth_v2.sbs"/><uid v="1511733208"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://curvature_sobel.sbs"/><uid v="1584755266"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://diffusion.sbs"/><uid v="1428149473"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://directional_distance.sbs"/><uid v="1584756315"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://edge_detect.sbs"/><uid v="1584756538"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://emboss_with_gloss.sbs"/><uid v="1584756581"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://extend_shape.sbs"/><uid v="1584756606"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://flood_fill_2.sbs"/><uid v="1323881949"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://floodfill_mapper.sbs"/><uid v="1584757991"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://floodfill_to_index.sbs"/><uid v="1346333927"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://fxaa.sbs"/><uid v="1508396744"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://glow.sbs"/><uid v="1508358597"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://hbao_2.sbs"/><uid v="1297162667"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://mosaic.sbs"/><uid v="1584761891"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://multi_directional_warp.sbs"/><uid v="1584762342"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://non_uniform_directional_warp.sbs"/><uid v="1502212841"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://reaction_diffusion.sbs"/><uid v="1308015868"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://rt_ao_v2.sbs"/><uid v="1477525485"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://rt_irradiance.sbs"/><uid v="1399023226"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://rt_shadows_v2.sbs"/><uid v="1455094509"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://shadows.sbs"/><uid v="1584774680"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://shape_shadow.sbs"/><uid v="1480609918"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://shape_glow.sbs"/><uid v="1290776980"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://shape_stroke.sbs"/><uid v="1297163167"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://summed_area_table.sbs"/><uid v="1440175403"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://swirl.sbs"/><uid v="1299269942"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://uber_emboss.sbs"/><uid v="1584775285"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://vector_morph.sbs"/><uid v="1584775387"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://vector_warp.sbs"/><uid v="1584775660"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://facing_normal.sbs"/><uid v="1584775752"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://height_normal_blend.sbs"/><uid v="1584775768"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://height_to_normal_world_units.sbs"/><uid v="1584775836"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://normal_blend.sbs"/><uid v="1584775947"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://normal_combine.sbs"/><uid v="1584775973"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://normal_intensity.sbs"/><uid v="1584776095"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://normal_invert.sbs"/><uid v="1243453053"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://normal_normalise.sbs"/><uid v="1190815953"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://normal_sobel.sbs"/><uid v="1584776161"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://normal_to_height_2.sbs"/><uid v="1584776273"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://normal_to_height_hq.sbs"/><uid v="1530637974"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://normal_transform.sbs"/><uid v="1584777680"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://normal_uncombine.sbs"/><uid v="1506777764"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://normal_vector_rotation.sbs"/><uid v="1584778297"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://rt_bent_normal_v2.sbs"/><uid v="1477526317"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://make_it_tile_patch.sbs"/><uid v="1584779224"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://make_it_tile_patch_grayscale.sbs"/><uid v="1584779388"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://make_it_tile_photo.sbs"/><uid v="1584779557"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://make_it_tile_photo_grayscale.sbs"/><uid v="1584779689"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://3d_texture_transform.sbs"/><uid v="1584779775"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://auto_crop.sbs"/><uid v="1440705000"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://cartesian_polar_transformation.sbs"/><uid v="1297162060"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://clone.sbs"/><uid v="1584780172"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://mirror.sbs"/><uid v="1584780181"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_upscale_1.sbs"/><uid v="1584780366"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_upscale_2.sbs"/><uid v="1584780379"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://noise_upscale_3.sbs"/><uid v="1149349407"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://non_square_transform.sbs"/><uid v="1584780399"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://non_uniform_rotation.sbs"/><uid v="1584780602"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://quad_transform.sbs"/><uid v="1302869619"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://safe_transform.sbs"/><uid v="1272498971"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://skew.sbs"/><uid v="1584781231"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://symmetry.sbs"/><uid v="1584781328"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://symmetry_slice.sbs"/><uid v="1584781417"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://trapezoid_transform.sbs"/><uid v="1584781538"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://bitmaptomaterial_2_light.sbs"/><uid v="1584783856"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://height_blend.sbs"/><uid v="1584784217"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://material_height_blend.sbs"/><uid v="1584784276"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://me_snow_cover.sbs"/><uid v="1290776934"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://me_water_level.sbs"/><uid v="1290776935"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://material_transform.sbs"/><uid v="1584785586"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://material_adjustment_blend.sbs"/><uid v="1584785651"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://material_blend.sbs"/><uid v="1290776917"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://material_color_blend.sbs"/><uid v="1290776918"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://material_switch.sbs"/><uid v="1584786054"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://multi_material_blend.sbs"/><uid v="1584786161"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://pbr_converter.sbs"/><uid v="1584786987"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://pbr_albedo_safe_color.sbs"/><uid v="1584787068"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://pbr_base_material.sbs"/><uid v="1584787098"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://pbr_basecolor_metallic_validate.sbs"/><uid v="1584787463"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://pbr_dielectric_F0.sbs"/><uid v="1584787542"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://pbr_metal_reflectance.sbs"/><uid v="1584787627"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://pbr_render2.sbs"/><uid v="1531260237"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://ao_cancel.sbs"/><uid v="1584796795"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://atlas_scatter.sbs"/><uid v="1365665603"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://atlas_spliter.sbs"/><uid v="1481279116"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://clone_patch.sbs"/><uid v="1508366894"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://color_equalizer.sbs"/><uid v="1508369033"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://crop.sbs"/><uid v="1280723759"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://multiangle_to_albedo.sbs"/><uid v="1584802931"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://multiangle_to_normal.sbs"/><uid v="1508376227"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://smart_auto_tile.sbs"/><uid v="1366339147"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://mg_bottom_to_top.sbs"/><uid v="1584804111"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://mg_cloth_wear.sbs"/><uid v="1584804126"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://mg_dirt.sbs"/><uid v="1584804145"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://mg_dripping_rust.sbs"/><uid v="1584805297"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://mg_dust.sbs"/><uid v="1584805527"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://mg_edge_blur.sbs"/><uid v="1584806800"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://mg_edge_damages.sbs"/><uid v="1584806814"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://mg_edge_dirt.sbs"/><uid v="1584806954"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://mg_edge_notch.sbs"/><uid v="1584807039"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://mg_edge_select.sbs"/><uid v="1584807217"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://mg_edge_speckle.sbs"/><uid v="1584807239"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://mg_edge_wear.sbs"/><uid v="1584807263"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://mg_fiber_glass_edge_wear.sbs"/><uid v="1290776943"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://mg_grease.sbs"/><uid v="1584807386"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://mg_ground_dirt.sbs"/><uid v="1584807964"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://mg_leaks.sbs"/><uid v="1584808043"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://mg_leather_wear.sbs"/><uid v="1290776946"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://mg_light.sbs"/><uid v="1297163082"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://mg_mask_builder.sbs"/><uid v="1584808205"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://mg_metal_edge_wear.sbs"/><uid v="1290776948"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://mg_paint_wear.sbs"/><uid v="1584808915"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://mg_selective_dirt.sbs"/><uid v="1584808943"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://mg_sun_bleach.sbs"/><uid v="1584809010"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://mg_surface_brush.sbs"/><uid v="1584809028"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://cracks_weathering_material.sbs"/><uid v="1584809448"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://fabric_weathering_material.sbs"/><uid v="1584809662"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://leather_weathering_material.sbs"/><uid v="1584810313"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://moss_weathering_material.sbs"/><uid v="1584810689"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://painted_metal_weathering_material.sbs"/><uid v="1584812005"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://rock_weathering_material.sbs"/><uid v="1584812357"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://rust_weathering_material.sbs"/><uid v="1584812765"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://3d_planar_projection.sbs"/><uid v="1584813788"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://material_mesh_data_blender.sbs"/><uid v="1584814194"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://material_selector.sbs"/><uid v="1290776921"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://mesh_data_combiner.sbs"/><uid v="1584814439"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://triplanar.sbs"/><uid v="1290776989"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://paths_tools.sbs"/><uid v="1479303590"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://spline_tools.sbs"/><uid v="1526803024"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://uv_mapper.sbs"/><uid v="1477136496"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://blackbody.sbs"/><uid v="1584828554"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://color_temperature_adjustment.sbs"/><uid v="1584828561"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://exposure.sbs"/><uid v="1584828624"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://hdr_exposure_preview.sbs"/><uid v="1584828638"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://hdr_merge.sbs"/><uid v="1363339633"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://panorama_nadir_extract.sbs"/><uid v="1584829259"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://panorama_position.sbs"/><uid v="1584829294"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://panorama_gradients.sbs"/><uid v="1584829312"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://panorama_nadir_patch.sbs"/><uid v="1358121241"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://panorama_physical_sun_sky.sbs"/><uid v="1356796196"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://panorama_rotation.sbs"/><uid v="1584831443"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://panorama_straighten_horizon.sbs"/><uid v="1351988730"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://materials/pbr/bricks_001.sbs"/><uid v="1584832716"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://materials/pbr/bricks_005.sbs"/><uid v="1584833071"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://materials/pbr/cardboard_001.sbs"/><uid v="1584833872"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://materials/pbr/concrete_002.sbs"/><uid v="1584834389"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://materials/pbr/concrete_006.sbs"/><uid v="1584835042"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://materials/pbr/concrete_010.sbs"/><uid v="1584835332"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://materials/pbr/concrete_011.sbs"/><uid v="1584835658"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://materials/pbr/concrete_044.sbs"/><uid v="1584835959"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://materials/pbr/concrete_070.sbs"/><uid v="1584836168"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://materials/pbr/fabric_002.sbs"/><uid v="1290777011"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://materials/pbr/fabric_009.sbs"/><uid v="1584837006"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://materials/pbr/fabric_025.sbs"/><uid v="1290777014"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://materials/pbr/gravel.sbs"/><uid v="1584838674"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://materials/pbr/metal_002.sbs"/><uid v="1290777016"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://materials/pbr/metal_003.sbs"/><uid v="1584839502"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://materials/pbr/metal_006.sbs"/><uid v="1584840071"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://materials/pbr/metal_plate_001.sbs"/><uid v="1584840273"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://materials/pbr/metal_plate_004.sbs"/><uid v="1290777022"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://materials/pbr/old_painted_planks.sbs"/><uid v="1584840994"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://materials/pbr/paper_005.sbs"/><uid v="1584841309"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://materials/pbr/rough_concrete_with_lines.sbs"/><uid v="1584841711"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://materials/pbr/tiles_002.sbs"/><uid v="1584841880"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://materials/pbr/tiles_008.sbs"/><uid v="1584842131"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://materials/pbr/tiles_011.sbs"/><uid v="1584842408"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://materials/pbr/tiles_025.sbs"/><uid v="1584842682"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://materials/pbr/wood_american_cherry.sbs"/><uid v="1584842986"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency><dependency><filename v="sbs://functions.sbs"/><uid v="1508498669"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency></dependencies><content><graph><identifier v="Graph"/><uid v="1584632781"/><graphtype v="material"/><paraminputs><paraminput><identifier v="input"/><uid v="1584632987"/><isConnectable v="1"/><type v="1"/><defaultValue><constantValueFloat4 v="0 0 0 0"/></defaultValue><defaultWidget><name v=""/><options/></defaultWidget></paraminput><paraminput><identifier v="input_1"/><uid v="1584633017"/><isConnectable v="1"/><type v="2"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v=""/><options/></defaultWidget></paraminput><paraminput><identifier v="input_2"/><uid v="1584633026"/><isConnectable v="1"/><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v=""/><options/></defaultWidget></paraminput></paraminputs><primaryInput v="1584632987"/><graphOutputs><graphoutput><identifier v="basecolor"/><uid v="1213284336"/><attributes><label v="Base Color"/></attributes><usages><usage><components v="RGBA"/><name v="baseColor"/></usage></usages><group v="Material"/></graphoutput><graphoutput><identifier v="normal"/><uid v="1213284338"/><attributes><label v="Normal"/></attributes><usages><usage><components v="RGBA"/><name v="normal"/></usage></usages><group v="Material"/></graphoutput><graphoutput><identifier v="roughness"/><uid v="1213284340"/><attributes><label v="Roughness"/></attributes><usages><usage><components v="RGBA"/><name v="roughness"/></usage></usages><channels v="2"/><group v="Material"/></graphoutput><graphoutput><identifier v="metallic"/><uid v="1213284342"/><attributes><label v="Metallic"/></attributes><usages><usage><components v="RGBA"/><name v="metallic"/></usage></usages><channels v="2"/><group v="Material"/></graphoutput><graphoutput><identifier v="height"/><uid v="1279137031"/><attributes><label v="Height"/></attributes><usages><usage><components v="RGBA"/><name v="height"/></usage></usages><channels v="2"/><group v="Material"/></graphoutput><graphoutput><identifier v="ambientocclusion"/><uid v="1359211721"/><attributes><label v="Ambient Occlusion"/></attributes><usages><usage><components v="RGBA"/><name v="ambientOcclusion"/></usage></usages><channels v="2"/><group v="Material"/></graphoutput><graphoutput><identifier v="output"/><uid v="1584633047"/></graphoutput></graphOutputs><compNodes><compNode><uid v="1213284337"/><connections><connection><identifier v="inputNodeOutput"/><connRef v="1359211355"/><connRefOutput v="1359211356"/></connection></connections><GUILayout><gpos v="4432 -208 0"/></GUILayout><compImplementation><compOutputBridge><output v="1213284336"/></compOutputBridge></compImplementation></compNode><compNode><uid v="1213284339"/><connections><connection><identifier v="inputNodeOutput"/><connRef v="1359211383"/><connRefOutput v="1359211384"/></connection></connections><GUILayout><gpos v="4432 -48 0"/></GUILayout><compImplementation><compOutputBridge><output v="1213284338"/></compOutputBridge></compImplementation></compNode><compNode><uid v="1213284341"/><connections><connection><identifier v="inputNodeOutput"/><connRef v="1359211391"/><connRefOutput v="1359211392"/></connection></connections><GUILayout><gpos v="4432 112 0"/></GUILayout><compImplementation><compOutputBridge><output v="1213284340"/></compOutputBridge></compImplementation></compNode><compNode><uid v="1213284343"/><connections><connection><identifier v="inputNodeOutput"/><connRef v="1359211407"/><connRefOutput v="1359211408"/></connection></connections><GUILayout><gpos v="4432 272 0"/></GUILayout><compImplementation><compOutputBridge><output v="1213284342"/></compOutputBridge></compImplementation></compNode><compNode><uid v="1279137030"/><connections><connection><identifier v="inputNodeOutput"/><connRef v="1359211415"/><connRefOutput v="1359211408"/></connection></connections><GUILayout><gpos v="4432 592 0"/></GUILayout><compImplementation><compOutputBridge><output v="1279137031"/></compOutputBridge></compImplementation></compNode><compNode><uid v="1359211355"/><GUILayout><gpos v="4272 -208 0"/></GUILayout><compOutputs><compOutput><uid v="1359211356"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compFilter><filter v="uniform"/><parameters><parameter><name v="outputcolor"/><relativeTo v="0"/><paramValue><constantValueFloat4 v="0.5 0.5 0.5 1"/></paramValue></parameter></parameters></compFilter></compImplementation></compNode><compNode><uid v="1359211383"/><GUILayout><gpos v="4272 -48 0"/></GUILayout><compOutputs><compOutput><uid v="1359211384"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compFilter><filter v="normal"/><parameters><parameter><name v="input2alpha"/><relativeTo v="0"/><paramValue><constantValueBool v="0"/></paramValue></parameter></parameters></compFilter></compImplementation></compNode><compNode><uid v="1359211391"/><GUILayout><gpos v="4272 112 0"/></GUILayout><compOutputs><compOutput><uid v="1359211392"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compFilter><filter v="uniform"/><parameters><parameter><name v="colorswitch"/><relativeTo v="0"/><paramValue><constantValueBool v="0"/></paramValue></parameter><parameter><name v="outputcolor"/><relativeTo v="0"/><paramValue><constantValueFloat4 v="0.25 0.25 0.25 1"/></paramValue></parameter></parameters></compFilter></compImplementation></compNode><compNode><uid v="1359211407"/><GUILayout><gpos v="4272 272 0"/></GUILayout><compOutputs><compOutput><uid v="1359211408"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compFilter><filter v="uniform"/><parameters><parameter><name v="colorswitch"/><relativeTo v="0"/><paramValue><constantValueBool v="0"/></paramValue></parameter></parameters></compFilter></compImplementation></compNode><compNode><uid v="1359211415"/><GUILayout><gpos v="4272 592 0"/></GUILayout><compOutputs><compOutput><uid v="1359211408"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compFilter><filter v="uniform"/><parameters><parameter><name v="colorswitch"/><relativeTo v="0"/><paramValue><constantValueBool v="0"/></paramValue></parameter><parameter><name v="outputcolor"/><relativeTo v="0"/><paramValue><constantValueFloat4 v="0.5 0.5 0.5 1"/></paramValue></parameter></parameters></compFilter></compImplementation></compNode><compNode><uid v="1359211719"/><GUILayout><gpos v="4272 432 0"/></GUILayout><compOutputs><compOutput><uid v="1359211408"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compFilter><filter v="uniform"/><parameters><parameter><name v="colorswitch"/><relativeTo v="0"/><paramValue><constantValueBool v="0"/></paramValue></parameter><parameter><name v="outputcolor"/><relativeTo v="0"/><paramValue><constantValueFloat4 v="1 1 1 1"/></paramValue></parameter></parameters></compFilter></compImplementation></compNode><compNode><uid v="1359211720"/><connections><connection><identifier v="inputNodeOutput"/><connRef v="1359211719"/><connRefOutput v="1359211408"/></connection></connections><GUILayout><gpos v="4432 432 0"/></GUILayout><compImplementation><compOutputBridge><output v="1359211721"/></compOutputBridge></compImplementation></compNode><compNode><uid v="1584632881"/><GUILayout><gpos v="-4144 -528 0"/></GUILayout><compOutputs><compOutput><uid v="1584632882"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compFilter><filter v="blend"/><parameters/></compFilter></compImplementation></compNode><compNode><uid v="1584632887"/><GUILayout><gpos v="-4144 -400 0"/></GUILayout><compOutputs><compOutput><uid v="1584632888"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compFilter><filter v="blur"/><parameters/></compFilter></compImplementation></compNode><compNode><uid v="1584632893"/><GUILayout><gpos v="-4144 -254.788361 0"/></GUILayout><compOutputs><compOutput><uid v="1584632894"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compFilter><filter v="shuffle"/><parameters/></compFilter></compImplementation></compNode><compNode><uid v="1584632919"/><GUILayout><gpos v="-4144 -129.870285 0"/></GUILayout><compOutputs><compOutput><uid v="1584632920"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compFilter><filter v="curve"/><parameters><parameter><name v="exposecurve"/><paramValue><constantValueBool v="1"/></paramValue></parameter></parameters></compFilter></compImplementation></compNode><compNode><uid v="1584632925"/><GUILayout><gpos v="-4144 16 0"/></GUILayout><compOutputs><compOutput><uid v="1584632926"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compFilter><filter v="dirmotionblur"/><parameters/></compFilter></compImplementation></compNode><compNode><uid v="1584632931"/><GUILayout><gpos v="-4144 144 0"/></GUILayout><compOutputs><compOutput><uid v="1584632932"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compFilter><filter v="directionalwarp"/><parameters/></compFilter></compImplementation></compNode><compNode><uid v="1584632937"/><GUILayout><gpos v="-4144 272 0"/></GUILayout><compOutputs><compOutput><uid v="1584632938"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compFilter><filter v="distance"/><parameters/></compFilter></compImplementation></compNode><compNode><uid v="1584632943"/><GUILayout><gpos v="-4144 400 0"/></GUILayout><compOutputs><compOutput><uid v="1584632944"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compFilter><filter v="emboss"/><parameters/></compFilter></compImplementation></compNode><compNode><uid v="1584632949"/><GUILayout><gpos v="-4144 528 0"/></GUILayout><compOutputs><compOutput><uid v="1584632950"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compFilter><filter v="fxmaps"/><parameters/><paramsGraphs><paramsGraph><name v=""/><uid v="1584632951"/><rootnode v="1584632953"/><paramsGraphDatas><paramsGraphData><uid v="1584632952"/><type v="paramset"/></paramsGraphData></paramsGraphDatas><paramsGraphNodes><paramsGraphNode><uid v="1584632953"/><type v="paramset"/><data v="1584632952"/></paramsGraphNode></paramsGraphNodes></paramsGraph></paramsGraphs></compFilter></compImplementation></compNode><compNode><uid v="1584632960"/><GUILayout><gpos v="-4144 656 0"/></GUILayout><compOutputs><compOutput><uid v="1584632961"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compFilter><filter v="dyngradient"/><parameters/></compFilter></compImplementation></compNode><compNode><uid v="1584632967"/><GUILayout><gpos v="-4144 784 0"/></GUILayout><compOutputs><compOutput><uid v="1584632968"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compFilter><filter v="gradient"/><parameters/></compFilter></compImplementation></compNode><compNode><uid v="1584632973"/><GUILayout><gpos v="-4144 912 0"/></GUILayout><compOutputs><compOutput><uid v="1584632974"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compFilter><filter v="grayscaleconversion"/><parameters/></compFilter></compImplementation></compNode><compNode><uid v="1584632980"/><GUILayout><gpos v="-4144 1040 0"/></GUILayout><compOutputs><compOutput><uid v="1584632981"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compFilter><filter v="hsl"/><parameters/></compFilter></compImplementation></compNode><compNode><uid v="1584632988"/><GUILayout><gpos v="-4144 1168 0"/></GUILayout><compOutputs><compOutput><uid v="1584632989"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInputBridge><entry v="1584632987"/><parameters><parameter><name v="outputsize"/><relativeTo v="1"/><paramValue><constantValueInt2 v="0 0"/></paramValue></parameter><parameter><name v="format"/><relativeTo v="1"/><paramValue><constantValueInt1 v="0"/></paramValue></parameter><parameter><name v="pixelsize"/><relativeTo v="1"/><paramValue><constantValueFloat2 v="1 1"/></paramValue></parameter><parameter><name v="pixelratio"/><relativeTo v="1"/><paramValue><constantValueInt1 v="0"/></paramValue></parameter><parameter><name v="tiling"/><relativeTo v="1"/><paramValue><constantValueInt1 v="0"/></paramValue></parameter><parameter><name v="randomseed"/><relativeTo v="1"/><paramValue><constantValueInt1 v="0"/></paramValue></parameter></parameters></compInputBridge></compImplementation></compNode><compNode><uid v="1584633001"/><GUILayout><gpos v="-4144 -656 0"/></GUILayout><compOutputs><compOutput><uid v="1584633002"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compFilter><filter v="bitmap"/><parameters><parameter><name v="bitmapresourcepath"/><relativeTo v="0"/><paramValue><constantValueString v="pkg:///Resources/Untitled_Bitmap?dependency=1584632780"/></paramValue></parameter><parameter><name v="outputsize"/><relativeTo v="0"/><paramValue><constantValueInt2 v="9 9"/></paramValue></parameter></parameters></compFilter></compImplementation></compNode><compNode><uid v="1584633018"/><GUILayout><gpos v="-4144 1296 0"/></GUILayout><compOutputs><compOutput><uid v="1584633019"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInputBridge><entry v="1584633017"/><parameters><parameter><name v="outputsize"/><relativeTo v="1"/><paramValue><constantValueInt2 v="0 0"/></paramValue></parameter><parameter><name v="format"/><relativeTo v="1"/><paramValue><constantValueInt1 v="0"/></paramValue></parameter><parameter><name v="pixelsize"/><relativeTo v="1"/><paramValue><constantValueFloat2 v="1 1"/></paramValue></parameter><parameter><name v="pixelratio"/><relativeTo v="1"/><paramValue><constantValueInt1 v="0"/></paramValue></parameter><parameter><name v="tiling"/><relativeTo v="1"/><paramValue><constantValueInt1 v="0"/></paramValue></parameter><parameter><name v="randomseed"/><relativeTo v="1"/><paramValue><constantValueInt1 v="0"/></paramValue></parameter></parameters></compInputBridge></compImplementation></compNode><compNode><uid v="1584633027"/><GUILayout><gpos v="-4144 1424 0"/></GUILayout><compOutputs><compOutput><uid v="1584633028"/><comptype v="256"/></compOutput></compOutputs><compImplementation><compInputBridge><entry v="1584633026"/><parameters><parameter><name v="outputsize"/><relativeTo v="1"/><paramValue><constantValueInt2 v="0 0"/></paramValue></parameter><parameter><name v="format"/><relativeTo v="1"/><paramValue><constantValueInt1 v="0"/></paramValue></parameter><parameter><name v="pixelsize"/><relativeTo v="1"/><paramValue><constantValueFloat2 v="1 1"/></paramValue></parameter><parameter><name v="pixelratio"/><relativeTo v="1"/><paramValue><constantValueInt1 v="0"/></paramValue></parameter><parameter><name v="tiling"/><relativeTo v="1"/><paramValue><constantValueInt1 v="0"/></paramValue></parameter><parameter><name v="randomseed"/><relativeTo v="1"/><paramValue><constantValueInt1 v="0"/></paramValue></parameter></parameters></compInputBridge></compImplementation></compNode><compNode><uid v="1584633036"/><GUILayout><gpos v="-4144 1552 0"/></GUILayout><compOutputs><compOutput><uid v="1584633037"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compFilter><filter v="levels"/><parameters/></compFilter></compImplementation></compNode><compNode><uid v="1584633042"/><GUILayout><gpos v="-4144 1680 0"/></GUILayout><compOutputs><compOutput><uid v="1584633043"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compFilter><filter v="normal"/><parameters><parameter><name v="input2alpha"/><relativeTo v="0"/><paramValue><constantValueBool v="0"/></paramValue></parameter></parameters></compFilter></compImplementation></compNode><compNode><uid v="1584633048"/><GUILayout><gpos v="-4144 1808 0"/></GUILayout><compImplementation><compOutputBridge><output v="1584633047"/></compOutputBridge></compImplementation></compNode><compNode><uid v="1584633054"/><GUILayout><gpos v="-4144 1936 0"/></GUILayout><compOutputs><compOutput><uid v="1584633055"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compFilter><filter v="pixelprocessor"/><parameters/></compFilter></compImplementation></compNode><compNode><uid v="1584633061"/><GUILayout><gpos v="-4144 2064 0"/></GUILayout><compOutputs><compOutput><uid v="1584633062"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compFilter><filter v="sharpen"/><parameters/></compFilter></compImplementation></compNode><compNode><uid v="1584633070"/><GUILayout><gpos v="-4144 2192 0"/></GUILayout><compOutputs><compOutput><uid v="1584633071"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compFilter><filter v="svg"/><parameters><parameter><name v="vectorresourcepath"/><relativeTo v="0"/><paramValue><constantValueString v="pkg:///Resources/Untitled_Vector_Graphics?dependency=1584632780"/></paramValue></parameter></parameters></compFilter></compImplementation></compNode><compNode><uid v="1584633077"/><GUILayout><gpos v="-4144 2320 0"/></GUILayout><compOutputs><compOutput><uid v="1584633078"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compFilter><filter v="text"/><parameters><parameter><name v="fontdata"/><relativeTo v="0"/><paramValue><constantValueString v="Arial"/></paramValue></parameter></parameters></compFilter></compImplementation></compNode><compNode><uid v="1584633084"/><GUILayout><gpos v="-4144 2462.80591 0"/></GUILayout><compOutputs><compOutput><uid v="1584633085"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compFilter><filter v="transformation"/><parameters/></compFilter></compImplementation></compNode><compNode><uid v="1584633093"/><GUILayout><gpos v="-4144 2576 0"/></GUILayout><compOutputs><compOutput><uid v="1584633094"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compFilter><filter v="uniform"/><parameters/></compFilter></compImplementation></compNode><compNode><uid v="1584633100"/><GUILayout><gpos v="-4144 2704 0"/></GUILayout><compOutputs><compOutput><uid v="1584633101"/><comptype v="256"/></compOutput></compOutputs><compImplementation><compFilter><filter v="valueprocessor"/><parameters/></compFilter></compImplementation></compNode><compNode><uid v="1584633107"/><GUILayout><gpos v="-4144 2832 0"/></GUILayout><compOutputs><compOutput><uid v="1584633108"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compFilter><filter v="warp"/><parameters/></compFilter></compImplementation></compNode><compNode><uid v="1584687025"/><GUILayout><gpos v="-3952 -656 0"/></GUILayout><compOutputs><compOutput><uid v="1584687026"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///3D_perlin_noise?dependency=1437570156"/><parameters/><outputBridgings><outputBridging><uid v="1584687026"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687027"/><GUILayout><gpos v="-3952 -528 0"/></GUILayout><compOutputs><compOutput><uid v="1584687028"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///3D_perlin_noise_fractal?dependency=1437570156"/><parameters/><outputBridgings><outputBridging><uid v="1584687028"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687029"/><GUILayout><gpos v="-3952 -400 0"/></GUILayout><compOutputs><compOutput><uid v="1584687030"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///3D_ridged_noise_fractal?dependency=1437570156"/><parameters/><outputBridgings><outputBridging><uid v="1584687030"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687031"/><GUILayout><gpos v="-3952 -272 0"/></GUILayout><compOutputs><compOutput><uid v="1584687032"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///3d_simplex_noise?dependency=1311275138"/><parameters/><outputBridgings><outputBridging><uid v="1584687032"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687033"/><GUILayout><gpos v="-3952 -144 0"/></GUILayout><compOutputs><compOutput><uid v="1584687034"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///3d_voronoi?dependency=1440766644"/><parameters/><outputBridgings><outputBridging><uid v="1584687034"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687035"/><GUILayout><gpos v="-3952 -16 0"/></GUILayout><compOutputs><compOutput><uid v="1584687036"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///3d_voronoi_fractal?dependency=1440766644"/><parameters/><outputBridgings><outputBridging><uid v="1584687036"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687037"/><GUILayout><gpos v="-3952 112 0"/></GUILayout><compOutputs><compOutput><uid v="1584687038"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///3D_worley_noise?dependency=1217378548"/><parameters/><outputBridgings><outputBridging><uid v="1584687038"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687039"/><GUILayout><gpos v="-3952 240 0"/></GUILayout><compOutputs><compOutput><uid v="1584687040"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///anisotropic_noise?dependency=1584639338"/><parameters/><outputBridgings><outputBridging><uid v="1584687040"/><identifier v="Anisotropic_Noise"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687041"/><GUILayout><gpos v="-3952 368 0"/></GUILayout><compOutputs><compOutput><uid v="1584687042"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///blue_noise_fast?dependency=1584639858"/><parameters/><outputBridgings><outputBridging><uid v="1584687042"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687043"/><GUILayout><gpos v="-3952 496 0"/></GUILayout><compOutputs><compOutput><uid v="1584687044"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///bnw_spots_1?dependency=1584639913"/><parameters/><outputBridgings><outputBridging><uid v="1584687044"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687045"/><GUILayout><gpos v="-3952 624 0"/></GUILayout><compOutputs><compOutput><uid v="1584687046"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///bnw_spots_2?dependency=1584640143"/><parameters/><outputBridgings><outputBridging><uid v="1584687046"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687047"/><GUILayout><gpos v="-3952 752 0"/></GUILayout><compOutputs><compOutput><uid v="1584687048"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///bnw_spots_3?dependency=1299276443"/><parameters/><outputBridgings><outputBridging><uid v="1584687048"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687049"/><GUILayout><gpos v="-3952 880 0"/></GUILayout><compOutputs><compOutput><uid v="1584687050"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///cells_1?dependency=1584642533"/><parameters/><outputBridgings><outputBridging><uid v="1584687050"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687051"/><GUILayout><gpos v="-3952 1008 0"/></GUILayout><compOutputs><compOutput><uid v="1584687052"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///cells_2?dependency=1584642645"/><parameters/><outputBridgings><outputBridging><uid v="1584687052"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687053"/><GUILayout><gpos v="-3952 1136 0"/></GUILayout><compOutputs><compOutput><uid v="1584687054"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///cells_3?dependency=1584643037"/><parameters/><outputBridgings><outputBridging><uid v="1584687054"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687055"/><GUILayout><gpos v="-3952 1264 0"/></GUILayout><compOutputs><compOutput><uid v="1584687056"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///cells_4?dependency=1299276447"/><parameters/><outputBridgings><outputBridging><uid v="1584687056"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687057"/><GUILayout><gpos v="-3952 1392 0"/></GUILayout><compOutputs><compOutput><uid v="1584687058"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///clouds_1?dependency=1584643174"/><parameters/><outputBridgings><outputBridging><uid v="1584687058"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687059"/><GUILayout><gpos v="-3952 1520 0"/></GUILayout><compOutputs><compOutput><uid v="1584687060"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///clouds_2?dependency=1584643519"/><parameters/><outputBridgings><outputBridging><uid v="1584687060"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687061"/><GUILayout><gpos v="-3952 1648 0"/></GUILayout><compOutputs><compOutput><uid v="1584687062"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///clouds_3?dependency=1584643869"/><parameters/><outputBridgings><outputBridging><uid v="1584687062"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687063"/><GUILayout><gpos v="-3952 1776 0"/></GUILayout><compOutputs><compOutput><uid v="1584687064"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///creased?dependency=1584644203"/><parameters/><outputBridgings><outputBridging><uid v="1584687064"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687065"/><GUILayout><gpos v="-3952 1904 0"/></GUILayout><compOutputs><compOutput><uid v="1584687066"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///crystal_1?dependency=1584644394"/><parameters/><outputBridgings><outputBridging><uid v="1584687066"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687067"/><GUILayout><gpos v="-3952 2032 0"/></GUILayout><compOutputs><compOutput><uid v="1584687068"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///crystal_2?dependency=1584644622"/><parameters/><outputBridgings><outputBridging><uid v="1584687068"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687069"/><GUILayout><gpos v="-3952 2160 0"/></GUILayout><compOutputs><compOutput><uid v="1584687070"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///directional_noise_1?dependency=1584645560"/><parameters/><outputBridgings><outputBridging><uid v="1584687070"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687071"/><GUILayout><gpos v="-3952 2288 0"/></GUILayout><compOutputs><compOutput><uid v="1584687072"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///directional_noise_2?dependency=1584646017"/><parameters/><outputBridgings><outputBridging><uid v="1584687072"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687073"/><GUILayout><gpos v="-3952 2416 0"/></GUILayout><compOutputs><compOutput><uid v="1584687074"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///directional_noise_3?dependency=1584646196"/><parameters/><outputBridgings><outputBridging><uid v="1584687074"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687075"/><GUILayout><gpos v="-3952 2544 0"/></GUILayout><compOutputs><compOutput><uid v="1584687076"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///directional_noise_4?dependency=1584646656"/><parameters/><outputBridgings><outputBridging><uid v="1584687076"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687077"/><GUILayout><gpos v="-3952 2672 0"/></GUILayout><compOutputs><compOutput><uid v="1584687078"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///directional_scratches?dependency=1584646818"/><parameters/><outputBridgings><outputBridging><uid v="1584687078"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687079"/><GUILayout><gpos v="-3952 2800 0"/></GUILayout><compOutputs><compOutput><uid v="1584687080"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///dirt_1?dependency=1299276460"/><parameters/><outputBridgings><outputBridging><uid v="1584687080"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687081"/><GUILayout><gpos v="-3952 2928 0"/></GUILayout><compOutputs><compOutput><uid v="1584687082"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///dirt_2?dependency=1584646981"/><parameters/><outputBridgings><outputBridging><uid v="1584687082"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687083"/><GUILayout><gpos v="-3952 3056 0"/></GUILayout><compOutputs><compOutput><uid v="1584687084"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///dirt_3?dependency=1584647143"/><parameters/><outputBridgings><outputBridging><uid v="1584687084"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687085"/><GUILayout><gpos v="-3952 3184 0"/></GUILayout><compOutputs><compOutput><uid v="1584687086"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///dirt_4?dependency=1584647426"/><parameters/><outputBridgings><outputBridging><uid v="1584687086"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687087"/><GUILayout><gpos v="-3952 3312 0"/></GUILayout><compOutputs><compOutput><uid v="1584687088"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///dirt_5?dependency=1584647603"/><parameters/><outputBridgings><outputBridging><uid v="1584687088"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687089"/><GUILayout><gpos v="-3952 3440 0"/></GUILayout><compOutputs><compOutput><uid v="1584687090"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///dirt_gradient?dependency=1584647753"/><parameters/><outputBridgings><outputBridging><uid v="1584687090"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687091"/><GUILayout><gpos v="-3952 3568 0"/></GUILayout><compOutputs><compOutput><uid v="1584687092"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///fluid?dependency=1584648733"/><parameters/><outputBridgings><outputBridging><uid v="1584687092"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687093"/><GUILayout><gpos v="-3952 3696 0"/></GUILayout><compOutputs><compOutput><uid v="1584687094"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///fractal_sum_1?dependency=1584648924"/><parameters/><outputBridgings><outputBridging><uid v="1584687094"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687095"/><GUILayout><gpos v="-3952 3824 0"/></GUILayout><compOutputs><compOutput><uid v="1584687096"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///fractal_sum_2?dependency=1584650329"/><parameters/><outputBridgings><outputBridging><uid v="1584687096"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687097"/><GUILayout><gpos v="-3952 3952 0"/></GUILayout><compOutputs><compOutput><uid v="1584687098"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///fractal_sum_3?dependency=1584650336"/><parameters/><outputBridgings><outputBridging><uid v="1584687098"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687099"/><GUILayout><gpos v="-3952 4080 0"/></GUILayout><compOutputs><compOutput><uid v="1584687100"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///fractal_sum_4?dependency=1584650343"/><parameters/><outputBridgings><outputBridging><uid v="1584687100"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687101"/><GUILayout><gpos v="-3952 4208 0"/></GUILayout><compOutputs><compOutput><uid v="1584687102"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///fractal_sum_base_2?dependency=1299276471"/><parameters/><outputBridgings><outputBridging><uid v="1584687102"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687103"/><GUILayout><gpos v="-3952 4336 0"/></GUILayout><compOutputs><compOutput><uid v="1584687104"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///fur_1?dependency=1584651925"/><parameters/><outputBridgings><outputBridging><uid v="1584687104"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687105"/><GUILayout><gpos v="-3952 4464 0"/></GUILayout><compOutputs><compOutput><uid v="1584687106"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///fur_2?dependency=1584652074"/><parameters/><outputBridgings><outputBridging><uid v="1584687106"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687107"/><GUILayout><gpos v="-3952 4592 0"/></GUILayout><compOutputs><compOutput><uid v="1584687108"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///fur_3?dependency=1584652238"/><parameters/><outputBridgings><outputBridging><uid v="1584687108"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687109"/><GUILayout><gpos v="-3952 4720 0"/></GUILayout><compOutputs><compOutput><uid v="1584687110"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///gaussian_noise?dependency=1584652549"/><parameters/><outputBridgings><outputBridging><uid v="1584687110"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687111"/><GUILayout><gpos v="-3952 4848 0"/></GUILayout><compOutputs><compOutput><uid v="1584687112"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///gaussian_spots_1?dependency=1584652663"/><parameters/><outputBridgings><outputBridging><uid v="1584687112"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687113"/><GUILayout><gpos v="-3952 4976 0"/></GUILayout><compOutputs><compOutput><uid v="1584687114"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///gaussian_spots_2?dependency=1584652796"/><parameters/><outputBridgings><outputBridging><uid v="1584687114"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687115"/><GUILayout><gpos v="-3952 5104 0"/></GUILayout><compOutputs><compOutput><uid v="1584687116"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///grunge_concrete?dependency=1584653196"/><parameters/><outputBridgings><outputBridging><uid v="1584687116"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687117"/><GUILayout><gpos v="-3952 5232 0"/></GUILayout><compOutputs><compOutput><uid v="1584687118"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///grunge_damas?dependency=1584656003"/><parameters/><outputBridgings><outputBridging><uid v="1584687118"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687119"/><GUILayout><gpos v="-3952 5360 0"/></GUILayout><compOutputs><compOutput><uid v="1584687120"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///grunge_galvanic_large?dependency=1584656093"/><parameters/><outputBridgings><outputBridging><uid v="1584687120"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687121"/><GUILayout><gpos v="-3952 5488 0"/></GUILayout><compOutputs><compOutput><uid v="1584687122"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///grunge_galvanic_small?dependency=1584656142"/><parameters/><outputBridgings><outputBridging><uid v="1584687122"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687123"/><GUILayout><gpos v="-3952 5616 0"/></GUILayout><compOutputs><compOutput><uid v="1584687124"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///grunge_leaks?dependency=1584656218"/><parameters/><outputBridgings><outputBridging><uid v="1584687124"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687125"/><GUILayout><gpos v="-3952 5744 0"/></GUILayout><compOutputs><compOutput><uid v="1584687126"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///grunge_leaky_paint?dependency=1584657378"/><parameters/><outputBridgings><outputBridging><uid v="1584687126"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687127"/><GUILayout><gpos v="-3952 5872 0"/></GUILayout><compOutputs><compOutput><uid v="1584687128"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///grunge_map_001?dependency=1584657405"/><parameters/><outputBridgings><outputBridging><uid v="1584687128"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687129"/><GUILayout><gpos v="-3952 6000 0"/></GUILayout><compOutputs><compOutput><uid v="1584687130"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///grunge_map_002?dependency=1584657590"/><parameters/><outputBridgings><outputBridging><uid v="1584687130"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687131"/><GUILayout><gpos v="-3952 6128 0"/></GUILayout><compOutputs><compOutput><uid v="1584687132"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///grunge_map_003?dependency=1584657667"/><parameters/><outputBridgings><outputBridging><uid v="1584687132"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687133"/><GUILayout><gpos v="-3952 6256 0"/></GUILayout><compOutputs><compOutput><uid v="1584687134"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///grunge_map_004?dependency=1584657828"/><parameters/><outputBridgings><outputBridging><uid v="1584687134"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687135"/><GUILayout><gpos v="-3952 6384 0"/></GUILayout><compOutputs><compOutput><uid v="1584687136"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///grunge_map_005?dependency=1584657939"/><parameters/><outputBridgings><outputBridging><uid v="1584687136"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687137"/><GUILayout><gpos v="-3952 6512 0"/></GUILayout><compOutputs><compOutput><uid v="1584687138"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///grunge_map_006?dependency=1584658048"/><parameters/><outputBridgings><outputBridging><uid v="1584687138"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687139"/><GUILayout><gpos v="-3952 6640 0"/></GUILayout><compOutputs><compOutput><uid v="1584687140"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///grunge_map_007?dependency=1584658179"/><parameters/><outputBridgings><outputBridging><uid v="1584687140"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687141"/><GUILayout><gpos v="-3952 6768 0"/></GUILayout><compOutputs><compOutput><uid v="1584687142"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///grunge_map_008?dependency=1584658386"/><parameters/><outputBridgings><outputBridging><uid v="1584687142"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687143"/><GUILayout><gpos v="-3952 6896 0"/></GUILayout><compOutputs><compOutput><uid v="1584687144"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///grunge_map_009?dependency=1584658597"/><parameters/><outputBridgings><outputBridging><uid v="1584687144"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687145"/><GUILayout><gpos v="-3952 7024 0"/></GUILayout><compOutputs><compOutput><uid v="1584687146"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///grunge_map_010?dependency=1584658787"/><parameters/><outputBridgings><outputBridging><uid v="1584687146"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687147"/><GUILayout><gpos v="-3952 7152 0"/></GUILayout><compOutputs><compOutput><uid v="1584687148"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///grunge_map_011?dependency=1584659113"/><parameters/><outputBridgings><outputBridging><uid v="1584687148"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687149"/><GUILayout><gpos v="-3952 7280 0"/></GUILayout><compOutputs><compOutput><uid v="1584687150"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///grunge_map_012?dependency=1584659350"/><parameters/><outputBridgings><outputBridging><uid v="1584687150"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687151"/><GUILayout><gpos v="-3952 7408 0"/></GUILayout><compOutputs><compOutput><uid v="1584687152"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///grunge_map_013?dependency=1584659549"/><parameters/><outputBridgings><outputBridging><uid v="1584687152"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687153"/><GUILayout><gpos v="-3952 7536 0"/></GUILayout><compOutputs><compOutput><uid v="1584687154"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///grunge_map_014?dependency=1584659688"/><parameters/><outputBridgings><outputBridging><uid v="1584687154"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687155"/><GUILayout><gpos v="-3952 7664 0"/></GUILayout><compOutputs><compOutput><uid v="1584687156"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///grunge_map_015?dependency=1584659892"/><parameters/><outputBridgings><outputBridging><uid v="1584687156"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687157"/><GUILayout><gpos v="-3952 7792 0"/></GUILayout><compOutputs><compOutput><uid v="1584687158"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///grunge_rough_dirty?dependency=1584660734"/><parameters/><outputBridgings><outputBridging><uid v="1584687158"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687159"/><GUILayout><gpos v="-3952 7920 0"/></GUILayout><compOutputs><compOutput><uid v="1584687160"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///grunge_rust_fine?dependency=1584661084"/><parameters/><outputBridgings><outputBridging><uid v="1584687160"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687161"/><GUILayout><gpos v="-3952 8048 0"/></GUILayout><compOutputs><compOutput><uid v="1584687162"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///grunge_scratches_dirty?dependency=1584661268"/><parameters/><outputBridgings><outputBridging><uid v="1584687162"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687163"/><GUILayout><gpos v="-3952 8176 0"/></GUILayout><compOutputs><compOutput><uid v="1584687164"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///grunge_scratches_fine?dependency=1584663445"/><parameters/><outputBridgings><outputBridging><uid v="1584687164"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687165"/><GUILayout><gpos v="-3952 8304 0"/></GUILayout><compOutputs><compOutput><uid v="1584687166"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///grunge_scratches_rough?dependency=1584663575"/><parameters/><outputBridgings><outputBridging><uid v="1584687166"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687167"/><GUILayout><gpos v="-3952 8432 0"/></GUILayout><compOutputs><compOutput><uid v="1584687168"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///grunge_shavings?dependency=1584663754"/><parameters/><outputBridgings><outputBridging><uid v="1584687168"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687169"/><GUILayout><gpos v="-3952 8560 0"/></GUILayout><compOutputs><compOutput><uid v="1584687170"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///grunge_splashes_dusty?dependency=1584663817"/><parameters/><outputBridgings><outputBridging><uid v="1584687170"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687171"/><GUILayout><gpos v="-3952 8688 0"/></GUILayout><compOutputs><compOutput><uid v="1584687172"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///grunge_spots?dependency=1584664353"/><parameters/><outputBridgings><outputBridging><uid v="1584687172"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687173"/><GUILayout><gpos v="-3952 8816 0"/></GUILayout><compOutputs><compOutput><uid v="1584687174"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///grunge_spots_dirty?dependency=1584664376"/><parameters/><outputBridgings><outputBridging><uid v="1584687174"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687175"/><GUILayout><gpos v="-3952 8944 0"/></GUILayout><compOutputs><compOutput><uid v="1584687176"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///liquid?dependency=1300576745"/><parameters/><outputBridgings><outputBridging><uid v="1584687176"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687177"/><GUILayout><gpos v="-3952 9072 0"/></GUILayout><compOutputs><compOutput><uid v="1584687178"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///messy_fibers_1?dependency=1439741058"/><parameters/><outputBridgings><outputBridging><uid v="1584687178"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687179"/><GUILayout><gpos v="-3952 9200 0"/></GUILayout><compOutputs><compOutput><uid v="1584687180"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///messy_fibers_2?dependency=1584665181"/><parameters/><outputBridgings><outputBridging><uid v="1584687180"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687181"/><GUILayout><gpos v="-3952 9328 0"/></GUILayout><compOutputs><compOutput><uid v="1584687182"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///messy_fibers_3?dependency=1584665329"/><parameters/><outputBridgings><outputBridging><uid v="1584687182"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687183"/><GUILayout><gpos v="-3952 9456 0"/></GUILayout><compOutputs><compOutput><uid v="1584687184"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///microscope_view?dependency=1584665471"/><parameters/><outputBridgings><outputBridging><uid v="1584687184"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687185"/><GUILayout><gpos v="-3952 9584 0"/></GUILayout><compOutputs><compOutput><uid v="1584687186"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///moisture_noise?dependency=1439297100"/><parameters/><outputBridgings><outputBridging><uid v="1584687186"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687187"/><GUILayout><gpos v="-3952 9712 0"/></GUILayout><compOutputs><compOutput><uid v="1584687188"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///perlin_noise?dependency=1584666054"/><parameters/><outputBridgings><outputBridging><uid v="1584687188"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687189"/><GUILayout><gpos v="-3952 9840 0"/></GUILayout><compOutputs><compOutput><uid v="1584687190"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///plasma?dependency=1584666365"/><parameters/><outputBridgings><outputBridging><uid v="1584687190"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687191"/><GUILayout><gpos v="-3952 9968 0"/></GUILayout><compOutputs><compOutput><uid v="1584687192"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///rt_caustics_color?dependency=1400391215"/><parameters/><outputBridgings><outputBridging><uid v="1584687192"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687193"/><GUILayout><gpos v="-3952 10096 0"/></GUILayout><compOutputs><compOutput><uid v="1584687194"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///rt_caustics_grayscale?dependency=1400391215"/><parameters/><outputBridgings><outputBridging><uid v="1584687194"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687195"/><GUILayout><gpos v="-3952 10224 0"/></GUILayout><compOutputs><compOutput><uid v="1584687196"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///voronoi?dependency=1440766644"/><parameters/><outputBridgings><outputBridging><uid v="1584687196"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687197"/><GUILayout><gpos v="-3952 10352 0"/></GUILayout><compOutputs><compOutput><uid v="1584687198"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///voronoi_fractal?dependency=1440766644"/><parameters/><outputBridgings><outputBridging><uid v="1584687198"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687199"/><GUILayout><gpos v="-3952 10480 0"/></GUILayout><compOutputs><compOutput><uid v="1584687200"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///waveform_1?dependency=1584685599"/><parameters/><outputBridgings><outputBridging><uid v="1584687200"/><identifier v="Waveform"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687201"/><GUILayout><gpos v="-3952 10608 0"/></GUILayout><compOutputs><compOutput><uid v="1584687202"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///white_noise_fast?dependency=1146345729"/><parameters/><outputBridgings><outputBridging><uid v="1584687202"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687228"/><GUILayout><gpos v="-3664 -656 0"/></GUILayout><compOutputs><compOutput><uid v="1584687229"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///3d_linear_gradient?dependency=1584635741"/><parameters/><outputBridgings><outputBridging><uid v="1584687229"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687230"/><GUILayout><gpos v="-3664 -528 0"/></GUILayout><compOutputs><compOutput><uid v="1584687231"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///3d_volume_mask?dependency=1584637151"/><parameters/><outputBridgings><outputBridging><uid v="1584687231"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687232"/><GUILayout><gpos v="-3664 -400 0"/></GUILayout><compOutputs><compOutput><uid v="1584687233"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///alveolus?dependency=1584639259"/><parameters/><outputBridgings><outputBridging><uid v="1584687233"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687234"/><GUILayout><gpos v="-3664 -272 0"/></GUILayout><compOutputs><compOutput><uid v="1584687235"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///arc_pavement?dependency=1584639528"/><parameters/><outputBridgings><outputBridging><uid v="1584687235"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687236"/><GUILayout><gpos v="-3664 -144 0"/></GUILayout><compOutputs><compOutput><uid v="1584687237"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///brick_1?dependency=1584640941"/><parameters/><outputBridgings><outputBridging><uid v="1584687237"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687238"/><GUILayout><gpos v="-3664 -16 0"/></GUILayout><compOutputs><compOutput><uid v="1584687239"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///brick_2?dependency=1584641083"/><parameters/><outputBridgings><outputBridging><uid v="1584687239"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687240"/><GUILayout><gpos v="-3664 112 0"/></GUILayout><compOutputs><compOutput><uid v="1584687241"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///brick_generator?dependency=1299369593"/><parameters/><outputBridgings><outputBridging><uid v="1584687241"/><identifier v="Bricks_Generator"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687242"/><GUILayout><gpos v="-3664 240 0"/></GUILayout><compOutputs><compOutput><uid v="1584687243"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///checker_1?dependency=1584643093"/><parameters/><outputBridgings><outputBridging><uid v="1584687243"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687244"/><GUILayout><gpos v="-3664 368 0"/></GUILayout><compOutputs><compOutput><uid v="1584687245"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///cube_3d?dependency=1311189968"/><parameters/><outputBridgings><outputBridging><uid v="1584687245"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687246"/><GUILayout><gpos v="-3664 506.666656 0"/></GUILayout><compOutputs><compOutput><uid v="1584687247"/><comptype v="1"/></compOutput><compOutput><uid v="1584687248"/><comptype v="1"/></compOutput><compOutput><uid v="1584687249"/><comptype v="2"/></compOutput><compOutput><uid v="1584687250"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///cube_3d_gbuffers?dependency=1311189968"/><parameters/><outputBridgings><outputBridging><uid v="1584687247"/><identifier v="position"/></outputBridging><outputBridging><uid v="1584687248"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584687249"/><identifier v="depth"/></outputBridging><outputBridging><uid v="1584687250"/><identifier v="uv"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687251"/><GUILayout><gpos v="-3664 656 0"/></GUILayout><compOutputs><compOutput><uid v="1584687252"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///fibers_1?dependency=1584648509"/><parameters/><outputBridgings><outputBridging><uid v="1584687252"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687253"/><GUILayout><gpos v="-3664 784 0"/></GUILayout><compOutputs><compOutput><uid v="1584687254"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///fibers_2?dependency=1584648609"/><parameters/><outputBridgings><outputBridging><uid v="1584687254"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687255"/><GUILayout><gpos v="-3664 912 0"/></GUILayout><compOutputs><compOutput><uid v="1584687256"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///gaussian_1?dependency=1584652394"/><parameters/><outputBridgings><outputBridging><uid v="1584687256"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687257"/><GUILayout><gpos v="-3664 1040 0"/></GUILayout><compOutputs><compOutput><uid v="1584687258"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///gaussian_2?dependency=1584652470"/><parameters/><outputBridgings><outputBridging><uid v="1584687258"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687259"/><GUILayout><gpos v="-3664 1168 0"/></GUILayout><compOutputs><compOutput><uid v="1584687260"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///gradient_axial?dependency=1584652945"/><parameters/><outputBridgings><outputBridging><uid v="1584687260"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687261"/><GUILayout><gpos v="-3664 1296 0"/></GUILayout><compOutputs><compOutput><uid v="1584687262"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///gradient_axial_reflected?dependency=1584652945"/><parameters/><outputBridgings><outputBridging><uid v="1584687262"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687263"/><GUILayout><gpos v="-3664 1424 0"/></GUILayout><compOutputs><compOutput><uid v="1584687264"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///gradient_circular?dependency=1584653012"/><parameters/><outputBridgings><outputBridging><uid v="1584687264"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687265"/><GUILayout><gpos v="-3664 1552 0"/></GUILayout><compOutputs><compOutput><uid v="1584687266"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///gradient_linear_1?dependency=1584653053"/><parameters/><outputBridgings><outputBridging><uid v="1584687266"/><identifier v="Simple_Gradient"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687267"/><GUILayout><gpos v="-3664 1680 0"/></GUILayout><compOutputs><compOutput><uid v="1584687268"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///gradient_linear_2?dependency=1584653087"/><parameters/><outputBridgings><outputBridging><uid v="1584687268"/><identifier v="Simple_Gradient_2"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687269"/><GUILayout><gpos v="-3664 1808 0"/></GUILayout><compOutputs><compOutput><uid v="1584687270"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///gradient_linear_3?dependency=1584653134"/><parameters/><outputBridgings><outputBridging><uid v="1584687270"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687271"/><GUILayout><gpos v="-3664 1936 0"/></GUILayout><compOutputs><compOutput><uid v="1584687272"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///gradient_radial?dependency=1584653155"/><parameters/><outputBridgings><outputBridging><uid v="1584687272"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687273"/><GUILayout><gpos v="-3664 2064 0"/></GUILayout><compOutputs><compOutput><uid v="1584687274"/><comptype v="2"/></compOutput><compOutput><uid v="1584687275"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///height_extrude?dependency=1349526162"/><parameters/><outputBridgings><outputBridging><uid v="1584687274"/><identifier v="depth"/></outputBridging><outputBridging><uid v="1584687275"/><identifier v="normal"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687276"/><GUILayout><gpos v="-3664 2192 0"/></GUILayout><compOutputs><compOutput><uid v="1584687277"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///mesh_1?dependency=1584665017"/><parameters/><outputBridgings><outputBridging><uid v="1584687277"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687279"/><GUILayout><gpos v="-3664 2320 0"/></GUILayout><compOutputs><compOutput><uid v="1584687280"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///mesh_2?dependency=1584665098"/><parameters/><outputBridgings><outputBridging><uid v="1584687280"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687281"/><GUILayout><gpos v="-3664 2448 0"/></GUILayout><compOutputs><compOutput><uid v="1584687282"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///panorama_shape?dependency=1358902059"/><parameters/><outputBridgings><outputBridging><uid v="1584687282"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687283"/><GUILayout><gpos v="-3664 2576 0"/></GUILayout><compOutputs><compOutput><uid v="1584687284"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///polygon_1?dependency=1584666596"/><parameters/><outputBridgings><outputBridging><uid v="1584687284"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687285"/><GUILayout><gpos v="-3664 2704 0"/></GUILayout><compOutputs><compOutput><uid v="1584687286"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///polygon_2?dependency=1357227353"/><parameters/><outputBridgings><outputBridging><uid v="1584687286"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687287"/><GUILayout><gpos v="-3664 2832 0"/></GUILayout><compOutputs><compOutput><uid v="1584687288"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///scratches_generator?dependency=1301400394"/><parameters/><outputBridgings><outputBridging><uid v="1584687288"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687289"/><GUILayout><gpos v="-3664 2960 0"/></GUILayout><compOutputs><compOutput><uid v="1584687290"/><comptype v="1"/></compOutput><compOutput><uid v="1584687291"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///scratches_generator_normal?dependency=1301400394"/><parameters/><outputBridgings><outputBridging><uid v="1584687290"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584687291"/><identifier v="mask"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687292"/><GUILayout><gpos v="-3664 3088 0"/></GUILayout><compOutputs><compOutput><uid v="1584687293"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///shape?dependency=1311189026"/><parameters/><outputBridgings><outputBridging><uid v="1584687293"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687294"/><GUILayout><gpos v="-3664 3216 0"/></GUILayout><compOutputs><compOutput><uid v="1584687295"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///shape_extrude_2?dependency=1324885430"/><parameters/><outputBridgings><outputBridging><uid v="1584687295"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687296"/><GUILayout><gpos v="-3664 3344 0"/></GUILayout><compOutputs><compOutput><uid v="1584687297"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///shape_mapper?dependency=1280489006"/><parameters/><outputBridgings><outputBridging><uid v="1584687297"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687298"/><GUILayout><gpos v="-3664 3472 0"/></GUILayout><compOutputs><compOutput><uid v="1584687299"/><comptype v="2"/></compOutput><compOutput><uid v="1584687300"/><comptype v="1"/></compOutput><compOutput><uid v="1584687301"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///shape_splatter?dependency=1508371125"/><parameters/><outputBridgings><outputBridging><uid v="1584687299"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584687300"/><identifier v="splatter_data_1"/></outputBridging><outputBridging><uid v="1584687301"/><identifier v="splatter_data_2"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687302"/><GUILayout><gpos v="-3664 3717.33325 0"/></GUILayout><compOutputs><compOutput><uid v="1584687303"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///shape_splatter_blend?dependency=1508371125"/><parameters/><outputBridgings><outputBridging><uid v="1584687303"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687304"/><GUILayout><gpos v="-3664 3877.33325 0"/></GUILayout><compOutputs><compOutput><uid v="1584687305"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///shape_splatter_blend_color?dependency=1508371125"/><parameters/><outputBridgings><outputBridging><uid v="1584687305"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687306"/><GUILayout><gpos v="-3664 4058.66675 0"/></GUILayout><compOutputs><compOutput><uid v="1584687307"/><comptype v="1"/></compOutput><compOutput><uid v="1584687308"/><comptype v="1"/></compOutput><compOutput><uid v="1584687309"/><comptype v="1"/></compOutput><compOutput><uid v="1584687310"/><comptype v="1"/></compOutput><compOutput><uid v="1584687311"/><comptype v="1"/></compOutput><compOutput><uid v="1584687312"/><comptype v="2"/></compOutput><compOutput><uid v="1584687313"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///shape_splatter_data_extract?dependency=1508371125"/><parameters/><outputBridgings><outputBridging><uid v="1584687307"/><identifier v="position"/></outputBridging><outputBridging><uid v="1584687308"/><identifier v="uv_shape_space"/></outputBridging><outputBridging><uid v="1584687309"/><identifier v="uv_texture_space"/></outputBridging><outputBridging><uid v="1584687310"/><identifier v="bounding_box_size"/></outputBridging><outputBridging><uid v="1584687311"/><identifier v="shape_index"/></outputBridging><outputBridging><uid v="1584687312"/><identifier v="pattern_id"/></outputBridging><outputBridging><uid v="1584687313"/><identifier v="shape_angle"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687314"/><GUILayout><gpos v="-3664 4272 0"/></GUILayout><compOutputs><compOutput><uid v="1584687315"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///shape_splatter_to_mask?dependency=1508371125"/><parameters/><outputBridgings><outputBridging><uid v="1584687315"/><identifier v="position"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687316"/><GUILayout><gpos v="-3664 4400 0"/></GUILayout><compOutputs><compOutput><uid v="1584687317"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///splatter?dependency=1584671756"/><parameters/><outputBridgings><outputBridging><uid v="1584687317"/><identifier v="Splatter_Grayscale"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687318"/><GUILayout><gpos v="-3664 4528 0"/></GUILayout><compOutputs><compOutput><uid v="1584687319"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///splatter_circular?dependency=1584671933"/><parameters/><outputBridgings><outputBridging><uid v="1584687319"/><identifier v="Splatter_Circular"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687320"/><GUILayout><gpos v="-3664 4656 0"/></GUILayout><compOutputs><compOutput><uid v="1584687321"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///splatter_circular_color?dependency=1584671933"/><parameters/><outputBridgings><outputBridging><uid v="1584687321"/><identifier v="Splatter_Circular"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687322"/><GUILayout><gpos v="-3664 4784 0"/></GUILayout><compOutputs><compOutput><uid v="1584687323"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///splatter_color?dependency=1584673176"/><parameters/><outputBridgings><outputBridging><uid v="1584687323"/><identifier v="Splatter"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687324"/><GUILayout><gpos v="-3664 4912 0"/></GUILayout><compOutputs><compOutput><uid v="1584687325"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///star?dependency=1584673379"/><parameters/><outputBridgings><outputBridging><uid v="1584687325"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687326"/><GUILayout><gpos v="-3664 5040 0"/></GUILayout><compOutputs><compOutput><uid v="1584687327"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///starburst?dependency=1584673434"/><parameters/><outputBridgings><outputBridging><uid v="1584687327"/><identifier v="Starburst"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687328"/><GUILayout><gpos v="-3664 5168 0"/></GUILayout><compOutputs><compOutput><uid v="1584687329"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///stripes?dependency=1584673498"/><parameters/><outputBridgings><outputBridging><uid v="1584687329"/><identifier v="Stripes"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687330"/><GUILayout><gpos v="-3664 5296 0"/></GUILayout><compOutputs><compOutput><uid v="1584687331"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///tile_generator?dependency=1386931028"/><parameters/><outputBridgings><outputBridging><uid v="1584687331"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687332"/><GUILayout><gpos v="-3664 5424 0"/></GUILayout><compOutputs><compOutput><uid v="1584687333"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///tile_generator_color?dependency=1386931028"/><parameters/><outputBridgings><outputBridging><uid v="1584687333"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687334"/><GUILayout><gpos v="-3664 5552 0"/></GUILayout><compOutputs><compOutput><uid v="1584687335"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///tile_random?dependency=1508386588"/><parameters/><outputBridgings><outputBridging><uid v="1584687335"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687336"/><GUILayout><gpos v="-3664 5669.3335 0"/></GUILayout><compOutputs><compOutput><uid v="1584687337"/><comptype v="2"/></compOutput><compOutput><uid v="1584687338"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///tile_random_2?dependency=1439203372"/><parameters/><outputBridgings><outputBridging><uid v="1584687337"/><identifier v="output"/></outputBridging><outputBridging><uid v="1584687338"/><identifier v="flood_fill_data1"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687339"/><GUILayout><gpos v="-3664 5840 0"/></GUILayout><compOutputs><compOutput><uid v="1584687340"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///tile_random_color?dependency=1508386588"/><parameters/><outputBridgings><outputBridging><uid v="1584687340"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687341"/><GUILayout><gpos v="-3664 5968 0"/></GUILayout><compOutputs><compOutput><uid v="1584687342"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///tile_sampler?dependency=1584681877"/><parameters/><outputBridgings><outputBridging><uid v="1584687342"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687343"/><GUILayout><gpos v="-3664 6224 0"/></GUILayout><compOutputs><compOutput><uid v="1584687344"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///tile_sampler_color?dependency=1584681877"/><parameters/><outputBridgings><outputBridging><uid v="1584687344"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687345"/><GUILayout><gpos v="-3664 6480 0"/></GUILayout><compOutputs><compOutput><uid v="1584687346"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///triangle_grid_color?dependency=1440702706"/><parameters/><outputBridgings><outputBridging><uid v="1584687346"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687347"/><GUILayout><gpos v="-3664 6608 0"/></GUILayout><compOutputs><compOutput><uid v="1584687348"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///triangle_grid_grayscale?dependency=1440702706"/><parameters/><outputBridgings><outputBridging><uid v="1584687348"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687349"/><GUILayout><gpos v="-3664 6736 0"/></GUILayout><compOutputs><compOutput><uid v="1584687350"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///weave_1?dependency=1584685657"/><parameters/><outputBridgings><outputBridging><uid v="1584687350"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687351"/><GUILayout><gpos v="-3664 6864 0"/></GUILayout><compOutputs><compOutput><uid v="1584687352"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///weave_2?dependency=1584685737"/><parameters/><outputBridgings><outputBridging><uid v="1584687352"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687353"/><GUILayout><gpos v="-3664 7002.6665 0"/></GUILayout><compOutputs><compOutput><uid v="1584687354"/><comptype v="2"/></compOutput><compOutput><uid v="1584687355"/><comptype v="2"/></compOutput><compOutput><uid v="1584687356"/><comptype v="2"/></compOutput><compOutput><uid v="1584687357"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///weave_generator?dependency=1584685870"/><parameters/><outputBridgings><outputBridging><uid v="1584687354"/><identifier v="Height"/></outputBridging><outputBridging><uid v="1584687355"/><identifier v="Opacity"/></outputBridging><outputBridging><uid v="1584687356"/><identifier v="Mask_1"/></outputBridging><outputBridging><uid v="1584687357"/><identifier v="Mask_2"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687442"/><GUILayout><gpos v="-3376 -656 0"/></GUILayout><compOutputs><compOutput><uid v="1584687443"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///acescg_to_linear_srgb?dependency=1584633171"/><parameters/><outputBridgings><outputBridging><uid v="1584687443"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584687453"/><GUILayout><gpos v="-3376 -528 0"/></GUILayout><compOutputs><compOutput><uid v="1584687454"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///acescg_to_srgb?dependency=1584633171"/><parameters/><outputBridgings><outputBridging><uid v="1584687454"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584688012"/><GUILayout><gpos v="-3376 -400 0"/></GUILayout><compOutputs><compOutput><uid v="1584688013"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///apply_color_palette?dependency=1512837926"/><parameters/><outputBridgings><outputBridging><uid v="1584688013"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584688014"/><GUILayout><gpos v="-3376 -272 0"/></GUILayout><compOutputs><compOutput><uid v="1584688015"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///auto_levels?dependency=1345231453"/><parameters/><outputBridgings><outputBridging><uid v="1584688015"/><identifier v="Output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584688654"/><GUILayout><gpos v="-3376 -144 0"/></GUILayout><compOutputs><compOutput><uid v="1584688655"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///channel_mixer?dependency=1584688016"/><parameters/><outputBridgings><outputBridging><uid v="1584688655"/><identifier v="Output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584688662"/><GUILayout><gpos v="-3376 -16 0"/></GUILayout><compOutputs><compOutput><uid v="1584688663"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///chrominance_extract?dependency=1584688656"/><parameters/><outputBridgings><outputBridging><uid v="1584688663"/><identifier v="Chrominance_Extract"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584688692"/><GUILayout><gpos v="-3376 112 0"/></GUILayout><compOutputs><compOutput><uid v="1584688693"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///clamp?dependency=1584688664"/><parameters/><outputBridgings><outputBridging><uid v="1584688693"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584688699"/><GUILayout><gpos v="-3376 240 0"/></GUILayout><compOutputs><compOutput><uid v="1584688700"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///clamp_grayscale?dependency=1584688664"/><parameters/><outputBridgings><outputBridging><uid v="1584688700"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584688832"/><GUILayout><gpos v="-3376 368 0"/></GUILayout><compOutputs><compOutput><uid v="1584688833"/><comptype v="1"/></compOutput><compOutput><uid v="1584688834"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///color_match?dependency=1584688701"/><parameters/><outputBridgings><outputBridging><uid v="1584688833"/><identifier v="output"/></outputBridging><outputBridging><uid v="1584688834"/><identifier v="mask"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584688896"/><GUILayout><gpos v="-3376 496 0"/></GUILayout><compOutputs><compOutput><uid v="1584688897"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///color_to_mask?dependency=1584688835"/><parameters/><outputBridgings><outputBridging><uid v="1584688897"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584688958"/><GUILayout><gpos v="-3376 624 0"/></GUILayout><compOutputs><compOutput><uid v="1584688959"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///contrast_luminosity?dependency=1344255853"/><parameters/><outputBridgings><outputBridging><uid v="1584688959"/><identifier v="Contrast_Luminosity"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584688960"/><GUILayout><gpos v="-3376 752 0"/></GUILayout><compOutputs><compOutput><uid v="1584688961"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///contrast_luminosity_grayscale?dependency=1344255853"/><parameters/><outputBridgings><outputBridging><uid v="1584688961"/><identifier v="Contrast_Luminosity"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584689070"/><GUILayout><gpos v="-3376 880 0"/></GUILayout><compOutputs><compOutput><uid v="1584689071"/><comptype v="1"/></compOutput><compOutput><uid v="1584689072"/><comptype v="16"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///create_color_palette_16colors?dependency=1512837926"/><parameters/><outputBridgings><outputBridging><uid v="1584689071"/><identifier v="palette"/></outputBridging><outputBridging><uid v="1584689072"/><identifier v="palette_color_amount"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584689076"/><GUILayout><gpos v="-3376 1008 0"/></GUILayout><compOutputs><compOutput><uid v="1584689077"/><comptype v="512"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///get_size_color?dependency=1584689073"/><parameters/><outputBridgings><outputBridging><uid v="1584689077"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584689080"/><GUILayout><gpos v="-3376 1136 0"/></GUILayout><compOutputs><compOutput><uid v="1584689081"/><comptype v="512"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///get_size_grayscale?dependency=1584689073"/><parameters/><outputBridgings><outputBridging><uid v="1584689081"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584689106"/><GUILayout><gpos v="-3376 1264 0"/></GUILayout><compOutputs><compOutput><uid v="1584689107"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///grayscale_conversion_advanced?dependency=1584689082"/><parameters/><outputBridgings><outputBridging><uid v="1584689107"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584689156"/><GUILayout><gpos v="-3376 1392 0"/></GUILayout><compOutputs><compOutput><uid v="1584689157"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///hald_clut?dependency=1584689108"/><parameters/><outputBridgings><outputBridging><uid v="1584689157"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584689201"/><GUILayout><gpos v="-3376 1520 0"/></GUILayout><compOutputs><compOutput><uid v="1584689202"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///hdr_range_viewer?dependency=1584689158"/><parameters/><outputBridgings><outputBridging><uid v="1584689202"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584689231"/><GUILayout><gpos v="-3376 1648 0"/></GUILayout><compOutputs><compOutput><uid v="1584689232"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///hdr_range_viewer_grayscale?dependency=1584689158"/><parameters/><outputBridgings><outputBridging><uid v="1584689232"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584689244"/><GUILayout><gpos v="-3376 1776 0"/></GUILayout><compOutputs><compOutput><uid v="1584689245"/><comptype v="2"/></compOutput><compOutput><uid v="1584689246"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///height_map_frequencies_mapper?dependency=1584689233"/><parameters/><outputBridgings><outputBridging><uid v="1584689245"/><identifier v="Displacement"/></outputBridging><outputBridging><uid v="1584689246"/><identifier v="Relief_Parallax"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584689253"/><GUILayout><gpos v="-3376 1904 0"/></GUILayout><compOutputs><compOutput><uid v="1584689254"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///highpass?dependency=1584689247"/><parameters/><outputBridgings><outputBridging><uid v="1584689254"/><identifier v="Highpass"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584689260"/><GUILayout><gpos v="-3376 2032 0"/></GUILayout><compOutputs><compOutput><uid v="1584689261"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///highpass_grayscale?dependency=1584689247"/><parameters/><outputBridgings><outputBridging><uid v="1584689261"/><identifier v="Highpass"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584689495"/><GUILayout><gpos v="-3376 2160 0"/></GUILayout><compOutputs><compOutput><uid v="1584689496"/><comptype v="2"/></compOutput><compOutput><uid v="1584689497"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///histogram_compute?dependency=1523648409"/><parameters/><outputBridgings><outputBridging><uid v="1584689496"/><identifier v="histogram"/></outputBridging><outputBridging><uid v="1584689497"/><identifier v="cdf"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584689523"/><GUILayout><gpos v="-3376 2288 0"/></GUILayout><compOutputs><compOutput><uid v="1584689524"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///histogram_equalize?dependency=1523648409"/><parameters/><outputBridgings><outputBridging><uid v="1584689524"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584689549"/><GUILayout><gpos v="-3376 2416 0"/></GUILayout><compOutputs><compOutput><uid v="1584689550"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///histogram_range?dependency=1584689526"/><parameters/><outputBridgings><outputBridging><uid v="1584689550"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584689829"/><GUILayout><gpos v="-3376 2544 0"/></GUILayout><compOutputs><compOutput><uid v="1584689830"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///histogram_render?dependency=1523648409"/><parameters/><outputBridgings><outputBridging><uid v="1584689830"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584689831"/><GUILayout><gpos v="-3376 2672 0"/></GUILayout><compOutputs><compOutput><uid v="1584689832"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///histogram_scan?dependency=1149349207"/><parameters/><outputBridgings><outputBridging><uid v="1584689832"/><identifier v="Output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584689879"/><GUILayout><gpos v="-3376 2800 0"/></GUILayout><compOutputs><compOutput><uid v="1584689880"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///histogram_scan_non_uniform?dependency=1584689833"/><parameters/><outputBridgings><outputBridging><uid v="1584689880"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584689881"/><GUILayout><gpos v="-3376 2928 0"/></GUILayout><compOutputs><compOutput><uid v="1584689882"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///histogram_select?dependency=1434230932"/><parameters/><outputBridgings><outputBridging><uid v="1584689882"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584689911"/><GUILayout><gpos v="-3376 3056 0"/></GUILayout><compOutputs><compOutput><uid v="1584689912"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///histogram_shift?dependency=1584689883"/><parameters/><outputBridgings><outputBridging><uid v="1584689912"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584689939"/><GUILayout><gpos v="-3376 3184 0"/></GUILayout><compOutputs><compOutput><uid v="1584689940"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///id_to_mask_grayscale?dependency=1584689913"/><parameters/><outputBridgings><outputBridging><uid v="1584689940"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584689949"/><GUILayout><gpos v="-3376 3312 0"/></GUILayout><compOutputs><compOutput><uid v="1584689950"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///invert?dependency=1177447620"/><parameters/><outputBridgings><outputBridging><uid v="1584689950"/><identifier v="Invert_Color"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584689951"/><GUILayout><gpos v="-3376 3440 0"/></GUILayout><compOutputs><compOutput><uid v="1584689952"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///invert_grayscale?dependency=1177447620"/><parameters/><outputBridgings><outputBridging><uid v="1584689952"/><identifier v="Invert_Grayscale"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584689959"/><GUILayout><gpos v="-3376 3568 0"/></GUILayout><compOutputs><compOutput><uid v="1584689960"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///lighting_cancel_hf?dependency=1584689953"/><parameters/><outputBridgings><outputBridging><uid v="1584689960"/><identifier v="Lighting_Cancel_HF"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584689993"/><GUILayout><gpos v="-3376 3696 0"/></GUILayout><compOutputs><compOutput><uid v="1584689994"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///lighting_cancel_lf?dependency=1584689961"/><parameters/><outputBridgings><outputBridging><uid v="1584689994"/><identifier v="Lighting_Cancel_LF"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584690003"/><GUILayout><gpos v="-3376 3824 0"/></GUILayout><compOutputs><compOutput><uid v="1584690004"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///linear_srgb_to_acescg?dependency=1584633171"/><parameters/><outputBridgings><outputBridging><uid v="1584690004"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584690005"/><GUILayout><gpos v="-3376 3952 0"/></GUILayout><compOutputs><compOutput><uid v="1584690006"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///linear_srgb_to_srgb?dependency=1584633171"/><parameters/><outputBridgings><outputBridging><uid v="1584690006"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584690007"/><GUILayout><gpos v="-3376 4080 0"/></GUILayout><compOutputs><compOutput><uid v="1584690008"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///linear_srgb_to_srgb_grayscale?dependency=1584633171"/><parameters/><outputBridgings><outputBridging><uid v="1584690008"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584690029"/><GUILayout><gpos v="-3376 4208 0"/></GUILayout><compOutputs><compOutput><uid v="1584690030"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///luminance_highpass?dependency=1584690009"/><parameters/><outputBridgings><outputBridging><uid v="1584690030"/><identifier v="Luminance_Highpass"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584690585"/><GUILayout><gpos v="-3376 4336 0"/></GUILayout><compOutputs><compOutput><uid v="1584690586"/><comptype v="256"/></compOutput><compOutput><uid v="1584690587"/><comptype v="256"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///min_max?dependency=1584690031"/><parameters/><outputBridgings><outputBridging><uid v="1584690586"/><identifier v="min"/></outputBridging><outputBridging><uid v="1584690587"/><identifier v="max"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584690774"/><GUILayout><gpos v="-3376 4464 0"/></GUILayout><compOutputs><compOutput><uid v="1584690775"/><comptype v="1"/></compOutput><compOutput><uid v="1584690776"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///modify_color_palette?dependency=1512837926"/><parameters/><outputBridgings><outputBridging><uid v="1584690775"/><identifier v="output"/></outputBridging><outputBridging><uid v="1584690776"/><identifier v="palette"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584690805"/><GUILayout><gpos v="-3376 4592 0"/></GUILayout><compOutputs><compOutput><uid v="1584690806"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///pow?dependency=1584690777"/><parameters/><outputBridgings><outputBridging><uid v="1584690806"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584690826"/><GUILayout><gpos v="-3376 4720 0"/></GUILayout><compOutputs><compOutput><uid v="1584690827"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///pow_grayscale?dependency=1584690777"/><parameters/><outputBridgings><outputBridging><uid v="1584690827"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584690884"/><GUILayout><gpos v="-3376 4848 0"/></GUILayout><compOutputs><compOutput><uid v="1584690885"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///quantize?dependency=1584690828"/><parameters/><outputBridgings><outputBridging><uid v="1584690885"/><identifier v="Quantize"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584693593"/><GUILayout><gpos v="-3376 4954.6665 0"/></GUILayout><compOutputs><compOutput><uid v="1584693594"/><comptype v="1"/></compOutput><compOutput><uid v="1584693595"/><comptype v="2"/></compOutput><compOutput><uid v="1584693596"/><comptype v="1"/></compOutput><compOutput><uid v="1584693597"/><comptype v="16"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///quantize_color?dependency=1512837926"/><parameters/><outputBridgings><outputBridging><uid v="1584693594"/><identifier v="output"/></outputBridging><outputBridging><uid v="1584693595"/><identifier v="id"/></outputBridging><outputBridging><uid v="1584693596"/><identifier v="palette"/></outputBridging><outputBridging><uid v="1584693597"/><identifier v="palette_color_amount"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584693679"/><GUILayout><gpos v="-3376 5104 0"/></GUILayout><compOutputs><compOutput><uid v="1584693680"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///quantize_grayscale?dependency=1584693598"/><parameters/><outputBridgings><outputBridging><uid v="1584693680"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584693711"/><GUILayout><gpos v="-3376 5232 0"/></GUILayout><compOutputs><compOutput><uid v="1584693712"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///replace_color?dependency=1290776969"/><parameters/><outputBridgings><outputBridging><uid v="1584693712"/><identifier v="ToTargetColor"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584693744"/><GUILayout><gpos v="-3376 5360 0"/></GUILayout><compOutputs><compOutput><uid v="1584693745"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///replace_color_range?dependency=1290776969"/><parameters/><outputBridgings><outputBridging><uid v="1584693745"/><identifier v="ToTargetColorRange"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584693755"/><GUILayout><gpos v="-3376 5488 0"/></GUILayout><compOutputs><compOutput><uid v="1584693756"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///srgb_to_acescg?dependency=1584633171"/><parameters/><outputBridgings><outputBridging><uid v="1584693756"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584693765"/><GUILayout><gpos v="-3376 5616 0"/></GUILayout><compOutputs><compOutput><uid v="1584693766"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///srgb_to_linear_srgb?dependency=1584633171"/><parameters/><outputBridgings><outputBridging><uid v="1584693766"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584693771"/><GUILayout><gpos v="-3376 5744 0"/></GUILayout><compOutputs><compOutput><uid v="1584693772"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///srgb_to_linear_srgb_grayscale?dependency=1584633171"/><parameters/><outputBridgings><outputBridging><uid v="1584693772"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584693806"/><GUILayout><gpos v="-3376 5872 0"/></GUILayout><compOutputs><compOutput><uid v="1584693807"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///threshold?dependency=1584693773"/><parameters/><outputBridgings><outputBridging><uid v="1584693807"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584693879"/><GUILayout><gpos v="-3152 -656 0"/></GUILayout><compOutputs><compOutput><uid v="1584693880"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///color?dependency=1290776863"/><parameters/><outputBridgings><outputBridging><uid v="1584693880"/><identifier v="Color"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584693909"/><GUILayout><gpos v="-3152 -528 0"/></GUILayout><compOutputs><compOutput><uid v="1584693910"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///color_burn?dependency=1290776863"/><parameters/><outputBridgings><outputBridging><uid v="1584693910"/><identifier v="Color_Burn"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584693947"/><GUILayout><gpos v="-3152 -400 0"/></GUILayout><compOutputs><compOutput><uid v="1584693948"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///color_dodge?dependency=1290776863"/><parameters/><outputBridgings><outputBridging><uid v="1584693948"/><identifier v="Color_Dodge"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584693969"/><GUILayout><gpos v="-3152 -272 0"/></GUILayout><compOutputs><compOutput><uid v="1584693970"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///difference?dependency=1290776863"/><parameters/><outputBridgings><outputBridging><uid v="1584693970"/><identifier v="Difference"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584693987"/><GUILayout><gpos v="-3152 -144 0"/></GUILayout><compOutputs><compOutput><uid v="1584693988"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///dissolve_2?dependency=1290776863"/><parameters/><outputBridgings><outputBridging><uid v="1584693988"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584694011"/><GUILayout><gpos v="-3152 -16 0"/></GUILayout><compOutputs><compOutput><uid v="1584694012"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///linear_burn?dependency=1290776863"/><parameters/><outputBridgings><outputBridging><uid v="1584694012"/><identifier v="Linear_Burn"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584694028"/><GUILayout><gpos v="-3152 112 0"/></GUILayout><compOutputs><compOutput><uid v="1584694029"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///luminosity?dependency=1290776863"/><parameters/><outputBridgings><outputBridging><uid v="1584694029"/><identifier v="Exclusion"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584694164"/><GUILayout><gpos v="-3152 240 0"/></GUILayout><compOutputs><compOutput><uid v="1584694165"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///multi_switch?dependency=1299239600"/><parameters/><outputBridgings><outputBridging><uid v="1584694165"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584694166"/><GUILayout><gpos v="-3152 368 0"/></GUILayout><compOutputs><compOutput><uid v="1584694167"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///multi_switch_grayscale?dependency=1299239600"/><parameters/><outputBridgings><outputBridging><uid v="1584694167"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584694168"/><GUILayout><gpos v="-3152 496 0"/></GUILayout><compOutputs><compOutput><uid v="1584694169"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///switch?dependency=1299239600"/><parameters/><outputBridgings><outputBridging><uid v="1584694169"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584694170"/><GUILayout><gpos v="-3152 624 0"/></GUILayout><compOutputs><compOutput><uid v="1584694171"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///switch_grayscale?dependency=1299239600"/><parameters/><outputBridgings><outputBridging><uid v="1584694171"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584694260"/><GUILayout><gpos v="-2960 -656 0"/></GUILayout><compOutputs><compOutput><uid v="1584694261"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///anisotropic_blur?dependency=1584694204"/><parameters/><outputBridgings><outputBridging><uid v="1584694261"/><identifier v="Anisotropic_Blur"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584694317"/><GUILayout><gpos v="-2960 -528 0"/></GUILayout><compOutputs><compOutput><uid v="1584694318"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///anisotropic_blur_grayscale?dependency=1584694204"/><parameters/><outputBridgings><outputBridging><uid v="1584694318"/><identifier v="Anisotropic_Blur"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584694319"/><GUILayout><gpos v="-2960 -400 0"/></GUILayout><compOutputs><compOutput><uid v="1584694320"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///blur_hq?dependency=1296927904"/><parameters/><outputBridgings><outputBridging><uid v="1584694320"/><identifier v="Blur_HQ"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584694321"/><GUILayout><gpos v="-2960 -272 0"/></GUILayout><compOutputs><compOutput><uid v="1584694322"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///blur_hq_grayscale?dependency=1296927904"/><parameters/><outputBridgings><outputBridging><uid v="1584694322"/><identifier v="Blur_HQ"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584700340"/><GUILayout><gpos v="-2960 -144 0"/></GUILayout><compOutputs><compOutput><uid v="1584700341"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///median_filter_color?dependency=1521441579"/><parameters/><outputBridgings><outputBridging><uid v="1584700341"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584702386"/><GUILayout><gpos v="-2960 -16 0"/></GUILayout><compOutputs><compOutput><uid v="1584702387"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///median_filter_grayscale?dependency=1521441579"/><parameters/><outputBridgings><outputBridging><uid v="1584702387"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584703098"/><GUILayout><gpos v="-2960 112 0"/></GUILayout><compOutputs><compOutput><uid v="1584703099"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///mlv_color?dependency=1519504554"/><parameters/><outputBridgings><outputBridging><uid v="1584703099"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584703483"/><GUILayout><gpos v="-2960 240 0"/></GUILayout><compOutputs><compOutput><uid v="1584703484"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///mlv_grayscale?dependency=1519504554"/><parameters/><outputBridgings><outputBridging><uid v="1584703484"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584704474"/><GUILayout><gpos v="-2960 368 0"/></GUILayout><compOutputs><compOutput><uid v="1584704475"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///non_uniform_blur?dependency=1502209989"/><parameters/><outputBridgings><outputBridging><uid v="1584704475"/><identifier v="Non_Uniform_Blur"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584704476"/><GUILayout><gpos v="-2960 496 0"/></GUILayout><compOutputs><compOutput><uid v="1584704477"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///non_uniform_blur_grayscale?dependency=1502209989"/><parameters/><outputBridgings><outputBridging><uid v="1584704477"/><identifier v="Non_Uniform_Blur"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584704743"/><GUILayout><gpos v="-2960 624 0"/></GUILayout><compOutputs><compOutput><uid v="1584704744"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///radial_blur?dependency=1312483850"/><parameters/><outputBridgings><outputBridging><uid v="1584704744"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584704745"/><GUILayout><gpos v="-2960 752 0"/></GUILayout><compOutputs><compOutput><uid v="1584704746"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///radial_blur_grayscale?dependency=1312483850"/><parameters/><outputBridgings><outputBridging><uid v="1584704746"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584705376"/><GUILayout><gpos v="-2960 880 0"/></GUILayout><compOutputs><compOutput><uid v="1584705377"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///slope_blur?dependency=1149349542"/><parameters/><outputBridgings><outputBridging><uid v="1584705377"/><identifier v="Slope_Blur"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584706007"/><GUILayout><gpos v="-2960 1008 0"/></GUILayout><compOutputs><compOutput><uid v="1584706008"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///slope_blur_grayscale_2?dependency=1149349542"/><parameters/><outputBridgings><outputBridging><uid v="1584706008"/><identifier v="Slope_Blur"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584706037"/><GUILayout><gpos v="-2768 -656 0"/></GUILayout><compOutputs><compOutput><uid v="1584706038"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///premult_to_straight?dependency=1511708294"/><parameters/><outputBridgings><outputBridging><uid v="1584706038"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584706039"/><GUILayout><gpos v="-2768 -528 0"/></GUILayout><compOutputs><compOutput><uid v="1584706040"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///rgb-a_merge?dependency=1278679669"/><parameters/><outputBridgings><outputBridging><uid v="1584706040"/><identifier v="RGB-A_Merge"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584706041"/><GUILayout><gpos v="-2768 -400 0"/></GUILayout><compOutputs><compOutput><uid v="1584706042"/><comptype v="1"/></compOutput><compOutput><uid v="1584706043"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///rgb-a_split?dependency=1278965594"/><parameters/><outputBridgings><outputBridging><uid v="1584706042"/><identifier v="RGB"/></outputBridging><outputBridging><uid v="1584706043"/><identifier v="A"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584706044"/><GUILayout><gpos v="-2768 -293.333344 0"/></GUILayout><compOutputs><compOutput><uid v="1584706045"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///rgba_merge?dependency=1147283951"/><parameters/><outputBridgings><outputBridging><uid v="1584706045"/><identifier v="RGBA_Merge"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584706055"/><GUILayout><gpos v="-2768 -133.333328 0"/></GUILayout><compOutputs><compOutput><uid v="1584706056"/><comptype v="2"/></compOutput><compOutput><uid v="1584706057"/><comptype v="2"/></compOutput><compOutput><uid v="1584706058"/><comptype v="2"/></compOutput><compOutput><uid v="1584706059"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///rgba_split?dependency=1584706046"/><parameters/><outputBridgings><outputBridging><uid v="1584706056"/><identifier v="R"/></outputBridging><outputBridging><uid v="1584706057"/><identifier v="G"/></outputBridging><outputBridging><uid v="1584706058"/><identifier v="B"/></outputBridging><outputBridging><uid v="1584706059"/><identifier v="A"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584706060"/><GUILayout><gpos v="-2768 16 0"/></GUILayout><compOutputs><compOutput><uid v="1584706061"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///straight_to_premult?dependency=1511708294"/><parameters/><outputBridgings><outputBridging><uid v="1584706061"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584740945"/><GUILayout><gpos v="-2559.06445 -674.173523 0"/></GUILayout><compOutputs><compOutput><uid v="1584740946"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///3d_texture_position?dependency=1584740921"/><parameters/><outputBridgings><outputBridging><uid v="1584740946"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584748834"/><GUILayout><gpos v="-2559.06445 -546.173523 0"/></GUILayout><compOutputs><compOutput><uid v="1584748835"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///3d_texture_sdf?dependency=1441169042"/><parameters/><outputBridgings><outputBridging><uid v="1584748835"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584749868"/><GUILayout><gpos v="-2559.06445 -418.173523 0"/></GUILayout><compOutputs><compOutput><uid v="1584749869"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///3d_texture_surface_render?dependency=1441883675"/><parameters/><outputBridgings><outputBridging><uid v="1584749869"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584750340"/><GUILayout><gpos v="-2559.06445 -290.173523 0"/></GUILayout><compOutputs><compOutput><uid v="1584750341"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///3d_texture_volume_render_light?dependency=1441883675"/><parameters/><outputBridgings><outputBridging><uid v="1584750341"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584751690"/><GUILayout><gpos v="-2559.06445 -172.84021 0"/></GUILayout><compOutputs><compOutput><uid v="1584751691"/><comptype v="1"/></compOutput><compOutput><uid v="1584751692"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///anisotropic_kuwahara_color?dependency=1511719455"/><parameters/><outputBridgings><outputBridging><uid v="1584751691"/><identifier v="output"/></outputBridging><outputBridging><uid v="1584751692"/><identifier v="direction_map"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584752930"/><GUILayout><gpos v="-2559.06445 -12.8402023 0"/></GUILayout><compOutputs><compOutput><uid v="1584752931"/><comptype v="2"/></compOutput><compOutput><uid v="1584752932"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///anisotropic_kuwahara_grayscale?dependency=1511719455"/><parameters/><outputBridgings><outputBridging><uid v="1584752931"/><identifier v="output"/></outputBridging><outputBridging><uid v="1584752932"/><identifier v="direction_map"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584753071"/><GUILayout><gpos v="-2559.06445 157.826477 0"/></GUILayout><compOutputs><compOutput><uid v="1584753072"/><comptype v="2"/></compOutput><compOutput><uid v="1584753073"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///bevel?dependency=1584752933"/><parameters/><outputBridgings><outputBridging><uid v="1584753072"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584753073"/><identifier v="normal"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584753935"/><GUILayout><gpos v="-2559.06445 285.826477 0"/></GUILayout><compOutputs><compOutput><uid v="1584753936"/><comptype v="2"/></compOutput><compOutput><uid v="1584753937"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///bevel_smooth?dependency=1506716929"/><parameters/><outputBridgings><outputBridging><uid v="1584753936"/><identifier v="output"/></outputBridging><outputBridging><uid v="1584753937"/><identifier v="uv"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584754547"/><GUILayout><gpos v="-2559.06445 413.826477 0"/></GUILayout><compOutputs><compOutput><uid v="1584754548"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///cross_section?dependency=1387487152"/><parameters/><outputBridgings><outputBridging><uid v="1584754548"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584754596"/><GUILayout><gpos v="-2559.06445 541.826477 0"/></GUILayout><compOutputs><compOutput><uid v="1584754597"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///curvature?dependency=1584754549"/><parameters/><outputBridgings><outputBridging><uid v="1584754597"/><identifier v="Output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584755262"/><GUILayout><gpos v="-2559.06445 669.826477 0"/></GUILayout><compOutputs><compOutput><uid v="1584755263"/><comptype v="2"/></compOutput><compOutput><uid v="1584755264"/><comptype v="2"/></compOutput><compOutput><uid v="1584755265"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///curvature_smooth_v2?dependency=1511733208"/><parameters/><outputBridgings><outputBridging><uid v="1584755263"/><identifier v="curvature"/></outputBridging><outputBridging><uid v="1584755264"/><identifier v="convexity"/></outputBridging><outputBridging><uid v="1584755265"/><identifier v="concavity"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584755433"/><GUILayout><gpos v="-2559.06445 797.826477 0"/></GUILayout><compOutputs><compOutput><uid v="1584755434"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///curvature_sobel?dependency=1584755266"/><parameters/><outputBridgings><outputBridging><uid v="1584755434"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584755966"/><GUILayout><gpos v="-2559.06445 925.826477 0"/></GUILayout><compOutputs><compOutput><uid v="1584755967"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///diffusion_color?dependency=1428149473"/><parameters/><outputBridgings><outputBridging><uid v="1584755967"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584756313"/><GUILayout><gpos v="-2559.06445 1053.82642 0"/></GUILayout><compOutputs><compOutput><uid v="1584756314"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///diffusion_grayscale?dependency=1428149473"/><parameters/><outputBridgings><outputBridging><uid v="1584756314"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584756535"/><GUILayout><gpos v="-2559.06445 1181.82642 0"/></GUILayout><compOutputs><compOutput><uid v="1584756536"/><comptype v="2"/></compOutput><compOutput><uid v="1584756537"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///directional_distance?dependency=1584756315"/><parameters/><outputBridgings><outputBridging><uid v="1584756536"/><identifier v="output"/></outputBridging><outputBridging><uid v="1584756537"/><identifier v="uv"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584756579"/><GUILayout><gpos v="-2559.06445 1309.82642 0"/></GUILayout><compOutputs><compOutput><uid v="1584756580"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///edge_detect?dependency=1584756538"/><parameters/><outputBridgings><outputBridging><uid v="1584756580"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584756604"/><GUILayout><gpos v="-2559.06445 1437.82642 0"/></GUILayout><compOutputs><compOutput><uid v="1584756605"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///emboss_with_gloss?dependency=1584756581"/><parameters/><outputBridgings><outputBridging><uid v="1584756605"/><identifier v="Emboss_With_Gloss"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584756796"/><GUILayout><gpos v="-2559.06445 1565.82642 0"/></GUILayout><compOutputs><compOutput><uid v="1584756797"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///extend_shape_color?dependency=1584756606"/><parameters/><outputBridgings><outputBridging><uid v="1584756797"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584757009"/><GUILayout><gpos v="-2559.06445 1693.82642 0"/></GUILayout><compOutputs><compOutput><uid v="1584757010"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///extend_shape_grayscale?dependency=1584756606"/><parameters/><outputBridgings><outputBridging><uid v="1584757010"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584757618"/><GUILayout><gpos v="-2559.06445 1821.82642 0"/></GUILayout><compOutputs><compOutput><uid v="1584757619"/><comptype v="1"/></compOutput><compOutput><uid v="1584757620"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///flood_fill?dependency=1323881949"/><parameters/><outputBridgings><outputBridging><uid v="1584757619"/><identifier v="output"/></outputBridging><outputBridging><uid v="1584757620"/><identifier v="referenceMap"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584757638"/><GUILayout><gpos v="-2559.06445 1949.82642 0"/></GUILayout><compOutputs><compOutput><uid v="1584757639"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///flood_fill_to_bbox_size?dependency=1323881949"/><parameters/><outputBridgings><outputBridging><uid v="1584757639"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584757726"/><GUILayout><gpos v="-2559.06445 2077.82642 0"/></GUILayout><compOutputs><compOutput><uid v="1584757727"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///flood_fill_to_color?dependency=1323881949"/><parameters/><outputBridgings><outputBridging><uid v="1584757727"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584757829"/><GUILayout><gpos v="-2559.06445 2205.82642 0"/></GUILayout><compOutputs><compOutput><uid v="1584757830"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///flood_fill_to_gradient_2?dependency=1323881949"/><parameters/><outputBridgings><outputBridging><uid v="1584757830"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584757887"/><GUILayout><gpos v="-2559.06445 2333.82642 0"/></GUILayout><compOutputs><compOutput><uid v="1584757888"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///flood_fill_to_grayscale?dependency=1323881949"/><parameters/><outputBridgings><outputBridging><uid v="1584757888"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584757917"/><GUILayout><gpos v="-2559.06445 2461.82642 0"/></GUILayout><compOutputs><compOutput><uid v="1584757918"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///flood_fill_to_position?dependency=1323881949"/><parameters/><outputBridgings><outputBridging><uid v="1584757918"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584757957"/><GUILayout><gpos v="-2559.06445 2589.82642 0"/></GUILayout><compOutputs><compOutput><uid v="1584757958"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///flood_fill_to_random_color?dependency=1323881949"/><parameters/><outputBridgings><outputBridging><uid v="1584757958"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584757989"/><GUILayout><gpos v="-2559.06445 2717.82642 0"/></GUILayout><compOutputs><compOutput><uid v="1584757990"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///flood_fill_to_random_grayscale?dependency=1323881949"/><parameters/><outputBridgings><outputBridging><uid v="1584757990"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584758518"/><GUILayout><gpos v="-2559.06445 2867.15967 0"/></GUILayout><compOutputs><compOutput><uid v="1584758519"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///floodfill_mapper_color?dependency=1584757991"/><parameters/><outputBridgings><outputBridging><uid v="1584758519"/><identifier v="Output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584758945"/><GUILayout><gpos v="-2559.06445 3037.82642 0"/></GUILayout><compOutputs><compOutput><uid v="1584758946"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///floodfill_mapper_grayscale?dependency=1584757991"/><parameters/><outputBridgings><outputBridging><uid v="1584758946"/><identifier v="Output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584759410"/><GUILayout><gpos v="-2559.06445 3229.82642 0"/></GUILayout><compOutputs><compOutput><uid v="1584759411"/><comptype v="2"/></compOutput><compOutput><uid v="1584759412"/><comptype v="1"/></compOutput><compOutput><uid v="1584759413"/><comptype v="256"/></compOutput><compOutput><uid v="1584759414"/><comptype v="512"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///floodfill_to_index?dependency=1346333927"/><parameters/><outputBridgings><outputBridging><uid v="1584759411"/><identifier v="shape_index"/></outputBridging><outputBridging><uid v="1584759412"/><identifier v="shape_data_table"/></outputBridging><outputBridging><uid v="1584759413"/><identifier v="shape_count"/></outputBridging><outputBridging><uid v="1584759414"/><identifier v="shape_data_table_size"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584760317"/><GUILayout><gpos v="-2559.06445 3357.82642 0"/></GUILayout><compOutputs><compOutput><uid v="1584760318"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///fxaa_color?dependency=1508396744"/><parameters/><outputBridgings><outputBridging><uid v="1584760318"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584760319"/><GUILayout><gpos v="-2559.06445 3485.82642 0"/></GUILayout><compOutputs><compOutput><uid v="1584760320"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///fxaa_grayscale?dependency=1508396744"/><parameters/><outputBridgings><outputBridging><uid v="1584760320"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584760342"/><GUILayout><gpos v="-2559.06445 3613.82642 0"/></GUILayout><compOutputs><compOutput><uid v="1584760343"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///glow?dependency=1508358597"/><parameters/><outputBridgings><outputBridging><uid v="1584760343"/><identifier v="Glow"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584760349"/><GUILayout><gpos v="-2559.06445 3741.82642 0"/></GUILayout><compOutputs><compOutput><uid v="1584760350"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///glow_grayscale?dependency=1508358597"/><parameters/><outputBridgings><outputBridging><uid v="1584760350"/><identifier v="Glow"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584761889"/><GUILayout><gpos v="-2559.06445 3869.82642 0"/></GUILayout><compOutputs><compOutput><uid v="1584761890"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///hbao?dependency=1297162667"/><parameters/><outputBridgings><outputBridging><uid v="1584761890"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584762115"/><GUILayout><gpos v="-2559.06445 3997.82642 0"/></GUILayout><compOutputs><compOutput><uid v="1584762116"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///mosaic?dependency=1584761891"/><parameters/><outputBridgings><outputBridging><uid v="1584762116"/><identifier v="Mosaic"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584762340"/><GUILayout><gpos v="-2559.06445 4125.82617 0"/></GUILayout><compOutputs><compOutput><uid v="1584762341"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///mosaic_grayscale?dependency=1584761891"/><parameters/><outputBridgings><outputBridging><uid v="1584762341"/><identifier v="Mosaic"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584762458"/><GUILayout><gpos v="-2559.06445 4253.82666 0"/></GUILayout><compOutputs><compOutput><uid v="1584762459"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///multi_directional_warp_color?dependency=1584762342"/><parameters/><outputBridgings><outputBridging><uid v="1584762459"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584762575"/><GUILayout><gpos v="-2559.06445 4381.82666 0"/></GUILayout><compOutputs><compOutput><uid v="1584762576"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///multi_directional_warp_grayscale?dependency=1584762342"/><parameters/><outputBridgings><outputBridging><uid v="1584762576"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584763581"/><GUILayout><gpos v="-2559.06445 4509.82666 0"/></GUILayout><compOutputs><compOutput><uid v="1584763582"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///non_uniform_directional_warp_color?dependency=1502212841"/><parameters/><outputBridgings><outputBridging><uid v="1584763582"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584764492"/><GUILayout><gpos v="-2559.06445 4637.82666 0"/></GUILayout><compOutputs><compOutput><uid v="1584764493"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///non_uniform_directional_warp_grayscale?dependency=1502212841"/><parameters/><outputBridgings><outputBridging><uid v="1584764493"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584764517"/><GUILayout><gpos v="-2559.06445 4765.82666 0"/></GUILayout><compOutputs><compOutput><uid v="1584764518"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///reaction_diffusion?dependency=1308015868"/><parameters/><outputBridgings><outputBridging><uid v="1584764518"/><identifier v="Output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584765350"/><GUILayout><gpos v="-2559.06445 4893.82666 0"/></GUILayout><compOutputs><compOutput><uid v="1584765351"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///rt_ao?dependency=1477525485"/><parameters/><outputBridgings><outputBridging><uid v="1584765351"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584773929"/><GUILayout><gpos v="-2559.06445 5011.16016 0"/></GUILayout><compOutputs><compOutput><uid v="1584773930"/><comptype v="1"/></compOutput><compOutput><uid v="1584773931"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///rt_irradiance?dependency=1399023226"/><parameters/><outputBridgings><outputBridging><uid v="1584773930"/><identifier v="output"/></outputBridging><outputBridging><uid v="1584773931"/><identifier v="raw_irradiance"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584774678"/><GUILayout><gpos v="-2559.06445 5181.82666 0"/></GUILayout><compOutputs><compOutput><uid v="1584774679"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///rt_shadows?dependency=1455094509"/><parameters/><outputBridgings><outputBridging><uid v="1584774679"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584774692"/><GUILayout><gpos v="-2559.06445 5309.82666 0"/></GUILayout><compOutputs><compOutput><uid v="1584774693"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///shadows?dependency=1584774680"/><parameters/><outputBridgings><outputBridging><uid v="1584774693"/><identifier v="shadows"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584774745"/><GUILayout><gpos v="-2559.06445 5437.82666 0"/></GUILayout><compOutputs><compOutput><uid v="1584774746"/><comptype v="1"/></compOutput><compOutput><uid v="1584774747"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///shape_drop_shadow_color?dependency=1480609918"/><parameters/><outputBridgings><outputBridging><uid v="1584774746"/><identifier v="output"/></outputBridging><outputBridging><uid v="1584774747"/><identifier v="mask"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584774755"/><GUILayout><gpos v="-2559.06445 5565.82666 0"/></GUILayout><compOutputs><compOutput><uid v="1584774756"/><comptype v="1"/></compOutput><compOutput><uid v="1584774757"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///shape_drop_shadow_grayscale?dependency=1480609918"/><parameters/><outputBridgings><outputBridging><uid v="1584774756"/><identifier v="output"/></outputBridging><outputBridging><uid v="1584774757"/><identifier v="mask"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584774841"/><GUILayout><gpos v="-2559.06445 5693.82666 0"/></GUILayout><compOutputs><compOutput><uid v="1584774842"/><comptype v="1"/></compOutput><compOutput><uid v="1584774843"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///shape_glow_color?dependency=1290776980"/><parameters/><outputBridgings><outputBridging><uid v="1584774842"/><identifier v="output"/></outputBridging><outputBridging><uid v="1584774843"/><identifier v="mask"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584774851"/><GUILayout><gpos v="-2559.06445 5821.82666 0"/></GUILayout><compOutputs><compOutput><uid v="1584774852"/><comptype v="1"/></compOutput><compOutput><uid v="1584774853"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///shape_glow_grayscale?dependency=1290776980"/><parameters/><outputBridgings><outputBridging><uid v="1584774852"/><identifier v="output"/></outputBridging><outputBridging><uid v="1584774853"/><identifier v="mask"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584774923"/><GUILayout><gpos v="-2559.06445 5949.82666 0"/></GUILayout><compOutputs><compOutput><uid v="1584774924"/><comptype v="1"/></compOutput><compOutput><uid v="1584774925"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///shape_stroke_color?dependency=1297163167"/><parameters/><outputBridgings><outputBridging><uid v="1584774924"/><identifier v="output"/></outputBridging><outputBridging><uid v="1584774925"/><identifier v="mask"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584774933"/><GUILayout><gpos v="-2559.06445 6077.82666 0"/></GUILayout><compOutputs><compOutput><uid v="1584774934"/><comptype v="1"/></compOutput><compOutput><uid v="1584774935"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///shape_stroke_grayscale?dependency=1297163167"/><parameters/><outputBridgings><outputBridging><uid v="1584774934"/><identifier v="output"/></outputBridging><outputBridging><uid v="1584774935"/><identifier v="mask"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584775017"/><GUILayout><gpos v="-2559.06445 6205.82666 0"/></GUILayout><compOutputs><compOutput><uid v="1584775018"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///summed_area_table?dependency=1440175403"/><parameters/><outputBridgings><outputBridging><uid v="1584775018"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584775168"/><GUILayout><gpos v="-2559.06445 6333.82666 0"/></GUILayout><compOutputs><compOutput><uid v="1584775169"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///swirl?dependency=1299269942"/><parameters/><outputBridgings><outputBridging><uid v="1584775169"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584775283"/><GUILayout><gpos v="-2559.06445 6461.82666 0"/></GUILayout><compOutputs><compOutput><uid v="1584775284"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///swirl_grayscale?dependency=1299269942"/><parameters/><outputBridgings><outputBridging><uid v="1584775284"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584775384"/><GUILayout><gpos v="-2559.06445 6589.82666 0"/></GUILayout><compOutputs><compOutput><uid v="1584775385"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///uber_emboss?dependency=1584775285"/><parameters/><outputBridgings><outputBridging><uid v="1584775385"/><identifier v="Uber_Emboss"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584775522"/><GUILayout><gpos v="-2559.06445 6717.82666 0"/></GUILayout><compOutputs><compOutput><uid v="1584775523"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///vector_morph?dependency=1584775387"/><parameters/><outputBridgings><outputBridging><uid v="1584775523"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584775658"/><GUILayout><gpos v="-2559.06445 6845.82666 0"/></GUILayout><compOutputs><compOutput><uid v="1584775659"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///vector_morph_grayscale?dependency=1584775387"/><parameters/><outputBridgings><outputBridging><uid v="1584775659"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584775696"/><GUILayout><gpos v="-2559.06445 6973.82666 0"/></GUILayout><compOutputs><compOutput><uid v="1584775697"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///vector_warp?dependency=1584775660"/><parameters/><outputBridgings><outputBridging><uid v="1584775697"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584775734"/><GUILayout><gpos v="-2559.06445 7101.82666 0"/></GUILayout><compOutputs><compOutput><uid v="1584775735"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///vector_warp_grayscale?dependency=1584775660"/><parameters/><outputBridgings><outputBridging><uid v="1584775735"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584775766"/><GUILayout><gpos v="-2384 -656 0"/></GUILayout><compOutputs><compOutput><uid v="1584775767"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///facing_normal?dependency=1584775752"/><parameters/><outputBridgings><outputBridging><uid v="1584775767"/><identifier v="Facing_Normal"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584775834"/><GUILayout><gpos v="-2384 -528 0"/></GUILayout><compOutputs><compOutput><uid v="1584775835"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///height_normal_blend?dependency=1584775768"/><parameters/><outputBridgings><outputBridging><uid v="1584775835"/><identifier v="Normal"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584775945"/><GUILayout><gpos v="-2384 -400 0"/></GUILayout><compOutputs><compOutput><uid v="1584775946"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///height_to_normal_world_units_2?dependency=1584775836"/><parameters><parameter><name v="normal_format"/><relativeTo v="0"/><paramValue><constantValueInt32 v="0"/></paramValue></parameter></parameters><outputBridgings><outputBridging><uid v="1584775946"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584775971"/><GUILayout><gpos v="-2384 -272 0"/></GUILayout><compOutputs><compOutput><uid v="1584775972"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///normal_blend?dependency=1584775947"/><parameters/><outputBridgings><outputBridging><uid v="1584775972"/><identifier v="Normal_Blend"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584776093"/><GUILayout><gpos v="-2384 -144 0"/></GUILayout><compOutputs><compOutput><uid v="1584776094"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///normal_combine?dependency=1584775973"/><parameters/><outputBridgings><outputBridging><uid v="1584776094"/><identifier v="normal"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584776155"/><GUILayout><gpos v="-2384 -16 0"/></GUILayout><compOutputs><compOutput><uid v="1584776156"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///normal_intensity?dependency=1584776095"/><parameters/><outputBridgings><outputBridging><uid v="1584776156"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584776157"/><GUILayout><gpos v="-2384 112 0"/></GUILayout><compOutputs><compOutput><uid v="1584776158"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///normal_invert?dependency=1243453053"/><parameters/><outputBridgings><outputBridging><uid v="1584776158"/><identifier v="normal"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584776159"/><GUILayout><gpos v="-2384 240 0"/></GUILayout><compOutputs><compOutput><uid v="1584776160"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///normal_normalise?dependency=1190815953"/><parameters/><outputBridgings><outputBridging><uid v="1584776160"/><identifier v="Normalise"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584776271"/><GUILayout><gpos v="-2384 368 0"/></GUILayout><compOutputs><compOutput><uid v="1584776272"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///normal_sobel_2?dependency=1584776161"/><parameters/><outputBridgings><outputBridging><uid v="1584776272"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584777044"/><GUILayout><gpos v="-2384 496 0"/></GUILayout><compOutputs><compOutput><uid v="1584777045"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///normal_to_height?dependency=1584776273"/><parameters/><outputBridgings><outputBridging><uid v="1584777045"/><identifier v="height"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584777678"/><GUILayout><gpos v="-2384 624 0"/></GUILayout><compOutputs><compOutput><uid v="1584777679"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///normal_to_height_hq?dependency=1530637974"/><parameters/><outputBridgings><outputBridging><uid v="1584777679"/><identifier v="height"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584777758"/><GUILayout><gpos v="-2384 752 0"/></GUILayout><compOutputs><compOutput><uid v="1584777759"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///normal_transform?dependency=1584777680"/><parameters/><outputBridgings><outputBridging><uid v="1584777759"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584778294"/><GUILayout><gpos v="-2384 880 0"/></GUILayout><compOutputs><compOutput><uid v="1584778295"/><comptype v="1"/></compOutput><compOutput><uid v="1584778296"/><comptype v="256"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///normal_uncombine?dependency=1506777764"/><parameters/><outputBridgings><outputBridging><uid v="1584778295"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584778296"/><identifier v="guessed_intensity"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584778353"/><GUILayout><gpos v="-2384 1008 0"/></GUILayout><compOutputs><compOutput><uid v="1584778354"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///normal_vector_rotation?dependency=1584778297"/><parameters/><outputBridgings><outputBridging><uid v="1584778354"/><identifier v="Normal"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584779200"/><GUILayout><gpos v="-2384 1136 0"/></GUILayout><compOutputs><compOutput><uid v="1584779201"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///rt_bent_normal?dependency=1477526317"/><parameters/><outputBridgings><outputBridging><uid v="1584779201"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584779386"/><GUILayout><gpos v="-2160 -656 0"/></GUILayout><compOutputs><compOutput><uid v="1584779387"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///make_it_tile_patch?dependency=1584779224"/><parameters/><outputBridgings><outputBridging><uid v="1584779387"/><identifier v="Make_It_Tile_Patch"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584779555"/><GUILayout><gpos v="-2160 -528 0"/></GUILayout><compOutputs><compOutput><uid v="1584779556"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///make_it_tile_patch_grayscale?dependency=1584779388"/><parameters/><outputBridgings><outputBridging><uid v="1584779556"/><identifier v="Make_It_Tile_Patch"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584779687"/><GUILayout><gpos v="-2160 -400 0"/></GUILayout><compOutputs><compOutput><uid v="1584779688"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///make_it_tile_photo?dependency=1584779557"/><parameters/><outputBridgings><outputBridging><uid v="1584779688"/><identifier v="Make_It_Tile_Photo"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584779749"/><GUILayout><gpos v="-2160 -272 0"/></GUILayout><compOutputs><compOutput><uid v="1584779750"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///make_it_tile_photo_grayscale?dependency=1584779689"/><parameters/><outputBridgings><outputBridging><uid v="1584779750"/><identifier v="Make_It_Tile_Photo"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584779828"/><GUILayout><gpos v="-1968 -656 0"/></GUILayout><compOutputs><compOutput><uid v="1584779829"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///3d_texture_offset_color?dependency=1584779775"/><parameters/><outputBridgings><outputBridging><uid v="1584779829"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584779882"/><GUILayout><gpos v="-1968 -528 0"/></GUILayout><compOutputs><compOutput><uid v="1584779883"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///3d_texture_offset_grayscale?dependency=1584779775"/><parameters/><outputBridgings><outputBridging><uid v="1584779883"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584780032"/><GUILayout><gpos v="-1968 -400 0"/></GUILayout><compOutputs><compOutput><uid v="1584780033"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///auto_crop_color?dependency=1440705000"/><parameters/><outputBridgings><outputBridging><uid v="1584780033"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584780115"/><GUILayout><gpos v="-1968 -272 0"/></GUILayout><compOutputs><compOutput><uid v="1584780116"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///auto_crop_grayscale?dependency=1440705000"/><parameters/><outputBridgings><outputBridging><uid v="1584780116"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584780162"/><GUILayout><gpos v="-1968 -144 0"/></GUILayout><compOutputs><compOutput><uid v="1584780163"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///cartesian_to_polar?dependency=1297162060"/><parameters/><outputBridgings><outputBridging><uid v="1584780163"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584780170"/><GUILayout><gpos v="-1968 -16 0"/></GUILayout><compOutputs><compOutput><uid v="1584780171"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///cartesian_to_polar_grayscale?dependency=1297162060"/><parameters/><outputBridgings><outputBridging><uid v="1584780171"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584780179"/><GUILayout><gpos v="-1968 112 0"/></GUILayout><compOutputs><compOutput><uid v="1584780180"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///clone?dependency=1584780172"/><parameters/><outputBridgings><outputBridging><uid v="1584780180"/><identifier v="Clone"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584780272"/><GUILayout><gpos v="-1968 240 0"/></GUILayout><compOutputs><compOutput><uid v="1584780273"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///mirror?dependency=1584780181"/><parameters/><outputBridgings><outputBridging><uid v="1584780273"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584780364"/><GUILayout><gpos v="-1968 368 0"/></GUILayout><compOutputs><compOutput><uid v="1584780365"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///mirror_grayscale?dependency=1584780181"/><parameters/><outputBridgings><outputBridging><uid v="1584780365"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584780377"/><GUILayout><gpos v="-1968 496 0"/></GUILayout><compOutputs><compOutput><uid v="1584780378"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///noise_upscale_1?dependency=1584780366"/><parameters/><outputBridgings><outputBridging><uid v="1584780378"/><identifier v="Noise_ResolutionX2"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584780394"/><GUILayout><gpos v="-1968 624 0"/></GUILayout><compOutputs><compOutput><uid v="1584780395"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///noise_upscale_2?dependency=1584780379"/><parameters/><outputBridgings><outputBridging><uid v="1584780395"/><identifier v="Noise_ResolutionX2_2"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584780396"/><GUILayout><gpos v="-1968 752 0"/></GUILayout><compOutputs><compOutput><uid v="1584780397"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///noise_upscale_3?dependency=1149349407"/><parameters/><outputBridgings><outputBridging><uid v="1584780397"/><identifier v="Noise_ResolutionX2_3"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584780499"/><GUILayout><gpos v="-1968 880 0"/></GUILayout><compOutputs><compOutput><uid v="1584780500"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///non_square_transform?dependency=1584780399"/><parameters/><outputBridgings><outputBridging><uid v="1584780500"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584780600"/><GUILayout><gpos v="-1968 1008 0"/></GUILayout><compOutputs><compOutput><uid v="1584780601"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///non_square_transform_greyscale?dependency=1584780399"/><parameters/><outputBridgings><outputBridging><uid v="1584780601"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584780678"/><GUILayout><gpos v="-1968 1136 0"/></GUILayout><compOutputs><compOutput><uid v="1584780679"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///non_uniform_rotation_color?dependency=1584780602"/><parameters/><outputBridgings><outputBridging><uid v="1584780679"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584780755"/><GUILayout><gpos v="-1968 1264 0"/></GUILayout><compOutputs><compOutput><uid v="1584780756"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///non_uniform_rotation_grayscale?dependency=1584780602"/><parameters/><outputBridgings><outputBridging><uid v="1584780756"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584780761"/><GUILayout><gpos v="-1968 1392 0"/></GUILayout><compOutputs><compOutput><uid v="1584780762"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///polar_to_cartesian?dependency=1297162060"/><parameters/><outputBridgings><outputBridging><uid v="1584780762"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584780767"/><GUILayout><gpos v="-1968 1520 0"/></GUILayout><compOutputs><compOutput><uid v="1584780768"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///polar_to_cartesian_grayscale?dependency=1297162060"/><parameters/><outputBridgings><outputBridging><uid v="1584780768"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584781021"/><GUILayout><gpos v="-1968 1648 0"/></GUILayout><compOutputs><compOutput><uid v="1584781022"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///quad_transform?dependency=1302869619"/><parameters/><outputBridgings><outputBridging><uid v="1584781022"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584781136"/><GUILayout><gpos v="-1968 1776 0"/></GUILayout><compOutputs><compOutput><uid v="1584781137"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///quad_transform_grayscale?dependency=1302869619"/><parameters/><outputBridgings><outputBridging><uid v="1584781137"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584781227"/><GUILayout><gpos v="-1968 1904 0"/></GUILayout><compOutputs><compOutput><uid v="1584781228"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///safe_transform?dependency=1272498971"/><parameters/><outputBridgings><outputBridging><uid v="1584781228"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584781229"/><GUILayout><gpos v="-1968 2032 0"/></GUILayout><compOutputs><compOutput><uid v="1584781230"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///safe_transform_grayscale?dependency=1272498971"/><parameters/><outputBridgings><outputBridging><uid v="1584781230"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584781278"/><GUILayout><gpos v="-1968 2160 0"/></GUILayout><compOutputs><compOutput><uid v="1584781279"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///skew?dependency=1584781231"/><parameters/><outputBridgings><outputBridging><uid v="1584781279"/><identifier v="Skew"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584781326"/><GUILayout><gpos v="-1968 2288 0"/></GUILayout><compOutputs><compOutput><uid v="1584781327"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///skew_grayscale?dependency=1584781231"/><parameters/><outputBridgings><outputBridging><uid v="1584781327"/><identifier v="Skew"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584781414"/><GUILayout><gpos v="-1968 2416 0"/></GUILayout><compOutputs><compOutput><uid v="1584781415"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///symmetry?dependency=1584781328"/><parameters/><outputBridgings><outputBridging><uid v="1584781415"/><identifier v="Symmetry"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584781536"/><GUILayout><gpos v="-1968 2544 0"/></GUILayout><compOutputs><compOutput><uid v="1584781537"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///symmetry_slice?dependency=1584781417"/><parameters/><outputBridgings><outputBridging><uid v="1584781537"/><identifier v="Symmetry_Slice"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584781579"/><GUILayout><gpos v="-1968 2672 0"/></GUILayout><compOutputs><compOutput><uid v="1584781580"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///trapezoid_transform?dependency=1584781538"/><parameters/><outputBridgings><outputBridging><uid v="1584781580"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584781621"/><GUILayout><gpos v="-1968 2800 0"/></GUILayout><compOutputs><compOutput><uid v="1584781622"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///trapezoid_transform_grayscale?dependency=1584781538"/><parameters/><outputBridgings><outputBridging><uid v="1584781622"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584784186"/><GUILayout><gpos v="-1744 -602.666687 0"/></GUILayout><compOutputs><compOutput><uid v="1584784187"/><comptype v="1"/></compOutput><compOutput><uid v="1584784188"/><comptype v="1"/></compOutput><compOutput><uid v="1584784189"/><comptype v="1"/></compOutput><compOutput><uid v="1584784190"/><comptype v="2"/></compOutput><compOutput><uid v="1584784191"/><comptype v="2"/></compOutput><compOutput><uid v="1584784192"/><comptype v="2"/></compOutput><compOutput><uid v="1584784193"/><comptype v="2"/></compOutput><compOutput><uid v="1584784194"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///Bitmap2Material_2_Light?dependency=1584783856"/><parameters/><outputBridgings><outputBridging><uid v="1584784187"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584784188"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584784189"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584784190"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584784191"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584784192"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584784193"/><identifier v="ambient_occlusion"/></outputBridging><outputBridging><uid v="1584784194"/><identifier v="height"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584784273"/><GUILayout><gpos v="-1520 -656 0"/></GUILayout><compOutputs><compOutput><uid v="1584784274"/><comptype v="2"/></compOutput><compOutput><uid v="1584784275"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///height_blend?dependency=1584784217"/><parameters/><outputBridgings><outputBridging><uid v="1584784274"/><identifier v="blended_height"/></outputBridging><outputBridging><uid v="1584784275"/><identifier v="height_mask"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584784367"/><GUILayout><gpos v="-1520 -517.333313 0"/></GUILayout><compOutputs><compOutput><uid v="1584784368"/><comptype v="1"/></compOutput><compOutput><uid v="1584784369"/><comptype v="1"/></compOutput><compOutput><uid v="1584784370"/><comptype v="1"/></compOutput><compOutput><uid v="1584784371"/><comptype v="1"/></compOutput><compOutput><uid v="1584784372"/><comptype v="1"/></compOutput><compOutput><uid v="1584784373"/><comptype v="2"/></compOutput><compOutput><uid v="1584784374"/><comptype v="2"/></compOutput><compOutput><uid v="1584784375"/><comptype v="2"/></compOutput><compOutput><uid v="1584784376"/><comptype v="2"/></compOutput><compOutput><uid v="1584784377"/><comptype v="2"/></compOutput><compOutput><uid v="1584784378"/><comptype v="2"/></compOutput><compOutput><uid v="1584784379"/><comptype v="2"/></compOutput><compOutput><uid v="1584784380"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///material_height_blend?dependency=1584784276"/><parameters/><outputBridgings><outputBridging><uid v="1584784368"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584784369"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584784370"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584784371"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584784372"/><identifier v="emissive"/></outputBridging><outputBridging><uid v="1584784373"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584784374"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584784375"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584784376"/><identifier v="specularlevel"/></outputBridging><outputBridging><uid v="1584784377"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584784378"/><identifier v="ambientocclusion"/></outputBridging><outputBridging><uid v="1584784379"/><identifier v="opacity"/></outputBridging><outputBridging><uid v="1584784380"/><identifier v="height_mask"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584784735"/><GUILayout><gpos v="-1520 -101.333328 0"/></GUILayout><compOutputs><compOutput><uid v="1584784736"/><comptype v="1"/></compOutput><compOutput><uid v="1584784737"/><comptype v="1"/></compOutput><compOutput><uid v="1584784738"/><comptype v="1"/></compOutput><compOutput><uid v="1584784739"/><comptype v="2"/></compOutput><compOutput><uid v="1584784740"/><comptype v="2"/></compOutput><compOutput><uid v="1584784741"/><comptype v="2"/></compOutput><compOutput><uid v="1584784742"/><comptype v="2"/></compOutput><compOutput><uid v="1584784743"/><comptype v="2"/></compOutput><compOutput><uid v="1584784744"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///snow_cover?dependency=1290776934"/><parameters/><outputBridgings><outputBridging><uid v="1584784736"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584784737"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584784738"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584784739"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584784740"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584784741"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584784742"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584784743"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584784744"/><identifier v="ambient_occlusion"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584785554"/><GUILayout><gpos v="-1520 90.6666718 0"/></GUILayout><compOutputs><compOutput><uid v="1584785555"/><comptype v="1"/></compOutput><compOutput><uid v="1584785556"/><comptype v="1"/></compOutput><compOutput><uid v="1584785557"/><comptype v="1"/></compOutput><compOutput><uid v="1584785558"/><comptype v="1"/></compOutput><compOutput><uid v="1584785559"/><comptype v="2"/></compOutput><compOutput><uid v="1584785560"/><comptype v="2"/></compOutput><compOutput><uid v="1584785561"/><comptype v="2"/></compOutput><compOutput><uid v="1584785562"/><comptype v="2"/></compOutput><compOutput><uid v="1584785563"/><comptype v="2"/></compOutput><compOutput><uid v="1584785564"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///water_level?dependency=1290776935"/><parameters/><outputBridgings><outputBridging><uid v="1584785555"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584785556"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584785557"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584785558"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584785559"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584785560"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584785561"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584785562"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584785563"/><identifier v="ambient_occlusion"/></outputBridging><outputBridging><uid v="1584785564"/><identifier v="mask"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584785611"/><GUILayout><gpos v="-1296 -592 0"/></GUILayout><compOutputs><compOutput><uid v="1584785612"/><comptype v="1"/></compOutput><compOutput><uid v="1584785613"/><comptype v="1"/></compOutput><compOutput><uid v="1584785614"/><comptype v="1"/></compOutput><compOutput><uid v="1584785615"/><comptype v="1"/></compOutput><compOutput><uid v="1584785616"/><comptype v="1"/></compOutput><compOutput><uid v="1584785617"/><comptype v="2"/></compOutput><compOutput><uid v="1584785618"/><comptype v="2"/></compOutput><compOutput><uid v="1584785619"/><comptype v="2"/></compOutput><compOutput><uid v="1584785620"/><comptype v="2"/></compOutput><compOutput><uid v="1584785621"/><comptype v="2"/></compOutput><compOutput><uid v="1584785622"/><comptype v="2"/></compOutput><compOutput><uid v="1584785623"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///material_transform?dependency=1584785586"/><parameters/><outputBridgings><outputBridging><uid v="1584785612"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584785613"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584785614"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584785615"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584785616"/><identifier v="emissive"/></outputBridging><outputBridging><uid v="1584785617"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584785618"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584785619"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584785620"/><identifier v="specularlevel"/></outputBridging><outputBridging><uid v="1584785621"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584785622"/><identifier v="ambient_occlusion"/></outputBridging><outputBridging><uid v="1584785623"/><identifier v="opacity"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584785791"/><GUILayout><gpos v="-1008 -592 0"/></GUILayout><compOutputs><compOutput><uid v="1584785792"/><comptype v="1"/></compOutput><compOutput><uid v="1584785793"/><comptype v="1"/></compOutput><compOutput><uid v="1584785794"/><comptype v="1"/></compOutput><compOutput><uid v="1584785795"/><comptype v="1"/></compOutput><compOutput><uid v="1584785796"/><comptype v="1"/></compOutput><compOutput><uid v="1584785797"/><comptype v="2"/></compOutput><compOutput><uid v="1584785798"/><comptype v="2"/></compOutput><compOutput><uid v="1584785799"/><comptype v="2"/></compOutput><compOutput><uid v="1584785800"/><comptype v="2"/></compOutput><compOutput><uid v="1584785801"/><comptype v="2"/></compOutput><compOutput><uid v="1584785802"/><comptype v="2"/></compOutput><compOutput><uid v="1584785803"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///material_adjustment_blend?dependency=1584785651"/><parameters/><outputBridgings><outputBridging><uid v="1584785792"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584785793"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584785794"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584785795"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584785796"/><identifier v="emissive"/></outputBridging><outputBridging><uid v="1584785797"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584785798"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584785799"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584785800"/><identifier v="specularlevel"/></outputBridging><outputBridging><uid v="1584785801"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584785802"/><identifier v="ambientocclusion"/></outputBridging><outputBridging><uid v="1584785803"/><identifier v="opacity"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584785912"/><GUILayout><gpos v="-1008 -314.666656 0"/></GUILayout><compOutputs><compOutput><uid v="1584785913"/><comptype v="1"/></compOutput><compOutput><uid v="1584785914"/><comptype v="1"/></compOutput><compOutput><uid v="1584785915"/><comptype v="1"/></compOutput><compOutput><uid v="1584785916"/><comptype v="1"/></compOutput><compOutput><uid v="1584785917"/><comptype v="1"/></compOutput><compOutput><uid v="1584785918"/><comptype v="2"/></compOutput><compOutput><uid v="1584785919"/><comptype v="2"/></compOutput><compOutput><uid v="1584785920"/><comptype v="2"/></compOutput><compOutput><uid v="1584785921"/><comptype v="2"/></compOutput><compOutput><uid v="1584785922"/><comptype v="2"/></compOutput><compOutput><uid v="1584785923"/><comptype v="2"/></compOutput><compOutput><uid v="1584785924"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///material_blend?dependency=1290776917"/><parameters/><outputBridgings><outputBridging><uid v="1584785913"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584785914"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584785915"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584785916"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584785917"/><identifier v="emissive"/></outputBridging><outputBridging><uid v="1584785918"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584785919"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584785920"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584785921"/><identifier v="specularlevel"/></outputBridging><outputBridging><uid v="1584785922"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584785923"/><identifier v="ambientocclusion"/></outputBridging><outputBridging><uid v="1584785924"/><identifier v="opacity"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584786041"/><GUILayout><gpos v="-1008 112 0"/></GUILayout><compOutputs><compOutput><uid v="1584786042"/><comptype v="1"/></compOutput><compOutput><uid v="1584786043"/><comptype v="1"/></compOutput><compOutput><uid v="1584786044"/><comptype v="1"/></compOutput><compOutput><uid v="1584786045"/><comptype v="1"/></compOutput><compOutput><uid v="1584786046"/><comptype v="1"/></compOutput><compOutput><uid v="1584786047"/><comptype v="2"/></compOutput><compOutput><uid v="1584786048"/><comptype v="2"/></compOutput><compOutput><uid v="1584786049"/><comptype v="2"/></compOutput><compOutput><uid v="1584786050"/><comptype v="2"/></compOutput><compOutput><uid v="1584786051"/><comptype v="2"/></compOutput><compOutput><uid v="1584786052"/><comptype v="2"/></compOutput><compOutput><uid v="1584786053"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///material_color_blend?dependency=1290776918"/><parameters/><outputBridgings><outputBridging><uid v="1584786042"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584786043"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584786044"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584786045"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584786046"/><identifier v="emissive"/></outputBridging><outputBridging><uid v="1584786047"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584786048"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584786049"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584786050"/><identifier v="specularlevel"/></outputBridging><outputBridging><uid v="1584786051"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584786052"/><identifier v="ambientocclusion"/></outputBridging><outputBridging><uid v="1584786053"/><identifier v="opacity"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584786148"/><GUILayout><gpos v="-1008 346.666687 0"/></GUILayout><compOutputs><compOutput><uid v="1584786149"/><comptype v="1"/></compOutput><compOutput><uid v="1584786150"/><comptype v="1"/></compOutput><compOutput><uid v="1584786151"/><comptype v="1"/></compOutput><compOutput><uid v="1584786152"/><comptype v="1"/></compOutput><compOutput><uid v="1584786153"/><comptype v="1"/></compOutput><compOutput><uid v="1584786154"/><comptype v="2"/></compOutput><compOutput><uid v="1584786155"/><comptype v="2"/></compOutput><compOutput><uid v="1584786156"/><comptype v="2"/></compOutput><compOutput><uid v="1584786157"/><comptype v="2"/></compOutput><compOutput><uid v="1584786158"/><comptype v="2"/></compOutput><compOutput><uid v="1584786159"/><comptype v="2"/></compOutput><compOutput><uid v="1584786160"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///material_switch?dependency=1584786054"/><parameters/><outputBridgings><outputBridging><uid v="1584786149"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584786150"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584786151"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584786152"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584786153"/><identifier v="emissive"/></outputBridging><outputBridging><uid v="1584786154"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584786155"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584786156"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584786157"/><identifier v="specularlevel"/></outputBridging><outputBridging><uid v="1584786158"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584786159"/><identifier v="ambientocclusion"/></outputBridging><outputBridging><uid v="1584786160"/><identifier v="opacity"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584786933"/><GUILayout><gpos v="-1008 773.333374 0"/></GUILayout><compOutputs><compOutput><uid v="1584786934"/><comptype v="1"/></compOutput><compOutput><uid v="1584786935"/><comptype v="1"/></compOutput><compOutput><uid v="1584786936"/><comptype v="1"/></compOutput><compOutput><uid v="1584786937"/><comptype v="1"/></compOutput><compOutput><uid v="1584786938"/><comptype v="1"/></compOutput><compOutput><uid v="1584786939"/><comptype v="2"/></compOutput><compOutput><uid v="1584786940"/><comptype v="2"/></compOutput><compOutput><uid v="1584786941"/><comptype v="2"/></compOutput><compOutput><uid v="1584786942"/><comptype v="2"/></compOutput><compOutput><uid v="1584786943"/><comptype v="2"/></compOutput><compOutput><uid v="1584786944"/><comptype v="2"/></compOutput><compOutput><uid v="1584786945"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///multi_material_blend?dependency=1584786161"/><parameters/><outputBridgings><outputBridging><uid v="1584786934"/><identifier v="Diffuse"/></outputBridging><outputBridging><uid v="1584786935"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584786936"/><identifier v="Normal"/></outputBridging><outputBridging><uid v="1584786937"/><identifier v="Specular"/></outputBridging><outputBridging><uid v="1584786938"/><identifier v="Emissive"/></outputBridging><outputBridging><uid v="1584786939"/><identifier v="Glossiness"/></outputBridging><outputBridging><uid v="1584786940"/><identifier v="Roughness"/></outputBridging><outputBridging><uid v="1584786941"/><identifier v="Metallic"/></outputBridging><outputBridging><uid v="1584786942"/><identifier v="specularlevel"/></outputBridging><outputBridging><uid v="1584786943"/><identifier v="AmbientOcclusion"/></outputBridging><outputBridging><uid v="1584786944"/><identifier v="Height"/></outputBridging><outputBridging><uid v="1584786945"/><identifier v="opacity"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584787058"/><GUILayout><gpos v="-738.958801 -645.333313 0"/></GUILayout><compOutputs><compOutput><uid v="1584787059"/><comptype v="1"/></compOutput><compOutput><uid v="1584787060"/><comptype v="1"/></compOutput><compOutput><uid v="1584787061"/><comptype v="1"/></compOutput><compOutput><uid v="1584787062"/><comptype v="1"/></compOutput><compOutput><uid v="1584787063"/><comptype v="1"/></compOutput><compOutput><uid v="1584787064"/><comptype v="2"/></compOutput><compOutput><uid v="1584787065"/><comptype v="2"/></compOutput><compOutput><uid v="1584787066"/><comptype v="2"/></compOutput><compOutput><uid v="1584787067"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///basecolor_metallic_roughness_converter?dependency=1584786987"/><parameters/><outputBridgings><outputBridging><uid v="1584787059"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584787060"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584787061"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584787062"/><identifier v="speuclar_face_color"/></outputBridging><outputBridging><uid v="1584787063"/><identifier v="reflection"/></outputBridging><outputBridging><uid v="1584787064"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584787065"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584787066"/><identifier v="ior"/></outputBridging><outputBridging><uid v="1584787067"/><identifier v="f0"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584787096"/><GUILayout><gpos v="-738.958801 -496 0"/></GUILayout><compOutputs><compOutput><uid v="1584787097"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///pbr_albedo_safe_color?dependency=1584787068"/><parameters/><outputBridgings><outputBridging><uid v="1584787097"/><identifier v="input"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584787453"/><GUILayout><gpos v="-738.958801 -368 0"/></GUILayout><compOutputs><compOutput><uid v="1584787454"/><comptype v="1"/></compOutput><compOutput><uid v="1584787455"/><comptype v="1"/></compOutput><compOutput><uid v="1584787456"/><comptype v="1"/></compOutput><compOutput><uid v="1584787457"/><comptype v="1"/></compOutput><compOutput><uid v="1584787458"/><comptype v="2"/></compOutput><compOutput><uid v="1584787459"/><comptype v="2"/></compOutput><compOutput><uid v="1584787460"/><comptype v="2"/></compOutput><compOutput><uid v="1584787461"/><comptype v="2"/></compOutput><compOutput><uid v="1584787462"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///pbr_base_material?dependency=1584787098"/><parameters/><outputBridgings><outputBridging><uid v="1584787454"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584787455"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584787456"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584787457"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584787458"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584787459"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584787460"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584787461"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584787462"/><identifier v="ambientOcclusion"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584787540"/><GUILayout><gpos v="-738.958801 -175.999985 0"/></GUILayout><compOutputs><compOutput><uid v="1584787541"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///pbr_basecolor_metallic_validate_2?dependency=1584787463"/><parameters/><outputBridgings><outputBridging><uid v="1584787541"/><identifier v="baseColor"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584787624"/><GUILayout><gpos v="-738.958801 -47.9999924 0"/></GUILayout><compOutputs><compOutput><uid v="1584787625"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///pbr_dielectric_F0?dependency=1584787542"/><parameters/><outputBridgings><outputBridging><uid v="1584787625"/><identifier v="specular"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584787673"/><GUILayout><gpos v="-738.958801 80.0000153 0"/></GUILayout><compOutputs><compOutput><uid v="1584787674"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///pbr_metal_reflectance?dependency=1584787627"/><parameters/><outputBridgings><outputBridging><uid v="1584787674"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584796648"/><GUILayout><gpos v="-738.958801 229.333359 0"/></GUILayout><compOutputs><compOutput><uid v="1584796649"/><comptype v="1"/></compOutput><compOutput><uid v="1584796650"/><comptype v="1"/></compOutput><compOutput><uid v="1584796651"/><comptype v="1"/></compOutput><compOutput><uid v="1584796652"/><comptype v="1"/></compOutput><compOutput><uid v="1584796653"/><comptype v="1"/></compOutput><compOutput><uid v="1584796654"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///PBR_render?dependency=1531260237"/><parameters/><outputBridgings><outputBridging><uid v="1584796649"/><identifier v="output"/></outputBridging><outputBridging><uid v="1584796650"/><identifier v="raw_irradiance"/></outputBridging><outputBridging><uid v="1584796651"/><identifier v="raw_specular"/></outputBridging><outputBridging><uid v="1584796652"/><identifier v="normalws"/></outputBridging><outputBridging><uid v="1584796653"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584796654"/><identifier v="uv"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584796667"/><GUILayout><gpos v="-738.958801 656 0"/></GUILayout><compOutputs><compOutput><uid v="1584796668"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///PBR_render_mapping_color?dependency=1531260237"/><parameters/><outputBridgings><outputBridging><uid v="1584796668"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584796684"/><GUILayout><gpos v="-738.958801 784 0"/></GUILayout><compOutputs><compOutput><uid v="1584796685"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///PBR_render_mapping_grayscale?dependency=1531260237"/><parameters/><outputBridgings><outputBridging><uid v="1584796685"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584796821"/><GUILayout><gpos v="-400 -624 0"/></GUILayout><compOutputs><compOutput><uid v="1584796822"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///ao_cancel?dependency=1584796795"/><parameters/><outputBridgings><outputBridging><uid v="1584796822"/><identifier v="color"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584799214"/><GUILayout><gpos v="-400 -496 0"/></GUILayout><compOutputs><compOutput><uid v="1584799215"/><comptype v="1"/></compOutput><compOutput><uid v="1584799216"/><comptype v="1"/></compOutput><compOutput><uid v="1584799217"/><comptype v="2"/></compOutput><compOutput><uid v="1584799218"/><comptype v="2"/></compOutput><compOutput><uid v="1584799219"/><comptype v="2"/></compOutput><compOutput><uid v="1584799220"/><comptype v="256"/></compOutput><compOutput><uid v="1584799221"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///atlas_scatter?dependency=1365665603"/><parameters/><outputBridgings><outputBridging><uid v="1584799215"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584799216"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584799217"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584799218"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584799219"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584799220"/><identifier v="shape_count"/></outputBridging><outputBridging><uid v="1584799221"/><identifier v="mask"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584799684"/><GUILayout><gpos v="-400 -37.3333321 0"/></GUILayout><compOutputs><compOutput><uid v="1584799685"/><comptype v="1"/></compOutput><compOutput><uid v="1584799686"/><comptype v="1"/></compOutput><compOutput><uid v="1584799687"/><comptype v="2"/></compOutput><compOutput><uid v="1584799688"/><comptype v="2"/></compOutput><compOutput><uid v="1584799689"/><comptype v="2"/></compOutput><compOutput><uid v="1584799690"/><comptype v="2"/></compOutput><compOutput><uid v="1584799691"/><comptype v="256"/></compOutput><compOutput><uid v="1584799692"/><comptype v="2"/></compOutput><compOutput><uid v="1584799693"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///atlas_spliter?dependency=1481279116"/><parameters/><outputBridgings><outputBridging><uid v="1584799685"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584799686"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584799687"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584799688"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584799689"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584799690"/><identifier v="opacity"/></outputBridging><outputBridging><uid v="1584799691"/><identifier v="shape_count"/></outputBridging><outputBridging><uid v="1584799692"/><identifier v="user1"/></outputBridging><outputBridging><uid v="1584799693"/><identifier v="user2"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584801517"/><GUILayout><gpos v="-400 176 0"/></GUILayout><compOutputs><compOutput><uid v="1584801518"/><comptype v="1"/></compOutput><compOutput><uid v="1584801519"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///clone_patch?dependency=1508366894"/><parameters/><outputBridgings><outputBridging><uid v="1584801518"/><identifier v="output"/></outputBridging><outputBridging><uid v="1584801519"/><identifier v="areas"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584801805"/><GUILayout><gpos v="-400 304 0"/></GUILayout><compOutputs><compOutput><uid v="1584801806"/><comptype v="2"/></compOutput><compOutput><uid v="1584801807"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///clone_patch_grayscale?dependency=1508366894"/><parameters/><outputBridgings><outputBridging><uid v="1584801806"/><identifier v="output"/></outputBridging><outputBridging><uid v="1584801807"/><identifier v="areas"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584802007"/><GUILayout><gpos v="-400 432 0"/></GUILayout><compOutputs><compOutput><uid v="1584802008"/><comptype v="1"/></compOutput><compOutput><uid v="1584802009"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///color_equalizer?dependency=1508369033"/><parameters/><outputBridgings><outputBridging><uid v="1584802008"/><identifier v="output"/></outputBridging><outputBridging><uid v="1584802009"/><identifier v="mask"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584802178"/><GUILayout><gpos v="-400 560 0"/></GUILayout><compOutputs><compOutput><uid v="1584802179"/><comptype v="1"/></compOutput><compOutput><uid v="1584802180"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///crop?dependency=1280723759"/><parameters/><outputBridgings><outputBridging><uid v="1584802179"/><identifier v="output"/></outputBridging><outputBridging><uid v="1584802180"/><identifier v="area"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584802301"/><GUILayout><gpos v="-400 688 0"/></GUILayout><compOutputs><compOutput><uid v="1584802302"/><comptype v="2"/></compOutput><compOutput><uid v="1584802303"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///crop_grayscale?dependency=1280723759"/><parameters/><outputBridgings><outputBridging><uid v="1584802302"/><identifier v="output"/></outputBridging><outputBridging><uid v="1584802303"/><identifier v="area"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584802714"/><GUILayout><gpos v="-400 805.333313 0"/></GUILayout><compOutputs><compOutput><uid v="1584802715"/><comptype v="1"/></compOutput><compOutput><uid v="1584802716"/><comptype v="1"/></compOutput><compOutput><uid v="1584802717"/><comptype v="1"/></compOutput><compOutput><uid v="1584802718"/><comptype v="1"/></compOutput><compOutput><uid v="1584802719"/><comptype v="1"/></compOutput><compOutput><uid v="1584802720"/><comptype v="2"/></compOutput><compOutput><uid v="1584802721"/><comptype v="2"/></compOutput><compOutput><uid v="1584802722"/><comptype v="2"/></compOutput><compOutput><uid v="1584802723"/><comptype v="2"/></compOutput><compOutput><uid v="1584802724"/><comptype v="2"/></compOutput><compOutput><uid v="1584802725"/><comptype v="2"/></compOutput><compOutput><uid v="1584802726"/><comptype v="2"/></compOutput><compOutput><uid v="1584802727"/><comptype v="2"/></compOutput><compOutput><uid v="1584802728"/><comptype v="2"/></compOutput><compOutput><uid v="1584802729"/><comptype v="2"/></compOutput><compOutput><uid v="1584802730"/><comptype v="1"/></compOutput><compOutput><uid v="1584802731"/><comptype v="1"/></compOutput><compOutput><uid v="1584802732"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///material_clone_patch?dependency=1508366894"/><parameters/><outputBridgings><outputBridging><uid v="1584802715"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584802716"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584802717"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584802718"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584802719"/><identifier v="emissive"/></outputBridging><outputBridging><uid v="1584802720"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584802721"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584802722"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584802723"/><identifier v="specular_level"/></outputBridging><outputBridging><uid v="1584802724"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584802725"/><identifier v="ambient_occlusion"/></outputBridging><outputBridging><uid v="1584802726"/><identifier v="opacity"/></outputBridging><outputBridging><uid v="1584802727"/><identifier v="anisotropy_level"/></outputBridging><outputBridging><uid v="1584802728"/><identifier v="anisotropy_angle"/></outputBridging><outputBridging><uid v="1584802729"/><identifier v="mask"/></outputBridging><outputBridging><uid v="1584802730"/><identifier v="areas_basecolor"/></outputBridging><outputBridging><uid v="1584802731"/><identifier v="areas_normal"/></outputBridging><outputBridging><uid v="1584802732"/><identifier v="areas_height"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584802772"/><GUILayout><gpos v="-400 1040 0"/></GUILayout><compOutputs><compOutput><uid v="1584802773"/><comptype v="1"/></compOutput><compOutput><uid v="1584802774"/><comptype v="1"/></compOutput><compOutput><uid v="1584802775"/><comptype v="1"/></compOutput><compOutput><uid v="1584802776"/><comptype v="1"/></compOutput><compOutput><uid v="1584802777"/><comptype v="1"/></compOutput><compOutput><uid v="1584802778"/><comptype v="2"/></compOutput><compOutput><uid v="1584802779"/><comptype v="2"/></compOutput><compOutput><uid v="1584802780"/><comptype v="2"/></compOutput><compOutput><uid v="1584802781"/><comptype v="2"/></compOutput><compOutput><uid v="1584802782"/><comptype v="2"/></compOutput><compOutput><uid v="1584802783"/><comptype v="2"/></compOutput><compOutput><uid v="1584802784"/><comptype v="2"/></compOutput><compOutput><uid v="1584802785"/><comptype v="2"/></compOutput><compOutput><uid v="1584802786"/><comptype v="2"/></compOutput><compOutput><uid v="1584802787"/><comptype v="2"/></compOutput><compOutput><uid v="1584802788"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///material_crop?dependency=1280723759"/><parameters/><outputBridgings><outputBridging><uid v="1584802773"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584802774"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584802775"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584802776"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584802777"/><identifier v="emissive"/></outputBridging><outputBridging><uid v="1584802778"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584802779"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584802780"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584802781"/><identifier v="specular_level"/></outputBridging><outputBridging><uid v="1584802782"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584802783"/><identifier v="ambient_occlusion"/></outputBridging><outputBridging><uid v="1584802784"/><identifier v="opacity"/></outputBridging><outputBridging><uid v="1584802785"/><identifier v="anisotropy_level"/></outputBridging><outputBridging><uid v="1584802786"/><identifier v="anisotropy_angle"/></outputBridging><outputBridging><uid v="1584802787"/><identifier v="mask"/></outputBridging><outputBridging><uid v="1584802788"/><identifier v="area"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584802806"/><GUILayout><gpos v="-400 1232 0"/></GUILayout><compOutputs><compOutput><uid v="1584802807"/><comptype v="1"/></compOutput><compOutput><uid v="1584802808"/><comptype v="1"/></compOutput><compOutput><uid v="1584802809"/><comptype v="1"/></compOutput><compOutput><uid v="1584802810"/><comptype v="1"/></compOutput><compOutput><uid v="1584802811"/><comptype v="1"/></compOutput><compOutput><uid v="1584802812"/><comptype v="1"/></compOutput><compOutput><uid v="1584802813"/><comptype v="1"/></compOutput><compOutput><uid v="1584802814"/><comptype v="1"/></compOutput><compOutput><uid v="1584802815"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///multi_clone_patch?dependency=1508366894"/><parameters/><outputBridgings><outputBridging><uid v="1584802807"/><identifier v="output_1"/></outputBridging><outputBridging><uid v="1584802808"/><identifier v="output_2"/></outputBridging><outputBridging><uid v="1584802809"/><identifier v="output_3"/></outputBridging><outputBridging><uid v="1584802810"/><identifier v="output_4"/></outputBridging><outputBridging><uid v="1584802811"/><identifier v="output_5"/></outputBridging><outputBridging><uid v="1584802812"/><identifier v="output_6"/></outputBridging><outputBridging><uid v="1584802813"/><identifier v="output_7"/></outputBridging><outputBridging><uid v="1584802814"/><identifier v="output_8"/></outputBridging><outputBridging><uid v="1584802815"/><identifier v="areas"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584802833"/><GUILayout><gpos v="-400 1360 0"/></GUILayout><compOutputs><compOutput><uid v="1584802834"/><comptype v="2"/></compOutput><compOutput><uid v="1584802835"/><comptype v="2"/></compOutput><compOutput><uid v="1584802836"/><comptype v="2"/></compOutput><compOutput><uid v="1584802837"/><comptype v="2"/></compOutput><compOutput><uid v="1584802838"/><comptype v="2"/></compOutput><compOutput><uid v="1584802839"/><comptype v="2"/></compOutput><compOutput><uid v="1584802840"/><comptype v="2"/></compOutput><compOutput><uid v="1584802841"/><comptype v="2"/></compOutput><compOutput><uid v="1584802842"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///multi_clone_patch_grayscale?dependency=1508366894"/><parameters/><outputBridgings><outputBridging><uid v="1584802834"/><identifier v="output_1"/></outputBridging><outputBridging><uid v="1584802835"/><identifier v="output_2"/></outputBridging><outputBridging><uid v="1584802836"/><identifier v="output_3"/></outputBridging><outputBridging><uid v="1584802837"/><identifier v="output_4"/></outputBridging><outputBridging><uid v="1584802838"/><identifier v="output_5"/></outputBridging><outputBridging><uid v="1584802839"/><identifier v="output_6"/></outputBridging><outputBridging><uid v="1584802840"/><identifier v="output_7"/></outputBridging><outputBridging><uid v="1584802841"/><identifier v="output_8"/></outputBridging><outputBridging><uid v="1584802842"/><identifier v="areas"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584802867"/><GUILayout><gpos v="-400 1488 0"/></GUILayout><compOutputs><compOutput><uid v="1584802868"/><comptype v="1"/></compOutput><compOutput><uid v="1584802869"/><comptype v="1"/></compOutput><compOutput><uid v="1584802870"/><comptype v="1"/></compOutput><compOutput><uid v="1584802871"/><comptype v="1"/></compOutput><compOutput><uid v="1584802872"/><comptype v="1"/></compOutput><compOutput><uid v="1584802873"/><comptype v="1"/></compOutput><compOutput><uid v="1584802874"/><comptype v="1"/></compOutput><compOutput><uid v="1584802875"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///multi_color_equalizer?dependency=1508369033"/><parameters/><outputBridgings><outputBridging><uid v="1584802868"/><identifier v="output_1"/></outputBridging><outputBridging><uid v="1584802869"/><identifier v="output_2"/></outputBridging><outputBridging><uid v="1584802870"/><identifier v="output_3"/></outputBridging><outputBridging><uid v="1584802871"/><identifier v="output_4"/></outputBridging><outputBridging><uid v="1584802872"/><identifier v="output_5"/></outputBridging><outputBridging><uid v="1584802873"/><identifier v="output_6"/></outputBridging><outputBridging><uid v="1584802874"/><identifier v="output_7"/></outputBridging><outputBridging><uid v="1584802875"/><identifier v="output_8"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584802893"/><GUILayout><gpos v="-400 1616 0"/></GUILayout><compOutputs><compOutput><uid v="1584802894"/><comptype v="1"/></compOutput><compOutput><uid v="1584802895"/><comptype v="1"/></compOutput><compOutput><uid v="1584802896"/><comptype v="1"/></compOutput><compOutput><uid v="1584802897"/><comptype v="1"/></compOutput><compOutput><uid v="1584802898"/><comptype v="1"/></compOutput><compOutput><uid v="1584802899"/><comptype v="1"/></compOutput><compOutput><uid v="1584802900"/><comptype v="1"/></compOutput><compOutput><uid v="1584802901"/><comptype v="1"/></compOutput><compOutput><uid v="1584802902"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///multi_crop?dependency=1280723759"/><parameters/><outputBridgings><outputBridging><uid v="1584802894"/><identifier v="output_1"/></outputBridging><outputBridging><uid v="1584802895"/><identifier v="output_2"/></outputBridging><outputBridging><uid v="1584802896"/><identifier v="output_3"/></outputBridging><outputBridging><uid v="1584802897"/><identifier v="output_4"/></outputBridging><outputBridging><uid v="1584802898"/><identifier v="output_5"/></outputBridging><outputBridging><uid v="1584802899"/><identifier v="output_6"/></outputBridging><outputBridging><uid v="1584802900"/><identifier v="output_7"/></outputBridging><outputBridging><uid v="1584802901"/><identifier v="output_8"/></outputBridging><outputBridging><uid v="1584802902"/><identifier v="area"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584802920"/><GUILayout><gpos v="-400 1744 0"/></GUILayout><compOutputs><compOutput><uid v="1584802921"/><comptype v="2"/></compOutput><compOutput><uid v="1584802922"/><comptype v="2"/></compOutput><compOutput><uid v="1584802923"/><comptype v="2"/></compOutput><compOutput><uid v="1584802924"/><comptype v="2"/></compOutput><compOutput><uid v="1584802925"/><comptype v="2"/></compOutput><compOutput><uid v="1584802926"/><comptype v="2"/></compOutput><compOutput><uid v="1584802927"/><comptype v="2"/></compOutput><compOutput><uid v="1584802928"/><comptype v="2"/></compOutput><compOutput><uid v="1584802929"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///multi_crop_grayscale?dependency=1280723759"/><parameters/><outputBridgings><outputBridging><uid v="1584802921"/><identifier v="output_1"/></outputBridging><outputBridging><uid v="1584802922"/><identifier v="output_2"/></outputBridging><outputBridging><uid v="1584802923"/><identifier v="output_3"/></outputBridging><outputBridging><uid v="1584802924"/><identifier v="output_4"/></outputBridging><outputBridging><uid v="1584802925"/><identifier v="output_5"/></outputBridging><outputBridging><uid v="1584802926"/><identifier v="output_6"/></outputBridging><outputBridging><uid v="1584802927"/><identifier v="output_7"/></outputBridging><outputBridging><uid v="1584802928"/><identifier v="output_8"/></outputBridging><outputBridging><uid v="1584802929"/><identifier v="area"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584803173"/><GUILayout><gpos v="-400 1872 0"/></GUILayout><compOutputs><compOutput><uid v="1584803174"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///multiangle_to_albedo?dependency=1584802931"/><parameters/><outputBridgings><outputBridging><uid v="1584803174"/><identifier v="albedo"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584803920"/><GUILayout><gpos v="-400 2000 0"/></GUILayout><compOutputs><compOutput><uid v="1584803921"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///multiangle_to_normal?dependency=1508376227"/><parameters/><outputBridgings><outputBridging><uid v="1584803921"/><identifier v="normal"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584804064"/><GUILayout><gpos v="-400 2138.66675 0"/></GUILayout><compOutputs><compOutput><uid v="1584804065"/><comptype v="1"/></compOutput><compOutput><uid v="1584804066"/><comptype v="1"/></compOutput><compOutput><uid v="1584804067"/><comptype v="2"/></compOutput><compOutput><uid v="1584804068"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///smart_auto_tile?dependency=1366339147"/><parameters/><outputBridgings><outputBridging><uid v="1584804065"/><identifier v="baseColor"/></outputBridging><outputBridging><uid v="1584804066"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584804067"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584804068"/><identifier v="pattern"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584804124"/><GUILayout><gpos v="-16 -656 0"/></GUILayout><compOutputs><compOutput><uid v="1584804125"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///mg_bottom_to_top?dependency=1584804111"/><parameters/><outputBridgings><outputBridging><uid v="1584804125"/><identifier v="mask"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584804143"/><GUILayout><gpos v="-16 -528 0"/></GUILayout><compOutputs><compOutput><uid v="1584804144"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///mg_cloth_wear?dependency=1584804126"/><parameters/><outputBridgings><outputBridging><uid v="1584804144"/><identifier v="mask"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584805295"/><GUILayout><gpos v="-16 -410.666656 0"/></GUILayout><compOutputs><compOutput><uid v="1584805296"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///mg_dirt?dependency=1584804145"/><parameters/><outputBridgings><outputBridging><uid v="1584805296"/><identifier v="mask"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584805525"/><GUILayout><gpos v="-16 -229.333313 0"/></GUILayout><compOutputs><compOutput><uid v="1584805526"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///mg_dripping_rust?dependency=1584805297"/><parameters/><outputBridgings><outputBridging><uid v="1584805526"/><identifier v="mask"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584806798"/><GUILayout><gpos v="-16 -80 0"/></GUILayout><compOutputs><compOutput><uid v="1584806799"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///mg_dust?dependency=1584805527"/><parameters/><outputBridgings><outputBridging><uid v="1584806799"/><identifier v="mask"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584806811"/><GUILayout><gpos v="-16 48 0"/></GUILayout><compOutputs><compOutput><uid v="1584806812"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///mg_edge_blur?dependency=1584806800"/><parameters/><outputBridgings><outputBridging><uid v="1584806812"/><identifier v="mask"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584806952"/><GUILayout><gpos v="-16 176 0"/></GUILayout><compOutputs><compOutput><uid v="1584806953"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///mg_edge_damages?dependency=1584806814"/><parameters/><outputBridgings><outputBridging><uid v="1584806953"/><identifier v="mask"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584807037"/><GUILayout><gpos v="-16 304 0"/></GUILayout><compOutputs><compOutput><uid v="1584807038"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///mg_edge_dirt?dependency=1584806954"/><parameters/><outputBridgings><outputBridging><uid v="1584807038"/><identifier v="mask"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584807214"/><GUILayout><gpos v="-16 432 0"/></GUILayout><compOutputs><compOutput><uid v="1584807215"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///mg_edge_notch?dependency=1584807039"/><parameters/><outputBridgings><outputBridging><uid v="1584807215"/><identifier v="mask"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584807237"/><GUILayout><gpos v="-16 560 0"/></GUILayout><compOutputs><compOutput><uid v="1584807238"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///mg_edge_select?dependency=1584807217"/><parameters/><outputBridgings><outputBridging><uid v="1584807238"/><identifier v="mask"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584807261"/><GUILayout><gpos v="-16 688 0"/></GUILayout><compOutputs><compOutput><uid v="1584807262"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///mg_edge_speckle?dependency=1584807239"/><parameters/><outputBridgings><outputBridging><uid v="1584807262"/><identifier v="mask"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584807336"/><GUILayout><gpos v="-16 816 0"/></GUILayout><compOutputs><compOutput><uid v="1584807337"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///mg_edge_wear?dependency=1584807263"/><parameters/><outputBridgings><outputBridging><uid v="1584807337"/><identifier v="mask"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584807384"/><GUILayout><gpos v="-16 933.333374 0"/></GUILayout><compOutputs><compOutput><uid v="1584807385"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///mg_fiber_glass_edge_wear?dependency=1290776943"/><parameters/><outputBridgings><outputBridging><uid v="1584807385"/><identifier v="mask"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584807962"/><GUILayout><gpos v="-16 1104 0"/></GUILayout><compOutputs><compOutput><uid v="1584807963"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///mg_grease?dependency=1584807386"/><parameters/><outputBridgings><outputBridging><uid v="1584807963"/><identifier v="mask"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584808041"/><GUILayout><gpos v="-16 1232 0"/></GUILayout><compOutputs><compOutput><uid v="1584808042"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///mg_ground_dirt?dependency=1584807964"/><parameters/><outputBridgings><outputBridging><uid v="1584808042"/><identifier v="mask"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584808089"/><GUILayout><gpos v="-16 1370.66663 0"/></GUILayout><compOutputs><compOutput><uid v="1584808090"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///mg_leaks?dependency=1584808043"/><parameters/><outputBridgings><outputBridging><uid v="1584808090"/><identifier v="mask"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584808118"/><GUILayout><gpos v="-16 1520 0"/></GUILayout><compOutputs><compOutput><uid v="1584808119"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///mg_leather_wear?dependency=1290776946"/><parameters/><outputBridgings><outputBridging><uid v="1584808119"/><identifier v="mask"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584808202"/><GUILayout><gpos v="-16 1648 0"/></GUILayout><compOutputs><compOutput><uid v="1584808203"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///mg_light?dependency=1297163082"/><parameters/><outputBridgings><outputBridging><uid v="1584808203"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584808863"/><GUILayout><gpos v="-16 1765.33325 0"/></GUILayout><compOutputs><compOutput><uid v="1584808864"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///mg_mask_builder_2?dependency=1584808205"/><parameters/><outputBridgings><outputBridging><uid v="1584808864"/><identifier v="diffuse"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584808913"/><GUILayout><gpos v="-16 1989.33325 0"/></GUILayout><compOutputs><compOutput><uid v="1584808914"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///mg_metal_edge_wear?dependency=1290776948"/><parameters/><outputBridgings><outputBridging><uid v="1584808914"/><identifier v="mask"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584808940"/><GUILayout><gpos v="-16 2160 0"/></GUILayout><compOutputs><compOutput><uid v="1584808941"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///mg_paint_wear?dependency=1584808915"/><parameters/><outputBridgings><outputBridging><uid v="1584808941"/><identifier v="mask"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584809008"/><GUILayout><gpos v="-16 2288 0"/></GUILayout><compOutputs><compOutput><uid v="1584809009"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///mg_selective_dirt?dependency=1584808943"/><parameters/><outputBridgings><outputBridging><uid v="1584809009"/><identifier v="mask"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584809026"/><GUILayout><gpos v="-16 2416 0"/></GUILayout><compOutputs><compOutput><uid v="1584809027"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///mg_sun_bleach?dependency=1584809010"/><parameters/><outputBridgings><outputBridging><uid v="1584809027"/><identifier v="mask"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584809068"/><GUILayout><gpos v="-16 2565.33325 0"/></GUILayout><compOutputs><compOutput><uid v="1584809069"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///mg_surface_brush?dependency=1584809028"/><parameters/><outputBridgings><outputBridging><uid v="1584809069"/><identifier v="mask"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584809651"/><GUILayout><gpos v="432 -570.666687 0"/></GUILayout><compOutputs><compOutput><uid v="1584809652"/><comptype v="1"/></compOutput><compOutput><uid v="1584809653"/><comptype v="1"/></compOutput><compOutput><uid v="1584809654"/><comptype v="1"/></compOutput><compOutput><uid v="1584809655"/><comptype v="1"/></compOutput><compOutput><uid v="1584809656"/><comptype v="2"/></compOutput><compOutput><uid v="1584809657"/><comptype v="2"/></compOutput><compOutput><uid v="1584809658"/><comptype v="2"/></compOutput><compOutput><uid v="1584809659"/><comptype v="2"/></compOutput><compOutput><uid v="1584809660"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///cracks_weathering?dependency=1584809448"/><parameters/><outputBridgings><outputBridging><uid v="1584809652"/><identifier v="Diffuse_1"/></outputBridging><outputBridging><uid v="1584809653"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584809654"/><identifier v="Normal"/></outputBridging><outputBridging><uid v="1584809655"/><identifier v="Specular"/></outputBridging><outputBridging><uid v="1584809656"/><identifier v="Glossiness"/></outputBridging><outputBridging><uid v="1584809657"/><identifier v="Roughness"/></outputBridging><outputBridging><uid v="1584809658"/><identifier v="Metallic"/></outputBridging><outputBridging><uid v="1584809659"/><identifier v="Height"/></outputBridging><outputBridging><uid v="1584809660"/><identifier v="ambient_occlusion"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584810302"/><GUILayout><gpos v="432 -282.666626 0"/></GUILayout><compOutputs><compOutput><uid v="1584810303"/><comptype v="1"/></compOutput><compOutput><uid v="1584810304"/><comptype v="1"/></compOutput><compOutput><uid v="1584810305"/><comptype v="1"/></compOutput><compOutput><uid v="1584810306"/><comptype v="1"/></compOutput><compOutput><uid v="1584810307"/><comptype v="2"/></compOutput><compOutput><uid v="1584810308"/><comptype v="2"/></compOutput><compOutput><uid v="1584810309"/><comptype v="2"/></compOutput><compOutput><uid v="1584810310"/><comptype v="2"/></compOutput><compOutput><uid v="1584810311"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///fabric_weathering?dependency=1584809662"/><parameters/><outputBridgings><outputBridging><uid v="1584810303"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584810304"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584810305"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584810306"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584810307"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584810308"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584810309"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584810310"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584810311"/><identifier v="ambient_occlusion"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584810677"/><GUILayout><gpos v="432 5.33335447 0"/></GUILayout><compOutputs><compOutput><uid v="1584810678"/><comptype v="1"/></compOutput><compOutput><uid v="1584810679"/><comptype v="1"/></compOutput><compOutput><uid v="1584810680"/><comptype v="1"/></compOutput><compOutput><uid v="1584810681"/><comptype v="1"/></compOutput><compOutput><uid v="1584810682"/><comptype v="2"/></compOutput><compOutput><uid v="1584810683"/><comptype v="2"/></compOutput><compOutput><uid v="1584810684"/><comptype v="2"/></compOutput><compOutput><uid v="1584810685"/><comptype v="2"/></compOutput><compOutput><uid v="1584810686"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///leather_weathering?dependency=1584810313"/><parameters/><outputBridgings><outputBridging><uid v="1584810678"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584810679"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584810680"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584810681"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584810682"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584810683"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584810684"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584810685"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584810686"/><identifier v="ambient_occlusion"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584811994"/><GUILayout><gpos v="432 325.333374 0"/></GUILayout><compOutputs><compOutput><uid v="1584811995"/><comptype v="1"/></compOutput><compOutput><uid v="1584811996"/><comptype v="1"/></compOutput><compOutput><uid v="1584811997"/><comptype v="1"/></compOutput><compOutput><uid v="1584811998"/><comptype v="1"/></compOutput><compOutput><uid v="1584811999"/><comptype v="2"/></compOutput><compOutput><uid v="1584812000"/><comptype v="2"/></compOutput><compOutput><uid v="1584812001"/><comptype v="2"/></compOutput><compOutput><uid v="1584812002"/><comptype v="2"/></compOutput><compOutput><uid v="1584812003"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///moss_weathering?dependency=1584810689"/><parameters/><outputBridgings><outputBridging><uid v="1584811995"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584811996"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584811997"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584811998"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584811999"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584812000"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584812001"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584812002"/><identifier v="ambient_Oolusion"/></outputBridging><outputBridging><uid v="1584812003"/><identifier v="height"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584812347"/><GUILayout><gpos v="432 613.333313 0"/></GUILayout><compOutputs><compOutput><uid v="1584812348"/><comptype v="1"/></compOutput><compOutput><uid v="1584812349"/><comptype v="1"/></compOutput><compOutput><uid v="1584812350"/><comptype v="1"/></compOutput><compOutput><uid v="1584812351"/><comptype v="1"/></compOutput><compOutput><uid v="1584812352"/><comptype v="2"/></compOutput><compOutput><uid v="1584812353"/><comptype v="2"/></compOutput><compOutput><uid v="1584812354"/><comptype v="2"/></compOutput><compOutput><uid v="1584812355"/><comptype v="2"/></compOutput><compOutput><uid v="1584812356"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///painted_metal_weathering?dependency=1584812005"/><parameters/><outputBridgings><outputBridging><uid v="1584812348"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584812349"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584812350"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584812351"/><identifier v="Specular"/></outputBridging><outputBridging><uid v="1584812352"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584812353"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584812354"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584812355"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584812356"/><identifier v="ambient_occlusion"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584812755"/><GUILayout><gpos v="432 912 0"/></GUILayout><compOutputs><compOutput><uid v="1584812756"/><comptype v="1"/></compOutput><compOutput><uid v="1584812757"/><comptype v="1"/></compOutput><compOutput><uid v="1584812758"/><comptype v="1"/></compOutput><compOutput><uid v="1584812759"/><comptype v="1"/></compOutput><compOutput><uid v="1584812760"/><comptype v="2"/></compOutput><compOutput><uid v="1584812761"/><comptype v="2"/></compOutput><compOutput><uid v="1584812762"/><comptype v="2"/></compOutput><compOutput><uid v="1584812763"/><comptype v="2"/></compOutput><compOutput><uid v="1584812764"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///rock_weathering?dependency=1584812357"/><parameters/><outputBridgings><outputBridging><uid v="1584812756"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584812757"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584812758"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584812759"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584812760"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584812761"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584812762"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584812763"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584812764"/><identifier v="ambient_occlusion"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584812976"/><GUILayout><gpos v="432 1232 0"/></GUILayout><compOutputs><compOutput><uid v="1584812977"/><comptype v="1"/></compOutput><compOutput><uid v="1584812978"/><comptype v="1"/></compOutput><compOutput><uid v="1584812979"/><comptype v="1"/></compOutput><compOutput><uid v="1584812980"/><comptype v="1"/></compOutput><compOutput><uid v="1584812981"/><comptype v="2"/></compOutput><compOutput><uid v="1584812982"/><comptype v="2"/></compOutput><compOutput><uid v="1584812983"/><comptype v="2"/></compOutput><compOutput><uid v="1584812984"/><comptype v="2"/></compOutput><compOutput><uid v="1584812985"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///rust_weathering?dependency=1584812765"/><parameters/><outputBridgings><outputBridging><uid v="1584812977"/><identifier v="Diffuse"/></outputBridging><outputBridging><uid v="1584812978"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584812979"/><identifier v="Normal"/></outputBridging><outputBridging><uid v="1584812980"/><identifier v="Specular"/></outputBridging><outputBridging><uid v="1584812981"/><identifier v="Glossiness"/></outputBridging><outputBridging><uid v="1584812982"/><identifier v="Roughness"/></outputBridging><outputBridging><uid v="1584812983"/><identifier v="Metallic"/></outputBridging><outputBridging><uid v="1584812984"/><identifier v="Height"/></outputBridging><outputBridging><uid v="1584812985"/><identifier v="ambient_occlusion"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584813989"/><GUILayout><gpos v="848 -669.778198 0"/></GUILayout><compOutputs><compOutput><uid v="1584813990"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///3d_planar_projection?dependency=1584813788"/><parameters/><outputBridgings><outputBridging><uid v="1584813990"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584814192"/><GUILayout><gpos v="848 -541.778198 0"/></GUILayout><compOutputs><compOutput><uid v="1584814193"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///3d_planar_projection_color?dependency=1584813788"/><parameters/><outputBridgings><outputBridging><uid v="1584814193"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584814314"/><GUILayout><gpos v="848 -413.778198 0"/></GUILayout><compOutputs><compOutput><uid v="1584814315"/><comptype v="1"/></compOutput><compOutput><uid v="1584814316"/><comptype v="1"/></compOutput><compOutput><uid v="1584814317"/><comptype v="1"/></compOutput><compOutput><uid v="1584814318"/><comptype v="1"/></compOutput><compOutput><uid v="1584814319"/><comptype v="2"/></compOutput><compOutput><uid v="1584814320"/><comptype v="2"/></compOutput><compOutput><uid v="1584814321"/><comptype v="2"/></compOutput><compOutput><uid v="1584814322"/><comptype v="2"/></compOutput><compOutput><uid v="1584814323"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///material_mesh_data_blender?dependency=1584814194"/><parameters/><outputBridgings><outputBridging><uid v="1584814315"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584814316"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584814317"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584814318"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584814319"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584814320"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584814321"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584814322"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584814323"/><identifier v="ambient_occlusion"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584814437"/><GUILayout><gpos v="848 -29.778204 0"/></GUILayout><compOutputs><compOutput><uid v="1584814438"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///material_selector?dependency=1290776921"/><parameters/><outputBridgings><outputBridging><uid v="1584814438"/><identifier v="mask"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584814451"/><GUILayout><gpos v="848 76.8884506 0"/></GUILayout><compOutputs><compOutput><uid v="1584814452"/><comptype v="2"/></compOutput><compOutput><uid v="1584814453"/><comptype v="2"/></compOutput><compOutput><uid v="1584814454"/><comptype v="2"/></compOutput><compOutput><uid v="1584814455"/><comptype v="2"/></compOutput><compOutput><uid v="1584814456"/><comptype v="2"/></compOutput><compOutput><uid v="1584814457"/><comptype v="1"/></compOutput><compOutput><uid v="1584814458"/><comptype v="1"/></compOutput><compOutput><uid v="1584814459"/><comptype v="1"/></compOutput><compOutput><uid v="1584814460"/><comptype v="1"/></compOutput><compOutput><uid v="1584814461"/><comptype v="1"/></compOutput><compOutput><uid v="1584814462"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///mesh_data_combiner?dependency=1584814439"/><parameters/><outputBridgings><outputBridging><uid v="1584814452"/><identifier v="ambient_occlusion"/></outputBridging><outputBridging><uid v="1584814453"/><identifier v="curvature"/></outputBridging><outputBridging><uid v="1584814454"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584814455"/><identifier v="position_grayscale"/></outputBridging><outputBridging><uid v="1584814456"/><identifier v="thickness"/></outputBridging><outputBridging><uid v="1584814457"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584814458"/><identifier v="position"/></outputBridging><outputBridging><uid v="1584814459"/><identifier v="uv_masks"/></outputBridging><outputBridging><uid v="1584814460"/><identifier v="vertex_color"/></outputBridging><outputBridging><uid v="1584814461"/><identifier v="direction"/></outputBridging><outputBridging><uid v="1584814462"/><identifier v="normalWS"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584814910"/><GUILayout><gpos v="848 354.221802 0"/></GUILayout><compOutputs><compOutput><uid v="1584814911"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///triplanar_3?dependency=1290776989"/><parameters/><outputBridgings><outputBridging><uid v="1584814911"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584815344"/><GUILayout><gpos v="848 482.221802 0"/></GUILayout><compOutputs><compOutput><uid v="1584815345"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///triplanar_grayscale_3?dependency=1290776989"/><parameters/><outputBridgings><outputBridging><uid v="1584815345"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584815812"/><GUILayout><gpos v="1200 -656 0"/></GUILayout><compOutputs><compOutput><uid v="1584815813"/><comptype v="1"/></compOutput><compOutput><uid v="1584815814"/><comptype v="1"/></compOutput><compOutput><uid v="1584815815"/><comptype v="16"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///path_to_spline?dependency=1479303590"/><parameters/><outputBridgings><outputBridging><uid v="1584815813"/><identifier v="spline_coords"/></outputBridging><outputBridging><uid v="1584815814"/><identifier v="spline_data"/></outputBridging><outputBridging><uid v="1584815815"/><identifier v="spline_amount"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584818731"/><GUILayout><gpos v="1200 -528 0"/></GUILayout><compOutputs><compOutput><uid v="1584818732"/><comptype v="2"/></compOutput><compOutput><uid v="1584818733"/><comptype v="1"/></compOutput><compOutput><uid v="1584818734"/><comptype v="16"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///point_list?dependency=1526803024"/><parameters/><outputBridgings><outputBridging><uid v="1584818732"/><identifier v="preview"/></outputBridging><outputBridging><uid v="1584818733"/><identifier v="point_list"/></outputBridging><outputBridging><uid v="1584818734"/><identifier v="point_number"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584819739"/><GUILayout><gpos v="1200 -410.666656 0"/></GUILayout><compOutputs><compOutput><uid v="1584819740"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///scatter_on_spline_color?dependency=1526803024"/><parameters/><outputBridgings><outputBridging><uid v="1584819740"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584820440"/><GUILayout><gpos v="1200 -186.666656 0"/></GUILayout><compOutputs><compOutput><uid v="1584820441"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///scatter_on_spline_grayscale?dependency=1526803024"/><parameters/><outputBridgings><outputBridging><uid v="1584820441"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584821455"/><GUILayout><gpos v="1200 48 0"/></GUILayout><compOutputs><compOutput><uid v="1584821456"/><comptype v="2"/></compOutput><compOutput><uid v="1584821457"/><comptype v="1"/></compOutput><compOutput><uid v="1584821458"/><comptype v="1"/></compOutput><compOutput><uid v="1584821459"/><comptype v="16"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///scatter_splines_on_splines?dependency=1526803024"/><parameters/><outputBridgings><outputBridging><uid v="1584821456"/><identifier v="preview"/></outputBridging><outputBridging><uid v="1584821457"/><identifier v="spline_coords"/></outputBridging><outputBridging><uid v="1584821458"/><identifier v="spline_data"/></outputBridging><outputBridging><uid v="1584821459"/><identifier v="spline_amount"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584821547"/><GUILayout><gpos v="1200 314.666656 0"/></GUILayout><compOutputs><compOutput><uid v="1584821548"/><comptype v="2"/></compOutput><compOutput><uid v="1584821549"/><comptype v="1"/></compOutput><compOutput><uid v="1584821550"/><comptype v="1"/></compOutput><compOutput><uid v="1584821551"/><comptype v="16"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///spline_2dtransform?dependency=1526803024"/><parameters/><outputBridgings><outputBridging><uid v="1584821548"/><identifier v="preview"/></outputBridging><outputBridging><uid v="1584821549"/><identifier v="spline_coords"/></outputBridging><outputBridging><uid v="1584821550"/><identifier v="spline_data"/></outputBridging><outputBridging><uid v="1584821551"/><identifier v="spline_amount"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584821776"/><GUILayout><gpos v="1200 453.333313 0"/></GUILayout><compOutputs><compOutput><uid v="1584821777"/><comptype v="2"/></compOutput><compOutput><uid v="1584821778"/><comptype v="1"/></compOutput><compOutput><uid v="1584821779"/><comptype v="1"/></compOutput><compOutput><uid v="1584821780"/><comptype v="16"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///spline_append?dependency=1526803024"/><parameters/><outputBridgings><outputBridging><uid v="1584821777"/><identifier v="preview"/></outputBridging><outputBridging><uid v="1584821778"/><identifier v="spline_coords"/></outputBridging><outputBridging><uid v="1584821779"/><identifier v="spline_data"/></outputBridging><outputBridging><uid v="1584821780"/><identifier v="spline_amount"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584822105"/><GUILayout><gpos v="1200 709.333313 0"/></GUILayout><compOutputs><compOutput><uid v="1584822106"/><comptype v="2"/></compOutput><compOutput><uid v="1584822107"/><comptype v="1"/></compOutput><compOutput><uid v="1584822108"/><comptype v="1"/></compOutput><compOutput><uid v="1584822109"/><comptype v="16"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///spline_bridge_2_splines?dependency=1526803024"/><parameters/><outputBridgings><outputBridging><uid v="1584822106"/><identifier v="preview"/></outputBridging><outputBridging><uid v="1584822107"/><identifier v="spline_coords"/></outputBridging><outputBridging><uid v="1584822108"/><identifier v="spline_data"/></outputBridging><outputBridging><uid v="1584822109"/><identifier v="spline_amount"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584822922"/><GUILayout><gpos v="1200 922.666687 0"/></GUILayout><compOutputs><compOutput><uid v="1584822923"/><comptype v="2"/></compOutput><compOutput><uid v="1584822924"/><comptype v="1"/></compOutput><compOutput><uid v="1584822925"/><comptype v="1"/></compOutput><compOutput><uid v="1584822926"/><comptype v="16"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///spline_bridge_list_v2?dependency=1526803024"/><parameters/><outputBridgings><outputBridging><uid v="1584822923"/><identifier v="preview"/></outputBridging><outputBridging><uid v="1584822924"/><identifier v="spline_coords"/></outputBridging><outputBridging><uid v="1584822925"/><identifier v="spline_data"/></outputBridging><outputBridging><uid v="1584822926"/><identifier v="spline_amount"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584823413"/><GUILayout><gpos v="1200 1082.66663 0"/></GUILayout><compOutputs><compOutput><uid v="1584823414"/><comptype v="1"/></compOutput><compOutput><uid v="1584823415"/><comptype v="2"/></compOutput><compOutput><uid v="1584823416"/><comptype v="1"/></compOutput><compOutput><uid v="1584823417"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///spline_bridge_mapper_color?dependency=1526803024"/><parameters/><outputBridgings><outputBridging><uid v="1584823414"/><identifier v="color"/></outputBridging><outputBridging><uid v="1584823415"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584823416"/><identifier v="uv"/></outputBridging><outputBridging><uid v="1584823417"/><identifier v="mask"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584823451"/><GUILayout><gpos v="1200 1242.66663 0"/></GUILayout><compOutputs><compOutput><uid v="1584823452"/><comptype v="2"/></compOutput><compOutput><uid v="1584823453"/><comptype v="2"/></compOutput><compOutput><uid v="1584823454"/><comptype v="1"/></compOutput><compOutput><uid v="1584823455"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///spline_bridge_mapper_grayscale?dependency=1526803024"/><parameters/><outputBridgings><outputBridging><uid v="1584823452"/><identifier v="color"/></outputBridging><outputBridging><uid v="1584823453"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584823454"/><identifier v="uv"/></outputBridging><outputBridging><uid v="1584823455"/><identifier v="mask"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584823997"/><GUILayout><gpos v="1200 1370.66663 0"/></GUILayout><compOutputs><compOutput><uid v="1584823998"/><comptype v="2"/></compOutput><compOutput><uid v="1584823999"/><comptype v="1"/></compOutput><compOutput><uid v="1584824000"/><comptype v="1"/></compOutput><compOutput><uid v="1584824001"/><comptype v="16"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///spline_circle?dependency=1526803024"/><parameters/><outputBridgings><outputBridging><uid v="1584823998"/><identifier v="preview"/></outputBridging><outputBridging><uid v="1584823999"/><identifier v="spline_coords"/></outputBridging><outputBridging><uid v="1584824000"/><identifier v="spline_data"/></outputBridging><outputBridging><uid v="1584824001"/><identifier v="spline_amount"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584824472"/><GUILayout><gpos v="1200 1530.66663 0"/></GUILayout><compOutputs><compOutput><uid v="1584824473"/><comptype v="2"/></compOutput><compOutput><uid v="1584824474"/><comptype v="1"/></compOutput><compOutput><uid v="1584824475"/><comptype v="1"/></compOutput><compOutput><uid v="1584824476"/><comptype v="16"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///spline_cubic?dependency=1526803024"/><parameters/><outputBridgings><outputBridging><uid v="1584824473"/><identifier v="preview"/></outputBridging><outputBridging><uid v="1584824474"/><identifier v="spline_coords"/></outputBridging><outputBridging><uid v="1584824475"/><identifier v="spline_data"/></outputBridging><outputBridging><uid v="1584824476"/><identifier v="spline_amount"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584824654"/><GUILayout><gpos v="1200 1680 0"/></GUILayout><compOutputs><compOutput><uid v="1584824655"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///spline_fill?dependency=1526803024"/><parameters/><outputBridgings><outputBridging><uid v="1584824655"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584825300"/><GUILayout><gpos v="1200 1818.66663 0"/></GUILayout><compOutputs><compOutput><uid v="1584825301"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///spline_flow_mapper?dependency=1526803024"/><parameters/><outputBridgings><outputBridging><uid v="1584825301"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584825783"/><GUILayout><gpos v="1200 1968 0"/></GUILayout><compOutputs><compOutput><uid v="1584825784"/><comptype v="1"/></compOutput><compOutput><uid v="1584825785"/><comptype v="2"/></compOutput><compOutput><uid v="1584825786"/><comptype v="1"/></compOutput><compOutput><uid v="1584825787"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///spline_mapper_color?dependency=1526803024"/><parameters/><outputBridgings><outputBridging><uid v="1584825784"/><identifier v="color"/></outputBridging><outputBridging><uid v="1584825785"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584825786"/><identifier v="uv"/></outputBridging><outputBridging><uid v="1584825787"/><identifier v="id"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584825809"/><GUILayout><gpos v="1200 2160 0"/></GUILayout><compOutputs><compOutput><uid v="1584825810"/><comptype v="2"/></compOutput><compOutput><uid v="1584825811"/><comptype v="2"/></compOutput><compOutput><uid v="1584825812"/><comptype v="1"/></compOutput><compOutput><uid v="1584825813"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///spline_mapper_grayscale?dependency=1526803024"/><parameters/><outputBridgings><outputBridging><uid v="1584825810"/><identifier v="color"/></outputBridging><outputBridging><uid v="1584825811"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584825812"/><identifier v="uv"/></outputBridging><outputBridging><uid v="1584825813"/><identifier v="id"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584826243"/><GUILayout><gpos v="1200 2330.66675 0"/></GUILayout><compOutputs><compOutput><uid v="1584826244"/><comptype v="2"/></compOutput><compOutput><uid v="1584826245"/><comptype v="1"/></compOutput><compOutput><uid v="1584826246"/><comptype v="1"/></compOutput><compOutput><uid v="1584826247"/><comptype v="16"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///spline_merge_list?dependency=1526803024"/><parameters/><outputBridgings><outputBridging><uid v="1584826244"/><identifier v="preview"/></outputBridging><outputBridging><uid v="1584826245"/><identifier v="spline_coords"/></outputBridging><outputBridging><uid v="1584826246"/><identifier v="spline_data"/></outputBridging><outputBridging><uid v="1584826247"/><identifier v="spline_amount"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584826940"/><GUILayout><gpos v="1200 2490.66675 0"/></GUILayout><compOutputs><compOutput><uid v="1584826941"/><comptype v="2"/></compOutput><compOutput><uid v="1584826942"/><comptype v="1"/></compOutput><compOutput><uid v="1584826943"/><comptype v="1"/></compOutput><compOutput><uid v="1584826944"/><comptype v="16"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///spline_poly_quadratic?dependency=1526803024"/><parameters/><outputBridgings><outputBridging><uid v="1584826941"/><identifier v="preview"/></outputBridging><outputBridging><uid v="1584826942"/><identifier v="spline_coords"/></outputBridging><outputBridging><uid v="1584826943"/><identifier v="spline_data"/></outputBridging><outputBridging><uid v="1584826944"/><identifier v="spline_amount"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584827367"/><GUILayout><gpos v="1200 2650.66675 0"/></GUILayout><compOutputs><compOutput><uid v="1584827368"/><comptype v="2"/></compOutput><compOutput><uid v="1584827369"/><comptype v="1"/></compOutput><compOutput><uid v="1584827370"/><comptype v="1"/></compOutput><compOutput><uid v="1584827371"/><comptype v="16"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///spline_quadratic?dependency=1526803024"/><parameters/><outputBridgings><outputBridging><uid v="1584827368"/><identifier v="preview"/></outputBridging><outputBridging><uid v="1584827369"/><identifier v="spline_coords"/></outputBridging><outputBridging><uid v="1584827370"/><identifier v="spline_data"/></outputBridging><outputBridging><uid v="1584827371"/><identifier v="spline_amount"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584827372"/><GUILayout><gpos v="1200 2778.66675 0"/></GUILayout><compOutputs><compOutput><uid v="1584827373"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///spline_render?dependency=1526803024"/><parameters/><outputBridgings><outputBridging><uid v="1584827373"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584827453"/><GUILayout><gpos v="1200 2949.33325 0"/></GUILayout><compOutputs><compOutput><uid v="1584827454"/><comptype v="2"/></compOutput><compOutput><uid v="1584827455"/><comptype v="1"/></compOutput><compOutput><uid v="1584827456"/><comptype v="1"/></compOutput><compOutput><uid v="1584827457"/><comptype v="16"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///spline_sample_height?dependency=1526803024"/><parameters/><outputBridgings><outputBridging><uid v="1584827454"/><identifier v="preview"/></outputBridging><outputBridging><uid v="1584827455"/><identifier v="spline_coords"/></outputBridging><outputBridging><uid v="1584827456"/><identifier v="spline_data"/></outputBridging><outputBridging><uid v="1584827457"/><identifier v="spline_amount"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584827473"/><GUILayout><gpos v="1200 3109.33325 0"/></GUILayout><compOutputs><compOutput><uid v="1584827474"/><comptype v="2"/></compOutput><compOutput><uid v="1584827475"/><comptype v="1"/></compOutput><compOutput><uid v="1584827476"/><comptype v="1"/></compOutput><compOutput><uid v="1584827477"/><comptype v="16"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///spline_sample_thickness?dependency=1526803024"/><parameters/><outputBridgings><outputBridging><uid v="1584827474"/><identifier v="preview"/></outputBridging><outputBridging><uid v="1584827475"/><identifier v="spline_coords"/></outputBridging><outputBridging><uid v="1584827476"/><identifier v="spline_data"/></outputBridging><outputBridging><uid v="1584827477"/><identifier v="spline_amount"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584827603"/><GUILayout><gpos v="1200 3290.66675 0"/></GUILayout><compOutputs><compOutput><uid v="1584827604"/><comptype v="2"/></compOutput><compOutput><uid v="1584827605"/><comptype v="1"/></compOutput><compOutput><uid v="1584827606"/><comptype v="1"/></compOutput><compOutput><uid v="1584827607"/><comptype v="16"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///spline_select?dependency=1526803024"/><parameters/><outputBridgings><outputBridging><uid v="1584827604"/><identifier v="preview"/></outputBridging><outputBridging><uid v="1584827605"/><identifier v="spline_coords"/></outputBridging><outputBridging><uid v="1584827606"/><identifier v="spline_data"/></outputBridging><outputBridging><uid v="1584827607"/><identifier v="spline_amount"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584827728"/><GUILayout><gpos v="1200 3440 0"/></GUILayout><compOutputs><compOutput><uid v="1584827729"/><comptype v="2"/></compOutput><compOutput><uid v="1584827730"/><comptype v="1"/></compOutput><compOutput><uid v="1584827731"/><comptype v="1"/></compOutput><compOutput><uid v="1584827732"/><comptype v="16"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///spline_warp?dependency=1526803024"/><parameters/><outputBridgings><outputBridging><uid v="1584827729"/><identifier v="preview"/></outputBridging><outputBridging><uid v="1584827730"/><identifier v="spline_coords"/></outputBridging><outputBridging><uid v="1584827731"/><identifier v="spline_data"/></outputBridging><outputBridging><uid v="1584827732"/><identifier v="spline_amount"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584827733"/><GUILayout><gpos v="1200 3632 0"/></GUILayout><compOutputs><compOutput><uid v="1584827734"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///uv_mapper_color?dependency=1477136496"/><parameters/><outputBridgings><outputBridging><uid v="1584827734"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584827735"/><GUILayout><gpos v="1200 3760 0"/></GUILayout><compOutputs><compOutput><uid v="1584827736"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///uv_mapper_grayscale?dependency=1477136496"/><parameters/><outputBridgings><outputBridging><uid v="1584827736"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584827819"/><GUILayout><gpos v="1552 -656 0"/></GUILayout><compOutputs><compOutput><uid v="1584827820"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///2dtransform_path?dependency=1479303590"/><parameters/><outputBridgings><outputBridging><uid v="1584827820"/><identifier v="paths"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584827821"/><GUILayout><gpos v="1552 -528 0"/></GUILayout><compOutputs><compOutput><uid v="1584827822"/><comptype v="1"/></compOutput><compOutput><uid v="1584827823"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///mask_to_paths_2?dependency=1479303590"/><parameters/><outputBridgings><outputBridging><uid v="1584827822"/><identifier v="preview"/></outputBridging><outputBridging><uid v="1584827823"/><identifier v="paths"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584827824"/><GUILayout><gpos v="1552 -400 0"/></GUILayout><compOutputs><compOutput><uid v="1584827825"/><comptype v="1"/></compOutput><compOutput><uid v="1584827826"/><comptype v="1"/></compOutput><compOutput><uid v="1584827827"/><comptype v="16"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///path_to_spline?dependency=1479303590"/><parameters/><outputBridgings><outputBridging><uid v="1584827825"/><identifier v="spline_coords"/></outputBridging><outputBridging><uid v="1584827826"/><identifier v="spline_data"/></outputBridging><outputBridging><uid v="1584827827"/><identifier v="spline_amount"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584828003"/><GUILayout><gpos v="1552 -272 0"/></GUILayout><compOutputs><compOutput><uid v="1584828004"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///paths_polygon?dependency=1479303590"/><parameters/><outputBridgings><outputBridging><uid v="1584828004"/><identifier v="paths"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584828005"/><GUILayout><gpos v="1552 -144 0"/></GUILayout><compOutputs><compOutput><uid v="1584828006"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///paths_trace?dependency=1479303590"/><parameters/><outputBridgings><outputBridging><uid v="1584828006"/><identifier v="tracing"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584828155"/><GUILayout><gpos v="1552 -16 0"/></GUILayout><compOutputs><compOutput><uid v="1584828156"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///paths_warp?dependency=1479303590"/><parameters/><outputBridgings><outputBridging><uid v="1584828156"/><identifier v="paths"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584828170"/><GUILayout><gpos v="1552 112 0"/></GUILayout><compOutputs><compOutput><uid v="1584828171"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///quad_transform_path?dependency=1479303590"/><parameters/><outputBridgings><outputBridging><uid v="1584828171"/><identifier v="paths"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584828216"/><GUILayout><gpos v="1552 240 0"/></GUILayout><compOutputs><compOutput><uid v="1584828217"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///select_path?dependency=1479303590"/><parameters/><outputBridgings><outputBridging><uid v="1584828217"/><identifier v="paths"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584828350"/><GUILayout><gpos v="1552 368 0"/></GUILayout><compOutputs><compOutput><uid v="1584828351"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///vertex_processor?dependency=1479303590"/><parameters/><outputBridgings><outputBridging><uid v="1584828351"/><identifier v="paths"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584828352"/><GUILayout><gpos v="1552 496 0"/></GUILayout><compOutputs><compOutput><uid v="1584828353"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///vertex_processor_simple?dependency=1479303590"/><parameters/><outputBridgings><outputBridging><uid v="1584828353"/><identifier v="paths"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584828559"/><GUILayout><gpos v="2160 -656 0"/></GUILayout><compOutputs><compOutput><uid v="1584828560"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///blackbody?dependency=1584828554"/><parameters/><outputBridgings><outputBridging><uid v="1584828560"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584828622"/><GUILayout><gpos v="2160 -528 0"/></GUILayout><compOutputs><compOutput><uid v="1584828623"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///color_temperature_adjustment?dependency=1584828561"/><parameters/><outputBridgings><outputBridging><uid v="1584828623"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584828635"/><GUILayout><gpos v="2160 -400 0"/></GUILayout><compOutputs><compOutput><uid v="1584828636"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///exposure?dependency=1584828624"/><parameters/><outputBridgings><outputBridging><uid v="1584828636"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584828682"/><GUILayout><gpos v="2160 -272 0"/></GUILayout><compOutputs><compOutput><uid v="1584828683"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///hdr_exposure_preview?dependency=1584828638"/><parameters/><outputBridgings><outputBridging><uid v="1584828683"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584829257"/><GUILayout><gpos v="2160 -144 0"/></GUILayout><compOutputs><compOutput><uid v="1584829258"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///hdr_merge_2?dependency=1363339633"/><parameters/><outputBridgings><outputBridging><uid v="1584829258"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584829292"/><GUILayout><gpos v="2160 176 0"/></GUILayout><compOutputs><compOutput><uid v="1584829293"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///nadir_extract?dependency=1584829259"/><parameters/><outputBridgings><outputBridging><uid v="1584829293"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584829310"/><GUILayout><gpos v="2160 304 0"/></GUILayout><compOutputs><compOutput><uid v="1584829311"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///panorama_3d_position?dependency=1584829294"/><parameters/><outputBridgings><outputBridging><uid v="1584829311"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584829381"/><GUILayout><gpos v="2160 432 0"/></GUILayout><compOutputs><compOutput><uid v="1584829382"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///panorama_gradient_2_points?dependency=1584829312"/><parameters/><outputBridgings><outputBridging><uid v="1584829382"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584829404"/><GUILayout><gpos v="2160 560 0"/></GUILayout><compOutputs><compOutput><uid v="1584829405"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///panorama_gradient_linear?dependency=1584829312"/><parameters/><outputBridgings><outputBridging><uid v="1584829405"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584830014"/><GUILayout><gpos v="2160 688 0"/></GUILayout><compOutputs><compOutput><uid v="1584830015"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///panorama_line_light?dependency=1358902059"/><parameters/><outputBridgings><outputBridging><uid v="1584830015"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584830391"/><GUILayout><gpos v="2160 816 0"/></GUILayout><compOutputs><compOutput><uid v="1584830392"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///panorama_nadir_patch?dependency=1358121241"/><parameters/><outputBridgings><outputBridging><uid v="1584830392"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584830983"/><GUILayout><gpos v="2160 944 0"/></GUILayout><compOutputs><compOutput><uid v="1584830984"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///panorama_physical_sun_sky?dependency=1356796196"/><parameters/><outputBridgings><outputBridging><uid v="1584830984"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584831441"/><GUILayout><gpos v="2160 1072 0"/></GUILayout><compOutputs><compOutput><uid v="1584831442"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///panorama_plane_light?dependency=1358902059"/><parameters/><outputBridgings><outputBridging><uid v="1584831442"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584831549"/><GUILayout><gpos v="2160 1200 0"/></GUILayout><compOutputs><compOutput><uid v="1584831550"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///panorama_rotation?dependency=1584831443"/><parameters/><outputBridgings><outputBridging><uid v="1584831550"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584831847"/><GUILayout><gpos v="2160 1328 0"/></GUILayout><compOutputs><compOutput><uid v="1584831848"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///panorama_shape_2?dependency=1358902059"/><parameters/><outputBridgings><outputBridging><uid v="1584831848"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584832052"/><GUILayout><gpos v="2160 1456 0"/></GUILayout><compOutputs><compOutput><uid v="1584832053"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///panorama_sphere_light?dependency=1358902059"/><parameters/><outputBridgings><outputBridging><uid v="1584832053"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584832250"/><GUILayout><gpos v="2160 1584 0"/></GUILayout><compOutputs><compOutput><uid v="1584832251"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///panorama_straighten_horizon?dependency=1351988730"/><parameters/><outputBridgings><outputBridging><uid v="1584832251"/><identifier v="output"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584832322"/><GUILayout><gpos v="1872 -656 0"/></GUILayout><compOutputs><compOutput><uid v="1584832323"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compFilter><filter v="bitmap"/><parameters><parameter><name v="bitmapresourcepath"/><relativeTo v="0"/><paramValue><constantValueString v="pkg:///Resources/spiaggia_di_mondello_1k?dependency=1584632780"/></paramValue></parameter><parameter><name v="outputsize"/><relativeTo v="0"/><paramValue><constantValueInt2 v="11 10"/></paramValue></parameter><parameter><name v="format"/><relativeTo v="0"/><paramValue><constantValueInt32 v="3"/></paramValue></parameter></parameters></compFilter></compImplementation></compNode><compNode><uid v="1584832324"/><GUILayout><gpos v="1872 -528 0"/></GUILayout><compOutputs><compOutput><uid v="1584832325"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compFilter><filter v="bitmap"/><parameters><parameter><name v="bitmapresourcepath"/><relativeTo v="0"/><paramValue><constantValueString v="pkg:///Resources/monochrome_studio_02_1k?dependency=1584632780"/></paramValue></parameter><parameter><name v="outputsize"/><relativeTo v="0"/><paramValue><constantValueInt2 v="11 10"/></paramValue></parameter><parameter><name v="format"/><relativeTo v="0"/><paramValue><constantValueInt32 v="3"/></paramValue></parameter></parameters></compFilter></compImplementation></compNode><compNode><uid v="1584832326"/><GUILayout><gpos v="1872 -400 0"/></GUILayout><compOutputs><compOutput><uid v="1584832327"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compFilter><filter v="bitmap"/><parameters><parameter><name v="bitmapresourcepath"/><relativeTo v="0"/><paramValue><constantValueString v="pkg:///Resources/metro_noord_1k?dependency=1584632780"/></paramValue></parameter><parameter><name v="outputsize"/><relativeTo v="0"/><paramValue><constantValueInt2 v="11 10"/></paramValue></parameter><parameter><name v="format"/><relativeTo v="0"/><paramValue><constantValueInt32 v="3"/></paramValue></parameter></parameters></compFilter></compImplementation></compNode><compNode><uid v="1584832328"/><GUILayout><gpos v="1872 -272 0"/></GUILayout><compOutputs><compOutput><uid v="1584832329"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compFilter><filter v="bitmap"/><parameters><parameter><name v="bitmapresourcepath"/><relativeTo v="0"/><paramValue><constantValueString v="pkg:///Resources/brown_photostudio_02_1k?dependency=1584632780"/></paramValue></parameter><parameter><name v="outputsize"/><relativeTo v="0"/><paramValue><constantValueInt2 v="11 10"/></paramValue></parameter><parameter><name v="format"/><relativeTo v="0"/><paramValue><constantValueInt32 v="3"/></paramValue></parameter></parameters></compFilter></compImplementation></compNode><compNode><uid v="1584833851"/><GUILayout><gpos v="2416 -624 0"/></GUILayout><compOutputs><compOutput><uid v="1584833852"/><comptype v="1"/></compOutput><compOutput><uid v="1584833853"/><comptype v="1"/></compOutput><compOutput><uid v="1584833854"/><comptype v="1"/></compOutput><compOutput><uid v="1584833855"/><comptype v="1"/></compOutput><compOutput><uid v="1584833856"/><comptype v="2"/></compOutput><compOutput><uid v="1584833857"/><comptype v="2"/></compOutput><compOutput><uid v="1584833858"/><comptype v="2"/></compOutput><compOutput><uid v="1584833859"/><comptype v="2"/></compOutput><compOutput><uid v="1584833860"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///bricks_001?dependency=1584832716"/><parameters/><outputBridgings><outputBridging><uid v="1584833852"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584833853"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584833854"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584833855"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584833856"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584833857"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584833858"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584833859"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584833860"/><identifier v="ambient_occlusion"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584833861"/><GUILayout><gpos v="2416 -432 0"/></GUILayout><compOutputs><compOutput><uid v="1584833862"/><comptype v="1"/></compOutput><compOutput><uid v="1584833863"/><comptype v="1"/></compOutput><compOutput><uid v="1584833864"/><comptype v="1"/></compOutput><compOutput><uid v="1584833865"/><comptype v="1"/></compOutput><compOutput><uid v="1584833866"/><comptype v="2"/></compOutput><compOutput><uid v="1584833867"/><comptype v="2"/></compOutput><compOutput><uid v="1584833868"/><comptype v="2"/></compOutput><compOutput><uid v="1584833869"/><comptype v="2"/></compOutput><compOutput><uid v="1584833870"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///bricks_005?dependency=1584833071"/><parameters/><outputBridgings><outputBridging><uid v="1584833862"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584833863"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584833864"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584833865"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584833866"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584833867"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584833868"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584833869"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584833870"/><identifier v="ambient_occlusion"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584834378"/><GUILayout><gpos v="2416 -240 0"/></GUILayout><compOutputs><compOutput><uid v="1584834379"/><comptype v="1"/></compOutput><compOutput><uid v="1584834380"/><comptype v="1"/></compOutput><compOutput><uid v="1584834381"/><comptype v="1"/></compOutput><compOutput><uid v="1584834382"/><comptype v="1"/></compOutput><compOutput><uid v="1584834383"/><comptype v="2"/></compOutput><compOutput><uid v="1584834384"/><comptype v="2"/></compOutput><compOutput><uid v="1584834385"/><comptype v="2"/></compOutput><compOutput><uid v="1584834386"/><comptype v="2"/></compOutput><compOutput><uid v="1584834387"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///cardboard_001?dependency=1584833872"/><parameters/><outputBridgings><outputBridging><uid v="1584834379"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584834380"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584834381"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584834382"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584834383"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584834384"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584834385"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584834386"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584834387"/><identifier v="ambient_occlusion"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584835031"/><GUILayout><gpos v="2416 -48 0"/></GUILayout><compOutputs><compOutput><uid v="1584835032"/><comptype v="1"/></compOutput><compOutput><uid v="1584835033"/><comptype v="1"/></compOutput><compOutput><uid v="1584835034"/><comptype v="1"/></compOutput><compOutput><uid v="1584835035"/><comptype v="1"/></compOutput><compOutput><uid v="1584835036"/><comptype v="2"/></compOutput><compOutput><uid v="1584835037"/><comptype v="2"/></compOutput><compOutput><uid v="1584835038"/><comptype v="2"/></compOutput><compOutput><uid v="1584835039"/><comptype v="2"/></compOutput><compOutput><uid v="1584835040"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///concrete_002?dependency=1584834389"/><parameters/><outputBridgings><outputBridging><uid v="1584835032"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584835033"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584835034"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584835035"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584835036"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584835037"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584835038"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584835039"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584835040"/><identifier v="ambient_occlusion"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584835321"/><GUILayout><gpos v="2416 144 0"/></GUILayout><compOutputs><compOutput><uid v="1584835322"/><comptype v="1"/></compOutput><compOutput><uid v="1584835323"/><comptype v="1"/></compOutput><compOutput><uid v="1584835324"/><comptype v="1"/></compOutput><compOutput><uid v="1584835325"/><comptype v="1"/></compOutput><compOutput><uid v="1584835326"/><comptype v="2"/></compOutput><compOutput><uid v="1584835327"/><comptype v="2"/></compOutput><compOutput><uid v="1584835328"/><comptype v="2"/></compOutput><compOutput><uid v="1584835329"/><comptype v="2"/></compOutput><compOutput><uid v="1584835330"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///concrete_006?dependency=1584835042"/><parameters/><outputBridgings><outputBridging><uid v="1584835322"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584835323"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584835324"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584835325"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584835326"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584835327"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584835328"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584835329"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584835330"/><identifier v="ambient_occlusion"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584835647"/><GUILayout><gpos v="2416 336 0"/></GUILayout><compOutputs><compOutput><uid v="1584835648"/><comptype v="1"/></compOutput><compOutput><uid v="1584835649"/><comptype v="1"/></compOutput><compOutput><uid v="1584835650"/><comptype v="1"/></compOutput><compOutput><uid v="1584835651"/><comptype v="1"/></compOutput><compOutput><uid v="1584835652"/><comptype v="2"/></compOutput><compOutput><uid v="1584835653"/><comptype v="2"/></compOutput><compOutput><uid v="1584835654"/><comptype v="2"/></compOutput><compOutput><uid v="1584835655"/><comptype v="2"/></compOutput><compOutput><uid v="1584835656"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///concrete_010?dependency=1584835332"/><parameters/><outputBridgings><outputBridging><uid v="1584835648"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584835649"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584835650"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584835651"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584835652"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584835653"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584835654"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584835655"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584835656"/><identifier v="ambient_occlusion"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584835948"/><GUILayout><gpos v="2416 528 0"/></GUILayout><compOutputs><compOutput><uid v="1584835949"/><comptype v="1"/></compOutput><compOutput><uid v="1584835950"/><comptype v="1"/></compOutput><compOutput><uid v="1584835951"/><comptype v="1"/></compOutput><compOutput><uid v="1584835952"/><comptype v="1"/></compOutput><compOutput><uid v="1584835953"/><comptype v="2"/></compOutput><compOutput><uid v="1584835954"/><comptype v="2"/></compOutput><compOutput><uid v="1584835955"/><comptype v="2"/></compOutput><compOutput><uid v="1584835956"/><comptype v="2"/></compOutput><compOutput><uid v="1584835957"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///concrete_011?dependency=1584835658"/><parameters/><outputBridgings><outputBridging><uid v="1584835949"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584835950"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584835951"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584835952"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584835953"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584835954"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584835955"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584835956"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584835957"/><identifier v="ambient_occlusion"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584836158"/><GUILayout><gpos v="2416 720 0"/></GUILayout><compOutputs><compOutput><uid v="1584836159"/><comptype v="1"/></compOutput><compOutput><uid v="1584836160"/><comptype v="1"/></compOutput><compOutput><uid v="1584836161"/><comptype v="1"/></compOutput><compOutput><uid v="1584836162"/><comptype v="1"/></compOutput><compOutput><uid v="1584836163"/><comptype v="2"/></compOutput><compOutput><uid v="1584836164"/><comptype v="2"/></compOutput><compOutput><uid v="1584836165"/><comptype v="2"/></compOutput><compOutput><uid v="1584836166"/><comptype v="2"/></compOutput><compOutput><uid v="1584836167"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///concrete_044?dependency=1584835959"/><parameters/><outputBridgings><outputBridging><uid v="1584836159"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584836160"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584836161"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584836162"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584836163"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584836164"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584836165"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584836166"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584836167"/><identifier v="ambient_occlusion"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584836287"/><GUILayout><gpos v="2416 912 0"/></GUILayout><compOutputs><compOutput><uid v="1584836288"/><comptype v="1"/></compOutput><compOutput><uid v="1584836289"/><comptype v="1"/></compOutput><compOutput><uid v="1584836290"/><comptype v="1"/></compOutput><compOutput><uid v="1584836291"/><comptype v="1"/></compOutput><compOutput><uid v="1584836292"/><comptype v="2"/></compOutput><compOutput><uid v="1584836293"/><comptype v="2"/></compOutput><compOutput><uid v="1584836294"/><comptype v="2"/></compOutput><compOutput><uid v="1584836295"/><comptype v="2"/></compOutput><compOutput><uid v="1584836296"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///concrete_070?dependency=1584836168"/><parameters/><outputBridgings><outputBridging><uid v="1584836288"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584836289"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584836290"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584836291"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584836292"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584836293"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584836294"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584836295"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584836296"/><identifier v="ambient_occlusion"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584836996"/><GUILayout><gpos v="2416 1104 0"/></GUILayout><compOutputs><compOutput><uid v="1584836997"/><comptype v="1"/></compOutput><compOutput><uid v="1584836998"/><comptype v="1"/></compOutput><compOutput><uid v="1584836999"/><comptype v="1"/></compOutput><compOutput><uid v="1584837000"/><comptype v="1"/></compOutput><compOutput><uid v="1584837001"/><comptype v="2"/></compOutput><compOutput><uid v="1584837002"/><comptype v="2"/></compOutput><compOutput><uid v="1584837003"/><comptype v="2"/></compOutput><compOutput><uid v="1584837004"/><comptype v="2"/></compOutput><compOutput><uid v="1584837005"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///fabric_002?dependency=1290777011"/><parameters/><outputBridgings><outputBridging><uid v="1584836997"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584836998"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584836999"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584837000"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584837001"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584837002"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584837003"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584837004"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584837005"/><identifier v="ambient_occlusion"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584837273"/><GUILayout><gpos v="2416 1296 0"/></GUILayout><compOutputs><compOutput><uid v="1584837274"/><comptype v="1"/></compOutput><compOutput><uid v="1584837275"/><comptype v="1"/></compOutput><compOutput><uid v="1584837276"/><comptype v="1"/></compOutput><compOutput><uid v="1584837277"/><comptype v="1"/></compOutput><compOutput><uid v="1584837278"/><comptype v="2"/></compOutput><compOutput><uid v="1584837279"/><comptype v="2"/></compOutput><compOutput><uid v="1584837280"/><comptype v="2"/></compOutput><compOutput><uid v="1584837281"/><comptype v="2"/></compOutput><compOutput><uid v="1584837282"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///fabric_009?dependency=1584837006"/><parameters/><outputBridgings><outputBridging><uid v="1584837274"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584837275"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584837276"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584837277"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584837278"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584837279"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584837280"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584837281"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584837282"/><identifier v="ambient_occlusion"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584838663"/><GUILayout><gpos v="2416 1488 0"/></GUILayout><compOutputs><compOutput><uid v="1584838664"/><comptype v="1"/></compOutput><compOutput><uid v="1584838665"/><comptype v="1"/></compOutput><compOutput><uid v="1584838666"/><comptype v="1"/></compOutput><compOutput><uid v="1584838667"/><comptype v="1"/></compOutput><compOutput><uid v="1584838668"/><comptype v="2"/></compOutput><compOutput><uid v="1584838669"/><comptype v="2"/></compOutput><compOutput><uid v="1584838670"/><comptype v="2"/></compOutput><compOutput><uid v="1584838671"/><comptype v="2"/></compOutput><compOutput><uid v="1584838672"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///fabric_025?dependency=1290777014"/><parameters/><outputBridgings><outputBridging><uid v="1584838664"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584838665"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584838666"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584838667"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584838668"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584838669"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584838670"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584838671"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584838672"/><identifier v="ambient_occlusion"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584839008"/><GUILayout><gpos v="2416 1680 0"/></GUILayout><compOutputs><compOutput><uid v="1584839009"/><comptype v="1"/></compOutput><compOutput><uid v="1584839010"/><comptype v="1"/></compOutput><compOutput><uid v="1584839011"/><comptype v="1"/></compOutput><compOutput><uid v="1584839012"/><comptype v="1"/></compOutput><compOutput><uid v="1584839013"/><comptype v="2"/></compOutput><compOutput><uid v="1584839014"/><comptype v="2"/></compOutput><compOutput><uid v="1584839015"/><comptype v="2"/></compOutput><compOutput><uid v="1584839016"/><comptype v="2"/></compOutput><compOutput><uid v="1584839017"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///gravel?dependency=1584838674"/><parameters/><outputBridgings><outputBridging><uid v="1584839009"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584839010"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584839011"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584839012"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584839013"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584839014"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584839015"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584839016"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584839017"/><identifier v="ambient_occlusion"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584839491"/><GUILayout><gpos v="2416 1872 0"/></GUILayout><compOutputs><compOutput><uid v="1584839492"/><comptype v="1"/></compOutput><compOutput><uid v="1584839493"/><comptype v="1"/></compOutput><compOutput><uid v="1584839494"/><comptype v="1"/></compOutput><compOutput><uid v="1584839495"/><comptype v="1"/></compOutput><compOutput><uid v="1584839496"/><comptype v="2"/></compOutput><compOutput><uid v="1584839497"/><comptype v="2"/></compOutput><compOutput><uid v="1584839498"/><comptype v="2"/></compOutput><compOutput><uid v="1584839499"/><comptype v="2"/></compOutput><compOutput><uid v="1584839500"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///metal_002?dependency=1290777016"/><parameters/><outputBridgings><outputBridging><uid v="1584839492"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584839493"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584839494"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584839495"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584839496"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584839497"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584839498"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584839499"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584839500"/><identifier v="ambient_occlusion"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584840061"/><GUILayout><gpos v="2416 2064 0"/></GUILayout><compOutputs><compOutput><uid v="1584840062"/><comptype v="1"/></compOutput><compOutput><uid v="1584840063"/><comptype v="1"/></compOutput><compOutput><uid v="1584840064"/><comptype v="1"/></compOutput><compOutput><uid v="1584840065"/><comptype v="1"/></compOutput><compOutput><uid v="1584840066"/><comptype v="2"/></compOutput><compOutput><uid v="1584840067"/><comptype v="2"/></compOutput><compOutput><uid v="1584840068"/><comptype v="2"/></compOutput><compOutput><uid v="1584840069"/><comptype v="2"/></compOutput><compOutput><uid v="1584840070"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///metal_003?dependency=1584839502"/><parameters/><outputBridgings><outputBridging><uid v="1584840062"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584840063"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584840064"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584840065"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584840066"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584840067"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584840068"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584840069"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584840070"/><identifier v="ambient_occlusion"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584840263"/><GUILayout><gpos v="2416 2256 0"/></GUILayout><compOutputs><compOutput><uid v="1584840264"/><comptype v="1"/></compOutput><compOutput><uid v="1584840265"/><comptype v="1"/></compOutput><compOutput><uid v="1584840266"/><comptype v="1"/></compOutput><compOutput><uid v="1584840267"/><comptype v="1"/></compOutput><compOutput><uid v="1584840268"/><comptype v="2"/></compOutput><compOutput><uid v="1584840269"/><comptype v="2"/></compOutput><compOutput><uid v="1584840270"/><comptype v="2"/></compOutput><compOutput><uid v="1584840271"/><comptype v="2"/></compOutput><compOutput><uid v="1584840272"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///metal_006?dependency=1584840071"/><parameters/><outputBridgings><outputBridging><uid v="1584840264"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584840265"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584840266"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584840267"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584840268"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584840269"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584840270"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584840271"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584840272"/><identifier v="ambient_occlusion"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584840449"/><GUILayout><gpos v="2416 2448 0"/></GUILayout><compOutputs><compOutput><uid v="1584840450"/><comptype v="1"/></compOutput><compOutput><uid v="1584840451"/><comptype v="1"/></compOutput><compOutput><uid v="1584840452"/><comptype v="1"/></compOutput><compOutput><uid v="1584840453"/><comptype v="1"/></compOutput><compOutput><uid v="1584840454"/><comptype v="2"/></compOutput><compOutput><uid v="1584840455"/><comptype v="2"/></compOutput><compOutput><uid v="1584840456"/><comptype v="2"/></compOutput><compOutput><uid v="1584840457"/><comptype v="2"/></compOutput><compOutput><uid v="1584840458"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///metal_plate_001?dependency=1584840273"/><parameters/><outputBridgings><outputBridging><uid v="1584840450"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584840451"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584840452"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584840453"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584840454"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584840455"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584840456"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584840457"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584840458"/><identifier v="ambient_occlusion"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584840983"/><GUILayout><gpos v="2416 2640 0"/></GUILayout><compOutputs><compOutput><uid v="1584840984"/><comptype v="1"/></compOutput><compOutput><uid v="1584840985"/><comptype v="1"/></compOutput><compOutput><uid v="1584840986"/><comptype v="1"/></compOutput><compOutput><uid v="1584840987"/><comptype v="1"/></compOutput><compOutput><uid v="1584840988"/><comptype v="2"/></compOutput><compOutput><uid v="1584840989"/><comptype v="2"/></compOutput><compOutput><uid v="1584840990"/><comptype v="2"/></compOutput><compOutput><uid v="1584840991"/><comptype v="2"/></compOutput><compOutput><uid v="1584840992"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///metal_plate_004?dependency=1290777022"/><parameters/><outputBridgings><outputBridging><uid v="1584840984"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584840985"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584840986"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584840987"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584840988"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584840989"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584840990"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584840991"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584840992"/><identifier v="ambient_occlusion"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584841298"/><GUILayout><gpos v="2416 2832 0"/></GUILayout><compOutputs><compOutput><uid v="1584841299"/><comptype v="1"/></compOutput><compOutput><uid v="1584841300"/><comptype v="1"/></compOutput><compOutput><uid v="1584841301"/><comptype v="1"/></compOutput><compOutput><uid v="1584841302"/><comptype v="1"/></compOutput><compOutput><uid v="1584841303"/><comptype v="2"/></compOutput><compOutput><uid v="1584841304"/><comptype v="2"/></compOutput><compOutput><uid v="1584841305"/><comptype v="2"/></compOutput><compOutput><uid v="1584841306"/><comptype v="2"/></compOutput><compOutput><uid v="1584841307"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///old_painted_planks?dependency=1584840994"/><parameters/><outputBridgings><outputBridging><uid v="1584841299"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584841300"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584841301"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584841302"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584841303"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584841304"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584841305"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584841306"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584841307"/><identifier v="ambient_occlusion"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584841700"/><GUILayout><gpos v="2416 3002.66675 0"/></GUILayout><compOutputs><compOutput><uid v="1584841701"/><comptype v="1"/></compOutput><compOutput><uid v="1584841702"/><comptype v="1"/></compOutput><compOutput><uid v="1584841703"/><comptype v="1"/></compOutput><compOutput><uid v="1584841704"/><comptype v="1"/></compOutput><compOutput><uid v="1584841705"/><comptype v="2"/></compOutput><compOutput><uid v="1584841706"/><comptype v="2"/></compOutput><compOutput><uid v="1584841707"/><comptype v="2"/></compOutput><compOutput><uid v="1584841708"/><comptype v="2"/></compOutput><compOutput><uid v="1584841709"/><comptype v="2"/></compOutput><compOutput><uid v="1584841710"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///paper_005?dependency=1584841309"/><parameters/><outputBridgings><outputBridging><uid v="1584841701"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584841702"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584841703"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584841704"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584841705"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584841706"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584841707"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584841708"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584841709"/><identifier v="ambient_occlusion"/></outputBridging><outputBridging><uid v="1584841710"/><identifier v="opacity"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584841869"/><GUILayout><gpos v="2416 3216 0"/></GUILayout><compOutputs><compOutput><uid v="1584841870"/><comptype v="1"/></compOutput><compOutput><uid v="1584841871"/><comptype v="1"/></compOutput><compOutput><uid v="1584841872"/><comptype v="1"/></compOutput><compOutput><uid v="1584841873"/><comptype v="1"/></compOutput><compOutput><uid v="1584841874"/><comptype v="2"/></compOutput><compOutput><uid v="1584841875"/><comptype v="2"/></compOutput><compOutput><uid v="1584841876"/><comptype v="2"/></compOutput><compOutput><uid v="1584841877"/><comptype v="2"/></compOutput><compOutput><uid v="1584841878"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///rough_concrete_with_lines?dependency=1584841711"/><parameters/><outputBridgings><outputBridging><uid v="1584841870"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584841871"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584841872"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584841873"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584841874"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584841875"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584841876"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584841877"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584841878"/><identifier v="ambient_occlusion"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584842120"/><GUILayout><gpos v="2416 3408 0"/></GUILayout><compOutputs><compOutput><uid v="1584842121"/><comptype v="1"/></compOutput><compOutput><uid v="1584842122"/><comptype v="1"/></compOutput><compOutput><uid v="1584842123"/><comptype v="1"/></compOutput><compOutput><uid v="1584842124"/><comptype v="1"/></compOutput><compOutput><uid v="1584842125"/><comptype v="2"/></compOutput><compOutput><uid v="1584842126"/><comptype v="2"/></compOutput><compOutput><uid v="1584842127"/><comptype v="2"/></compOutput><compOutput><uid v="1584842128"/><comptype v="2"/></compOutput><compOutput><uid v="1584842129"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///tiles_002?dependency=1584841880"/><parameters/><outputBridgings><outputBridging><uid v="1584842121"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584842122"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584842123"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584842124"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584842125"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584842126"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584842127"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584842128"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584842129"/><identifier v="ambient_occlusion"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584842397"/><GUILayout><gpos v="2416 3600 0"/></GUILayout><compOutputs><compOutput><uid v="1584842398"/><comptype v="1"/></compOutput><compOutput><uid v="1584842399"/><comptype v="1"/></compOutput><compOutput><uid v="1584842400"/><comptype v="1"/></compOutput><compOutput><uid v="1584842401"/><comptype v="1"/></compOutput><compOutput><uid v="1584842402"/><comptype v="2"/></compOutput><compOutput><uid v="1584842403"/><comptype v="2"/></compOutput><compOutput><uid v="1584842404"/><comptype v="2"/></compOutput><compOutput><uid v="1584842405"/><comptype v="2"/></compOutput><compOutput><uid v="1584842406"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///tiles_008?dependency=1584842131"/><parameters/><outputBridgings><outputBridging><uid v="1584842398"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584842399"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584842400"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584842401"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584842402"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584842403"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584842404"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584842405"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584842406"/><identifier v="ambient_occlusion"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584842671"/><GUILayout><gpos v="2416 3792 0"/></GUILayout><compOutputs><compOutput><uid v="1584842672"/><comptype v="1"/></compOutput><compOutput><uid v="1584842673"/><comptype v="1"/></compOutput><compOutput><uid v="1584842674"/><comptype v="1"/></compOutput><compOutput><uid v="1584842675"/><comptype v="1"/></compOutput><compOutput><uid v="1584842676"/><comptype v="2"/></compOutput><compOutput><uid v="1584842677"/><comptype v="2"/></compOutput><compOutput><uid v="1584842678"/><comptype v="2"/></compOutput><compOutput><uid v="1584842679"/><comptype v="2"/></compOutput><compOutput><uid v="1584842680"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///tiles_011?dependency=1584842408"/><parameters/><outputBridgings><outputBridging><uid v="1584842672"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584842673"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584842674"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584842675"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584842676"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584842677"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584842678"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584842679"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584842680"/><identifier v="ambient_occlusion"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584842975"/><GUILayout><gpos v="2416 3984 0"/></GUILayout><compOutputs><compOutput><uid v="1584842976"/><comptype v="1"/></compOutput><compOutput><uid v="1584842977"/><comptype v="1"/></compOutput><compOutput><uid v="1584842978"/><comptype v="1"/></compOutput><compOutput><uid v="1584842979"/><comptype v="1"/></compOutput><compOutput><uid v="1584842980"/><comptype v="2"/></compOutput><compOutput><uid v="1584842981"/><comptype v="2"/></compOutput><compOutput><uid v="1584842982"/><comptype v="2"/></compOutput><compOutput><uid v="1584842983"/><comptype v="2"/></compOutput><compOutput><uid v="1584842984"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///tiles_025?dependency=1584842682"/><parameters/><outputBridgings><outputBridging><uid v="1584842976"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584842977"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584842978"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584842979"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584842980"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584842981"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584842982"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584842983"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584842984"/><identifier v="ambient_occlusion"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584843264"/><GUILayout><gpos v="2416 4176 0"/></GUILayout><compOutputs><compOutput><uid v="1584843265"/><comptype v="1"/></compOutput><compOutput><uid v="1584843266"/><comptype v="1"/></compOutput><compOutput><uid v="1584843267"/><comptype v="1"/></compOutput><compOutput><uid v="1584843268"/><comptype v="1"/></compOutput><compOutput><uid v="1584843269"/><comptype v="2"/></compOutput><compOutput><uid v="1584843270"/><comptype v="2"/></compOutput><compOutput><uid v="1584843271"/><comptype v="2"/></compOutput><compOutput><uid v="1584843272"/><comptype v="2"/></compOutput><compOutput><uid v="1584843273"/><comptype v="2"/></compOutput></compOutputs><compImplementation><compInstance><path v="pkg:///wood_american_cherry?dependency=1584842986"/><parameters/><outputBridgings><outputBridging><uid v="1584843265"/><identifier v="diffuse"/></outputBridging><outputBridging><uid v="1584843266"/><identifier v="basecolor"/></outputBridging><outputBridging><uid v="1584843267"/><identifier v="normal"/></outputBridging><outputBridging><uid v="1584843268"/><identifier v="specular"/></outputBridging><outputBridging><uid v="1584843269"/><identifier v="glossiness"/></outputBridging><outputBridging><uid v="1584843270"/><identifier v="roughness"/></outputBridging><outputBridging><uid v="1584843271"/><identifier v="metallic"/></outputBridging><outputBridging><uid v="1584843272"/><identifier v="height"/></outputBridging><outputBridging><uid v="1584843273"/><identifier v="ambient_occlusion"/></outputBridging></outputBridgings></compInstance></compImplementation></compNode><compNode><uid v="1584843868"/><GUILayout><gpos v="2704 -656 0"/></GUILayout><compOutputs><compOutput><uid v="1584843869"/><comptype v="1"/></compOutput></compOutputs><compImplementation><compFilter><filter v="blend"/><parameters><parameter><name v="outputsize"/><relativeTo v="2"/><paramValue><dynamicValue><paramNodes><paramNode><uid v="1584844553"/><GUILayout><gpos v="-368 336 0"/></GUILayout><function v="const_bool"/><type v="4"/></paramNode><paramNode><uid v="1584844554"/><GUILayout><gpos v="-368 464 0"/></GUILayout><function v="const_float1"/><type v="256"/></paramNode><paramNode><uid v="1584844555"/><GUILayout><gpos v="-368 592 0"/></GUILayout><function v="const_float2"/><type v="512"/></paramNode><paramNode><uid v="1584844556"/><GUILayout><gpos v="-368 720 0"/></GUILayout><function v="const_float3"/><type v="1024"/></paramNode><paramNode><uid v="1584844557"/><GUILayout><gpos v="-368 848 0"/></GUILayout><function v="const_float4"/><type v="2048"/></paramNode><paramNode><uid v="1584844558"/><GUILayout><gpos v="-368 976 0"/></GUILayout><function v="const_int1"/><type v="16"/></paramNode><paramNode><uid v="1584844559"/><GUILayout><gpos v="-368 1104 0"/></GUILayout><function v="const_int2"/><type v="32"/></paramNode><paramNode><uid v="1584844560"/><GUILayout><gpos v="-368 1232 0"/></GUILayout><function v="const_int3"/><type v="64"/></paramNode><paramNode><uid v="1584844561"/><GUILayout><gpos v="-368 1360 0"/></GUILayout><function v="const_int4"/><type v="128"/></paramNode><paramNode><uid v="1584844562"/><GUILayout><gpos v="-368 1488 0"/></GUILayout><function v="const_string"/><type v="16384"/></paramNode><paramNode><uid v="1584844788"/><GUILayout><gpos v="-176 336 0"/></GUILayout><function v="swizzle1"/><type v="256"/></paramNode><paramNode><uid v="1584844789"/><GUILayout><gpos v="-176 464 0"/></GUILayout><function v="swizzle2"/><type v="512"/></paramNode><paramNode><uid v="1584844790"/><GUILayout><gpos v="-176 592 0"/></GUILayout><function v="swizzle3"/><type v="1024"/></paramNode><paramNode><uid v="1584844791"/><GUILayout><gpos v="-176 720 0"/></GUILayout><function v="swizzle4"/><type v="2048"/></paramNode><paramNode><uid v="1584844792"/><GUILayout><gpos v="-176 848 0"/></GUILayout><function v="iswizzle1"/><type v="16"/></paramNode><paramNode><uid v="1584844793"/><GUILayout><gpos v="-176 976 0"/></GUILayout><function v="iswizzle2"/><type v="32"/></paramNode><paramNode><uid v="1584844794"/><GUILayout><gpos v="-176 1104 0"/></GUILayout><function v="iswizzle3"/><type v="64"/></paramNode><paramNode><uid v="1584844795"/><GUILayout><gpos v="-176 1232 0"/></GUILayout><function v="iswizzle4"/><type v="128"/></paramNode><paramNode><uid v="1584844796"/><GUILayout><gpos v="-176 1360 0"/></GUILayout><function v="vector2"/><type v="512"/></paramNode><paramNode><uid v="1584844797"/><GUILayout><gpos v="-176 1488 0"/></GUILayout><function v="vector3"/><type v="1024"/></paramNode><paramNode><uid v="1584844798"/><GUILayout><gpos v="-176 1616 0"/></GUILayout><function v="vector4"/><type v="2048"/></paramNode><paramNode><uid v="1584844799"/><GUILayout><gpos v="-176 1744 0"/></GUILayout><function v="ivector2"/><type v="32"/></paramNode><paramNode><uid v="1584844800"/><GUILayout><gpos v="-176 1872 0"/></GUILayout><function v="ivector3"/><type v="64"/></paramNode><paramNode><uid v="1584844801"/><GUILayout><gpos v="-176 2000 0"/></GUILayout><function v="ivector4"/><type v="128"/></paramNode><paramNode><uid v="1584844815"/><GUILayout><gpos v="16 336 0"/></GUILayout><function v="get_bool"/><type v="4"/></paramNode><paramNode><uid v="1584844816"/><GUILayout><gpos v="16 464 0"/></GUILayout><function v="get_float1"/><type v="256"/></paramNode><paramNode><uid v="1584844817"/><GUILayout><gpos v="16 592 0"/></GUILayout><function v="get_float2"/><type v="512"/></paramNode><paramNode><uid v="1584844818"/><GUILayout><gpos v="16 720 0"/></GUILayout><function v="get_float3"/><type v="1024"/></paramNode><paramNode><uid v="1584844819"/><GUILayout><gpos v="16 848 0"/></GUILayout><function v="get_float4"/><type v="2048"/></paramNode><paramNode><uid v="1584844820"/><GUILayout><gpos v="16 976 0"/></GUILayout><function v="get_integer1"/><type v="16"/></paramNode><paramNode><uid v="1584844821"/><GUILayout><gpos v="16 1104 0"/></GUILayout><function v="get_integer2"/><type v="32"/></paramNode><paramNode><uid v="1584844822"/><GUILayout><gpos v="16 1232 0"/></GUILayout><function v="get_integer3"/><type v="64"/></paramNode><paramNode><uid v="1584844823"/><GUILayout><gpos v="16 1360 0"/></GUILayout><function v="get_integer4"/><type v="128"/></paramNode><paramNode><uid v="1584844824"/><GUILayout><gpos v="16 1488 0"/></GUILayout><function v="get_string"/><type v="16384"/></paramNode><paramNode><uid v="1584844825"/><GUILayout><gpos v="16 1616 0"/></GUILayout><function v="set"/><type v="131072"/></paramNode><paramNode><uid v="1584844845"/><GUILayout><gpos v="208 336 0"/></GUILayout><function v="samplecol"/><type v="2048"/></paramNode><paramNode><uid v="1584844846"/><GUILayout><gpos v="208 464 0"/></GUILayout><function v="samplelum"/><type v="256"/></paramNode><paramNode><uid v="1584844865"/><GUILayout><gpos v="400 336 0"/></GUILayout><function v="tofloat"/><type v="256"/></paramNode><paramNode><uid v="1584844866"/><GUILayout><gpos v="400 464 0"/></GUILayout><function v="tofloat2"/><type v="512"/></paramNode><paramNode><uid v="1584844867"/><GUILayout><gpos v="400 592 0"/></GUILayout><function v="tofloat3"/><type v="1024"/></paramNode><paramNode><uid v="1584844868"/><GUILayout><gpos v="400 720 0"/></GUILayout><function v="tofloat4"/><type v="2048"/></paramNode><paramNode><uid v="1584844869"/><GUILayout><gpos v="400 848 0"/></GUILayout><function v="toint1"/><type v="16"/></paramNode><paramNode><uid v="1584844870"/><GUILayout><gpos v="400 976 0"/></GUILayout><function v="toint2"/><type v="32"/></paramNode><paramNode><uid v="1584844871"/><GUILayout><gpos v="400 1104 0"/></GUILayout><function v="toint3"/><type v="64"/></paramNode><paramNode><uid v="1584844872"/><GUILayout><gpos v="400 1232 0"/></GUILayout><function v="toint4"/><type v="128"/></paramNode><paramNode><uid v="1584844886"/><GUILayout><gpos v="592 336 0"/></GUILayout><function v="add"/><type v="131072"/></paramNode><paramNode><uid v="1584844887"/><GUILayout><gpos v="592 464 0"/></GUILayout><function v="div"/><type v="131072"/></paramNode><paramNode><uid v="1584844888"/><GUILayout><gpos v="592 592 0"/></GUILayout><function v="dot"/><type v="256"/></paramNode><paramNode><uid v="1584844889"/><GUILayout><gpos v="592 720 0"/></GUILayout><function v="mod"/><type v="131072"/></paramNode><paramNode><uid v="1584844890"/><GUILayout><gpos v="592 848 0"/></GUILayout><function v="mul"/><type v="131072"/></paramNode><paramNode><uid v="1584844891"/><GUILayout><gpos v="592 976 0"/></GUILayout><function v="neg"/><type v="131072"/></paramNode><paramNode><uid v="1584844892"/><GUILayout><gpos v="592 1104 0"/></GUILayout><function v="mulscalar"/><type v="131072"/></paramNode><paramNode><uid v="1584844893"/><GUILayout><gpos v="592 1232 0"/></GUILayout><function v="sub"/><type v="131072"/></paramNode><paramNode><uid v="1584844907"/><GUILayout><gpos v="784 336 0"/></GUILayout><function v="and"/><type v="4"/></paramNode><paramNode><uid v="1584844908"/><GUILayout><gpos v="784 464 0"/></GUILayout><function v="not"/><type v="4"/></paramNode><paramNode><uid v="1584844909"/><GUILayout><gpos v="784 592 0"/></GUILayout><function v="or"/><type v="4"/></paramNode><paramNode><uid v="1584844927"/><GUILayout><gpos v="976 336 0"/></GUILayout><function v="eq"/><type v="4"/></paramNode><paramNode><uid v="1584844928"/><GUILayout><gpos v="976 464 0"/></GUILayout><function v="gt"/><type v="4"/></paramNode><paramNode><uid v="1584844929"/><GUILayout><gpos v="976 592 0"/></GUILayout><function v="gteq"/><type v="4"/></paramNode><paramNode><uid v="1584844930"/><GUILayout><gpos v="976 720 0"/></GUILayout><function v="lr"/><type v="4"/></paramNode><paramNode><uid v="1584844931"/><GUILayout><gpos v="976 848 0"/></GUILayout><function v="lreq"/><type v="4"/></paramNode><paramNode><uid v="1584844932"/><GUILayout><gpos v="976 976 0"/></GUILayout><function v="noteq"/><type v="4"/></paramNode><paramNode><uid v="1584844949"/><GUILayout><gpos v="1168 336 0"/></GUILayout><function v="pow2"/><type v="131072"/></paramNode><paramNode><uid v="1584844950"/><GUILayout><gpos v="1168 464 0"/></GUILayout><function v="abs"/><type v="131072"/></paramNode><paramNode><uid v="1584844951"/><GUILayout><gpos v="1168 592 0"/></GUILayout><function v="atan2"/><type v="256"/></paramNode><paramNode><uid v="1584844952"/><GUILayout><gpos v="1168 720 0"/></GUILayout><function v="cartesian"/><type v="512"/></paramNode><paramNode><uid v="1584844953"/><GUILayout><gpos v="1168 848 0"/></GUILayout><function v="ceil"/><type v="131072"/></paramNode><paramNode><uid v="1584844954"/><GUILayout><gpos v="1168 976 0"/></GUILayout><function v="cos"/><type v="131072"/></paramNode><paramNode><uid v="1584844955"/><GUILayout><gpos v="1168 1104 0"/></GUILayout><function v="exp"/><type v="131072"/></paramNode><paramNode><uid v="1584844956"/><GUILayout><gpos v="1168 1232 0"/></GUILayout><function v="floor"/><type v="131072"/></paramNode><paramNode><uid v="1584844957"/><GUILayout><gpos v="1168 1360 0"/></GUILayout><function v="lerp"/><type v="131072"/></paramNode><paramNode><uid v="1584844958"/><GUILayout><gpos v="1168 1488 0"/></GUILayout><function v="log"/><type v="131072"/></paramNode><paramNode><uid v="1584844959"/><GUILayout><gpos v="1168 1616 0"/></GUILayout><function v="log2"/><type v="131072"/></paramNode><paramNode><uid v="1584844960"/><GUILayout><gpos v="1168 1744 0"/></GUILayout><function v="max"/><type v="131072"/></paramNode><paramNode><uid v="1584844961"/><GUILayout><gpos v="1168 1872 0"/></GUILayout><function v="min"/><type v="131072"/></paramNode><paramNode><uid v="1584844962"/><GUILayout><gpos v="1168 2000 0"/></GUILayout><function v="pow"/><type v="131072"/></paramNode><paramNode><uid v="1584844963"/><GUILayout><gpos v="1168 2128 0"/></GUILayout><function v="rand"/><type v="256"/></paramNode><paramNode><uid v="1584844964"/><GUILayout><gpos v="1168 2256 0"/></GUILayout><function v="sin"/><type v="131072"/></paramNode><paramNode><uid v="1584844965"/><GUILayout><gpos v="1168 2384 0"/></GUILayout><function v="sqrt"/><type v="131072"/></paramNode><paramNode><uid v="1584844966"/><GUILayout><gpos v="1168 2512 0"/></GUILayout><function v="tan"/><type v="131072"/></paramNode><paramNode><uid v="1584844983"/><GUILayout><gpos v="1360 336 0"/></GUILayout><function v="ifelse"/><type v="131072"/></paramNode><paramNode><uid v="1584844984"/><GUILayout><gpos v="1360 464 0"/></GUILayout><function v="sequence"/><type v="131072"/></paramNode><paramNode><uid v="1584844985"/><GUILayout><gpos v="1360 592 0"/></GUILayout><function v="while"/><type v="131072"/><funcDatas><funcData><name v="while"/><constantValue><constantValueInt1 v="32"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845014"/><GUILayout><gpos v="2064 336 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/acescg_to_linear_srgb?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845015"/><GUILayout><gpos v="2064 464 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/directionToNormal?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845016"/><GUILayout><gpos v="2064 592 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/HCLtoRGB?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845017"/><GUILayout><gpos v="2064 720 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/HSItoRGB?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845018"/><GUILayout><gpos v="2064 858.666687 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/hsl_offset?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845019"/><GUILayout><gpos v="2064 1008 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/HSLtoRGB?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845020"/><GUILayout><gpos v="2064 1136 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/HSVtoRGB?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845021"/><GUILayout><gpos v="2064 1264 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/linear_srgb_to_acescg?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845022"/><GUILayout><gpos v="2064 1392 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/linear_to_sRGB_luminance?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845023"/><GUILayout><gpos v="2064 1520 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/linear_to_sRGB_rgb?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845024"/><GUILayout><gpos v="2064 1648 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/Random_Color?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845025"/><GUILayout><gpos v="2064 1776 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/Random_Luminosity?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845026"/><GUILayout><gpos v="2064 1904 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_chroma_2_polar?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845027"/><GUILayout><gpos v="2064 2032 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_chroma_hexagonal?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845028"/><GUILayout><gpos v="2064 2160 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_hue_2_polar?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845029"/><GUILayout><gpos v="2064 2288 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_hue_hexagonal?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845030"/><GUILayout><gpos v="2064 2416 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_lightness_average?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845031"/><GUILayout><gpos v="2064 2544 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_lightness_bihexcone?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845032"/><GUILayout><gpos v="2064 2672 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_lightness_hexcone?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845033"/><GUILayout><gpos v="2064 2800 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_lightness_luma_rec601?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845034"/><GUILayout><gpos v="2064 2928 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_lightness_luma_rec709?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845035"/><GUILayout><gpos v="2064 3056 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_saturation_HSI?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845036"/><GUILayout><gpos v="2064 3184 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_saturation_HSL?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845037"/><GUILayout><gpos v="2064 3312 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_saturation_HSV?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845038"/><GUILayout><gpos v="2064 3440 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGBtoHCL?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845039"/><GUILayout><gpos v="2064 3568 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGBtoHSI?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845040"/><GUILayout><gpos v="2064 3696 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGBtoHSL?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845041"/><GUILayout><gpos v="2064 3824 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGBtoHSV?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845042"/><GUILayout><gpos v="2064 3952 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/sRGB_to_linear_luminance?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845043"/><GUILayout><gpos v="2064 4080 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/sRGB_to_linear_rgb?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845044"/><GUILayout><gpos v="2064 4208 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/temperature_to_rgb?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845065"/><GUILayout><gpos v="2256 336 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Equality_Boolean?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845066"/><GUILayout><gpos v="2256 464 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Equality_Float2?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845067"/><GUILayout><gpos v="2256 592 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Equality_Float3?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845068"/><GUILayout><gpos v="2256 720 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Equality_Float4?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845069"/><GUILayout><gpos v="2256 848 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/NotEqual_Boolean?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845070"/><GUILayout><gpos v="2256 976 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/NotEqual_Float2?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845071"/><GUILayout><gpos v="2256 1104 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/NotEqual_Float3?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845072"/><GUILayout><gpos v="2256 1232 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/NotEqual_Float4?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845087"/><GUILayout><gpos v="2448 336 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/2Pi?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845088"/><GUILayout><gpos v="2448 464 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Pi?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845105"/><GUILayout><gpos v="2640 336 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Ranges/[-1_1]_to_[0_1]?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845106"/><GUILayout><gpos v="2640 464 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Ranges/[0,1]_to_[0,1,0]?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845107"/><GUILayout><gpos v="2640 592 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Ranges/[0_1]_to_[-1_1]?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845108"/><GUILayout><gpos v="2640 720 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Ranges/[0_1]_to_[1_0]?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845109"/><GUILayout><gpos v="2640 848 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Ranges/[a,b]_to_[0,1]?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845110"/><GUILayout><gpos v="2640 976 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/typeConverters/booleanToFloat1?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845111"/><GUILayout><gpos v="2640 1104 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Trigo/deg_to_rad?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845112"/><GUILayout><gpos v="2640 1232 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Random/Degrees_to_Turn?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845113"/><GUILayout><gpos v="2640 1360 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Ranges/Height_Balance_Fn?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845114"/><GUILayout><gpos v="2640 1488 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Ranges/sawtooth_wave?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845115"/><GUILayout><gpos v="2640 1616 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Ranges/triangle_wave?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845116"/><GUILayout><gpos v="2640 1744 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/typeConverters/turnsToDegrees?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845131"/><GUILayout><gpos v="2832 336 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Trigo/acos?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845132"/><GUILayout><gpos v="2832 464 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Trigo/asin?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845133"/><GUILayout><gpos v="2832 592 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/average_float1?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845134"/><GUILayout><gpos v="2832 720 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/average_float2?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845135"/><GUILayout><gpos v="2832 848 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/average_float3?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845136"/><GUILayout><gpos v="2832 976 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/average_float4?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845137"/><GUILayout><gpos v="2832 1104 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/clamp?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845138"/><GUILayout><gpos v="2832 1232 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/cross_product?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845139"/><GUILayout><gpos v="2832 1360 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/cross_product_vec2?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845140"/><GUILayout><gpos v="2832 1488 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/distance_vec2?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845141"/><GUILayout><gpos v="2832 1616 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/distance_vec3?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845142"/><GUILayout><gpos v="2832 1744 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/divide_float2?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845143"/><GUILayout><gpos v="2832 1872 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/divide_float3?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845144"/><GUILayout><gpos v="2832 2000 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/divide_float4?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845145"/><GUILayout><gpos v="2832 2128 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/fmod?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845146"/><GUILayout><gpos v="2832 2256 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/frac?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845147"/><GUILayout><gpos v="2832 2384 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/length_vec2?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845148"/><GUILayout><gpos v="2832 2512 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/length_vec3?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845149"/><GUILayout><gpos v="2832 2640 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/merge_float3?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845150"/><GUILayout><gpos v="2832 2746.66675 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/merge_float4?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845151"/><GUILayout><gpos v="2832 2896 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/normalize_vec2?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845152"/><GUILayout><gpos v="2832 3024 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/normalize_vec3?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845153"/><GUILayout><gpos v="2832 3152 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/normalize_vec4?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845154"/><GUILayout><gpos v="2832 3280 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845155"/><GUILayout><gpos v="2832 3408 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/orthogonal_vec2?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845156"/><GUILayout><gpos v="2832 3536 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/reflect?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845157"/><GUILayout><gpos v="2832 3664 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/round_float1?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845158"/><GUILayout><gpos v="2832 3792 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/saturate?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845159"/><GUILayout><gpos v="2832 3920 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/saturate_float2?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845160"/><GUILayout><gpos v="2832 4048 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/sign?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845161"/><GUILayout><gpos v="2832 4176 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/smoothstep?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845162"/><GUILayout><gpos v="2832 4304 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/step?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845163"/><GUILayout><gpos v="2832 4432 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/truncate_float1_decimals?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845177"/><GUILayout><gpos v="3024 336 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Parity/EvenCount?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845178"/><GUILayout><gpos v="3024 464 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Parity/OddCount?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845179"/><GUILayout><gpos v="3024 592 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Parity/ParityTest?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845194"/><GUILayout><gpos v="3216 336 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Random/Discrete_[A,B]?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845195"/><GUILayout><gpos v="3216 464 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Random/GlobalRandom?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845196"/><GUILayout><gpos v="3216 592 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Random/normal_distribution?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845197"/><GUILayout><gpos v="3216 720 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Random/Uniform_[-1,1[?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845198"/><GUILayout><gpos v="3216 848 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Random/Uniform_[A,B[?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845199"/><GUILayout><gpos v="3216 976 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Random/Uniform_F2_[A,B[?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845200"/><GUILayout><gpos v="3216 1104 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Random/Uniform_F3_[A,B[?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845201"/><GUILayout><gpos v="3216 1232 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Random/Uniform_F4_[A,B[?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845216"/><GUILayout><gpos v="3408 336 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Transforms/carthesian_to_polar?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845217"/><GUILayout><gpos v="3408 464 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Transforms/Directional_Offset?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845218"/><GUILayout><gpos v="3408 592 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Transforms/matrix_invert?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845219"/><GUILayout><gpos v="3408 720 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Transforms/MatrixMultiply?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845220"/><GUILayout><gpos v="3408 848 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Transforms/polar_to_carthesian?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845221"/><GUILayout><gpos v="3408 976 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Transforms/rotate_vec2?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845222"/><GUILayout><gpos v="3408 1104 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Transforms/RotationMatrix?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845223"/><GUILayout><gpos v="3408 1232 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Transforms/ScaleMatrix?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845224"/><GUILayout><gpos v="3408 1360 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Transforms/TileMatrix?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845238"/><GUILayout><gpos v="3600 336 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Curve_Function?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845239"/><GUILayout><gpos v="3600 464 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Various/non_square_expansion_uv_scale?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845240"/><GUILayout><gpos v="3600 592 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Various/non_square_output_size?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845241"/><GUILayout><gpos v="3600 730.666687 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Roughness?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845242"/><GUILayout><gpos v="3600 880 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float1/switch_float1_2_inputs?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845243"/><GUILayout><gpos v="3600 1008 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float2/switch_float2_2_inputs?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845244"/><GUILayout><gpos v="3600 1125.33337 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float2/switch_float2_4_inputs?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845245"/><GUILayout><gpos v="3600 1296 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float2/switch_float2_8_inputs?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845246"/><GUILayout><gpos v="3600 1552 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float3/switch_float3_2_inputs?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845247"/><GUILayout><gpos v="3600 1701.33337 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float3/switch_float3_4_inputs?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845248"/><GUILayout><gpos v="3600 1872 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float3/switch_float3_8_inputs?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845249"/><GUILayout><gpos v="3600 2128 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float4/switch_float4_2_inputs?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845250"/><GUILayout><gpos v="3600 2245.33325 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float4/switch_float4_4_inputs?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845251"/><GUILayout><gpos v="3600 2416 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float4/switch_float4_8_inputs?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845252"/><GUILayout><gpos v="3600 2672 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer1/switch_integer1_2_inputs?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845253"/><GUILayout><gpos v="3600 2789.33325 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer1/switch_integer1_4_inputs?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845254"/><GUILayout><gpos v="3600 2960 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer1/switch_integer1_8_inputs?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845255"/><GUILayout><gpos v="3600 3216 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer2/switch_integer2_2_inputs?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845256"/><GUILayout><gpos v="3600 3365.33325 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer2/switch_integer2_4_inputs?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845257"/><GUILayout><gpos v="3600 3536 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer2/switch_integer2_8_inputs?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845258"/><GUILayout><gpos v="3600 3792 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer3/switch_integer3_2_inputs?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845259"/><GUILayout><gpos v="3600 3909.33325 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer3/switch_integer3_4_inputs?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845260"/><GUILayout><gpos v="3600 4080 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer3/switch_integer3_8_inputs?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845261"/><GUILayout><gpos v="3600 4336 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer4/switch_integer4_2_inputs?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845262"/><GUILayout><gpos v="3600 4453.3335 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer4/switch_integer4_4_inputs?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845263"/><GUILayout><gpos v="3600 4624 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer4/switch_integer4_8_inputs?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845264"/><GUILayout><gpos v="3600 4880 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Cycles/Wave?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845278"/><GUILayout><gpos v="3792 336 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/easings/circ/ease_in_circ?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845279"/><GUILayout><gpos v="3792 464 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/easings/cubic/ease_in_cubic?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845280"/><GUILayout><gpos v="3792 592 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/easings/expo/ease_in_expo?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845281"/><GUILayout><gpos v="3792 720 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/easings/circ/ease_in_out_circ?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845282"/><GUILayout><gpos v="3792 848 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/easings/cubic/ease_in_out_cubic?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845283"/><GUILayout><gpos v="3792 976 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/easings/expo/ease_in_out_expo?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845284"/><GUILayout><gpos v="3792 1104 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/easings/quad/ease_in_out_quad?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845285"/><GUILayout><gpos v="3792 1232 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/easings/quart/ease_in_out_quart?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845286"/><GUILayout><gpos v="3792 1360 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/easings/quint/ease_in_out_quint?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845287"/><GUILayout><gpos v="3792 1488 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/easings/sine/ease_in_out_sine?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845288"/><GUILayout><gpos v="3792 1616 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/easings/quad/ease_in_quad?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845289"/><GUILayout><gpos v="3792 1744 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/easings/quart/ease_in_quart?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845290"/><GUILayout><gpos v="3792 1872 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/easings/quint/ease_in_quint?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845291"/><GUILayout><gpos v="3792 2000 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/easings/sine/ease_in_sine?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845292"/><GUILayout><gpos v="3792 2128 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/easings/circ/ease_out_circ?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845293"/><GUILayout><gpos v="3792 2256 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/easings/cubic/ease_out_cubic?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845294"/><GUILayout><gpos v="3792 2384 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/easings/expo/ease_out_expo?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845295"/><GUILayout><gpos v="3792 2512 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/easings/quad/ease_out_quad?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845296"/><GUILayout><gpos v="3792 2640 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/easings/quart/ease_out_quart?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845297"/><GUILayout><gpos v="3792 2768 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/easings/quint/ease_out_quint?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1584845298"/><GUILayout><gpos v="3792 2896 0"/></GUILayout><function v="instance"/><type v="118772"/><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/easings/sine/ease_out_sine?dependency=1508498669"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects><GUIObject><type v="COMMENT"/><GUILayout><gpos v="-448 256 -100"/><size v="160 1312"/></GUILayout><GUIName v=""/><uid v="1584844773"/><title v="Constant"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="-256 256 0"/><size v="160 1824"/></GUILayout><GUIName v=""/><uid v="1584844806"/><title v="Vector"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="-64 256 0"/><size v="160 1440"/></GUILayout><GUIName v=""/><uid v="1584844833"/><title v="Variables"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="128 256 -100"/><size v="160 288"/></GUILayout><GUIName v=""/><uid v="1584844850"/><title v="Samplers"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="320 256 -100"/><size v="160 1056"/></GUILayout><GUIName v=""/><uid v="1584844876"/><title v="Cast"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="512 256 -100"/><size v="160 1056"/></GUILayout><GUIName v=""/><uid v="1584844896"/><title v="Operator"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="704 256 -100"/><size v="160 416"/></GUILayout><GUIName v=""/><uid v="1584844915"/><title v="Logical"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="896 256 -100"/><size v="160 800"/></GUILayout><GUIName v=""/><uid v="1584844937"/><title v="Comparison"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="1088 256 -100"/><size v="160 2336"/></GUILayout><GUIName v=""/><uid v="1584844971"/><title v="Function"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="1280 256 -100"/><size v="160 416"/></GUILayout><GUIName v=""/><uid v="1584844988"/><title v="Control"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="1984 256 -100"/><size v="160 4032"/></GUILayout><GUIName v=""/><uid v="1584845048"/><title v="Color"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="2176 256 -100"/><size v="160 1056"/></GUILayout><GUIName v=""/><uid v="1584845075"/><title v="Comparison"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="2368 256 -100"/><size v="160 288"/></GUILayout><GUIName v=""/><uid v="1584845092"/><title v="Constant"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="2560 256 -100"/><size v="160 1568"/></GUILayout><GUIName v=""/><uid v="1584845120"/><title v="Conversion"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="2752 256 -100"/><size v="160 4256"/></GUILayout><GUIName v=""/><uid v="1584845167"/><title v="Maths"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="2944 256 -100"/><size v="160 416"/></GUILayout><GUIName v=""/><uid v="1584845182"/><title v="Parity"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="3136 256 -100"/><size v="160 1056"/></GUILayout><GUIName v=""/><uid v="1584845204"/><title v="Random"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="3328 256 -100"/><size v="160 1184"/></GUILayout><GUIName v=""/><uid v="1584845227"/><title v="Transformation"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="3520 256 -100"/><size v="160 4704"/></GUILayout><GUIName v=""/><uid v="1584845267"/><title v="Various"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="3712 256 -100"/><size v="160 2720"/></GUILayout><GUIName v=""/><uid v="1584845302"/><title v="Easings"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject></GUIObjects></dynamicValue></paramValue></parameter></parameters></compFilter></compImplementation></compNode></compNodes><baseParameters/><GUIObjects><GUIObject><type v="COMMENT"/><GUILayout><gpos v="-4224 -736 -100"/><size v="160 3744"/></GUILayout><GUIName v=""/><uid v="1584635645"/><title v="Atomic Nodes"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="-4032 -736 -100"/><size v="160 11424"/></GUILayout><GUIName v=""/><uid v="1584687207"/><title v="Texture Generators - Noises"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="-3744 -736 -100"/><size v="160 7840"/></GUILayout><GUIName v=""/><uid v="1584687364"/><title v="Texture Generators - Patterns"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="-3456 -736 -100"/><size v="160 6688"/></GUILayout><GUIName v=""/><uid v="1584693813"/><title v="Filters - Adjustments"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="-3232 -736 -100"/><size v="160 1440"/></GUILayout><GUIName v=""/><uid v="1584694177"/><title v="Filters - Blending"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="-3040 -736 -100"/><size v="160 1824"/></GUILayout><GUIName v=""/><uid v="1584706016"/><title v="Filters - Blurs"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="-2848 -736 -100"/><size v="160 832"/></GUILayout><GUIName v=""/><uid v="1584706065"/><title v="Filters - Channels"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="-2624 -736 -100"/><size v="128 7904"/></GUILayout><GUIName v=""/><uid v="1584775740"/><title v="Filters - Effects"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="-2464 -736 -100"/><size v="160 1952"/></GUILayout><GUIName v=""/><uid v="1584779207"/><title v="Filters - Normal map"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="-2240 -736 -100"/><size v="160 544"/></GUILayout><GUIName v=""/><uid v="1584779754"/><title v="Filters - Tiling"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="-2048 -736 -100"/><size v="160 3616"/></GUILayout><GUIName v=""/><uid v="1584781628"/><title v="Filters - Transforms"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="-1824 -736 -100"/><size v="160 256"/></GUILayout><GUIName v=""/><uid v="1584784201"/><title v="Material Filters - 1 click"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="-1600 -736 -100"/><size v="160 960"/></GUILayout><GUIName v=""/><uid v="1584785571"/><title v="Material Filters - Effects"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="-1376 -736 -100"/><size v="160 288"/></GUILayout><GUIName v=""/><uid v="1584785631"/><title v="Material Filters - Transforms"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="-1088 -736 -100"/><size v="160 1728"/></GUILayout><GUIName v=""/><uid v="1584786964"/><title v="Material Filters - Blending"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="-800 -736 -100"/><size v="128 1600"/></GUILayout><GUIName v=""/><uid v="1584796768"/><title v="Material Filters - PBR Utilities"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="-480 -736 -100"/><size v="160 2976"/></GUILayout><GUIName v=""/><uid v="1584804075"/><title v="Material Filters - Scan Processing"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="-96 -736 -100"/><size v="160 3392"/></GUILayout><GUIName v=""/><uid v="1584809406"/><title v="Mesh-based Generators - Mask generators"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="352 -736 -100"/><size v="160 2144"/></GUILayout><GUIName v=""/><uid v="1584813766"/><title v="Mesh-based generators - Weathering"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="768 -736 0"/><size v="160 1280"/></GUILayout><GUIName v=""/><uid v="1584815351"/><title v="Mesh-based generators - Utilities"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="1120 -736 -100"/><size v="160 4576"/></GUILayout><GUIName v=""/><uid v="1584827743"/><title v="Spline & Path Tools - Spline Tools"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="1472 -736 -100"/><size v="160 1312"/></GUILayout><GUIName v=""/><uid v="1584828358"/><title v="Spline & Path tools - Path tools"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="2080 -736 -100"/><size v="160 2400"/></GUILayout><GUIName v=""/><uid v="1584832257"/><title v="3D view - HDRI tools"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="1792 -736 -100"/><size v="160 640"/></GUILayout><GUIName v=""/><uid v="1584832395"/><title v="3D view - HDRI environments"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="2336 -736 -100"/><size v="160 5024"/></GUILayout><GUIName v=""/><uid v="1584843807"/><title v="PBR Materials"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject><GUIObject><type v="COMMENT"/><GUILayout><gpos v="2624 -736 -100"/><size v="160 160"/></GUILayout><GUIName v=""/><uid v="1584844577"/><title v="Functions Inside"/><frameColor v="0.101960786 0.552941203 1 0.250980407"/><isTitleVisible v="1"/><isFrameVisible v="1"/></GUIObject></GUIObjects><options><option><name v="defaultParentSize"/><value v="11x11"/></option></options><root><rootOutputs><rootOutput><output v="1213284336"/><format v="0"/><usertag v=""/></rootOutput><rootOutput><output v="1213284338"/><format v="0"/><usertag v=""/></rootOutput><rootOutput><output v="1213284340"/><format v="0"/><usertag v=""/></rootOutput><rootOutput><output v="1213284342"/><format v="0"/><usertag v=""/></rootOutput><rootOutput><output v="1279137031"/><format v="0"/><usertag v=""/></rootOutput><rootOutput><output v="1359211721"/><format v="0"/><usertag v=""/></rootOutput><rootOutput><output v="1584633047"/><format v="0"/><usertag v=""/></rootOutput></rootOutputs></root></graph><group><uid v="1584632999"/><identifier v="Resources"/><content><resource><identifier v="Untitled_Bitmap"/><uid v="1584633000"/><type v="bitmap"/><format v="png"/><filepath v="../AppData/Local/Temp/Test/Test/resources/test.png"/><source><externalcopy><filename v="all_nodes.resources/test.bmp"/></externalcopy></source></resource><resource><identifier v="Untitled_Vector_Graphics"/><uid v="1584633069"/><type v="svg"/><format v="SVG"/><filepath v=""/><source><binembedded><datalength v="157"/><strdata v="AAAAnXicVY1BCsMgEEX3PYXMAWZMSjcSe5cQRQWNQYdMj18hodDVX7zH+0s/g1pzGGNO33qqu4UJNajoU4hs4TXNoP6RJMfxJp+S924hMh+GSERQnlhboFlrTSN7K+Y6+ZmOHa45+1Bb4ljShlstdEk4IND78QW4mjPI"/></binembedded></source></resource><resource><identifier v="brown_photostudio_02_1k"/><uid v="1584828400"/><type v="bitmap"/><colorSpace v="[use_embedded_profile]"/><format v="exr"/><filepath v="sd-3dview-maps://brown_photostudio_02_1k.exr"/></resource><resource><identifier v="spiaggia_di_mondello_1k"/><uid v="1584832279"/><type v="bitmap"/><colorSpace v="[use_embedded_profile]"/><format v="exr"/><filepath v="sd-3dview-maps://spiaggia_di_mondello_1k.exr"/></resource><resource><identifier v="monochrome_studio_02_1k"/><uid v="1584832280"/><type v="bitmap"/><colorSpace v="[use_embedded_profile]"/><format v="exr"/><filepath v="sd-3dview-maps://monochrome_studio_02_1k.exr"/></resource><resource><identifier v="metro_noord_1k"/><uid v="1584832281"/><type v="bitmap"/><colorSpace v="[use_embedded_profile]"/><format v="exr"/><filepath v="sd-3dview-maps://metro_noord_1k.exr"/></resource></content></group></content></package> diff --git a/crates/engine/src/node_library.rs b/crates/engine/src/node_library.rs index 80c4dfb..b2541aa 100644 --- a/crates/engine/src/node_library.rs +++ b/crates/engine/src/node_library.rs @@ -1,8 +1,9 @@ //! 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. +//! is loaded once per process and lends its graphs: function graphs go under Functions (sorted by +//! their folder), other graphs under their attribute category. Native nodes, function operations, +//! FX-Map nodes and graph items fill the rest of the tree. A package whose titled frames are library +//! categories ("Filters - Blurs") can also lay the library out: each node inside a frame becomes an +//! entry in that category, listed as missing until a package provides it. use materialcraft_core::{Package, PatternNodeKind}; use materialcraft_formats::sbs::{LayoutItem, library}; @@ -233,7 +234,10 @@ impl NodeLibrary { continue; } let item = LibraryItem::Node { def: definition.id.into() }; - push(&mut out, entry(id, definition.label, definition.category, definition.description, item, None)); + // Graph inputs and outputs sit with the atomic nodes; Graph items holds annotations and the Dot + let category = + if matches!(definition.id, "input_color" | "input_grayscale" | "input_value" | "output") { "Atomic nodes" } else { definition.category }; + push(&mut out, entry(id, definition.label, category, definition.description, item, None)); } for operation in materialcraft_nodes::function::FUNCTIONS { let id = format!("function:{}", operation.id); @@ -255,7 +259,8 @@ impl NodeLibrary { continue; } let placement = if graph.function.is_some() { - Placement { category: "Functions".into(), item: LayoutItem::FunctionInstance { package: path.clone(), graph: name } } + let category = known_category(&graph.attributes.category).unwrap_or_else(|| function_category(&name)); + Placement { category, 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() } } @@ -369,8 +374,12 @@ 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())) + // A sub-category the tree doesn't have names no category ("Functions/colorValues" is a folder) + let sub = match parts.next() { + None => None, + Some(sub) => Some(*subs.iter().find(|name| key(name) == key(sub))?), + }; + Some(category_path(top, sub)) } fn category_path(top: &str, sub: Option<&str>) -> String { @@ -392,6 +401,48 @@ fn sub_category(category: &str, graph: &str) -> String { .map_or_else(|| category.to_string(), |(top, sub, _)| category_path(top, Some(sub))) } +/// Function graphs whose name decides their Functions sub-category +const FUNCTION_NAMES: &[(&str, &str)] = &[ + ("Pi", "Constant"), + ("2Pi", "Constant"), + ("deg_to_rad", "Conversion"), + ("Degrees_to_Turn", "Conversion"), + ("Curve_Function", "Various"), + ("Roughness", "Various"), +]; +/// Name prefixes that decide a function graph's sub-category +const FUNCTION_PREFIXES: &[(&str, &str)] = &[("Equality_", "Comparison"), ("NotEqual_", "Comparison")]; +/// Library folders (below `Functions/`) and the Functions sub-category of the graphs in them; the +/// first folder that holds the graph wins +const FUNCTION_FOLDERS: &[(&str, &str)] = &[ + ("colorValues", "Color"), + ("Tonemappers", "Color"), + ("easings", "Easings"), + ("Math/Parity", "Parity"), + ("Random", "Random"), + ("Ranges", "Conversion"), + ("typeConverters", "Conversion"), + ("Transforms", "Transformation"), + ("switch", "Various"), + ("Various", "Various"), + ("Cycles", "Various"), + ("Math", "Maths"), +]; + +/// The Functions sub-category of a function graph, from its path in the library package +/// (`Functions/Math/Pi` → `Functions/Constant`); `Functions` when nothing matches +pub fn function_category(path: &str) -> String { + let (folder, name) = path.rsplit_once('/').unwrap_or(("", path)); + let folder = folder.strip_prefix("Functions").map_or(folder, |rest| rest.trim_start_matches('/')); + let sub = FUNCTION_NAMES + .iter() + .find(|(known, _)| *known == name) + .or_else(|| FUNCTION_PREFIXES.iter().find(|(prefix, _)| name.starts_with(prefix))) + .or_else(|| FUNCTION_FOLDERS.iter().find(|(known, _)| folder == *known || folder.strip_prefix(known).is_some_and(|rest| rest.starts_with('/')))) + .map(|(_, sub)| *sub); + category_path("Functions", sub) +} + /// A readable label from an SBS identifier: `3D_perlin_noise` → "3D Perlin Noise" pub fn humanize(identifier: &str) -> String { const WORDS: &[(&str, &str)] = &[ diff --git a/crates/engine/src/node_library.test.rs b/crates/engine/src/node_library.test.rs index c37f571..1c6fbd4 100644 --- a/crates/engine/src/node_library.test.rs +++ b/crates/engine/src/node_library.test.rs @@ -28,15 +28,29 @@ fn identifiers_read_as_labels() { } #[test] -fn the_bundled_library_fills_every_category_of_the_tree() { +fn functions_sort_into_sub_categories_by_folder_and_name() { + assert_eq!(function_category("Functions/Math/Pi"), "Functions/Constant"); + assert_eq!(function_category("Functions/Math/Equality_Float2"), "Functions/Comparison"); + assert_eq!(function_category("Functions/Math/Parity/EvenCount"), "Functions/Parity"); + assert_eq!(function_category("Functions/Math/Trigo/acos"), "Functions/Maths"); + assert_eq!(function_category("Functions/Math/Trigo/deg_to_rad"), "Functions/Conversion"); + assert_eq!(function_category("Functions/easings/sine/ease_in_sine"), "Functions/Easings"); + assert_eq!(function_category("Functions/switch/Float2/switch_float2_4_inputs"), "Functions/Various"); + assert_eq!(function_category("Functions/Tonemappers/tonemap_ACES"), "Functions/Color"); + assert_eq!(function_category("Functions/Mathematics/x"), "Functions", "a folder name must match whole"); + assert_eq!(function_category("Loose"), "Functions"); +} + +#[test] +fn the_bundled_library_fills_the_tree_with_what_materialcraft_has() { let library = NodeLibrary::shared(); - assert_eq!(library.layouts, vec!["sbs://all_nodes.sbs".to_string()]); + assert!(library.layouts.is_empty()); 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"); + assert!(entries.iter().all(|entry| entry.missing.is_none()), "everything listed can be added"); let known = |category: &str| { let mut parts = category.split('/'); let top = parts.next().unwrap_or(""); @@ -48,47 +62,54 @@ fn the_bundled_library_fills_every_category_of_the_tree() { 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 top in ["Function nodes", "Functions"] { + let (_, subs) = CATEGORIES.iter().find(|(name, _)| *name == top).unwrap(); 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!(count(&format!("{top}/{sub}")) > 0, "{top}/{sub} is empty"); } } - assert_eq!(count("Texture generators/Noises"), 89); + // Every bundled function has a sub-category + assert_eq!(entries.iter().filter(|entry| entry.category.starts_with("Functions/")).count(), 171); + assert_eq!(count("Functions"), 0); + assert_eq!(find("sbs://functions.sbs#Functions/Tonemappers/tonemap_ACES").category, "Functions/Color"); 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()); + for id in ["node:blur", "node:bitmap", "node:output", "node:input_color", "node:input_value"] { + assert_eq!(find(id).category, "Atomic nodes", "{id}"); + } 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); } +/// A layout that places a library node MaterialCraft doesn't have yet, a function and a sub-category +/// the PBR keywords decide +const LAYOUT: &str = r#"<package><dependencies> + <dependency><filename v="sbs://3d_perlin_noise.sbs"/><uid v="2"/></dependency> + <dependency><filename v="sbs://materials/bricks_001.sbs"/><uid v="3"/></dependency></dependencies> + <content><graph><identifier v="Layout"/><compNodes> + <compNode><uid v="10"/><GUILayout><gpos v="20 40 0"/></GUILayout><compImplementation><compInstance><path v="pkg:///3D_perlin_noise?dependency=2"/></compInstance></compImplementation></compNode> + <compNode><uid v="11"/><GUILayout><gpos v="220 40 0"/></GUILayout><compImplementation><compInstance><path v="pkg:///bricks_001?dependency=3"/></compInstance></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="200 0 0"/><size v="160 200"/></GUILayout><title v="PBR Materials"/></GUIObject> + </GUIObjects></graph></content></package>"#; + #[test] -fn a_library_package_makes_its_placed_entry_available() { - let library = NodeLibrary::shared(); - let mut dependencies = library.packages.clone(); +fn a_layout_lists_what_it_places_and_a_library_package_makes_it_available() { + let frames = materialcraft_formats::sbs::read_layout(LAYOUT.as_bytes(), "sbs://layout.sbs").unwrap(); + let library = NodeLibrary { placements: placements(&frames), ..Default::default() }; + let entries = library.entries(&BTreeMap::new()); + let perlin = entries.iter().find(|entry| entry.id == "sbs://3d_perlin_noise.sbs#3D_perlin_noise").unwrap(); + assert_eq!((perlin.label.as_str(), perlin.category.as_str()), ("3D Perlin Noise", "Texture generators/Noises")); + assert!(perlin.missing.is_some(), "a placed node whose package is absent is listed but not addable"); + let bricks = entries.iter().find(|entry| entry.id == "sbs://materials/bricks_001.sbs#bricks_001").unwrap(); + assert_eq!(bricks.category, "PBR materials/Bricks"); + let mut graph = Graph::new("3D_perlin_noise"); graph.add_node("uniform", [0.0; 2]); graph.add_node("output", [200.0, 0.0]); @@ -97,7 +118,7 @@ fn a_library_package_makes_its_placed_entry_available() { 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 dependencies = BTreeMap::from([("sbs://3d_perlin_noise.sbs".to_string(), 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(); diff --git a/crates/engine/tests/it/node_library.rs b/crates/engine/tests/it/node_library.rs index 26062ca..720c6e6 100644 --- a/crates/engine/tests/it/node_library.rs +++ b/crates/engine/tests/it/node_library.rs @@ -16,11 +16,14 @@ fn the_library_tree_lists_categories_and_filters_entries() { 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"])); + assert_eq!(tree["layouts"], json!([])); - 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 constants = entries(&mut session, json!({"category": "Functions/Constant"})); + assert!(constants.iter().any(|entry| entry["label"] == "Pi")); + let functions = entries(&mut session, json!({"category": "Functions"})); + assert_eq!(functions.len(), 171, "every bundled function, across the sub-categories"); + assert!(entries(&mut session, json!({})).iter().all(|entry| entry["missing"].is_null())); + assert!(entries(&mut session, json!({"category": "Texture generators"})).is_empty()); 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")); @@ -46,9 +49,6 @@ fn library_entries_add_to_the_graph_they_fit() { 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 @@ -75,8 +75,8 @@ fn library_entries_add_to_the_graph_they_fit() { 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!(reloaded["entries"].as_u64().unwrap() > 250); + assert_eq!(reloaded["available"], reloaded["entries"]); assert!(!session.modified); assert!(session.pkg.dependencies.contains_key("sbs://functions.sbs")); } diff --git a/crates/formats/src/sbs/library.rs b/crates/formats/src/sbs/library.rs index bd3a41a..535ebeb 100644 --- a/crates/formats/src/sbs/library.rs +++ b/crates/formats/src/sbs/library.rs @@ -79,13 +79,12 @@ 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"]; +pub const BUNDLED: &[&str] = &["sbs://functions.sbs"]; /// Bounds for scanning the library folder: how deep, and how many packages const MAX_DEPTH: usize = 6; diff --git a/crates/formats/src/sbs/library_layout.rs b/crates/formats/src/sbs/library_layout.rs index 337a86b..c127a15 100644 --- a/crates/formats/src/sbs/library_layout.rs +++ b/crates/formats/src/sbs/library_layout.rs @@ -281,18 +281,4 @@ mod tests { 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")) - ); - } } diff --git a/crates/ui-egui/src/library.test.rs b/crates/ui-egui/src/library.test.rs index 63e2233..522ca15 100644 --- a/crates/ui-egui/src/library.test.rs +++ b/crates/ui-egui/src/library.test.rs @@ -29,12 +29,12 @@ fn open_package_graphs_are_explorer_resources_not_library_entries() { #[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 = "Functions".into(); + let functions = labels(&app); + app.ui.library_category = "Functions/Constant".into(); + let constants = labels(&app); + assert!(!constants.is_empty() && constants.len() < functions.len()); + assert!(constants.iter().all(|label| functions.contains(label))); app.ui.library_category = FAVORITES.into(); assert!(labels(&app).is_empty()); @@ -48,9 +48,11 @@ fn categories_include_their_sub_categories_and_favorites_follow_the_star() { #[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(); + // "Uniform" names a native node and random functions; a material graph takes only the node + app.ui.library_search = "uniform".into(); let found = labels(&app); - assert_eq!(found.first().map(String::as_str), Some("Blur")); + assert_eq!(found.first().map(String::as_str), Some("Uniform color"), "{found:?}"); + assert!(found.len() > 1, "{found:?}"); let entries = app.session.library_entries(); let here = Here::of(&app); let shown = visible(&app, &entries, &here); @@ -90,13 +92,14 @@ fn every_tree_category_has_an_icon_and_double_click_adds() { 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"] { + // A material graph takes the Blur node, not a function + for id in ["node:blur", "sbs://functions.sbs#Functions/Math/Pi"] { 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"); + assert_eq!(app.session.graph().unwrap().nodes.len(), before + 1, "only the entry the graph takes 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); diff --git a/crates/ui-egui/tests/snapshot/library.rs b/crates/ui-egui/tests/snapshot/library.rs index 30e60b0..7a92bb8 100644 --- a/crates/ui-egui/tests/snapshot/library.rs +++ b/crates/ui-egui/tests/snapshot/library.rs @@ -70,13 +70,31 @@ fn library_tree_shows_every_category_and_adds_what_the_graph_takes() { 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 + // Categories MaterialCraft has no nodes for yet say so 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"); + assert!(harness.query(By::new().label("Nothing in this category yet")).is_some()); + harness.get(tree("Texture generators")).click(); + settle(&mut harness, 2); + harness.get(tree("Texture generators")).click(); + settle(&mut harness, 2); + + // Opening a category shows its sub-categories; functions sort into theirs by folder + harness.get(tree("Functions")).click(); + settle(&mut harness, 3); + harness.get(tree("Constant")).click(); + settle(&mut harness, 4); + for label in ["Pi", "2Pi"] { + assert!(harness.query(tile(label)).is_some(), "{label}"); + } + save(&mut harness, &directory, "library-functions-constant"); + harness.get(tree("Functions")).click(); + settle(&mut harness, 2); + harness.get(tree("Functions")).click(); + settle(&mut harness, 2); + assert!(!harness.state().ui.library_expanded.contains("Functions")); for (top, subs) in [ ("Filters", &["Adjustments", "Blending", "Blurs", "Channels", "Effects", "Normal map", "Tiling", "Transforms"][..]), @@ -112,8 +130,8 @@ fn library_tree_shows_every_category_and_adds_what_the_graph_takes() { 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(); + harness.state_mut().ui.library_search = "blur".into(); settle(&mut harness, 4); - assert!(harness.query(tile("3D Perlin Noise")).is_some()); + assert!(harness.query(tile("Blur")).is_some()); save(&mut harness, &directory, "library-search"); } diff --git a/docs/architecture.md b/docs/architecture.md index 6b184fa..83f5136 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -105,12 +105,13 @@ Resource paths resolve beside their owning package: `resources/tile.png` in 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`. +until `library.reload`). Each package joins every session's dependencies, so its graphs can be +instanced, and the Library lists them: function graphs under Functions, sorted into its +sub-categories by their folder (`Functions/Math/Pi` → Constant), other graphs under their attribute +category. A package whose titled frames name Library categories ("Filters - Blurs") can also lay +the tree out (`formats::sbs::read_layout`): each node inside a frame becomes an entry there, listed +as missing until a package in the folder provides it. Installed and browser builds embed +`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 diff --git a/docs/control-protocol.md b/docs/control-protocol.md index 22ec6ec..f5051aa 100644 --- a/docs/control-protocol.md +++ b/docs/control-protocol.md @@ -121,14 +121,13 @@ Types: `move`, `down`, `up`, `click`, `doubleClick`, `drag`, `scroll`, `key` (eg ## 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. +browser builds use the bundled `functions.sbs`) loads once per process, and its graphs join every +session's dependencies. Function graphs are listed under Functions, in the sub-category their folder +names (`Functions/colorValues` → Color, `Functions/easings` → Easings); other graphs under the +category in their attributes. A package whose graphs group nodes in titled frames lays the library +out instead: a frame titled `Top - Sub` (or `Top`) is a Library category, and every node inside it +becomes an entry there, `missing` until its package is in the folder. Function frames name only the +sub-category. The older category name "SDF functions" reads as MCF functions. ## Linked packages diff --git a/docs/file-format-parity.md b/docs/file-format-parity.md index 47e9bf2..0d8b1d6 100644 --- a/docs/file-format-parity.md +++ b/docs/file-format-parity.md @@ -17,7 +17,7 @@ material artists exchange. | Format | Read | Write | Fidelity | Tests | |---|---|---|---|---| -| `.sbs` package (XML), the main format | Yes: atomic filters, library nodes with a MaterialCraft node of the same name (88 of the 491 in `assets/sbs/all_nodes.sbs`), graph instances, graph inputs/outputs, exposed values, parameters linked to inputs, base parameters, frames, comments, embedded and linked bitmaps and SVGs. Anything else (missing nodes, curve points, gradient keys, function graphs, environment maps) is a Console warning; missing nodes stay as placeholders | Yes: SBS data with bitmaps embedded, plus MaterialCraft's exact copy | Lossless for files MaterialCraft saved (exact copy, guarded by a content hash); placeholders round-trip their SBS data | `formats::sbs::tests`, engine `sbs_is_the_default_save_format_and_mcraft_still_works`, `an_sbs_file_with_missing_nodes_opens_softly` | +| `.sbs` package (XML), the main format | Yes: atomic filters, library nodes with a MaterialCraft node of the same name (88 of the 491 in a sample that instanced every library node), graph instances, graph inputs/outputs, exposed values, parameters linked to inputs, base parameters, frames, comments, embedded and linked bitmaps and SVGs. Anything else (missing nodes, curve points, gradient keys, function graphs, environment maps) is a Console warning; missing nodes stay as placeholders | Yes: SBS data with bitmaps embedded, plus MaterialCraft's exact copy | Lossless for files MaterialCraft saved (exact copy, guarded by a content hash); placeholders round-trip their SBS data | `formats::sbs::tests`, engine `sbs_is_the_default_save_format_and_mcraft_still_works`, `an_sbs_file_with_missing_nodes_opens_softly` | | `.mcraft` package (zip: `package.json` + `resources/`), older | Yes | Yes | Lossless (graphs, parameters, frames, comments, pins, exposed inputs, embedded bitmaps) | `formats::tests::package_round_trip`, engine `package_save_and_open_round_trip` | | PNG | Yes (8/16-bit, gray and color) | Yes (8/16-bit) | 16-bit gray round-trips within 1/65535 | `formats::tests::export_every_format` | | JPEG | Yes | Yes (8-bit) | Lossy | same | diff --git a/docs/gaps.md b/docs/gaps.md index 32d3135..8ea9e0d 100644 --- a/docs/gaps.md +++ b/docs/gaps.md @@ -24,10 +24,12 @@ 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. +Path tools, MCF functions, Functions, 3D view, PBR materials, Values). It lists what MaterialCraft +has: the atomic nodes, the function operations, the 171 bundled functions (sorted into the Functions +sub-categories) and the FX-Map nodes. Texture generators, Filters, Material filters, Mesh-based +generators, Spline & Path tools, MCF functions, 3D view, PBR materials and Values stay empty until +library packages for them are added to `assets/sbs`; the CC0 environments in `assets/hdr` are not +listed yet. > **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 From 91333baf33b85681e193ed38d5da1a28acbb7b83 Mon Sep 17 00:00:00 2001 From: PiJellyPin <pijellypin@outlook.com> Date: Tue, 10 Nov 2026 04:54:37 +0100 Subject: [PATCH 3/5] Other Fixes --- crates/ui-egui/src/function/canvas.rs | 2 + .../ui-egui/src/function/function_editor.rs | 3 + .../src/function/function_library_drag.rs | 1 + crates/ui-egui/src/function/input.rs | 47 +++-- crates/ui-egui/src/function/library.rs | 48 +++++ crates/ui-egui/src/function/mod.rs | 1 + crates/ui-egui/src/function/search.rs | 180 ++++++++++++++++++ .../src/graph/function_search_tests.rs | 149 +++++++++++++++ crates/ui-egui/src/graph/input.rs | 14 +- crates/ui-egui/src/graph/interaction_tests.rs | 11 +- crates/ui-egui/src/graph/mod.rs | 2 + crates/ui-egui/src/graph/modality_tests.rs | 4 +- crates/ui-egui/src/graph/node_search.rs | 2 + crates/ui-egui/src/graph/search.rs | 23 ++- crates/ui-egui/src/graph/toolbar.rs | 104 +++++++--- crates/ui-egui/src/library.rs | 2 + crates/ui-egui/src/library.test.rs | 2 + crates/ui-egui/tests/snapshot.rs | 3 + .../tests/snapshot/function_library.rs | 3 +- crates/ui-egui/tests/snapshot/node_search.rs | 40 ++++ docs/atomic-workflow.md | 5 + 21 files changed, 584 insertions(+), 62 deletions(-) create mode 100644 crates/ui-egui/src/function/search.rs create mode 100644 crates/ui-egui/src/graph/function_search_tests.rs create mode 100644 crates/ui-egui/tests/snapshot/node_search.rs diff --git a/crates/ui-egui/src/function/canvas.rs b/crates/ui-egui/src/function/canvas.rs index 36978e0..8ec089f 100644 --- a/crates/ui-egui/src/function/canvas.rs +++ b/crates/ui-egui/src/function/canvas.rs @@ -34,6 +34,8 @@ pub(super) fn canvas(app: &mut MaterialCraftApp, editor: &mut FunctionEditor, ui .input(|input| input.pointer.hover_pos()) .is_some_and(|pointer| frame.frames.iter().any(|frame| frame.contains(pointer)) || frame.comments.iter().any(|(_, rect)| rect.contains(pointer))); super::input::handle(app, editor, ui, &frame.response, &frame.ports, &frame.geometry, on_annotation); + let camera = GraphCamera { origin: frame.response.rect.min, pan: editor.pan, zoom: editor.zoom }; + super::search::show(app, editor, ui, &camera); frame.geometry.publish(&mut app.graph, frame.response.rect); if standalone { if editor.drag.is_none() { diff --git a/crates/ui-egui/src/function/function_editor.rs b/crates/ui-egui/src/function/function_editor.rs index 67ca80b..aa6d3f9 100644 --- a/crates/ui-egui/src/function/function_editor.rs +++ b/crates/ui-egui/src/function/function_editor.rs @@ -19,6 +19,8 @@ pub struct FunctionEditor { pub(super) menu_at: Pos2, pub(crate) framed: bool, pub(super) open_reference: Option<u32>, + /// The open node search (Space, Tab, double-click or a wire dropped on empty canvas) + pub(crate) search: Option<super::search::FunctionSearch>, } impl FunctionEditor { @@ -49,6 +51,7 @@ impl FunctionEditor { menu_at: Pos2::ZERO, framed: false, open_reference: None, + search: None, } } diff --git a/crates/ui-egui/src/function/function_library_drag.rs b/crates/ui-egui/src/function/function_library_drag.rs index 71a9011..c4a5062 100644 --- a/crates/ui-egui/src/function/function_library_drag.rs +++ b/crates/ui-egui/src/function/function_library_drag.rs @@ -1,4 +1,5 @@ /// A library function being dragged onto a Function canvas +#[derive(Clone, Debug)] pub(crate) enum FunctionLibraryDrag { Operation(String), Instance { package: String, graph: String }, diff --git a/crates/ui-egui/src/function/input.rs b/crates/ui-egui/src/function/input.rs index 67571c5..8a7628c 100644 --- a/crates/ui-egui/src/function/input.rs +++ b/crates/ui-egui/src/function/input.rs @@ -1,4 +1,5 @@ use super::function_port::FunctionPort; +use super::search::{FunctionSearch, SearchWire}; use super::{FunctionDrag, FunctionEditor}; use crate::{ MaterialCraftApp, @@ -97,6 +98,7 @@ pub(super) fn handle( None => {} } + let camera = GraphCamera { origin: canvas_bounds.min, pan: editor.pan, zoom: editor.zoom }; let owner = match editor.drag { Some(FunctionDrag::Pan(button)) => button, _ => egui::PointerButton::Primary, @@ -118,23 +120,22 @@ pub(super) fn handle( crate::graph::node_selection::select_box(&mut editor.selection, nodes, start, pointer, ui.input(|input| input.modifiers)); } } - Some(FunctionDrag::Wire(from)) => { - if let Some(pointer) = pointer - && let Some((to, Some(input))) = near(pointer) - && from != to - { - editor.edit(app, FunctionEdit::Connect { from, to, input }, false); + Some(FunctionDrag::Wire(from)) => match pointer.map(|pointer| (pointer, near(pointer))) { + Some((_, Some((to, Some(input))))) if from != to => editor.edit(app, FunctionEdit::Connect { from, to, input }, false), + // Dropped on empty canvas: search for a node that takes the wire + Some((pointer, None)) if canvas_bounds.contains(pointer) => { + editor.search = Some(FunctionSearch::at(camera.to_graph(pointer), Some(SearchWire::From(from)))); } - } - Some(FunctionDrag::InputWire(to, input)) => { - // Dropped anywhere but on another node's output, the input stays unconnected - if let Some(pointer) = pointer - && let Some((from, None)) = near(pointer) - && from != to - { - editor.edit(app, FunctionEdit::Connect { from, to, input }, false); + _ => {} + }, + Some(FunctionDrag::InputWire(to, input)) => match pointer.map(|pointer| (pointer, near(pointer))) { + Some((_, Some((from, None)))) if from != to => editor.edit(app, FunctionEdit::Connect { from, to, input }, false), + // Dropped on empty canvas: search for a node whose output feeds the input + Some((pointer, None)) if canvas_bounds.contains(pointer) => { + editor.search = Some(FunctionSearch::at(camera.to_graph(pointer), Some(SearchWire::To(to, input)))); } - } + _ => {} + }, _ => {} } } @@ -144,8 +145,6 @@ pub(super) fn handle( crate::graph::node_selection::select(&mut editor.selected_wires, None, ui.input(|input| input.modifiers)); } - let camera = GraphCamera { origin: canvas_bounds.min, pan: editor.pan, zoom: editor.zoom }; - if let Some(payload) = crate::widgets::dnd_release::<super::function_library_drag::FunctionLibraryDrag>(response) && let Some(pointer) = pointer { @@ -176,14 +175,20 @@ pub(super) fn handle( { editor.menu_at = camera.to_graph(pointer_position); } - if response.hovered() - && !ui.ctx().egui_wants_keyboard_input() - && ui.input(|input| input.key_pressed(egui::Key::Space)) + // Space or Tab over the canvas, or a double-click on empty canvas, searches for a node to add + // Tab moves focus between widgets, so it waits only for text fields and focus held before this frame + let space = !ui.ctx().egui_wants_keyboard_input() && ui.input(|input| input.key_pressed(egui::Key::Space)); + let tab = !app.graph.keyboard_was_focused && !ui.ctx().text_edit_focused() && ui.input(|input| input.key_pressed(egui::Key::Tab)); + let keys = space || tab; + let on_node = pointer.is_some_and(|pointer| geometry.rects.iter().any(|(_, bounds)| bounds.contains(pointer))); + let double_click = response.double_clicked() && !on_wire && !on_annotation && !on_node && pointer.and_then(near).is_none(); + if editor.search.is_none() + && ((response.hovered() && keys) || double_click) && !crate::shell::modality::Modality::capture(app, ui.ctx()).is_blocked() && let Some(pointer_position) = pointer { editor.menu_at = camera.to_graph(pointer_position); - egui::Popup::open_id(ui.ctx(), response.id.with("menu")); + editor.search = Some(FunctionSearch::at(editor.menu_at, None)); } response.context_menu(|ui| { super::context_menu::show(app, editor, ui, None); diff --git a/crates/ui-egui/src/function/library.rs b/crates/ui-egui/src/function/library.rs index 5c6a63a..c08db84 100644 --- a/crates/ui-egui/src/function/library.rs +++ b/crates/ui-egui/src/function/library.rs @@ -11,6 +11,54 @@ pub(crate) fn add(app: &mut MaterialCraftApp, entry: &FunctionLibraryDrag) { } } +/// The common function nodes on the canvas toolbar, in groups: (operation, what the button shows). +/// Icons where one fits, short text where the node is a value or an operator +pub(crate) const QUICK: &[&[(&str, &str)]] = &[ + &[("const_float1", "F1"), ("const_float2", "F2"), ("const_float3", "F3"), ("const_float4", "F4"), ("const_int1", "I1"), ("const_bool", "B")], + &[("get_float1", "$1"), ("get_float2", "$2"), ("get_float3", "$3"), ("get_float4", "$4")], + &[("vector2", "V2"), ("vector3", "V3"), ("vector4", "V4"), ("swizzle1", egui_phosphor::regular::SHUFFLE)], + &[("add", "+"), ("sub", "\u{2212}"), ("mul", "\u{d7}"), ("div", "\u{f7}"), ("mulscalar", "k\u{d7}"), ("dot", "\u{b7}")], + &[ + ("lerp", egui_phosphor::regular::SLIDERS_HORIZONTAL), + ("min", egui_phosphor::regular::ARROW_LINE_DOWN), + ("max", egui_phosphor::regular::ARROW_LINE_UP), + ("abs", "|x|"), + ], + &[("ifelse", egui_phosphor::regular::GIT_BRANCH), ("sequence", egui_phosphor::regular::LIST_NUMBERS)], + &[ + ("samplecol", egui_phosphor::regular::EYEDROPPER_SAMPLE), + ("samplelum", egui_phosphor::regular::EYEDROPPER), + ("passthrough", egui_phosphor::regular::DOT_OUTLINE), + ], +]; + +/// Add `operation` right of the one selected node, wired from it when the new node has an input; +/// in the middle of the view otherwise +pub(crate) fn add_near_selection(app: &mut MaterialCraftApp, operation: &str) { + let Some(mut editor) = app.function_editor.take() else { return }; + let source = match editor.selection.as_slice() { + [id] => editor.current(app).and_then(|graph| graph.node(*id)).map(|node| (node.id, node.pos)), + _ => None, + }; + let at = source.map_or_else( + || { + let center = editor.pan + app.graph.view.size() * 0.5 / editor.zoom; + [center.x - crate::graph::NODE_W * 0.5, center.y - 40.0] + }, + |(_, position)| [position[0] + 180.0, position[1]], + ); + let before = editor.selection.clone(); + editor.edit(app, FunctionEdit::Add { operation: operation.into(), at, snap: app.ui.prefs.snap_to_grid }, false); + if let Some((from, _)) = source + && let Some(&id) = editor.selection.first().filter(|_| editor.selection != before) + && editor.current(app).and_then(|graph| graph.node(id)).is_some_and(|node| !node.inputs.is_empty()) + { + editor.edit(app, FunctionEdit::Connect { from, to: id, input: 0 }, false); + editor.selection = vec![id]; + } + 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> { diff --git a/crates/ui-egui/src/function/mod.rs b/crates/ui-egui/src/function/mod.rs index bfa47d9..109d73d 100644 --- a/crates/ui-egui/src/function/mod.rs +++ b/crates/ui-egui/src/function/mod.rs @@ -7,6 +7,7 @@ mod function_target; pub(crate) mod library; mod port_label; pub(crate) mod properties; +pub(crate) mod search; pub(crate) use actions::{enabled, invoke}; use function_drag::FunctionDrag; diff --git a/crates/ui-egui/src/function/search.rs b/crates/ui-egui/src/function/search.rs new file mode 100644 index 0000000..243f01d --- /dev/null +++ b/crates/ui-egui/src/function/search.rs @@ -0,0 +1,180 @@ +//! The node search of Function canvases (Space, Tab, a double-click, or a wire dropped on empty +//! canvas): the operations the canvas takes, then the library's functions. A search opened from a +//! wire connects the new node to it. + +use super::FunctionEditor; +use super::library::FunctionLibraryDrag; +use crate::{MaterialCraftApp, graph::GraphCamera, i18n::tr, theme::Tokens}; +use egui::{Pos2, Ui}; +use egui_phosphor::regular as icon; +use materialcraft_engine::{FunctionEdit, LibraryItem}; + +/// The wire a search was opened from +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) enum SearchWire { + /// Dragged from this node's output: the new node takes it on its first input + From(u32), + /// Dragged from this node's input slot: the new node's output feeds it + To(u32, usize), +} + +#[derive(Clone, Debug)] +pub(crate) struct FunctionSearch { + /// Where the new node goes, in canvas coordinates + pub(crate) at: Pos2, + pub(crate) text: String, + pub(crate) sel: usize, + pub(crate) wire: Option<SearchWire>, + pub(crate) focus: bool, +} + +impl FunctionSearch { + pub(crate) fn at(at: Pos2, wire: Option<SearchWire>) -> Self { + Self { at, text: String::new(), sel: 0, wire, focus: true } + } +} + +/// One search result: its label, what it is (shown dimmed on the right) and what adding it does +#[derive(Clone, Debug)] +pub(crate) struct Candidate { + pub(crate) label: String, + pub(crate) group: String, + pub(crate) entry: FunctionLibraryDrag, +} + +/// Every operation the canvas takes, then the library's functions, matching all words of `text` +/// (label, id or group), names that start with the first word first +pub(crate) fn candidates(app: &MaterialCraftApp, editor: &FunctionEditor, text: &str) -> Vec<Candidate> { + let Some(target) = editor.command_target() else { return Vec::new() }; + let mut all: Vec<(String, Candidate)> = target + .available_operations(&app.session) + .map(|operation| { + let candidate = Candidate { + label: tr(operation.label).to_string(), + group: tr(operation.category).to_string(), + entry: FunctionLibraryDrag::Operation(operation.id.into()), + }; + (operation.id.to_string(), candidate) + }) + .collect(); + for entry in app.session.library_entries() { + if let LibraryItem::FunctionInstance { package, graph } = &entry.item + && entry.missing.is_none() + { + let group = entry.category.rsplit('/').next().unwrap_or(&entry.category).to_string(); + let candidate = + Candidate { label: entry.label.clone(), group, entry: FunctionLibraryDrag::Instance { package: package.clone(), graph: graph.clone() } }; + all.push((graph.clone(), candidate)); + } + } + let words: Vec<String> = text.split_whitespace().map(str::to_lowercase).collect(); + let mut found: Vec<Candidate> = all + .into_iter() + .filter(|(id, candidate)| { + let haystack = format!("{} {} {}", candidate.label.to_lowercase(), id.to_lowercase(), candidate.group.to_lowercase()); + words.iter().all(|word| haystack.contains(word.as_str())) + }) + .map(|(_, candidate)| candidate) + .collect(); + if let Some(first) = words.first() { + found.sort_by_key(|candidate| !candidate.label.to_lowercase().starts_with(first.as_str())); + } + found +} + +/// Add `candidate` at the search position and connect it to the wire the search came from +pub(crate) fn pick(app: &mut MaterialCraftApp, editor: &mut FunctionEditor, search: &FunctionSearch, candidate: &Candidate) { + let before = editor.selection.clone(); + let at = [search.at.x - crate::graph::NODE_W * 0.5, search.at.y - 20.0]; + super::library::insert(app, editor, &candidate.entry, at); + let Some(&id) = editor.selection.first().filter(|_| editor.selection != before && editor.selection.len() == 1) else { return }; + + match search.wire { + Some(SearchWire::From(from)) => { + // Nodes without inputs (constants, variables) take no wire + let inputs = editor.current(app).and_then(|graph| graph.node(id)).map_or(0, |node| node.inputs.len()); + if inputs > 0 { + editor.edit(app, FunctionEdit::Connect { from, to: id, input: 0 }, false); + } + } + Some(SearchWire::To(to, input)) => editor.edit(app, FunctionEdit::Connect { from: id, to, input }, false), + None => {} + } + editor.selection = vec![id]; + editor.inspected_node = Some(id); +} + +pub(super) fn show(app: &mut MaterialCraftApp, editor: &mut FunctionEditor, ui: &mut Ui, camera: &GraphCamera) { + let blocked = crate::shell::modality::Modality::capture(app, ui.ctx()).is_blocked(); + let Some(mut search) = editor.search.take() else { return }; + + let tokens = Tokens::get(ui.ctx()); + let list = candidates(app, editor, &search.text); + let area = egui::Id::unique("function-node-search"); + let mut close = false; + let mut chosen = None; + egui::Area::new(area).fixed_pos(camera.to_screen(search.at)).order(egui::Order::Foreground).show(ui.ctx(), |ui| { + egui::Frame::popup(ui.style()).show(ui, |ui| { + ui.set_width(280.0); + if blocked { + ui.disable(); + search.focus = true; + } + let mut reveal = search.focus; + ui.horizontal(|ui| { + ui.label(egui::RichText::new(icon::MAGNIFYING_GLASS).color(tokens.text_dim)); + let field = ui.add(egui::TextEdit::singleline(&mut search.text).hint_text(tr("Search functions...")).desired_width(240.0)); + crate::widgets::name(&field, egui::Role::SearchInput, "Search functions"); + if search.focus && !blocked { + field.request_focus(); + search.focus = false; + } + if field.changed() { + search.sel = 0; + reveal = true; + } + }); + // The list reflects the text typed this frame on the next one + let (up, down, enter, escape) = ui.input(|input| { + let pressed = |key| !blocked && input.key_pressed(key); + (pressed(egui::Key::ArrowUp), pressed(egui::Key::ArrowDown), pressed(egui::Key::Enter), pressed(egui::Key::Escape)) + }); + if down { + search.sel = (search.sel + 1).min(list.len().saturating_sub(1)); + } + if up { + search.sel = search.sel.saturating_sub(1); + } + close |= escape; + if enter { + chosen = list.get(search.sel).cloned(); + } + egui::ScrollArea::vertical().max_height(320.0).show(ui, |ui| { + for (index, candidate) in list.iter().enumerate() { + let row = ui.add( + egui::Button::selectable(index == search.sel, format!("{} ", candidate.label)) + .min_size(egui::vec2(ui.available_width(), 0.0)) + .right_text(egui::RichText::new(&candidate.group).size(10.0).color(tokens.text_dim)), + ); + if index == search.sel && (up || down || reveal) { + row.scroll_to_me(None); + } + if row.clicked() { + chosen = Some(candidate.clone()); + } + } + if list.is_empty() { + ui.label(egui::RichText::new(tr("No matching node")).color(tokens.text_dim)); + } + }); + }); + }); + let clicked_outside = !blocked + && ui.input(|input| input.pointer.any_pressed()) + && ui.ctx().pointer_interact_pos().is_some_and(|pointer| !ui.ctx().layer_id_at(pointer).is_some_and(|layer| layer.id == area)); + if let Some(candidate) = chosen.filter(|_| !blocked) { + pick(app, editor, &search, &candidate); + } else if !close && !clicked_outside { + editor.search = Some(search); + } +} diff --git a/crates/ui-egui/src/graph/function_search_tests.rs b/crates/ui-egui/src/graph/function_search_tests.rs new file mode 100644 index 0000000..c689df1 --- /dev/null +++ b/crates/ui-egui/src/graph/function_search_tests.rs @@ -0,0 +1,149 @@ +//! The node search of Function canvases: keys, double-click and wires dropped on empty canvas + +use egui::{Event, Key, Modifiers, PointerButton, Pos2, vec2}; +use materialcraft_engine::core::{FunctionGraph, Value}; +use materialcraft_engine::new_session; +use serde_json::json; + +use super::frames::Frames; +use crate::function::search::{FunctionSearch, SearchWire}; + +fn press(key: Key) -> Event { + Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE } +} + +/// A Function Graph holding one constant, framed in the canvas +fn function_canvas() -> (Frames, u32) { + let mut frames = Frames::new(new_session()); + frames.app.run("file.new", json!({"kind": "function"})).unwrap(); + let mut graph = FunctionGraph::default(); + let constant = graph.add_constant(Value::Float(2.0)); + graph.output = Some(constant); + frames.app.run("graph.function.set", json!({"function": graph})).unwrap(); + frames.app.ui.frame_all = true; + for _ in 0..4 { + frames.run(Vec::new(), Modifiers::NONE); + } + (frames, constant) +} + +fn search(frames: &Frames) -> Option<FunctionSearch> { + frames.app.function_editor.as_ref().and_then(|editor| editor.search.clone()) +} + +fn empty(frames: &Frames) -> Pos2 { + frames.app.graph.view.min + vec2(40.0, 40.0) +} + +fn port(frames: &Frames, node: u32, port: &str) -> Pos2 { + frames + .app + .graph + .ports + .iter() + .find(|hit| hit.node.0 == u64::from(node) && hit.port == port) + .map(|hit| hit.pos) + .unwrap_or_else(|| panic!("no port {node}:{port}")) +} + +fn drag(frames: &mut Frames, from: Pos2, to: Pos2) { + frames.run(vec![Event::PointerMoved(from)], Modifiers::NONE); + frames.run(vec![Event::PointerButton { pos: from, button: PointerButton::Primary, pressed: true, modifiers: Modifiers::NONE }], Modifiers::NONE); + for step in 1..=8 { + frames.run(vec![Event::PointerMoved(from.lerp(to, step as f32 / 8.0))], Modifiers::NONE); + } + frames.run(vec![Event::PointerButton { pos: to, button: PointerButton::Primary, pressed: false, modifiers: Modifiers::NONE }], Modifiers::NONE); + frames.run(Vec::new(), Modifiers::NONE); +} + +/// Type `text` into the open search and pick the first result with Enter +fn choose(frames: &mut Frames, text: &str) { + frames.run(Vec::new(), Modifiers::NONE); + frames.run(vec![Event::Text(text.into())], Modifiers::NONE); + frames.run(Vec::new(), Modifiers::NONE); + frames.run(vec![press(Key::Enter)], Modifiers::NONE); + frames.run(Vec::new(), Modifiers::NONE); +} + +fn nodes(frames: &Frames) -> Vec<(u32, String, Vec<Option<u32>>)> { + let function = frames.app.session.graph().unwrap().function.as_ref().unwrap(); + function.nodes.iter().map(|node| (node.id, node.op.clone(), node.inputs.clone())).collect() +} + +#[test] +fn space_tab_and_double_click_open_the_search_and_enter_adds() { + let (mut frames, _) = function_canvas(); + for key in [Key::Space, Key::Tab] { + frames.run(vec![Event::PointerMoved(empty(&frames))], Modifiers::NONE); + frames.run(vec![press(key)], Modifiers::NONE); + let opened = search(&frames).unwrap_or_else(|| panic!("{key:?} opens the search")); + assert_eq!(opened.wire, None); + frames.run(vec![press(Key::Escape)], Modifiers::NONE); + assert!(search(&frames).is_none(), "Escape closes it"); + } + + // Away from the canvas, the keys open nothing + frames.run(vec![Event::PointerMoved(Pos2::new(5.0, 5.0))], Modifiers::NONE); + frames.run(vec![press(Key::Space)], Modifiers::NONE); + assert!(search(&frames).is_none()); + + let at = empty(&frames); + frames.time += 1.0; + frames.run(vec![Event::PointerMoved(at)], Modifiers::NONE); + for pressed in [true, false, true, false] { + frames.run(vec![Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE }], Modifiers::NONE); + } + assert!(search(&frames).is_some(), "a double-click on empty canvas opens the search"); + + let before = nodes(&frames).len(); + choose(&mut frames, "add"); + assert!(search(&frames).is_none()); + let nodes = nodes(&frames); + assert_eq!(nodes.len(), before + 1); + assert!(nodes.iter().any(|(_, op, _)| op == "add")); +} + +#[test] +fn wires_dropped_on_empty_canvas_search_and_connect_the_new_node() { + let (mut frames, constant) = function_canvas(); + + // From an output: the new node takes the wire on its first input + let from = port(&frames, constant, "output"); + drag(&mut frames, from, from + vec2(260.0, -60.0)); + assert_eq!(search(&frames).unwrap().wire, Some(SearchWire::From(constant))); + choose(&mut frames, "add"); + let (add, _, inputs) = nodes(&frames).into_iter().find(|(_, op, _)| op == "add").unwrap(); + assert_eq!(inputs, [Some(constant), None]); + + // From an unconnected input: the new node's output feeds it + frames.run(Vec::new(), Modifiers::NONE); + let input = port(&frames, add, "1"); + let drop = input + vec2(-40.0, 110.0); + assert!(frames.app.graph.view.contains(input) && frames.app.graph.view.contains(drop)); + drag(&mut frames, input, drop); + assert_eq!(search(&frames).unwrap().wire, Some(SearchWire::To(add, 1))); + choose(&mut frames, "Float"); + let nodes = nodes(&frames); + let (_, _, inputs) = nodes.iter().find(|(id, _, _)| *id == add).unwrap(); + let fed = inputs[1].unwrap(); + assert_eq!(nodes.iter().find(|(id, _, _)| *id == fed).unwrap().1, "const_float1"); + + // A click on a port is not a drop on empty canvas + frames.click(port(&frames, constant, "output"), Modifiers::NONE); + assert!(search(&frames).is_none()); +} + +#[test] +fn the_toolbar_adds_common_function_nodes_wired_from_the_selection() { + let (mut frames, constant) = function_canvas(); + let editor = frames.app.function_editor.as_mut().unwrap(); + editor.selection = vec![constant]; + crate::function::library::add_near_selection(&mut frames.app, "add"); + let (_, _, inputs) = nodes(&frames).into_iter().find(|(_, op, _)| op == "add").unwrap(); + assert_eq!(inputs, [Some(constant), None]); + + // With nothing selected, a constant goes in the middle of the view, unwired + frames.app.function_editor.as_mut().unwrap().selection.clear(); + crate::function::library::add_near_selection(&mut frames.app, "const_float2"); + assert!(nodes(&frames).iter().any(|(_, op, _)| op == "const_float2")); +} diff --git a/crates/ui-egui/src/graph/input.rs b/crates/ui-egui/src/graph/input.rs index 9e2a5bb..b7dc4b3 100644 --- a/crates/ui-egui/src/graph/input.rs +++ b/crates/ui-egui/src/graph/input.rs @@ -1,5 +1,10 @@ use super::{GraphCamera, GraphDrag, LibraryDrag, NODE_W, PortHit, WireRef}; -use super::{navigation::frame, port_hit::nearest as nearest_port, search::open_search, wire_actions::wire_menu}; +use super::{ + navigation::frame, + port_hit::nearest as nearest_port, + search::{open_search, open_search_to}, + wire_actions::wire_menu, +}; use crate::MaterialCraftApp; use egui::{Rect, Ui, Vec2}; use materialcraft_engine::core::NodeId; @@ -140,9 +145,14 @@ pub(super) fn handle( } } GraphDrag::InputWire { to } => { - // Dropped anywhere but on another node's output, the input stays unconnected if let Some(source) = drop_target(&app.graph.ports, pointer, true).filter(|source| source.node != to.0) { app.run("graph.connect", json!({"from": source.node.0, "fromPort": source.port, "to": to.0.0, "toPort": to.1})); + } else if let Some(position) = pointer + && rect.contains(position) + && nearest_port(&app.graph.ports, position, 12.0).is_none() + { + // Dropped on empty canvas: search for a node whose output feeds the input + open_search_to(app, &context, camera.to_graph(position), to); } } GraphDrag::Frame { .. } | GraphDrag::Comment { .. } => super::annotation_input::finish(app, drag), diff --git a/crates/ui-egui/src/graph/interaction_tests.rs b/crates/ui-egui/src/graph/interaction_tests.rs index acb396f..42b7172 100644 --- a/crates/ui-egui/src/graph/interaction_tests.rs +++ b/crates/ui-egui/src/graph/interaction_tests.rs @@ -838,15 +838,20 @@ fn wires_pulled_from_an_unconnected_input_connect_on_an_output() { let empty = frames.app.graph.view.left_bottom() + vec2(24.0, -24.0); assert!(!frames.app.graph.rects.iter().any(|(_, rect)| rect.expand(12.0).contains(empty)), "the drop point must be empty canvas"); - // A click, and drops on empty canvas, on another input and on the node's own output leave the input unconnected + // A click, and drops on another input and on the node's own output leave the input unconnected let history = frames.app.session.history(); frames.click(inputs[0].pos, Modifiers::NONE); frames.time += 1.0; - for end in [empty, inputs[1].pos, ports(&frames, target, true)[0].pos] { + assert!(frames.app.graph.search.is_none(), "a click on an input opens nothing"); + for end in [inputs[1].pos, ports(&frames, target, true)[0].pos] { drag(&mut frames, inputs[0].pos, end); } + assert!(frames.app.graph.search.is_none()); + // Dropped on empty canvas, it searches for a node to feed the input, as an output wire does + drag(&mut frames, inputs[0].pos, empty); + assert!(frames.app.graph.search.as_ref().is_some_and(|search| search.connect_to == Some((target, inputs[0].port.clone())))); + frames.app.graph.search = None; assert!(wires(&frames).is_empty()); - assert!(frames.app.graph.search.is_none(), "an input wire dropped on empty canvas does not open the node search"); assert_eq!(frames.app.session.history(), history, "a missed wire must not add an undo step"); // While dragging, the wire is pulled from the input; dropped on the output, it connects diff --git a/crates/ui-egui/src/graph/mod.rs b/crates/ui-egui/src/graph/mod.rs index 08076b3..b569c97 100644 --- a/crates/ui-egui/src/graph/mod.rs +++ b/crates/ui-egui/src/graph/mod.rs @@ -7,6 +7,8 @@ mod context_menu; pub(crate) mod frame_hit; #[cfg(test)] mod frames; +#[cfg(test)] +mod function_search_tests; mod graph_camera; mod graph_drag; pub(crate) mod graph_parent; diff --git a/crates/ui-egui/src/graph/modality_tests.rs b/crates/ui-egui/src/graph/modality_tests.rs index ea244f0..31ecb94 100644 --- a/crates/ui-egui/src/graph/modality_tests.rs +++ b/crates/ui-egui/src/graph/modality_tests.rs @@ -46,7 +46,9 @@ fn corner(frames: &Frames) -> Pos2 { } fn add_menu_open(frames: &Frames) -> bool { - frames.app.graph.search.is_some() || egui::Popup::is_any_open(&frames.ctx) + frames.app.graph.search.is_some() + || frames.app.function_editor.as_ref().is_some_and(|editor| editor.search.is_some()) + || egui::Popup::is_any_open(&frames.ctx) } #[test] diff --git a/crates/ui-egui/src/graph/node_search.rs b/crates/ui-egui/src/graph/node_search.rs index b25f646..334bce0 100644 --- a/crates/ui-egui/src/graph/node_search.rs +++ b/crates/ui-egui/src/graph/node_search.rs @@ -8,5 +8,7 @@ pub(super) struct NodeSearch { pub(super) text: String, pub(super) sel: usize, pub(super) connect: Option<(NodeId, String)>, + /// Opened from this input (a wire dragged off it): the new node's output feeds it + pub(super) connect_to: Option<(NodeId, String)>, pub(super) focus: bool, } diff --git a/crates/ui-egui/src/graph/search.rs b/crates/ui-egui/src/graph/search.rs index 8a3eff0..055092a 100644 --- a/crates/ui-egui/src/graph/search.rs +++ b/crates/ui-egui/src/graph/search.rs @@ -9,7 +9,15 @@ pub(super) fn open_search(app: &mut MaterialCraftApp, ctx: &egui::Context, at: P if crate::shell::modality::Modality::capture(app, ctx).is_blocked() { return; } - app.graph.search = Some(NodeSearch { at, text: String::new(), sel: 0, connect, focus: true }); + app.graph.search = Some(NodeSearch { at, text: String::new(), sel: 0, connect, connect_to: None, focus: true }); +} + +/// The search for a node whose output feeds input `to` (a wire dragged off it onto empty canvas) +pub(super) fn open_search_to(app: &mut MaterialCraftApp, ctx: &egui::Context, at: Pos2, to: (NodeId, String)) { + open_search(app, ctx, at, None); + if let Some(search) = app.graph.search.as_mut() { + search.connect_to = Some(to); + } } /// Catalog entries matching `text` (label or id contains every word) @@ -58,7 +66,11 @@ pub(super) fn show(app: &mut MaterialCraftApp, ui: &mut Ui, cam: &GraphCamera) { reveal_selection = true; } }); - let list = matches(&s.text); + // Feeding an input needs a node with an output + let mut list = matches(&s.text); + if s.connect_to.is_some() { + list.retain(|definition| !definition.outputs.is_empty()); + } let (up, down, enter, esc) = ui.input(|i| { let pressed = |key| !blocked && i.key_pressed(key); (pressed(egui::Key::ArrowUp), pressed(egui::Key::ArrowDown), pressed(egui::Key::Enter), pressed(egui::Key::Escape)) @@ -105,7 +117,12 @@ pub(super) fn show(app: &mut MaterialCraftApp, ui: &mut Ui, cam: &GraphCamera) { if let Some((n, port)) = s.connect { p["connectFrom"] = json!({"node": n.0, "port": port}); } - app.run("graph.node.add", p); + let added = app.run("graph.node.add", p).and_then(|result| result.get("id").and_then(serde_json::Value::as_u64)).map(NodeId); + if let (Some(id), Some((to, port))) = (added, s.connect_to) + && let Some(output) = app.session.output_ports(id).first().cloned() + { + app.run("graph.connect", json!({"from": id.0, "fromPort": output, "to": to.0, "toPort": port})); + } } } else if close || clicked_out { app.graph.search = None; diff --git a/crates/ui-egui/src/graph/toolbar.rs b/crates/ui-egui/src/graph/toolbar.rs index c880127..541c3f0 100644 --- a/crates/ui-egui/src/graph/toolbar.rs +++ b/crates/ui-egui/src/graph/toolbar.rs @@ -47,37 +47,6 @@ pub(super) fn show(app: &mut MaterialCraftApp, ui: &mut Ui) { } } - if !pattern && !function { - // Quick insert of the atomic nodes - for (ic, def) in [ - (icon::IMAGE, "bitmap"), - (icon::PALETTE, "uniform"), - (icon::STACK, "blend"), - (icon::DROP, "blur"), - (icon::SHUFFLE, "channels_shuffle"), - (icon::CHART_LINE, "curve"), - (icon::WIND, "directional_blur"), - (icon::ARROWS_OUT_LINE_HORIZONTAL, "directional_warp"), - (icon::RULER, "distance"), - (icon::MOUNTAINS, "emboss"), - (icon::GRADIENT, "gradient_map"), - (icon::CIRCLE_HALF, "grayscale_conversion"), - (icon::SWATCHES, "hsl"), - (icon::SLIDERS_HORIZONTAL, "levels"), - (icon::CUBE, "normal"), - (icon::CODE, "pixel_processor"), - (icon::DIAMOND, "sharpen"), - (icon::ARROWS_CLOCKWISE, "transformation"), - (icon::WAVES, "warp"), - (icon::SIGN_IN, "input_grayscale"), - (icon::SIGN_OUT, "output"), - ] { - let label = materialcraft_engine::nodes::find(def).map_or(def, |d| d.label); - if b(ui, ic, label) { - add_node_near_selection(app, def); - } - } - } ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| { if super::subgraph_navigation::can_return(app) { if b(ui, icon::ARROW_BEND_UP_LEFT, tr("Return to parent graph")) { @@ -97,8 +66,81 @@ pub(super) fn show(app: &mut MaterialCraftApp, ui: &mut Ui) { } }); }); + // A second row inserts nodes with one click, like the Library's most common entries + if !pattern { + row(ui, |ui| quick_nodes(app, ui, function)); + } } +/// The atomic nodes of a graph, or the common nodes of a Function canvas, as one-click buttons +fn quick_nodes(app: &mut MaterialCraftApp, ui: &mut Ui, function: bool) { + if function { + let available = crate::function::library::available_operations(app); + for (index, group) in crate::function::library::QUICK.iter().enumerate() { + if index > 0 { + ui.separator(); + } + for (operation, glyph) in *group { + let label = materialcraft_engine::nodes::function::definition(operation).map_or(*operation, |definition| definition.label); + // "New … node" keeps the button apart from the canvas nodes of the same name + let tooltip = crate::i18n::trf("New {node} node", &[("node", &tr(label))]); + if ui.add_enabled_ui(available.contains(operation), |ui| button(ui, glyph, &tooltip)).inner { + crate::function::library::add_near_selection(app, operation); + } + } + } + return; + } + for (index, group) in ATOMIC_QUICK.iter().enumerate() { + if index > 0 { + ui.separator(); + } + for (ic, def) in *group { + let label = materialcraft_engine::nodes::find(def).map_or(*def, |d| d.label); + if button(ui, ic, tr(label)) { + add_node_near_selection(app, def); + } + } + } +} + +/// The atomic nodes on the graph toolbar, in groups +const ATOMIC_QUICK: &[&[(&str, &str)]] = &[ + &[ + (icon::IMAGE, "bitmap"), + (icon::STACK, "blend"), + (icon::DROP, "blur"), + (icon::SHUFFLE, "channels_shuffle"), + (icon::CHART_LINE, "curve"), + (icon::WIND, "directional_blur"), + (icon::ARROWS_OUT_LINE_HORIZONTAL, "directional_warp"), + (icon::RULER, "distance"), + (icon::MOUNTAINS, "emboss"), + (icon::SQUARES_FOUR, "fx_map"), + (icon::ARROWS_DOWN_UP, "gradient_dynamic"), + (icon::GRADIENT, "gradient_map"), + (icon::CIRCLE_HALF, "grayscale_conversion"), + (icon::SWATCHES, "hsl"), + (icon::SLIDERS_HORIZONTAL, "levels"), + (icon::CUBE, "normal"), + (icon::CODE, "pixel_processor"), + (icon::BEZIER_CURVE, "svg"), + (icon::DIAMOND, "sharpen"), + (icon::TEXT_T, "text"), + (icon::ARROWS_CLOCKWISE, "transformation"), + (icon::PALETTE, "uniform"), + (icon::FUNCTION, "value_processor"), + (icon::WAVES, "warp"), + ], + &[ + (icon::PAINT_BUCKET, "input_color"), + (icon::SIGN_IN, "input_grayscale"), + (icon::HASH, "input_value"), + (icon::SIGN_OUT, "output"), + (icon::DOT_OUTLINE, "dot"), + ], +]; + fn row(ui: &mut Ui, draw: impl FnOnce(&mut Ui)) { let tokens = Tokens::get(ui.ctx()); egui::Frame::NONE.fill(tokens.panel).inner_margin(egui::Margin::symmetric(6, 3)).show(ui, |ui| { diff --git a/crates/ui-egui/src/library.rs b/crates/ui-egui/src/library.rs index 5227ff3..759ecfe 100644 --- a/crates/ui-egui/src/library.rs +++ b/crates/ui-egui/src/library.rs @@ -285,6 +285,8 @@ pub(crate) fn visible<'a>(app: &MaterialCraftApp, entries: &'a [LibraryEntry], h .iter() .filter(|entry| app.ui.library_show_missing || entry.missing.is_none()) .filter(|entry| app.ui.library_show_other || entry.canvas == here.canvas) + // The open canvas hides its own kind of entry it can't take (a value processor can't sample images) + .filter(|entry| entry.canvas != here.canvas || entry.missing.is_some() || here.takes(entry)) .filter_map(|entry| { if !search.is_empty() { let label = entry.label.to_lowercase(); diff --git a/crates/ui-egui/src/library.test.rs b/crates/ui-egui/src/library.test.rs index 522ca15..1e9e15c 100644 --- a/crates/ui-egui/src/library.test.rs +++ b/crates/ui-egui/src/library.test.rs @@ -76,6 +76,8 @@ fn processor_functions_take_operations_their_canvas_allows() { 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"); + app.ui.library_search = "sample".into(); + assert!(!labels(&app).iter().any(|label| label == "Sample color"), "and the library hides what the canvas can't take"); assert!(!here.takes(find("node:blur"))); assert!(here.refusal(find("node:blur")).is_some()); } diff --git a/crates/ui-egui/tests/snapshot.rs b/crates/ui-egui/tests/snapshot.rs index afede05..be9e6ec 100644 --- a/crates/ui-egui/tests/snapshot.rs +++ b/crates/ui-egui/tests/snapshot.rs @@ -16,6 +16,9 @@ mod embedded_graphs; #[path = "snapshot/library.rs"] mod library; +#[path = "snapshot/node_search.rs"] +mod node_search; + use std::time::Duration; use egui::vec2; diff --git a/crates/ui-egui/tests/snapshot/function_library.rs b/crates/ui-egui/tests/snapshot/function_library.rs index 615254c..bf31310 100644 --- a/crates/ui-egui/tests/snapshot/function_library.rs +++ b/crates/ui-egui/tests/snapshot/function_library.rs @@ -80,7 +80,8 @@ fn bottom_library_drags_functions_into_function_and_processor_canvases() { harness.state_mut().ui.library_search = "MissingFunction".into(); settle(&mut harness, 3); - drag(&mut harness, "MissingFunction", vec2(160.0, 180.0)); + // The canvas sits under the two toolbar rows; drop above its lower edge + drag(&mut harness, "MissingFunction", vec2(160.0, 110.0)); let missing = target .current(&harness.state().session) diff --git a/crates/ui-egui/tests/snapshot/node_search.rs b/crates/ui-egui/tests/snapshot/node_search.rs new file mode 100644 index 0000000..f7677ab --- /dev/null +++ b/crates/ui-egui/tests/snapshot/node_search.rs @@ -0,0 +1,40 @@ +use super::{By, MaterialCraftApp, Queryable, UiState, harness, json, save, settle}; +use egui::accesskit::Role; + +#[test] +#[ignore = "requires an offscreen GPU; run explicitly with --ignored"] +fn graph_toolbars_and_the_function_node_search() { + 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); + // Every atomic node has a toolbar button + for label in ["Bitmap", "FX-Map", "SVG", "Text", "Value processor", "Input color", "Input value", "Output"] { + assert!(harness.query_all(By::new().role(Role::Button).label(label)).next().is_some(), "{label}"); + } + save(&mut harness, &directory, "graph-toolbar-material"); + + harness.state_mut().run("file.new", json!({"kind": "function", "name": "Search"})).unwrap(); + settle(&mut harness, 5); + for label in ["Float", "Add", "Division", "Linear interpolation", "If...Else", "Sample color"] { + let label = format!("New {label} node"); + assert!(harness.query(By::new().role(Role::Button).label(&label)).is_some(), "function toolbar: {label}"); + } + harness.get(By::new().role(Role::Button).label("New Float node")).click(); + settle(&mut harness, 3); + let center = harness.state().graph.view.center(); + harness.event(egui::Event::PointerMoved(center + egui::vec2(-200.0, -120.0))); + harness.step(); + harness.key_press(egui::Key::Space); + settle(&mut harness, 3); + assert!(harness.query(By::new().label("Search functions")).is_some()); + harness.event(egui::Event::Text("pi".into())); + settle(&mut harness, 3); + save(&mut harness, &directory, "function-node-search"); + harness.key_press(egui::Key::Enter); + settle(&mut harness, 3); + let function = harness.state().session.graph().unwrap().function.as_ref().unwrap(); + assert_eq!(function.nodes.len(), 2, "the toolbar's Float and the searched node"); + save(&mut harness, &directory, "graph-toolbar-function"); +} diff --git a/docs/atomic-workflow.md b/docs/atomic-workflow.md index 9ef2c15..8480a86 100644 --- a/docs/atomic-workflow.md +++ b/docs/atomic-workflow.md @@ -12,6 +12,11 @@ function, combines its gradient with an iterated pattern, and blurs the result. output and a value output. Use the library or Space search to add primitives and drag between ports to connect them. +Space, Tab or a double-click on empty canvas opens the node search in graphs and Function canvases +alike; a Function canvas lists the operations it takes, then the library's functions. Drop a wire +from an output or an input on empty canvas to search for a node that connects to it. The graph +toolbar's second row adds every atomic node with one click; in a Function canvas it adds the common +function nodes, wired from the selected node when it has an input. Select a Value Processor or Pixel Processor and choose **Edit function** in Properties. The function editor supports adding operations, editing constants and wiring ports. Right-click a function node and choose **Set as output node** to designate the result. Its body turns orange, From bc2f20b36509da8f316409d7d195137fac5f7bea Mon Sep 17 00:00:00 2001 From: chasse20 <chasse20@gmail.com> Date: Mon, 9 Nov 2026 23:59:27 -0500 Subject: [PATCH 4/5] Fix library review, graph annotations and processor sampling --- assets/sbs/functions.sbs | 2 +- crates/core/src/canvas_annotations.rs | 32 ++++ crates/core/src/function_graph.rs | 2 + crates/core/src/lib.rs | 2 + crates/core/src/pattern_graph.rs | 3 + crates/engine/src/annotation_commands.rs | 10 +- crates/engine/src/annotation_selection.rs | 6 +- crates/engine/src/annotation_target.rs | 150 +++++++++++++++ crates/engine/src/commands.rs | 5 +- crates/engine/src/comment_commands.rs | 22 ++- crates/engine/src/edit_cmds.rs | 15 +- crates/engine/src/frame_commands.rs | 37 ++-- crates/engine/src/function_graph_target.rs | 7 +- crates/engine/src/graph_cmds.rs | 25 +-- crates/engine/src/inspect.rs | 1 + crates/engine/src/lib.rs | 6 + crates/engine/src/linked_packages.rs | 14 ++ crates/engine/src/node_library.rs | 161 +++++++--------- crates/engine/src/node_library.test.rs | 38 +++- .../engine/src/node_library/library_canvas.rs | 11 ++ .../engine/src/node_library/library_entry.rs | 22 +++ .../engine/src/node_library/library_item.rs | 51 ++++++ .../src/node_library/library_placement.rs | 8 + crates/engine/src/node_library_commands.rs | 75 +++++++- .../engine/src/node_library_commands.test.rs | 46 +++++ crates/engine/src/open_document.rs | 5 + crates/engine/src/pin_commands.rs | 65 +++++++ crates/engine/src/session.rs | 22 ++- crates/engine/src/snapshot.rs | 1 + crates/engine/tests/it/annotations.rs | 107 +++++++++++ crates/engine/tests/it/embedded_edit.rs | 59 ++++-- crates/engine/tests/it/node_library.rs | 48 ++++- crates/engine/tests/support/node_library.rs | 27 +++ crates/eval/src/tests.rs | 6 +- .../standard_function_library/convert.rs | 2 - .../standard_function_library/tests.rs | 26 ++- crates/formats/src/sbs/canvas.rs | 17 +- crates/formats/src/sbs/function_graph.rs | 12 +- crates/formats/src/sbs/layout_frame.rs | 10 + crates/formats/src/sbs/layout_item.rs | 17 ++ crates/formats/src/sbs/library.rs | 8 + crates/formats/src/sbs/library_layout.rs | 55 +++--- crates/formats/src/sbs/mod.rs | 6 +- crates/formats/src/sbs/pattern_graph.rs | 12 +- crates/formats/src/sbs/sbs_reader.rs | 5 +- crates/formats/tests/function_library.rs | 12 +- .../src/annotation/comment_properties.rs | 8 +- .../src/annotation/frame_properties.rs | 2 +- crates/ui-egui/src/annotation/mod.rs | 38 ++++ .../ui-egui/src/annotation/pin_properties.rs | 28 +++ crates/ui-egui/src/control.rs | 2 + crates/ui-egui/src/explorer.rs | 8 +- crates/ui-egui/src/explorer/actions.rs | 7 + crates/ui-egui/src/explorer/context_menu.rs | 36 +--- .../src/explorer/explorer_menu_state.rs | 28 +++ crates/ui-egui/src/explorer/explorer_row.rs | 9 + crates/ui-egui/src/explorer/explorer_tree.rs | 3 +- crates/ui-egui/src/function/actions.rs | 8 +- crates/ui-egui/src/function/canvas.rs | 34 ++-- crates/ui-egui/src/function/context_menu.rs | 10 +- .../ui-egui/src/function/function_canvas.rs | 1 + .../ui-egui/src/function/function_editor.rs | 4 + crates/ui-egui/src/function/geometry.rs | 6 +- crates/ui-egui/src/function/input.rs | 22 ++- crates/ui-egui/src/function/library.rs | 3 +- crates/ui-egui/src/function/render.rs | 24 +-- crates/ui-egui/src/graph/actions.rs | 16 +- crates/ui-egui/src/graph/annotation_canvas.rs | 22 ++- crates/ui-egui/src/graph/annotation_input.rs | 43 ++++- crates/ui-egui/src/graph/canvas.rs | 6 +- crates/ui-egui/src/graph/editor_target.rs | 9 +- crates/ui-egui/src/graph/graph_drag.rs | 4 + crates/ui-egui/src/graph/graph_view.rs | 12 +- crates/ui-egui/src/graph/input.rs | 21 ++- crates/ui-egui/src/graph/interaction_tests.rs | 55 ++++++ crates/ui-egui/src/graph/toolbar.rs | 10 +- crates/ui-egui/src/library.rs | 172 ++++++++---------- crates/ui-egui/src/library.test.rs | 111 ++++++++--- crates/ui-egui/src/library/library_target.rs | 48 +++++ crates/ui-egui/src/material_craft_app.rs | 25 +++ crates/ui-egui/src/material_craft_app.test.rs | 14 ++ crates/ui-egui/src/menus.rs | 116 ++++++++---- crates/ui-egui/src/pattern/actions.rs | 16 +- crates/ui-egui/src/pattern/canvas.rs | 42 ++++- crates/ui-egui/src/pattern/context_menu.rs | 7 + crates/ui-egui/src/pattern/input.rs | 27 ++- crates/ui-egui/src/pattern/mod.rs | 1 + crates/ui-egui/src/pattern/pattern_canvas.rs | 12 ++ crates/ui-egui/src/pattern/pattern_editor.rs | 9 + crates/ui-egui/src/property/mod.rs | 5 +- crates/ui-egui/tests/snapshot.rs | 24 ++- .../tests/snapshot/function_library.rs | 41 +++++ crates/ui-egui/tests/snapshot/graph_items.rs | 68 +++++++ crates/ui-egui/tests/snapshot/library.rs | 4 + crates/ui-egui/tests/snapshot/menu.rs | 55 ++++++ docs/architecture.md | 2 +- docs/atomic-workflow.md | 7 +- docs/control-protocol.md | 30 ++- docs/file-format-parity.md | 9 +- 99 files changed, 2051 insertions(+), 546 deletions(-) create mode 100644 crates/core/src/canvas_annotations.rs create mode 100644 crates/engine/src/annotation_target.rs create mode 100644 crates/engine/src/node_library/library_canvas.rs create mode 100644 crates/engine/src/node_library/library_entry.rs create mode 100644 crates/engine/src/node_library/library_item.rs create mode 100644 crates/engine/src/node_library/library_placement.rs create mode 100644 crates/engine/src/node_library_commands.test.rs create mode 100644 crates/engine/src/pin_commands.rs create mode 100644 crates/engine/tests/support/node_library.rs create mode 100644 crates/formats/src/sbs/layout_frame.rs create mode 100644 crates/formats/src/sbs/layout_item.rs create mode 100644 crates/ui-egui/src/annotation/pin_properties.rs create mode 100644 crates/ui-egui/src/explorer/explorer_menu_state.rs create mode 100644 crates/ui-egui/src/explorer/explorer_row.rs create mode 100644 crates/ui-egui/src/library/library_target.rs create mode 100644 crates/ui-egui/src/pattern/pattern_canvas.rs create mode 100644 crates/ui-egui/tests/snapshot/graph_items.rs create mode 100644 crates/ui-egui/tests/snapshot/menu.rs diff --git a/assets/sbs/functions.sbs b/assets/sbs/functions.sbs index 0294f74..c9713d3 100644 --- a/assets/sbs/functions.sbs +++ b/assets/sbs/functions.sbs @@ -1 +1 @@ -<?xml version="1.0" encoding="UTF-8"?><package><identifier v="Functions"/><formatVersion v="1.1.0.202401"/><updaterVersion v="0.1.3"/><fileUID v="0"/><versionUID v="0"/><dependencies><dependency><filename v="?himself"/><uid v="1000000001"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency></dependencies><content><group><identifier v="Functions"/><uid v="1000000002"/><content><group><identifier v="Tonemappers"/><uid v="1000000003"/><content><function><identifier v="tonemap_Hejl"/><uid v="1000000039"/><attributes><category v="Functions/Tonemappers"/><description v="Evaluates the tonemap_Hejl function graph. Result type: Float3. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000040"/><attributes><label v="input"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000000029"/><paramNodes><paramNode><uid v="1000000004"/><function v="max"/><type v="1024"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000018"/></connection><connection><identifier v="b"/><connRef v="1000000011"/></connection></connections></paramNode><paramNode><uid v="1000000005"/><function v="add"/><type v="1024"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000028"/></connection><connection><identifier v="b"/><connRef v="1000000023"/></connection></connections></paramNode><paramNode><uid v="1000000006"/><function v="mulscalar"/><type v="1024"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000004"/></connection><connection><identifier v="scalar"/><connRef v="1000000012"/></connection></connections></paramNode><paramNode><uid v="1000000007"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1.25"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000008"/><function v="swizzle3"/><type v="1024"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000000016"/></connection></connections><funcDatas><funcData><name v="swizzle3"/><constantValue><constantValueInt3 v="0 0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000009"/><function v="swizzle3"/><type v="1024"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000000021"/></connection></connections><funcDatas><funcData><name v="swizzle3"/><constantValue><constantValueInt3 v="0 0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000010"/><function v="mulscalar"/><type v="1024"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000019"/></connection><connection><identifier v="scalar"/><connRef v="1000000007"/></connection></connections></paramNode><paramNode><uid v="1000000011"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0 0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000012"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.22"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000013"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000037"/></connection><connection><identifier v="b"/><connRef v="1000000022"/></connection></connections></paramNode><paramNode><uid v="1000000014"/><function v="mul"/><type v="1024"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000004"/></connection><connection><identifier v="b"/><connRef v="1000000005"/></connection></connections></paramNode><paramNode><uid v="1000000015"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000037"/></connection><connection><identifier v="b"/><connRef v="1000000032"/></connection></connections></paramNode><paramNode><uid v="1000000016"/><function v="div"/><type v="256"/><GUILayout><gpos v="344 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000032"/></connection><connection><identifier v="b"/><connRef v="1000000022"/></connection></connections></paramNode><paramNode><uid v="1000000017"/><function v="div"/><type v="1024"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000034"/></connection><connection><identifier v="b"/><connRef v="1000000033"/></connection></connections></paramNode><paramNode><uid v="1000000018"/><function v="sub"/><type v="1024"/><GUILayout><gpos v="344 704 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000038"/></connection><connection><identifier v="b"/><connRef v="1000000035"/></connection></connections></paramNode><paramNode><uid v="1000000019"/><function v="swizzle3"/><type v="1024"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000000015"/></connection></connections><funcDatas><funcData><name v="swizzle3"/><constantValue><constantValueInt3 v="0 0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000020"/><function v="swizzle3"/><type v="1024"/><GUILayout><gpos v="624 544 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000000036"/></connection></connections><funcDatas><funcData><name v="swizzle3"/><constantValue><constantValueInt3 v="0 0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000021"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000022"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000023"/><function v="mulscalar"/><type v="1024"/><GUILayout><gpos v="904 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000020"/></connection><connection><identifier v="scalar"/><connRef v="1000000007"/></connection></connections></paramNode><paramNode><uid v="1000000024"/><function v="mulscalar"/><type v="1024"/><GUILayout><gpos v="904 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000008"/></connection><connection><identifier v="scalar"/><connRef v="1000000007"/></connection></connections></paramNode><paramNode><uid v="1000000025"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 864 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000012"/></connection><connection><identifier v="b"/><connRef v="1000000007"/></connection></connections></paramNode><paramNode><uid v="1000000026"/><function v="mul"/><type v="1024"/><GUILayout><gpos v="1464 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000004"/></connection><connection><identifier v="b"/><connRef v="1000000027"/></connection></connections></paramNode><paramNode><uid v="1000000027"/><function v="add"/><type v="1024"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000006"/></connection><connection><identifier v="b"/><connRef v="1000000009"/></connection></connections></paramNode><paramNode><uid v="1000000028"/><function v="mulscalar"/><type v="1024"/><GUILayout><gpos v="904 704 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000004"/></connection><connection><identifier v="scalar"/><connRef v="1000000025"/></connection></connections></paramNode><paramNode><uid v="1000000029"/><function v="sub"/><type v="1024"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000017"/></connection><connection><identifier v="b"/><connRef v="1000000024"/></connection></connections></paramNode><paramNode><uid v="1000000030"/><function v="swizzle3"/><type v="1024"/><GUILayout><gpos v="624 704 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000000013"/></connection></connections><funcDatas><funcData><name v="swizzle3"/><constantValue><constantValueInt3 v="0 0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000031"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000032"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.01"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000033"/><function v="add"/><type v="1024"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000026"/></connection><connection><identifier v="b"/><connRef v="1000000030"/></connection></connections></paramNode><paramNode><uid v="1000000034"/><function v="add"/><type v="1024"/><GUILayout><gpos v="1744 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000014"/></connection><connection><identifier v="b"/><connRef v="1000000010"/></connection></connections></paramNode><paramNode><uid v="1000000035"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0.004 0.004 0.004"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000036"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 1024 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000021"/></connection><connection><identifier v="b"/><connRef v="1000000031"/></connection></connections></paramNode><paramNode><uid v="1000000037"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000038"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="tonemap_ACES"/><uid v="1000000070"/><attributes><category v="Functions/Tonemappers"/><description v="Evaluates the tonemap_ACES function graph. Result type: Float3. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000071"/><attributes><label v="input"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000000061"/><paramNodes><paramNode><uid v="1000000041"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000042"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0.000090537 0.000090537 0.000090537"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000043"/><function v="add"/><type v="1024"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000069"/></connection><connection><identifier v="b"/><connRef v="1000000044"/></connection></connections></paramNode><paramNode><uid v="1000000044"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0.0245786 0.0245786 0.0245786"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000045"/><function v="mul"/><type v="1024"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000069"/></connection><connection><identifier v="b"/><connRef v="1000000043"/></connection></connections></paramNode><paramNode><uid v="1000000046"/><function v="sub"/><type v="1024"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000045"/></connection><connection><identifier v="b"/><connRef v="1000000042"/></connection></connections></paramNode><paramNode><uid v="1000000047"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0.983729 0.983729 0.983729"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000048"/><function v="mul"/><type v="1024"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000069"/></connection><connection><identifier v="b"/><connRef v="1000000047"/></connection></connections></paramNode><paramNode><uid v="1000000049"/><function v="add"/><type v="1024"/><GUILayout><gpos v="1464 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000048"/></connection><connection><identifier v="b"/><connRef v="1000000050"/></connection></connections></paramNode><paramNode><uid v="1000000050"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0.432951 0.432951 0.432951"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000051"/><function v="mul"/><type v="1024"/><GUILayout><gpos v="1744 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000069"/></connection><connection><identifier v="b"/><connRef v="1000000049"/></connection></connections></paramNode><paramNode><uid v="1000000052"/><function v="add"/><type v="1024"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000051"/></connection><connection><identifier v="b"/><connRef v="1000000053"/></connection></connections></paramNode><paramNode><uid v="1000000053"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0.238081 0.238081 0.238081"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000054"/><function v="div"/><type v="1024"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000046"/></connection><connection><identifier v="b"/><connRef v="1000000052"/></connection></connections></paramNode><paramNode><uid v="1000000055"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="-0.00327 -0.07276 1.07602"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000056"/><function v="dot"/><type v="256"/><GUILayout><gpos v="2584 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000055"/></connection><connection><identifier v="b"/><connRef v="1000000054"/></connection></connections></paramNode><paramNode><uid v="1000000057"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="1.60475 -0.53108 -0.07367"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000058"/><function v="dot"/><type v="256"/><GUILayout><gpos v="2584 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000059"/></connection><connection><identifier v="b"/><connRef v="1000000054"/></connection></connections></paramNode><paramNode><uid v="1000000059"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="-0.10208 1.10813 -0.00605"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000060"/><function v="dot"/><type v="256"/><GUILayout><gpos v="2584 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000057"/></connection><connection><identifier v="b"/><connRef v="1000000054"/></connection></connections></paramNode><paramNode><uid v="1000000061"/><function v="instance"/><type v="118772"/><GUILayout><gpos v="2864 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000060"/></connection><connection><identifier v="y"/><connRef v="1000000058"/></connection><connection><identifier v="z"/><connRef v="1000000056"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/merge_float3"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input><input><identifier v="y"/><type v="0"/></input><input><identifier v="z"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000062"/><function v="instance"/><type v="118772"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000067"/></connection><connection><identifier v="y"/><connRef v="1000000064"/></connection><connection><identifier v="z"/><connRef v="1000000065"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/merge_float3"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input><input><identifier v="y"/><type v="0"/></input><input><identifier v="z"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000063"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0.076 0.90834 0.01566"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000064"/><function v="dot"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000063"/></connection><connection><identifier v="b"/><connRef v="1000000041"/></connection></connections></paramNode><paramNode><uid v="1000000065"/><function v="dot"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000066"/></connection><connection><identifier v="b"/><connRef v="1000000041"/></connection></connections></paramNode><paramNode><uid v="1000000066"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 1664 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0.00284 0.13383 0.83777"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000067"/><function v="dot"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000068"/></connection><connection><identifier v="b"/><connRef v="1000000041"/></connection></connections></paramNode><paramNode><uid v="1000000068"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 1824 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0.59719 0.35458 0.04823"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000069"/><function v="passthrough"/><type v="1024"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000000062"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="tonemap_AgX"/><uid v="1000000116"/><attributes><category v="Functions/Tonemappers"/><description v="Evaluates the tonemap_AgX function graph. Result type: Float3. Inputs: input, slope, power, offset, saturation."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000117"/><attributes><label v="input"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="slope"/><uid v="1000000118"/><attributes><label v="slope"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="power"/><uid v="1000000119"/><attributes><label v="power"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="offset"/><uid v="1000000120"/><attributes><label v="offset"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="saturation"/><uid v="1000000121"/><attributes><label v="saturation"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000000104"/><paramNodes><paramNode><uid v="1000000072"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000073"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="-12.47393"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000074"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="4.026069"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000075"/><function v="log2"/><type v="1024"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000112"/></connection></connections></paramNode><paramNode><uid v="1000000076"/><function v="max"/><type v="1024"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000075"/></connection><connection><identifier v="b"/><connRef v="1000000077"/></connection></connections></paramNode><paramNode><uid v="1000000077"/><function v="swizzle3"/><type v="1024"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000000073"/></connection></connections><funcDatas><funcData><name v="swizzle3"/><constantValue><constantValueInt3 v="0 0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000078"/><function v="min"/><type v="1024"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000076"/></connection><connection><identifier v="b"/><connRef v="1000000079"/></connection></connections></paramNode><paramNode><uid v="1000000079"/><function v="swizzle3"/><type v="1024"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000000074"/></connection></connections><funcDatas><funcData><name v="swizzle3"/><constantValue><constantValueInt3 v="0 0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000080"/><function v="sub"/><type v="1024"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000078"/></connection><connection><identifier v="b"/><connRef v="1000000077"/></connection></connections></paramNode><paramNode><uid v="1000000081"/><function v="sub"/><type v="1024"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000079"/></connection><connection><identifier v="b"/><connRef v="1000000077"/></connection></connections></paramNode><paramNode><uid v="1000000082"/><function v="div"/><type v="1024"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000080"/></connection><connection><identifier v="b"/><connRef v="1000000081"/></connection></connections></paramNode><paramNode><uid v="1000000083"/><function v="passthrough"/><type v="1024"/><GUILayout><gpos v="3144 64 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000000089"/></connection></connections></paramNode><paramNode><uid v="1000000084"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="power"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000085"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="offset"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000086"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="saturation"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000087"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="slope"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000088"/><function v="instance"/><type v="1024"/><GUILayout><gpos v="2584 64 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000000082"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Tonemappers/tonemap_AgX_approx"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000089"/><function v="instance"/><type v="1024"/><GUILayout><gpos v="2864 64 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000000088"/></connection><connection><identifier v="offset"/><connRef v="1000000091"/></connection><connection><identifier v="slope"/><connRef v="1000000093"/></connection><connection><identifier v="power"/><connRef v="1000000095"/></connection><connection><identifier v="saturation"/><connRef v="1000000098"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Tonemappers/tonemap_AgX_look"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input"/><type v="0"/></input><input><identifier v="offset"/><type v="0"/></input><input><identifier v="slope"/><type v="0"/></input><input><identifier v="power"/><type v="0"/></input><input><identifier v="saturation"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000090"/><function v="isdefined"/><type v="4"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="isdefined"/><constantValue><constantValueString v="offset"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000091"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000090"/></connection><connection><identifier v="ifpath"/><connRef v="1000000085"/></connection><connection><identifier v="elsepath"/><connRef v="1000000092"/></connection></connections></paramNode><paramNode><uid v="1000000092"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0 0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000093"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="344 548 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000094"/></connection><connection><identifier v="ifpath"/><connRef v="1000000087"/></connection><connection><identifier v="elsepath"/><connRef v="1000000092"/></connection></connections></paramNode><paramNode><uid v="1000000094"/><function v="isdefined"/><type v="4"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="isdefined"/><constantValue><constantValueString v="slope"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000095"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="344 712 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000096"/></connection><connection><identifier v="ifpath"/><connRef v="1000000084"/></connection><connection><identifier v="elsepath"/><connRef v="1000000092"/></connection></connections></paramNode><paramNode><uid v="1000000096"/><function v="isdefined"/><type v="4"/><GUILayout><gpos v="64 1664 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="isdefined"/><constantValue><constantValueString v="power"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000097"/><function v="isdefined"/><type v="4"/><GUILayout><gpos v="64 1824 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="isdefined"/><constantValue><constantValueString v="saturation"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000098"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="344 876 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000097"/></connection><connection><identifier v="ifpath"/><connRef v="1000000086"/></connection><connection><identifier v="elsepath"/><connRef v="1000000099"/></connection></connections></paramNode><paramNode><uid v="1000000099"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1984 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000100"/><function v="dot"/><type v="256"/><GUILayout><gpos v="3424 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000105"/></connection><connection><identifier v="b"/><connRef v="1000000083"/></connection></connections></paramNode><paramNode><uid v="1000000101"/><function v="dot"/><type v="256"/><GUILayout><gpos v="3424 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000106"/></connection><connection><identifier v="b"/><connRef v="1000000083"/></connection></connections></paramNode><paramNode><uid v="1000000102"/><function v="dot"/><type v="256"/><GUILayout><gpos v="3424 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000107"/></connection><connection><identifier v="b"/><connRef v="1000000083"/></connection></connections></paramNode><paramNode><uid v="1000000103"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="3704 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000000100"/></connection><connection><identifier v="componentslast"/><connRef v="1000000101"/></connection></connections></paramNode><paramNode><uid v="1000000104"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="3984 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000000103"/></connection><connection><identifier v="componentslast"/><connRef v="1000000102"/></connection></connections></paramNode><paramNode><uid v="1000000105"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 2144 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="1.196879 -0.09802088 -0.09902974"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000106"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 2304 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="-0.05289685 1.151903 -0.09896117"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000107"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 2464 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="-0.05297164 -0.09804345 1.1510737"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000108"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000000111"/></connection><connection><identifier v="componentslast"/><connRef v="1000000110"/></connection></connections></paramNode><paramNode><uid v="1000000109"/><function v="dot"/><type v="256"/><GUILayout><gpos v="344 1040 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000072"/></connection><connection><identifier v="b"/><connRef v="1000000115"/></connection></connections></paramNode><paramNode><uid v="1000000110"/><function v="dot"/><type v="256"/><GUILayout><gpos v="344 1200 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000072"/></connection><connection><identifier v="b"/><connRef v="1000000114"/></connection></connections></paramNode><paramNode><uid v="1000000111"/><function v="dot"/><type v="256"/><GUILayout><gpos v="344 1360 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000072"/></connection><connection><identifier v="b"/><connRef v="1000000113"/></connection></connections></paramNode><paramNode><uid v="1000000112"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000000108"/></connection><connection><identifier v="componentslast"/><connRef v="1000000109"/></connection></connections></paramNode><paramNode><uid v="1000000113"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 2624 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0.84247905 0.0784336 0.07922374"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000114"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 2784 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0.04232824 0.8784686 0.07916613"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000115"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 2944 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0.04237565 0.0784336 0.879143"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="tonemap_AgX_look"/><uid v="1000000136"/><attributes><category v="Functions/Tonemappers"/><description v="Evaluates the tonemap_AgX_look function graph. Result type: Float3. Inputs: input, offset, slope, power, saturation."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000137"/><attributes><label v="input"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="offset"/><uid v="1000000138"/><attributes><label v="offset"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="slope"/><uid v="1000000139"/><attributes><label v="slope"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="power"/><uid v="1000000140"/><attributes><label v="power"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="saturation"/><uid v="1000000141"/><attributes><label v="saturation"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000000135"/><paramNodes><paramNode><uid v="1000000122"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000123"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0.2126 0.7152 0.0722"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000124"/><function v="dot"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000123"/></connection><connection><identifier v="b"/><connRef v="1000000122"/></connection></connections></paramNode><paramNode><uid v="1000000125"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="slope"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000126"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="offset"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000127"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="power"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000128"/><function v="mul"/><type v="1024"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000122"/></connection><connection><identifier v="b"/><connRef v="1000000125"/></connection></connections></paramNode><paramNode><uid v="1000000129"/><function v="add"/><type v="1024"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000128"/></connection><connection><identifier v="b"/><connRef v="1000000126"/></connection></connections></paramNode><paramNode><uid v="1000000130"/><function v="pow"/><type v="1024"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000129"/></connection><connection><identifier v="b"/><connRef v="1000000127"/></connection></connections></paramNode><paramNode><uid v="1000000131"/><function v="sub"/><type v="1024"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000130"/></connection><connection><identifier v="b"/><connRef v="1000000132"/></connection></connections></paramNode><paramNode><uid v="1000000132"/><function v="swizzle3"/><type v="1024"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000000124"/></connection></connections><funcDatas><funcData><name v="swizzle3"/><constantValue><constantValueInt3 v="0 0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000133"/><function v="mulscalar"/><type v="1024"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000131"/></connection><connection><identifier v="scalar"/><connRef v="1000000134"/></connection></connections></paramNode><paramNode><uid v="1000000134"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="saturation"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000135"/><function v="add"/><type v="1024"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000133"/></connection><connection><identifier v="b"/><connRef v="1000000132"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="tonemap_AgX_approx"/><uid v="1000000167"/><attributes><category v="Functions/Tonemappers"/><description v="Evaluates the tonemap_AgX_approx function graph. Result type: Float3. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000168"/><attributes><label v="input"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000000165"/><paramNodes><paramNode><uid v="1000000142"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000143"/><function v="mul"/><type v="1024"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000142"/></connection><connection><identifier v="b"/><connRef v="1000000142"/></connection></connections></paramNode><paramNode><uid v="1000000144"/><function v="mul"/><type v="1024"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000143"/></connection><connection><identifier v="b"/><connRef v="1000000143"/></connection></connections></paramNode><paramNode><uid v="1000000145"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="15.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000146"/><function v="mul"/><type v="1024"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000144"/></connection><connection><identifier v="b"/><connRef v="1000000143"/></connection></connections></paramNode><paramNode><uid v="1000000147"/><function v="mulscalar"/><type v="1024"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000146"/></connection><connection><identifier v="scalar"/><connRef v="1000000145"/></connection></connections></paramNode><paramNode><uid v="1000000148"/><function v="sub"/><type v="1024"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000147"/></connection><connection><identifier v="b"/><connRef v="1000000150"/></connection></connections></paramNode><paramNode><uid v="1000000149"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="40.14"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000150"/><function v="mulscalar"/><type v="1024"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000151"/></connection><connection><identifier v="scalar"/><connRef v="1000000149"/></connection></connections></paramNode><paramNode><uid v="1000000151"/><function v="mul"/><type v="1024"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000144"/></connection><connection><identifier v="b"/><connRef v="1000000142"/></connection></connections></paramNode><paramNode><uid v="1000000152"/><function v="mulscalar"/><type v="1024"/><GUILayout><gpos v="904 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000144"/></connection><connection><identifier v="scalar"/><connRef v="1000000153"/></connection></connections></paramNode><paramNode><uid v="1000000153"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="31.96"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000154"/><function v="add"/><type v="1024"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000148"/></connection><connection><identifier v="b"/><connRef v="1000000152"/></connection></connections></paramNode><paramNode><uid v="1000000155"/><function v="mulscalar"/><type v="1024"/><GUILayout><gpos v="904 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000158"/></connection><connection><identifier v="scalar"/><connRef v="1000000156"/></connection></connections></paramNode><paramNode><uid v="1000000156"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="6.868"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000157"/><function v="sub"/><type v="1024"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000154"/></connection><connection><identifier v="b"/><connRef v="1000000155"/></connection></connections></paramNode><paramNode><uid v="1000000158"/><function v="mul"/><type v="1024"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000143"/></connection><connection><identifier v="b"/><connRef v="1000000142"/></connection></connections></paramNode><paramNode><uid v="1000000159"/><function v="mulscalar"/><type v="1024"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000143"/></connection><connection><identifier v="scalar"/><connRef v="1000000161"/></connection></connections></paramNode><paramNode><uid v="1000000160"/><function v="add"/><type v="1024"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000157"/></connection><connection><identifier v="b"/><connRef v="1000000159"/></connection></connections></paramNode><paramNode><uid v="1000000161"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.4298"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000162"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.1191"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000163"/><function v="mulscalar"/><type v="1024"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000142"/></connection><connection><identifier v="scalar"/><connRef v="1000000162"/></connection></connections></paramNode><paramNode><uid v="1000000164"/><function v="add"/><type v="1024"/><GUILayout><gpos v="2584 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000160"/></connection><connection><identifier v="b"/><connRef v="1000000163"/></connection></connections></paramNode><paramNode><uid v="1000000165"/><function v="sub"/><type v="1024"/><GUILayout><gpos v="2864 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000164"/></connection><connection><identifier v="b"/><connRef v="1000000166"/></connection></connections></paramNode><paramNode><uid v="1000000166"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0.00232 0.00232 0.00232"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="easings"/><uid v="1000000169"/><content><group><identifier v="circ"/><uid v="1000000170"/><content><function><identifier v="ease_in_circ"/><uid v="1000000176"/><attributes><category v="Functions/easings/circ"/><description v="Evaluates the ease_in_circ function graph. Result type: Float. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000177"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000172"/><paramNodes><paramNode><uid v="1000000171"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000172"/><function v="instance"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000173"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000173"/><function v="sqrt"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000174"/></connection></connections></paramNode><paramNode><uid v="1000000174"/><function v="instance"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000175"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000175"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000171"/></connection><connection><identifier v="b"/><connRef v="1000000171"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="ease_out_circ"/><uid v="1000000184"/><attributes><category v="Functions/easings/circ"/><description v="Evaluates the ease_out_circ function graph. Result type: Float. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000185"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000179"/><paramNodes><paramNode><uid v="1000000178"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000179"/><function v="sqrt"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000180"/></connection></connections></paramNode><paramNode><uid v="1000000180"/><function v="instance"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000181"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000181"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000182"/></connection><connection><identifier v="b"/><connRef v="1000000182"/></connection></connections></paramNode><paramNode><uid v="1000000182"/><function v="sub"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000178"/></connection><connection><identifier v="b"/><connRef v="1000000183"/></connection></connections></paramNode><paramNode><uid v="1000000183"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="ease_in_out_circ"/><uid v="1000000208"/><attributes><category v="Functions/easings/circ"/><description v="Evaluates the ease_in_out_circ function graph. Result type: Float. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000209"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000191"/><paramNodes><paramNode><uid v="1000000186"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000187"/><function v="sqrt"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000188"/></connection></connections></paramNode><paramNode><uid v="1000000188"/><function v="instance"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000196"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000189"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000186"/></connection><connection><identifier v="b"/><connRef v="1000000190"/></connection></connections></paramNode><paramNode><uid v="1000000190"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000191"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000189"/></connection><connection><identifier v="ifpath"/><connRef v="1000000206"/></connection><connection><identifier v="elsepath"/><connRef v="1000000207"/></connection></connections></paramNode><paramNode><uid v="1000000192"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000186"/></connection><connection><identifier v="b"/><connRef v="1000000193"/></connection></connections></paramNode><paramNode><uid v="1000000193"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="-2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000194"/><function v="add"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000192"/></connection><connection><identifier v="b"/><connRef v="1000000195"/></connection></connections></paramNode><paramNode><uid v="1000000195"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000196"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000194"/></connection><connection><identifier v="b"/><connRef v="1000000194"/></connection></connections></paramNode><paramNode><uid v="1000000197"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000198"/><function v="instance"/><type v="256"/><GUILayout><gpos v="1464 224 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000199"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000199"/><function v="sqrt"/><type v="256"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000200"/></connection></connections></paramNode><paramNode><uid v="1000000200"/><function v="instance"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000203"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000201"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000202"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000186"/></connection><connection><identifier v="b"/><connRef v="1000000201"/></connection></connections></paramNode><paramNode><uid v="1000000203"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000202"/></connection><connection><identifier v="b"/><connRef v="1000000202"/></connection></connections></paramNode><paramNode><uid v="1000000204"/><function v="add"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000187"/></connection><connection><identifier v="b"/><connRef v="1000000205"/></connection></connections></paramNode><paramNode><uid v="1000000205"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000206"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1744 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000198"/></connection><connection><identifier v="b"/><connRef v="1000000197"/></connection></connections></paramNode><paramNode><uid v="1000000207"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000204"/></connection><connection><identifier v="b"/><connRef v="1000000197"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="expo"/><uid v="1000000210"/><content><function><identifier v="ease_in_expo"/><uid v="1000000219"/><attributes><category v="Functions/easings/expo"/><description v="Evaluates the ease_in_expo function graph. Result type: Float. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000220"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000212"/><paramNodes><paramNode><uid v="1000000211"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000212"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000213"/></connection><connection><identifier v="ifpath"/><connRef v="1000000214"/></connection><connection><identifier v="elsepath"/><connRef v="1000000218"/></connection></connections></paramNode><paramNode><uid v="1000000213"/><function v="eq"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000211"/></connection><connection><identifier v="b"/><connRef v="1000000214"/></connection></connections></paramNode><paramNode><uid v="1000000214"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000215"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000211"/></connection><connection><identifier v="b"/><connRef v="1000000216"/></connection></connections></paramNode><paramNode><uid v="1000000216"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="10"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000217"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000215"/></connection><connection><identifier v="b"/><connRef v="1000000216"/></connection></connections></paramNode><paramNode><uid v="1000000218"/><function v="pow2"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000217"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="ease_out_expo"/><uid v="1000000229"/><attributes><category v="Functions/easings/expo"/><description v="Evaluates the ease_out_expo function graph. Result type: Float. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000230"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000222"/><paramNodes><paramNode><uid v="1000000221"/><function v="eq"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000225"/></connection><connection><identifier v="b"/><connRef v="1000000224"/></connection></connections></paramNode><paramNode><uid v="1000000222"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000221"/></connection><connection><identifier v="ifpath"/><connRef v="1000000224"/></connection><connection><identifier v="elsepath"/><connRef v="1000000227"/></connection></connections></paramNode><paramNode><uid v="1000000223"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="-10"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000224"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000225"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000226"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000225"/></connection><connection><identifier v="b"/><connRef v="1000000223"/></connection></connections></paramNode><paramNode><uid v="1000000227"/><function v="instance"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000228"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000228"/><function v="pow2"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000226"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="ease_in_out_expo"/><uid v="1000000256"/><attributes><category v="Functions/easings/expo"/><description v="Evaluates the ease_in_out_expo function graph. Result type: Float. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000257"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000234"/><paramNodes><paramNode><uid v="1000000231"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000232"/><function v="eq"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000231"/></connection><connection><identifier v="b"/><connRef v="1000000233"/></connection></connections></paramNode><paramNode><uid v="1000000233"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000234"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000232"/></connection><connection><identifier v="ifpath"/><connRef v="1000000233"/></connection><connection><identifier v="elsepath"/><connRef v="1000000237"/></connection></connections></paramNode><paramNode><uid v="1000000235"/><function v="eq"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000231"/></connection><connection><identifier v="b"/><connRef v="1000000236"/></connection></connections></paramNode><paramNode><uid v="1000000236"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000237"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000235"/></connection><connection><identifier v="ifpath"/><connRef v="1000000236"/></connection><connection><identifier v="elsepath"/><connRef v="1000000240"/></connection></connections></paramNode><paramNode><uid v="1000000238"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000231"/></connection><connection><identifier v="b"/><connRef v="1000000239"/></connection></connections></paramNode><paramNode><uid v="1000000239"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000240"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000238"/></connection><connection><identifier v="ifpath"/><connRef v="1000000252"/></connection><connection><identifier v="elsepath"/><connRef v="1000000255"/></connection></connections></paramNode><paramNode><uid v="1000000241"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000231"/></connection><connection><identifier v="b"/><connRef v="1000000242"/></connection></connections></paramNode><paramNode><uid v="1000000242"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="20"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000243"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000241"/></connection><connection><identifier v="b"/><connRef v="1000000244"/></connection></connections></paramNode><paramNode><uid v="1000000244"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="10"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000245"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 704 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000231"/></connection><connection><identifier v="b"/><connRef v="1000000246"/></connection></connections></paramNode><paramNode><uid v="1000000246"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="-20"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000247"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000248"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="10"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000249"/><function v="add"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000245"/></connection><connection><identifier v="b"/><connRef v="1000000248"/></connection></connections></paramNode><paramNode><uid v="1000000250"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000247"/></connection><connection><identifier v="b"/><connRef v="1000000254"/></connection></connections></paramNode><paramNode><uid v="1000000251"/><function v="pow2"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000243"/></connection></connections></paramNode><paramNode><uid v="1000000252"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000251"/></connection><connection><identifier v="b"/><connRef v="1000000253"/></connection></connections></paramNode><paramNode><uid v="1000000253"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000254"/><function v="pow2"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000249"/></connection></connections></paramNode><paramNode><uid v="1000000255"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000250"/></connection><connection><identifier v="b"/><connRef v="1000000253"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="quint"/><uid v="1000000258"/><content><function><identifier v="ease_in_quint"/><uid v="1000000264"/><attributes><category v="Functions/easings/quint"/><description v="Evaluates the ease_in_quint function graph. Result type: Float. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000265"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000263"/><paramNodes><paramNode><uid v="1000000259"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000260"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000259"/></connection><connection><identifier v="b"/><connRef v="1000000259"/></connection></connections></paramNode><paramNode><uid v="1000000261"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000260"/></connection><connection><identifier v="b"/><connRef v="1000000259"/></connection></connections></paramNode><paramNode><uid v="1000000262"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000261"/></connection><connection><identifier v="b"/><connRef v="1000000259"/></connection></connections></paramNode><paramNode><uid v="1000000263"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000262"/></connection><connection><identifier v="b"/><connRef v="1000000259"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="ease_out_quint"/><uid v="1000000273"/><attributes><category v="Functions/easings/quint"/><description v="Evaluates the ease_out_quint function graph. Result type: Float. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000274"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000270"/><paramNodes><paramNode><uid v="1000000266"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000267"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000269"/></connection><connection><identifier v="b"/><connRef v="1000000269"/></connection></connections></paramNode><paramNode><uid v="1000000268"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000267"/></connection><connection><identifier v="b"/><connRef v="1000000269"/></connection></connections></paramNode><paramNode><uid v="1000000269"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000266"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000270"/><function v="instance"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000272"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000271"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000268"/></connection><connection><identifier v="b"/><connRef v="1000000269"/></connection></connections></paramNode><paramNode><uid v="1000000272"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000271"/></connection><connection><identifier v="b"/><connRef v="1000000269"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="ease_in_out_quint"/><uid v="1000000296"/><attributes><category v="Functions/easings/quint"/><description v="Evaluates the ease_in_out_quint function graph. Result type: Float. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000297"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000281"/><paramNodes><paramNode><uid v="1000000275"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="16"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000276"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000279"/></connection><connection><identifier v="b"/><connRef v="1000000279"/></connection></connections></paramNode><paramNode><uid v="1000000277"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000279"/></connection><connection><identifier v="b"/><connRef v="1000000280"/></connection></connections></paramNode><paramNode><uid v="1000000278"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000294"/></connection><connection><identifier v="b"/><connRef v="1000000275"/></connection></connections></paramNode><paramNode><uid v="1000000279"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000280"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000281"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="2864 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000277"/></connection><connection><identifier v="ifpath"/><connRef v="1000000278"/></connection><connection><identifier v="elsepath"/><connRef v="1000000283"/></connection></connections></paramNode><paramNode><uid v="1000000282"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000276"/></connection><connection><identifier v="b"/><connRef v="1000000279"/></connection></connections></paramNode><paramNode><uid v="1000000283"/><function v="instance"/><type v="256"/><GUILayout><gpos v="2584 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000288"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000284"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000285"/><function v="add"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000284"/></connection><connection><identifier v="b"/><connRef v="1000000290"/></connection></connections></paramNode><paramNode><uid v="1000000286"/><function v="neg"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000284"/></connection></connections></paramNode><paramNode><uid v="1000000287"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000285"/></connection><connection><identifier v="b"/><connRef v="1000000285"/></connection></connections></paramNode><paramNode><uid v="1000000288"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000295"/></connection><connection><identifier v="b"/><connRef v="1000000289"/></connection></connections></paramNode><paramNode><uid v="1000000289"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000290"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000279"/></connection><connection><identifier v="b"/><connRef v="1000000286"/></connection></connections></paramNode><paramNode><uid v="1000000291"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1464 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000287"/></connection><connection><identifier v="b"/><connRef v="1000000285"/></connection></connections></paramNode><paramNode><uid v="1000000292"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000282"/></connection><connection><identifier v="b"/><connRef v="1000000279"/></connection></connections></paramNode><paramNode><uid v="1000000293"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000291"/></connection><connection><identifier v="b"/><connRef v="1000000285"/></connection></connections></paramNode><paramNode><uid v="1000000294"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000292"/></connection><connection><identifier v="b"/><connRef v="1000000279"/></connection></connections></paramNode><paramNode><uid v="1000000295"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000293"/></connection><connection><identifier v="b"/><connRef v="1000000285"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="quart"/><uid v="1000000298"/><content><function><identifier v="ease_in_quart"/><uid v="1000000303"/><attributes><category v="Functions/easings/quart"/><description v="Evaluates the ease_in_quart function graph. Result type: Float. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000304"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000302"/><paramNodes><paramNode><uid v="1000000299"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000300"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000299"/></connection><connection><identifier v="b"/><connRef v="1000000299"/></connection></connections></paramNode><paramNode><uid v="1000000301"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000300"/></connection><connection><identifier v="b"/><connRef v="1000000299"/></connection></connections></paramNode><paramNode><uid v="1000000302"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000301"/></connection><connection><identifier v="b"/><connRef v="1000000299"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="ease_out_quart"/><uid v="1000000311"/><attributes><category v="Functions/easings/quart"/><description v="Evaluates the ease_out_quart function graph. Result type: Float. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000312"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000309"/><paramNodes><paramNode><uid v="1000000305"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000306"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000308"/></connection><connection><identifier v="b"/><connRef v="1000000308"/></connection></connections></paramNode><paramNode><uid v="1000000307"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000306"/></connection><connection><identifier v="b"/><connRef v="1000000308"/></connection></connections></paramNode><paramNode><uid v="1000000308"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000305"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000309"/><function v="instance"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000310"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000310"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000307"/></connection><connection><identifier v="b"/><connRef v="1000000308"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="ease_in_out_quart"/><uid v="1000000332"/><attributes><category v="Functions/easings/quart"/><description v="Evaluates the ease_in_out_quart function graph. Result type: Float. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000333"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000319"/><paramNodes><paramNode><uid v="1000000313"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="8"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000314"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000317"/></connection><connection><identifier v="b"/><connRef v="1000000317"/></connection></connections></paramNode><paramNode><uid v="1000000315"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000317"/></connection><connection><identifier v="b"/><connRef v="1000000318"/></connection></connections></paramNode><paramNode><uid v="1000000316"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000330"/></connection><connection><identifier v="b"/><connRef v="1000000313"/></connection></connections></paramNode><paramNode><uid v="1000000317"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000318"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000319"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="2584 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000315"/></connection><connection><identifier v="ifpath"/><connRef v="1000000316"/></connection><connection><identifier v="elsepath"/><connRef v="1000000321"/></connection></connections></paramNode><paramNode><uid v="1000000320"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000314"/></connection><connection><identifier v="b"/><connRef v="1000000317"/></connection></connections></paramNode><paramNode><uid v="1000000321"/><function v="instance"/><type v="256"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000326"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000322"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000323"/><function v="add"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000322"/></connection><connection><identifier v="b"/><connRef v="1000000328"/></connection></connections></paramNode><paramNode><uid v="1000000324"/><function v="neg"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000322"/></connection></connections></paramNode><paramNode><uid v="1000000325"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000323"/></connection><connection><identifier v="b"/><connRef v="1000000323"/></connection></connections></paramNode><paramNode><uid v="1000000326"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000331"/></connection><connection><identifier v="b"/><connRef v="1000000327"/></connection></connections></paramNode><paramNode><uid v="1000000327"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000328"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000317"/></connection><connection><identifier v="b"/><connRef v="1000000324"/></connection></connections></paramNode><paramNode><uid v="1000000329"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000325"/></connection><connection><identifier v="b"/><connRef v="1000000323"/></connection></connections></paramNode><paramNode><uid v="1000000330"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000320"/></connection><connection><identifier v="b"/><connRef v="1000000317"/></connection></connections></paramNode><paramNode><uid v="1000000331"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000329"/></connection><connection><identifier v="b"/><connRef v="1000000323"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="cubic"/><uid v="1000000334"/><content><function><identifier v="ease_in_cubic"/><uid v="1000000338"/><attributes><category v="Functions/easings/cubic"/><description v="Evaluates the ease_in_cubic function graph. Result type: Float. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000339"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000337"/><paramNodes><paramNode><uid v="1000000335"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000336"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000335"/></connection><connection><identifier v="b"/><connRef v="1000000335"/></connection></connections></paramNode><paramNode><uid v="1000000337"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000336"/></connection><connection><identifier v="b"/><connRef v="1000000335"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="ease_out_cubic"/><uid v="1000000345"/><attributes><category v="Functions/easings/cubic"/><description v="Evaluates the ease_out_cubic function graph. Result type: Float. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000346"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000344"/><paramNodes><paramNode><uid v="1000000340"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000341"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000343"/></connection><connection><identifier v="b"/><connRef v="1000000343"/></connection></connections></paramNode><paramNode><uid v="1000000342"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000341"/></connection><connection><identifier v="b"/><connRef v="1000000343"/></connection></connections></paramNode><paramNode><uid v="1000000343"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000340"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000344"/><function v="instance"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000342"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="ease_in_out_cubic"/><uid v="1000000364"/><attributes><category v="Functions/easings/cubic"/><description v="Evaluates the ease_in_out_cubic function graph. Result type: Float. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000365"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000353"/><paramNodes><paramNode><uid v="1000000347"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000348"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000351"/></connection><connection><identifier v="b"/><connRef v="1000000351"/></connection></connections></paramNode><paramNode><uid v="1000000349"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000351"/></connection><connection><identifier v="b"/><connRef v="1000000352"/></connection></connections></paramNode><paramNode><uid v="1000000350"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000354"/></connection><connection><identifier v="b"/><connRef v="1000000347"/></connection></connections></paramNode><paramNode><uid v="1000000351"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000352"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000353"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000349"/></connection><connection><identifier v="ifpath"/><connRef v="1000000350"/></connection><connection><identifier v="elsepath"/><connRef v="1000000355"/></connection></connections></paramNode><paramNode><uid v="1000000354"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000348"/></connection><connection><identifier v="b"/><connRef v="1000000351"/></connection></connections></paramNode><paramNode><uid v="1000000355"/><function v="instance"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000360"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000356"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000357"/><function v="add"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000356"/></connection><connection><identifier v="b"/><connRef v="1000000362"/></connection></connections></paramNode><paramNode><uid v="1000000358"/><function v="neg"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000356"/></connection></connections></paramNode><paramNode><uid v="1000000359"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000357"/></connection><connection><identifier v="b"/><connRef v="1000000357"/></connection></connections></paramNode><paramNode><uid v="1000000360"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000363"/></connection><connection><identifier v="b"/><connRef v="1000000361"/></connection></connections></paramNode><paramNode><uid v="1000000361"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000362"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000351"/></connection><connection><identifier v="b"/><connRef v="1000000358"/></connection></connections></paramNode><paramNode><uid v="1000000363"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000359"/></connection><connection><identifier v="b"/><connRef v="1000000357"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="quad"/><uid v="1000000366"/><content><function><identifier v="ease_in_quad"/><uid v="1000000369"/><attributes><category v="Functions/easings/quad"/><description v="Evaluates the ease_in_quad function graph. Result type: Float. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000370"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000368"/><paramNodes><paramNode><uid v="1000000367"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000368"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000367"/></connection><connection><identifier v="b"/><connRef v="1000000367"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="ease_out_quad"/><uid v="1000000375"/><attributes><category v="Functions/easings/quad"/><description v="Evaluates the ease_out_quad function graph. Result type: Float. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000376"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000373"/><paramNodes><paramNode><uid v="1000000371"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000372"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000374"/></connection><connection><identifier v="b"/><connRef v="1000000374"/></connection></connections></paramNode><paramNode><uid v="1000000373"/><function v="instance"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000372"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000374"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000371"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="ease_in_out_quad"/><uid v="1000000390"/><attributes><category v="Functions/easings/quad"/><description v="Evaluates the ease_in_out_quad function graph. Result type: Float. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000391"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000380"/><paramNodes><paramNode><uid v="1000000377"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000378"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000377"/></connection><connection><identifier v="b"/><connRef v="1000000379"/></connection></connections></paramNode><paramNode><uid v="1000000379"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000380"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000378"/></connection><connection><identifier v="ifpath"/><connRef v="1000000382"/></connection><connection><identifier v="elsepath"/><connRef v="1000000383"/></connection></connections></paramNode><paramNode><uid v="1000000381"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000377"/></connection><connection><identifier v="b"/><connRef v="1000000377"/></connection></connections></paramNode><paramNode><uid v="1000000382"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000381"/></connection><connection><identifier v="b"/><connRef v="1000000387"/></connection></connections></paramNode><paramNode><uid v="1000000383"/><function v="instance"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000385"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000384"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000386"/></connection><connection><identifier v="b"/><connRef v="1000000386"/></connection></connections></paramNode><paramNode><uid v="1000000385"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000384"/></connection><connection><identifier v="b"/><connRef v="1000000379"/></connection></connections></paramNode><paramNode><uid v="1000000386"/><function v="add"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000387"/></connection><connection><identifier v="b"/><connRef v="1000000388"/></connection></connections></paramNode><paramNode><uid v="1000000387"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000388"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000377"/></connection><connection><identifier v="b"/><connRef v="1000000389"/></connection></connections></paramNode><paramNode><uid v="1000000389"/><function v="neg"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000387"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="sine"/><uid v="1000000392"/><content><function><identifier v="ease_in_sine"/><uid v="1000000400"/><attributes><category v="Functions/easings/sine"/><description v="Evaluates the ease_in_sine function graph. Result type: Float. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000401"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000399"/><paramNodes><paramNode><uid v="1000000393"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000394"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000393"/></connection><connection><identifier v="b"/><connRef v="1000000395"/></connection></connections></paramNode><paramNode><uid v="1000000395"/><function v="instance"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Pi"/></constantValue></funcData></funcDatas><materialcraftInterface></materialcraftInterface></paramNode><paramNode><uid v="1000000396"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000394"/></connection><connection><identifier v="b"/><connRef v="1000000397"/></connection></connections></paramNode><paramNode><uid v="1000000397"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000398"/><function v="cos"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000396"/></connection></connections></paramNode><paramNode><uid v="1000000399"/><function v="instance"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000398"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="ease_out_sine"/><uid v="1000000408"/><attributes><category v="Functions/easings/sine"/><description v="Evaluates the ease_out_sine function graph. Result type: Float. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000409"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000407"/><paramNodes><paramNode><uid v="1000000402"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000403"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000402"/></connection><connection><identifier v="b"/><connRef v="1000000404"/></connection></connections></paramNode><paramNode><uid v="1000000404"/><function v="instance"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Pi"/></constantValue></funcData></funcDatas><materialcraftInterface></materialcraftInterface></paramNode><paramNode><uid v="1000000405"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000403"/></connection><connection><identifier v="b"/><connRef v="1000000406"/></connection></connections></paramNode><paramNode><uid v="1000000406"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000407"/><function v="sin"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000405"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="ease_in_out_sine"/><uid v="1000000419"/><attributes><category v="Functions/easings/sine"/><description v="Evaluates the ease_in_out_sine function graph. Result type: Float. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000420"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000416"/><paramNodes><paramNode><uid v="1000000410"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000411"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000410"/></connection><connection><identifier v="b"/><connRef v="1000000412"/></connection></connections></paramNode><paramNode><uid v="1000000412"/><function v="instance"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Pi"/></constantValue></funcData></funcDatas><materialcraftInterface></materialcraftInterface></paramNode><paramNode><uid v="1000000413"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000417"/></connection><connection><identifier v="b"/><connRef v="1000000414"/></connection></connections></paramNode><paramNode><uid v="1000000414"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000415"/><function v="cos"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000411"/></connection></connections></paramNode><paramNode><uid v="1000000416"/><function v="neg"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000413"/></connection></connections></paramNode><paramNode><uid v="1000000417"/><function v="sub"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000415"/></connection><connection><identifier v="b"/><connRef v="1000000418"/></connection></connections></paramNode><paramNode><uid v="1000000418"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group></content></group><group><identifier v="switch"/><uid v="1000000421"/><content><group><identifier v="Integer4"/><uid v="1000000422"/><content><function><identifier v="switch_integer4_2_inputs"/><uid v="1000000429"/><attributes><category v="Functions/switch/Integer4"/><description v="Evaluates the switch_integer4_2_inputs function graph. Result type: Integer4. Inputs: input_selection, value_1, value_2."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000430"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000431"/><attributes><label v="Value 1"/></attributes><type v="128"/><defaultValue><constantValueInt4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000432"/><attributes><label v="Value 2"/></attributes><type v="128"/><defaultValue><constantValueInt4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput></paraminputs><type v="128"/><paramValue><dynamicValue><rootnode v="1000000424"/><paramNodes><paramNode><uid v="1000000423"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000424"/><function v="ifelse"/><type v="128"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000426"/></connection><connection><identifier v="ifpath"/><connRef v="1000000427"/></connection><connection><identifier v="elsepath"/><connRef v="1000000428"/></connection></connections></paramNode><paramNode><uid v="1000000425"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000426"/><function v="gt"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000423"/></connection><connection><identifier v="b"/><connRef v="1000000425"/></connection></connections></paramNode><paramNode><uid v="1000000427"/><function v="get_integer4"/><type v="128"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer4"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000428"/><function v="get_integer4"/><type v="128"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer4"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="switch_integer4_4_inputs"/><uid v="1000000444"/><attributes><category v="Functions/switch/Integer4"/><description v="Evaluates the switch_integer4_4_inputs function graph. Result type: Integer4. Inputs: input_selection, value_1, value_2, value_3, value_4."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000445"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000446"/><attributes><label v="Value 1"/></attributes><type v="128"/><defaultValue><constantValueInt4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000447"/><attributes><label v="Value 2"/></attributes><type v="128"/><defaultValue><constantValueInt4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_3"/><uid v="1000000448"/><attributes><label v="Value 3"/></attributes><type v="128"/><defaultValue><constantValueInt4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_4"/><uid v="1000000449"/><attributes><label v="Value 4"/></attributes><type v="128"/><defaultValue><constantValueInt4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput></paraminputs><type v="128"/><paramValue><dynamicValue><rootnode v="1000000435"/><paramNodes><paramNode><uid v="1000000433"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000434"/><function v="sub"/><type v="16"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000433"/></connection><connection><identifier v="b"/><connRef v="1000000436"/></connection></connections></paramNode><paramNode><uid v="1000000435"/><function v="ifelse"/><type v="128"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000437"/></connection><connection><identifier v="ifpath"/><connRef v="1000000442"/></connection><connection><identifier v="elsepath"/><connRef v="1000000443"/></connection></connections></paramNode><paramNode><uid v="1000000436"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000437"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000433"/></connection><connection><identifier v="b"/><connRef v="1000000436"/></connection></connections></paramNode><paramNode><uid v="1000000438"/><function v="get_integer4"/><type v="128"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer4"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000439"/><function v="get_integer4"/><type v="128"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer4"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000440"/><function v="get_integer4"/><type v="128"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer4"/><constantValue><constantValueString v="value_4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000441"/><function v="get_integer4"/><type v="128"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer4"/><constantValue><constantValueString v="value_3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000442"/><function v="instance"/><type v="128"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000433"/></connection><connection><identifier v="value_1"/><connRef v="1000000438"/></connection><connection><identifier v="value_2"/><connRef v="1000000439"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer4/switch_integer4_2_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000443"/><function v="instance"/><type v="128"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000434"/></connection><connection><identifier v="value_1"/><connRef v="1000000441"/></connection><connection><identifier v="value_2"/><connRef v="1000000440"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer4/switch_integer4_2_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="switch_integer4_8_inputs"/><uid v="1000000465"/><attributes><category v="Functions/switch/Integer4"/><description v="Evaluates the switch_integer4_8_inputs function graph. Result type: Integer4. Inputs: input_selection, value_1, value_2, value_3, value_4, value_5, value_6, value_7, value_8."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000466"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000467"/><attributes><label v="Value 1"/></attributes><type v="128"/><defaultValue><constantValueInt4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000468"/><attributes><label v="Value 2"/></attributes><type v="128"/><defaultValue><constantValueInt4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_3"/><uid v="1000000469"/><attributes><label v="Value 3"/></attributes><type v="128"/><defaultValue><constantValueInt4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_4"/><uid v="1000000470"/><attributes><label v="Value 4"/></attributes><type v="128"/><defaultValue><constantValueInt4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_5"/><uid v="1000000471"/><attributes><label v="Value 5"/></attributes><type v="128"/><defaultValue><constantValueInt4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_6"/><uid v="1000000472"/><attributes><label v="Value 6"/></attributes><type v="128"/><defaultValue><constantValueInt4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_7"/><uid v="1000000473"/><attributes><label v="Value 7"/></attributes><type v="128"/><defaultValue><constantValueInt4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_8"/><uid v="1000000474"/><attributes><label v="Value 8"/></attributes><type v="128"/><defaultValue><constantValueInt4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput></paraminputs><type v="128"/><paramValue><dynamicValue><rootnode v="1000000451"/><paramNodes><paramNode><uid v="1000000450"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000451"/><function v="ifelse"/><type v="128"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000454"/></connection><connection><identifier v="ifpath"/><connRef v="1000000463"/></connection><connection><identifier v="elsepath"/><connRef v="1000000464"/></connection></connections></paramNode><paramNode><uid v="1000000452"/><function v="sub"/><type v="16"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000450"/></connection><connection><identifier v="b"/><connRef v="1000000453"/></connection></connections></paramNode><paramNode><uid v="1000000453"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000454"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000450"/></connection><connection><identifier v="b"/><connRef v="1000000453"/></connection></connections></paramNode><paramNode><uid v="1000000455"/><function v="get_integer4"/><type v="128"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer4"/><constantValue><constantValueString v="value_3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000456"/><function v="get_integer4"/><type v="128"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer4"/><constantValue><constantValueString v="value_4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000457"/><function v="get_integer4"/><type v="128"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer4"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000458"/><function v="get_integer4"/><type v="128"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer4"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000459"/><function v="get_integer4"/><type v="128"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer4"/><constantValue><constantValueString v="value_8"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000460"/><function v="get_integer4"/><type v="128"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer4"/><constantValue><constantValueString v="value_5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000461"/><function v="get_integer4"/><type v="128"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer4"/><constantValue><constantValueString v="value_6"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000462"/><function v="get_integer4"/><type v="128"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer4"/><constantValue><constantValueString v="value_7"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000463"/><function v="instance"/><type v="128"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000450"/></connection><connection><identifier v="value_1"/><connRef v="1000000457"/></connection><connection><identifier v="value_2"/><connRef v="1000000458"/></connection><connection><identifier v="value_3"/><connRef v="1000000455"/></connection><connection><identifier v="value_4"/><connRef v="1000000456"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer4/switch_integer4_4_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input><input><identifier v="value_3"/><type v="0"/></input><input><identifier v="value_4"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000464"/><function v="instance"/><type v="128"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000452"/></connection><connection><identifier v="value_1"/><connRef v="1000000460"/></connection><connection><identifier v="value_2"/><connRef v="1000000461"/></connection><connection><identifier v="value_3"/><connRef v="1000000462"/></connection><connection><identifier v="value_4"/><connRef v="1000000459"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer4/switch_integer4_4_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input><input><identifier v="value_3"/><type v="0"/></input><input><identifier v="value_4"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="Integer3"/><uid v="1000000475"/><content><function><identifier v="switch_integer3_2_inputs"/><uid v="1000000482"/><attributes><category v="Functions/switch/Integer3"/><description v="Evaluates the switch_integer3_2_inputs function graph. Result type: Integer3. Inputs: input_selection, value_1, value_2."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000483"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000484"/><attributes><label v="Value 1"/></attributes><type v="64"/><defaultValue><constantValueInt3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000485"/><attributes><label v="Value 2"/></attributes><type v="64"/><defaultValue><constantValueInt3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput></paraminputs><type v="64"/><paramValue><dynamicValue><rootnode v="1000000477"/><paramNodes><paramNode><uid v="1000000476"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000477"/><function v="ifelse"/><type v="64"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000479"/></connection><connection><identifier v="ifpath"/><connRef v="1000000480"/></connection><connection><identifier v="elsepath"/><connRef v="1000000481"/></connection></connections></paramNode><paramNode><uid v="1000000478"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000479"/><function v="gt"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000476"/></connection><connection><identifier v="b"/><connRef v="1000000478"/></connection></connections></paramNode><paramNode><uid v="1000000480"/><function v="get_integer3"/><type v="64"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer3"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000481"/><function v="get_integer3"/><type v="64"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer3"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="switch_integer3_4_inputs"/><uid v="1000000497"/><attributes><category v="Functions/switch/Integer3"/><description v="Evaluates the switch_integer3_4_inputs function graph. Result type: Integer3. Inputs: input_selection, value_1, value_2, value_3, value_4."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000498"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000499"/><attributes><label v="Value 1"/></attributes><type v="64"/><defaultValue><constantValueInt3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000500"/><attributes><label v="Value 2"/></attributes><type v="64"/><defaultValue><constantValueInt3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_3"/><uid v="1000000501"/><attributes><label v="Value 3"/></attributes><type v="64"/><defaultValue><constantValueInt3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_4"/><uid v="1000000502"/><attributes><label v="Value 4"/></attributes><type v="64"/><defaultValue><constantValueInt3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput></paraminputs><type v="64"/><paramValue><dynamicValue><rootnode v="1000000488"/><paramNodes><paramNode><uid v="1000000486"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000487"/><function v="sub"/><type v="16"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000486"/></connection><connection><identifier v="b"/><connRef v="1000000489"/></connection></connections></paramNode><paramNode><uid v="1000000488"/><function v="ifelse"/><type v="64"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000490"/></connection><connection><identifier v="ifpath"/><connRef v="1000000495"/></connection><connection><identifier v="elsepath"/><connRef v="1000000496"/></connection></connections></paramNode><paramNode><uid v="1000000489"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000490"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000486"/></connection><connection><identifier v="b"/><connRef v="1000000489"/></connection></connections></paramNode><paramNode><uid v="1000000491"/><function v="get_integer3"/><type v="64"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer3"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000492"/><function v="get_integer3"/><type v="64"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer3"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000493"/><function v="get_integer3"/><type v="64"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer3"/><constantValue><constantValueString v="value_3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000494"/><function v="get_integer3"/><type v="64"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer3"/><constantValue><constantValueString v="value_4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000495"/><function v="instance"/><type v="64"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000486"/></connection><connection><identifier v="value_1"/><connRef v="1000000492"/></connection><connection><identifier v="value_2"/><connRef v="1000000491"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer3/switch_integer3_2_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000496"/><function v="instance"/><type v="64"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000487"/></connection><connection><identifier v="value_1"/><connRef v="1000000493"/></connection><connection><identifier v="value_2"/><connRef v="1000000494"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer3/switch_integer3_2_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="switch_integer3_8_inputs"/><uid v="1000000518"/><attributes><category v="Functions/switch/Integer3"/><description v="Evaluates the switch_integer3_8_inputs function graph. Result type: Integer3. Inputs: input_selection, value_1, value_2, value_3, value_4, value_5, value_6, value_7, value_8."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000519"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000520"/><attributes><label v="Value 1"/></attributes><type v="64"/><defaultValue><constantValueInt3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000521"/><attributes><label v="Value 2"/></attributes><type v="64"/><defaultValue><constantValueInt3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_3"/><uid v="1000000522"/><attributes><label v="Value 3"/></attributes><type v="64"/><defaultValue><constantValueInt3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_4"/><uid v="1000000523"/><attributes><label v="Value 4"/></attributes><type v="64"/><defaultValue><constantValueInt3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_5"/><uid v="1000000524"/><attributes><label v="Value 5"/></attributes><type v="64"/><defaultValue><constantValueInt3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_6"/><uid v="1000000525"/><attributes><label v="Value 6"/></attributes><type v="64"/><defaultValue><constantValueInt3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_7"/><uid v="1000000526"/><attributes><label v="Value 7"/></attributes><type v="64"/><defaultValue><constantValueInt3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_8"/><uid v="1000000527"/><attributes><label v="Value 8"/></attributes><type v="64"/><defaultValue><constantValueInt3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput></paraminputs><type v="64"/><paramValue><dynamicValue><rootnode v="1000000504"/><paramNodes><paramNode><uid v="1000000503"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000504"/><function v="ifelse"/><type v="64"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000507"/></connection><connection><identifier v="ifpath"/><connRef v="1000000516"/></connection><connection><identifier v="elsepath"/><connRef v="1000000517"/></connection></connections></paramNode><paramNode><uid v="1000000505"/><function v="sub"/><type v="16"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000503"/></connection><connection><identifier v="b"/><connRef v="1000000506"/></connection></connections></paramNode><paramNode><uid v="1000000506"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000507"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000503"/></connection><connection><identifier v="b"/><connRef v="1000000506"/></connection></connections></paramNode><paramNode><uid v="1000000508"/><function v="get_integer3"/><type v="64"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer3"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000509"/><function v="get_integer3"/><type v="64"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer3"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000510"/><function v="get_integer3"/><type v="64"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer3"/><constantValue><constantValueString v="value_4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000511"/><function v="get_integer3"/><type v="64"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer3"/><constantValue><constantValueString v="value_3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000512"/><function v="get_integer3"/><type v="64"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer3"/><constantValue><constantValueString v="value_5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000513"/><function v="get_integer3"/><type v="64"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer3"/><constantValue><constantValueString v="value_6"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000514"/><function v="get_integer3"/><type v="64"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer3"/><constantValue><constantValueString v="value_8"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000515"/><function v="get_integer3"/><type v="64"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer3"/><constantValue><constantValueString v="value_7"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000516"/><function v="instance"/><type v="64"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000503"/></connection><connection><identifier v="value_1"/><connRef v="1000000508"/></connection><connection><identifier v="value_2"/><connRef v="1000000509"/></connection><connection><identifier v="value_3"/><connRef v="1000000511"/></connection><connection><identifier v="value_4"/><connRef v="1000000510"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer3/switch_integer3_4_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input><input><identifier v="value_3"/><type v="0"/></input><input><identifier v="value_4"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000517"/><function v="instance"/><type v="64"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000505"/></connection><connection><identifier v="value_1"/><connRef v="1000000512"/></connection><connection><identifier v="value_2"/><connRef v="1000000513"/></connection><connection><identifier v="value_3"/><connRef v="1000000515"/></connection><connection><identifier v="value_4"/><connRef v="1000000514"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer3/switch_integer3_4_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input><input><identifier v="value_3"/><type v="0"/></input><input><identifier v="value_4"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="Integer2"/><uid v="1000000528"/><content><function><identifier v="switch_integer2_2_inputs"/><uid v="1000000535"/><attributes><category v="Functions/switch/Integer2"/><description v="Evaluates the switch_integer2_2_inputs function graph. Result type: Integer2. Inputs: input_selection, value_1, value_2."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000536"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000537"/><attributes><label v="Value 1"/></attributes><type v="32"/><defaultValue><constantValueInt2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000538"/><attributes><label v="Value 2"/></attributes><type v="32"/><defaultValue><constantValueInt2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput></paraminputs><type v="32"/><paramValue><dynamicValue><rootnode v="1000000530"/><paramNodes><paramNode><uid v="1000000529"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000530"/><function v="ifelse"/><type v="32"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000532"/></connection><connection><identifier v="ifpath"/><connRef v="1000000534"/></connection><connection><identifier v="elsepath"/><connRef v="1000000533"/></connection></connections></paramNode><paramNode><uid v="1000000531"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000532"/><function v="gt"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000529"/></connection><connection><identifier v="b"/><connRef v="1000000531"/></connection></connections></paramNode><paramNode><uid v="1000000533"/><function v="get_integer2"/><type v="32"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer2"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000534"/><function v="get_integer2"/><type v="32"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer2"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="switch_integer2_4_inputs"/><uid v="1000000550"/><attributes><category v="Functions/switch/Integer2"/><description v="Evaluates the switch_integer2_4_inputs function graph. Result type: Integer2. Inputs: input_selection, value_1, value_2, value_3, value_4."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000551"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000552"/><attributes><label v="Value 1"/></attributes><type v="32"/><defaultValue><constantValueInt2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000553"/><attributes><label v="Value 2"/></attributes><type v="32"/><defaultValue><constantValueInt2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_3"/><uid v="1000000554"/><attributes><label v="Value 3"/></attributes><type v="32"/><defaultValue><constantValueInt2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_4"/><uid v="1000000555"/><attributes><label v="Value 4"/></attributes><type v="32"/><defaultValue><constantValueInt2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput></paraminputs><type v="32"/><paramValue><dynamicValue><rootnode v="1000000541"/><paramNodes><paramNode><uid v="1000000539"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000540"/><function v="sub"/><type v="16"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000539"/></connection><connection><identifier v="b"/><connRef v="1000000542"/></connection></connections></paramNode><paramNode><uid v="1000000541"/><function v="ifelse"/><type v="32"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000543"/></connection><connection><identifier v="ifpath"/><connRef v="1000000548"/></connection><connection><identifier v="elsepath"/><connRef v="1000000549"/></connection></connections></paramNode><paramNode><uid v="1000000542"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000543"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000539"/></connection><connection><identifier v="b"/><connRef v="1000000542"/></connection></connections></paramNode><paramNode><uid v="1000000544"/><function v="get_integer2"/><type v="32"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer2"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000545"/><function v="get_integer2"/><type v="32"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer2"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000546"/><function v="get_integer2"/><type v="32"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer2"/><constantValue><constantValueString v="value_3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000547"/><function v="get_integer2"/><type v="32"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer2"/><constantValue><constantValueString v="value_4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000548"/><function v="instance"/><type v="32"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000539"/></connection><connection><identifier v="value_1"/><connRef v="1000000545"/></connection><connection><identifier v="value_2"/><connRef v="1000000544"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer2/switch_integer2_2_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000549"/><function v="instance"/><type v="32"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000540"/></connection><connection><identifier v="value_1"/><connRef v="1000000546"/></connection><connection><identifier v="value_2"/><connRef v="1000000547"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer2/switch_integer2_2_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="switch_integer2_8_inputs"/><uid v="1000000571"/><attributes><category v="Functions/switch/Integer2"/><description v="Evaluates the switch_integer2_8_inputs function graph. Result type: Integer2. Inputs: input_selection, value_1, value_2, value_3, value_4, value_5, value_6, value_7, value_8."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000572"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000573"/><attributes><label v="Value 1"/></attributes><type v="32"/><defaultValue><constantValueInt2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000574"/><attributes><label v="Value 2"/></attributes><type v="32"/><defaultValue><constantValueInt2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_3"/><uid v="1000000575"/><attributes><label v="Value 3"/></attributes><type v="32"/><defaultValue><constantValueInt2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_4"/><uid v="1000000576"/><attributes><label v="Value 4"/></attributes><type v="32"/><defaultValue><constantValueInt2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_5"/><uid v="1000000577"/><attributes><label v="Value 5"/></attributes><type v="32"/><defaultValue><constantValueInt2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_6"/><uid v="1000000578"/><attributes><label v="Value 6"/></attributes><type v="32"/><defaultValue><constantValueInt2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_7"/><uid v="1000000579"/><attributes><label v="Value 7"/></attributes><type v="32"/><defaultValue><constantValueInt2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_8"/><uid v="1000000580"/><attributes><label v="Value 8"/></attributes><type v="32"/><defaultValue><constantValueInt2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput></paraminputs><type v="32"/><paramValue><dynamicValue><rootnode v="1000000557"/><paramNodes><paramNode><uid v="1000000556"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000557"/><function v="ifelse"/><type v="32"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000560"/></connection><connection><identifier v="ifpath"/><connRef v="1000000569"/></connection><connection><identifier v="elsepath"/><connRef v="1000000570"/></connection></connections></paramNode><paramNode><uid v="1000000558"/><function v="sub"/><type v="16"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000556"/></connection><connection><identifier v="b"/><connRef v="1000000559"/></connection></connections></paramNode><paramNode><uid v="1000000559"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000560"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000556"/></connection><connection><identifier v="b"/><connRef v="1000000559"/></connection></connections></paramNode><paramNode><uid v="1000000561"/><function v="get_integer2"/><type v="32"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer2"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000562"/><function v="get_integer2"/><type v="32"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer2"/><constantValue><constantValueString v="value_4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000563"/><function v="get_integer2"/><type v="32"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer2"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000564"/><function v="get_integer2"/><type v="32"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer2"/><constantValue><constantValueString v="value_3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000565"/><function v="get_integer2"/><type v="32"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer2"/><constantValue><constantValueString v="value_7"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000566"/><function v="get_integer2"/><type v="32"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer2"/><constantValue><constantValueString v="value_8"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000567"/><function v="get_integer2"/><type v="32"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer2"/><constantValue><constantValueString v="value_6"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000568"/><function v="get_integer2"/><type v="32"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer2"/><constantValue><constantValueString v="value_5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000569"/><function v="instance"/><type v="32"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000556"/></connection><connection><identifier v="value_1"/><connRef v="1000000563"/></connection><connection><identifier v="value_2"/><connRef v="1000000561"/></connection><connection><identifier v="value_3"/><connRef v="1000000564"/></connection><connection><identifier v="value_4"/><connRef v="1000000562"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer2/switch_integer2_4_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input><input><identifier v="value_3"/><type v="0"/></input><input><identifier v="value_4"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000570"/><function v="instance"/><type v="32"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000558"/></connection><connection><identifier v="value_1"/><connRef v="1000000568"/></connection><connection><identifier v="value_2"/><connRef v="1000000567"/></connection><connection><identifier v="value_3"/><connRef v="1000000565"/></connection><connection><identifier v="value_4"/><connRef v="1000000566"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer2/switch_integer2_4_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input><input><identifier v="value_3"/><type v="0"/></input><input><identifier v="value_4"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="Integer1"/><uid v="1000000581"/><content><function><identifier v="switch_integer1_2_inputs"/><uid v="1000000588"/><attributes><category v="Functions/switch/Integer1"/><description v="Evaluates the switch_integer1_2_inputs function graph. Result type: Integer. Inputs: input_selection, value_1, value_2."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000589"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000590"/><attributes><label v="Value 1"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000591"/><attributes><label v="Value 2"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput></paraminputs><type v="16"/><paramValue><dynamicValue><rootnode v="1000000583"/><paramNodes><paramNode><uid v="1000000582"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000583"/><function v="ifelse"/><type v="16"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000585"/></connection><connection><identifier v="ifpath"/><connRef v="1000000587"/></connection><connection><identifier v="elsepath"/><connRef v="1000000586"/></connection></connections></paramNode><paramNode><uid v="1000000584"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000585"/><function v="gt"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000582"/></connection><connection><identifier v="b"/><connRef v="1000000584"/></connection></connections></paramNode><paramNode><uid v="1000000586"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000587"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="switch_integer1_4_inputs"/><uid v="1000000603"/><attributes><category v="Functions/switch/Integer1"/><description v="Evaluates the switch_integer1_4_inputs function graph. Result type: Integer. Inputs: input_selection, value_1, value_2, value_3, value_4."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000604"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000605"/><attributes><label v="Value 1"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000606"/><attributes><label v="Value 2"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_3"/><uid v="1000000607"/><attributes><label v="Value 3"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_4"/><uid v="1000000608"/><attributes><label v="Value 4"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput></paraminputs><type v="16"/><paramValue><dynamicValue><rootnode v="1000000594"/><paramNodes><paramNode><uid v="1000000592"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000593"/><function v="sub"/><type v="16"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000592"/></connection><connection><identifier v="b"/><connRef v="1000000595"/></connection></connections></paramNode><paramNode><uid v="1000000594"/><function v="ifelse"/><type v="16"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000596"/></connection><connection><identifier v="ifpath"/><connRef v="1000000601"/></connection><connection><identifier v="elsepath"/><connRef v="1000000602"/></connection></connections></paramNode><paramNode><uid v="1000000595"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000596"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000592"/></connection><connection><identifier v="b"/><connRef v="1000000595"/></connection></connections></paramNode><paramNode><uid v="1000000597"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000598"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000599"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="value_3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000600"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="value_4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000601"/><function v="instance"/><type v="16"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000592"/></connection><connection><identifier v="value_1"/><connRef v="1000000598"/></connection><connection><identifier v="value_2"/><connRef v="1000000597"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer1/switch_integer1_2_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000602"/><function v="instance"/><type v="16"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000593"/></connection><connection><identifier v="value_1"/><connRef v="1000000599"/></connection><connection><identifier v="value_2"/><connRef v="1000000600"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer1/switch_integer1_2_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="switch_integer1_8_inputs"/><uid v="1000000624"/><attributes><category v="Functions/switch/Integer1"/><description v="Evaluates the switch_integer1_8_inputs function graph. Result type: Integer. Inputs: input_selection, value_1, value_2, value_3, value_4, value_5, value_6, value_7, value_8."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000625"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000626"/><attributes><label v="Value 1"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000627"/><attributes><label v="Value 2"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_3"/><uid v="1000000628"/><attributes><label v="Value 3"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_4"/><uid v="1000000629"/><attributes><label v="Value 4"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_5"/><uid v="1000000630"/><attributes><label v="Value 5"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_6"/><uid v="1000000631"/><attributes><label v="Value 6"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_7"/><uid v="1000000632"/><attributes><label v="Value 7"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_8"/><uid v="1000000633"/><attributes><label v="Value 8"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput></paraminputs><type v="16"/><paramValue><dynamicValue><rootnode v="1000000610"/><paramNodes><paramNode><uid v="1000000609"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000610"/><function v="ifelse"/><type v="16"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000613"/></connection><connection><identifier v="ifpath"/><connRef v="1000000622"/></connection><connection><identifier v="elsepath"/><connRef v="1000000623"/></connection></connections></paramNode><paramNode><uid v="1000000611"/><function v="sub"/><type v="16"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000609"/></connection><connection><identifier v="b"/><connRef v="1000000612"/></connection></connections></paramNode><paramNode><uid v="1000000612"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000613"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000609"/></connection><connection><identifier v="b"/><connRef v="1000000612"/></connection></connections></paramNode><paramNode><uid v="1000000614"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="value_4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000615"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000616"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="value_3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000617"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000618"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="value_8"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000619"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="value_5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000620"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="value_7"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000621"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="value_6"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000622"/><function v="instance"/><type v="16"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000609"/></connection><connection><identifier v="value_1"/><connRef v="1000000615"/></connection><connection><identifier v="value_2"/><connRef v="1000000617"/></connection><connection><identifier v="value_3"/><connRef v="1000000616"/></connection><connection><identifier v="value_4"/><connRef v="1000000614"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer1/switch_integer1_4_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input><input><identifier v="value_3"/><type v="0"/></input><input><identifier v="value_4"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000623"/><function v="instance"/><type v="16"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000611"/></connection><connection><identifier v="value_1"/><connRef v="1000000619"/></connection><connection><identifier v="value_2"/><connRef v="1000000621"/></connection><connection><identifier v="value_3"/><connRef v="1000000620"/></connection><connection><identifier v="value_4"/><connRef v="1000000618"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer1/switch_integer1_4_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input><input><identifier v="value_3"/><type v="0"/></input><input><identifier v="value_4"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="Float4"/><uid v="1000000634"/><content><function><identifier v="switch_float4_2_inputs"/><uid v="1000000641"/><attributes><category v="Functions/switch/Float4"/><description v="Evaluates the switch_float4_2_inputs function graph. Result type: Float4. Inputs: input_selection, value_1, value_2."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000642"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000643"/><attributes><label v="Value 1"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000644"/><attributes><label v="Value 2"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="2048"/><paramValue><dynamicValue><rootnode v="1000000636"/><paramNodes><paramNode><uid v="1000000635"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000636"/><function v="ifelse"/><type v="2048"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000638"/></connection><connection><identifier v="ifpath"/><connRef v="1000000639"/></connection><connection><identifier v="elsepath"/><connRef v="1000000640"/></connection></connections></paramNode><paramNode><uid v="1000000637"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000638"/><function v="gt"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000635"/></connection><connection><identifier v="b"/><connRef v="1000000637"/></connection></connections></paramNode><paramNode><uid v="1000000639"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000640"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="switch_float4_4_inputs"/><uid v="1000000656"/><attributes><category v="Functions/switch/Float4"/><description v="Evaluates the switch_float4_4_inputs function graph. Result type: Float4. Inputs: input_selection, value_1, value_2, value_3, value_4."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000657"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000658"/><attributes><label v="Value 1"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000659"/><attributes><label v="Value 2"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_3"/><uid v="1000000660"/><attributes><label v="Value 3"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_4"/><uid v="1000000661"/><attributes><label v="Value 4"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="2048"/><paramValue><dynamicValue><rootnode v="1000000647"/><paramNodes><paramNode><uid v="1000000645"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000646"/><function v="sub"/><type v="16"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000645"/></connection><connection><identifier v="b"/><connRef v="1000000648"/></connection></connections></paramNode><paramNode><uid v="1000000647"/><function v="ifelse"/><type v="2048"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000649"/></connection><connection><identifier v="ifpath"/><connRef v="1000000654"/></connection><connection><identifier v="elsepath"/><connRef v="1000000655"/></connection></connections></paramNode><paramNode><uid v="1000000648"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000649"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000645"/></connection><connection><identifier v="b"/><connRef v="1000000648"/></connection></connections></paramNode><paramNode><uid v="1000000650"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000651"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000652"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="value_4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000653"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="value_3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000654"/><function v="instance"/><type v="2048"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000645"/></connection><connection><identifier v="value_1"/><connRef v="1000000650"/></connection><connection><identifier v="value_2"/><connRef v="1000000651"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float4/switch_float4_2_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000655"/><function v="instance"/><type v="2048"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000646"/></connection><connection><identifier v="value_1"/><connRef v="1000000653"/></connection><connection><identifier v="value_2"/><connRef v="1000000652"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float4/switch_float4_2_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="switch_float4_8_inputs"/><uid v="1000000677"/><attributes><category v="Functions/switch/Float4"/><description v="Evaluates the switch_float4_8_inputs function graph. Result type: Float4. Inputs: input_selection, value_1, value_2, value_3, value_4, value_5, value_6, value_7, value_8."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000678"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000679"/><attributes><label v="Value 1"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000680"/><attributes><label v="Value 2"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_3"/><uid v="1000000681"/><attributes><label v="Value 3"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_4"/><uid v="1000000682"/><attributes><label v="Value 4"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_5"/><uid v="1000000683"/><attributes><label v="Value 5"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_6"/><uid v="1000000684"/><attributes><label v="Value 6"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_7"/><uid v="1000000685"/><attributes><label v="Value 7"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_8"/><uid v="1000000686"/><attributes><label v="Value 8"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="2048"/><paramValue><dynamicValue><rootnode v="1000000663"/><paramNodes><paramNode><uid v="1000000662"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000663"/><function v="ifelse"/><type v="2048"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000666"/></connection><connection><identifier v="ifpath"/><connRef v="1000000671"/></connection><connection><identifier v="elsepath"/><connRef v="1000000672"/></connection></connections></paramNode><paramNode><uid v="1000000664"/><function v="sub"/><type v="16"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000662"/></connection><connection><identifier v="b"/><connRef v="1000000665"/></connection></connections></paramNode><paramNode><uid v="1000000665"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000666"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000662"/></connection><connection><identifier v="b"/><connRef v="1000000665"/></connection></connections></paramNode><paramNode><uid v="1000000667"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000668"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="value_3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000669"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000670"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="value_4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000671"/><function v="instance"/><type v="2048"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000662"/></connection><connection><identifier v="value_1"/><connRef v="1000000667"/></connection><connection><identifier v="value_2"/><connRef v="1000000669"/></connection><connection><identifier v="value_3"/><connRef v="1000000668"/></connection><connection><identifier v="value_4"/><connRef v="1000000670"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float4/switch_float4_4_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input><input><identifier v="value_3"/><type v="0"/></input><input><identifier v="value_4"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000672"/><function v="instance"/><type v="2048"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000664"/></connection><connection><identifier v="value_1"/><connRef v="1000000676"/></connection><connection><identifier v="value_2"/><connRef v="1000000674"/></connection><connection><identifier v="value_3"/><connRef v="1000000673"/></connection><connection><identifier v="value_4"/><connRef v="1000000675"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float4/switch_float4_4_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input><input><identifier v="value_3"/><type v="0"/></input><input><identifier v="value_4"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000673"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="value_7"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000674"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="value_6"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000675"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="value_8"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000676"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="value_5"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="Float3"/><uid v="1000000687"/><content><function><identifier v="switch_float3_2_inputs"/><uid v="1000000694"/><attributes><category v="Functions/switch/Float3"/><description v="Evaluates the switch_float3_2_inputs function graph. Result type: Float3. Inputs: input_selection, value_1, value_2."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000695"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000696"/><attributes><label v="Value 1"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000697"/><attributes><label v="Value 2"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000000689"/><paramNodes><paramNode><uid v="1000000688"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000689"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000691"/></connection><connection><identifier v="ifpath"/><connRef v="1000000692"/></connection><connection><identifier v="elsepath"/><connRef v="1000000693"/></connection></connections></paramNode><paramNode><uid v="1000000690"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000691"/><function v="gt"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000688"/></connection><connection><identifier v="b"/><connRef v="1000000690"/></connection></connections></paramNode><paramNode><uid v="1000000692"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000693"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="switch_float3_4_inputs"/><uid v="1000000709"/><attributes><category v="Functions/switch/Float3"/><description v="Evaluates the switch_float3_4_inputs function graph. Result type: Float3. Inputs: input_selection, value_1, value_2, value_3, value_4."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000710"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000711"/><attributes><label v="Value 1"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000712"/><attributes><label v="Value 2"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_3"/><uid v="1000000713"/><attributes><label v="Value 3"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_4"/><uid v="1000000714"/><attributes><label v="Value 4"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000000700"/><paramNodes><paramNode><uid v="1000000698"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000699"/><function v="sub"/><type v="16"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000698"/></connection><connection><identifier v="b"/><connRef v="1000000701"/></connection></connections></paramNode><paramNode><uid v="1000000700"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000702"/></connection><connection><identifier v="ifpath"/><connRef v="1000000707"/></connection><connection><identifier v="elsepath"/><connRef v="1000000708"/></connection></connections></paramNode><paramNode><uid v="1000000701"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000702"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000698"/></connection><connection><identifier v="b"/><connRef v="1000000701"/></connection></connections></paramNode><paramNode><uid v="1000000703"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000704"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000705"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="value_3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000706"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="value_4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000707"/><function v="instance"/><type v="1024"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000698"/></connection><connection><identifier v="value_1"/><connRef v="1000000703"/></connection><connection><identifier v="value_2"/><connRef v="1000000704"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float3/switch_float3_2_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000708"/><function v="instance"/><type v="1024"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000699"/></connection><connection><identifier v="value_1"/><connRef v="1000000705"/></connection><connection><identifier v="value_2"/><connRef v="1000000706"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float3/switch_float3_2_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="switch_float3_8_inputs"/><uid v="1000000730"/><attributes><category v="Functions/switch/Float3"/><description v="Evaluates the switch_float3_8_inputs function graph. Result type: Float3. Inputs: input_selection, value_1, value_2, value_3, value_4, value_5, value_6, value_7, value_8."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000731"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000732"/><attributes><label v="Value 1"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000733"/><attributes><label v="Value 2"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_3"/><uid v="1000000734"/><attributes><label v="Value 3"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_4"/><uid v="1000000735"/><attributes><label v="Value 4"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_5"/><uid v="1000000736"/><attributes><label v="Value 5"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_6"/><uid v="1000000737"/><attributes><label v="Value 6"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_7"/><uid v="1000000738"/><attributes><label v="Value 7"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_8"/><uid v="1000000739"/><attributes><label v="Value 8"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000000716"/><paramNodes><paramNode><uid v="1000000715"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000716"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000719"/></connection><connection><identifier v="ifpath"/><connRef v="1000000728"/></connection><connection><identifier v="elsepath"/><connRef v="1000000729"/></connection></connections></paramNode><paramNode><uid v="1000000717"/><function v="sub"/><type v="16"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000715"/></connection><connection><identifier v="b"/><connRef v="1000000718"/></connection></connections></paramNode><paramNode><uid v="1000000718"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000719"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000715"/></connection><connection><identifier v="b"/><connRef v="1000000718"/></connection></connections></paramNode><paramNode><uid v="1000000720"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="value_4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000721"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000722"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="value_3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000723"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000724"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="value_6"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000725"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="value_7"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000726"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="value_8"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000727"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="value_5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000728"/><function v="instance"/><type v="1024"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000715"/></connection><connection><identifier v="value_1"/><connRef v="1000000723"/></connection><connection><identifier v="value_2"/><connRef v="1000000721"/></connection><connection><identifier v="value_3"/><connRef v="1000000722"/></connection><connection><identifier v="value_4"/><connRef v="1000000720"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float3/switch_float3_4_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input><input><identifier v="value_3"/><type v="0"/></input><input><identifier v="value_4"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000729"/><function v="instance"/><type v="1024"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000717"/></connection><connection><identifier v="value_1"/><connRef v="1000000727"/></connection><connection><identifier v="value_2"/><connRef v="1000000724"/></connection><connection><identifier v="value_3"/><connRef v="1000000725"/></connection><connection><identifier v="value_4"/><connRef v="1000000726"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float3/switch_float3_4_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input><input><identifier v="value_3"/><type v="0"/></input><input><identifier v="value_4"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="Float2"/><uid v="1000000740"/><content><function><identifier v="switch_float2_2_inputs"/><uid v="1000000747"/><attributes><category v="Functions/switch/Float2"/><description v="Evaluates the switch_float2_2_inputs function graph. Result type: Float2. Inputs: input_selection, value_1, value_2."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000748"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000749"/><attributes><label v="Value 1"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000750"/><attributes><label v="Value 2"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="512"/><paramValue><dynamicValue><rootnode v="1000000742"/><paramNodes><paramNode><uid v="1000000741"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000742"/><function v="ifelse"/><type v="512"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000744"/></connection><connection><identifier v="ifpath"/><connRef v="1000000746"/></connection><connection><identifier v="elsepath"/><connRef v="1000000745"/></connection></connections></paramNode><paramNode><uid v="1000000743"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000744"/><function v="gt"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000741"/></connection><connection><identifier v="b"/><connRef v="1000000743"/></connection></connections></paramNode><paramNode><uid v="1000000745"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000746"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="switch_float2_4_inputs"/><uid v="1000000762"/><attributes><category v="Functions/switch/Float2"/><description v="Evaluates the switch_float2_4_inputs function graph. Result type: Float2. Inputs: input_selection, value_1, value_2, value_3, value_4."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000763"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000764"/><attributes><label v="Value 1"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000765"/><attributes><label v="Value 2"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_3"/><uid v="1000000766"/><attributes><label v="Value 3"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_4"/><uid v="1000000767"/><attributes><label v="Value 4"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="512"/><paramValue><dynamicValue><rootnode v="1000000753"/><paramNodes><paramNode><uid v="1000000751"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000752"/><function v="sub"/><type v="16"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000751"/></connection><connection><identifier v="b"/><connRef v="1000000754"/></connection></connections></paramNode><paramNode><uid v="1000000753"/><function v="ifelse"/><type v="512"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000755"/></connection><connection><identifier v="ifpath"/><connRef v="1000000760"/></connection><connection><identifier v="elsepath"/><connRef v="1000000761"/></connection></connections></paramNode><paramNode><uid v="1000000754"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000755"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000751"/></connection><connection><identifier v="b"/><connRef v="1000000754"/></connection></connections></paramNode><paramNode><uid v="1000000756"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000757"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000758"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="value_4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000759"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="value_3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000760"/><function v="instance"/><type v="512"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000751"/></connection><connection><identifier v="value_1"/><connRef v="1000000757"/></connection><connection><identifier v="value_2"/><connRef v="1000000756"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float2/switch_float2_2_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000761"/><function v="instance"/><type v="512"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="value_1"/><connRef v="1000000759"/></connection><connection><identifier v="value_2"/><connRef v="1000000758"/></connection><connection><identifier v="input_selection"/><connRef v="1000000752"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float2/switch_float2_2_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input><input><identifier v="input_selection"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="switch_float2_8_inputs"/><uid v="1000000783"/><attributes><category v="Functions/switch/Float2"/><description v="Evaluates the switch_float2_8_inputs function graph. Result type: Float2. Inputs: input_selection, value_1, value_2, value_3, value_4, value_5, value_6, value_7, value_8."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000784"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000785"/><attributes><label v="Value 1"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000786"/><attributes><label v="Value 2"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_3"/><uid v="1000000787"/><attributes><label v="Value 3"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_4"/><uid v="1000000788"/><attributes><label v="Value 4"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_5"/><uid v="1000000789"/><attributes><label v="Value 5"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_6"/><uid v="1000000790"/><attributes><label v="Value 6"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_7"/><uid v="1000000791"/><attributes><label v="Value 7"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_8"/><uid v="1000000792"/><attributes><label v="Value 8"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="512"/><paramValue><dynamicValue><rootnode v="1000000769"/><paramNodes><paramNode><uid v="1000000768"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000769"/><function v="ifelse"/><type v="512"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000772"/></connection><connection><identifier v="ifpath"/><connRef v="1000000777"/></connection><connection><identifier v="elsepath"/><connRef v="1000000782"/></connection></connections></paramNode><paramNode><uid v="1000000770"/><function v="sub"/><type v="16"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000768"/></connection><connection><identifier v="b"/><connRef v="1000000771"/></connection></connections></paramNode><paramNode><uid v="1000000771"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000772"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000768"/></connection><connection><identifier v="b"/><connRef v="1000000771"/></connection></connections></paramNode><paramNode><uid v="1000000773"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="value_4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000774"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000775"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000776"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="value_3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000777"/><function v="instance"/><type v="512"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000768"/></connection><connection><identifier v="value_1"/><connRef v="1000000774"/></connection><connection><identifier v="value_2"/><connRef v="1000000775"/></connection><connection><identifier v="value_3"/><connRef v="1000000776"/></connection><connection><identifier v="value_4"/><connRef v="1000000773"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float2/switch_float2_4_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input><input><identifier v="value_3"/><type v="0"/></input><input><identifier v="value_4"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000778"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="value_8"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000779"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="value_5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000780"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="value_6"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000781"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="value_7"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000782"/><function v="instance"/><type v="512"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000770"/></connection><connection><identifier v="value_1"/><connRef v="1000000779"/></connection><connection><identifier v="value_2"/><connRef v="1000000780"/></connection><connection><identifier v="value_3"/><connRef v="1000000781"/></connection><connection><identifier v="value_4"/><connRef v="1000000778"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float2/switch_float2_4_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input><input><identifier v="value_3"/><type v="0"/></input><input><identifier v="value_4"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="Float1"/><uid v="1000000793"/><content><function><identifier v="switch_float1_2_inputs"/><uid v="1000000800"/><attributes><category v="Functions/switch/Float1"/><description v="Evaluates the switch_float1_2_inputs function graph. Result type: Float. Inputs: input_selection, value_1, value_2."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000801"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000802"/><attributes><label v="Value 1"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000803"/><attributes><label v="Value 2"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000797"/><paramNodes><paramNode><uid v="1000000794"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000795"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000796"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000797"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000799"/></connection><connection><identifier v="ifpath"/><connRef v="1000000796"/></connection><connection><identifier v="elsepath"/><connRef v="1000000795"/></connection></connections></paramNode><paramNode><uid v="1000000798"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000799"/><function v="gt"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000794"/></connection><connection><identifier v="b"/><connRef v="1000000798"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="switch_float1_4_inputs"/><uid v="1000000815"/><attributes><category v="Functions/switch/Float1"/><description v="Evaluates the switch_float1_4_inputs function graph. Result type: Float. Inputs: input_selection, value_1, value_2, value_3, value_4."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000816"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000817"/><attributes><label v="Value 1"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000818"/><attributes><label v="Value 2"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_3"/><uid v="1000000819"/><attributes><label v="Value 3"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_4"/><uid v="1000000820"/><attributes><label v="Value 4"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000811"/><paramNodes><paramNode><uid v="1000000804"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000805"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000806"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000807"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="value_3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000808"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="value_4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000809"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="value_1"/><connRef v="1000000805"/></connection><connection><identifier v="value_2"/><connRef v="1000000806"/></connection><connection><identifier v="input_selection"/><connRef v="1000000804"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float1/switch_float1_2_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input><input><identifier v="input_selection"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000810"/><function v="sub"/><type v="16"/><GUILayout><gpos v="344 228 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000804"/></connection><connection><identifier v="b"/><connRef v="1000000813"/></connection></connections></paramNode><paramNode><uid v="1000000811"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000814"/></connection><connection><identifier v="ifpath"/><connRef v="1000000809"/></connection><connection><identifier v="elsepath"/><connRef v="1000000812"/></connection></connections></paramNode><paramNode><uid v="1000000812"/><function v="instance"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="value_1"/><connRef v="1000000807"/></connection><connection><identifier v="value_2"/><connRef v="1000000808"/></connection><connection><identifier v="input_selection"/><connRef v="1000000810"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float1/switch_float1_2_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input><input><identifier v="input_selection"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000813"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000814"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 388 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000804"/></connection><connection><identifier v="b"/><connRef v="1000000813"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="switch_float1_8_inputs"/><uid v="1000000836"/><attributes><category v="Functions/switch/Float1"/><description v="Evaluates the switch_float1_8_inputs function graph. Result type: Float. Inputs: input_selection, value_1, value_2, value_3, value_4, value_5, value_6, value_7, value_8."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000837"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000838"/><attributes><label v="Value 1"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000839"/><attributes><label v="Value 2"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_3"/><uid v="1000000840"/><attributes><label v="Value 3"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_4"/><uid v="1000000841"/><attributes><label v="Value 4"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_5"/><uid v="1000000842"/><attributes><label v="Value 5"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_6"/><uid v="1000000843"/><attributes><label v="Value 6"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_7"/><uid v="1000000844"/><attributes><label v="Value 7"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_8"/><uid v="1000000845"/><attributes><label v="Value 8"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000831"/><paramNodes><paramNode><uid v="1000000821"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000822"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000823"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000824"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="value_3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000825"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="value_4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000826"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="value_5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000827"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="value_6"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000828"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="value_7"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000829"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="value_8"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000830"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000821"/></connection><connection><identifier v="value_1"/><connRef v="1000000822"/></connection><connection><identifier v="value_2"/><connRef v="1000000823"/></connection><connection><identifier v="value_3"/><connRef v="1000000824"/></connection><connection><identifier v="value_4"/><connRef v="1000000825"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float1/switch_float1_4_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input><input><identifier v="value_3"/><type v="0"/></input><input><identifier v="value_4"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000831"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000835"/></connection><connection><identifier v="ifpath"/><connRef v="1000000830"/></connection><connection><identifier v="elsepath"/><connRef v="1000000832"/></connection></connections></paramNode><paramNode><uid v="1000000832"/><function v="instance"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="value_1"/><connRef v="1000000826"/></connection><connection><identifier v="value_2"/><connRef v="1000000827"/></connection><connection><identifier v="value_3"/><connRef v="1000000828"/></connection><connection><identifier v="value_4"/><connRef v="1000000829"/></connection><connection><identifier v="input_selection"/><connRef v="1000000833"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float1/switch_float1_4_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input><input><identifier v="value_3"/><type v="0"/></input><input><identifier v="value_4"/><type v="0"/></input><input><identifier v="input_selection"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000833"/><function v="sub"/><type v="16"/><GUILayout><gpos v="344 284 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000821"/></connection><connection><identifier v="b"/><connRef v="1000000834"/></connection></connections></paramNode><paramNode><uid v="1000000834"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000835"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 444 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000821"/></connection><connection><identifier v="b"/><connRef v="1000000834"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group></content></group><group><identifier v="Various"/><uid v="1000000846"/><content><function><identifier v="disorder"/><uid v="1000000859"/><attributes><category v="Functions/Various"/><description v="Evaluates the disorder function graph. Result type: Float2. Inputs: disorder_radius, disorder_angle."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="disorder_radius"/><uid v="1000000860"/><attributes><label v="disorder_radius"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="disorder_angle"/><uid v="1000000861"/><attributes><label v="disorder_angle"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="512"/><paramValue><dynamicValue><rootnode v="1000000848"/><paramNodes><paramNode><uid v="1000000847"/><function v="rand"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000849"/></connection></connections></paramNode><paramNode><uid v="1000000848"/><function v="cartesian"/><type v="512"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="rho"/><connRef v="1000000847"/></connection><connection><identifier v="theta"/><connRef v="1000000858"/></connection></connections></paramNode><paramNode><uid v="1000000849"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="disorder_radius"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000850"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000851"/><function v="rand"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000850"/></connection></connections></paramNode><paramNode><uid v="1000000852"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000851"/></connection><connection><identifier v="b"/><connRef v="1000000853"/></connection></connections></paramNode><paramNode><uid v="1000000853"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000854"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="6.283185"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000855"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000854"/></connection><connection><identifier v="b"/><connRef v="1000000852"/></connection></connections></paramNode><paramNode><uid v="1000000856"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="disorder_angle"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000857"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000854"/></connection><connection><identifier v="b"/><connRef v="1000000856"/></connection></connections></paramNode><paramNode><uid v="1000000858"/><function v="add"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000855"/></connection><connection><identifier v="b"/><connRef v="1000000857"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="disorder_v2"/><uid v="1000000872"/><attributes><category v="Functions/Various"/><description v="Evaluates the disorder_v2 function graph. Result type: Float2. Inputs: disorder_radius, disorder_angle."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="disorder_radius"/><uid v="1000000873"/><attributes><label v="disorder_radius"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="disorder_angle"/><uid v="1000000874"/><attributes><label v="disorder_angle"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="512"/><paramValue><dynamicValue><rootnode v="1000000863"/><paramNodes><paramNode><uid v="1000000862"/><function v="rand"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000870"/></connection></connections></paramNode><paramNode><uid v="1000000863"/><function v="cartesian"/><type v="512"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="rho"/><connRef v="1000000871"/></connection><connection><identifier v="theta"/><connRef v="1000000868"/></connection></connections></paramNode><paramNode><uid v="1000000864"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="disorder_radius"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000865"/><function v="rand"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000870"/></connection></connections></paramNode><paramNode><uid v="1000000866"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="6.283185"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000867"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="disorder_angle"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000868"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000869"/></connection><connection><identifier v="b"/><connRef v="1000000866"/></connection></connections></paramNode><paramNode><uid v="1000000869"/><function v="add"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000865"/></connection><connection><identifier v="b"/><connRef v="1000000867"/></connection></connections></paramNode><paramNode><uid v="1000000870"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000871"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000864"/></connection><connection><identifier v="b"/><connRef v="1000000862"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="disorder_anim"/><uid v="1000000890"/><attributes><category v="Functions/Various"/><description v="Evaluates the disorder_anim function graph. Result type: Float2. Inputs: disorder_angle, speed."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="disorder_angle"/><uid v="1000000891"/><attributes><label v="disorder_angle"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="speed"/><uid v="1000000892"/><attributes><label v="speed"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="512"/><paramValue><dynamicValue><rootnode v="1000000876"/><paramNodes><paramNode><uid v="1000000875"/><function v="rand"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000883"/></connection></connections></paramNode><paramNode><uid v="1000000876"/><function v="cartesian"/><type v="512"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="rho"/><connRef v="1000000889"/></connection><connection><identifier v="theta"/><connRef v="1000000881"/></connection></connections></paramNode><paramNode><uid v="1000000877"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000878"/><function v="rand"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000877"/></connection></connections></paramNode><paramNode><uid v="1000000879"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="6.283185"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000880"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="disorder_angle"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000881"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000882"/></connection><connection><identifier v="b"/><connRef v="1000000879"/></connection></connections></paramNode><paramNode><uid v="1000000882"/><function v="add"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000878"/></connection><connection><identifier v="b"/><connRef v="1000000880"/></connection></connections></paramNode><paramNode><uid v="1000000883"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.75"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000884"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000887"/></connection><connection><identifier v="b"/><connRef v="1000000885"/></connection></connections></paramNode><paramNode><uid v="1000000885"/><function v="add"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000886"/></connection><connection><identifier v="b"/><connRef v="1000000875"/></connection></connections></paramNode><paramNode><uid v="1000000886"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.25"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000887"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="speed"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000888"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.15915495"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000889"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000884"/></connection><connection><identifier v="b"/><connRef v="1000000888"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="non_square_output_size"/><uid v="1000000963"/><attributes><category v="Functions/Various"/><description v="Evaluates the non_square_output_size function graph. Result type: Integer2. Inputs: scale, output_size, non_square."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="scale"/><uid v="1000000964"/><attributes><label v="scale"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="output_size"/><uid v="1000000965"/><attributes><label v="output_size"/></attributes><type v="32"/><defaultValue><constantValueInt2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="non_square"/><uid v="1000000966"/><attributes><label v="non_square"/></attributes><type v="4"/><defaultValue><constantValueBool v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="32"/><paramValue><dynamicValue><rootnode v="1000000893"/><paramNodes><paramNode><uid v="1000000893"/><function v="sequence"/><type v="32"/><GUILayout><gpos v="6784 64 0"/></GUILayout><connections><connection><identifier v="seqin"/><connRef v="1000000957"/></connection><connection><identifier v="seqlast"/><connRef v="1000000906"/></connection></connections></paramNode><paramNode><uid v="1000000894"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000000899"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000895"/><function v="toint1"/><type v="16"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000000898"/></connection></connections></paramNode><paramNode><uid v="1000000896"/><function v="mul"/><type v="16"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000895"/></connection><connection><identifier v="b"/><connRef v="1000000901"/></connection></connections></paramNode><paramNode><uid v="1000000897"/><function v="abs"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000955"/></connection></connections></paramNode><paramNode><uid v="1000000898"/><function v="pow2"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000897"/></connection></connections></paramNode><paramNode><uid v="1000000899"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="$sizelog2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000900"/><function v="set"/><type v="16"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000000896"/></connection></connections><funcDatas><funcData><name v="set"/><constantValue><constantValueString v="real_scale"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000901"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="scale"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000902"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000000899"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000903"/><function v="sequence"/><type v="256"/><GUILayout><gpos v="6224 64 0"/></GUILayout><connections><connection><identifier v="seqin"/><connRef v="1000000907"/></connection><connection><identifier v="seqlast"/><connRef v="1000000904"/></connection></connections></paramNode><paramNode><uid v="1000000904"/><function v="set"/><type v="256"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000000955"/></connection></connections><funcDatas><funcData><name v="set"/><constantValue><constantValueString v="xy_difference"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000905"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000902"/></connection><connection><identifier v="b"/><connRef v="1000000894"/></connection></connections></paramNode><paramNode><uid v="1000000906"/><function v="get_integer2"/><type v="32"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer2"/><constantValue><constantValueString v="output_size"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000907"/><function v="sequence"/><type v="16"/><GUILayout><gpos v="5944 64 0"/></GUILayout><connections><connection><identifier v="seqin"/><connRef v="1000000928"/></connection><connection><identifier v="seqlast"/><connRef v="1000000900"/></connection></connections></paramNode><paramNode><uid v="1000000908"/><function v="set"/><type v="2048"/><GUILayout><gpos v="5104 64 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000000932"/></connection></connections><funcDatas><funcData><name v="set"/><constantValue><constantValueString v="tiling_region"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000909"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000910"/><function v="swizzle4"/><type v="2048"/><GUILayout><gpos v="4824 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000000918"/></connection></connections><funcDatas><funcData><name v="swizzle4"/><constantValue><constantValueInt4 v="2 3 0 1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000911"/><function v="mul"/><type v="2048"/><GUILayout><gpos v="4264 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000914"/></connection><connection><identifier v="b"/><connRef v="1000000953"/></connection></connections></paramNode><paramNode><uid v="1000000912"/><function v="mulscalar"/><type v="512"/><GUILayout><gpos v="2584 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000923"/></connection><connection><identifier v="scalar"/><connRef v="1000000926"/></connection></connections></paramNode><paramNode><uid v="1000000913"/><function v="const_float2"/><type v="512"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float2"/><constantValue><constantValueFloat2 v="1 1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000914"/><function v="vector4"/><type v="2048"/><GUILayout><gpos v="2304 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000000913"/></connection><connection><identifier v="componentslast"/><connRef v="1000000924"/></connection></connections></paramNode><paramNode><uid v="1000000915"/><function v="gt"/><type v="4"/><GUILayout><gpos v="1184 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000955"/></connection><connection><identifier v="b"/><connRef v="1000000909"/></connection></connections></paramNode><paramNode><uid v="1000000916"/><function v="ifelse"/><type v="2048"/><GUILayout><gpos v="5104 224 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000915"/></connection><connection><identifier v="ifpath"/><connRef v="1000000918"/></connection><connection><identifier v="elsepath"/><connRef v="1000000910"/></connection></connections></paramNode><paramNode><uid v="1000000917"/><function v="neg"/><type v="256"/><GUILayout><gpos v="1464 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000920"/></connection></connections></paramNode><paramNode><uid v="1000000918"/><function v="add"/><type v="2048"/><GUILayout><gpos v="4544 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000921"/></connection><connection><identifier v="b"/><connRef v="1000000911"/></connection></connections></paramNode><paramNode><uid v="1000000919"/><function v="pow2"/><type v="256"/><GUILayout><gpos v="1744 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000917"/></connection></connections></paramNode><paramNode><uid v="1000000920"/><function v="abs"/><type v="256"/><GUILayout><gpos v="1184 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000955"/></connection></connections></paramNode><paramNode><uid v="1000000921"/><function v="vector4"/><type v="2048"/><GUILayout><gpos v="2864 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000000925"/></connection><connection><identifier v="componentslast"/><connRef v="1000000912"/></connection></connections></paramNode><paramNode><uid v="1000000922"/><function v="const_float2"/><type v="512"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float2"/><constantValue><constantValueFloat2 v="1 1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000923"/><function v="sub"/><type v="512"/><GUILayout><gpos v="2304 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000922"/></connection><connection><identifier v="b"/><connRef v="1000000924"/></connection></connections></paramNode><paramNode><uid v="1000000924"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2024 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000000919"/></connection><connection><identifier v="componentslast"/><connRef v="1000000919"/></connection></connections></paramNode><paramNode><uid v="1000000925"/><function v="const_float2"/><type v="512"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float2"/><constantValue><constantValueFloat2 v="0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000926"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000927"/><function v="set"/><type v="2048"/><GUILayout><gpos v="5384 64 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000000916"/></connection></connections><funcDatas><funcData><name v="set"/><constantValue><constantValueString v="render_region"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000928"/><function v="sequence"/><type v="2048"/><GUILayout><gpos v="5664 64 0"/></GUILayout><connections><connection><identifier v="seqin"/><connRef v="1000000927"/></connection><connection><identifier v="seqlast"/><connRef v="1000000908"/></connection></connections></paramNode><paramNode><uid v="1000000929"/><function v="get_bool"/><type v="4"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_bool"/><constantValue><constantValueString v="non_square"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000930"/><function v="const_float4"/><type v="2048"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float4"/><constantValue><constantValueFloat4 v="0 1 0 1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000931"/><function v="neg"/><type v="256"/><GUILayout><gpos v="3144 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000938"/></connection></connections></paramNode><paramNode><uid v="1000000932"/><function v="ifelse"/><type v="2048"/><GUILayout><gpos v="4824 224 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000915"/></connection><connection><identifier v="ifpath"/><connRef v="1000000941"/></connection><connection><identifier v="elsepath"/><connRef v="1000000936"/></connection></connections></paramNode><paramNode><uid v="1000000933"/><function v="tofloat"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000000901"/></connection></connections></paramNode><paramNode><uid v="1000000934"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2864 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000000949"/></connection><connection><identifier v="componentslast"/><connRef v="1000000940"/></connection></connections></paramNode><paramNode><uid v="1000000935"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="344 544 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000000937"/></connection><connection><identifier v="componentslast"/><connRef v="1000000937"/></connection></connections></paramNode><paramNode><uid v="1000000936"/><function v="swizzle4"/><type v="2048"/><GUILayout><gpos v="4544 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000000941"/></connection></connections><funcDatas><funcData><name v="swizzle4"/><constantValue><constantValueInt4 v="2 3 0 1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000937"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1664 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000938"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2864 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000943"/></connection><connection><identifier v="b"/><connRef v="1000000950"/></connection></connections></paramNode><paramNode><uid v="1000000939"/><function v="vector4"/><type v="2048"/><GUILayout><gpos v="3704 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000000946"/></connection><connection><identifier v="componentslast"/><connRef v="1000000946"/></connection></connections></paramNode><paramNode><uid v="1000000940"/><function v="neg"/><type v="256"/><GUILayout><gpos v="2584 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000949"/></connection></connections></paramNode><paramNode><uid v="1000000941"/><function v="add"/><type v="2048"/><GUILayout><gpos v="4264 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000953"/></connection><connection><identifier v="b"/><connRef v="1000000947"/></connection></connections></paramNode><paramNode><uid v="1000000942"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1744 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000898"/></connection><connection><identifier v="b"/><connRef v="1000000951"/></connection></connections></paramNode><paramNode><uid v="1000000943"/><function v="sub"/><type v="256"/><GUILayout><gpos v="2584 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000945"/></connection><connection><identifier v="b"/><connRef v="1000000952"/></connection></connections></paramNode><paramNode><uid v="1000000944"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1824 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000945"/><function v="tofloat"/><type v="256"/><GUILayout><gpos v="2304 544 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000000896"/></connection></connections></paramNode><paramNode><uid v="1000000946"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="3424 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000000931"/></connection><connection><identifier v="componentslast"/><connRef v="1000000938"/></connection></connections></paramNode><paramNode><uid v="1000000947"/><function v="vector4"/><type v="2048"/><GUILayout><gpos v="3144 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000000935"/></connection><connection><identifier v="componentslast"/><connRef v="1000000934"/></connection></connections></paramNode><paramNode><uid v="1000000948"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2024 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000942"/></connection><connection><identifier v="b"/><connRef v="1000000944"/></connection></connections></paramNode><paramNode><uid v="1000000949"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2304 704 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000933"/></connection><connection><identifier v="b"/><connRef v="1000000948"/></connection></connections></paramNode><paramNode><uid v="1000000950"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1984 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000951"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 2144 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000952"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 2304 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000953"/><function v="add"/><type v="2048"/><GUILayout><gpos v="3984 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000939"/></connection><connection><identifier v="b"/><connRef v="1000000930"/></connection></connections></paramNode><paramNode><uid v="1000000954"/><function v="const_float4"/><type v="2048"/><GUILayout><gpos v="64 2464 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float4"/><constantValue><constantValueFloat4 v="1 1 1 1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000955"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000929"/></connection><connection><identifier v="ifpath"/><connRef v="1000000905"/></connection><connection><identifier v="elsepath"/><connRef v="1000000956"/></connection></connections></paramNode><paramNode><uid v="1000000956"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 2624 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000957"/><function v="sequence"/><type v="512"/><GUILayout><gpos v="6504 64 0"/></GUILayout><connections><connection><identifier v="seqin"/><connRef v="1000000903"/></connection><connection><identifier v="seqlast"/><connRef v="1000000958"/></connection></connections></paramNode><paramNode><uid v="1000000958"/><function v="set"/><type v="512"/><GUILayout><gpos v="2024 544 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000000962"/></connection></connections><funcDatas><funcData><name v="set"/><constantValue><constantValueString v="xy_ratio"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000959"/><function v="pow2"/><type v="256"/><GUILayout><gpos v="1184 704 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000955"/></connection></connections></paramNode><paramNode><uid v="1000000960"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 2784 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000961"/><function v="div"/><type v="256"/><GUILayout><gpos v="1464 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000960"/></connection><connection><identifier v="b"/><connRef v="1000000959"/></connection></connections></paramNode><paramNode><uid v="1000000962"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1744 544 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000000960"/></connection><connection><identifier v="componentslast"/><connRef v="1000000961"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="non_square_output_size_v2"/><uid v="1000001066"/><attributes><category v="Functions/Various"/><description v="Evaluates the non_square_output_size_v2 function graph. Result type: Integer2. Inputs: scale, output_size, non_square, tile_offset."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="scale"/><uid v="1000001067"/><attributes><label v="scale"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="output_size"/><uid v="1000001068"/><attributes><label v="output_size"/></attributes><type v="32"/><defaultValue><constantValueInt2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="non_square"/><uid v="1000001069"/><attributes><label v="non_square"/></attributes><type v="4"/><defaultValue><constantValueBool v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="tile_offset"/><uid v="1000001070"/><attributes><label v="tile_offset"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="32"/><paramValue><dynamicValue><rootnode v="1000000967"/><paramNodes><paramNode><uid v="1000000967"/><function v="sequence"/><type v="32"/><GUILayout><gpos v="9304 64 0"/></GUILayout><connections><connection><identifier v="seqin"/><connRef v="1000001001"/></connection><connection><identifier v="seqlast"/><connRef v="1000000975"/></connection></connections></paramNode><paramNode><uid v="1000000968"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000000969"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000969"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="$sizelog2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000970"/><function v="set"/><type v="16"/><GUILayout><gpos v="3704 64 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000001008"/></connection></connections><funcDatas><funcData><name v="set"/><constantValue><constantValueString v="real_scale"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000971"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000000969"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000972"/><function v="sequence"/><type v="256"/><GUILayout><gpos v="8744 64 0"/></GUILayout><connections><connection><identifier v="seqin"/><connRef v="1000001017"/></connection><connection><identifier v="seqlast"/><connRef v="1000000973"/></connection></connections></paramNode><paramNode><uid v="1000000973"/><function v="set"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000000999"/></connection></connections><funcDatas><funcData><name v="set"/><constantValue><constantValueString v="xy_difference"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000974"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000971"/></connection><connection><identifier v="b"/><connRef v="1000000968"/></connection></connections></paramNode><paramNode><uid v="1000000975"/><function v="get_integer2"/><type v="32"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer2"/><constantValue><constantValueString v="output_size"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000976"/><function v="sequence"/><type v="16"/><GUILayout><gpos v="5944 64 0"/></GUILayout><connections><connection><identifier v="seqin"/><connRef v="1000000991"/></connection><connection><identifier v="seqlast"/><connRef v="1000000970"/></connection></connections></paramNode><paramNode><uid v="1000000977"/><function v="set"/><type v="2048"/><GUILayout><gpos v="5384 64 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000001022"/></connection></connections><funcDatas><funcData><name v="set"/><constantValue><constantValueString v="tiling_region"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000978"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000979"/><function v="swizzle4"/><type v="2048"/><GUILayout><gpos v="4264 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001040"/></connection></connections><funcDatas><funcData><name v="swizzle4"/><constantValue><constantValueInt4 v="2 3 0 1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000980"/><function v="mulscalar"/><type v="512"/><GUILayout><gpos v="2584 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000987"/></connection><connection><identifier v="scalar"/><connRef v="1000000989"/></connection></connections></paramNode><paramNode><uid v="1000000981"/><function v="gt"/><type v="4"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000999"/></connection><connection><identifier v="b"/><connRef v="1000000978"/></connection></connections></paramNode><paramNode><uid v="1000000982"/><function v="ifelse"/><type v="2048"/><GUILayout><gpos v="4544 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000981"/></connection><connection><identifier v="ifpath"/><connRef v="1000001040"/></connection><connection><identifier v="elsepath"/><connRef v="1000000979"/></connection></connections></paramNode><paramNode><uid v="1000000983"/><function v="neg"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000985"/></connection></connections></paramNode><paramNode><uid v="1000000984"/><function v="pow2"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000983"/></connection></connections></paramNode><paramNode><uid v="1000000985"/><function v="abs"/><type v="256"/><GUILayout><gpos v="1184 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000999"/></connection></connections></paramNode><paramNode><uid v="1000000986"/><function v="const_float2"/><type v="512"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float2"/><constantValue><constantValueFloat2 v="1 1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000987"/><function v="sub"/><type v="512"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000986"/></connection><connection><identifier v="b"/><connRef v="1000000988"/></connection></connections></paramNode><paramNode><uid v="1000000988"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000000984"/></connection><connection><identifier v="componentslast"/><connRef v="1000000984"/></connection></connections></paramNode><paramNode><uid v="1000000989"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000990"/><function v="set"/><type v="2048"/><GUILayout><gpos v="5384 224 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000001022"/></connection></connections><funcDatas><funcData><name v="set"/><constantValue><constantValueString v="render_region"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000991"/><function v="sequence"/><type v="2048"/><GUILayout><gpos v="5664 64 0"/></GUILayout><connections><connection><identifier v="seqin"/><connRef v="1000000990"/></connection><connection><identifier v="seqlast"/><connRef v="1000000977"/></connection></connections></paramNode><paramNode><uid v="1000000992"/><function v="get_bool"/><type v="4"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_bool"/><constantValue><constantValueString v="non_square"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000993"/><function v="neg"/><type v="256"/><GUILayout><gpos v="2584 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000994"/></connection></connections></paramNode><paramNode><uid v="1000000994"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2304 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000995"/></connection><connection><identifier v="b"/><connRef v="1000000997"/></connection></connections></paramNode><paramNode><uid v="1000000995"/><function v="sub"/><type v="256"/><GUILayout><gpos v="2024 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001028"/></connection><connection><identifier v="b"/><connRef v="1000000998"/></connection></connections></paramNode><paramNode><uid v="1000000996"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2864 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000000993"/></connection><connection><identifier v="componentslast"/><connRef v="1000000994"/></connection></connections></paramNode><paramNode><uid v="1000000997"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000998"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000999"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000992"/></connection><connection><identifier v="ifpath"/><connRef v="1000000974"/></connection><connection><identifier v="elsepath"/><connRef v="1000001000"/></connection></connections></paramNode><paramNode><uid v="1000001000"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001001"/><function v="sequence"/><type v="512"/><GUILayout><gpos v="9024 64 0"/></GUILayout><connections><connection><identifier v="seqin"/><connRef v="1000000972"/></connection><connection><identifier v="seqlast"/><connRef v="1000001002"/></connection></connections></paramNode><paramNode><uid v="1000001002"/><function v="set"/><type v="512"/><GUILayout><gpos v="2024 384 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000001006"/></connection></connections><funcDatas><funcData><name v="set"/><constantValue><constantValueString v="xy_ratio"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001003"/><function v="pow2"/><type v="256"/><GUILayout><gpos v="1184 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000999"/></connection></connections></paramNode><paramNode><uid v="1000001004"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001005"/><function v="div"/><type v="256"/><GUILayout><gpos v="1464 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001004"/></connection><connection><identifier v="b"/><connRef v="1000001003"/></connection></connections></paramNode><paramNode><uid v="1000001006"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1744 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001004"/></connection><connection><identifier v="componentslast"/><connRef v="1000001005"/></connection></connections></paramNode><paramNode><uid v="1000001007"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 1664 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="scale"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001008"/><function v="toint1"/><type v="16"/><GUILayout><gpos v="3424 64 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000001034"/></connection></connections></paramNode><paramNode><uid v="1000001009"/><function v="ceil"/><type v="256"/><GUILayout><gpos v="1744 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001029"/></connection></connections></paramNode><paramNode><uid v="1000001010"/><function v="gt"/><type v="4"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000971"/></connection><connection><identifier v="b"/><connRef v="1000000968"/></connection></connections></paramNode><paramNode><uid v="1000001011"/><function v="ifelse"/><type v="512"/><GUILayout><gpos v="1464 384 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001010"/></connection><connection><identifier v="ifpath"/><connRef v="1000001012"/></connection><connection><identifier v="elsepath"/><connRef v="1000001015"/></connection></connections></paramNode><paramNode><uid v="1000001012"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="904 228 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000000974"/></connection><connection><identifier v="componentslast"/><connRef v="1000001013"/></connection></connections></paramNode><paramNode><uid v="1000001013"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1824 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001014"/><function v="pow2"/><type v="512"/><GUILayout><gpos v="2024 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001033"/></connection></connections></paramNode><paramNode><uid v="1000001015"/><function v="swizzle2"/><type v="512"/><GUILayout><gpos v="1184 704 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001012"/></connection></connections><funcDatas><funcData><name v="swizzle2"/><constantValue><constantValueInt2 v="1 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001016"/><function v="set"/><type v="16"/><GUILayout><gpos v="8184 64 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000001052"/></connection></connections><funcDatas><funcData><name v="set"/><constantValue><constantValueString v="total_number"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001017"/><function v="sequence"/><type v="16"/><GUILayout><gpos v="8464 64 0"/></GUILayout><connections><connection><identifier v="seqin"/><connRef v="1000000976"/></connection><connection><identifier v="seqlast"/><connRef v="1000001016"/></connection></connections></paramNode><paramNode><uid v="1000001018"/><function v="mul"/><type v="512"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001019"/></connection><connection><identifier v="b"/><connRef v="1000001030"/></connection></connections></paramNode><paramNode><uid v="1000001019"/><function v="const_float2"/><type v="512"/><GUILayout><gpos v="64 1984 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float2"/><constantValue><constantValueFloat2 v="1 -1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001020"/><function v="swizzle4"/><type v="2048"/><GUILayout><gpos v="904 388 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001021"/></connection></connections><funcDatas><funcData><name v="swizzle4"/><constantValue><constantValueInt4 v="0 0 1 1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001021"/><function v="mulscalar"/><type v="512"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001018"/></connection><connection><identifier v="scalar"/><connRef v="1000001064"/></connection></connections></paramNode><paramNode><uid v="1000001022"/><function v="add"/><type v="2048"/><GUILayout><gpos v="5104 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001041"/></connection><connection><identifier v="b"/><connRef v="1000001032"/></connection></connections></paramNode><paramNode><uid v="1000001023"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 2144 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001024"/><function v="add"/><type v="256"/><GUILayout><gpos v="2584 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001026"/></connection><connection><identifier v="b"/><connRef v="1000001027"/></connection></connections></paramNode><paramNode><uid v="1000001025"/><function v="add"/><type v="256"/><GUILayout><gpos v="2864 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001035"/></connection><connection><identifier v="b"/><connRef v="1000001024"/></connection></connections></paramNode><paramNode><uid v="1000001026"/><function v="mod"/><type v="256"/><GUILayout><gpos v="2304 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001035"/></connection><connection><identifier v="b"/><connRef v="1000001023"/></connection></connections></paramNode><paramNode><uid v="1000001027"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 2304 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001028"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1744 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001029"/></connection><connection><identifier v="b"/><connRef v="1000001064"/></connection></connections></paramNode><paramNode><uid v="1000001029"/><function v="pow2"/><type v="256"/><GUILayout><gpos v="1464 548 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000985"/></connection></connections></paramNode><paramNode><uid v="1000001030"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 2464 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="tile_offset"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001031"/><function v="swizzle4"/><type v="2048"/><GUILayout><gpos v="2584 544 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001062"/></connection></connections><funcDatas><funcData><name v="swizzle4"/><constantValue><constantValueInt4 v="0 0 1 1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001032"/><function v="mul"/><type v="2048"/><GUILayout><gpos v="2864 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001020"/></connection><connection><identifier v="b"/><connRef v="1000001031"/></connection></connections></paramNode><paramNode><uid v="1000001033"/><function v="abs"/><type v="512"/><GUILayout><gpos v="1744 704 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001011"/></connection></connections></paramNode><paramNode><uid v="1000001034"/><function v="mul"/><type v="256"/><GUILayout><gpos v="3144 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001025"/></connection><connection><identifier v="b"/><connRef v="1000001025"/></connection></connections></paramNode><paramNode><uid v="1000001035"/><function v="passthrough"/><type v="256"/><GUILayout><gpos v="2024 704 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000001009"/></connection></connections></paramNode><paramNode><uid v="1000001036"/><function v="add"/><type v="512"/><GUILayout><gpos v="3144 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000996"/></connection><connection><identifier v="b"/><connRef v="1000001037"/></connection></connections></paramNode><paramNode><uid v="1000001037"/><function v="const_float2"/><type v="512"/><GUILayout><gpos v="64 2624 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float2"/><constantValue><constantValueFloat2 v="0 1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001038"/><function v="mul"/><type v="512"/><GUILayout><gpos v="3424 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001036"/></connection><connection><identifier v="b"/><connRef v="1000000988"/></connection></connections></paramNode><paramNode><uid v="1000001039"/><function v="add"/><type v="512"/><GUILayout><gpos v="3704 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001038"/></connection><connection><identifier v="b"/><connRef v="1000000980"/></connection></connections></paramNode><paramNode><uid v="1000001040"/><function v="vector4"/><type v="2048"/><GUILayout><gpos v="3984 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001036"/></connection><connection><identifier v="componentslast"/><connRef v="1000001039"/></connection></connections></paramNode><paramNode><uid v="1000001041"/><function v="mulscalar"/><type v="2048"/><GUILayout><gpos v="4824 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000982"/></connection><connection><identifier v="scalar"/><connRef v="1000001042"/></connection></connections></paramNode><paramNode><uid v="1000001042"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 2784 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001043"/><function v="abs"/><type v="2048"/><GUILayout><gpos v="5384 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001022"/></connection></connections></paramNode><paramNode><uid v="1000001044"/><function v="ceil"/><type v="2048"/><GUILayout><gpos v="5944 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001060"/></connection></connections></paramNode><paramNode><uid v="1000001045"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="6224 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001044"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001046"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="6224 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001044"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001047"/><function v="max"/><type v="256"/><GUILayout><gpos v="6504 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001045"/></connection><connection><identifier v="b"/><connRef v="1000001046"/></connection></connections></paramNode><paramNode><uid v="1000001048"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="6224 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001044"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001049"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="6224 544 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001044"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001050"/><function v="max"/><type v="256"/><GUILayout><gpos v="6504 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001049"/></connection><connection><identifier v="b"/><connRef v="1000001048"/></connection></connections></paramNode><paramNode><uid v="1000001051"/><function v="mul"/><type v="256"/><GUILayout><gpos v="7624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001059"/></connection><connection><identifier v="b"/><connRef v="1000001059"/></connection></connections></paramNode><paramNode><uid v="1000001052"/><function v="toint1"/><type v="16"/><GUILayout><gpos v="7904 64 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000001051"/></connection></connections></paramNode><paramNode><uid v="1000001053"/><function v="mul"/><type v="256"/><GUILayout><gpos v="6784 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001047"/></connection><connection><identifier v="b"/><connRef v="1000001054"/></connection></connections></paramNode><paramNode><uid v="1000001054"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 2944 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001055"/><function v="add"/><type v="256"/><GUILayout><gpos v="7064 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001053"/></connection><connection><identifier v="b"/><connRef v="1000001056"/></connection></connections></paramNode><paramNode><uid v="1000001056"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 3104 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001057"/><function v="add"/><type v="256"/><GUILayout><gpos v="7064 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001058"/></connection><connection><identifier v="b"/><connRef v="1000001056"/></connection></connections></paramNode><paramNode><uid v="1000001058"/><function v="mul"/><type v="256"/><GUILayout><gpos v="6784 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001050"/></connection><connection><identifier v="b"/><connRef v="1000001054"/></connection></connections></paramNode><paramNode><uid v="1000001059"/><function v="max"/><type v="256"/><GUILayout><gpos v="7344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001055"/></connection><connection><identifier v="b"/><connRef v="1000001057"/></connection></connections></paramNode><paramNode><uid v="1000001060"/><function v="sub"/><type v="2048"/><GUILayout><gpos v="5664 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001043"/></connection><connection><identifier v="b"/><connRef v="1000001061"/></connection></connections></paramNode><paramNode><uid v="1000001061"/><function v="const_float4"/><type v="2048"/><GUILayout><gpos v="64 3264 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float4"/><constantValue><constantValueFloat4 v="-0.5 0.5 -0.5 0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001062"/><function v="ifelse"/><type v="512"/><GUILayout><gpos v="2304 544 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000992"/></connection><connection><identifier v="ifpath"/><connRef v="1000001014"/></connection><connection><identifier v="elsepath"/><connRef v="1000001063"/></connection></connections></paramNode><paramNode><uid v="1000001063"/><function v="const_float2"/><type v="512"/><GUILayout><gpos v="64 3424 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float2"/><constantValue><constantValueFloat2 v="1 1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001064"/><function v="max"/><type v="256"/><GUILayout><gpos v="344 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001007"/></connection><connection><identifier v="b"/><connRef v="1000001065"/></connection></connections></paramNode><paramNode><uid v="1000001065"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 3584 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="non_square_expansion_uv_scale"/><uid v="1000001092"/><attributes><category v="Functions/Various"/><description v="Evaluates the non_square_expansion_uv_scale function graph. Result type: Float2. Inputs: position, non_square_expansion."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="position"/><uid v="1000001093"/><attributes><label v="Position"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="non_square_expansion"/><uid v="1000001094"/><attributes><label v="Non-square expansion"/></attributes><type v="4"/><defaultValue><constantValueBool v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="512"/><paramValue><dynamicValue><rootnode v="1000001077"/><paramNodes><paramNode><uid v="1000001071"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="position"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001072"/><function v="get_bool"/><type v="4"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_bool"/><constantValue><constantValueString v="non_square_expansion"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001073"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="$sizelog2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001074"/><function v="max"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001076"/></connection><connection><identifier v="b"/><connRef v="1000001083"/></connection></connections></paramNode><paramNode><uid v="1000001075"/><function v="const_float2"/><type v="512"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float2"/><constantValue><constantValueFloat2 v="0.5 0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001076"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001073"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001077"/><function v="ifelse"/><type v="512"/><GUILayout><gpos v="3144 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001072"/></connection><connection><identifier v="ifpath"/><connRef v="1000001081"/></connection><connection><identifier v="elsepath"/><connRef v="1000001071"/></connection></connections></paramNode><paramNode><uid v="1000001078"/><function v="ifelse"/><type v="512"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001086"/></connection><connection><identifier v="ifpath"/><connRef v="1000001085"/></connection><connection><identifier v="elsepath"/><connRef v="1000001089"/></connection></connections></paramNode><paramNode><uid v="1000001079"/><function v="mul"/><type v="512"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001080"/></connection><connection><identifier v="b"/><connRef v="1000001071"/></connection></connections></paramNode><paramNode><uid v="1000001080"/><function v="pow2"/><type v="512"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001078"/></connection></connections></paramNode><paramNode><uid v="1000001081"/><function v="sub"/><type v="512"/><GUILayout><gpos v="2864 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001079"/></connection><connection><identifier v="b"/><connRef v="1000001082"/></connection></connections></paramNode><paramNode><uid v="1000001082"/><function v="mul"/><type v="512"/><GUILayout><gpos v="2584 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001087"/></connection><connection><identifier v="b"/><connRef v="1000001075"/></connection></connections></paramNode><paramNode><uid v="1000001083"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001073"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001084"/><function v="const_float2"/><type v="512"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float2"/><constantValue><constantValueFloat2 v="1 1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001085"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001091"/></connection><connection><identifier v="componentslast"/><connRef v="1000001088"/></connection></connections></paramNode><paramNode><uid v="1000001086"/><function v="gt"/><type v="4"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001076"/></connection><connection><identifier v="b"/><connRef v="1000001083"/></connection></connections></paramNode><paramNode><uid v="1000001087"/><function v="sub"/><type v="512"/><GUILayout><gpos v="2304 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001080"/></connection><connection><identifier v="b"/><connRef v="1000001084"/></connection></connections></paramNode><paramNode><uid v="1000001088"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001089"/><function v="swizzle2"/><type v="512"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001085"/></connection></connections><funcDatas><funcData><name v="swizzle2"/><constantValue><constantValueInt2 v="1 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001090"/><function v="min"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001076"/></connection><connection><identifier v="b"/><connRef v="1000001083"/></connection></connections></paramNode><paramNode><uid v="1000001091"/><function v="sub"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001074"/></connection><connection><identifier v="b"/><connRef v="1000001090"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="compute_total_number"/><uid v="1000001128"/><attributes><category v="Functions/Various"/><description v="Evaluates the compute_total_number function graph. Result type: Integer. Inputs: tile_multiplier."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="tile_multiplier"/><uid v="1000001129"/><attributes><label v="tile_multiplier"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput></paraminputs><type v="16"/><paramValue><dynamicValue><rootnode v="1000001127"/><paramNodes><paramNode><uid v="1000001095"/><function v="mul"/><type v="256"/><GUILayout><gpos v="3984 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001108"/></connection><connection><identifier v="b"/><connRef v="1000001108"/></connection></connections></paramNode><paramNode><uid v="1000001096"/><function v="toint1"/><type v="16"/><GUILayout><gpos v="4264 64 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000001095"/></connection></connections></paramNode><paramNode><uid v="1000001097"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001098"/><function v="mul"/><type v="256"/><GUILayout><gpos v="3144 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001107"/></connection><connection><identifier v="b"/><connRef v="1000001097"/></connection></connections></paramNode><paramNode><uid v="1000001099"/><function v="const_float4"/><type v="2048"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float4"/><constantValue><constantValueFloat4 v="-0.5 0.5 -0.5 0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001100"/><function v="sub"/><type v="2048"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001106"/></connection><connection><identifier v="b"/><connRef v="1000001099"/></connection></connections></paramNode><paramNode><uid v="1000001101"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="2584 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001102"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001102"/><function v="ceil"/><type v="2048"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001100"/></connection></connections></paramNode><paramNode><uid v="1000001103"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001104"/><function v="mul"/><type v="256"/><GUILayout><gpos v="3144 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001114"/></connection><connection><identifier v="b"/><connRef v="1000001097"/></connection></connections></paramNode><paramNode><uid v="1000001105"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="2584 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001102"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001106"/><function v="abs"/><type v="2048"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001113"/></connection></connections></paramNode><paramNode><uid v="1000001107"/><function v="max"/><type v="256"/><GUILayout><gpos v="2864 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001109"/></connection><connection><identifier v="b"/><connRef v="1000001105"/></connection></connections></paramNode><paramNode><uid v="1000001108"/><function v="max"/><type v="256"/><GUILayout><gpos v="3704 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001110"/></connection><connection><identifier v="b"/><connRef v="1000001111"/></connection></connections></paramNode><paramNode><uid v="1000001109"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="2584 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001102"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001110"/><function v="add"/><type v="256"/><GUILayout><gpos v="3424 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001098"/></connection><connection><identifier v="b"/><connRef v="1000001103"/></connection></connections></paramNode><paramNode><uid v="1000001111"/><function v="add"/><type v="256"/><GUILayout><gpos v="3424 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001104"/></connection><connection><identifier v="b"/><connRef v="1000001103"/></connection></connections></paramNode><paramNode><uid v="1000001112"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="2584 544 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001102"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001113"/><function v="mulscalar"/><type v="2048"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001117"/></connection><connection><identifier v="scalar"/><connRef v="1000001116"/></connection></connections></paramNode><paramNode><uid v="1000001114"/><function v="max"/><type v="256"/><GUILayout><gpos v="2864 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001101"/></connection><connection><identifier v="b"/><connRef v="1000001112"/></connection></connections></paramNode><paramNode><uid v="1000001115"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="tile_multiplier"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001116"/><function v="tofloat"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000001121"/></connection></connections></paramNode><paramNode><uid v="1000001117"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="render_region"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001118"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="$tiling"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001119"/><function v="eq"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001118"/></connection><connection><identifier v="b"/><connRef v="1000001120"/></connection></connections></paramNode><paramNode><uid v="1000001120"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001121"/><function v="ifelse"/><type v="16"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001124"/></connection><connection><identifier v="ifpath"/><connRef v="1000001115"/></connection><connection><identifier v="elsepath"/><connRef v="1000001122"/></connection></connections></paramNode><paramNode><uid v="1000001122"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001123"/><function v="isdefined"/><type v="4"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="isdefined"/><constantValue><constantValueString v="tile_multiplier"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001124"/><function v="and"/><type v="4"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001119"/></connection><connection><identifier v="b"/><connRef v="1000001123"/></connection></connections></paramNode><paramNode><uid v="1000001125"/><function v="tofloat"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000001115"/></connection></connections></paramNode><paramNode><uid v="1000001126"/><function v="set"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000001125"/></connection></connections><funcDatas><funcData><name v="set"/><constantValue><constantValueString v="c_tile_multiplier"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001127"/><function v="sequence"/><type v="16"/><GUILayout><gpos v="4544 64 0"/></GUILayout><connections><connection><identifier v="seqin"/><connRef v="1000001126"/></connection><connection><identifier v="seqlast"/><connRef v="1000001096"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="colorValues"/><uid v="1000001130"/><content><function><identifier v="directionToNormal"/><uid v="1000001156"/><attributes><category v="Functions/colorValues"/><description v="Evaluates the directionToNormal function graph. Result type: Float4. Inputs: Direction, slopeAngle, yUp."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="Direction"/><uid v="1000001157"/><attributes><label v="Direction"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="360"/></option></options></defaultWidget></paraminput><paraminput><identifier v="slopeAngle"/><uid v="1000001158"/><attributes><label v="slopeAngle"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="90"/></option></options></defaultWidget></paraminput><paraminput><identifier v="yUp"/><uid v="1000001159"/><attributes><label v="yUp"/></attributes><type v="4"/><defaultValue><constantValueBool v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="2048"/><paramValue><dynamicValue><rootnode v="1000001153"/><paramNodes><paramNode><uid v="1000001131"/><function v="sin"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001150"/></connection></connections></paramNode><paramNode><uid v="1000001132"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001133"/></connection><connection><identifier v="componentslast"/><connRef v="1000001133"/></connection></connections></paramNode><paramNode><uid v="1000001133"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001134"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001146"/></connection><connection><identifier v="b"/><connRef v="1000001142"/></connection></connections></paramNode><paramNode><uid v="1000001135"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="180"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001136"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001137"/><function v="instance"/><type v="118772"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="Input"/><connRef v="1000001141"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Ranges/[-1_1]_to_[0_1]"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="Input"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001138"/><function v="add"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001154"/></connection><connection><identifier v="b"/><connRef v="1000001145"/></connection></connections></paramNode><paramNode><uid v="1000001139"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="slopeAngle"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001140"/><function v="instance"/><type v="118772"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="deg"/><connRef v="1000001155"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Trigo/deg_to_rad"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="deg"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001141"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1464 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001131"/></connection><connection><identifier v="b"/><connRef v="1000001142"/></connection></connections></paramNode><paramNode><uid v="1000001142"/><function v="sin"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001140"/></connection></connections></paramNode><paramNode><uid v="1000001143"/><function v="instance"/><type v="118772"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="deg"/><connRef v="1000001149"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Trigo/deg_to_rad"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="deg"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001144"/><function v="instance"/><type v="118772"/><GUILayout><gpos v="1744 224 0"/></GUILayout><connections><connection><identifier v="Input"/><connRef v="1000001134"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Ranges/[-1_1]_to_[0_1]"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="Input"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001145"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001148"/></connection><connection><identifier v="ifpath"/><connRef v="1000001136"/></connection><connection><identifier v="elsepath"/><connRef v="1000001151"/></connection></connections></paramNode><paramNode><uid v="1000001146"/><function v="cos"/><type v="256"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001143"/></connection></connections></paramNode><paramNode><uid v="1000001147"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001144"/></connection><connection><identifier v="componentslast"/><connRef v="1000001137"/></connection></connections></paramNode><paramNode><uid v="1000001148"/><function v="get_bool"/><type v="4"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_bool"/><constantValue><constantValueString v="yUp"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001149"/><function v="add"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001154"/></connection><connection><identifier v="b"/><connRef v="1000001135"/></connection></connections></paramNode><paramNode><uid v="1000001150"/><function v="instance"/><type v="118772"/><GUILayout><gpos v="904 384 0"/></GUILayout><connections><connection><identifier v="deg"/><connRef v="1000001138"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Trigo/deg_to_rad"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="deg"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001151"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="180"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001152"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="Direction"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001153"/><function v="vector4"/><type v="2048"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001147"/></connection><connection><identifier v="componentslast"/><connRef v="1000001132"/></connection></connections></paramNode><paramNode><uid v="1000001154"/><function v="instance"/><type v="118772"/><GUILayout><gpos v="344 388 0"/></GUILayout><connections><connection><identifier v="turns"/><connRef v="1000001152"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/typeConverters/turnsToDegrees"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="turns"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001155"/><function v="instance"/><type v="118772"/><GUILayout><gpos v="344 548 0"/></GUILayout><connections><connection><identifier v="turns"/><connRef v="1000001139"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/typeConverters/turnsToDegrees"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="turns"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="RGBtoHSL"/><uid v="1000001207"/><attributes><category v="Functions/colorValues"/><description v="Evaluates the RGBtoHSL function graph. Result type: Float3. Inputs: RGB."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="RGB"/><uid v="1000001208"/><attributes><label v="RGB"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="0 0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000001175"/><paramNodes><paramNode><uid v="1000001160"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001195"/></connection><connection><identifier v="ifpath"/><connRef v="1000001196"/></connection><connection><identifier v="elsepath"/><connRef v="1000001178"/></connection></connections></paramNode><paramNode><uid v="1000001161"/><function v="noteq"/><type v="4"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001174"/></connection><connection><identifier v="b"/><connRef v="1000001164"/></connection></connections></paramNode><paramNode><uid v="1000001162"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001163"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001193"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001164"/><function v="min"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001183"/></connection><connection><identifier v="b"/><connRef v="1000001191"/></connection></connections></paramNode><paramNode><uid v="1000001165"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001166"/><function v="div"/><type v="256"/><GUILayout><gpos v="1744 228 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001169"/></connection><connection><identifier v="b"/><connRef v="1000001190"/></connection></connections></paramNode><paramNode><uid v="1000001167"/><function v="div"/><type v="256"/><GUILayout><gpos v="1744 388 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001187"/></connection><connection><identifier v="b"/><connRef v="1000001190"/></connection></connections></paramNode><paramNode><uid v="1000001168"/><function v="passthrough"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000001206"/></connection></connections></paramNode><paramNode><uid v="1000001169"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001200"/></connection><connection><identifier v="b"/><connRef v="1000001163"/></connection></connections></paramNode><paramNode><uid v="1000001170"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001203"/></connection><connection><identifier v="b"/><connRef v="1000001174"/></connection></connections></paramNode><paramNode><uid v="1000001171"/><function v="div"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001190"/></connection><connection><identifier v="b"/><connRef v="1000001160"/></connection></connections></paramNode><paramNode><uid v="1000001172"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001173"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="2584 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001202"/></connection><connection><identifier v="ifpath"/><connRef v="1000001204"/></connection><connection><identifier v="elsepath"/><connRef v="1000001176"/></connection></connections></paramNode><paramNode><uid v="1000001174"/><function v="max"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001201"/></connection><connection><identifier v="b"/><connRef v="1000001191"/></connection></connections></paramNode><paramNode><uid v="1000001175"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="3704 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001161"/></connection><connection><identifier v="ifpath"/><connRef v="1000001194"/></connection><connection><identifier v="elsepath"/><connRef v="1000001198"/></connection></connections></paramNode><paramNode><uid v="1000001176"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001199"/></connection><connection><identifier v="ifpath"/><connRef v="1000001182"/></connection><connection><identifier v="elsepath"/><connRef v="1000001189"/></connection></connections></paramNode><paramNode><uid v="1000001177"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001191"/></connection><connection><identifier v="b"/><connRef v="1000001200"/></connection></connections></paramNode><paramNode><uid v="1000001178"/><function v="add"/><type v="256"/><GUILayout><gpos v="1184 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001174"/></connection><connection><identifier v="b"/><connRef v="1000001164"/></connection></connections></paramNode><paramNode><uid v="1000001179"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="3144 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001181"/></connection><connection><identifier v="componentslast"/><connRef v="1000001171"/></connection></connections></paramNode><paramNode><uid v="1000001180"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001181"/><function v="div"/><type v="256"/><GUILayout><gpos v="2864 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001173"/></connection><connection><identifier v="b"/><connRef v="1000001197"/></connection></connections></paramNode><paramNode><uid v="1000001182"/><function v="add"/><type v="256"/><GUILayout><gpos v="2024 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001205"/></connection><connection><identifier v="b"/><connRef v="1000001165"/></connection></connections></paramNode><paramNode><uid v="1000001183"/><function v="min"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001200"/></connection><connection><identifier v="b"/><connRef v="1000001163"/></connection></connections></paramNode><paramNode><uid v="1000001184"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1184 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001174"/></connection><connection><identifier v="b"/><connRef v="1000001164"/></connection></connections></paramNode><paramNode><uid v="1000001185"/><function v="const_float2"/><type v="512"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float2"/><constantValue><constantValueFloat2 v="0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001186"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="6"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001187"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001163"/></connection><connection><identifier v="b"/><connRef v="1000001191"/></connection></connections></paramNode><paramNode><uid v="1000001188"/><function v="lr"/><type v="4"/><GUILayout><gpos v="624 704 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001163"/></connection><connection><identifier v="b"/><connRef v="1000001191"/></connection></connections></paramNode><paramNode><uid v="1000001189"/><function v="add"/><type v="256"/><GUILayout><gpos v="2024 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001166"/></connection><connection><identifier v="b"/><connRef v="1000001180"/></connection></connections></paramNode><paramNode><uid v="1000001190"/><function v="passthrough"/><type v="256"/><GUILayout><gpos v="1464 224 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000001184"/></connection></connections></paramNode><paramNode><uid v="1000001191"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001193"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001192"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="904 384 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001188"/></connection><connection><identifier v="ifpath"/><connRef v="1000001186"/></connection><connection><identifier v="elsepath"/><connRef v="1000001172"/></connection></connections></paramNode><paramNode><uid v="1000001193"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="RGB"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001194"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="3424 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001179"/></connection><connection><identifier v="componentslast"/><connRef v="1000001168"/></connection></connections></paramNode><paramNode><uid v="1000001195"/><function v="gt"/><type v="4"/><GUILayout><gpos v="1464 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001206"/></connection><connection><identifier v="b"/><connRef v="1000001162"/></connection></connections></paramNode><paramNode><uid v="1000001196"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1464 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001170"/></connection><connection><identifier v="b"/><connRef v="1000001164"/></connection></connections></paramNode><paramNode><uid v="1000001197"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="6"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001198"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="1744 548 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001185"/></connection><connection><identifier v="componentslast"/><connRef v="1000001168"/></connection></connections></paramNode><paramNode><uid v="1000001199"/><function v="eq"/><type v="4"/><GUILayout><gpos v="1184 704 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001174"/></connection><connection><identifier v="b"/><connRef v="1000001163"/></connection></connections></paramNode><paramNode><uid v="1000001200"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001193"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001201"/><function v="max"/><type v="256"/><GUILayout><gpos v="624 864 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001200"/></connection><connection><identifier v="b"/><connRef v="1000001163"/></connection></connections></paramNode><paramNode><uid v="1000001202"/><function v="eq"/><type v="4"/><GUILayout><gpos v="1184 864 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001174"/></connection><connection><identifier v="b"/><connRef v="1000001200"/></connection></connections></paramNode><paramNode><uid v="1000001203"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001204"/><function v="add"/><type v="256"/><GUILayout><gpos v="2024 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001167"/></connection><connection><identifier v="b"/><connRef v="1000001192"/></connection></connections></paramNode><paramNode><uid v="1000001205"/><function v="div"/><type v="256"/><GUILayout><gpos v="1744 708 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001177"/></connection><connection><identifier v="b"/><connRef v="1000001190"/></connection></connections></paramNode><paramNode><uid v="1000001206"/><function v="instance"/><type v="118772"/><GUILayout><gpos v="1184 1024 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001174"/></connection><connection><identifier v="b"/><connRef v="1000001164"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/average_float1"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="a"/><type v="0"/></input><input><identifier v="b"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="HSLtoRGB"/><uid v="1000001252"/><attributes><category v="Functions/colorValues"/><description v="Evaluates the HSLtoRGB function graph. Result type: Float3. Inputs: HSL."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="HSL"/><uid v="1000001253"/><attributes><label v="HSL"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="0 0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000001249"/><paramNodes><paramNode><uid v="1000001209"/><function v="swizzle3"/><type v="1024"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001251"/></connection></connections><funcDatas><funcData><name v="swizzle3"/><constantValue><constantValueInt3 v="0 0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001210"/><function v="sub"/><type v="1024"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001209"/></connection><connection><identifier v="b"/><connRef v="1000001216"/></connection></connections></paramNode><paramNode><uid v="1000001211"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001212"/></connection><connection><identifier v="componentslast"/><connRef v="1000001215"/></connection></connections></paramNode><paramNode><uid v="1000001212"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001213"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001214"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001215"/><function v="div"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001213"/></connection><connection><identifier v="b"/><connRef v="1000001214"/></connection></connections></paramNode><paramNode><uid v="1000001216"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001211"/></connection><connection><identifier v="componentslast"/><connRef v="1000001217"/></connection></connections></paramNode><paramNode><uid v="1000001217"/><function v="div"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001218"/></connection><connection><identifier v="b"/><connRef v="1000001214"/></connection></connections></paramNode><paramNode><uid v="1000001218"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001219"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001210"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001220"/><function v="abs"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001219"/></connection></connections></paramNode><paramNode><uid v="1000001221"/><function v="abs"/><type v="256"/><GUILayout><gpos v="1744 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001222"/></connection></connections></paramNode><paramNode><uid v="1000001222"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="1464 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001210"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001223"/><function v="abs"/><type v="256"/><GUILayout><gpos v="1744 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001224"/></connection></connections></paramNode><paramNode><uid v="1000001224"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="1464 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001210"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001225"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001220"/></connection><connection><identifier v="componentslast"/><connRef v="1000001221"/></connection></connections></paramNode><paramNode><uid v="1000001226"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001225"/></connection><connection><identifier v="componentslast"/><connRef v="1000001223"/></connection></connections></paramNode><paramNode><uid v="1000001227"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="6 -6 -6"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001228"/><function v="mul"/><type v="1024"/><GUILayout><gpos v="2584 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001226"/></connection><connection><identifier v="b"/><connRef v="1000001227"/></connection></connections></paramNode><paramNode><uid v="1000001229"/><function v="add"/><type v="1024"/><GUILayout><gpos v="2864 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001228"/></connection><connection><identifier v="b"/><connRef v="1000001230"/></connection></connections></paramNode><paramNode><uid v="1000001230"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="-1 2 2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001231"/><function v="min"/><type v="1024"/><GUILayout><gpos v="3144 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001229"/></connection><connection><identifier v="b"/><connRef v="1000001233"/></connection></connections></paramNode><paramNode><uid v="1000001232"/><function v="max"/><type v="1024"/><GUILayout><gpos v="3424 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001231"/></connection><connection><identifier v="b"/><connRef v="1000001234"/></connection></connections></paramNode><paramNode><uid v="1000001233"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="1 1 1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001234"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0 0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001235"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 544 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001251"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001236"/><function v="add"/><type v="256"/><GUILayout><gpos v="1744 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001235"/></connection><connection><identifier v="b"/><connRef v="1000001237"/></connection></connections></paramNode><paramNode><uid v="1000001237"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1464 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001242"/></connection><connection><identifier v="b"/><connRef v="1000001238"/></connection></connections></paramNode><paramNode><uid v="1000001238"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 704 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001251"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001239"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001240"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001239"/></connection><connection><identifier v="b"/><connRef v="1000001235"/></connection></connections></paramNode><paramNode><uid v="1000001241"/><function v="abs"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001240"/></connection></connections></paramNode><paramNode><uid v="1000001242"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001239"/></connection><connection><identifier v="b"/><connRef v="1000001241"/></connection></connections></paramNode><paramNode><uid v="1000001243"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001235"/></connection><connection><identifier v="b"/><connRef v="1000001244"/></connection></connections></paramNode><paramNode><uid v="1000001244"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001245"/><function v="sub"/><type v="256"/><GUILayout><gpos v="2024 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001243"/></connection><connection><identifier v="b"/><connRef v="1000001236"/></connection></connections></paramNode><paramNode><uid v="1000001246"/><function v="swizzle3"/><type v="1024"/><GUILayout><gpos v="2304 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001245"/></connection></connections><funcDatas><funcData><name v="swizzle3"/><constantValue><constantValueInt3 v="0 0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001247"/><function v="swizzle3"/><type v="1024"/><GUILayout><gpos v="2024 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001236"/></connection></connections><funcDatas><funcData><name v="swizzle3"/><constantValue><constantValueInt3 v="0 0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001248"/><function v="sub"/><type v="1024"/><GUILayout><gpos v="2584 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001247"/></connection><connection><identifier v="b"/><connRef v="1000001246"/></connection></connections></paramNode><paramNode><uid v="1000001249"/><function v="add"/><type v="1024"/><GUILayout><gpos v="3984 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001246"/></connection><connection><identifier v="b"/><connRef v="1000001250"/></connection></connections></paramNode><paramNode><uid v="1000001250"/><function v="mul"/><type v="1024"/><GUILayout><gpos v="3704 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001248"/></connection><connection><identifier v="b"/><connRef v="1000001232"/></connection></connections></paramNode><paramNode><uid v="1000001251"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 1664 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="HSL"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="Random_Color"/><uid v="1000001283"/><attributes><category v="Functions/colorValues"/><description v="Evaluates the Random_Color function graph. Result type: Float3. Inputs: RGB, RGB_Randomness."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="RGB"/><uid v="1000001284"/><attributes><label v="RGB"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="0 0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="RGB_Randomness"/><uid v="1000001285"/><attributes><label v="RGB_Randomness"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="0 0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000001282"/><paramNodes><paramNode><uid v="1000001254"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001255"/></connection><connection><identifier v="b"/><connRef v="1000001269"/></connection></connections></paramNode><paramNode><uid v="1000001255"/><function v="rand"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001278"/></connection></connections></paramNode><paramNode><uid v="1000001256"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001260"/></connection><connection><identifier v="componentslast"/><connRef v="1000001261"/></connection></connections></paramNode><paramNode><uid v="1000001257"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001273"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001258"/><function v="rand"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001278"/></connection></connections></paramNode><paramNode><uid v="1000001259"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001258"/></connection><connection><identifier v="b"/><connRef v="1000001266"/></connection></connections></paramNode><paramNode><uid v="1000001260"/><function v="add"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001272"/></connection><connection><identifier v="b"/><connRef v="1000001279"/></connection></connections></paramNode><paramNode><uid v="1000001261"/><function v="add"/><type v="256"/><GUILayout><gpos v="1464 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001268"/></connection><connection><identifier v="b"/><connRef v="1000001280"/></connection></connections></paramNode><paramNode><uid v="1000001262"/><function v="sub"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001270"/></connection><connection><identifier v="b"/><connRef v="1000001278"/></connection></connections></paramNode><paramNode><uid v="1000001263"/><function v="sub"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001259"/></connection><connection><identifier v="b"/><connRef v="1000001278"/></connection></connections></paramNode><paramNode><uid v="1000001264"/><function v="add"/><type v="256"/><GUILayout><gpos v="1464 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001257"/></connection><connection><identifier v="b"/><connRef v="1000001281"/></connection></connections></paramNode><paramNode><uid v="1000001265"/><function v="rand"/><type v="256"/><GUILayout><gpos v="344 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001278"/></connection></connections></paramNode><paramNode><uid v="1000001266"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001267"/><function v="sub"/><type v="256"/><GUILayout><gpos v="904 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001254"/></connection><connection><identifier v="b"/><connRef v="1000001278"/></connection></connections></paramNode><paramNode><uid v="1000001268"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 704 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001273"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001269"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001270"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001265"/></connection><connection><identifier v="b"/><connRef v="1000001271"/></connection></connections></paramNode><paramNode><uid v="1000001271"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001272"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 864 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001273"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001273"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="RGB"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001274"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 1024 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001277"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001275"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 1184 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001277"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001276"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 1344 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001277"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001277"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="RGB_Randomness"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001278"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001279"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001267"/></connection><connection><identifier v="b"/><connRef v="1000001274"/></connection></connections></paramNode><paramNode><uid v="1000001280"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001263"/></connection><connection><identifier v="b"/><connRef v="1000001275"/></connection></connections></paramNode><paramNode><uid v="1000001281"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001262"/></connection><connection><identifier v="b"/><connRef v="1000001276"/></connection></connections></paramNode><paramNode><uid v="1000001282"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001256"/></connection><connection><identifier v="componentslast"/><connRef v="1000001264"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="Random_Luminosity"/><uid v="1000001302"/><attributes><category v="Functions/colorValues"/><description v="Evaluates the Random_Luminosity function graph. Result type: Float3. Inputs: RGB, Luminosity_Randomness."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="RGB"/><uid v="1000001303"/><attributes><label v="RGB"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="0 0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="Luminosity_Randomness"/><uid v="1000001304"/><attributes><label v="Luminosity_Randomness"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000001301"/><paramNodes><paramNode><uid v="1000001286"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001287"/></connection><connection><identifier v="b"/><connRef v="1000001295"/></connection></connections></paramNode><paramNode><uid v="1000001287"/><function v="rand"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001298"/></connection></connections></paramNode><paramNode><uid v="1000001288"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001290"/></connection><connection><identifier v="componentslast"/><connRef v="1000001291"/></connection></connections></paramNode><paramNode><uid v="1000001289"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001297"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001290"/><function v="add"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001296"/></connection><connection><identifier v="b"/><connRef v="1000001299"/></connection></connections></paramNode><paramNode><uid v="1000001291"/><function v="add"/><type v="256"/><GUILayout><gpos v="1464 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001294"/></connection><connection><identifier v="b"/><connRef v="1000001299"/></connection></connections></paramNode><paramNode><uid v="1000001292"/><function v="add"/><type v="256"/><GUILayout><gpos v="1464 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001289"/></connection><connection><identifier v="b"/><connRef v="1000001299"/></connection></connections></paramNode><paramNode><uid v="1000001293"/><function v="sub"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001286"/></connection><connection><identifier v="b"/><connRef v="1000001298"/></connection></connections></paramNode><paramNode><uid v="1000001294"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001297"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001295"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001296"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 544 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001297"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001297"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="RGB"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001298"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001299"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001293"/></connection><connection><identifier v="b"/><connRef v="1000001300"/></connection></connections></paramNode><paramNode><uid v="1000001300"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="Luminosity_Randomness"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001301"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001288"/></connection><connection><identifier v="componentslast"/><connRef v="1000001292"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="RGBtoHSV"/><uid v="1000001311"/><attributes><category v="Functions/colorValues"/><description v="Evaluates the RGBtoHSV function graph. Result type: Float3. Inputs: rgb."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="rgb"/><uid v="1000001312"/><attributes><label v="RGB"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000001306"/><paramNodes><paramNode><uid v="1000001305"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001307"/></connection><connection><identifier v="componentslast"/><connRef v="1000001308"/></connection></connections></paramNode><paramNode><uid v="1000001306"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001305"/></connection><connection><identifier v="componentslast"/><connRef v="1000001309"/></connection></connections></paramNode><paramNode><uid v="1000001307"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="rgb"/><connRef v="1000001310"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_hue_hexagonal"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="rgb"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001308"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="rgb"/><connRef v="1000001310"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_saturation_HSV"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="rgb"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001309"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="rgb"/><connRef v="1000001310"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_lightness_hexcone"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="rgb"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001310"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="rgb"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="RGBtoHSI"/><uid v="1000001319"/><attributes><category v="Functions/colorValues"/><description v="Evaluates the RGBtoHSI function graph. Result type: Float3. Inputs: rgb."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="rgb"/><uid v="1000001320"/><attributes><label v="RGB"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000001318"/><paramNodes><paramNode><uid v="1000001313"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="rgb"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001314"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="rgb"/><connRef v="1000001313"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_saturation_HSI"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="rgb"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001315"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="rgb"/><connRef v="1000001313"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_hue_2_polar"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="rgb"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001316"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="rgb"/><connRef v="1000001313"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_lightness_average"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="rgb"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001317"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001315"/></connection><connection><identifier v="componentslast"/><connRef v="1000001314"/></connection></connections></paramNode><paramNode><uid v="1000001318"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001317"/></connection><connection><identifier v="componentslast"/><connRef v="1000001316"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="RGBtoHCL"/><uid v="1000001327"/><attributes><category v="Functions/colorValues"/><description v="Evaluates the RGBtoHCL function graph. Result type: Float3. Inputs: rgb."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="rgb"/><uid v="1000001328"/><attributes><label v="RGB"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000001322"/><paramNodes><paramNode><uid v="1000001321"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001324"/></connection><connection><identifier v="componentslast"/><connRef v="1000001325"/></connection></connections></paramNode><paramNode><uid v="1000001322"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001321"/></connection><connection><identifier v="componentslast"/><connRef v="1000001326"/></connection></connections></paramNode><paramNode><uid v="1000001323"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="rgb"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001324"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="rgb"/><connRef v="1000001323"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_hue_hexagonal"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="rgb"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001325"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="rgb"/><connRef v="1000001323"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_chroma_hexagonal"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="rgb"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001326"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="rgb"/><connRef v="1000001323"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_lightness_luma_rec601"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="rgb"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="RGB_lightness_average"/><uid v="1000001337"/><attributes><category v="Functions/colorValues"/><description v="Evaluates the RGB_lightness_average function graph. Result type: Float. Inputs: rgb."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="rgb"/><uid v="1000001338"/><attributes><label v="RGB"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001335"/><paramNodes><paramNode><uid v="1000001329"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="rgb"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001330"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001329"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001331"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001329"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001332"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001329"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001333"/><function v="add"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001330"/></connection><connection><identifier v="b"/><connRef v="1000001331"/></connection></connections></paramNode><paramNode><uid v="1000001334"/><function v="add"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001333"/></connection><connection><identifier v="b"/><connRef v="1000001332"/></connection></connections></paramNode><paramNode><uid v="1000001335"/><function v="div"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001334"/></connection><connection><identifier v="b"/><connRef v="1000001336"/></connection></connections></paramNode><paramNode><uid v="1000001336"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="3"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="RGB_lightness_hexcone"/><uid v="1000001345"/><attributes><category v="Functions/colorValues"/><description v="Evaluates the RGB_lightness_hexcone function graph. Result type: Float. Inputs: rgb."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="rgb"/><uid v="1000001346"/><attributes><label v="RGB"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001344"/><paramNodes><paramNode><uid v="1000001339"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001342"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001340"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001342"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001341"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001342"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001342"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="rgb"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001343"/><function v="max"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001341"/></connection><connection><identifier v="b"/><connRef v="1000001340"/></connection></connections></paramNode><paramNode><uid v="1000001344"/><function v="max"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001343"/></connection><connection><identifier v="b"/><connRef v="1000001339"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="RGB_lightness_bihexcone"/><uid v="1000001358"/><attributes><category v="Functions/colorValues"/><description v="Evaluates the RGB_lightness_bihexcone function graph. Result type: Float. Inputs: rgb."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="rgb"/><uid v="1000001359"/><attributes><label v="RGB"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001356"/><paramNodes><paramNode><uid v="1000001347"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="rgb"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001348"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001347"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001349"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001347"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001350"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001347"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001351"/><function v="min"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001349"/></connection><connection><identifier v="b"/><connRef v="1000001350"/></connection></connections></paramNode><paramNode><uid v="1000001352"/><function v="min"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001351"/></connection><connection><identifier v="b"/><connRef v="1000001348"/></connection></connections></paramNode><paramNode><uid v="1000001353"/><function v="max"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001349"/></connection><connection><identifier v="b"/><connRef v="1000001350"/></connection></connections></paramNode><paramNode><uid v="1000001354"/><function v="max"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001353"/></connection><connection><identifier v="b"/><connRef v="1000001348"/></connection></connections></paramNode><paramNode><uid v="1000001355"/><function v="add"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001354"/></connection><connection><identifier v="b"/><connRef v="1000001352"/></connection></connections></paramNode><paramNode><uid v="1000001356"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001355"/></connection><connection><identifier v="b"/><connRef v="1000001357"/></connection></connections></paramNode><paramNode><uid v="1000001357"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="RGB_lightness_luma_rec601"/><uid v="1000001372"/><attributes><category v="Functions/colorValues"/><description v="Evaluates the RGB_lightness_luma_rec601 function graph. Result type: Float. Inputs: rgb."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="rgb"/><uid v="1000001373"/><attributes><label v="RGB"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001368"/><paramNodes><paramNode><uid v="1000001360"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001365"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001361"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.587"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001362"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.299"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001363"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001362"/></connection><connection><identifier v="b"/><connRef v="1000001360"/></connection></connections></paramNode><paramNode><uid v="1000001364"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001361"/></connection><connection><identifier v="b"/><connRef v="1000001369"/></connection></connections></paramNode><paramNode><uid v="1000001365"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="rgb"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001366"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.114"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001367"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001366"/></connection><connection><identifier v="b"/><connRef v="1000001370"/></connection></connections></paramNode><paramNode><uid v="1000001368"/><function v="add"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001371"/></connection><connection><identifier v="b"/><connRef v="1000001367"/></connection></connections></paramNode><paramNode><uid v="1000001369"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001365"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001370"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001365"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001371"/><function v="add"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001363"/></connection><connection><identifier v="b"/><connRef v="1000001364"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="RGB_lightness_luma_rec709"/><uid v="1000001386"/><attributes><category v="Functions/colorValues"/><description v="Evaluates the RGB_lightness_luma_rec709 function graph. Result type: Float. Inputs: rgb."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="rgb"/><uid v="1000001387"/><attributes><label v="RGB"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001374"/><paramNodes><paramNode><uid v="1000001374"/><function v="add"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001382"/></connection><connection><identifier v="b"/><connRef v="1000001380"/></connection></connections></paramNode><paramNode><uid v="1000001375"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001377"/></connection><connection><identifier v="b"/><connRef v="1000001376"/></connection></connections></paramNode><paramNode><uid v="1000001376"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001385"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001377"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.2126"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001378"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.7152"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001379"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001378"/></connection><connection><identifier v="b"/><connRef v="1000001381"/></connection></connections></paramNode><paramNode><uid v="1000001380"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001384"/></connection><connection><identifier v="b"/><connRef v="1000001383"/></connection></connections></paramNode><paramNode><uid v="1000001381"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001385"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001382"/><function v="add"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001375"/></connection><connection><identifier v="b"/><connRef v="1000001379"/></connection></connections></paramNode><paramNode><uid v="1000001383"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001385"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001384"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.0722"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001385"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="rgb"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="RGB_chroma_hexagonal"/><uid v="1000001397"/><attributes><category v="Functions/colorValues"/><description v="Evaluates the RGB_chroma_hexagonal function graph. Result type: Float. Inputs: rgb."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="rgb"/><uid v="1000001398"/><attributes><label v="RGB"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001396"/><paramNodes><paramNode><uid v="1000001388"/><function v="min"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001393"/></connection><connection><identifier v="b"/><connRef v="1000001389"/></connection></connections></paramNode><paramNode><uid v="1000001389"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001391"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001390"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001391"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001391"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="rgb"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001392"/><function v="max"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001395"/></connection><connection><identifier v="b"/><connRef v="1000001390"/></connection></connections></paramNode><paramNode><uid v="1000001393"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001391"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001394"/><function v="min"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001388"/></connection><connection><identifier v="b"/><connRef v="1000001390"/></connection></connections></paramNode><paramNode><uid v="1000001395"/><function v="max"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001393"/></connection><connection><identifier v="b"/><connRef v="1000001389"/></connection></connections></paramNode><paramNode><uid v="1000001396"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001392"/></connection><connection><identifier v="b"/><connRef v="1000001394"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="RGB_chroma_2_polar"/><uid v="1000001419"/><attributes><category v="Functions/colorValues"/><description v="Evaluates the RGB_chroma_2_polar function graph. Result type: Float. Inputs: rgb."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="rgb"/><uid v="1000001420"/><attributes><label v="RGB"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001418"/><paramNodes><paramNode><uid v="1000001399"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001400"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001400"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="rgb"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001401"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001400"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001402"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001400"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001403"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001404"/></connection><connection><identifier v="b"/><connRef v="1000001401"/></connection></connections></paramNode><paramNode><uid v="1000001404"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001405"/><function v="sub"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001403"/></connection><connection><identifier v="b"/><connRef v="1000001399"/></connection></connections></paramNode><paramNode><uid v="1000001406"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001405"/></connection><connection><identifier v="b"/><connRef v="1000001402"/></connection></connections></paramNode><paramNode><uid v="1000001407"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001406"/></connection><connection><identifier v="b"/><connRef v="1000001408"/></connection></connections></paramNode><paramNode><uid v="1000001408"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001409"/><function v="sqrt"/><type v="256"/><GUILayout><gpos v="344 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001410"/></connection></connections></paramNode><paramNode><uid v="1000001410"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001411"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001409"/></connection><connection><identifier v="b"/><connRef v="1000001412"/></connection></connections></paramNode><paramNode><uid v="1000001412"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001413"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001399"/></connection><connection><identifier v="b"/><connRef v="1000001402"/></connection></connections></paramNode><paramNode><uid v="1000001414"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001413"/></connection><connection><identifier v="b"/><connRef v="1000001411"/></connection></connections></paramNode><paramNode><uid v="1000001415"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001407"/></connection><connection><identifier v="b"/><connRef v="1000001407"/></connection></connections></paramNode><paramNode><uid v="1000001416"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001414"/></connection><connection><identifier v="b"/><connRef v="1000001414"/></connection></connections></paramNode><paramNode><uid v="1000001417"/><function v="add"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001415"/></connection><connection><identifier v="b"/><connRef v="1000001416"/></connection></connections></paramNode><paramNode><uid v="1000001418"/><function v="sqrt"/><type v="256"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001417"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="RGB_hue_hexagonal"/><uid v="1000001457"/><attributes><category v="Functions/colorValues"/><description v="Evaluates the RGB_hue_hexagonal function graph. Result type: Float. Inputs: rgb."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="rgb"/><uid v="1000001458"/><attributes><label v="RGB"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001451"/><paramNodes><paramNode><uid v="1000001421"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="rgb"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001422"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001421"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001423"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001428"/></connection><connection><identifier v="b"/><connRef v="1000001429"/></connection></connections></paramNode><paramNode><uid v="1000001424"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001421"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001425"/><function v="min"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001422"/></connection><connection><identifier v="b"/><connRef v="1000001426"/></connection></connections></paramNode><paramNode><uid v="1000001426"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001421"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001427"/><function v="max"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001422"/></connection><connection><identifier v="b"/><connRef v="1000001426"/></connection></connections></paramNode><paramNode><uid v="1000001428"/><function v="max"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001427"/></connection><connection><identifier v="b"/><connRef v="1000001424"/></connection></connections></paramNode><paramNode><uid v="1000001429"/><function v="min"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001425"/></connection><connection><identifier v="b"/><connRef v="1000001424"/></connection></connections></paramNode><paramNode><uid v="1000001430"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001426"/></connection><connection><identifier v="b"/><connRef v="1000001424"/></connection></connections></paramNode><paramNode><uid v="1000001431"/><function v="div"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001430"/></connection><connection><identifier v="b"/><connRef v="1000001423"/></connection></connections></paramNode><paramNode><uid v="1000001432"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001424"/></connection><connection><identifier v="b"/><connRef v="1000001422"/></connection></connections></paramNode><paramNode><uid v="1000001433"/><function v="div"/><type v="256"/><GUILayout><gpos v="1464 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001432"/></connection><connection><identifier v="b"/><connRef v="1000001423"/></connection></connections></paramNode><paramNode><uid v="1000001434"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 704 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001422"/></connection><connection><identifier v="b"/><connRef v="1000001426"/></connection></connections></paramNode><paramNode><uid v="1000001435"/><function v="div"/><type v="256"/><GUILayout><gpos v="1464 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001434"/></connection><connection><identifier v="b"/><connRef v="1000001423"/></connection></connections></paramNode><paramNode><uid v="1000001436"/><function v="mod"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001431"/></connection><connection><identifier v="b"/><connRef v="1000001437"/></connection></connections></paramNode><paramNode><uid v="1000001437"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="6"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001438"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001439"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001440"/><function v="eq"/><type v="4"/><GUILayout><gpos v="1464 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001441"/></connection><connection><identifier v="b"/><connRef v="1000001423"/></connection></connections></paramNode><paramNode><uid v="1000001441"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001442"/><function v="eq"/><type v="4"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001422"/></connection><connection><identifier v="b"/><connRef v="1000001428"/></connection></connections></paramNode><paramNode><uid v="1000001443"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="2584 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001442"/></connection><connection><identifier v="ifpath"/><connRef v="1000001436"/></connection><connection><identifier v="elsepath"/><connRef v="1000001446"/></connection></connections></paramNode><paramNode><uid v="1000001444"/><function v="eq"/><type v="4"/><GUILayout><gpos v="1184 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001426"/></connection><connection><identifier v="b"/><connRef v="1000001428"/></connection></connections></paramNode><paramNode><uid v="1000001445"/><function v="eq"/><type v="4"/><GUILayout><gpos v="1184 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001424"/></connection><connection><identifier v="b"/><connRef v="1000001428"/></connection></connections></paramNode><paramNode><uid v="1000001446"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001444"/></connection><connection><identifier v="ifpath"/><connRef v="1000001455"/></connection><connection><identifier v="elsepath"/><connRef v="1000001447"/></connection></connections></paramNode><paramNode><uid v="1000001447"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001445"/></connection><connection><identifier v="ifpath"/><connRef v="1000001456"/></connection><connection><identifier v="elsepath"/><connRef v="1000001448"/></connection></connections></paramNode><paramNode><uid v="1000001448"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001449"/><function v="mul"/><type v="256"/><GUILayout><gpos v="3144 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001453"/></connection><connection><identifier v="b"/><connRef v="1000001450"/></connection></connections></paramNode><paramNode><uid v="1000001450"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="60"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001451"/><function v="div"/><type v="256"/><GUILayout><gpos v="3424 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001449"/></connection><connection><identifier v="b"/><connRef v="1000001452"/></connection></connections></paramNode><paramNode><uid v="1000001452"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="360"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001453"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="2864 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001440"/></connection><connection><identifier v="ifpath"/><connRef v="1000001454"/></connection><connection><identifier v="elsepath"/><connRef v="1000001443"/></connection></connections></paramNode><paramNode><uid v="1000001454"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001455"/><function v="add"/><type v="256"/><GUILayout><gpos v="1744 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001433"/></connection><connection><identifier v="b"/><connRef v="1000001438"/></connection></connections></paramNode><paramNode><uid v="1000001456"/><function v="add"/><type v="256"/><GUILayout><gpos v="1744 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001435"/></connection><connection><identifier v="b"/><connRef v="1000001439"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="RGB_hue_2_polar"/><uid v="1000001487"/><attributes><category v="Functions/colorValues"/><description v="Evaluates the RGB_hue_2_polar function graph. Result type: Float. Inputs: rgb."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="rgb"/><uid v="1000001488"/><attributes><label v="RGB"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001483"/><paramNodes><paramNode><uid v="1000001459"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001460"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001460"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="rgb"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001461"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001460"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001462"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001460"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001463"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001464"/></connection><connection><identifier v="b"/><connRef v="1000001461"/></connection></connections></paramNode><paramNode><uid v="1000001464"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001465"/><function v="sub"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001463"/></connection><connection><identifier v="b"/><connRef v="1000001459"/></connection></connections></paramNode><paramNode><uid v="1000001466"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001465"/></connection><connection><identifier v="b"/><connRef v="1000001462"/></connection></connections></paramNode><paramNode><uid v="1000001467"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001466"/></connection><connection><identifier v="b"/><connRef v="1000001468"/></connection></connections></paramNode><paramNode><uid v="1000001468"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001469"/><function v="sqrt"/><type v="256"/><GUILayout><gpos v="344 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001470"/></connection></connections></paramNode><paramNode><uid v="1000001470"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001471"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001469"/></connection><connection><identifier v="b"/><connRef v="1000001472"/></connection></connections></paramNode><paramNode><uid v="1000001472"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001473"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001459"/></connection><connection><identifier v="b"/><connRef v="1000001462"/></connection></connections></paramNode><paramNode><uid v="1000001474"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001473"/></connection><connection><identifier v="b"/><connRef v="1000001471"/></connection></connections></paramNode><paramNode><uid v="1000001475"/><function v="atan2"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001476"/></connection></connections></paramNode><paramNode><uid v="1000001476"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001467"/></connection><connection><identifier v="componentslast"/><connRef v="1000001474"/></connection></connections></paramNode><paramNode><uid v="1000001477"/><function v="div"/><type v="256"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001475"/></connection><connection><identifier v="b"/><connRef v="1000001478"/></connection></connections></paramNode><paramNode><uid v="1000001478"/><function v="instance"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Pi"/></constantValue></funcData></funcDatas><materialcraftInterface></materialcraftInterface></paramNode><paramNode><uid v="1000001479"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2584 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001477"/></connection><connection><identifier v="b"/><connRef v="1000001480"/></connection></connections></paramNode><paramNode><uid v="1000001480"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001481"/><function v="add"/><type v="256"/><GUILayout><gpos v="2864 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001479"/></connection><connection><identifier v="b"/><connRef v="1000001482"/></connection></connections></paramNode><paramNode><uid v="1000001482"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001483"/><function v="mod"/><type v="256"/><GUILayout><gpos v="3424 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001485"/></connection><connection><identifier v="b"/><connRef v="1000001484"/></connection></connections></paramNode><paramNode><uid v="1000001484"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001485"/><function v="add"/><type v="256"/><GUILayout><gpos v="3144 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001481"/></connection><connection><identifier v="b"/><connRef v="1000001486"/></connection></connections></paramNode><paramNode><uid v="1000001486"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="RGB_saturation_HSV"/><uid v="1000001497"/><attributes><category v="Functions/colorValues"/><description v="Evaluates the RGB_saturation_HSV function graph. Result type: Float. Inputs: rgb."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="rgb"/><uid v="1000001498"/><attributes><label v="RGB"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001493"/><paramNodes><paramNode><uid v="1000001489"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="rgb"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001490"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="rgb"/><connRef v="1000001489"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_chroma_hexagonal"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="rgb"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001491"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="rgb"/><connRef v="1000001489"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_lightness_hexcone"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="rgb"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001492"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001490"/></connection><connection><identifier v="b"/><connRef v="1000001491"/></connection></connections></paramNode><paramNode><uid v="1000001493"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001494"/></connection><connection><identifier v="ifpath"/><connRef v="1000001496"/></connection><connection><identifier v="elsepath"/><connRef v="1000001492"/></connection></connections></paramNode><paramNode><uid v="1000001494"/><function v="eq"/><type v="4"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001491"/></connection><connection><identifier v="b"/><connRef v="1000001495"/></connection></connections></paramNode><paramNode><uid v="1000001495"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001496"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="RGB_saturation_HSL"/><uid v="1000001514"/><attributes><category v="Functions/colorValues"/><description v="Evaluates the RGB_saturation_HSL function graph. Result type: Float. Inputs: rgb."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="rgb"/><uid v="1000001515"/><attributes><label v="RGB"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001510"/><paramNodes><paramNode><uid v="1000001499"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="rgb"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001500"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="rgb"/><connRef v="1000001499"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_chroma_hexagonal"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="rgb"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001501"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="rgb"/><connRef v="1000001499"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_lightness_bihexcone"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="rgb"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001502"/><function v="div"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001500"/></connection><connection><identifier v="b"/><connRef v="1000001509"/></connection></connections></paramNode><paramNode><uid v="1000001503"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001501"/></connection><connection><identifier v="b"/><connRef v="1000001504"/></connection></connections></paramNode><paramNode><uid v="1000001504"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001505"/><function v="sub"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001503"/></connection><connection><identifier v="b"/><connRef v="1000001506"/></connection></connections></paramNode><paramNode><uid v="1000001506"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001507"/><function v="abs"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001505"/></connection></connections></paramNode><paramNode><uid v="1000001508"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001509"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001508"/></connection><connection><identifier v="b"/><connRef v="1000001507"/></connection></connections></paramNode><paramNode><uid v="1000001510"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001511"/></connection><connection><identifier v="ifpath"/><connRef v="1000001513"/></connection><connection><identifier v="elsepath"/><connRef v="1000001502"/></connection></connections></paramNode><paramNode><uid v="1000001511"/><function v="eq"/><type v="4"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001512"/></connection><connection><identifier v="b"/><connRef v="1000001501"/></connection></connections></paramNode><paramNode><uid v="1000001512"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001513"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="RGB_saturation_HSI"/><uid v="1000001530"/><attributes><category v="Functions/colorValues"/><description v="Evaluates the RGB_saturation_HSI function graph. Result type: Float. Inputs: rgb."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="rgb"/><uid v="1000001531"/><attributes><label v="RGB"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001526"/><paramNodes><paramNode><uid v="1000001516"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="rgb"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001517"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="rgb"/><connRef v="1000001516"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_lightness_average"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="rgb"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001518"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001516"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001519"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001516"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001520"/><function v="min"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001522"/></connection><connection><identifier v="b"/><connRef v="1000001518"/></connection></connections></paramNode><paramNode><uid v="1000001521"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 544 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001516"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001522"/><function v="min"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001521"/></connection><connection><identifier v="b"/><connRef v="1000001519"/></connection></connections></paramNode><paramNode><uid v="1000001523"/><function v="div"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001520"/></connection><connection><identifier v="b"/><connRef v="1000001517"/></connection></connections></paramNode><paramNode><uid v="1000001524"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001525"/></connection><connection><identifier v="b"/><connRef v="1000001523"/></connection></connections></paramNode><paramNode><uid v="1000001525"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001526"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001527"/></connection><connection><identifier v="ifpath"/><connRef v="1000001529"/></connection><connection><identifier v="elsepath"/><connRef v="1000001524"/></connection></connections></paramNode><paramNode><uid v="1000001527"/><function v="eq"/><type v="4"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001528"/></connection><connection><identifier v="b"/><connRef v="1000001517"/></connection></connections></paramNode><paramNode><uid v="1000001528"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001529"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="HSItoRGB"/><uid v="1000001603"/><attributes><category v="Functions/colorValues"/><description v="Evaluates the HSItoRGB function graph. Result type: Float3. Inputs: hsi."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="hsi"/><uid v="1000001604"/><attributes><label v="HSI"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000001592"/><paramNodes><paramNode><uid v="1000001532"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="hsi"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001533"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001532"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001534"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001532"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001535"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001532"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001536"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2584 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001538"/></connection><connection><identifier v="b"/><connRef v="1000001600"/></connection></connections></paramNode><paramNode><uid v="1000001537"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001538"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001537"/></connection><connection><identifier v="b"/><connRef v="1000001539"/></connection></connections></paramNode><paramNode><uid v="1000001539"/><function v="abs"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001544"/></connection></connections></paramNode><paramNode><uid v="1000001540"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001541"/></connection><connection><identifier v="b"/><connRef v="1000001533"/></connection></connections></paramNode><paramNode><uid v="1000001541"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="6"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001542"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001540"/></connection><connection><identifier v="b"/><connRef v="1000001543"/></connection></connections></paramNode><paramNode><uid v="1000001543"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001544"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001542"/></connection><connection><identifier v="b"/><connRef v="1000001545"/></connection></connections></paramNode><paramNode><uid v="1000001545"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001546"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="4544 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001548"/></connection><connection><identifier v="ifpath"/><connRef v="1000001573"/></connection><connection><identifier v="elsepath"/><connRef v="1000001585"/></connection></connections></paramNode><paramNode><uid v="1000001547"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001549"/></connection><connection><identifier v="b"/><connRef v="1000001540"/></connection></connections></paramNode><paramNode><uid v="1000001548"/><function v="and"/><type v="4"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001547"/></connection><connection><identifier v="b"/><connRef v="1000001566"/></connection></connections></paramNode><paramNode><uid v="1000001549"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001550"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001551"/><function v="and"/><type v="4"/><GUILayout><gpos v="1184 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001553"/></connection><connection><identifier v="b"/><connRef v="1000001567"/></connection></connections></paramNode><paramNode><uid v="1000001552"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001553"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001550"/></connection><connection><identifier v="b"/><connRef v="1000001540"/></connection></connections></paramNode><paramNode><uid v="1000001554"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001552"/></connection><connection><identifier v="b"/><connRef v="1000001540"/></connection></connections></paramNode><paramNode><uid v="1000001555"/><function v="and"/><type v="4"/><GUILayout><gpos v="1184 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001554"/></connection><connection><identifier v="b"/><connRef v="1000001568"/></connection></connections></paramNode><paramNode><uid v="1000001556"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001557"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 704 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001556"/></connection><connection><identifier v="b"/><connRef v="1000001540"/></connection></connections></paramNode><paramNode><uid v="1000001558"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001559"/><function v="and"/><type v="4"/><GUILayout><gpos v="1184 704 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001557"/></connection><connection><identifier v="b"/><connRef v="1000001569"/></connection></connections></paramNode><paramNode><uid v="1000001560"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 864 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001558"/></connection><connection><identifier v="b"/><connRef v="1000001540"/></connection></connections></paramNode><paramNode><uid v="1000001561"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1664 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001562"/><function v="and"/><type v="4"/><GUILayout><gpos v="1184 864 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001560"/></connection><connection><identifier v="b"/><connRef v="1000001570"/></connection></connections></paramNode><paramNode><uid v="1000001563"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 1024 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001561"/></connection><connection><identifier v="b"/><connRef v="1000001540"/></connection></connections></paramNode><paramNode><uid v="1000001564"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1824 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="6"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001565"/><function v="and"/><type v="4"/><GUILayout><gpos v="1184 1024 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001563"/></connection><connection><identifier v="b"/><connRef v="1000001571"/></connection></connections></paramNode><paramNode><uid v="1000001566"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 1184 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001540"/></connection><connection><identifier v="b"/><connRef v="1000001550"/></connection></connections></paramNode><paramNode><uid v="1000001567"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 1344 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001540"/></connection><connection><identifier v="b"/><connRef v="1000001552"/></connection></connections></paramNode><paramNode><uid v="1000001568"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 1504 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001540"/></connection><connection><identifier v="b"/><connRef v="1000001556"/></connection></connections></paramNode><paramNode><uid v="1000001569"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 1664 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001540"/></connection><connection><identifier v="b"/><connRef v="1000001558"/></connection></connections></paramNode><paramNode><uid v="1000001570"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 1824 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001540"/></connection><connection><identifier v="b"/><connRef v="1000001561"/></connection></connections></paramNode><paramNode><uid v="1000001571"/><function v="lr"/><type v="4"/><GUILayout><gpos v="904 1984 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001540"/></connection><connection><identifier v="b"/><connRef v="1000001564"/></connection></connections></paramNode><paramNode><uid v="1000001572"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2864 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001600"/></connection><connection><identifier v="componentslast"/><connRef v="1000001536"/></connection></connections></paramNode><paramNode><uid v="1000001573"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="3144 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001572"/></connection><connection><identifier v="componentslast"/><connRef v="1000001574"/></connection></connections></paramNode><paramNode><uid v="1000001574"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1984 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001575"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2864 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001536"/></connection><connection><identifier v="componentslast"/><connRef v="1000001600"/></connection></connections></paramNode><paramNode><uid v="1000001576"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="3144 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001575"/></connection><connection><identifier v="componentslast"/><connRef v="1000001574"/></connection></connections></paramNode><paramNode><uid v="1000001577"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2584 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001574"/></connection><connection><identifier v="componentslast"/><connRef v="1000001600"/></connection></connections></paramNode><paramNode><uid v="1000001578"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="2864 384 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001577"/></connection><connection><identifier v="componentslast"/><connRef v="1000001536"/></connection></connections></paramNode><paramNode><uid v="1000001579"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="3144 384 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001580"/></connection><connection><identifier v="componentslast"/><connRef v="1000001600"/></connection></connections></paramNode><paramNode><uid v="1000001580"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2864 544 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001574"/></connection><connection><identifier v="componentslast"/><connRef v="1000001536"/></connection></connections></paramNode><paramNode><uid v="1000001581"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="3144 544 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001582"/></connection><connection><identifier v="componentslast"/><connRef v="1000001600"/></connection></connections></paramNode><paramNode><uid v="1000001582"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2864 704 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001536"/></connection><connection><identifier v="componentslast"/><connRef v="1000001574"/></connection></connections></paramNode><paramNode><uid v="1000001583"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="2864 864 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001584"/></connection><connection><identifier v="componentslast"/><connRef v="1000001536"/></connection></connections></paramNode><paramNode><uid v="1000001584"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2584 384 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001600"/></connection><connection><identifier v="componentslast"/><connRef v="1000001574"/></connection></connections></paramNode><paramNode><uid v="1000001585"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="4264 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001551"/></connection><connection><identifier v="ifpath"/><connRef v="1000001576"/></connection><connection><identifier v="elsepath"/><connRef v="1000001586"/></connection></connections></paramNode><paramNode><uid v="1000001586"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="3984 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001555"/></connection><connection><identifier v="ifpath"/><connRef v="1000001578"/></connection><connection><identifier v="elsepath"/><connRef v="1000001587"/></connection></connections></paramNode><paramNode><uid v="1000001587"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="3704 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001559"/></connection><connection><identifier v="ifpath"/><connRef v="1000001579"/></connection><connection><identifier v="elsepath"/><connRef v="1000001588"/></connection></connections></paramNode><paramNode><uid v="1000001588"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="3424 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001562"/></connection><connection><identifier v="ifpath"/><connRef v="1000001581"/></connection><connection><identifier v="elsepath"/><connRef v="1000001589"/></connection></connections></paramNode><paramNode><uid v="1000001589"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="3144 704 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001565"/></connection><connection><identifier v="ifpath"/><connRef v="1000001583"/></connection><connection><identifier v="elsepath"/><connRef v="1000001590"/></connection></connections></paramNode><paramNode><uid v="1000001590"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 2144 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0 0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001591"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001601"/></connection><connection><identifier v="b"/><connRef v="1000001534"/></connection></connections></paramNode><paramNode><uid v="1000001592"/><function v="add"/><type v="1024"/><GUILayout><gpos v="4824 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001594"/></connection><connection><identifier v="b"/><connRef v="1000001546"/></connection></connections></paramNode><paramNode><uid v="1000001593"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1184 1184 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001602"/></connection><connection><identifier v="componentslast"/><connRef v="1000001602"/></connection></connections></paramNode><paramNode><uid v="1000001594"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="1464 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001593"/></connection><connection><identifier v="componentslast"/><connRef v="1000001602"/></connection></connections></paramNode><paramNode><uid v="1000001595"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001535"/></connection><connection><identifier v="b"/><connRef v="1000001596"/></connection></connections></paramNode><paramNode><uid v="1000001596"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 2304 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001597"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 2144 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001534"/></connection><connection><identifier v="b"/><connRef v="1000001595"/></connection></connections></paramNode><paramNode><uid v="1000001598"/><function v="add"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001538"/></connection><connection><identifier v="b"/><connRef v="1000001599"/></connection></connections></paramNode><paramNode><uid v="1000001599"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 2464 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001600"/><function v="div"/><type v="256"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001597"/></connection><connection><identifier v="b"/><connRef v="1000001598"/></connection></connections></paramNode><paramNode><uid v="1000001601"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 2624 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001602"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 2304 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001591"/></connection><connection><identifier v="b"/><connRef v="1000001535"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="HSVtoRGB"/><uid v="1000001669"/><attributes><category v="Functions/colorValues"/><description v="Evaluates the HSVtoRGB function graph. Result type: Float3. Inputs: hsv."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="hsv"/><uid v="1000001670"/><attributes><label v="HSV"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000001665"/><paramNodes><paramNode><uid v="1000001605"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="hsv"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001606"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001605"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001607"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001605"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001608"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001605"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001609"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001611"/></connection><connection><identifier v="b"/><connRef v="1000001668"/></connection></connections></paramNode><paramNode><uid v="1000001610"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001611"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001610"/></connection><connection><identifier v="b"/><connRef v="1000001612"/></connection></connections></paramNode><paramNode><uid v="1000001612"/><function v="abs"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001617"/></connection></connections></paramNode><paramNode><uid v="1000001613"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001614"/></connection><connection><identifier v="b"/><connRef v="1000001606"/></connection></connections></paramNode><paramNode><uid v="1000001614"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="6"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001615"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001613"/></connection><connection><identifier v="b"/><connRef v="1000001616"/></connection></connections></paramNode><paramNode><uid v="1000001616"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001617"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001615"/></connection><connection><identifier v="b"/><connRef v="1000001618"/></connection></connections></paramNode><paramNode><uid v="1000001618"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001619"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="3984 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001621"/></connection><connection><identifier v="ifpath"/><connRef v="1000001646"/></connection><connection><identifier v="elsepath"/><connRef v="1000001658"/></connection></connections></paramNode><paramNode><uid v="1000001620"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001622"/></connection><connection><identifier v="b"/><connRef v="1000001613"/></connection></connections></paramNode><paramNode><uid v="1000001621"/><function v="and"/><type v="4"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001620"/></connection><connection><identifier v="b"/><connRef v="1000001639"/></connection></connections></paramNode><paramNode><uid v="1000001622"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001623"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001624"/><function v="and"/><type v="4"/><GUILayout><gpos v="1184 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001626"/></connection><connection><identifier v="b"/><connRef v="1000001640"/></connection></connections></paramNode><paramNode><uid v="1000001625"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001626"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001623"/></connection><connection><identifier v="b"/><connRef v="1000001613"/></connection></connections></paramNode><paramNode><uid v="1000001627"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001625"/></connection><connection><identifier v="b"/><connRef v="1000001613"/></connection></connections></paramNode><paramNode><uid v="1000001628"/><function v="and"/><type v="4"/><GUILayout><gpos v="1184 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001627"/></connection><connection><identifier v="b"/><connRef v="1000001641"/></connection></connections></paramNode><paramNode><uid v="1000001629"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001630"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 704 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001629"/></connection><connection><identifier v="b"/><connRef v="1000001613"/></connection></connections></paramNode><paramNode><uid v="1000001631"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001632"/><function v="and"/><type v="4"/><GUILayout><gpos v="1184 704 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001630"/></connection><connection><identifier v="b"/><connRef v="1000001642"/></connection></connections></paramNode><paramNode><uid v="1000001633"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 864 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001631"/></connection><connection><identifier v="b"/><connRef v="1000001613"/></connection></connections></paramNode><paramNode><uid v="1000001634"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1664 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001635"/><function v="and"/><type v="4"/><GUILayout><gpos v="1184 864 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001633"/></connection><connection><identifier v="b"/><connRef v="1000001643"/></connection></connections></paramNode><paramNode><uid v="1000001636"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 1024 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001634"/></connection><connection><identifier v="b"/><connRef v="1000001613"/></connection></connections></paramNode><paramNode><uid v="1000001637"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1824 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="6"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001638"/><function v="and"/><type v="4"/><GUILayout><gpos v="1184 1024 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001636"/></connection><connection><identifier v="b"/><connRef v="1000001644"/></connection></connections></paramNode><paramNode><uid v="1000001639"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 1184 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001613"/></connection><connection><identifier v="b"/><connRef v="1000001623"/></connection></connections></paramNode><paramNode><uid v="1000001640"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 1344 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001613"/></connection><connection><identifier v="b"/><connRef v="1000001625"/></connection></connections></paramNode><paramNode><uid v="1000001641"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 1504 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001613"/></connection><connection><identifier v="b"/><connRef v="1000001629"/></connection></connections></paramNode><paramNode><uid v="1000001642"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 1664 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001613"/></connection><connection><identifier v="b"/><connRef v="1000001631"/></connection></connections></paramNode><paramNode><uid v="1000001643"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 1824 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001613"/></connection><connection><identifier v="b"/><connRef v="1000001634"/></connection></connections></paramNode><paramNode><uid v="1000001644"/><function v="lr"/><type v="4"/><GUILayout><gpos v="904 1984 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001613"/></connection><connection><identifier v="b"/><connRef v="1000001637"/></connection></connections></paramNode><paramNode><uid v="1000001645"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001668"/></connection><connection><identifier v="componentslast"/><connRef v="1000001609"/></connection></connections></paramNode><paramNode><uid v="1000001646"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="2584 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001645"/></connection><connection><identifier v="componentslast"/><connRef v="1000001647"/></connection></connections></paramNode><paramNode><uid v="1000001647"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1984 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001648"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2304 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001609"/></connection><connection><identifier v="componentslast"/><connRef v="1000001668"/></connection></connections></paramNode><paramNode><uid v="1000001649"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="2584 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001648"/></connection><connection><identifier v="componentslast"/><connRef v="1000001647"/></connection></connections></paramNode><paramNode><uid v="1000001650"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="904 2144 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001647"/></connection><connection><identifier v="componentslast"/><connRef v="1000001668"/></connection></connections></paramNode><paramNode><uid v="1000001651"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="2304 384 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001650"/></connection><connection><identifier v="componentslast"/><connRef v="1000001609"/></connection></connections></paramNode><paramNode><uid v="1000001652"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="2584 384 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001653"/></connection><connection><identifier v="componentslast"/><connRef v="1000001668"/></connection></connections></paramNode><paramNode><uid v="1000001653"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2304 544 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001647"/></connection><connection><identifier v="componentslast"/><connRef v="1000001609"/></connection></connections></paramNode><paramNode><uid v="1000001654"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="2584 544 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001655"/></connection><connection><identifier v="componentslast"/><connRef v="1000001668"/></connection></connections></paramNode><paramNode><uid v="1000001655"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2304 704 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001609"/></connection><connection><identifier v="componentslast"/><connRef v="1000001647"/></connection></connections></paramNode><paramNode><uid v="1000001656"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="2304 864 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001657"/></connection><connection><identifier v="componentslast"/><connRef v="1000001609"/></connection></connections></paramNode><paramNode><uid v="1000001657"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="904 2304 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001668"/></connection><connection><identifier v="componentslast"/><connRef v="1000001647"/></connection></connections></paramNode><paramNode><uid v="1000001658"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="3704 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001624"/></connection><connection><identifier v="ifpath"/><connRef v="1000001649"/></connection><connection><identifier v="elsepath"/><connRef v="1000001659"/></connection></connections></paramNode><paramNode><uid v="1000001659"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="3424 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001628"/></connection><connection><identifier v="ifpath"/><connRef v="1000001651"/></connection><connection><identifier v="elsepath"/><connRef v="1000001660"/></connection></connections></paramNode><paramNode><uid v="1000001660"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="3144 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001632"/></connection><connection><identifier v="ifpath"/><connRef v="1000001652"/></connection><connection><identifier v="elsepath"/><connRef v="1000001661"/></connection></connections></paramNode><paramNode><uid v="1000001661"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="2864 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001635"/></connection><connection><identifier v="ifpath"/><connRef v="1000001654"/></connection><connection><identifier v="elsepath"/><connRef v="1000001662"/></connection></connections></paramNode><paramNode><uid v="1000001662"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="2584 704 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001638"/></connection><connection><identifier v="ifpath"/><connRef v="1000001656"/></connection><connection><identifier v="elsepath"/><connRef v="1000001663"/></connection></connections></paramNode><paramNode><uid v="1000001663"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 2144 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0 0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001664"/><function v="sub"/><type v="256"/><GUILayout><gpos v="904 2464 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001608"/></connection><connection><identifier v="b"/><connRef v="1000001668"/></connection></connections></paramNode><paramNode><uid v="1000001665"/><function v="add"/><type v="1024"/><GUILayout><gpos v="4264 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001667"/></connection><connection><identifier v="b"/><connRef v="1000001619"/></connection></connections></paramNode><paramNode><uid v="1000001666"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1184 1184 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001664"/></connection><connection><identifier v="componentslast"/><connRef v="1000001664"/></connection></connections></paramNode><paramNode><uid v="1000001667"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="1464 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001666"/></connection><connection><identifier v="componentslast"/><connRef v="1000001664"/></connection></connections></paramNode><paramNode><uid v="1000001668"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001607"/></connection><connection><identifier v="b"/><connRef v="1000001608"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="HCLtoRGB"/><uid v="1000001735"/><attributes><category v="Functions/colorValues"/><description v="Evaluates the HCLtoRGB function graph. Result type: Float3. Inputs: hcl."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="hcl"/><uid v="1000001736"/><attributes><label v="HCL"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000001732"/><paramNodes><paramNode><uid v="1000001671"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="hcl"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001672"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001671"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001673"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001671"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001674"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001671"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001675"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001677"/></connection><connection><identifier v="b"/><connRef v="1000001673"/></connection></connections></paramNode><paramNode><uid v="1000001676"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001677"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001676"/></connection><connection><identifier v="b"/><connRef v="1000001678"/></connection></connections></paramNode><paramNode><uid v="1000001678"/><function v="abs"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001683"/></connection></connections></paramNode><paramNode><uid v="1000001679"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001680"/></connection><connection><identifier v="b"/><connRef v="1000001672"/></connection></connections></paramNode><paramNode><uid v="1000001680"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="6"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001681"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001679"/></connection><connection><identifier v="b"/><connRef v="1000001682"/></connection></connections></paramNode><paramNode><uid v="1000001682"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001683"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001681"/></connection><connection><identifier v="b"/><connRef v="1000001684"/></connection></connections></paramNode><paramNode><uid v="1000001684"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001685"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="3984 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001687"/></connection><connection><identifier v="ifpath"/><connRef v="1000001712"/></connection><connection><identifier v="elsepath"/><connRef v="1000001724"/></connection></connections></paramNode><paramNode><uid v="1000001686"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001688"/></connection><connection><identifier v="b"/><connRef v="1000001679"/></connection></connections></paramNode><paramNode><uid v="1000001687"/><function v="and"/><type v="4"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001686"/></connection><connection><identifier v="b"/><connRef v="1000001705"/></connection></connections></paramNode><paramNode><uid v="1000001688"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001689"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001690"/><function v="and"/><type v="4"/><GUILayout><gpos v="1184 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001692"/></connection><connection><identifier v="b"/><connRef v="1000001706"/></connection></connections></paramNode><paramNode><uid v="1000001691"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001692"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001689"/></connection><connection><identifier v="b"/><connRef v="1000001679"/></connection></connections></paramNode><paramNode><uid v="1000001693"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001691"/></connection><connection><identifier v="b"/><connRef v="1000001679"/></connection></connections></paramNode><paramNode><uid v="1000001694"/><function v="and"/><type v="4"/><GUILayout><gpos v="1184 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001693"/></connection><connection><identifier v="b"/><connRef v="1000001707"/></connection></connections></paramNode><paramNode><uid v="1000001695"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001696"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 704 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001695"/></connection><connection><identifier v="b"/><connRef v="1000001679"/></connection></connections></paramNode><paramNode><uid v="1000001697"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001698"/><function v="and"/><type v="4"/><GUILayout><gpos v="1184 704 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001696"/></connection><connection><identifier v="b"/><connRef v="1000001708"/></connection></connections></paramNode><paramNode><uid v="1000001699"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 864 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001697"/></connection><connection><identifier v="b"/><connRef v="1000001679"/></connection></connections></paramNode><paramNode><uid v="1000001700"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1664 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001701"/><function v="and"/><type v="4"/><GUILayout><gpos v="1184 864 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001699"/></connection><connection><identifier v="b"/><connRef v="1000001709"/></connection></connections></paramNode><paramNode><uid v="1000001702"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 1024 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001700"/></connection><connection><identifier v="b"/><connRef v="1000001679"/></connection></connections></paramNode><paramNode><uid v="1000001703"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1824 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="6"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001704"/><function v="and"/><type v="4"/><GUILayout><gpos v="1184 1024 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001702"/></connection><connection><identifier v="b"/><connRef v="1000001710"/></connection></connections></paramNode><paramNode><uid v="1000001705"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 1184 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001679"/></connection><connection><identifier v="b"/><connRef v="1000001689"/></connection></connections></paramNode><paramNode><uid v="1000001706"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 1344 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001679"/></connection><connection><identifier v="b"/><connRef v="1000001691"/></connection></connections></paramNode><paramNode><uid v="1000001707"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 1504 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001679"/></connection><connection><identifier v="b"/><connRef v="1000001695"/></connection></connections></paramNode><paramNode><uid v="1000001708"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 1664 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001679"/></connection><connection><identifier v="b"/><connRef v="1000001697"/></connection></connections></paramNode><paramNode><uid v="1000001709"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 1824 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001679"/></connection><connection><identifier v="b"/><connRef v="1000001700"/></connection></connections></paramNode><paramNode><uid v="1000001710"/><function v="lr"/><type v="4"/><GUILayout><gpos v="904 1984 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001679"/></connection><connection><identifier v="b"/><connRef v="1000001703"/></connection></connections></paramNode><paramNode><uid v="1000001711"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001673"/></connection><connection><identifier v="componentslast"/><connRef v="1000001675"/></connection></connections></paramNode><paramNode><uid v="1000001712"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="2584 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001711"/></connection><connection><identifier v="componentslast"/><connRef v="1000001713"/></connection></connections></paramNode><paramNode><uid v="1000001713"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1984 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001714"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2304 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001675"/></connection><connection><identifier v="componentslast"/><connRef v="1000001673"/></connection></connections></paramNode><paramNode><uid v="1000001715"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="2584 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001714"/></connection><connection><identifier v="componentslast"/><connRef v="1000001713"/></connection></connections></paramNode><paramNode><uid v="1000001716"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001713"/></connection><connection><identifier v="componentslast"/><connRef v="1000001673"/></connection></connections></paramNode><paramNode><uid v="1000001717"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="2304 384 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001716"/></connection><connection><identifier v="componentslast"/><connRef v="1000001675"/></connection></connections></paramNode><paramNode><uid v="1000001718"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="2584 384 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001719"/></connection><connection><identifier v="componentslast"/><connRef v="1000001673"/></connection></connections></paramNode><paramNode><uid v="1000001719"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2304 544 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001713"/></connection><connection><identifier v="componentslast"/><connRef v="1000001675"/></connection></connections></paramNode><paramNode><uid v="1000001720"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="2584 544 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001721"/></connection><connection><identifier v="componentslast"/><connRef v="1000001673"/></connection></connections></paramNode><paramNode><uid v="1000001721"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2304 704 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001675"/></connection><connection><identifier v="componentslast"/><connRef v="1000001713"/></connection></connections></paramNode><paramNode><uid v="1000001722"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="2304 864 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001723"/></connection><connection><identifier v="componentslast"/><connRef v="1000001675"/></connection></connections></paramNode><paramNode><uid v="1000001723"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001673"/></connection><connection><identifier v="componentslast"/><connRef v="1000001713"/></connection></connections></paramNode><paramNode><uid v="1000001724"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="3704 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001690"/></connection><connection><identifier v="ifpath"/><connRef v="1000001715"/></connection><connection><identifier v="elsepath"/><connRef v="1000001725"/></connection></connections></paramNode><paramNode><uid v="1000001725"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="3424 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001694"/></connection><connection><identifier v="ifpath"/><connRef v="1000001717"/></connection><connection><identifier v="elsepath"/><connRef v="1000001726"/></connection></connections></paramNode><paramNode><uid v="1000001726"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="3144 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001698"/></connection><connection><identifier v="ifpath"/><connRef v="1000001718"/></connection><connection><identifier v="elsepath"/><connRef v="1000001727"/></connection></connections></paramNode><paramNode><uid v="1000001727"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="2864 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001701"/></connection><connection><identifier v="ifpath"/><connRef v="1000001720"/></connection><connection><identifier v="elsepath"/><connRef v="1000001728"/></connection></connections></paramNode><paramNode><uid v="1000001728"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="2584 704 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001704"/></connection><connection><identifier v="ifpath"/><connRef v="1000001722"/></connection><connection><identifier v="elsepath"/><connRef v="1000001729"/></connection></connections></paramNode><paramNode><uid v="1000001729"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 2144 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0 0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001730"/><function v="instance"/><type v="256"/><GUILayout><gpos v="4264 64 0"/></GUILayout><connections><connection><identifier v="rgb"/><connRef v="1000001685"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_lightness_luma_rec601"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="rgb"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001731"/><function v="sub"/><type v="256"/><GUILayout><gpos v="4544 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001674"/></connection><connection><identifier v="b"/><connRef v="1000001730"/></connection></connections></paramNode><paramNode><uid v="1000001732"/><function v="add"/><type v="1024"/><GUILayout><gpos v="5384 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001734"/></connection><connection><identifier v="b"/><connRef v="1000001685"/></connection></connections></paramNode><paramNode><uid v="1000001733"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="4824 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001731"/></connection><connection><identifier v="componentslast"/><connRef v="1000001731"/></connection></connections></paramNode><paramNode><uid v="1000001734"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="5104 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001733"/></connection><connection><identifier v="componentslast"/><connRef v="1000001731"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="linear_to_sRGB_luminance"/><uid v="1000001751"/><attributes><category v="Functions/colorValues"/><description v="Evaluates the linear_to_sRGB_luminance function graph. Result type: Float. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000001752"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001737"/><paramNodes><paramNode><uid v="1000001737"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001739"/></connection><connection><identifier v="ifpath"/><connRef v="1000001741"/></connection><connection><identifier v="elsepath"/><connRef v="1000001748"/></connection></connections></paramNode><paramNode><uid v="1000001738"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001739"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001738"/></connection><connection><identifier v="b"/><connRef v="1000001740"/></connection></connections></paramNode><paramNode><uid v="1000001740"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.0031308"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001741"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001738"/></connection><connection><identifier v="b"/><connRef v="1000001742"/></connection></connections></paramNode><paramNode><uid v="1000001742"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="12.92"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001743"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1.055"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001744"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001743"/></connection><connection><identifier v="b"/><connRef v="1000001750"/></connection></connections></paramNode><paramNode><uid v="1000001745"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001746"/><function v="div"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001745"/></connection><connection><identifier v="b"/><connRef v="1000001747"/></connection></connections></paramNode><paramNode><uid v="1000001747"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2.4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001748"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001744"/></connection><connection><identifier v="b"/><connRef v="1000001749"/></connection></connections></paramNode><paramNode><uid v="1000001749"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.055"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001750"/><function v="pow"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001738"/></connection><connection><identifier v="b"/><connRef v="1000001746"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="linear_to_sRGB_rgb"/><uid v="1000001762"/><attributes><category v="Functions/colorValues"/><description v="Evaluates the linear_to_sRGB_rgb function graph. Result type: Float3. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000001763"/><attributes><label v="input"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000001760"/><paramNodes><paramNode><uid v="1000001753"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001761"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001754"/><function v="instance"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000001753"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/linear_to_sRGB_luminance"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001755"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001761"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001756"/><function v="instance"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000001755"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/linear_to_sRGB_luminance"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001757"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001761"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001758"/><function v="instance"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000001757"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/linear_to_sRGB_luminance"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001759"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001754"/></connection><connection><identifier v="componentslast"/><connRef v="1000001756"/></connection></connections></paramNode><paramNode><uid v="1000001760"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001759"/></connection><connection><identifier v="componentslast"/><connRef v="1000001758"/></connection></connections></paramNode><paramNode><uid v="1000001761"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="sRGB_to_linear_rgb"/><uid v="1000001773"/><attributes><category v="Functions/colorValues"/><description v="Evaluates the sRGB_to_linear_rgb function graph. Result type: Float3. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000001774"/><attributes><label v="input"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000001772"/><paramNodes><paramNode><uid v="1000001764"/><function v="instance"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000001766"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/sRGB_to_linear_luminance"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001765"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001766"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001765"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001767"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001765"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001768"/><function v="instance"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000001767"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/sRGB_to_linear_luminance"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001769"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001765"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001770"/><function v="instance"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000001769"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/sRGB_to_linear_luminance"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001771"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001764"/></connection><connection><identifier v="componentslast"/><connRef v="1000001768"/></connection></connections></paramNode><paramNode><uid v="1000001772"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001771"/></connection><connection><identifier v="componentslast"/><connRef v="1000001770"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="sRGB_to_linear_luminance"/><uid v="1000001789"/><attributes><category v="Functions/colorValues"/><description v="Evaluates the sRGB_to_linear_luminance function graph. Result type: Float. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000001790"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001778"/><paramNodes><paramNode><uid v="1000001775"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001776"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001775"/></connection><connection><identifier v="b"/><connRef v="1000001777"/></connection></connections></paramNode><paramNode><uid v="1000001777"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.04045"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001778"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001776"/></connection><connection><identifier v="ifpath"/><connRef v="1000001782"/></connection><connection><identifier v="elsepath"/><connRef v="1000001788"/></connection></connections></paramNode><paramNode><uid v="1000001779"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001780"/><function v="div"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001779"/></connection><connection><identifier v="b"/><connRef v="1000001781"/></connection></connections></paramNode><paramNode><uid v="1000001781"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="12.92"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001782"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001775"/></connection><connection><identifier v="b"/><connRef v="1000001780"/></connection></connections></paramNode><paramNode><uid v="1000001783"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.055"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001784"/><function v="add"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001775"/></connection><connection><identifier v="b"/><connRef v="1000001783"/></connection></connections></paramNode><paramNode><uid v="1000001785"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001784"/></connection><connection><identifier v="b"/><connRef v="1000001786"/></connection></connections></paramNode><paramNode><uid v="1000001786"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1.055"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001787"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2.4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001788"/><function v="pow"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001785"/></connection><connection><identifier v="b"/><connRef v="1000001787"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="temperature_to_rgb"/><uid v="1000001813"/><attributes><category v="Functions/colorValues"/><description v="Evaluates the temperature_to_rgb function graph. Result type: Float3. Inputs: temperature."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="temperature"/><uid v="1000001814"/><attributes><label v="Temperature"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000001808"/><paramNodes><paramNode><uid v="1000001791"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001810"/></connection><connection><identifier v="componentslast"/><connRef v="1000001811"/></connection></connections></paramNode><paramNode><uid v="1000001792"/><function v="div"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001793"/></connection><connection><identifier v="b"/><connRef v="1000001795"/></connection></connections></paramNode><paramNode><uid v="1000001793"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="temperature"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001794"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001791"/></connection><connection><identifier v="componentslast"/><connRef v="1000001812"/></connection></connections></paramNode><paramNode><uid v="1000001795"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="100"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001796"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.9969671"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001797"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="-0.2677948"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001798"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2.7219892"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001799"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1344.492"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001800"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.6792997"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001801"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.04639626"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001802"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="-1.5172572"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001803"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="10.576205"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001804"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1664 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="-0.36975914"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001805"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1824 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="865.37256"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001806"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1984 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1.6870481"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001807"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 2144 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2.090228"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001808"/><function v="max"/><type v="1024"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001794"/></connection><connection><identifier v="b"/><connRef v="1000001809"/></connection></connections></paramNode><paramNode><uid v="1000001809"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 2304 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0 0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001810"/><function v="instance"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000001792"/></connection><connection><identifier v="a"/><connRef v="1000001800"/></connection><connection><identifier v="b"/><connRef v="1000001801"/></connection><connection><identifier v="c"/><connRef v="1000001803"/></connection><connection><identifier v="d"/><connRef v="1000001802"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/temperature_to_rgb_fit"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input"/><type v="0"/></input><input><identifier v="a"/><type v="0"/></input><input><identifier v="b"/><type v="0"/></input><input><identifier v="c"/><type v="0"/></input><input><identifier v="d"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001811"/><function v="instance"/><type v="256"/><GUILayout><gpos v="624 284 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000001792"/></connection><connection><identifier v="a"/><connRef v="1000001797"/></connection><connection><identifier v="b"/><connRef v="1000001799"/></connection><connection><identifier v="c"/><connRef v="1000001796"/></connection><connection><identifier v="d"/><connRef v="1000001798"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/temperature_to_rgb_fit"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input"/><type v="0"/></input><input><identifier v="a"/><type v="0"/></input><input><identifier v="b"/><type v="0"/></input><input><identifier v="c"/><type v="0"/></input><input><identifier v="d"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001812"/><function v="instance"/><type v="256"/><GUILayout><gpos v="624 504 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000001792"/></connection><connection><identifier v="a"/><connRef v="1000001804"/></connection><connection><identifier v="b"/><connRef v="1000001805"/></connection><connection><identifier v="c"/><connRef v="1000001807"/></connection><connection><identifier v="d"/><connRef v="1000001806"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/temperature_to_rgb_fit"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input"/><type v="0"/></input><input><identifier v="a"/><type v="0"/></input><input><identifier v="b"/><type v="0"/></input><input><identifier v="c"/><type v="0"/></input><input><identifier v="d"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="temperature_to_rgb_fit"/><uid v="1000001826"/><attributes><category v="Functions/colorValues"/><description v="Evaluates the temperature_to_rgb_fit function graph. Result type: Float. Inputs: input, a, b, c, d."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000001827"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="a"/><uid v="1000001828"/><attributes><label v="a"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="b"/><uid v="1000001829"/><attributes><label v="b"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="c"/><uid v="1000001830"/><attributes><label v="c"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="d"/><uid v="1000001831"/><attributes><label v="d"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001823"/><paramNodes><paramNode><uid v="1000001815"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001816"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="d"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001817"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="b"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001818"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="c"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001819"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="a"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001820"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001818"/></connection><connection><identifier v="b"/><connRef v="1000001825"/></connection></connections></paramNode><paramNode><uid v="1000001821"/><function v="add"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001825"/></connection><connection><identifier v="b"/><connRef v="1000001817"/></connection></connections></paramNode><paramNode><uid v="1000001822"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001819"/></connection><connection><identifier v="b"/><connRef v="1000001817"/></connection></connections></paramNode><paramNode><uid v="1000001823"/><function v="div"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001824"/></connection><connection><identifier v="b"/><connRef v="1000001821"/></connection></connections></paramNode><paramNode><uid v="1000001824"/><function v="add"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001822"/></connection><connection><identifier v="b"/><connRef v="1000001820"/></connection></connections></paramNode><paramNode><uid v="1000001825"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="n"/><connRef v="1000001816"/></connection><connection><identifier v="x"/><connRef v="1000001815"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Pow"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="n"/><type v="0"/></input><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="acescg_to_linear_srgb"/><uid v="1000001840"/><attributes><category v="Functions/colorValues"/><description v="Evaluates the acescg_to_linear_srgb function graph. Result type: Float3. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000001841"/><attributes><label v="input"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000001839"/><paramNodes><paramNode><uid v="1000001832"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001833"/><function v="dot"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001834"/></connection><connection><identifier v="b"/><connRef v="1000001832"/></connection></connections></paramNode><paramNode><uid v="1000001834"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="-0.0241261 -0.124633 1.14882"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001835"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="-0.129553 1.13837 -0.00876801"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001836"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="1.7049 -0.62416 -0.0809141"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001837"/><function v="dot"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001835"/></connection><connection><identifier v="b"/><connRef v="1000001832"/></connection></connections></paramNode><paramNode><uid v="1000001838"/><function v="dot"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001836"/></connection><connection><identifier v="b"/><connRef v="1000001832"/></connection></connections></paramNode><paramNode><uid v="1000001839"/><function v="instance"/><type v="1024"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000001838"/></connection><connection><identifier v="y"/><connRef v="1000001837"/></connection><connection><identifier v="z"/><connRef v="1000001833"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/merge_float3"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input><input><identifier v="y"/><type v="0"/></input><input><identifier v="z"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="linear_srgb_to_acescg"/><uid v="1000001850"/><attributes><category v="Functions/colorValues"/><description v="Evaluates the linear_srgb_to_acescg function graph. Result type: Float3. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000001851"/><attributes><label v="input"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000001848"/><paramNodes><paramNode><uid v="1000001842"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001843"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0.020463 0.106769 0.872716"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001844"/><function v="dot"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001843"/></connection><connection><identifier v="b"/><connRef v="1000001842"/></connection></connections></paramNode><paramNode><uid v="1000001845"/><function v="dot"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001846"/></connection><connection><identifier v="b"/><connRef v="1000001842"/></connection></connections></paramNode><paramNode><uid v="1000001846"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0.0699341 0.918103 0.0119328"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001847"/><function v="dot"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001849"/></connection><connection><identifier v="b"/><connRef v="1000001842"/></connection></connections></paramNode><paramNode><uid v="1000001848"/><function v="instance"/><type v="1024"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000001847"/></connection><connection><identifier v="y"/><connRef v="1000001845"/></connection><connection><identifier v="z"/><connRef v="1000001844"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/merge_float3"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input><input><identifier v="y"/><type v="0"/></input><input><identifier v="z"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001849"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0.613118 0.341182 0.0457873"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="hsl_offset"/><uid v="1000001868"/><attributes><category v="Functions/colorValues"/><description v="Evaluates the hsl_offset function graph. Result type: Float3. Inputs: rgb, hue, saturation, lightness."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="rgb"/><uid v="1000001869"/><attributes><label v="rgb"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="hue"/><uid v="1000001870"/><attributes><label v="hue"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="saturation"/><uid v="1000001871"/><attributes><label v="saturation"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="lightness"/><uid v="1000001872"/><attributes><label v="lightness"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000001860"/><paramNodes><paramNode><uid v="1000001852"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="rgb"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001853"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001865"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001854"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="hue"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001855"/><function v="add"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001854"/></connection><connection><identifier v="b"/><connRef v="1000001853"/></connection></connections></paramNode><paramNode><uid v="1000001856"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001865"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001857"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="saturation"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001858"/><function v="add"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001857"/></connection><connection><identifier v="b"/><connRef v="1000001856"/></connection></connections></paramNode><paramNode><uid v="1000001859"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001866"/></connection><connection><identifier v="componentslast"/><connRef v="1000001858"/></connection></connections></paramNode><paramNode><uid v="1000001860"/><function v="instance"/><type v="1024"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="HSL"/><connRef v="1000001861"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/HSLtoRGB"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="HSL"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001861"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001859"/></connection><connection><identifier v="componentslast"/><connRef v="1000001864"/></connection></connections></paramNode><paramNode><uid v="1000001862"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001865"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001863"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="lightness"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001864"/><function v="add"/><type v="256"/><GUILayout><gpos v="904 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001863"/></connection><connection><identifier v="b"/><connRef v="1000001862"/></connection></connections></paramNode><paramNode><uid v="1000001865"/><function v="instance"/><type v="1024"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="RGB"/><connRef v="1000001852"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGBtoHSL"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="RGB"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001866"/><function v="mod"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001855"/></connection><connection><identifier v="b"/><connRef v="1000001867"/></connection></connections></paramNode><paramNode><uid v="1000001867"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="typeConverters"/><uid v="1000001873"/><content><function><identifier v="booleanToFloat1"/><uid v="1000001878"/><attributes><category v="Functions/typeConverters"/><description v="Evaluates the booleanToFloat1 function graph. Result type: Float. Inputs: Boolean."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="Boolean"/><uid v="1000001879"/><attributes><label v="Boolean"/></attributes><type v="4"/><defaultValue><constantValueBool v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001877"/><paramNodes><paramNode><uid v="1000001874"/><function v="get_bool"/><type v="4"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_bool"/><constantValue><constantValueString v="Boolean"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001875"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001876"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001877"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001874"/></connection><connection><identifier v="ifpath"/><connRef v="1000001876"/></connection><connection><identifier v="elsepath"/><connRef v="1000001875"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="turnsToDegrees"/><uid v="1000001883"/><attributes><category v="Functions/typeConverters"/><description v="Evaluates the turnsToDegrees function graph. Result type: Float. Inputs: turns."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="turns"/><uid v="1000001884"/><attributes><label v="turns"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001882"/><paramNodes><paramNode><uid v="1000001880"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="turns"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001881"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="360"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001882"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001880"/></connection><connection><identifier v="b"/><connRef v="1000001881"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="Ranges"/><uid v="1000001885"/><content><function><identifier v="[-1_1]_to_[0_1]"/><uid v="1000001891"/><attributes><category v="Functions/Ranges"/><description v="Evaluates the [-1_1]_to_[0_1] function graph. Result type: Float. Inputs: Input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="Input"/><uid v="1000001892"/><attributes><label v="Input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001890"/><paramNodes><paramNode><uid v="1000001886"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="Input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001887"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001888"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001889"/><function v="add"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001886"/></connection><connection><identifier v="b"/><connRef v="1000001887"/></connection></connections></paramNode><paramNode><uid v="1000001890"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001889"/></connection><connection><identifier v="b"/><connRef v="1000001888"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="[0_1]_to_[-1_1]"/><uid v="1000001898"/><attributes><category v="Functions/Ranges"/><description v="Evaluates the [0_1]_to_[-1_1] function graph. Result type: Float. Inputs: Input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="Input"/><uid v="1000001899"/><attributes><label v="Input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001897"/><paramNodes><paramNode><uid v="1000001893"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="Input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001894"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001895"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001896"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001893"/></connection><connection><identifier v="b"/><connRef v="1000001895"/></connection></connections></paramNode><paramNode><uid v="1000001897"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001896"/></connection><connection><identifier v="b"/><connRef v="1000001894"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="[0_1]_to_[1_0]"/><uid v="1000001905"/><attributes><category v="Functions/Ranges"/><description v="Evaluates the [0_1]_to_[1_0] function graph. Result type: Float. Inputs: Input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="Input"/><uid v="1000001906"/><attributes><label v="Input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001904"/><paramNodes><paramNode><uid v="1000001900"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="Input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001901"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001902"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="-1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001903"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001900"/></connection><connection><identifier v="b"/><connRef v="1000001902"/></connection></connections></paramNode><paramNode><uid v="1000001904"/><function v="add"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001903"/></connection><connection><identifier v="b"/><connRef v="1000001901"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="negateFloat"/><uid v="1000001910"/><attributes><category v="Functions/Ranges"/><description v="Evaluates the negateFloat function graph. Result type: Float. Inputs: Input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="Input"/><uid v="1000001911"/><attributes><label v="Input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001909"/><paramNodes><paramNode><uid v="1000001907"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="Input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001908"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="-1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001909"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001907"/></connection><connection><identifier v="b"/><connRef v="1000001908"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="Height_Balance_Fn"/><uid v="1000001928"/><attributes><category v="Functions/Ranges"/><description v="Evaluates the Height_Balance_Fn function graph. Result type: Float4. Inputs: Depth_Balance."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="Depth_Balance"/><uid v="1000001929"/><attributes><label v="Depth_Balance"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-1"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="2048"/><paramValue><dynamicValue><rootnode v="1000001916"/><paramNodes><paramNode><uid v="1000001912"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="Depth_Balance"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001913"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001914"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001915"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001924"/></connection><connection><identifier v="componentslast"/><connRef v="1000001925"/></connection></connections></paramNode><paramNode><uid v="1000001916"/><function v="vector4"/><type v="2048"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001915"/></connection><connection><identifier v="componentslast"/><connRef v="1000001919"/></connection></connections></paramNode><paramNode><uid v="1000001917"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001918"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001919"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001927"/></connection><connection><identifier v="componentslast"/><connRef v="1000001926"/></connection></connections></paramNode><paramNode><uid v="1000001920"/><function v="add"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001913"/></connection><connection><identifier v="b"/><connRef v="1000001912"/></connection></connections></paramNode><paramNode><uid v="1000001921"/><function v="sub"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001918"/></connection><connection><identifier v="b"/><connRef v="1000001912"/></connection></connections></paramNode><paramNode><uid v="1000001922"/><function v="add"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001914"/></connection><connection><identifier v="b"/><connRef v="1000001912"/></connection></connections></paramNode><paramNode><uid v="1000001923"/><function v="sub"/><type v="256"/><GUILayout><gpos v="344 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001917"/></connection><connection><identifier v="b"/><connRef v="1000001912"/></connection></connections></paramNode><paramNode><uid v="1000001924"/><function v="max"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001922"/></connection><connection><identifier v="b"/><connRef v="1000001914"/></connection></connections></paramNode><paramNode><uid v="1000001925"/><function v="min"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001920"/></connection><connection><identifier v="b"/><connRef v="1000001913"/></connection></connections></paramNode><paramNode><uid v="1000001926"/><function v="min"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001923"/></connection><connection><identifier v="b"/><connRef v="1000001917"/></connection></connections></paramNode><paramNode><uid v="1000001927"/><function v="max"/><type v="256"/><GUILayout><gpos v="624 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001921"/></connection><connection><identifier v="b"/><connRef v="1000001918"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="[0,1]_to_[0,1,0]"/><uid v="1000001937"/><attributes><category v="Functions/Ranges"/><description v="Evaluates the [0,1]_to_[0,1,0] function graph. Result type: Float. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000001938"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001936"/><paramNodes><paramNode><uid v="1000001930"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001931"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001930"/></connection><connection><identifier v="b"/><connRef v="1000001932"/></connection></connections></paramNode><paramNode><uid v="1000001932"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001933"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001931"/></connection><connection><identifier v="b"/><connRef v="1000001934"/></connection></connections></paramNode><paramNode><uid v="1000001934"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001935"/><function v="abs"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001933"/></connection></connections></paramNode><paramNode><uid v="1000001936"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001934"/></connection><connection><identifier v="b"/><connRef v="1000001935"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="[a,b]_to_[0,1]"/><uid v="1000001948"/><attributes><category v="Functions/Ranges"/><description v="Evaluates the [a,b]_to_[0,1] function graph. Result type: Float. Inputs: X, A, B."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="X"/><uid v="1000001949"/><attributes><label v="X"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="A"/><uid v="1000001950"/><attributes><label v="A"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="B"/><uid v="1000001951"/><attributes><label v="B"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001945"/><paramNodes><paramNode><uid v="1000001939"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="X"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001940"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001944"/></connection><connection><identifier v="b"/><connRef v="1000001941"/></connection></connections></paramNode><paramNode><uid v="1000001941"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="A"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001942"/><function v="div"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001940"/></connection><connection><identifier v="b"/><connRef v="1000001947"/></connection></connections></paramNode><paramNode><uid v="1000001943"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="B"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001944"/><function v="max"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001939"/></connection><connection><identifier v="b"/><connRef v="1000001941"/></connection></connections></paramNode><paramNode><uid v="1000001945"/><function v="min"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001946"/></connection><connection><identifier v="b"/><connRef v="1000001942"/></connection></connections></paramNode><paramNode><uid v="1000001946"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001947"/><function v="sub"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001943"/></connection><connection><identifier v="b"/><connRef v="1000001941"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="triangle_wave"/><uid v="1000001959"/><attributes><category v="Functions/Ranges"/><description v="Evaluates the triangle_wave function graph. Result type: Float. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000001960"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001957"/><paramNodes><paramNode><uid v="1000001952"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001953"/><function v="mod"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001952"/></connection><connection><identifier v="b"/><connRef v="1000001954"/></connection></connections></paramNode><paramNode><uid v="1000001954"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001955"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001953"/></connection><connection><identifier v="b"/><connRef v="1000001956"/></connection></connections></paramNode><paramNode><uid v="1000001956"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001957"/><function v="instance"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000001958"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001958"/><function v="abs"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001955"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="sawtooth_wave"/><uid v="1000001972"/><attributes><category v="Functions/Ranges"/><description v="Evaluates the sawtooth_wave function graph. Result type: Float. Inputs: x."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="x"/><uid v="1000001973"/><attributes><label v="x"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001964"/><paramNodes><paramNode><uid v="1000001961"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="x"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001962"/><function v="mod"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001961"/></connection><connection><identifier v="b"/><connRef v="1000001963"/></connection></connections></paramNode><paramNode><uid v="1000001963"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001964"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001967"/></connection><connection><identifier v="ifpath"/><connRef v="1000001969"/></connection><connection><identifier v="elsepath"/><connRef v="1000001962"/></connection></connections></paramNode><paramNode><uid v="1000001965"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001966"/><function v="gt"/><type v="4"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001971"/></connection><connection><identifier v="b"/><connRef v="1000001965"/></connection></connections></paramNode><paramNode><uid v="1000001967"/><function v="eq"/><type v="4"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001962"/></connection><connection><identifier v="b"/><connRef v="1000001968"/></connection></connections></paramNode><paramNode><uid v="1000001968"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001969"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001966"/></connection><connection><identifier v="ifpath"/><connRef v="1000001970"/></connection><connection><identifier v="elsepath"/><connRef v="1000001971"/></connection></connections></paramNode><paramNode><uid v="1000001970"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001971"/><function v="abs"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001961"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="Cycles"/><uid v="1000001974"/><content><function><identifier v="Wave"/><uid v="1000001984"/><attributes><category v="Functions/Cycles"/><description v="Evaluates the Wave function graph. Result type: Float. Inputs: Amplitude, Frequency, greaterThanZero."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="Amplitude"/><uid v="1000001985"/><attributes><label v="Amplitude"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="Frequency"/><uid v="1000001986"/><attributes><label v="Frequency"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="greaterThanZero"/><uid v="1000001987"/><attributes><label v="greaterThanZero"/></attributes><type v="4"/><defaultValue><constantValueBool v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001981"/><paramNodes><paramNode><uid v="1000001975"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="$time"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001976"/><function v="sin"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001979"/></connection></connections></paramNode><paramNode><uid v="1000001977"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="Amplitude"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001978"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="Frequency"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001979"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001978"/></connection><connection><identifier v="b"/><connRef v="1000001975"/></connection></connections></paramNode><paramNode><uid v="1000001980"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001977"/></connection><connection><identifier v="b"/><connRef v="1000001976"/></connection></connections></paramNode><paramNode><uid v="1000001981"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001983"/></connection><connection><identifier v="ifpath"/><connRef v="1000001982"/></connection><connection><identifier v="elsepath"/><connRef v="1000001980"/></connection></connections></paramNode><paramNode><uid v="1000001982"/><function v="add"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001977"/></connection><connection><identifier v="b"/><connRef v="1000001980"/></connection></connections></paramNode><paramNode><uid v="1000001983"/><function v="get_bool"/><type v="4"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_bool"/><constantValue><constantValueString v="greaterThanZero"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="Transforms"/><uid v="1000001988"/><content><function><identifier v="Directional_Offset"/><uid v="1000001998"/><attributes><category v="Functions/Transforms"/><description v="Evaluates the Directional_Offset function graph. Result type: Float2. Inputs: Direction, Distance."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="Direction"/><uid v="1000001999"/><attributes><label v="Direction"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="360"/></option></options></defaultWidget></paraminput><paraminput><identifier v="Distance"/><uid v="1000002000"/><attributes><label v="Distance"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="512"/><paramValue><dynamicValue><rootnode v="1000001991"/><paramNodes><paramNode><uid v="1000001989"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001993"/></connection><connection><identifier v="b"/><connRef v="1000001995"/></connection></connections></paramNode><paramNode><uid v="1000001990"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="Direction"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001991"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001989"/></connection><connection><identifier v="componentslast"/><connRef v="1000001992"/></connection></connections></paramNode><paramNode><uid v="1000001992"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001994"/></connection><connection><identifier v="b"/><connRef v="1000001995"/></connection></connections></paramNode><paramNode><uid v="1000001993"/><function v="cos"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001997"/></connection></connections></paramNode><paramNode><uid v="1000001994"/><function v="sin"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001997"/></connection></connections></paramNode><paramNode><uid v="1000001995"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="Distance"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001996"/><function v="instance"/><type v="118772"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="turns"/><connRef v="1000001990"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/typeConverters/turnsToDegrees"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="turns"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001997"/><function v="instance"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="deg"/><connRef v="1000001996"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Trigo/deg_to_rad"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="deg"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="MatrixMultiply"/><uid v="1000002026"/><attributes><category v="Functions/Transforms"/><description v="Evaluates the MatrixMultiply function graph. Result type: Float4. Inputs: MatrixA, MatrixB."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="MatrixA"/><uid v="1000002027"/><attributes><label v="MatrixA"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 0 0 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="MatrixB"/><uid v="1000002028"/><attributes><label v="MatrixB"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 0 0 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="2048"/><paramValue><dynamicValue><rootnode v="1000002020"/><paramNodes><paramNode><uid v="1000002001"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002012"/></connection><connection><identifier v="componentslast"/><connRef v="1000002021"/></connection></connections></paramNode><paramNode><uid v="1000002002"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002025"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002003"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002024"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002004"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002003"/></connection><connection><identifier v="b"/><connRef v="1000002002"/></connection></connections></paramNode><paramNode><uid v="1000002005"/><function v="add"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002010"/></connection><connection><identifier v="b"/><connRef v="1000002006"/></connection></connections></paramNode><paramNode><uid v="1000002006"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002014"/></connection><connection><identifier v="b"/><connRef v="1000002019"/></connection></connections></paramNode><paramNode><uid v="1000002007"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002014"/></connection><connection><identifier v="b"/><connRef v="1000002008"/></connection></connections></paramNode><paramNode><uid v="1000002008"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002025"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002009"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002023"/></connection><connection><identifier v="b"/><connRef v="1000002008"/></connection></connections></paramNode><paramNode><uid v="1000002010"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 704 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002017"/></connection><connection><identifier v="b"/><connRef v="1000002022"/></connection></connections></paramNode><paramNode><uid v="1000002011"/><function v="add"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002015"/></connection><connection><identifier v="b"/><connRef v="1000002007"/></connection></connections></paramNode><paramNode><uid v="1000002012"/><function v="add"/><type v="256"/><GUILayout><gpos v="904 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002004"/></connection><connection><identifier v="b"/><connRef v="1000002009"/></connection></connections></paramNode><paramNode><uid v="1000002013"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 864 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002003"/></connection><connection><identifier v="b"/><connRef v="1000002022"/></connection></connections></paramNode><paramNode><uid v="1000002014"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 544 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002024"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002015"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 1024 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002017"/></connection><connection><identifier v="b"/><connRef v="1000002002"/></connection></connections></paramNode><paramNode><uid v="1000002016"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002011"/></connection><connection><identifier v="componentslast"/><connRef v="1000002005"/></connection></connections></paramNode><paramNode><uid v="1000002017"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 704 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002024"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002018"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 1184 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002023"/></connection><connection><identifier v="b"/><connRef v="1000002019"/></connection></connections></paramNode><paramNode><uid v="1000002019"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 864 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002025"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002020"/><function v="vector4"/><type v="2048"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002016"/></connection><connection><identifier v="componentslast"/><connRef v="1000002001"/></connection></connections></paramNode><paramNode><uid v="1000002021"/><function v="add"/><type v="256"/><GUILayout><gpos v="904 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002013"/></connection><connection><identifier v="b"/><connRef v="1000002018"/></connection></connections></paramNode><paramNode><uid v="1000002022"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 1024 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002025"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002023"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 1184 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002024"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002024"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="MatrixA"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002025"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="MatrixB"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="RotationMatrix"/><uid v="1000002039"/><attributes><category v="Functions/Transforms"/><description v="Evaluates the RotationMatrix function graph. Result type: Float4. Inputs: RotationW."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="RotationW"/><uid v="1000002040"/><attributes><label v="RotationW"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-360"/></option><option><name v="max"/><value v="360"/></option></options></defaultWidget></paraminput></paraminputs><type v="2048"/><paramValue><dynamicValue><rootnode v="1000002033"/><paramNodes><paramNode><uid v="1000002029"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002035"/></connection><connection><identifier v="b"/><connRef v="1000002030"/></connection></connections></paramNode><paramNode><uid v="1000002030"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="-1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002031"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002035"/></connection><connection><identifier v="componentslast"/><connRef v="1000002032"/></connection></connections></paramNode><paramNode><uid v="1000002032"/><function v="cos"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002038"/></connection></connections></paramNode><paramNode><uid v="1000002033"/><function v="vector4"/><type v="2048"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002034"/></connection><connection><identifier v="componentslast"/><connRef v="1000002031"/></connection></connections></paramNode><paramNode><uid v="1000002034"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002032"/></connection><connection><identifier v="componentslast"/><connRef v="1000002029"/></connection></connections></paramNode><paramNode><uid v="1000002035"/><function v="sin"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002038"/></connection></connections></paramNode><paramNode><uid v="1000002036"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="RotationW"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002037"/><function v="instance"/><type v="118772"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="turns"/><connRef v="1000002036"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/typeConverters/turnsToDegrees"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="turns"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000002038"/><function v="instance"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="deg"/><connRef v="1000002037"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Trigo/deg_to_rad"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="deg"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="ScaleMatrix"/><uid v="1000002051"/><attributes><category v="Functions/Transforms"/><description v="Evaluates the ScaleMatrix function graph. Result type: Float4. Inputs: ScaleUV."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="ScaleUV"/><uid v="1000002052"/><attributes><label v="ScaleUV"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="100 100"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="2048"/><paramValue><dynamicValue><rootnode v="1000002048"/><paramNodes><paramNode><uid v="1000002041"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002042"/></connection><connection><identifier v="b"/><connRef v="1000002044"/></connection></connections></paramNode><paramNode><uid v="1000002042"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="100"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002043"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002050"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002044"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002050"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002045"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002042"/></connection><connection><identifier v="b"/><connRef v="1000002043"/></connection></connections></paramNode><paramNode><uid v="1000002046"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002049"/></connection><connection><identifier v="componentslast"/><connRef v="1000002041"/></connection></connections></paramNode><paramNode><uid v="1000002047"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002045"/></connection><connection><identifier v="componentslast"/><connRef v="1000002049"/></connection></connections></paramNode><paramNode><uid v="1000002048"/><function v="vector4"/><type v="2048"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002047"/></connection><connection><identifier v="componentslast"/><connRef v="1000002046"/></connection></connections></paramNode><paramNode><uid v="1000002049"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002050"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="ScaleUV"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="TileMatrix"/><uid v="1000002060"/><attributes><category v="Functions/Transforms"/><description v="Evaluates the TileMatrix function graph. Result type: Float4. Inputs: tiles_xy."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="tiles_xy"/><uid v="1000002061"/><attributes><label v="Tiles X/Y"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="100 100"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="2048"/><paramValue><dynamicValue><rootnode v="1000002056"/><paramNodes><paramNode><uid v="1000002053"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002058"/></connection><connection><identifier v="componentslast"/><connRef v="1000002054"/></connection></connections></paramNode><paramNode><uid v="1000002054"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002059"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002055"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002057"/></connection><connection><identifier v="componentslast"/><connRef v="1000002058"/></connection></connections></paramNode><paramNode><uid v="1000002056"/><function v="vector4"/><type v="2048"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002055"/></connection><connection><identifier v="componentslast"/><connRef v="1000002053"/></connection></connections></paramNode><paramNode><uid v="1000002057"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002059"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002058"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002059"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="tiles_xy"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="rotate_vec2"/><uid v="1000002079"/><attributes><category v="Functions/Transforms"/><description v="Evaluates the rotate_vec2 function graph. Result type: Float2. Inputs: vec2, angle, pivot."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="vec2"/><uid v="1000002080"/><attributes><label v="vec2"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="angle"/><uid v="1000002081"/><attributes><label v="angle"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="pivot"/><uid v="1000002082"/><attributes><label v="pivot"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="512"/><paramValue><dynamicValue><rootnode v="1000002077"/><paramNodes><paramNode><uid v="1000002062"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="angle"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002063"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002067"/></connection><connection><identifier v="componentslast"/><connRef v="1000002064"/></connection></connections></paramNode><paramNode><uid v="1000002064"/><function v="dot"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002075"/></connection><connection><identifier v="b"/><connRef v="1000002071"/></connection></connections></paramNode><paramNode><uid v="1000002065"/><function v="neg"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002066"/></connection></connections></paramNode><paramNode><uid v="1000002066"/><function v="sin"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002072"/></connection></connections></paramNode><paramNode><uid v="1000002067"/><function v="dot"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002075"/></connection><connection><identifier v="b"/><connRef v="1000002068"/></connection></connections></paramNode><paramNode><uid v="1000002068"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002069"/></connection><connection><identifier v="componentslast"/><connRef v="1000002066"/></connection></connections></paramNode><paramNode><uid v="1000002069"/><function v="cos"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002072"/></connection></connections></paramNode><paramNode><uid v="1000002070"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002071"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1464 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002065"/></connection><connection><identifier v="componentslast"/><connRef v="1000002069"/></connection></connections></paramNode><paramNode><uid v="1000002072"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002073"/></connection><connection><identifier v="b"/><connRef v="1000002078"/></connection></connections></paramNode><paramNode><uid v="1000002073"/><function v="add"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002070"/></connection><connection><identifier v="b"/><connRef v="1000002062"/></connection></connections></paramNode><paramNode><uid v="1000002074"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="vec2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002075"/><function v="sub"/><type v="512"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002074"/></connection><connection><identifier v="b"/><connRef v="1000002076"/></connection></connections></paramNode><paramNode><uid v="1000002076"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="pivot"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002077"/><function v="add"/><type v="512"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002063"/></connection><connection><identifier v="b"/><connRef v="1000002076"/></connection></connections></paramNode><paramNode><uid v="1000002078"/><function v="instance"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/2Pi"/></constantValue></funcData></funcDatas><materialcraftInterface></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="rotate_vec2_rad"/><uid v="1000002093"/><attributes><category v="Functions/Transforms"/><description v="Evaluates the rotate_vec2_rad function graph. Result type: Float2. Inputs: vec2, angle."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="vec2"/><uid v="1000002094"/><attributes><label v="vec2"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="angle"/><uid v="1000002095"/><attributes><label v="angle"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="512"/><paramValue><dynamicValue><rootnode v="1000002084"/><paramNodes><paramNode><uid v="1000002083"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="angle"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002084"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002088"/></connection><connection><identifier v="componentslast"/><connRef v="1000002085"/></connection></connections></paramNode><paramNode><uid v="1000002085"/><function v="dot"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002092"/></connection><connection><identifier v="b"/><connRef v="1000002091"/></connection></connections></paramNode><paramNode><uid v="1000002086"/><function v="neg"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002087"/></connection></connections></paramNode><paramNode><uid v="1000002087"/><function v="sin"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002083"/></connection></connections></paramNode><paramNode><uid v="1000002088"/><function v="dot"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002092"/></connection><connection><identifier v="b"/><connRef v="1000002089"/></connection></connections></paramNode><paramNode><uid v="1000002089"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002090"/></connection><connection><identifier v="componentslast"/><connRef v="1000002087"/></connection></connections></paramNode><paramNode><uid v="1000002090"/><function v="cos"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002083"/></connection></connections></paramNode><paramNode><uid v="1000002091"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002086"/></connection><connection><identifier v="componentslast"/><connRef v="1000002090"/></connection></connections></paramNode><paramNode><uid v="1000002092"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="vec2"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="matrix_invert"/><uid v="1000002109"/><attributes><category v="Functions/Transforms"/><description v="Evaluates the matrix_invert function graph. Result type: Float4. Inputs: matrix22."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="matrix22"/><uid v="1000002110"/><attributes><label v="matrix22"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="2048"/><paramValue><dynamicValue><rootnode v="1000002107"/><paramNodes><paramNode><uid v="1000002096"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002104"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002097"/><function v="swizzle2"/><type v="512"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002103"/></connection></connections><funcDatas><funcData><name v="swizzle2"/><constantValue><constantValueInt2 v="0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002098"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002104"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002099"/><function v="swizzle2"/><type v="512"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002103"/></connection></connections><funcDatas><funcData><name v="swizzle2"/><constantValue><constantValueInt2 v="3 2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002100"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002101"/><function v="swizzle4"/><type v="2048"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002103"/></connection></connections><funcDatas><funcData><name v="swizzle4"/><constantValue><constantValueInt4 v="3 1 2 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002102"/><function v="mulscalar"/><type v="2048"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002101"/></connection><connection><identifier v="scalar"/><connRef v="1000002105"/></connection></connections></paramNode><paramNode><uid v="1000002103"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="matrix22"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002104"/><function v="mul"/><type v="512"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002097"/></connection><connection><identifier v="b"/><connRef v="1000002099"/></connection></connections></paramNode><paramNode><uid v="1000002105"/><function v="div"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002100"/></connection><connection><identifier v="b"/><connRef v="1000002106"/></connection></connections></paramNode><paramNode><uid v="1000002106"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002096"/></connection><connection><identifier v="b"/><connRef v="1000002098"/></connection></connections></paramNode><paramNode><uid v="1000002107"/><function v="mul"/><type v="2048"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002108"/></connection><connection><identifier v="b"/><connRef v="1000002102"/></connection></connections></paramNode><paramNode><uid v="1000002108"/><function v="const_float4"/><type v="2048"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float4"/><constantValue><constantValueFloat4 v="1 -1 -1 1"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="polar_to_carthesian"/><uid v="1000002129"/><attributes><category v="Functions/Transforms"/><description v="Evaluates the polar_to_carthesian function graph. Result type: Float3. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000002130"/><attributes><label v="input"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000002125"/><paramNodes><paramNode><uid v="1000002111"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002123"/></connection><connection><identifier v="b"/><connRef v="1000002112"/></connection></connections></paramNode><paramNode><uid v="1000002112"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002126"/></connection><connection><identifier v="b"/><connRef v="1000002127"/></connection></connections></paramNode><paramNode><uid v="1000002113"/><function v="mulscalar"/><type v="512"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002118"/></connection><connection><identifier v="scalar"/><connRef v="1000002120"/></connection></connections></paramNode><paramNode><uid v="1000002114"/><function v="sin"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002111"/></connection></connections></paramNode><paramNode><uid v="1000002115"/><function v="sin"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002124"/></connection></connections></paramNode><paramNode><uid v="1000002116"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002119"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002117"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002118"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002122"/></connection><connection><identifier v="componentslast"/><connRef v="1000002115"/></connection></connections></paramNode><paramNode><uid v="1000002119"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002120"/><function v="cos"/><type v="256"/><GUILayout><gpos v="1184 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002111"/></connection></connections></paramNode><paramNode><uid v="1000002121"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002117"/></connection><connection><identifier v="b"/><connRef v="1000002123"/></connection></connections></paramNode><paramNode><uid v="1000002122"/><function v="cos"/><type v="256"/><GUILayout><gpos v="904 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002124"/></connection></connections></paramNode><paramNode><uid v="1000002123"/><function v="instance"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Pi"/></constantValue></funcData></funcDatas><materialcraftInterface></materialcraftInterface></paramNode><paramNode><uid v="1000002124"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002116"/></connection><connection><identifier v="b"/><connRef v="1000002121"/></connection></connections></paramNode><paramNode><uid v="1000002125"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002113"/></connection><connection><identifier v="componentslast"/><connRef v="1000002128"/></connection></connections></paramNode><paramNode><uid v="1000002126"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002119"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002127"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002128"/><function v="neg"/><type v="256"/><GUILayout><gpos v="1464 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002114"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="carthesian_to_polar"/><uid v="1000002151"/><attributes><category v="Functions/Transforms"/><description v="Evaluates the carthesian_to_polar function graph. Result type: Float2. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000002152"/><attributes><label v="input"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="512"/><paramValue><dynamicValue><rootnode v="1000002136"/><paramNodes><paramNode><uid v="1000002131"/><function v="atan2"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002142"/></connection></connections></paramNode><paramNode><uid v="1000002132"/><function v="instance"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Pi"/></constantValue></funcData></funcDatas><materialcraftInterface></materialcraftInterface></paramNode><paramNode><uid v="1000002133"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002145"/></connection><connection><identifier v="componentslast"/><connRef v="1000002146"/></connection></connections></paramNode><paramNode><uid v="1000002134"/><function v="div"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002131"/></connection><connection><identifier v="b"/><connRef v="1000002132"/></connection></connections></paramNode><paramNode><uid v="1000002135"/><function v="instance"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/2Pi"/></constantValue></funcData></funcDatas><materialcraftInterface></materialcraftInterface></paramNode><paramNode><uid v="1000002136"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2864 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002148"/></connection><connection><identifier v="componentslast"/><connRef v="1000002150"/></connection></connections></paramNode><paramNode><uid v="1000002137"/><function v="atan2"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002133"/></connection></connections></paramNode><paramNode><uid v="1000002138"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002139"/><function v="div"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002137"/></connection><connection><identifier v="b"/><connRef v="1000002135"/></connection></connections></paramNode><paramNode><uid v="1000002140"/><function v="add"/><type v="256"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002134"/></connection><connection><identifier v="b"/><connRef v="1000002138"/></connection></connections></paramNode><paramNode><uid v="1000002141"/><function v="dot"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002133"/></connection><connection><identifier v="b"/><connRef v="1000002133"/></connection></connections></paramNode><paramNode><uid v="1000002142"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002143"/></connection><connection><identifier v="componentslast"/><connRef v="1000002147"/></connection></connections></paramNode><paramNode><uid v="1000002143"/><function v="sqrt"/><type v="256"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002141"/></connection></connections></paramNode><paramNode><uid v="1000002144"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002145"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002144"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002146"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002144"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002147"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002144"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002148"/><function v="mod"/><type v="256"/><GUILayout><gpos v="1464 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002139"/></connection><connection><identifier v="b"/><connRef v="1000002149"/></connection></connections></paramNode><paramNode><uid v="1000002149"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002150"/><function v="instance"/><type v="256"/><GUILayout><gpos v="2584 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000002140"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="Random"/><uid v="1000002153"/><content><function><identifier v="Uniform_[A,B["/><uid v="1000002159"/><attributes><category v="Functions/Random"/><description v="Evaluates the Uniform_[A,B[ function graph. Result type: Float. Inputs: A, B."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="A"/><uid v="1000002160"/><attributes><label v="A"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput><paraminput><identifier v="B"/><uid v="1000002161"/><attributes><label v="B"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002155"/><paramNodes><paramNode><uid v="1000002154"/><function v="rand"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002156"/></connection></connections></paramNode><paramNode><uid v="1000002155"/><function v="add"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002154"/></connection><connection><identifier v="b"/><connRef v="1000002157"/></connection></connections></paramNode><paramNode><uid v="1000002156"/><function v="sub"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002158"/></connection><connection><identifier v="b"/><connRef v="1000002157"/></connection></connections></paramNode><paramNode><uid v="1000002157"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="A"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002158"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="B"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="Discrete_[A,B]"/><uid v="1000002169"/><attributes><category v="Functions/Random"/><description v="Evaluates the Discrete_[A,B] function graph. Result type: Float. Inputs: A, B, Probability."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="A"/><uid v="1000002170"/><attributes><label v="A"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput><paraminput><identifier v="B"/><uid v="1000002171"/><attributes><label v="B"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput><paraminput><identifier v="Probability"/><uid v="1000002172"/><attributes><label v="Probability"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0.5"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002166"/><paramNodes><paramNode><uid v="1000002162"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="A"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002163"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="B"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002164"/><function v="rand"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002168"/></connection></connections></paramNode><paramNode><uid v="1000002165"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="Probability"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002166"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000002167"/></connection><connection><identifier v="ifpath"/><connRef v="1000002162"/></connection><connection><identifier v="elsepath"/><connRef v="1000002163"/></connection></connections></paramNode><paramNode><uid v="1000002167"/><function v="gteq"/><type v="4"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002164"/></connection><connection><identifier v="b"/><connRef v="1000002165"/></connection></connections></paramNode><paramNode><uid v="1000002168"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="Uniform_[-1,1["/><uid v="1000002177"/><attributes><category v="Functions/Random"/><description v="Evaluates the Uniform_[-1,1[ function graph. Result type: Float. Inputs: none."/><author v=""/><tags v=""/></attributes><paraminputs></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002175"/><paramNodes><paramNode><uid v="1000002173"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002174"/><function v="rand"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002173"/></connection></connections></paramNode><paramNode><uid v="1000002175"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002174"/></connection><connection><identifier v="b"/><connRef v="1000002176"/></connection></connections></paramNode><paramNode><uid v="1000002176"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="Uniform_F2_[A,B["/><uid v="1000002187"/><attributes><category v="Functions/Random"/><description v="Evaluates the Uniform_F2_[A,B[ function graph. Result type: Float2. Inputs: A2, B2."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="A2"/><uid v="1000002188"/><attributes><label v="A2"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput><paraminput><identifier v="B2"/><uid v="1000002189"/><attributes><label v="B2"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput></paraminputs><type v="512"/><paramValue><dynamicValue><rootnode v="1000002186"/><paramNodes><paramNode><uid v="1000002178"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="A2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002179"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="B2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002180"/><function v="sub"/><type v="512"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002179"/></connection><connection><identifier v="b"/><connRef v="1000002178"/></connection></connections></paramNode><paramNode><uid v="1000002181"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002180"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002182"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002180"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002183"/><function v="rand"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002181"/></connection></connections></paramNode><paramNode><uid v="1000002184"/><function v="rand"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002182"/></connection></connections></paramNode><paramNode><uid v="1000002185"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002183"/></connection><connection><identifier v="componentslast"/><connRef v="1000002184"/></connection></connections></paramNode><paramNode><uid v="1000002186"/><function v="add"/><type v="512"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002185"/></connection><connection><identifier v="b"/><connRef v="1000002178"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="Uniform_F3_[A,B["/><uid v="1000002202"/><attributes><category v="Functions/Random"/><description v="Evaluates the Uniform_F3_[A,B[ function graph. Result type: Float3. Inputs: A, B."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="A"/><uid v="1000002203"/><attributes><label v="A"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="0 0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput><paraminput><identifier v="B"/><uid v="1000002204"/><attributes><label v="B"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000002201"/><paramNodes><paramNode><uid v="1000002190"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="A"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002191"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="B"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002192"/><function v="sub"/><type v="1024"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002191"/></connection><connection><identifier v="b"/><connRef v="1000002190"/></connection></connections></paramNode><paramNode><uid v="1000002193"/><function v="rand"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002194"/></connection></connections></paramNode><paramNode><uid v="1000002194"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002192"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002195"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002192"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002196"/><function v="rand"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002195"/></connection></connections></paramNode><paramNode><uid v="1000002197"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002192"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002198"/><function v="rand"/><type v="256"/><GUILayout><gpos v="904 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002197"/></connection></connections></paramNode><paramNode><uid v="1000002199"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002200"/></connection><connection><identifier v="componentslast"/><connRef v="1000002198"/></connection></connections></paramNode><paramNode><uid v="1000002200"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002193"/></connection><connection><identifier v="componentslast"/><connRef v="1000002196"/></connection></connections></paramNode><paramNode><uid v="1000002201"/><function v="add"/><type v="1024"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002199"/></connection><connection><identifier v="b"/><connRef v="1000002190"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="Uniform_F4_[A,B["/><uid v="1000002220"/><attributes><category v="Functions/Random"/><description v="Evaluates the Uniform_F4_[A,B[ function graph. Result type: Float4. Inputs: A, B."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="A"/><uid v="1000002221"/><attributes><label v="A"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="0 0 0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput><paraminput><identifier v="B"/><uid v="1000002222"/><attributes><label v="B"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput></paraminputs><type v="2048"/><paramValue><dynamicValue><rootnode v="1000002219"/><paramNodes><paramNode><uid v="1000002205"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="A"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002206"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="B"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002207"/><function v="sub"/><type v="2048"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002206"/></connection><connection><identifier v="b"/><connRef v="1000002205"/></connection></connections></paramNode><paramNode><uid v="1000002208"/><function v="rand"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002209"/></connection></connections></paramNode><paramNode><uid v="1000002209"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002207"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002210"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002207"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002211"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002207"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002212"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="624 544 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002207"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002213"/><function v="rand"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002210"/></connection></connections></paramNode><paramNode><uid v="1000002214"/><function v="rand"/><type v="256"/><GUILayout><gpos v="904 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002211"/></connection></connections></paramNode><paramNode><uid v="1000002215"/><function v="rand"/><type v="256"/><GUILayout><gpos v="904 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002212"/></connection></connections></paramNode><paramNode><uid v="1000002216"/><function v="vector4"/><type v="2048"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002217"/></connection><connection><identifier v="componentslast"/><connRef v="1000002218"/></connection></connections></paramNode><paramNode><uid v="1000002217"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002208"/></connection><connection><identifier v="componentslast"/><connRef v="1000002213"/></connection></connections></paramNode><paramNode><uid v="1000002218"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002214"/></connection><connection><identifier v="componentslast"/><connRef v="1000002215"/></connection></connections></paramNode><paramNode><uid v="1000002219"/><function v="add"/><type v="2048"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002216"/></connection><connection><identifier v="b"/><connRef v="1000002205"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="Degrees_to_Turn"/><uid v="1000002226"/><attributes><category v="Functions/Random"/><description v="Evaluates the Degrees_to_Turn function graph. Result type: Float. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000002227"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002224"/><paramNodes><paramNode><uid v="1000002223"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002224"/><function v="div"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002223"/></connection><connection><identifier v="b"/><connRef v="1000002225"/></connection></connections></paramNode><paramNode><uid v="1000002225"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="360"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="GlobalRandom"/><uid v="1000002364"/><attributes><category v="Functions/Random"/><description v="Evaluates the GlobalRandom function graph. Result type: Float. Inputs: Input, Seed."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="Input"/><uid v="1000002365"/><attributes><label v="Input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="Seed"/><uid v="1000002366"/><attributes><label v="Seed"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002363"/><paramNodes><paramNode><uid v="1000002228"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="512"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002229"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="512"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002230"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="32768"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002231"/><function v="sub"/><type v="256"/><GUILayout><gpos v="4264 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002266"/></connection><connection><identifier v="b"/><connRef v="1000002304"/></connection></connections></paramNode><paramNode><uid v="1000002232"/><function v="mul"/><type v="256"/><GUILayout><gpos v="10704 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002243"/></connection><connection><identifier v="b"/><connRef v="1000002261"/></connection></connections></paramNode><paramNode><uid v="1000002233"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002295"/></connection><connection><identifier v="b"/><connRef v="1000002241"/></connection></connections></paramNode><paramNode><uid v="1000002234"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002246"/></connection><connection><identifier v="b"/><connRef v="1000002305"/></connection></connections></paramNode><paramNode><uid v="1000002235"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="16384"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002236"/><function v="add"/><type v="256"/><GUILayout><gpos v="7624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002264"/></connection><connection><identifier v="b"/><connRef v="1000002283"/></connection></connections></paramNode><paramNode><uid v="1000002237"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1024"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002238"/><function v="sub"/><type v="256"/><GUILayout><gpos v="3424 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002267"/></connection><connection><identifier v="b"/><connRef v="1000002244"/></connection></connections></paramNode><paramNode><uid v="1000002239"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002246"/></connection><connection><identifier v="b"/><connRef v="1000002228"/></connection></connections></paramNode><paramNode><uid v="1000002240"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002246"/></connection><connection><identifier v="b"/><connRef v="1000002254"/></connection></connections></paramNode><paramNode><uid v="1000002241"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="16384"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002242"/><function v="div"/><type v="256"/><GUILayout><gpos v="5104 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002282"/></connection><connection><identifier v="b"/><connRef v="1000002316"/></connection></connections></paramNode><paramNode><uid v="1000002243"/><function v="div"/><type v="256"/><GUILayout><gpos v="10424 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002268"/></connection><connection><identifier v="b"/><connRef v="1000002279"/></connection></connections></paramNode><paramNode><uid v="1000002244"/><function v="sub"/><type v="256"/><GUILayout><gpos v="3144 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002239"/></connection><connection><identifier v="b"/><connRef v="1000002272"/></connection></connections></paramNode><paramNode><uid v="1000002245"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="128"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002246"/><function v="add"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002332"/></connection><connection><identifier v="b"/><connRef v="1000002261"/></connection></connections></paramNode><paramNode><uid v="1000002247"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002246"/></connection><connection><identifier v="b"/><connRef v="1000002256"/></connection></connections></paramNode><paramNode><uid v="1000002248"/><function v="add"/><type v="256"/><GUILayout><gpos v="7904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002236"/></connection><connection><identifier v="b"/><connRef v="1000002244"/></connection></connections></paramNode><paramNode><uid v="1000002249"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 704 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002246"/></connection><connection><identifier v="b"/><connRef v="1000002301"/></connection></connections></paramNode><paramNode><uid v="1000002250"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002310"/></connection><connection><identifier v="b"/><connRef v="1000002302"/></connection></connections></paramNode><paramNode><uid v="1000002251"/><function v="add"/><type v="256"/><GUILayout><gpos v="6504 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002324"/></connection><connection><identifier v="b"/><connRef v="1000002299"/></connection></connections></paramNode><paramNode><uid v="1000002252"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 864 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002246"/></connection><connection><identifier v="b"/><connRef v="1000002230"/></connection></connections></paramNode><paramNode><uid v="1000002253"/><function v="add"/><type v="256"/><GUILayout><gpos v="9024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002312"/></connection><connection><identifier v="b"/><connRef v="1000002290"/></connection></connections></paramNode><paramNode><uid v="1000002254"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002255"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1024"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002256"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="64"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002257"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 1024 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002246"/></connection><connection><identifier v="b"/><connRef v="1000002308"/></connection></connections></paramNode><paramNode><uid v="1000002258"/><function v="add"/><type v="256"/><GUILayout><gpos v="9584 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002286"/></connection><connection><identifier v="b"/><connRef v="1000002284"/></connection></connections></paramNode><paramNode><uid v="1000002259"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1664 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="32"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002260"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 1184 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002246"/></connection><connection><identifier v="b"/><connRef v="1000002288"/></connection></connections></paramNode><paramNode><uid v="1000002261"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 1824 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="Input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002262"/><function v="sub"/><type v="256"/><GUILayout><gpos v="4544 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002265"/></connection><connection><identifier v="b"/><connRef v="1000002231"/></connection></connections></paramNode><paramNode><uid v="1000002263"/><function v="sub"/><type v="256"/><GUILayout><gpos v="2584 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002306"/></connection><connection><identifier v="b"/><connRef v="1000002287"/></connection></connections></paramNode><paramNode><uid v="1000002264"/><function v="add"/><type v="256"/><GUILayout><gpos v="7344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002275"/></connection><connection><identifier v="b"/><connRef v="1000002281"/></connection></connections></paramNode><paramNode><uid v="1000002265"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 1344 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002246"/></connection><connection><identifier v="b"/><connRef v="1000002235"/></connection></connections></paramNode><paramNode><uid v="1000002266"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 1504 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002246"/></connection><connection><identifier v="b"/><connRef v="1000002274"/></connection></connections></paramNode><paramNode><uid v="1000002267"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 1664 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002246"/></connection><connection><identifier v="b"/><connRef v="1000002255"/></connection></connections></paramNode><paramNode><uid v="1000002268"/><function v="add"/><type v="256"/><GUILayout><gpos v="10144 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002278"/></connection><connection><identifier v="b"/><connRef v="1000002273"/></connection></connections></paramNode><paramNode><uid v="1000002269"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002250"/></connection><connection><identifier v="b"/><connRef v="1000002237"/></connection></connections></paramNode><paramNode><uid v="1000002270"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1984 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="4096"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002271"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 1824 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002246"/></connection><connection><identifier v="b"/><connRef v="1000002296"/></connection></connections></paramNode><paramNode><uid v="1000002272"/><function v="sub"/><type v="256"/><GUILayout><gpos v="2864 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002234"/></connection><connection><identifier v="b"/><connRef v="1000002263"/></connection></connections></paramNode><paramNode><uid v="1000002273"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002276"/></connection><connection><identifier v="b"/><connRef v="1000002298"/></connection></connections></paramNode><paramNode><uid v="1000002274"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 2144 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="8192"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002275"/><function v="add"/><type v="256"/><GUILayout><gpos v="7064 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002294"/></connection><connection><identifier v="b"/><connRef v="1000002277"/></connection></connections></paramNode><paramNode><uid v="1000002276"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 1984 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002246"/></connection><connection><identifier v="b"/><connRef v="1000002292"/></connection></connections></paramNode><paramNode><uid v="1000002277"/><function v="div"/><type v="256"/><GUILayout><gpos v="4264 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002304"/></connection><connection><identifier v="b"/><connRef v="1000002309"/></connection></connections></paramNode><paramNode><uid v="1000002278"/><function v="add"/><type v="256"/><GUILayout><gpos v="9864 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002258"/></connection><connection><identifier v="b"/><connRef v="1000002233"/></connection></connections></paramNode><paramNode><uid v="1000002279"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 2304 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="131072"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002280"/><function v="sub"/><type v="256"/><GUILayout><gpos v="2024 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002257"/></connection><connection><identifier v="b"/><connRef v="1000002250"/></connection></connections></paramNode><paramNode><uid v="1000002281"/><function v="div"/><type v="256"/><GUILayout><gpos v="3984 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002313"/></connection><connection><identifier v="b"/><connRef v="1000002259"/></connection></connections></paramNode><paramNode><uid v="1000002282"/><function v="sub"/><type v="256"/><GUILayout><gpos v="4824 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002252"/></connection><connection><identifier v="b"/><connRef v="1000002262"/></connection></connections></paramNode><paramNode><uid v="1000002283"/><function v="div"/><type v="256"/><GUILayout><gpos v="3704 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002238"/></connection><connection><identifier v="b"/><connRef v="1000002289"/></connection></connections></paramNode><paramNode><uid v="1000002284"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1744 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002302"/></connection><connection><identifier v="b"/><connRef v="1000002270"/></connection></connections></paramNode><paramNode><uid v="1000002285"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 2464 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2048"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002286"/><function v="add"/><type v="256"/><GUILayout><gpos v="9304 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002253"/></connection><connection><identifier v="b"/><connRef v="1000002269"/></connection></connections></paramNode><paramNode><uid v="1000002287"/><function v="sub"/><type v="256"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002247"/></connection><connection><identifier v="b"/><connRef v="1000002280"/></connection></connections></paramNode><paramNode><uid v="1000002288"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 2624 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2048"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002289"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 2784 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002290"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2304 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002280"/></connection><connection><identifier v="b"/><connRef v="1000002300"/></connection></connections></paramNode><paramNode><uid v="1000002291"/><function v="div"/><type v="256"/><GUILayout><gpos v="4544 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002231"/></connection><connection><identifier v="b"/><connRef v="1000002229"/></connection></connections></paramNode><paramNode><uid v="1000002292"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 2944 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002293"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 3104 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="16"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002294"/><function v="add"/><type v="256"/><GUILayout><gpos v="6784 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002251"/></connection><connection><identifier v="b"/><connRef v="1000002291"/></connection></connections></paramNode><paramNode><uid v="1000002295"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002240"/></connection><connection><identifier v="b"/><connRef v="1000002276"/></connection></connections></paramNode><paramNode><uid v="1000002296"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 3264 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="8"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002297"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 3424 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="64"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002298"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 3584 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="65536"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002299"/><function v="div"/><type v="256"/><GUILayout><gpos v="4824 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002262"/></connection><connection><identifier v="b"/><connRef v="1000002285"/></connection></connections></paramNode><paramNode><uid v="1000002300"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 3744 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="256"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002301"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 3904 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="4096"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002302"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1464 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002271"/></connection><connection><identifier v="b"/><connRef v="1000002295"/></connection></connections></paramNode><paramNode><uid v="1000002303"/><function v="add"/><type v="256"/><GUILayout><gpos v="8464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002307"/></connection><connection><identifier v="b"/><connRef v="1000002315"/></connection></connections></paramNode><paramNode><uid v="1000002304"/><function v="sub"/><type v="256"/><GUILayout><gpos v="3984 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002249"/></connection><connection><identifier v="b"/><connRef v="1000002313"/></connection></connections></paramNode><paramNode><uid v="1000002305"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 4064 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="256"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002306"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 2144 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002246"/></connection><connection><identifier v="b"/><connRef v="1000002245"/></connection></connections></paramNode><paramNode><uid v="1000002307"/><function v="add"/><type v="256"/><GUILayout><gpos v="8184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002248"/></connection><connection><identifier v="b"/><connRef v="1000002317"/></connection></connections></paramNode><paramNode><uid v="1000002308"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 4224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="32"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002309"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 4384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="128"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002310"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 2304 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002246"/></connection><connection><identifier v="b"/><connRef v="1000002293"/></connection></connections></paramNode><paramNode><uid v="1000002311"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 4544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="16"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002312"/><function v="add"/><type v="256"/><GUILayout><gpos v="8744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002303"/></connection><connection><identifier v="b"/><connRef v="1000002314"/></connection></connections></paramNode><paramNode><uid v="1000002313"/><function v="sub"/><type v="256"/><GUILayout><gpos v="3704 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002260"/></connection><connection><identifier v="b"/><connRef v="1000002238"/></connection></connections></paramNode><paramNode><uid v="1000002314"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2584 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002287"/></connection><connection><identifier v="b"/><connRef v="1000002297"/></connection></connections></paramNode><paramNode><uid v="1000002315"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2864 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002263"/></connection><connection><identifier v="b"/><connRef v="1000002311"/></connection></connections></paramNode><paramNode><uid v="1000002316"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 4704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="8192"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002317"/><function v="mul"/><type v="256"/><GUILayout><gpos v="3144 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002272"/></connection><connection><identifier v="b"/><connRef v="1000002318"/></connection></connections></paramNode><paramNode><uid v="1000002318"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 4864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002319"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 2464 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002246"/></connection><connection><identifier v="b"/><connRef v="1000002320"/></connection></connections></paramNode><paramNode><uid v="1000002320"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 5024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="65536"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002321"/><function v="sub"/><type v="256"/><GUILayout><gpos v="5104 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002319"/></connection><connection><identifier v="b"/><connRef v="1000002282"/></connection></connections></paramNode><paramNode><uid v="1000002322"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 5184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="32768"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002323"/><function v="div"/><type v="256"/><GUILayout><gpos v="5384 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002321"/></connection><connection><identifier v="b"/><connRef v="1000002322"/></connection></connections></paramNode><paramNode><uid v="1000002324"/><function v="add"/><type v="256"/><GUILayout><gpos v="6224 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002330"/></connection><connection><identifier v="b"/><connRef v="1000002242"/></connection></connections></paramNode><paramNode><uid v="1000002325"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 5344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="131072"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002326"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 2624 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002246"/></connection><connection><identifier v="b"/><connRef v="1000002325"/></connection></connections></paramNode><paramNode><uid v="1000002327"/><function v="div"/><type v="256"/><GUILayout><gpos v="5664 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002329"/></connection><connection><identifier v="b"/><connRef v="1000002328"/></connection></connections></paramNode><paramNode><uid v="1000002328"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 5504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="131072"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002329"/><function v="sub"/><type v="256"/><GUILayout><gpos v="5384 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002326"/></connection><connection><identifier v="b"/><connRef v="1000002321"/></connection></connections></paramNode><paramNode><uid v="1000002330"/><function v="add"/><type v="256"/><GUILayout><gpos v="5944 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002327"/></connection><connection><identifier v="b"/><connRef v="1000002323"/></connection></connections></paramNode><paramNode><uid v="1000002331"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 5664 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="Seed"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002332"/><function v="tofloat"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000002331"/></connection></connections></paramNode><paramNode><uid v="1000002333"/><function v="div"/><type v="256"/><GUILayout><gpos v="3704 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002334"/></connection><connection><identifier v="b"/><connRef v="1000002336"/></connection></connections></paramNode><paramNode><uid v="1000002334"/><function v="sub"/><type v="256"/><GUILayout><gpos v="3424 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002346"/></connection><connection><identifier v="b"/><connRef v="1000002342"/></connection></connections></paramNode><paramNode><uid v="1000002335"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 5824 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="100"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002336"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 5984 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="100"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002337"/><function v="sub"/><type v="256"/><GUILayout><gpos v="2304 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002350"/></connection><connection><identifier v="b"/><connRef v="1000002359"/></connection></connections></paramNode><paramNode><uid v="1000002338"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 6144 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="4321"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002339"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 6304 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="65536"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002340"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 6464 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="100"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002341"/><function v="add"/><type v="256"/><GUILayout><gpos v="1184 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002345"/></connection><connection><identifier v="b"/><connRef v="1000002338"/></connection></connections></paramNode><paramNode><uid v="1000002342"/><function v="mod"/><type v="256"/><GUILayout><gpos v="3144 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002357"/></connection><connection><identifier v="b"/><connRef v="1000002340"/></connection></connections></paramNode><paramNode><uid v="1000002343"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 6624 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="100"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002344"/><function v="div"/><type v="256"/><GUILayout><gpos v="2584 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002337"/></connection><connection><identifier v="b"/><connRef v="1000002335"/></connection></connections></paramNode><paramNode><uid v="1000002345"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 2784 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002348"/></connection><connection><identifier v="b"/><connRef v="1000002339"/></connection></connections></paramNode><paramNode><uid v="1000002346"/><function v="mod"/><type v="256"/><GUILayout><gpos v="3144 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002357"/></connection><connection><identifier v="b"/><connRef v="1000002356"/></connection></connections></paramNode><paramNode><uid v="1000002347"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1744 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002354"/></connection><connection><identifier v="b"/><connRef v="1000002352"/></connection></connections></paramNode><paramNode><uid v="1000002348"/><function v="add"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002362"/></connection><connection><identifier v="b"/><connRef v="1000002338"/></connection></connections></paramNode><paramNode><uid v="1000002349"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 6784 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="35"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002350"/><function v="mod"/><type v="256"/><GUILayout><gpos v="2024 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002347"/></connection><connection><identifier v="b"/><connRef v="1000002360"/></connection></connections></paramNode><paramNode><uid v="1000002351"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 6944 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="Input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002352"/><function v="pow2"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002349"/></connection></connections></paramNode><paramNode><uid v="1000002353"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 7104 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1234"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002354"/><function v="div"/><type v="256"/><GUILayout><gpos v="1464 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002353"/></connection><connection><identifier v="b"/><connRef v="1000002341"/></connection></connections></paramNode><paramNode><uid v="1000002355"/><function v="div"/><type v="256"/><GUILayout><gpos v="3984 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002333"/></connection><connection><identifier v="b"/><connRef v="1000002358"/></connection></connections></paramNode><paramNode><uid v="1000002356"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 7264 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1000000"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002357"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2864 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002344"/></connection><connection><identifier v="b"/><connRef v="1000002344"/></connection></connections></paramNode><paramNode><uid v="1000002358"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 7424 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="10000"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002359"/><function v="mod"/><type v="256"/><GUILayout><gpos v="2024 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002347"/></connection><connection><identifier v="b"/><connRef v="1000002343"/></connection></connections></paramNode><paramNode><uid v="1000002360"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 7584 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1000000"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002361"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 7744 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="Seed"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002362"/><function v="tofloat"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000002361"/></connection></connections></paramNode><paramNode><uid v="1000002363"/><function v="mul"/><type v="256"/><GUILayout><gpos v="4264 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002351"/></connection><connection><identifier v="b"/><connRef v="1000002355"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="normal_distribution"/><uid v="1000002383"/><attributes><category v="Functions/Random"/><description v="Evaluates the normal_distribution function graph. Result type: Float2. Inputs: radius, uniform_random."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="radius"/><uid v="1000002384"/><attributes><label v="radius"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="uniform_random"/><uid v="1000002385"/><attributes><label v="uniform_random"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="512"/><paramValue><dynamicValue><rootnode v="1000002370"/><paramNodes><paramNode><uid v="1000002367"/><function v="log"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002380"/></connection></connections></paramNode><paramNode><uid v="1000002368"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002379"/></connection><connection><identifier v="b"/><connRef v="1000002382"/></connection></connections></paramNode><paramNode><uid v="1000002369"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.25"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002370"/><function v="cartesian"/><type v="512"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="rho"/><connRef v="1000002375"/></connection><connection><identifier v="theta"/><connRef v="1000002368"/></connection></connections></paramNode><paramNode><uid v="1000002371"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002367"/></connection><connection><identifier v="b"/><connRef v="1000002373"/></connection></connections></paramNode><paramNode><uid v="1000002372"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002374"/></connection><connection><identifier v="b"/><connRef v="1000002369"/></connection></connections></paramNode><paramNode><uid v="1000002373"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="-2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002374"/><function v="sqrt"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002371"/></connection></connections></paramNode><paramNode><uid v="1000002375"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002372"/></connection><connection><identifier v="b"/><connRef v="1000002376"/></connection></connections></paramNode><paramNode><uid v="1000002376"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="radius"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002377"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="uniform_random"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002378"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002377"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002379"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002377"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002380"/><function v="max"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002378"/></connection><connection><identifier v="b"/><connRef v="1000002381"/></connection></connections></paramNode><paramNode><uid v="1000002381"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.0001"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002382"/><function v="instance"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/2Pi"/></constantValue></funcData></funcDatas><materialcraftInterface></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="Math"/><uid v="1000002386"/><content><function><identifier v="Ln"/><uid v="1000002392"/><attributes><category v="Functions/Math"/><description v="Evaluates the Ln function graph. Result type: Float. Inputs: a."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="a"/><uid v="1000002393"/><attributes><label v="a"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002389"/><paramNodes><paramNode><uid v="1000002387"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="a"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002388"/><function v="log"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002387"/></connection></connections></paramNode><paramNode><uid v="1000002389"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002388"/></connection><connection><identifier v="b"/><connRef v="1000002391"/></connection></connections></paramNode><paramNode><uid v="1000002390"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002391"/><function v="exp"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002390"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="Pi"/><uid v="1000002395"/><attributes><category v="Functions/Math"/><description v="Evaluates the Pi function graph. Result type: Float. Inputs: none."/><author v=""/><tags v=""/></attributes><paraminputs></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002394"/><paramNodes><paramNode><uid v="1000002394"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="3.1415927"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="2Pi"/><uid v="1000002397"/><attributes><category v="Functions/Math"/><description v="Evaluates the 2Pi function graph. Result type: Float. Inputs: none."/><author v=""/><tags v=""/></attributes><paraminputs></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002396"/><paramNodes><paramNode><uid v="1000002396"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="6.2831855"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="Pow"/><uid v="1000002409"/><attributes><category v="Functions/Math"/><description v="Evaluates the Pow function graph. Result type: Float. Inputs: x, n."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="x"/><uid v="1000002410"/><attributes><label v="x"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="n"/><uid v="1000002411"/><attributes><label v="n"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002407"/><paramNodes><paramNode><uid v="1000002398"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="n"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002399"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="x"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002400"/><function v="pow2"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002402"/></connection></connections></paramNode><paramNode><uid v="1000002401"/><function v="log"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002399"/></connection></connections></paramNode><paramNode><uid v="1000002402"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002405"/></connection><connection><identifier v="b"/><connRef v="1000002398"/></connection></connections></paramNode><paramNode><uid v="1000002403"/><function v="log"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002404"/></connection></connections></paramNode><paramNode><uid v="1000002404"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002405"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002401"/></connection><connection><identifier v="b"/><connRef v="1000002403"/></connection></connections></paramNode><paramNode><uid v="1000002406"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002407"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000002408"/></connection><connection><identifier v="ifpath"/><connRef v="1000002406"/></connection><connection><identifier v="elsepath"/><connRef v="1000002400"/></connection></connections></paramNode><paramNode><uid v="1000002408"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002399"/></connection><connection><identifier v="b"/><connRef v="1000002406"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="Roughness"/><uid v="1000002436"/><attributes><category v="Functions/Math"/><description v="Evaluates the Roughness function graph. Result type: Float. Inputs: Roughness, CurrentLevel, TotalLevel, GlobalOpacity."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="Roughness"/><uid v="1000002437"/><attributes><label v="Roughness"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="CurrentLevel"/><uid v="1000002438"/><attributes><label v="CurrentLevel"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="TotalLevel"/><uid v="1000002439"/><attributes><label v="TotalLevel"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="GlobalOpacity"/><uid v="1000002440"/><attributes><label v="GlobalOpacity"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002426"/><paramNodes><paramNode><uid v="1000002412"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="Roughness"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002413"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002414"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000002428"/></connection><connection><identifier v="ifpath"/><connRef v="1000002421"/></connection><connection><identifier v="elsepath"/><connRef v="1000002418"/></connection></connections></paramNode><paramNode><uid v="1000002415"/><function v="eq"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002412"/></connection><connection><identifier v="b"/><connRef v="1000002413"/></connection></connections></paramNode><paramNode><uid v="1000002416"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002417"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002418"/><function v="div"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002431"/></connection><connection><identifier v="b"/><connRef v="1000002433"/></connection></connections></paramNode><paramNode><uid v="1000002419"/><function v="sub"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002417"/></connection><connection><identifier v="b"/><connRef v="1000002412"/></connection></connections></paramNode><paramNode><uid v="1000002420"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000002415"/></connection><connection><identifier v="ifpath"/><connRef v="1000002423"/></connection><connection><identifier v="elsepath"/><connRef v="1000002414"/></connection></connections></paramNode><paramNode><uid v="1000002421"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002424"/></connection><connection><identifier v="b"/><connRef v="1000002422"/></connection></connections></paramNode><paramNode><uid v="1000002422"/><function v="tofloat"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000002427"/></connection></connections></paramNode><paramNode><uid v="1000002423"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002424"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002425"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="GlobalOpacity"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002426"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002425"/></connection><connection><identifier v="b"/><connRef v="1000002420"/></connection></connections></paramNode><paramNode><uid v="1000002427"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="TotalLevel"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002428"/><function v="eq"/><type v="4"/><GUILayout><gpos v="344 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002412"/></connection><connection><identifier v="b"/><connRef v="1000002416"/></connection></connections></paramNode><paramNode><uid v="1000002429"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="CurrentLevel"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002430"/><function v="tofloat"/><type v="256"/><GUILayout><gpos v="344 704 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000002429"/></connection></connections></paramNode><paramNode><uid v="1000002431"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002419"/></connection><connection><identifier v="b"/><connRef v="1000002434"/></connection></connections></paramNode><paramNode><uid v="1000002432"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002433"/><function v="sub"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002432"/></connection><connection><identifier v="b"/><connRef v="1000002435"/></connection></connections></paramNode><paramNode><uid v="1000002434"/><function v="pow"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002412"/></connection><connection><identifier v="b"/><connRef v="1000002430"/></connection></connections></paramNode><paramNode><uid v="1000002435"/><function v="pow"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002412"/></connection><connection><identifier v="b"/><connRef v="1000002422"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="Equality_Float2"/><uid v="1000002450"/><attributes><category v="Functions/Math"/><description v="Evaluates the Equality_Float2 function graph. Result type: Boolean. Inputs: A, B."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="A"/><uid v="1000002451"/><attributes><label v="A"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput><paraminput><identifier v="B"/><uid v="1000002452"/><attributes><label v="B"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput></paraminputs><type v="4"/><paramValue><dynamicValue><rootnode v="1000002449"/><paramNodes><paramNode><uid v="1000002441"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="A"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002442"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="B"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002443"/><function v="eq"/><type v="4"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002444"/></connection><connection><identifier v="b"/><connRef v="1000002445"/></connection></connections></paramNode><paramNode><uid v="1000002444"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002441"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002445"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002442"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002446"/><function v="eq"/><type v="4"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002447"/></connection><connection><identifier v="b"/><connRef v="1000002448"/></connection></connections></paramNode><paramNode><uid v="1000002447"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002441"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002448"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 544 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002442"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002449"/><function v="and"/><type v="4"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002443"/></connection><connection><identifier v="b"/><connRef v="1000002446"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="Equality_Float3"/><uid v="1000002462"/><attributes><category v="Functions/Math"/><description v="Evaluates the Equality_Float3 function graph. Result type: Boolean. Inputs: A, B."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="A"/><uid v="1000002463"/><attributes><label v="A"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="0 0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput><paraminput><identifier v="B"/><uid v="1000002464"/><attributes><label v="B"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="0 0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput></paraminputs><type v="4"/><paramValue><dynamicValue><rootnode v="1000002461"/><paramNodes><paramNode><uid v="1000002453"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="A"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002454"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="B"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002455"/><function v="swizzle2"/><type v="512"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002453"/></connection></connections><funcDatas><funcData><name v="swizzle2"/><constantValue><constantValueInt2 v="0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002456"/><function v="swizzle2"/><type v="512"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002454"/></connection></connections><funcDatas><funcData><name v="swizzle2"/><constantValue><constantValueInt2 v="0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002457"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002453"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002458"/><function v="instance"/><type v="4"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="A"/><connRef v="1000002455"/></connection><connection><identifier v="B"/><connRef v="1000002456"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Equality_Float2"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="A"/><type v="0"/></input><input><identifier v="B"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000002459"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 544 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002454"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002460"/><function v="eq"/><type v="4"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002457"/></connection><connection><identifier v="b"/><connRef v="1000002459"/></connection></connections></paramNode><paramNode><uid v="1000002461"/><function v="and"/><type v="4"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002458"/></connection><connection><identifier v="b"/><connRef v="1000002460"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="Equality_Boolean"/><uid v="1000002472"/><attributes><category v="Functions/Math"/><description v="Evaluates the Equality_Boolean function graph. Result type: Boolean. Inputs: A, B."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="A"/><uid v="1000002473"/><attributes><label v="A"/></attributes><type v="4"/><defaultValue><constantValueBool v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="B"/><uid v="1000002474"/><attributes><label v="B"/></attributes><type v="4"/><defaultValue><constantValueBool v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="4"/><paramValue><dynamicValue><rootnode v="1000002468"/><paramNodes><paramNode><uid v="1000002465"/><function v="get_bool"/><type v="4"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_bool"/><constantValue><constantValueString v="A"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002466"/><function v="get_bool"/><type v="4"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_bool"/><constantValue><constantValueString v="B"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002467"/><function v="and"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002465"/></connection><connection><identifier v="b"/><connRef v="1000002466"/></connection></connections></paramNode><paramNode><uid v="1000002468"/><function v="or"/><type v="4"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002467"/></connection><connection><identifier v="b"/><connRef v="1000002471"/></connection></connections></paramNode><paramNode><uid v="1000002469"/><function v="not"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002465"/></connection></connections></paramNode><paramNode><uid v="1000002470"/><function v="not"/><type v="4"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002466"/></connection></connections></paramNode><paramNode><uid v="1000002471"/><function v="and"/><type v="4"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002469"/></connection><connection><identifier v="b"/><connRef v="1000002470"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="Equality_Float4"/><uid v="1000002484"/><attributes><category v="Functions/Math"/><description v="Evaluates the Equality_Float4 function graph. Result type: Boolean. Inputs: A, B."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="A"/><uid v="1000002485"/><attributes><label v="A"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="0 0 0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput><paraminput><identifier v="B"/><uid v="1000002486"/><attributes><label v="B"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="0 0 0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput></paraminputs><type v="4"/><paramValue><dynamicValue><rootnode v="1000002483"/><paramNodes><paramNode><uid v="1000002475"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="A"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002476"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="B"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002477"/><function v="swizzle2"/><type v="512"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002475"/></connection></connections><funcDatas><funcData><name v="swizzle2"/><constantValue><constantValueInt2 v="0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002478"/><function v="swizzle2"/><type v="512"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002475"/></connection></connections><funcDatas><funcData><name v="swizzle2"/><constantValue><constantValueInt2 v="2 3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002479"/><function v="swizzle2"/><type v="512"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002476"/></connection></connections><funcDatas><funcData><name v="swizzle2"/><constantValue><constantValueInt2 v="0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002480"/><function v="swizzle2"/><type v="512"/><GUILayout><gpos v="344 544 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002476"/></connection></connections><funcDatas><funcData><name v="swizzle2"/><constantValue><constantValueInt2 v="2 3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002481"/><function v="instance"/><type v="4"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="A"/><connRef v="1000002477"/></connection><connection><identifier v="B"/><connRef v="1000002479"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Equality_Float2"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="A"/><type v="0"/></input><input><identifier v="B"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000002482"/><function v="instance"/><type v="4"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="B"/><connRef v="1000002480"/></connection><connection><identifier v="A"/><connRef v="1000002478"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Equality_Float2"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="B"/><type v="0"/></input><input><identifier v="A"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000002483"/><function v="and"/><type v="4"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002481"/></connection><connection><identifier v="b"/><connRef v="1000002482"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="NotEqual_Float2"/><uid v="1000002491"/><attributes><category v="Functions/Math"/><description v="Evaluates the NotEqual_Float2 function graph. Result type: Boolean. Inputs: A, B."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="A"/><uid v="1000002492"/><attributes><label v="A"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput><paraminput><identifier v="B"/><uid v="1000002493"/><attributes><label v="B"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput></paraminputs><type v="4"/><paramValue><dynamicValue><rootnode v="1000002490"/><paramNodes><paramNode><uid v="1000002487"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="A"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002488"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="B"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002489"/><function v="instance"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="A"/><connRef v="1000002487"/></connection><connection><identifier v="B"/><connRef v="1000002488"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Equality_Float2"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="A"/><type v="0"/></input><input><identifier v="B"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000002490"/><function v="not"/><type v="4"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002489"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="NotEqual_Float3"/><uid v="1000002498"/><attributes><category v="Functions/Math"/><description v="Evaluates the NotEqual_Float3 function graph. Result type: Boolean. Inputs: A, B."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="A"/><uid v="1000002499"/><attributes><label v="A"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="0 0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput><paraminput><identifier v="B"/><uid v="1000002500"/><attributes><label v="B"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="0 0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput></paraminputs><type v="4"/><paramValue><dynamicValue><rootnode v="1000002497"/><paramNodes><paramNode><uid v="1000002494"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="A"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002495"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="B"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002496"/><function v="instance"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="A"/><connRef v="1000002494"/></connection><connection><identifier v="B"/><connRef v="1000002495"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Equality_Float3"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="A"/><type v="0"/></input><input><identifier v="B"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000002497"/><function v="not"/><type v="4"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002496"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="NotEqual_Float4"/><uid v="1000002505"/><attributes><category v="Functions/Math"/><description v="Evaluates the NotEqual_Float4 function graph. Result type: Boolean. Inputs: A, B."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="A"/><uid v="1000002506"/><attributes><label v="A"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="0 0 0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput><paraminput><identifier v="B"/><uid v="1000002507"/><attributes><label v="B"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="0 0 0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput></paraminputs><type v="4"/><paramValue><dynamicValue><rootnode v="1000002504"/><paramNodes><paramNode><uid v="1000002501"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="A"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002502"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="B"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002503"/><function v="instance"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="A"/><connRef v="1000002501"/></connection><connection><identifier v="B"/><connRef v="1000002502"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Equality_Float4"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="A"/><type v="0"/></input><input><identifier v="B"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000002504"/><function v="not"/><type v="4"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002503"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="NotEqual_Boolean"/><uid v="1000002512"/><attributes><category v="Functions/Math"/><description v="Evaluates the NotEqual_Boolean function graph. Result type: Boolean. Inputs: A, B."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="A"/><uid v="1000002513"/><attributes><label v="A"/></attributes><type v="4"/><defaultValue><constantValueBool v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="B"/><uid v="1000002514"/><attributes><label v="B"/></attributes><type v="4"/><defaultValue><constantValueBool v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="4"/><paramValue><dynamicValue><rootnode v="1000002511"/><paramNodes><paramNode><uid v="1000002508"/><function v="get_bool"/><type v="4"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_bool"/><constantValue><constantValueString v="A"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002509"/><function v="get_bool"/><type v="4"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_bool"/><constantValue><constantValueString v="B"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002510"/><function v="instance"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="A"/><connRef v="1000002508"/></connection><connection><identifier v="B"/><connRef v="1000002509"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Equality_Boolean"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="A"/><type v="0"/></input><input><identifier v="B"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000002511"/><function v="not"/><type v="4"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002510"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="Curve_Function"/><uid v="1000002544"/><attributes><category v="Functions/Math"/><description v="Evaluates the Curve_Function function graph. Result type: Float. Inputs: curve, input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="curve"/><uid v="1000002545"/><attributes><label v="curve"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="input"/><uid v="1000002546"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002542"/><paramNodes><paramNode><uid v="1000002515"/><function v="sqrt"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002520"/></connection></connections></paramNode><paramNode><uid v="1000002516"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002517"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="curve"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002518"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002519"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002518"/></connection><connection><identifier v="b"/><connRef v="1000002518"/></connection></connections></paramNode><paramNode><uid v="1000002520"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002516"/></connection><connection><identifier v="b"/><connRef v="1000002519"/></connection></connections></paramNode><paramNode><uid v="1000002521"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002522"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002521"/></connection><connection><identifier v="b"/><connRef v="1000002515"/></connection></connections></paramNode><paramNode><uid v="1000002523"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002522"/></connection><connection><identifier v="b"/><connRef v="1000002517"/></connection></connections></paramNode><paramNode><uid v="1000002524"/><function v="add"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002523"/></connection><connection><identifier v="b"/><connRef v="1000002527"/></connection></connections></paramNode><paramNode><uid v="1000002525"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002526"/><function v="sub"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002525"/></connection><connection><identifier v="b"/><connRef v="1000002517"/></connection></connections></paramNode><paramNode><uid v="1000002527"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002518"/></connection><connection><identifier v="b"/><connRef v="1000002526"/></connection></connections></paramNode><paramNode><uid v="1000002528"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002538"/></connection><connection><identifier v="b"/><connRef v="1000002543"/></connection></connections></paramNode><paramNode><uid v="1000002529"/><function v="add"/><type v="256"/><GUILayout><gpos v="1744 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002533"/></connection><connection><identifier v="b"/><connRef v="1000002528"/></connection></connections></paramNode><paramNode><uid v="1000002530"/><function v="sqrt"/><type v="256"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002537"/></connection></connections></paramNode><paramNode><uid v="1000002531"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002532"/><function v="sub"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002538"/></connection><connection><identifier v="b"/><connRef v="1000002531"/></connection></connections></paramNode><paramNode><uid v="1000002533"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1464 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002530"/></connection><connection><identifier v="b"/><connRef v="1000002539"/></connection></connections></paramNode><paramNode><uid v="1000002534"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002532"/></connection><connection><identifier v="b"/><connRef v="1000002532"/></connection></connections></paramNode><paramNode><uid v="1000002535"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002536"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002537"/><function v="sub"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002536"/></connection><connection><identifier v="b"/><connRef v="1000002534"/></connection></connections></paramNode><paramNode><uid v="1000002538"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002539"/><function v="neg"/><type v="256"/><GUILayout><gpos v="344 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002517"/></connection></connections></paramNode><paramNode><uid v="1000002540"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 704 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002517"/></connection><connection><identifier v="b"/><connRef v="1000002541"/></connection></connections></paramNode><paramNode><uid v="1000002541"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002542"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000002540"/></connection><connection><identifier v="ifpath"/><connRef v="1000002529"/></connection><connection><identifier v="elsepath"/><connRef v="1000002524"/></connection></connections></paramNode><paramNode><uid v="1000002543"/><function v="add"/><type v="256"/><GUILayout><gpos v="344 864 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002535"/></connection><connection><identifier v="b"/><connRef v="1000002517"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="merge_float4"/><uid v="1000002554"/><attributes><category v="Functions/Math"/><description v="Evaluates the merge_float4 function graph. Result type: Float4. Inputs: x, y, z, w."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="x"/><uid v="1000002555"/><attributes><label v="x"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="y"/><uid v="1000002556"/><attributes><label v="y"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="z"/><uid v="1000002557"/><attributes><label v="z"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="w"/><uid v="1000002558"/><attributes><label v="w"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="2048"/><paramValue><dynamicValue><rootnode v="1000002552"/><paramNodes><paramNode><uid v="1000002547"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002548"/></connection><connection><identifier v="componentslast"/><connRef v="1000002549"/></connection></connections></paramNode><paramNode><uid v="1000002548"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="x"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002549"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="y"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002550"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="z"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002551"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002550"/></connection><connection><identifier v="componentslast"/><connRef v="1000002553"/></connection></connections></paramNode><paramNode><uid v="1000002552"/><function v="vector4"/><type v="2048"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002547"/></connection><connection><identifier v="componentslast"/><connRef v="1000002551"/></connection></connections></paramNode><paramNode><uid v="1000002553"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="w"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="merge_float3"/><uid v="1000002564"/><attributes><category v="Functions/Math"/><description v="Evaluates the merge_float3 function graph. Result type: Float3. Inputs: x, y, z."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="x"/><uid v="1000002565"/><attributes><label v="x"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="y"/><uid v="1000002566"/><attributes><label v="y"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="z"/><uid v="1000002567"/><attributes><label v="z"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000002559"/><paramNodes><paramNode><uid v="1000002559"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002560"/></connection><connection><identifier v="componentslast"/><connRef v="1000002563"/></connection></connections></paramNode><paramNode><uid v="1000002560"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002561"/></connection><connection><identifier v="componentslast"/><connRef v="1000002562"/></connection></connections></paramNode><paramNode><uid v="1000002561"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="x"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002562"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="y"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002563"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="z"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="distance_vec3"/><uid v="1000002572"/><attributes><category v="Functions/Math"/><description v="Evaluates the distance_vec3 function graph. Result type: Float. Inputs: a, b."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="a"/><uid v="1000002573"/><attributes><label v="A"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="b"/><uid v="1000002574"/><attributes><label v="B"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002570"/><paramNodes><paramNode><uid v="1000002568"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="a"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002569"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="b"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002570"/><function v="instance"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="input_v"/><connRef v="1000002571"/></connection><connection><identifier v="v"/><connRef v="1000002571"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/length_vec3"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_v"/><type v="0"/></input><input><identifier v="v"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000002571"/><function v="sub"/><type v="1024"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002569"/></connection><connection><identifier v="b"/><connRef v="1000002568"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="distance_vec2"/><uid v="1000002579"/><attributes><category v="Functions/Math"/><description v="Evaluates the distance_vec2 function graph. Result type: Float. Inputs: a, b."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="a"/><uid v="1000002580"/><attributes><label v="A"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="b"/><uid v="1000002581"/><attributes><label v="B"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002578"/><paramNodes><paramNode><uid v="1000002575"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="a"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002576"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="b"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002577"/><function v="sub"/><type v="512"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002576"/></connection><connection><identifier v="b"/><connRef v="1000002575"/></connection></connections></paramNode><paramNode><uid v="1000002578"/><function v="instance"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="v"/><connRef v="1000002577"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/length_vec2"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="v"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="length_vec2"/><uid v="1000002585"/><attributes><category v="Functions/Math"/><description v="Evaluates the length_vec2 function graph. Result type: Float. Inputs: v."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="v"/><uid v="1000002586"/><attributes><label v="Vector"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002583"/><paramNodes><paramNode><uid v="1000002582"/><function v="dot"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002584"/></connection><connection><identifier v="b"/><connRef v="1000002584"/></connection></connections></paramNode><paramNode><uid v="1000002583"/><function v="sqrt"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002582"/></connection></connections></paramNode><paramNode><uid v="1000002584"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="v"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="length_vec3"/><uid v="1000002590"/><attributes><category v="Functions/Math"/><description v="Evaluates the length_vec3 function graph. Result type: Float. Inputs: v."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="v"/><uid v="1000002591"/><attributes><label v="Vector"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002589"/><paramNodes><paramNode><uid v="1000002587"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="v"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002588"/><function v="dot"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002587"/></connection><connection><identifier v="b"/><connRef v="1000002587"/></connection></connections></paramNode><paramNode><uid v="1000002589"/><function v="sqrt"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002588"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="sign"/><uid v="1000002598"/><attributes><category v="Functions/Math"/><description v="Evaluates the sign function graph. Result type: Float. Inputs: x."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="x"/><uid v="1000002599"/><attributes><label v="X"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002594"/><paramNodes><paramNode><uid v="1000002592"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="x"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002593"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002594"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000002597"/></connection><connection><identifier v="ifpath"/><connRef v="1000002595"/></connection><connection><identifier v="elsepath"/><connRef v="1000002596"/></connection></connections></paramNode><paramNode><uid v="1000002595"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002596"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="-1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002597"/><function v="gteq"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002592"/></connection><connection><identifier v="b"/><connRef v="1000002593"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="reflect"/><uid v="1000002607"/><attributes><category v="Functions/Math"/><description v="Evaluates the reflect function graph. Result type: Float3. Inputs: i, n."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="i"/><uid v="1000002608"/><attributes><label v="Incidence"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="n"/><uid v="1000002609"/><attributes><label v="Normal"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000002602"/><paramNodes><paramNode><uid v="1000002600"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="i"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002601"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="n"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002602"/><function v="sub"/><type v="1024"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002600"/></connection><connection><identifier v="b"/><connRef v="1000002604"/></connection></connections></paramNode><paramNode><uid v="1000002603"/><function v="dot"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002601"/></connection><connection><identifier v="b"/><connRef v="1000002600"/></connection></connections></paramNode><paramNode><uid v="1000002604"/><function v="mulscalar"/><type v="1024"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002605"/></connection><connection><identifier v="scalar"/><connRef v="1000002603"/></connection></connections></paramNode><paramNode><uid v="1000002605"/><function v="mulscalar"/><type v="1024"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002601"/></connection><connection><identifier v="scalar"/><connRef v="1000002606"/></connection></connections></paramNode><paramNode><uid v="1000002606"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="oneminus"/><uid v="1000002613"/><attributes><category v="Functions/Math"/><description v="Evaluates the oneminus function graph. Result type: Float. Inputs: x."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="x"/><uid v="1000002614"/><attributes><label v="X"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002611"/><paramNodes><paramNode><uid v="1000002610"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="x"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002611"/><function v="sub"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002612"/></connection><connection><identifier v="b"/><connRef v="1000002610"/></connection></connections></paramNode><paramNode><uid v="1000002612"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="fmod"/><uid v="1000002626"/><attributes><category v="Functions/Math"/><description v="Evaluates the fmod function graph. Result type: Float. Inputs: a, b."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="a"/><uid v="1000002627"/><attributes><label v="A"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="b"/><uid v="1000002628"/><attributes><label v="B"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002622"/><paramNodes><paramNode><uid v="1000002615"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="a"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002616"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="b"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002617"/><function v="instance"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000002619"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/frac"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000002618"/><function v="div"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002615"/></connection><connection><identifier v="b"/><connRef v="1000002616"/></connection></connections></paramNode><paramNode><uid v="1000002619"/><function v="abs"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002618"/></connection></connections></paramNode><paramNode><uid v="1000002620"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002617"/></connection><connection><identifier v="b"/><connRef v="1000002621"/></connection></connections></paramNode><paramNode><uid v="1000002621"/><function v="abs"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002616"/></connection></connections></paramNode><paramNode><uid v="1000002622"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000002623"/></connection><connection><identifier v="ifpath"/><connRef v="1000002625"/></connection><connection><identifier v="elsepath"/><connRef v="1000002620"/></connection></connections></paramNode><paramNode><uid v="1000002623"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002615"/></connection><connection><identifier v="b"/><connRef v="1000002624"/></connection></connections></paramNode><paramNode><uid v="1000002624"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002625"/><function v="neg"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002620"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="frac"/><uid v="1000002632"/><attributes><category v="Functions/Math"/><description v="Evaluates the frac function graph. Result type: Float. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000002633"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002630"/><paramNodes><paramNode><uid v="1000002629"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002630"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002629"/></connection><connection><identifier v="b"/><connRef v="1000002631"/></connection></connections></paramNode><paramNode><uid v="1000002631"/><function v="floor"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002629"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="cross_product"/><uid v="1000002643"/><attributes><category v="Functions/Math"/><description v="Evaluates the cross_product function graph. Result type: Float3. Inputs: a, b."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="a"/><uid v="1000002644"/><attributes><label v="A"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="b"/><uid v="1000002645"/><attributes><label v="B"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000002638"/><paramNodes><paramNode><uid v="1000002634"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="a"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002635"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="b"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002636"/><function v="mul"/><type v="1024"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002637"/></connection><connection><identifier v="b"/><connRef v="1000002639"/></connection></connections></paramNode><paramNode><uid v="1000002637"/><function v="swizzle3"/><type v="1024"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002634"/></connection></connections><funcDatas><funcData><name v="swizzle3"/><constantValue><constantValueInt3 v="1 2 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002638"/><function v="sub"/><type v="1024"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002636"/></connection><connection><identifier v="b"/><connRef v="1000002641"/></connection></connections></paramNode><paramNode><uid v="1000002639"/><function v="swizzle3"/><type v="1024"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002635"/></connection></connections><funcDatas><funcData><name v="swizzle3"/><constantValue><constantValueInt3 v="2 0 1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002640"/><function v="swizzle3"/><type v="1024"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002634"/></connection></connections><funcDatas><funcData><name v="swizzle3"/><constantValue><constantValueInt3 v="2 0 1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002641"/><function v="mul"/><type v="1024"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002640"/></connection><connection><identifier v="b"/><connRef v="1000002642"/></connection></connections></paramNode><paramNode><uid v="1000002642"/><function v="swizzle3"/><type v="1024"/><GUILayout><gpos v="344 544 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002635"/></connection></connections><funcDatas><funcData><name v="swizzle3"/><constantValue><constantValueInt3 v="1 2 0"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="cross_product_vec2"/><uid v="1000002657"/><attributes><category v="Functions/Math"/><description v="Evaluates the cross_product_vec2 function graph. Result type: Float. Inputs: a, b."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="a"/><uid v="1000002658"/><attributes><label v="a"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="b"/><uid v="1000002659"/><attributes><label v="b"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002653"/><paramNodes><paramNode><uid v="1000002646"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002651"/></connection><connection><identifier v="b"/><connRef v="1000002650"/></connection></connections></paramNode><paramNode><uid v="1000002647"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002648"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002648"/><function v="passthrough"/><type v="512"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000002655"/></connection></connections></paramNode><paramNode><uid v="1000002649"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002652"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002650"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002648"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002651"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="624 544 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002652"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002652"/><function v="passthrough"/><type v="512"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000002656"/></connection></connections></paramNode><paramNode><uid v="1000002653"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002654"/></connection><connection><identifier v="b"/><connRef v="1000002646"/></connection></connections></paramNode><paramNode><uid v="1000002654"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002649"/></connection><connection><identifier v="b"/><connRef v="1000002647"/></connection></connections></paramNode><paramNode><uid v="1000002655"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="a"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002656"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="b"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="step"/><uid v="1000002666"/><attributes><category v="Functions/Math"/><description v="Evaluates the step function graph. Result type: Float. Inputs: a, x."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="a"/><uid v="1000002667"/><attributes><label v="A"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="x"/><uid v="1000002668"/><attributes><label v="X"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002663"/><paramNodes><paramNode><uid v="1000002660"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="a"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002661"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="x"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002662"/><function v="gteq"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002661"/></connection><connection><identifier v="b"/><connRef v="1000002660"/></connection></connections></paramNode><paramNode><uid v="1000002663"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000002662"/></connection><connection><identifier v="ifpath"/><connRef v="1000002664"/></connection><connection><identifier v="elsepath"/><connRef v="1000002665"/></connection></connections></paramNode><paramNode><uid v="1000002664"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002665"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="divide_float4"/><uid v="1000002682"/><attributes><category v="Functions/Math"/><description v="Evaluates the divide_float4 function graph. Result type: Float4. Inputs: input, scalar."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000002683"/><attributes><label v="input"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="scalar"/><uid v="1000002684"/><attributes><label v="scalar"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="2048"/><paramValue><dynamicValue><rootnode v="1000002681"/><paramNodes><paramNode><uid v="1000002669"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002670"/></connection><connection><identifier v="b"/><connRef v="1000002673"/></connection></connections></paramNode><paramNode><uid v="1000002670"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002679"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002671"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002679"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002672"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002671"/></connection><connection><identifier v="b"/><connRef v="1000002673"/></connection></connections></paramNode><paramNode><uid v="1000002673"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="scalar"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002674"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002669"/></connection><connection><identifier v="componentslast"/><connRef v="1000002672"/></connection></connections></paramNode><paramNode><uid v="1000002675"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002676"/></connection><connection><identifier v="b"/><connRef v="1000002673"/></connection></connections></paramNode><paramNode><uid v="1000002676"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002679"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002677"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002678"/></connection><connection><identifier v="b"/><connRef v="1000002673"/></connection></connections></paramNode><paramNode><uid v="1000002678"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 544 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002679"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002679"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002680"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002675"/></connection><connection><identifier v="componentslast"/><connRef v="1000002677"/></connection></connections></paramNode><paramNode><uid v="1000002681"/><function v="vector4"/><type v="2048"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002674"/></connection><connection><identifier v="componentslast"/><connRef v="1000002680"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="divide_float3"/><uid v="1000002695"/><attributes><category v="Functions/Math"/><description v="Evaluates the divide_float3 function graph. Result type: Float3. Inputs: input, scalar."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000002696"/><attributes><label v="input"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="scalar"/><uid v="1000002697"/><attributes><label v="scalar"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000002694"/><paramNodes><paramNode><uid v="1000002685"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002686"/></connection><connection><identifier v="b"/><connRef v="1000002689"/></connection></connections></paramNode><paramNode><uid v="1000002686"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002693"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002687"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002693"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002688"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002687"/></connection><connection><identifier v="b"/><connRef v="1000002689"/></connection></connections></paramNode><paramNode><uid v="1000002689"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="scalar"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002690"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002685"/></connection><connection><identifier v="componentslast"/><connRef v="1000002688"/></connection></connections></paramNode><paramNode><uid v="1000002691"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002692"/></connection><connection><identifier v="b"/><connRef v="1000002689"/></connection></connections></paramNode><paramNode><uid v="1000002692"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002693"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002693"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002694"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002690"/></connection><connection><identifier v="componentslast"/><connRef v="1000002691"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="divide_float2"/><uid v="1000002705"/><attributes><category v="Functions/Math"/><description v="Evaluates the divide_float2 function graph. Result type: Float2. Inputs: input, scalar."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000002706"/><attributes><label v="input"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="scalar"/><uid v="1000002707"/><attributes><label v="scalar"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="512"/><paramValue><dynamicValue><rootnode v="1000002704"/><paramNodes><paramNode><uid v="1000002698"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002699"/></connection><connection><identifier v="b"/><connRef v="1000002703"/></connection></connections></paramNode><paramNode><uid v="1000002699"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002700"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002700"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002701"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002700"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002702"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002701"/></connection><connection><identifier v="b"/><connRef v="1000002703"/></connection></connections></paramNode><paramNode><uid v="1000002703"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="scalar"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002704"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002698"/></connection><connection><identifier v="componentslast"/><connRef v="1000002702"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="clamp"/><uid v="1000002713"/><attributes><category v="Functions/Math"/><description v="Evaluates the clamp function graph. Result type: Float. Inputs: input, min, max."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000002714"/><attributes><label v="Input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="min"/><uid v="1000002715"/><attributes><label v="Min"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="max"/><uid v="1000002716"/><attributes><label v="Max"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002711"/><paramNodes><paramNode><uid v="1000002708"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002709"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="max"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002710"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="min"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002711"/><function v="max"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002710"/></connection><connection><identifier v="b"/><connRef v="1000002712"/></connection></connections></paramNode><paramNode><uid v="1000002712"/><function v="min"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002708"/></connection><connection><identifier v="b"/><connRef v="1000002709"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="normalize_vec2"/><uid v="1000002723"/><attributes><category v="Functions/Math"/><description v="Evaluates the normalize_vec2 function graph. Result type: Float2. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000002724"/><attributes><label v="input"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="512"/><paramValue><dynamicValue><rootnode v="1000002722"/><paramNodes><paramNode><uid v="1000002717"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002718"/><function v="dot"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002717"/></connection><connection><identifier v="b"/><connRef v="1000002717"/></connection></connections></paramNode><paramNode><uid v="1000002719"/><function v="sqrt"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002718"/></connection></connections></paramNode><paramNode><uid v="1000002720"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002721"/><function v="div"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002720"/></connection><connection><identifier v="b"/><connRef v="1000002719"/></connection></connections></paramNode><paramNode><uid v="1000002722"/><function v="mulscalar"/><type v="512"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002717"/></connection><connection><identifier v="scalar"/><connRef v="1000002721"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="normalize_vec3"/><uid v="1000002731"/><attributes><category v="Functions/Math"/><description v="Evaluates the normalize_vec3 function graph. Result type: Float3. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000002732"/><attributes><label v="input"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000002729"/><paramNodes><paramNode><uid v="1000002725"/><function v="dot"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002730"/></connection><connection><identifier v="b"/><connRef v="1000002730"/></connection></connections></paramNode><paramNode><uid v="1000002726"/><function v="sqrt"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002725"/></connection></connections></paramNode><paramNode><uid v="1000002727"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002728"/><function v="div"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002727"/></connection><connection><identifier v="b"/><connRef v="1000002726"/></connection></connections></paramNode><paramNode><uid v="1000002729"/><function v="mulscalar"/><type v="1024"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002730"/></connection><connection><identifier v="scalar"/><connRef v="1000002728"/></connection></connections></paramNode><paramNode><uid v="1000002730"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="normalize_vec4"/><uid v="1000002739"/><attributes><category v="Functions/Math"/><description v="Evaluates the normalize_vec4 function graph. Result type: Float4. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000002740"/><attributes><label v="input"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="2048"/><paramValue><dynamicValue><rootnode v="1000002737"/><paramNodes><paramNode><uid v="1000002733"/><function v="dot"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002738"/></connection><connection><identifier v="b"/><connRef v="1000002738"/></connection></connections></paramNode><paramNode><uid v="1000002734"/><function v="sqrt"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002733"/></connection></connections></paramNode><paramNode><uid v="1000002735"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002736"/><function v="div"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002735"/></connection><connection><identifier v="b"/><connRef v="1000002734"/></connection></connections></paramNode><paramNode><uid v="1000002737"/><function v="mulscalar"/><type v="2048"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002738"/></connection><connection><identifier v="scalar"/><connRef v="1000002736"/></connection></connections></paramNode><paramNode><uid v="1000002738"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="smoothstep"/><uid v="1000002754"/><attributes><category v="Functions/Math"/><description v="Evaluates the smoothstep function graph. Result type: Float. Inputs: a, b, x."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="a"/><uid v="1000002755"/><attributes><label v="A"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="b"/><uid v="1000002756"/><attributes><label v="B"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="x"/><uid v="1000002757"/><attributes><label v="X"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002748"/><paramNodes><paramNode><uid v="1000002741"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="x"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002742"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="a"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002743"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="b"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002744"/><function v="sub"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002741"/></connection><connection><identifier v="b"/><connRef v="1000002742"/></connection></connections></paramNode><paramNode><uid v="1000002745"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002744"/></connection><connection><identifier v="b"/><connRef v="1000002746"/></connection></connections></paramNode><paramNode><uid v="1000002746"/><function v="sub"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002743"/></connection><connection><identifier v="b"/><connRef v="1000002742"/></connection></connections></paramNode><paramNode><uid v="1000002747"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002753"/></connection><connection><identifier v="b"/><connRef v="1000002753"/></connection></connections></paramNode><paramNode><uid v="1000002748"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002747"/></connection><connection><identifier v="b"/><connRef v="1000002750"/></connection></connections></paramNode><paramNode><uid v="1000002749"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002750"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002749"/></connection><connection><identifier v="b"/><connRef v="1000002752"/></connection></connections></paramNode><paramNode><uid v="1000002751"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002752"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002751"/></connection><connection><identifier v="b"/><connRef v="1000002753"/></connection></connections></paramNode><paramNode><uid v="1000002753"/><function v="instance"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000002745"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/saturate"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="saturate_float2"/><uid v="1000002764"/><attributes><category v="Functions/Math"/><description v="Evaluates the saturate_float2 function graph. Result type: Float2. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000002765"/><attributes><label v="input"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="512"/><paramValue><dynamicValue><rootnode v="1000002758"/><paramNodes><paramNode><uid v="1000002758"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002760"/></connection><connection><identifier v="componentslast"/><connRef v="1000002759"/></connection></connections></paramNode><paramNode><uid v="1000002759"/><function v="instance"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000002761"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/saturate"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000002760"/><function v="instance"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000002762"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/saturate"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000002761"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002763"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002762"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002763"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002763"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="average_float1"/><uid v="1000002771"/><attributes><category v="Functions/Math"/><description v="Evaluates the average_float1 function graph. Result type: Float. Inputs: a, b."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="a"/><uid v="1000002772"/><attributes><label v="A"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="b"/><uid v="1000002773"/><attributes><label v="B"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002770"/><paramNodes><paramNode><uid v="1000002766"/><function v="add"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002768"/></connection><connection><identifier v="b"/><connRef v="1000002769"/></connection></connections></paramNode><paramNode><uid v="1000002767"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002768"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="a"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002769"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="b"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002770"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002766"/></connection><connection><identifier v="b"/><connRef v="1000002767"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="average_float2"/><uid v="1000002779"/><attributes><category v="Functions/Math"/><description v="Evaluates the average_float2 function graph. Result type: Float2. Inputs: a, b."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="a"/><uid v="1000002780"/><attributes><label v="a"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="b"/><uid v="1000002781"/><attributes><label v="b"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="512"/><paramValue><dynamicValue><rootnode v="1000002777"/><paramNodes><paramNode><uid v="1000002774"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="a"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002775"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="b"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002776"/><function v="add"/><type v="512"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002774"/></connection><connection><identifier v="b"/><connRef v="1000002775"/></connection></connections></paramNode><paramNode><uid v="1000002777"/><function v="mulscalar"/><type v="512"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002776"/></connection><connection><identifier v="scalar"/><connRef v="1000002778"/></connection></connections></paramNode><paramNode><uid v="1000002778"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="average_float3"/><uid v="1000002787"/><attributes><category v="Functions/Math"/><description v="Evaluates the average_float3 function graph. Result type: Float3. Inputs: a, b."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="a"/><uid v="1000002788"/><attributes><label v="a"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="b"/><uid v="1000002789"/><attributes><label v="b"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000002783"/><paramNodes><paramNode><uid v="1000002782"/><function v="add"/><type v="1024"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002785"/></connection><connection><identifier v="b"/><connRef v="1000002786"/></connection></connections></paramNode><paramNode><uid v="1000002783"/><function v="mulscalar"/><type v="1024"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002782"/></connection><connection><identifier v="scalar"/><connRef v="1000002784"/></connection></connections></paramNode><paramNode><uid v="1000002784"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002785"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="a"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002786"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="b"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="average_float4"/><uid v="1000002795"/><attributes><category v="Functions/Math"/><description v="Evaluates the average_float4 function graph. Result type: Float4. Inputs: a, b."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="a"/><uid v="1000002796"/><attributes><label v="a"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="b"/><uid v="1000002797"/><attributes><label v="b"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="2048"/><paramValue><dynamicValue><rootnode v="1000002791"/><paramNodes><paramNode><uid v="1000002790"/><function v="add"/><type v="2048"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002793"/></connection><connection><identifier v="b"/><connRef v="1000002794"/></connection></connections></paramNode><paramNode><uid v="1000002791"/><function v="mulscalar"/><type v="2048"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002790"/></connection><connection><identifier v="scalar"/><connRef v="1000002792"/></connection></connections></paramNode><paramNode><uid v="1000002792"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002793"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="a"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002794"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="b"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="orthogonal_vec2"/><uid v="1000002802"/><attributes><category v="Functions/Math"/><description v="Evaluates the orthogonal_vec2 function graph. Result type: Float2. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000002803"/><attributes><label v="input"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="512"/><paramValue><dynamicValue><rootnode v="1000002798"/><paramNodes><paramNode><uid v="1000002798"/><function v="mul"/><type v="512"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002799"/></connection><connection><identifier v="b"/><connRef v="1000002800"/></connection></connections></paramNode><paramNode><uid v="1000002799"/><function v="swizzle2"/><type v="512"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002801"/></connection></connections><funcDatas><funcData><name v="swizzle2"/><constantValue><constantValueInt2 v="1 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002800"/><function v="const_float2"/><type v="512"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float2"/><constantValue><constantValueFloat2 v="1 -1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002801"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="saturate"/><uid v="1000002809"/><attributes><category v="Functions/Math"/><description v="Evaluates the saturate function graph. Result type: Float. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000002810"/><attributes><label v="Input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002808"/><paramNodes><paramNode><uid v="1000002804"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002805"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002806"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002807"/><function v="min"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002805"/></connection><connection><identifier v="b"/><connRef v="1000002806"/></connection></connections></paramNode><paramNode><uid v="1000002808"/><function v="max"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002804"/></connection><connection><identifier v="b"/><connRef v="1000002807"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="truncate_float1_decimals"/><uid v="1000002822"/><attributes><category v="Functions/Math"/><description v="Evaluates the truncate_float1_decimals function graph. Result type: Float. Inputs: input, decimals."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000002823"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="decimals"/><uid v="1000002824"/><attributes><label v="decimals"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002819"/><paramNodes><paramNode><uid v="1000002811"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002812"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002811"/></connection><connection><identifier v="b"/><connRef v="1000002817"/></connection></connections></paramNode><paramNode><uid v="1000002813"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="10"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002814"/><function v="floor"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002812"/></connection></connections></paramNode><paramNode><uid v="1000002815"/><function v="div"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002814"/></connection><connection><identifier v="b"/><connRef v="1000002817"/></connection></connections></paramNode><paramNode><uid v="1000002816"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="decimals"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002817"/><function v="instance"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="n"/><connRef v="1000002818"/></connection><connection><identifier v="x"/><connRef v="1000002813"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Pow"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="n"/><type v="0"/></input><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000002818"/><function v="tofloat"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000002816"/></connection></connections></paramNode><paramNode><uid v="1000002819"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000002820"/></connection><connection><identifier v="ifpath"/><connRef v="1000002811"/></connection><connection><identifier v="elsepath"/><connRef v="1000002815"/></connection></connections></paramNode><paramNode><uid v="1000002820"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002816"/></connection><connection><identifier v="b"/><connRef v="1000002821"/></connection></connections></paramNode><paramNode><uid v="1000002821"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="round_float1"/><uid v="1000002829"/><attributes><category v="Functions/Math"/><description v="Evaluates the round_float1 function graph. Result type: Float. Inputs: input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000002830"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002828"/><paramNodes><paramNode><uid v="1000002825"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002826"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002827"/><function v="add"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002825"/></connection><connection><identifier v="b"/><connRef v="1000002826"/></connection></connections></paramNode><paramNode><uid v="1000002828"/><function v="floor"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002827"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><group><identifier v="Parity"/><uid v="1000002831"/><content><function><identifier v="EvenCount"/><uid v="1000002837"/><attributes><category v="Functions/Math/Parity"/><description v="Evaluates the EvenCount function graph. Result type: Float. Inputs: Input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="Input"/><uid v="1000002838"/><attributes><label v="Input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002836"/><paramNodes><paramNode><uid v="1000002832"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="Input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002833"/><function v="floor"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002832"/></connection></connections></paramNode><paramNode><uid v="1000002834"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002835"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002833"/></connection><connection><identifier v="b"/><connRef v="1000002834"/></connection></connections></paramNode><paramNode><uid v="1000002836"/><function v="ceil"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002835"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="OddCount"/><uid v="1000002844"/><attributes><category v="Functions/Math/Parity"/><description v="Evaluates the OddCount function graph. Result type: Float. Inputs: Input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="Input"/><uid v="1000002845"/><attributes><label v="Input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002843"/><paramNodes><paramNode><uid v="1000002839"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="Input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002840"/><function v="floor"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002839"/></connection></connections></paramNode><paramNode><uid v="1000002841"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002842"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002840"/></connection><connection><identifier v="b"/><connRef v="1000002841"/></connection></connections></paramNode><paramNode><uid v="1000002843"/><function v="floor"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002842"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="ParityTest"/><uid v="1000002856"/><attributes><category v="Functions/Math/Parity"/><description v="Evaluates the ParityTest function graph. Result type: Boolean. Inputs: Input."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="Input"/><uid v="1000002857"/><attributes><label v="Input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="4"/><paramValue><dynamicValue><rootnode v="1000002846"/><paramNodes><paramNode><uid v="1000002846"/><function v="gt"/><type v="4"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002855"/></connection><connection><identifier v="b"/><connRef v="1000002854"/></connection></connections></paramNode><paramNode><uid v="1000002847"/><function v="floor"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002848"/></connection></connections></paramNode><paramNode><uid v="1000002848"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002851"/></connection><connection><identifier v="b"/><connRef v="1000002849"/></connection></connections></paramNode><paramNode><uid v="1000002849"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.25"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002850"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002851"/><function v="add"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002853"/></connection><connection><identifier v="b"/><connRef v="1000002850"/></connection></connections></paramNode><paramNode><uid v="1000002852"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="Input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002853"/><function v="add"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002852"/></connection><connection><identifier v="b"/><connRef v="1000002852"/></connection></connections></paramNode><paramNode><uid v="1000002854"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002848"/></connection><connection><identifier v="b"/><connRef v="1000002847"/></connection></connections></paramNode><paramNode><uid v="1000002855"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="Trigo"/><uid v="1000002858"/><content><function><identifier v="deg_to_rad"/><uid v="1000002864"/><attributes><category v="Functions/Math/Trigo"/><description v="Evaluates the deg_to_rad function graph. Result type: Float. Inputs: deg."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="deg"/><uid v="1000002865"/><attributes><label v="deg"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002862"/><paramNodes><paramNode><uid v="1000002859"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="deg"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002860"/><function v="div"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002863"/></connection><connection><identifier v="b"/><connRef v="1000002861"/></connection></connections></paramNode><paramNode><uid v="1000002861"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="180"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002862"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002859"/></connection><connection><identifier v="b"/><connRef v="1000002860"/></connection></connections></paramNode><paramNode><uid v="1000002863"/><function v="instance"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Pi"/></constantValue></funcData></funcDatas><materialcraftInterface></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="asin"/><uid v="1000002888"/><attributes><category v="Functions/Math/Trigo"/><description v="Evaluates the asin function graph. Result type: Float. Inputs: x."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="x"/><uid v="1000002889"/><attributes><label v="x"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002884"/><paramNodes><paramNode><uid v="1000002866"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="-0.0187293"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002867"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1.5707288"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002868"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.074261"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002869"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="-0.2121144"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002870"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="x"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002871"/><function v="abs"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002870"/></connection></connections></paramNode><paramNode><uid v="1000002872"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002871"/></connection><connection><identifier v="b"/><connRef v="1000002866"/></connection></connections></paramNode><paramNode><uid v="1000002873"/><function v="add"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002872"/></connection><connection><identifier v="b"/><connRef v="1000002868"/></connection></connections></paramNode><paramNode><uid v="1000002874"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002871"/></connection><connection><identifier v="b"/><connRef v="1000002873"/></connection></connections></paramNode><paramNode><uid v="1000002875"/><function v="add"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002874"/></connection><connection><identifier v="b"/><connRef v="1000002869"/></connection></connections></paramNode><paramNode><uid v="1000002876"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002871"/></connection><connection><identifier v="b"/><connRef v="1000002875"/></connection></connections></paramNode><paramNode><uid v="1000002877"/><function v="add"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002876"/></connection><connection><identifier v="b"/><connRef v="1000002867"/></connection></connections></paramNode><paramNode><uid v="1000002878"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002879"/></connection><connection><identifier v="b"/><connRef v="1000002871"/></connection></connections></paramNode><paramNode><uid v="1000002879"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002880"/><function v="sqrt"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002878"/></connection></connections></paramNode><paramNode><uid v="1000002881"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1.5707964"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002882"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002880"/></connection><connection><identifier v="b"/><connRef v="1000002877"/></connection></connections></paramNode><paramNode><uid v="1000002883"/><function v="sub"/><type v="256"/><GUILayout><gpos v="2584 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002881"/></connection><connection><identifier v="b"/><connRef v="1000002882"/></connection></connections></paramNode><paramNode><uid v="1000002884"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="2864 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000002885"/></connection><connection><identifier v="ifpath"/><connRef v="1000002883"/></connection><connection><identifier v="elsepath"/><connRef v="1000002887"/></connection></connections></paramNode><paramNode><uid v="1000002885"/><function v="gteq"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002870"/></connection><connection><identifier v="b"/><connRef v="1000002886"/></connection></connections></paramNode><paramNode><uid v="1000002886"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002887"/><function v="sub"/><type v="256"/><GUILayout><gpos v="2584 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002882"/></connection><connection><identifier v="b"/><connRef v="1000002881"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="acos"/><uid v="1000002896"/><attributes><category v="Functions/Math/Trigo"/><description v="Evaluates the acos function graph. Result type: Float. Inputs: x."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="x"/><uid v="1000002897"/><attributes><label v="x"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002891"/><paramNodes><paramNode><uid v="1000002890"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="x"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002891"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002892"/></connection><connection><identifier v="b"/><connRef v="1000002893"/></connection></connections></paramNode><paramNode><uid v="1000002892"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002894"/></connection><connection><identifier v="b"/><connRef v="1000002895"/></connection></connections></paramNode><paramNode><uid v="1000002893"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000002890"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Trigo/asin"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000002894"/><function v="instance"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Pi"/></constantValue></funcData></funcDatas><materialcraftInterface></materialcraftInterface></paramNode><paramNode><uid v="1000002895"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group></content></group></content></group></content></package> +<?xml version="1.0" encoding="UTF-8"?><package><identifier v="Functions"/><formatVersion v="1.1.0.202401"/><updaterVersion v="0.1.3"/><fileUID v="0"/><versionUID v="0"/><dependencies><dependency><filename v="?himself"/><uid v="1000000001"/><type v="package"/><fileUID v="0"/><versionUID v="0"/></dependency></dependencies><content><group><identifier v="Functions"/><uid v="1000000002"/><content><group><identifier v="Tonemappers"/><uid v="1000000003"/><content><function><identifier v="tonemap_Hejl"/><uid v="1000000039"/><attributes><category v=""/><description v="Evaluates the tonemap_Hejl function graph. Result type: Float3. Inputs: input."/><author v=""/><tags v="Color"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000040"/><attributes><label v="input"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000000029"/><paramNodes><paramNode><uid v="1000000004"/><function v="max"/><type v="1024"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000018"/></connection><connection><identifier v="b"/><connRef v="1000000011"/></connection></connections></paramNode><paramNode><uid v="1000000005"/><function v="add"/><type v="1024"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000028"/></connection><connection><identifier v="b"/><connRef v="1000000023"/></connection></connections></paramNode><paramNode><uid v="1000000006"/><function v="mulscalar"/><type v="1024"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000004"/></connection><connection><identifier v="scalar"/><connRef v="1000000012"/></connection></connections></paramNode><paramNode><uid v="1000000007"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1.25"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000008"/><function v="swizzle3"/><type v="1024"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000000016"/></connection></connections><funcDatas><funcData><name v="swizzle3"/><constantValue><constantValueInt3 v="0 0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000009"/><function v="swizzle3"/><type v="1024"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000000021"/></connection></connections><funcDatas><funcData><name v="swizzle3"/><constantValue><constantValueInt3 v="0 0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000010"/><function v="mulscalar"/><type v="1024"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000019"/></connection><connection><identifier v="scalar"/><connRef v="1000000007"/></connection></connections></paramNode><paramNode><uid v="1000000011"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0 0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000012"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.22"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000013"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000037"/></connection><connection><identifier v="b"/><connRef v="1000000022"/></connection></connections></paramNode><paramNode><uid v="1000000014"/><function v="mul"/><type v="1024"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000004"/></connection><connection><identifier v="b"/><connRef v="1000000005"/></connection></connections></paramNode><paramNode><uid v="1000000015"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000037"/></connection><connection><identifier v="b"/><connRef v="1000000032"/></connection></connections></paramNode><paramNode><uid v="1000000016"/><function v="div"/><type v="256"/><GUILayout><gpos v="344 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000032"/></connection><connection><identifier v="b"/><connRef v="1000000022"/></connection></connections></paramNode><paramNode><uid v="1000000017"/><function v="div"/><type v="1024"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000034"/></connection><connection><identifier v="b"/><connRef v="1000000033"/></connection></connections></paramNode><paramNode><uid v="1000000018"/><function v="sub"/><type v="1024"/><GUILayout><gpos v="344 704 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000038"/></connection><connection><identifier v="b"/><connRef v="1000000035"/></connection></connections></paramNode><paramNode><uid v="1000000019"/><function v="swizzle3"/><type v="1024"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000000015"/></connection></connections><funcDatas><funcData><name v="swizzle3"/><constantValue><constantValueInt3 v="0 0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000020"/><function v="swizzle3"/><type v="1024"/><GUILayout><gpos v="624 544 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000000036"/></connection></connections><funcDatas><funcData><name v="swizzle3"/><constantValue><constantValueInt3 v="0 0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000021"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000022"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000023"/><function v="mulscalar"/><type v="1024"/><GUILayout><gpos v="904 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000020"/></connection><connection><identifier v="scalar"/><connRef v="1000000007"/></connection></connections></paramNode><paramNode><uid v="1000000024"/><function v="mulscalar"/><type v="1024"/><GUILayout><gpos v="904 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000008"/></connection><connection><identifier v="scalar"/><connRef v="1000000007"/></connection></connections></paramNode><paramNode><uid v="1000000025"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 864 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000012"/></connection><connection><identifier v="b"/><connRef v="1000000007"/></connection></connections></paramNode><paramNode><uid v="1000000026"/><function v="mul"/><type v="1024"/><GUILayout><gpos v="1464 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000004"/></connection><connection><identifier v="b"/><connRef v="1000000027"/></connection></connections></paramNode><paramNode><uid v="1000000027"/><function v="add"/><type v="1024"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000006"/></connection><connection><identifier v="b"/><connRef v="1000000009"/></connection></connections></paramNode><paramNode><uid v="1000000028"/><function v="mulscalar"/><type v="1024"/><GUILayout><gpos v="904 704 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000004"/></connection><connection><identifier v="scalar"/><connRef v="1000000025"/></connection></connections></paramNode><paramNode><uid v="1000000029"/><function v="sub"/><type v="1024"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000017"/></connection><connection><identifier v="b"/><connRef v="1000000024"/></connection></connections></paramNode><paramNode><uid v="1000000030"/><function v="swizzle3"/><type v="1024"/><GUILayout><gpos v="624 704 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000000013"/></connection></connections><funcDatas><funcData><name v="swizzle3"/><constantValue><constantValueInt3 v="0 0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000031"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000032"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.01"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000033"/><function v="add"/><type v="1024"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000026"/></connection><connection><identifier v="b"/><connRef v="1000000030"/></connection></connections></paramNode><paramNode><uid v="1000000034"/><function v="add"/><type v="1024"/><GUILayout><gpos v="1744 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000014"/></connection><connection><identifier v="b"/><connRef v="1000000010"/></connection></connections></paramNode><paramNode><uid v="1000000035"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0.004 0.004 0.004"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000036"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 1024 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000021"/></connection><connection><identifier v="b"/><connRef v="1000000031"/></connection></connections></paramNode><paramNode><uid v="1000000037"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000038"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="tonemap_ACES"/><uid v="1000000070"/><attributes><category v=""/><description v="Evaluates the tonemap_ACES function graph. Result type: Float3. Inputs: input."/><author v=""/><tags v="Color"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000071"/><attributes><label v="input"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000000061"/><paramNodes><paramNode><uid v="1000000041"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000042"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0.000090537 0.000090537 0.000090537"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000043"/><function v="add"/><type v="1024"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000069"/></connection><connection><identifier v="b"/><connRef v="1000000044"/></connection></connections></paramNode><paramNode><uid v="1000000044"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0.0245786 0.0245786 0.0245786"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000045"/><function v="mul"/><type v="1024"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000069"/></connection><connection><identifier v="b"/><connRef v="1000000043"/></connection></connections></paramNode><paramNode><uid v="1000000046"/><function v="sub"/><type v="1024"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000045"/></connection><connection><identifier v="b"/><connRef v="1000000042"/></connection></connections></paramNode><paramNode><uid v="1000000047"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0.983729 0.983729 0.983729"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000048"/><function v="mul"/><type v="1024"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000069"/></connection><connection><identifier v="b"/><connRef v="1000000047"/></connection></connections></paramNode><paramNode><uid v="1000000049"/><function v="add"/><type v="1024"/><GUILayout><gpos v="1464 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000048"/></connection><connection><identifier v="b"/><connRef v="1000000050"/></connection></connections></paramNode><paramNode><uid v="1000000050"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0.432951 0.432951 0.432951"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000051"/><function v="mul"/><type v="1024"/><GUILayout><gpos v="1744 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000069"/></connection><connection><identifier v="b"/><connRef v="1000000049"/></connection></connections></paramNode><paramNode><uid v="1000000052"/><function v="add"/><type v="1024"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000051"/></connection><connection><identifier v="b"/><connRef v="1000000053"/></connection></connections></paramNode><paramNode><uid v="1000000053"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0.238081 0.238081 0.238081"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000054"/><function v="div"/><type v="1024"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000046"/></connection><connection><identifier v="b"/><connRef v="1000000052"/></connection></connections></paramNode><paramNode><uid v="1000000055"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="-0.00327 -0.07276 1.07602"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000056"/><function v="dot"/><type v="256"/><GUILayout><gpos v="2584 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000055"/></connection><connection><identifier v="b"/><connRef v="1000000054"/></connection></connections></paramNode><paramNode><uid v="1000000057"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="1.60475 -0.53108 -0.07367"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000058"/><function v="dot"/><type v="256"/><GUILayout><gpos v="2584 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000059"/></connection><connection><identifier v="b"/><connRef v="1000000054"/></connection></connections></paramNode><paramNode><uid v="1000000059"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="-0.10208 1.10813 -0.00605"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000060"/><function v="dot"/><type v="256"/><GUILayout><gpos v="2584 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000057"/></connection><connection><identifier v="b"/><connRef v="1000000054"/></connection></connections></paramNode><paramNode><uid v="1000000061"/><function v="instance"/><type v="118772"/><GUILayout><gpos v="2864 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000060"/></connection><connection><identifier v="y"/><connRef v="1000000058"/></connection><connection><identifier v="z"/><connRef v="1000000056"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/merge_float3"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input><input><identifier v="y"/><type v="0"/></input><input><identifier v="z"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000062"/><function v="instance"/><type v="118772"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000067"/></connection><connection><identifier v="y"/><connRef v="1000000064"/></connection><connection><identifier v="z"/><connRef v="1000000065"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/merge_float3"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input><input><identifier v="y"/><type v="0"/></input><input><identifier v="z"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000063"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0.076 0.90834 0.01566"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000064"/><function v="dot"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000063"/></connection><connection><identifier v="b"/><connRef v="1000000041"/></connection></connections></paramNode><paramNode><uid v="1000000065"/><function v="dot"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000066"/></connection><connection><identifier v="b"/><connRef v="1000000041"/></connection></connections></paramNode><paramNode><uid v="1000000066"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 1664 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0.00284 0.13383 0.83777"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000067"/><function v="dot"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000068"/></connection><connection><identifier v="b"/><connRef v="1000000041"/></connection></connections></paramNode><paramNode><uid v="1000000068"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 1824 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0.59719 0.35458 0.04823"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000069"/><function v="passthrough"/><type v="1024"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000000062"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="tonemap_AgX"/><uid v="1000000116"/><attributes><category v=""/><description v="Evaluates the tonemap_AgX function graph. Result type: Float3. Inputs: input, slope, power, offset, saturation."/><author v=""/><tags v="Color"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000117"/><attributes><label v="input"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="slope"/><uid v="1000000118"/><attributes><label v="slope"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="power"/><uid v="1000000119"/><attributes><label v="power"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="offset"/><uid v="1000000120"/><attributes><label v="offset"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="saturation"/><uid v="1000000121"/><attributes><label v="saturation"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000000104"/><paramNodes><paramNode><uid v="1000000072"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000073"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="-12.47393"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000074"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="4.026069"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000075"/><function v="log2"/><type v="1024"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000112"/></connection></connections></paramNode><paramNode><uid v="1000000076"/><function v="max"/><type v="1024"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000075"/></connection><connection><identifier v="b"/><connRef v="1000000077"/></connection></connections></paramNode><paramNode><uid v="1000000077"/><function v="swizzle3"/><type v="1024"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000000073"/></connection></connections><funcDatas><funcData><name v="swizzle3"/><constantValue><constantValueInt3 v="0 0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000078"/><function v="min"/><type v="1024"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000076"/></connection><connection><identifier v="b"/><connRef v="1000000079"/></connection></connections></paramNode><paramNode><uid v="1000000079"/><function v="swizzle3"/><type v="1024"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000000074"/></connection></connections><funcDatas><funcData><name v="swizzle3"/><constantValue><constantValueInt3 v="0 0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000080"/><function v="sub"/><type v="1024"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000078"/></connection><connection><identifier v="b"/><connRef v="1000000077"/></connection></connections></paramNode><paramNode><uid v="1000000081"/><function v="sub"/><type v="1024"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000079"/></connection><connection><identifier v="b"/><connRef v="1000000077"/></connection></connections></paramNode><paramNode><uid v="1000000082"/><function v="div"/><type v="1024"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000080"/></connection><connection><identifier v="b"/><connRef v="1000000081"/></connection></connections></paramNode><paramNode><uid v="1000000083"/><function v="passthrough"/><type v="1024"/><GUILayout><gpos v="3144 64 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000000089"/></connection></connections></paramNode><paramNode><uid v="1000000084"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="power"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000085"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="offset"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000086"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="saturation"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000087"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="slope"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000088"/><function v="instance"/><type v="1024"/><GUILayout><gpos v="2584 64 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000000082"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Tonemappers/tonemap_AgX_approx"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000089"/><function v="instance"/><type v="1024"/><GUILayout><gpos v="2864 64 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000000088"/></connection><connection><identifier v="offset"/><connRef v="1000000091"/></connection><connection><identifier v="slope"/><connRef v="1000000093"/></connection><connection><identifier v="power"/><connRef v="1000000095"/></connection><connection><identifier v="saturation"/><connRef v="1000000098"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Tonemappers/tonemap_AgX_look"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input"/><type v="0"/></input><input><identifier v="offset"/><type v="0"/></input><input><identifier v="slope"/><type v="0"/></input><input><identifier v="power"/><type v="0"/></input><input><identifier v="saturation"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000090"/><function v="isdefined"/><type v="4"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="isdefined"/><constantValue><constantValueString v="offset"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000091"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000090"/></connection><connection><identifier v="ifpath"/><connRef v="1000000085"/></connection><connection><identifier v="elsepath"/><connRef v="1000000092"/></connection></connections></paramNode><paramNode><uid v="1000000092"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0 0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000093"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="344 548 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000094"/></connection><connection><identifier v="ifpath"/><connRef v="1000000087"/></connection><connection><identifier v="elsepath"/><connRef v="1000000092"/></connection></connections></paramNode><paramNode><uid v="1000000094"/><function v="isdefined"/><type v="4"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="isdefined"/><constantValue><constantValueString v="slope"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000095"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="344 712 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000096"/></connection><connection><identifier v="ifpath"/><connRef v="1000000084"/></connection><connection><identifier v="elsepath"/><connRef v="1000000092"/></connection></connections></paramNode><paramNode><uid v="1000000096"/><function v="isdefined"/><type v="4"/><GUILayout><gpos v="64 1664 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="isdefined"/><constantValue><constantValueString v="power"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000097"/><function v="isdefined"/><type v="4"/><GUILayout><gpos v="64 1824 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="isdefined"/><constantValue><constantValueString v="saturation"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000098"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="344 876 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000097"/></connection><connection><identifier v="ifpath"/><connRef v="1000000086"/></connection><connection><identifier v="elsepath"/><connRef v="1000000099"/></connection></connections></paramNode><paramNode><uid v="1000000099"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1984 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000100"/><function v="dot"/><type v="256"/><GUILayout><gpos v="3424 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000105"/></connection><connection><identifier v="b"/><connRef v="1000000083"/></connection></connections></paramNode><paramNode><uid v="1000000101"/><function v="dot"/><type v="256"/><GUILayout><gpos v="3424 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000106"/></connection><connection><identifier v="b"/><connRef v="1000000083"/></connection></connections></paramNode><paramNode><uid v="1000000102"/><function v="dot"/><type v="256"/><GUILayout><gpos v="3424 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000107"/></connection><connection><identifier v="b"/><connRef v="1000000083"/></connection></connections></paramNode><paramNode><uid v="1000000103"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="3704 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000000100"/></connection><connection><identifier v="componentslast"/><connRef v="1000000101"/></connection></connections></paramNode><paramNode><uid v="1000000104"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="3984 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000000103"/></connection><connection><identifier v="componentslast"/><connRef v="1000000102"/></connection></connections></paramNode><paramNode><uid v="1000000105"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 2144 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="1.196879 -0.09802088 -0.09902974"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000106"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 2304 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="-0.05289685 1.151903 -0.09896117"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000107"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 2464 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="-0.05297164 -0.09804345 1.1510737"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000108"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000000111"/></connection><connection><identifier v="componentslast"/><connRef v="1000000110"/></connection></connections></paramNode><paramNode><uid v="1000000109"/><function v="dot"/><type v="256"/><GUILayout><gpos v="344 1040 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000072"/></connection><connection><identifier v="b"/><connRef v="1000000115"/></connection></connections></paramNode><paramNode><uid v="1000000110"/><function v="dot"/><type v="256"/><GUILayout><gpos v="344 1200 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000072"/></connection><connection><identifier v="b"/><connRef v="1000000114"/></connection></connections></paramNode><paramNode><uid v="1000000111"/><function v="dot"/><type v="256"/><GUILayout><gpos v="344 1360 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000072"/></connection><connection><identifier v="b"/><connRef v="1000000113"/></connection></connections></paramNode><paramNode><uid v="1000000112"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000000108"/></connection><connection><identifier v="componentslast"/><connRef v="1000000109"/></connection></connections></paramNode><paramNode><uid v="1000000113"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 2624 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0.84247905 0.0784336 0.07922374"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000114"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 2784 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0.04232824 0.8784686 0.07916613"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000115"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 2944 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0.04237565 0.0784336 0.879143"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="tonemap_AgX_look"/><uid v="1000000136"/><attributes><category v=""/><description v="Evaluates the tonemap_AgX_look function graph. Result type: Float3. Inputs: input, offset, slope, power, saturation."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000137"/><attributes><label v="input"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="offset"/><uid v="1000000138"/><attributes><label v="offset"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="slope"/><uid v="1000000139"/><attributes><label v="slope"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="power"/><uid v="1000000140"/><attributes><label v="power"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="saturation"/><uid v="1000000141"/><attributes><label v="saturation"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000000135"/><paramNodes><paramNode><uid v="1000000122"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000123"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0.2126 0.7152 0.0722"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000124"/><function v="dot"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000123"/></connection><connection><identifier v="b"/><connRef v="1000000122"/></connection></connections></paramNode><paramNode><uid v="1000000125"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="slope"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000126"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="offset"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000127"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="power"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000128"/><function v="mul"/><type v="1024"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000122"/></connection><connection><identifier v="b"/><connRef v="1000000125"/></connection></connections></paramNode><paramNode><uid v="1000000129"/><function v="add"/><type v="1024"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000128"/></connection><connection><identifier v="b"/><connRef v="1000000126"/></connection></connections></paramNode><paramNode><uid v="1000000130"/><function v="pow"/><type v="1024"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000129"/></connection><connection><identifier v="b"/><connRef v="1000000127"/></connection></connections></paramNode><paramNode><uid v="1000000131"/><function v="sub"/><type v="1024"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000130"/></connection><connection><identifier v="b"/><connRef v="1000000132"/></connection></connections></paramNode><paramNode><uid v="1000000132"/><function v="swizzle3"/><type v="1024"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000000124"/></connection></connections><funcDatas><funcData><name v="swizzle3"/><constantValue><constantValueInt3 v="0 0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000133"/><function v="mulscalar"/><type v="1024"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000131"/></connection><connection><identifier v="scalar"/><connRef v="1000000134"/></connection></connections></paramNode><paramNode><uid v="1000000134"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="saturation"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000135"/><function v="add"/><type v="1024"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000133"/></connection><connection><identifier v="b"/><connRef v="1000000132"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="tonemap_AgX_approx"/><uid v="1000000167"/><attributes><category v=""/><description v="Evaluates the tonemap_AgX_approx function graph. Result type: Float3. Inputs: input."/><author v=""/><tags v="Color"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000168"/><attributes><label v="input"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000000165"/><paramNodes><paramNode><uid v="1000000142"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000143"/><function v="mul"/><type v="1024"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000142"/></connection><connection><identifier v="b"/><connRef v="1000000142"/></connection></connections></paramNode><paramNode><uid v="1000000144"/><function v="mul"/><type v="1024"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000143"/></connection><connection><identifier v="b"/><connRef v="1000000143"/></connection></connections></paramNode><paramNode><uid v="1000000145"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="15.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000146"/><function v="mul"/><type v="1024"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000144"/></connection><connection><identifier v="b"/><connRef v="1000000143"/></connection></connections></paramNode><paramNode><uid v="1000000147"/><function v="mulscalar"/><type v="1024"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000146"/></connection><connection><identifier v="scalar"/><connRef v="1000000145"/></connection></connections></paramNode><paramNode><uid v="1000000148"/><function v="sub"/><type v="1024"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000147"/></connection><connection><identifier v="b"/><connRef v="1000000150"/></connection></connections></paramNode><paramNode><uid v="1000000149"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="40.14"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000150"/><function v="mulscalar"/><type v="1024"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000151"/></connection><connection><identifier v="scalar"/><connRef v="1000000149"/></connection></connections></paramNode><paramNode><uid v="1000000151"/><function v="mul"/><type v="1024"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000144"/></connection><connection><identifier v="b"/><connRef v="1000000142"/></connection></connections></paramNode><paramNode><uid v="1000000152"/><function v="mulscalar"/><type v="1024"/><GUILayout><gpos v="904 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000144"/></connection><connection><identifier v="scalar"/><connRef v="1000000153"/></connection></connections></paramNode><paramNode><uid v="1000000153"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="31.96"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000154"/><function v="add"/><type v="1024"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000148"/></connection><connection><identifier v="b"/><connRef v="1000000152"/></connection></connections></paramNode><paramNode><uid v="1000000155"/><function v="mulscalar"/><type v="1024"/><GUILayout><gpos v="904 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000158"/></connection><connection><identifier v="scalar"/><connRef v="1000000156"/></connection></connections></paramNode><paramNode><uid v="1000000156"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="6.868"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000157"/><function v="sub"/><type v="1024"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000154"/></connection><connection><identifier v="b"/><connRef v="1000000155"/></connection></connections></paramNode><paramNode><uid v="1000000158"/><function v="mul"/><type v="1024"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000143"/></connection><connection><identifier v="b"/><connRef v="1000000142"/></connection></connections></paramNode><paramNode><uid v="1000000159"/><function v="mulscalar"/><type v="1024"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000143"/></connection><connection><identifier v="scalar"/><connRef v="1000000161"/></connection></connections></paramNode><paramNode><uid v="1000000160"/><function v="add"/><type v="1024"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000157"/></connection><connection><identifier v="b"/><connRef v="1000000159"/></connection></connections></paramNode><paramNode><uid v="1000000161"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.4298"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000162"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.1191"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000163"/><function v="mulscalar"/><type v="1024"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000142"/></connection><connection><identifier v="scalar"/><connRef v="1000000162"/></connection></connections></paramNode><paramNode><uid v="1000000164"/><function v="add"/><type v="1024"/><GUILayout><gpos v="2584 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000160"/></connection><connection><identifier v="b"/><connRef v="1000000163"/></connection></connections></paramNode><paramNode><uid v="1000000165"/><function v="sub"/><type v="1024"/><GUILayout><gpos v="2864 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000164"/></connection><connection><identifier v="b"/><connRef v="1000000166"/></connection></connections></paramNode><paramNode><uid v="1000000166"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0.00232 0.00232 0.00232"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="easings"/><uid v="1000000169"/><content><group><identifier v="circ"/><uid v="1000000170"/><content><function><identifier v="ease_in_circ"/><uid v="1000000176"/><attributes><category v=""/><description v="Evaluates the ease_in_circ function graph. Result type: Float. Inputs: input."/><author v=""/><tags v="Easing"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000177"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000172"/><paramNodes><paramNode><uid v="1000000171"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000172"/><function v="instance"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000173"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000173"/><function v="sqrt"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000174"/></connection></connections></paramNode><paramNode><uid v="1000000174"/><function v="instance"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000175"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000175"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000171"/></connection><connection><identifier v="b"/><connRef v="1000000171"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="ease_out_circ"/><uid v="1000000184"/><attributes><category v=""/><description v="Evaluates the ease_out_circ function graph. Result type: Float. Inputs: input."/><author v=""/><tags v="Easing"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000185"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000179"/><paramNodes><paramNode><uid v="1000000178"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000179"/><function v="sqrt"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000180"/></connection></connections></paramNode><paramNode><uid v="1000000180"/><function v="instance"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000181"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000181"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000182"/></connection><connection><identifier v="b"/><connRef v="1000000182"/></connection></connections></paramNode><paramNode><uid v="1000000182"/><function v="sub"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000178"/></connection><connection><identifier v="b"/><connRef v="1000000183"/></connection></connections></paramNode><paramNode><uid v="1000000183"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="ease_in_out_circ"/><uid v="1000000208"/><attributes><category v=""/><description v="Evaluates the ease_in_out_circ function graph. Result type: Float. Inputs: input."/><author v=""/><tags v="Easing"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000209"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000191"/><paramNodes><paramNode><uid v="1000000186"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000187"/><function v="sqrt"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000188"/></connection></connections></paramNode><paramNode><uid v="1000000188"/><function v="instance"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000196"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000189"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000186"/></connection><connection><identifier v="b"/><connRef v="1000000190"/></connection></connections></paramNode><paramNode><uid v="1000000190"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000191"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000189"/></connection><connection><identifier v="ifpath"/><connRef v="1000000206"/></connection><connection><identifier v="elsepath"/><connRef v="1000000207"/></connection></connections></paramNode><paramNode><uid v="1000000192"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000186"/></connection><connection><identifier v="b"/><connRef v="1000000193"/></connection></connections></paramNode><paramNode><uid v="1000000193"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="-2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000194"/><function v="add"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000192"/></connection><connection><identifier v="b"/><connRef v="1000000195"/></connection></connections></paramNode><paramNode><uid v="1000000195"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000196"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000194"/></connection><connection><identifier v="b"/><connRef v="1000000194"/></connection></connections></paramNode><paramNode><uid v="1000000197"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000198"/><function v="instance"/><type v="256"/><GUILayout><gpos v="1464 224 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000199"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000199"/><function v="sqrt"/><type v="256"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000200"/></connection></connections></paramNode><paramNode><uid v="1000000200"/><function v="instance"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000203"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000201"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000202"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000186"/></connection><connection><identifier v="b"/><connRef v="1000000201"/></connection></connections></paramNode><paramNode><uid v="1000000203"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000202"/></connection><connection><identifier v="b"/><connRef v="1000000202"/></connection></connections></paramNode><paramNode><uid v="1000000204"/><function v="add"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000187"/></connection><connection><identifier v="b"/><connRef v="1000000205"/></connection></connections></paramNode><paramNode><uid v="1000000205"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000206"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1744 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000198"/></connection><connection><identifier v="b"/><connRef v="1000000197"/></connection></connections></paramNode><paramNode><uid v="1000000207"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000204"/></connection><connection><identifier v="b"/><connRef v="1000000197"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="expo"/><uid v="1000000210"/><content><function><identifier v="ease_in_expo"/><uid v="1000000219"/><attributes><category v=""/><description v="Evaluates the ease_in_expo function graph. Result type: Float. Inputs: input."/><author v=""/><tags v="Easing"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000220"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000212"/><paramNodes><paramNode><uid v="1000000211"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000212"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000213"/></connection><connection><identifier v="ifpath"/><connRef v="1000000214"/></connection><connection><identifier v="elsepath"/><connRef v="1000000218"/></connection></connections></paramNode><paramNode><uid v="1000000213"/><function v="eq"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000211"/></connection><connection><identifier v="b"/><connRef v="1000000214"/></connection></connections></paramNode><paramNode><uid v="1000000214"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000215"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000211"/></connection><connection><identifier v="b"/><connRef v="1000000216"/></connection></connections></paramNode><paramNode><uid v="1000000216"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="10"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000217"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000215"/></connection><connection><identifier v="b"/><connRef v="1000000216"/></connection></connections></paramNode><paramNode><uid v="1000000218"/><function v="pow2"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000217"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="ease_out_expo"/><uid v="1000000229"/><attributes><category v=""/><description v="Evaluates the ease_out_expo function graph. Result type: Float. Inputs: input."/><author v=""/><tags v="Easing"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000230"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000222"/><paramNodes><paramNode><uid v="1000000221"/><function v="eq"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000225"/></connection><connection><identifier v="b"/><connRef v="1000000224"/></connection></connections></paramNode><paramNode><uid v="1000000222"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000221"/></connection><connection><identifier v="ifpath"/><connRef v="1000000224"/></connection><connection><identifier v="elsepath"/><connRef v="1000000227"/></connection></connections></paramNode><paramNode><uid v="1000000223"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="-10"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000224"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000225"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000226"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000225"/></connection><connection><identifier v="b"/><connRef v="1000000223"/></connection></connections></paramNode><paramNode><uid v="1000000227"/><function v="instance"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000228"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000228"/><function v="pow2"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000226"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="ease_in_out_expo"/><uid v="1000000256"/><attributes><category v=""/><description v="Evaluates the ease_in_out_expo function graph. Result type: Float. Inputs: input."/><author v=""/><tags v="Easing"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000257"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000234"/><paramNodes><paramNode><uid v="1000000231"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000232"/><function v="eq"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000231"/></connection><connection><identifier v="b"/><connRef v="1000000233"/></connection></connections></paramNode><paramNode><uid v="1000000233"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000234"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000232"/></connection><connection><identifier v="ifpath"/><connRef v="1000000233"/></connection><connection><identifier v="elsepath"/><connRef v="1000000237"/></connection></connections></paramNode><paramNode><uid v="1000000235"/><function v="eq"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000231"/></connection><connection><identifier v="b"/><connRef v="1000000236"/></connection></connections></paramNode><paramNode><uid v="1000000236"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000237"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000235"/></connection><connection><identifier v="ifpath"/><connRef v="1000000236"/></connection><connection><identifier v="elsepath"/><connRef v="1000000240"/></connection></connections></paramNode><paramNode><uid v="1000000238"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000231"/></connection><connection><identifier v="b"/><connRef v="1000000239"/></connection></connections></paramNode><paramNode><uid v="1000000239"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000240"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000238"/></connection><connection><identifier v="ifpath"/><connRef v="1000000252"/></connection><connection><identifier v="elsepath"/><connRef v="1000000255"/></connection></connections></paramNode><paramNode><uid v="1000000241"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000231"/></connection><connection><identifier v="b"/><connRef v="1000000242"/></connection></connections></paramNode><paramNode><uid v="1000000242"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="20"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000243"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000241"/></connection><connection><identifier v="b"/><connRef v="1000000244"/></connection></connections></paramNode><paramNode><uid v="1000000244"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="10"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000245"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 704 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000231"/></connection><connection><identifier v="b"/><connRef v="1000000246"/></connection></connections></paramNode><paramNode><uid v="1000000246"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="-20"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000247"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000248"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="10"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000249"/><function v="add"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000245"/></connection><connection><identifier v="b"/><connRef v="1000000248"/></connection></connections></paramNode><paramNode><uid v="1000000250"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000247"/></connection><connection><identifier v="b"/><connRef v="1000000254"/></connection></connections></paramNode><paramNode><uid v="1000000251"/><function v="pow2"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000243"/></connection></connections></paramNode><paramNode><uid v="1000000252"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000251"/></connection><connection><identifier v="b"/><connRef v="1000000253"/></connection></connections></paramNode><paramNode><uid v="1000000253"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000254"/><function v="pow2"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000249"/></connection></connections></paramNode><paramNode><uid v="1000000255"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000250"/></connection><connection><identifier v="b"/><connRef v="1000000253"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="quint"/><uid v="1000000258"/><content><function><identifier v="ease_in_quint"/><uid v="1000000264"/><attributes><category v=""/><description v="Evaluates the ease_in_quint function graph. Result type: Float. Inputs: input."/><author v=""/><tags v="Easing"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000265"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000263"/><paramNodes><paramNode><uid v="1000000259"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000260"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000259"/></connection><connection><identifier v="b"/><connRef v="1000000259"/></connection></connections></paramNode><paramNode><uid v="1000000261"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000260"/></connection><connection><identifier v="b"/><connRef v="1000000259"/></connection></connections></paramNode><paramNode><uid v="1000000262"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000261"/></connection><connection><identifier v="b"/><connRef v="1000000259"/></connection></connections></paramNode><paramNode><uid v="1000000263"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000262"/></connection><connection><identifier v="b"/><connRef v="1000000259"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="ease_out_quint"/><uid v="1000000273"/><attributes><category v=""/><description v="Evaluates the ease_out_quint function graph. Result type: Float. Inputs: input."/><author v=""/><tags v="Easing"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000274"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000270"/><paramNodes><paramNode><uid v="1000000266"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000267"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000269"/></connection><connection><identifier v="b"/><connRef v="1000000269"/></connection></connections></paramNode><paramNode><uid v="1000000268"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000267"/></connection><connection><identifier v="b"/><connRef v="1000000269"/></connection></connections></paramNode><paramNode><uid v="1000000269"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000266"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000270"/><function v="instance"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000272"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000271"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000268"/></connection><connection><identifier v="b"/><connRef v="1000000269"/></connection></connections></paramNode><paramNode><uid v="1000000272"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000271"/></connection><connection><identifier v="b"/><connRef v="1000000269"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="ease_in_out_quint"/><uid v="1000000296"/><attributes><category v=""/><description v="Evaluates the ease_in_out_quint function graph. Result type: Float. Inputs: input."/><author v=""/><tags v="Easing"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000297"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000281"/><paramNodes><paramNode><uid v="1000000275"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="16"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000276"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000279"/></connection><connection><identifier v="b"/><connRef v="1000000279"/></connection></connections></paramNode><paramNode><uid v="1000000277"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000279"/></connection><connection><identifier v="b"/><connRef v="1000000280"/></connection></connections></paramNode><paramNode><uid v="1000000278"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000294"/></connection><connection><identifier v="b"/><connRef v="1000000275"/></connection></connections></paramNode><paramNode><uid v="1000000279"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000280"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000281"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="2864 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000277"/></connection><connection><identifier v="ifpath"/><connRef v="1000000278"/></connection><connection><identifier v="elsepath"/><connRef v="1000000283"/></connection></connections></paramNode><paramNode><uid v="1000000282"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000276"/></connection><connection><identifier v="b"/><connRef v="1000000279"/></connection></connections></paramNode><paramNode><uid v="1000000283"/><function v="instance"/><type v="256"/><GUILayout><gpos v="2584 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000288"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000284"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000285"/><function v="add"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000284"/></connection><connection><identifier v="b"/><connRef v="1000000290"/></connection></connections></paramNode><paramNode><uid v="1000000286"/><function v="neg"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000284"/></connection></connections></paramNode><paramNode><uid v="1000000287"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000285"/></connection><connection><identifier v="b"/><connRef v="1000000285"/></connection></connections></paramNode><paramNode><uid v="1000000288"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000295"/></connection><connection><identifier v="b"/><connRef v="1000000289"/></connection></connections></paramNode><paramNode><uid v="1000000289"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000290"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000279"/></connection><connection><identifier v="b"/><connRef v="1000000286"/></connection></connections></paramNode><paramNode><uid v="1000000291"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1464 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000287"/></connection><connection><identifier v="b"/><connRef v="1000000285"/></connection></connections></paramNode><paramNode><uid v="1000000292"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000282"/></connection><connection><identifier v="b"/><connRef v="1000000279"/></connection></connections></paramNode><paramNode><uid v="1000000293"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000291"/></connection><connection><identifier v="b"/><connRef v="1000000285"/></connection></connections></paramNode><paramNode><uid v="1000000294"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000292"/></connection><connection><identifier v="b"/><connRef v="1000000279"/></connection></connections></paramNode><paramNode><uid v="1000000295"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000293"/></connection><connection><identifier v="b"/><connRef v="1000000285"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="quart"/><uid v="1000000298"/><content><function><identifier v="ease_in_quart"/><uid v="1000000303"/><attributes><category v=""/><description v="Evaluates the ease_in_quart function graph. Result type: Float. Inputs: input."/><author v=""/><tags v="Easing"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000304"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000302"/><paramNodes><paramNode><uid v="1000000299"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000300"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000299"/></connection><connection><identifier v="b"/><connRef v="1000000299"/></connection></connections></paramNode><paramNode><uid v="1000000301"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000300"/></connection><connection><identifier v="b"/><connRef v="1000000299"/></connection></connections></paramNode><paramNode><uid v="1000000302"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000301"/></connection><connection><identifier v="b"/><connRef v="1000000299"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="ease_out_quart"/><uid v="1000000311"/><attributes><category v=""/><description v="Evaluates the ease_out_quart function graph. Result type: Float. Inputs: input."/><author v=""/><tags v="Easing"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000312"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000309"/><paramNodes><paramNode><uid v="1000000305"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000306"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000308"/></connection><connection><identifier v="b"/><connRef v="1000000308"/></connection></connections></paramNode><paramNode><uid v="1000000307"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000306"/></connection><connection><identifier v="b"/><connRef v="1000000308"/></connection></connections></paramNode><paramNode><uid v="1000000308"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000305"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000309"/><function v="instance"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000310"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000310"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000307"/></connection><connection><identifier v="b"/><connRef v="1000000308"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="ease_in_out_quart"/><uid v="1000000332"/><attributes><category v=""/><description v="Evaluates the ease_in_out_quart function graph. Result type: Float. Inputs: input."/><author v=""/><tags v="Easing"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000333"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000319"/><paramNodes><paramNode><uid v="1000000313"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="8"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000314"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000317"/></connection><connection><identifier v="b"/><connRef v="1000000317"/></connection></connections></paramNode><paramNode><uid v="1000000315"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000317"/></connection><connection><identifier v="b"/><connRef v="1000000318"/></connection></connections></paramNode><paramNode><uid v="1000000316"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000330"/></connection><connection><identifier v="b"/><connRef v="1000000313"/></connection></connections></paramNode><paramNode><uid v="1000000317"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000318"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000319"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="2584 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000315"/></connection><connection><identifier v="ifpath"/><connRef v="1000000316"/></connection><connection><identifier v="elsepath"/><connRef v="1000000321"/></connection></connections></paramNode><paramNode><uid v="1000000320"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000314"/></connection><connection><identifier v="b"/><connRef v="1000000317"/></connection></connections></paramNode><paramNode><uid v="1000000321"/><function v="instance"/><type v="256"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000326"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000322"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000323"/><function v="add"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000322"/></connection><connection><identifier v="b"/><connRef v="1000000328"/></connection></connections></paramNode><paramNode><uid v="1000000324"/><function v="neg"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000322"/></connection></connections></paramNode><paramNode><uid v="1000000325"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000323"/></connection><connection><identifier v="b"/><connRef v="1000000323"/></connection></connections></paramNode><paramNode><uid v="1000000326"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000331"/></connection><connection><identifier v="b"/><connRef v="1000000327"/></connection></connections></paramNode><paramNode><uid v="1000000327"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000328"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000317"/></connection><connection><identifier v="b"/><connRef v="1000000324"/></connection></connections></paramNode><paramNode><uid v="1000000329"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000325"/></connection><connection><identifier v="b"/><connRef v="1000000323"/></connection></connections></paramNode><paramNode><uid v="1000000330"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000320"/></connection><connection><identifier v="b"/><connRef v="1000000317"/></connection></connections></paramNode><paramNode><uid v="1000000331"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000329"/></connection><connection><identifier v="b"/><connRef v="1000000323"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="cubic"/><uid v="1000000334"/><content><function><identifier v="ease_in_cubic"/><uid v="1000000338"/><attributes><category v=""/><description v="Evaluates the ease_in_cubic function graph. Result type: Float. Inputs: input."/><author v=""/><tags v="Easing"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000339"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000337"/><paramNodes><paramNode><uid v="1000000335"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000336"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000335"/></connection><connection><identifier v="b"/><connRef v="1000000335"/></connection></connections></paramNode><paramNode><uid v="1000000337"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000336"/></connection><connection><identifier v="b"/><connRef v="1000000335"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="ease_out_cubic"/><uid v="1000000345"/><attributes><category v=""/><description v="Evaluates the ease_out_cubic function graph. Result type: Float. Inputs: input."/><author v=""/><tags v="Easing"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000346"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000344"/><paramNodes><paramNode><uid v="1000000340"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000341"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000343"/></connection><connection><identifier v="b"/><connRef v="1000000343"/></connection></connections></paramNode><paramNode><uid v="1000000342"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000341"/></connection><connection><identifier v="b"/><connRef v="1000000343"/></connection></connections></paramNode><paramNode><uid v="1000000343"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000340"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000344"/><function v="instance"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000342"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="ease_in_out_cubic"/><uid v="1000000364"/><attributes><category v=""/><description v="Evaluates the ease_in_out_cubic function graph. Result type: Float. Inputs: input."/><author v=""/><tags v="Easing"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000365"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000353"/><paramNodes><paramNode><uid v="1000000347"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000348"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000351"/></connection><connection><identifier v="b"/><connRef v="1000000351"/></connection></connections></paramNode><paramNode><uid v="1000000349"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000351"/></connection><connection><identifier v="b"/><connRef v="1000000352"/></connection></connections></paramNode><paramNode><uid v="1000000350"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000354"/></connection><connection><identifier v="b"/><connRef v="1000000347"/></connection></connections></paramNode><paramNode><uid v="1000000351"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000352"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000353"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000349"/></connection><connection><identifier v="ifpath"/><connRef v="1000000350"/></connection><connection><identifier v="elsepath"/><connRef v="1000000355"/></connection></connections></paramNode><paramNode><uid v="1000000354"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000348"/></connection><connection><identifier v="b"/><connRef v="1000000351"/></connection></connections></paramNode><paramNode><uid v="1000000355"/><function v="instance"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000360"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000356"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000357"/><function v="add"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000356"/></connection><connection><identifier v="b"/><connRef v="1000000362"/></connection></connections></paramNode><paramNode><uid v="1000000358"/><function v="neg"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000356"/></connection></connections></paramNode><paramNode><uid v="1000000359"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000357"/></connection><connection><identifier v="b"/><connRef v="1000000357"/></connection></connections></paramNode><paramNode><uid v="1000000360"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000363"/></connection><connection><identifier v="b"/><connRef v="1000000361"/></connection></connections></paramNode><paramNode><uid v="1000000361"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000362"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000351"/></connection><connection><identifier v="b"/><connRef v="1000000358"/></connection></connections></paramNode><paramNode><uid v="1000000363"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000359"/></connection><connection><identifier v="b"/><connRef v="1000000357"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="quad"/><uid v="1000000366"/><content><function><identifier v="ease_in_quad"/><uid v="1000000369"/><attributes><category v=""/><description v="Evaluates the ease_in_quad function graph. Result type: Float. Inputs: input."/><author v=""/><tags v="Easing"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000370"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000368"/><paramNodes><paramNode><uid v="1000000367"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000368"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000367"/></connection><connection><identifier v="b"/><connRef v="1000000367"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="ease_out_quad"/><uid v="1000000375"/><attributes><category v=""/><description v="Evaluates the ease_out_quad function graph. Result type: Float. Inputs: input."/><author v=""/><tags v="Easing"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000376"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000373"/><paramNodes><paramNode><uid v="1000000371"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000372"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000374"/></connection><connection><identifier v="b"/><connRef v="1000000374"/></connection></connections></paramNode><paramNode><uid v="1000000373"/><function v="instance"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000372"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000374"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000371"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="ease_in_out_quad"/><uid v="1000000390"/><attributes><category v=""/><description v="Evaluates the ease_in_out_quad function graph. Result type: Float. Inputs: input."/><author v=""/><tags v="Easing"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000391"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000380"/><paramNodes><paramNode><uid v="1000000377"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000378"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000377"/></connection><connection><identifier v="b"/><connRef v="1000000379"/></connection></connections></paramNode><paramNode><uid v="1000000379"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000380"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000378"/></connection><connection><identifier v="ifpath"/><connRef v="1000000382"/></connection><connection><identifier v="elsepath"/><connRef v="1000000383"/></connection></connections></paramNode><paramNode><uid v="1000000381"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000377"/></connection><connection><identifier v="b"/><connRef v="1000000377"/></connection></connections></paramNode><paramNode><uid v="1000000382"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000381"/></connection><connection><identifier v="b"/><connRef v="1000000387"/></connection></connections></paramNode><paramNode><uid v="1000000383"/><function v="instance"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000385"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000384"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000386"/></connection><connection><identifier v="b"/><connRef v="1000000386"/></connection></connections></paramNode><paramNode><uid v="1000000385"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000384"/></connection><connection><identifier v="b"/><connRef v="1000000379"/></connection></connections></paramNode><paramNode><uid v="1000000386"/><function v="add"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000387"/></connection><connection><identifier v="b"/><connRef v="1000000388"/></connection></connections></paramNode><paramNode><uid v="1000000387"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000388"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000377"/></connection><connection><identifier v="b"/><connRef v="1000000389"/></connection></connections></paramNode><paramNode><uid v="1000000389"/><function v="neg"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000387"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="sine"/><uid v="1000000392"/><content><function><identifier v="ease_in_sine"/><uid v="1000000400"/><attributes><category v=""/><description v="Evaluates the ease_in_sine function graph. Result type: Float. Inputs: input."/><author v=""/><tags v="Easing"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000401"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000399"/><paramNodes><paramNode><uid v="1000000393"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000394"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000393"/></connection><connection><identifier v="b"/><connRef v="1000000395"/></connection></connections></paramNode><paramNode><uid v="1000000395"/><function v="instance"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Pi"/></constantValue></funcData></funcDatas><materialcraftInterface></materialcraftInterface></paramNode><paramNode><uid v="1000000396"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000394"/></connection><connection><identifier v="b"/><connRef v="1000000397"/></connection></connections></paramNode><paramNode><uid v="1000000397"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000398"/><function v="cos"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000396"/></connection></connections></paramNode><paramNode><uid v="1000000399"/><function v="instance"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000000398"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="ease_out_sine"/><uid v="1000000408"/><attributes><category v=""/><description v="Evaluates the ease_out_sine function graph. Result type: Float. Inputs: input."/><author v=""/><tags v="Easing"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000409"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000407"/><paramNodes><paramNode><uid v="1000000402"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000403"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000402"/></connection><connection><identifier v="b"/><connRef v="1000000404"/></connection></connections></paramNode><paramNode><uid v="1000000404"/><function v="instance"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Pi"/></constantValue></funcData></funcDatas><materialcraftInterface></materialcraftInterface></paramNode><paramNode><uid v="1000000405"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000403"/></connection><connection><identifier v="b"/><connRef v="1000000406"/></connection></connections></paramNode><paramNode><uid v="1000000406"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000407"/><function v="sin"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000405"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="ease_in_out_sine"/><uid v="1000000419"/><attributes><category v=""/><description v="Evaluates the ease_in_out_sine function graph. Result type: Float. Inputs: input."/><author v=""/><tags v="Easing"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000000420"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000416"/><paramNodes><paramNode><uid v="1000000410"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000411"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000410"/></connection><connection><identifier v="b"/><connRef v="1000000412"/></connection></connections></paramNode><paramNode><uid v="1000000412"/><function v="instance"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Pi"/></constantValue></funcData></funcDatas><materialcraftInterface></materialcraftInterface></paramNode><paramNode><uid v="1000000413"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000417"/></connection><connection><identifier v="b"/><connRef v="1000000414"/></connection></connections></paramNode><paramNode><uid v="1000000414"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000415"/><function v="cos"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000411"/></connection></connections></paramNode><paramNode><uid v="1000000416"/><function v="neg"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000413"/></connection></connections></paramNode><paramNode><uid v="1000000417"/><function v="sub"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000415"/></connection><connection><identifier v="b"/><connRef v="1000000418"/></connection></connections></paramNode><paramNode><uid v="1000000418"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group></content></group><group><identifier v="switch"/><uid v="1000000421"/><content><group><identifier v="Integer4"/><uid v="1000000422"/><content><function><identifier v="switch_integer4_2_inputs"/><uid v="1000000429"/><attributes><category v=""/><description v="Evaluates the switch_integer4_2_inputs function graph. Result type: Integer4. Inputs: input_selection, value_1, value_2."/><author v=""/><tags v="Various"/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000430"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000431"/><attributes><label v="Value 1"/></attributes><type v="128"/><defaultValue><constantValueInt4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000432"/><attributes><label v="Value 2"/></attributes><type v="128"/><defaultValue><constantValueInt4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput></paraminputs><type v="128"/><paramValue><dynamicValue><rootnode v="1000000424"/><paramNodes><paramNode><uid v="1000000423"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000424"/><function v="ifelse"/><type v="128"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000426"/></connection><connection><identifier v="ifpath"/><connRef v="1000000427"/></connection><connection><identifier v="elsepath"/><connRef v="1000000428"/></connection></connections></paramNode><paramNode><uid v="1000000425"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000426"/><function v="gt"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000423"/></connection><connection><identifier v="b"/><connRef v="1000000425"/></connection></connections></paramNode><paramNode><uid v="1000000427"/><function v="get_integer4"/><type v="128"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer4"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000428"/><function v="get_integer4"/><type v="128"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer4"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="switch_integer4_4_inputs"/><uid v="1000000444"/><attributes><category v=""/><description v="Evaluates the switch_integer4_4_inputs function graph. Result type: Integer4. Inputs: input_selection, value_1, value_2, value_3, value_4."/><author v=""/><tags v="Various"/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000445"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000446"/><attributes><label v="Value 1"/></attributes><type v="128"/><defaultValue><constantValueInt4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000447"/><attributes><label v="Value 2"/></attributes><type v="128"/><defaultValue><constantValueInt4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_3"/><uid v="1000000448"/><attributes><label v="Value 3"/></attributes><type v="128"/><defaultValue><constantValueInt4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_4"/><uid v="1000000449"/><attributes><label v="Value 4"/></attributes><type v="128"/><defaultValue><constantValueInt4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput></paraminputs><type v="128"/><paramValue><dynamicValue><rootnode v="1000000435"/><paramNodes><paramNode><uid v="1000000433"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000434"/><function v="sub"/><type v="16"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000433"/></connection><connection><identifier v="b"/><connRef v="1000000436"/></connection></connections></paramNode><paramNode><uid v="1000000435"/><function v="ifelse"/><type v="128"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000437"/></connection><connection><identifier v="ifpath"/><connRef v="1000000442"/></connection><connection><identifier v="elsepath"/><connRef v="1000000443"/></connection></connections></paramNode><paramNode><uid v="1000000436"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000437"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000433"/></connection><connection><identifier v="b"/><connRef v="1000000436"/></connection></connections></paramNode><paramNode><uid v="1000000438"/><function v="get_integer4"/><type v="128"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer4"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000439"/><function v="get_integer4"/><type v="128"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer4"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000440"/><function v="get_integer4"/><type v="128"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer4"/><constantValue><constantValueString v="value_4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000441"/><function v="get_integer4"/><type v="128"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer4"/><constantValue><constantValueString v="value_3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000442"/><function v="instance"/><type v="128"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000433"/></connection><connection><identifier v="value_1"/><connRef v="1000000438"/></connection><connection><identifier v="value_2"/><connRef v="1000000439"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer4/switch_integer4_2_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000443"/><function v="instance"/><type v="128"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000434"/></connection><connection><identifier v="value_1"/><connRef v="1000000441"/></connection><connection><identifier v="value_2"/><connRef v="1000000440"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer4/switch_integer4_2_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="switch_integer4_8_inputs"/><uid v="1000000465"/><attributes><category v=""/><description v="Evaluates the switch_integer4_8_inputs function graph. Result type: Integer4. Inputs: input_selection, value_1, value_2, value_3, value_4, value_5, value_6, value_7, value_8."/><author v=""/><tags v="Various"/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000466"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000467"/><attributes><label v="Value 1"/></attributes><type v="128"/><defaultValue><constantValueInt4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000468"/><attributes><label v="Value 2"/></attributes><type v="128"/><defaultValue><constantValueInt4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_3"/><uid v="1000000469"/><attributes><label v="Value 3"/></attributes><type v="128"/><defaultValue><constantValueInt4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_4"/><uid v="1000000470"/><attributes><label v="Value 4"/></attributes><type v="128"/><defaultValue><constantValueInt4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_5"/><uid v="1000000471"/><attributes><label v="Value 5"/></attributes><type v="128"/><defaultValue><constantValueInt4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_6"/><uid v="1000000472"/><attributes><label v="Value 6"/></attributes><type v="128"/><defaultValue><constantValueInt4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_7"/><uid v="1000000473"/><attributes><label v="Value 7"/></attributes><type v="128"/><defaultValue><constantValueInt4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_8"/><uid v="1000000474"/><attributes><label v="Value 8"/></attributes><type v="128"/><defaultValue><constantValueInt4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput></paraminputs><type v="128"/><paramValue><dynamicValue><rootnode v="1000000451"/><paramNodes><paramNode><uid v="1000000450"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000451"/><function v="ifelse"/><type v="128"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000454"/></connection><connection><identifier v="ifpath"/><connRef v="1000000463"/></connection><connection><identifier v="elsepath"/><connRef v="1000000464"/></connection></connections></paramNode><paramNode><uid v="1000000452"/><function v="sub"/><type v="16"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000450"/></connection><connection><identifier v="b"/><connRef v="1000000453"/></connection></connections></paramNode><paramNode><uid v="1000000453"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000454"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000450"/></connection><connection><identifier v="b"/><connRef v="1000000453"/></connection></connections></paramNode><paramNode><uid v="1000000455"/><function v="get_integer4"/><type v="128"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer4"/><constantValue><constantValueString v="value_3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000456"/><function v="get_integer4"/><type v="128"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer4"/><constantValue><constantValueString v="value_4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000457"/><function v="get_integer4"/><type v="128"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer4"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000458"/><function v="get_integer4"/><type v="128"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer4"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000459"/><function v="get_integer4"/><type v="128"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer4"/><constantValue><constantValueString v="value_8"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000460"/><function v="get_integer4"/><type v="128"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer4"/><constantValue><constantValueString v="value_5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000461"/><function v="get_integer4"/><type v="128"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer4"/><constantValue><constantValueString v="value_6"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000462"/><function v="get_integer4"/><type v="128"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer4"/><constantValue><constantValueString v="value_7"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000463"/><function v="instance"/><type v="128"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000450"/></connection><connection><identifier v="value_1"/><connRef v="1000000457"/></connection><connection><identifier v="value_2"/><connRef v="1000000458"/></connection><connection><identifier v="value_3"/><connRef v="1000000455"/></connection><connection><identifier v="value_4"/><connRef v="1000000456"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer4/switch_integer4_4_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input><input><identifier v="value_3"/><type v="0"/></input><input><identifier v="value_4"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000464"/><function v="instance"/><type v="128"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000452"/></connection><connection><identifier v="value_1"/><connRef v="1000000460"/></connection><connection><identifier v="value_2"/><connRef v="1000000461"/></connection><connection><identifier v="value_3"/><connRef v="1000000462"/></connection><connection><identifier v="value_4"/><connRef v="1000000459"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer4/switch_integer4_4_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input><input><identifier v="value_3"/><type v="0"/></input><input><identifier v="value_4"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="Integer3"/><uid v="1000000475"/><content><function><identifier v="switch_integer3_2_inputs"/><uid v="1000000482"/><attributes><category v=""/><description v="Evaluates the switch_integer3_2_inputs function graph. Result type: Integer3. Inputs: input_selection, value_1, value_2."/><author v=""/><tags v="Various"/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000483"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000484"/><attributes><label v="Value 1"/></attributes><type v="64"/><defaultValue><constantValueInt3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000485"/><attributes><label v="Value 2"/></attributes><type v="64"/><defaultValue><constantValueInt3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput></paraminputs><type v="64"/><paramValue><dynamicValue><rootnode v="1000000477"/><paramNodes><paramNode><uid v="1000000476"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000477"/><function v="ifelse"/><type v="64"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000479"/></connection><connection><identifier v="ifpath"/><connRef v="1000000480"/></connection><connection><identifier v="elsepath"/><connRef v="1000000481"/></connection></connections></paramNode><paramNode><uid v="1000000478"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000479"/><function v="gt"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000476"/></connection><connection><identifier v="b"/><connRef v="1000000478"/></connection></connections></paramNode><paramNode><uid v="1000000480"/><function v="get_integer3"/><type v="64"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer3"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000481"/><function v="get_integer3"/><type v="64"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer3"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="switch_integer3_4_inputs"/><uid v="1000000497"/><attributes><category v=""/><description v="Evaluates the switch_integer3_4_inputs function graph. Result type: Integer3. Inputs: input_selection, value_1, value_2, value_3, value_4."/><author v=""/><tags v="Various"/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000498"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000499"/><attributes><label v="Value 1"/></attributes><type v="64"/><defaultValue><constantValueInt3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000500"/><attributes><label v="Value 2"/></attributes><type v="64"/><defaultValue><constantValueInt3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_3"/><uid v="1000000501"/><attributes><label v="Value 3"/></attributes><type v="64"/><defaultValue><constantValueInt3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_4"/><uid v="1000000502"/><attributes><label v="Value 4"/></attributes><type v="64"/><defaultValue><constantValueInt3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput></paraminputs><type v="64"/><paramValue><dynamicValue><rootnode v="1000000488"/><paramNodes><paramNode><uid v="1000000486"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000487"/><function v="sub"/><type v="16"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000486"/></connection><connection><identifier v="b"/><connRef v="1000000489"/></connection></connections></paramNode><paramNode><uid v="1000000488"/><function v="ifelse"/><type v="64"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000490"/></connection><connection><identifier v="ifpath"/><connRef v="1000000495"/></connection><connection><identifier v="elsepath"/><connRef v="1000000496"/></connection></connections></paramNode><paramNode><uid v="1000000489"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000490"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000486"/></connection><connection><identifier v="b"/><connRef v="1000000489"/></connection></connections></paramNode><paramNode><uid v="1000000491"/><function v="get_integer3"/><type v="64"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer3"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000492"/><function v="get_integer3"/><type v="64"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer3"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000493"/><function v="get_integer3"/><type v="64"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer3"/><constantValue><constantValueString v="value_3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000494"/><function v="get_integer3"/><type v="64"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer3"/><constantValue><constantValueString v="value_4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000495"/><function v="instance"/><type v="64"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000486"/></connection><connection><identifier v="value_1"/><connRef v="1000000492"/></connection><connection><identifier v="value_2"/><connRef v="1000000491"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer3/switch_integer3_2_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000496"/><function v="instance"/><type v="64"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000487"/></connection><connection><identifier v="value_1"/><connRef v="1000000493"/></connection><connection><identifier v="value_2"/><connRef v="1000000494"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer3/switch_integer3_2_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="switch_integer3_8_inputs"/><uid v="1000000518"/><attributes><category v=""/><description v="Evaluates the switch_integer3_8_inputs function graph. Result type: Integer3. Inputs: input_selection, value_1, value_2, value_3, value_4, value_5, value_6, value_7, value_8."/><author v=""/><tags v="Various"/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000519"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000520"/><attributes><label v="Value 1"/></attributes><type v="64"/><defaultValue><constantValueInt3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000521"/><attributes><label v="Value 2"/></attributes><type v="64"/><defaultValue><constantValueInt3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_3"/><uid v="1000000522"/><attributes><label v="Value 3"/></attributes><type v="64"/><defaultValue><constantValueInt3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_4"/><uid v="1000000523"/><attributes><label v="Value 4"/></attributes><type v="64"/><defaultValue><constantValueInt3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_5"/><uid v="1000000524"/><attributes><label v="Value 5"/></attributes><type v="64"/><defaultValue><constantValueInt3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_6"/><uid v="1000000525"/><attributes><label v="Value 6"/></attributes><type v="64"/><defaultValue><constantValueInt3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_7"/><uid v="1000000526"/><attributes><label v="Value 7"/></attributes><type v="64"/><defaultValue><constantValueInt3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_8"/><uid v="1000000527"/><attributes><label v="Value 8"/></attributes><type v="64"/><defaultValue><constantValueInt3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput></paraminputs><type v="64"/><paramValue><dynamicValue><rootnode v="1000000504"/><paramNodes><paramNode><uid v="1000000503"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000504"/><function v="ifelse"/><type v="64"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000507"/></connection><connection><identifier v="ifpath"/><connRef v="1000000516"/></connection><connection><identifier v="elsepath"/><connRef v="1000000517"/></connection></connections></paramNode><paramNode><uid v="1000000505"/><function v="sub"/><type v="16"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000503"/></connection><connection><identifier v="b"/><connRef v="1000000506"/></connection></connections></paramNode><paramNode><uid v="1000000506"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000507"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000503"/></connection><connection><identifier v="b"/><connRef v="1000000506"/></connection></connections></paramNode><paramNode><uid v="1000000508"/><function v="get_integer3"/><type v="64"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer3"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000509"/><function v="get_integer3"/><type v="64"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer3"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000510"/><function v="get_integer3"/><type v="64"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer3"/><constantValue><constantValueString v="value_4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000511"/><function v="get_integer3"/><type v="64"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer3"/><constantValue><constantValueString v="value_3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000512"/><function v="get_integer3"/><type v="64"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer3"/><constantValue><constantValueString v="value_5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000513"/><function v="get_integer3"/><type v="64"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer3"/><constantValue><constantValueString v="value_6"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000514"/><function v="get_integer3"/><type v="64"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer3"/><constantValue><constantValueString v="value_8"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000515"/><function v="get_integer3"/><type v="64"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer3"/><constantValue><constantValueString v="value_7"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000516"/><function v="instance"/><type v="64"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000503"/></connection><connection><identifier v="value_1"/><connRef v="1000000508"/></connection><connection><identifier v="value_2"/><connRef v="1000000509"/></connection><connection><identifier v="value_3"/><connRef v="1000000511"/></connection><connection><identifier v="value_4"/><connRef v="1000000510"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer3/switch_integer3_4_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input><input><identifier v="value_3"/><type v="0"/></input><input><identifier v="value_4"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000517"/><function v="instance"/><type v="64"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000505"/></connection><connection><identifier v="value_1"/><connRef v="1000000512"/></connection><connection><identifier v="value_2"/><connRef v="1000000513"/></connection><connection><identifier v="value_3"/><connRef v="1000000515"/></connection><connection><identifier v="value_4"/><connRef v="1000000514"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer3/switch_integer3_4_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input><input><identifier v="value_3"/><type v="0"/></input><input><identifier v="value_4"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="Integer2"/><uid v="1000000528"/><content><function><identifier v="switch_integer2_2_inputs"/><uid v="1000000535"/><attributes><category v=""/><description v="Evaluates the switch_integer2_2_inputs function graph. Result type: Integer2. Inputs: input_selection, value_1, value_2."/><author v=""/><tags v="Various"/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000536"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000537"/><attributes><label v="Value 1"/></attributes><type v="32"/><defaultValue><constantValueInt2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000538"/><attributes><label v="Value 2"/></attributes><type v="32"/><defaultValue><constantValueInt2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput></paraminputs><type v="32"/><paramValue><dynamicValue><rootnode v="1000000530"/><paramNodes><paramNode><uid v="1000000529"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000530"/><function v="ifelse"/><type v="32"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000532"/></connection><connection><identifier v="ifpath"/><connRef v="1000000534"/></connection><connection><identifier v="elsepath"/><connRef v="1000000533"/></connection></connections></paramNode><paramNode><uid v="1000000531"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000532"/><function v="gt"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000529"/></connection><connection><identifier v="b"/><connRef v="1000000531"/></connection></connections></paramNode><paramNode><uid v="1000000533"/><function v="get_integer2"/><type v="32"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer2"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000534"/><function v="get_integer2"/><type v="32"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer2"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="switch_integer2_4_inputs"/><uid v="1000000550"/><attributes><category v=""/><description v="Evaluates the switch_integer2_4_inputs function graph. Result type: Integer2. Inputs: input_selection, value_1, value_2, value_3, value_4."/><author v=""/><tags v="Various"/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000551"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000552"/><attributes><label v="Value 1"/></attributes><type v="32"/><defaultValue><constantValueInt2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000553"/><attributes><label v="Value 2"/></attributes><type v="32"/><defaultValue><constantValueInt2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_3"/><uid v="1000000554"/><attributes><label v="Value 3"/></attributes><type v="32"/><defaultValue><constantValueInt2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_4"/><uid v="1000000555"/><attributes><label v="Value 4"/></attributes><type v="32"/><defaultValue><constantValueInt2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput></paraminputs><type v="32"/><paramValue><dynamicValue><rootnode v="1000000541"/><paramNodes><paramNode><uid v="1000000539"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000540"/><function v="sub"/><type v="16"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000539"/></connection><connection><identifier v="b"/><connRef v="1000000542"/></connection></connections></paramNode><paramNode><uid v="1000000541"/><function v="ifelse"/><type v="32"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000543"/></connection><connection><identifier v="ifpath"/><connRef v="1000000548"/></connection><connection><identifier v="elsepath"/><connRef v="1000000549"/></connection></connections></paramNode><paramNode><uid v="1000000542"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000543"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000539"/></connection><connection><identifier v="b"/><connRef v="1000000542"/></connection></connections></paramNode><paramNode><uid v="1000000544"/><function v="get_integer2"/><type v="32"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer2"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000545"/><function v="get_integer2"/><type v="32"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer2"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000546"/><function v="get_integer2"/><type v="32"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer2"/><constantValue><constantValueString v="value_3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000547"/><function v="get_integer2"/><type v="32"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer2"/><constantValue><constantValueString v="value_4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000548"/><function v="instance"/><type v="32"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000539"/></connection><connection><identifier v="value_1"/><connRef v="1000000545"/></connection><connection><identifier v="value_2"/><connRef v="1000000544"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer2/switch_integer2_2_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000549"/><function v="instance"/><type v="32"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000540"/></connection><connection><identifier v="value_1"/><connRef v="1000000546"/></connection><connection><identifier v="value_2"/><connRef v="1000000547"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer2/switch_integer2_2_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="switch_integer2_8_inputs"/><uid v="1000000571"/><attributes><category v=""/><description v="Evaluates the switch_integer2_8_inputs function graph. Result type: Integer2. Inputs: input_selection, value_1, value_2, value_3, value_4, value_5, value_6, value_7, value_8."/><author v=""/><tags v="Various"/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000572"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000573"/><attributes><label v="Value 1"/></attributes><type v="32"/><defaultValue><constantValueInt2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000574"/><attributes><label v="Value 2"/></attributes><type v="32"/><defaultValue><constantValueInt2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_3"/><uid v="1000000575"/><attributes><label v="Value 3"/></attributes><type v="32"/><defaultValue><constantValueInt2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_4"/><uid v="1000000576"/><attributes><label v="Value 4"/></attributes><type v="32"/><defaultValue><constantValueInt2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_5"/><uid v="1000000577"/><attributes><label v="Value 5"/></attributes><type v="32"/><defaultValue><constantValueInt2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_6"/><uid v="1000000578"/><attributes><label v="Value 6"/></attributes><type v="32"/><defaultValue><constantValueInt2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_7"/><uid v="1000000579"/><attributes><label v="Value 7"/></attributes><type v="32"/><defaultValue><constantValueInt2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_8"/><uid v="1000000580"/><attributes><label v="Value 8"/></attributes><type v="32"/><defaultValue><constantValueInt2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput></paraminputs><type v="32"/><paramValue><dynamicValue><rootnode v="1000000557"/><paramNodes><paramNode><uid v="1000000556"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000557"/><function v="ifelse"/><type v="32"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000560"/></connection><connection><identifier v="ifpath"/><connRef v="1000000569"/></connection><connection><identifier v="elsepath"/><connRef v="1000000570"/></connection></connections></paramNode><paramNode><uid v="1000000558"/><function v="sub"/><type v="16"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000556"/></connection><connection><identifier v="b"/><connRef v="1000000559"/></connection></connections></paramNode><paramNode><uid v="1000000559"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000560"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000556"/></connection><connection><identifier v="b"/><connRef v="1000000559"/></connection></connections></paramNode><paramNode><uid v="1000000561"/><function v="get_integer2"/><type v="32"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer2"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000562"/><function v="get_integer2"/><type v="32"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer2"/><constantValue><constantValueString v="value_4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000563"/><function v="get_integer2"/><type v="32"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer2"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000564"/><function v="get_integer2"/><type v="32"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer2"/><constantValue><constantValueString v="value_3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000565"/><function v="get_integer2"/><type v="32"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer2"/><constantValue><constantValueString v="value_7"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000566"/><function v="get_integer2"/><type v="32"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer2"/><constantValue><constantValueString v="value_8"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000567"/><function v="get_integer2"/><type v="32"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer2"/><constantValue><constantValueString v="value_6"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000568"/><function v="get_integer2"/><type v="32"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer2"/><constantValue><constantValueString v="value_5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000569"/><function v="instance"/><type v="32"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000556"/></connection><connection><identifier v="value_1"/><connRef v="1000000563"/></connection><connection><identifier v="value_2"/><connRef v="1000000561"/></connection><connection><identifier v="value_3"/><connRef v="1000000564"/></connection><connection><identifier v="value_4"/><connRef v="1000000562"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer2/switch_integer2_4_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input><input><identifier v="value_3"/><type v="0"/></input><input><identifier v="value_4"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000570"/><function v="instance"/><type v="32"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000558"/></connection><connection><identifier v="value_1"/><connRef v="1000000568"/></connection><connection><identifier v="value_2"/><connRef v="1000000567"/></connection><connection><identifier v="value_3"/><connRef v="1000000565"/></connection><connection><identifier v="value_4"/><connRef v="1000000566"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer2/switch_integer2_4_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input><input><identifier v="value_3"/><type v="0"/></input><input><identifier v="value_4"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="Integer1"/><uid v="1000000581"/><content><function><identifier v="switch_integer1_2_inputs"/><uid v="1000000588"/><attributes><category v=""/><description v="Evaluates the switch_integer1_2_inputs function graph. Result type: Integer. Inputs: input_selection, value_1, value_2."/><author v=""/><tags v="Various"/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000589"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000590"/><attributes><label v="Value 1"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000591"/><attributes><label v="Value 2"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput></paraminputs><type v="16"/><paramValue><dynamicValue><rootnode v="1000000583"/><paramNodes><paramNode><uid v="1000000582"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000583"/><function v="ifelse"/><type v="16"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000585"/></connection><connection><identifier v="ifpath"/><connRef v="1000000587"/></connection><connection><identifier v="elsepath"/><connRef v="1000000586"/></connection></connections></paramNode><paramNode><uid v="1000000584"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000585"/><function v="gt"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000582"/></connection><connection><identifier v="b"/><connRef v="1000000584"/></connection></connections></paramNode><paramNode><uid v="1000000586"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000587"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="switch_integer1_4_inputs"/><uid v="1000000603"/><attributes><category v=""/><description v="Evaluates the switch_integer1_4_inputs function graph. Result type: Integer. Inputs: input_selection, value_1, value_2, value_3, value_4."/><author v=""/><tags v="Various"/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000604"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000605"/><attributes><label v="Value 1"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000606"/><attributes><label v="Value 2"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_3"/><uid v="1000000607"/><attributes><label v="Value 3"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_4"/><uid v="1000000608"/><attributes><label v="Value 4"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput></paraminputs><type v="16"/><paramValue><dynamicValue><rootnode v="1000000594"/><paramNodes><paramNode><uid v="1000000592"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000593"/><function v="sub"/><type v="16"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000592"/></connection><connection><identifier v="b"/><connRef v="1000000595"/></connection></connections></paramNode><paramNode><uid v="1000000594"/><function v="ifelse"/><type v="16"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000596"/></connection><connection><identifier v="ifpath"/><connRef v="1000000601"/></connection><connection><identifier v="elsepath"/><connRef v="1000000602"/></connection></connections></paramNode><paramNode><uid v="1000000595"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000596"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000592"/></connection><connection><identifier v="b"/><connRef v="1000000595"/></connection></connections></paramNode><paramNode><uid v="1000000597"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000598"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000599"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="value_3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000600"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="value_4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000601"/><function v="instance"/><type v="16"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000592"/></connection><connection><identifier v="value_1"/><connRef v="1000000598"/></connection><connection><identifier v="value_2"/><connRef v="1000000597"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer1/switch_integer1_2_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000602"/><function v="instance"/><type v="16"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000593"/></connection><connection><identifier v="value_1"/><connRef v="1000000599"/></connection><connection><identifier v="value_2"/><connRef v="1000000600"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer1/switch_integer1_2_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="switch_integer1_8_inputs"/><uid v="1000000624"/><attributes><category v=""/><description v="Evaluates the switch_integer1_8_inputs function graph. Result type: Integer. Inputs: input_selection, value_1, value_2, value_3, value_4, value_5, value_6, value_7, value_8."/><author v=""/><tags v="Various"/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000625"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000626"/><attributes><label v="Value 1"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000627"/><attributes><label v="Value 2"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_3"/><uid v="1000000628"/><attributes><label v="Value 3"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_4"/><uid v="1000000629"/><attributes><label v="Value 4"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_5"/><uid v="1000000630"/><attributes><label v="Value 5"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_6"/><uid v="1000000631"/><attributes><label v="Value 6"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_7"/><uid v="1000000632"/><attributes><label v="Value 7"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_8"/><uid v="1000000633"/><attributes><label v="Value 8"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput></paraminputs><type v="16"/><paramValue><dynamicValue><rootnode v="1000000610"/><paramNodes><paramNode><uid v="1000000609"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000610"/><function v="ifelse"/><type v="16"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000613"/></connection><connection><identifier v="ifpath"/><connRef v="1000000622"/></connection><connection><identifier v="elsepath"/><connRef v="1000000623"/></connection></connections></paramNode><paramNode><uid v="1000000611"/><function v="sub"/><type v="16"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000609"/></connection><connection><identifier v="b"/><connRef v="1000000612"/></connection></connections></paramNode><paramNode><uid v="1000000612"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000613"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000609"/></connection><connection><identifier v="b"/><connRef v="1000000612"/></connection></connections></paramNode><paramNode><uid v="1000000614"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="value_4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000615"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000616"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="value_3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000617"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000618"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="value_8"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000619"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="value_5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000620"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="value_7"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000621"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="value_6"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000622"/><function v="instance"/><type v="16"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000609"/></connection><connection><identifier v="value_1"/><connRef v="1000000615"/></connection><connection><identifier v="value_2"/><connRef v="1000000617"/></connection><connection><identifier v="value_3"/><connRef v="1000000616"/></connection><connection><identifier v="value_4"/><connRef v="1000000614"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer1/switch_integer1_4_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input><input><identifier v="value_3"/><type v="0"/></input><input><identifier v="value_4"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000623"/><function v="instance"/><type v="16"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000611"/></connection><connection><identifier v="value_1"/><connRef v="1000000619"/></connection><connection><identifier v="value_2"/><connRef v="1000000621"/></connection><connection><identifier v="value_3"/><connRef v="1000000620"/></connection><connection><identifier v="value_4"/><connRef v="1000000618"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Integer1/switch_integer1_4_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input><input><identifier v="value_3"/><type v="0"/></input><input><identifier v="value_4"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="Float4"/><uid v="1000000634"/><content><function><identifier v="switch_float4_2_inputs"/><uid v="1000000641"/><attributes><category v=""/><description v="Evaluates the switch_float4_2_inputs function graph. Result type: Float4. Inputs: input_selection, value_1, value_2."/><author v=""/><tags v="Various"/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000642"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000643"/><attributes><label v="Value 1"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000644"/><attributes><label v="Value 2"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="2048"/><paramValue><dynamicValue><rootnode v="1000000636"/><paramNodes><paramNode><uid v="1000000635"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000636"/><function v="ifelse"/><type v="2048"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000638"/></connection><connection><identifier v="ifpath"/><connRef v="1000000639"/></connection><connection><identifier v="elsepath"/><connRef v="1000000640"/></connection></connections></paramNode><paramNode><uid v="1000000637"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000638"/><function v="gt"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000635"/></connection><connection><identifier v="b"/><connRef v="1000000637"/></connection></connections></paramNode><paramNode><uid v="1000000639"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000640"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="switch_float4_4_inputs"/><uid v="1000000656"/><attributes><category v=""/><description v="Evaluates the switch_float4_4_inputs function graph. Result type: Float4. Inputs: input_selection, value_1, value_2, value_3, value_4."/><author v=""/><tags v="Various"/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000657"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000658"/><attributes><label v="Value 1"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000659"/><attributes><label v="Value 2"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_3"/><uid v="1000000660"/><attributes><label v="Value 3"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_4"/><uid v="1000000661"/><attributes><label v="Value 4"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="2048"/><paramValue><dynamicValue><rootnode v="1000000647"/><paramNodes><paramNode><uid v="1000000645"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000646"/><function v="sub"/><type v="16"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000645"/></connection><connection><identifier v="b"/><connRef v="1000000648"/></connection></connections></paramNode><paramNode><uid v="1000000647"/><function v="ifelse"/><type v="2048"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000649"/></connection><connection><identifier v="ifpath"/><connRef v="1000000654"/></connection><connection><identifier v="elsepath"/><connRef v="1000000655"/></connection></connections></paramNode><paramNode><uid v="1000000648"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000649"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000645"/></connection><connection><identifier v="b"/><connRef v="1000000648"/></connection></connections></paramNode><paramNode><uid v="1000000650"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000651"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000652"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="value_4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000653"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="value_3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000654"/><function v="instance"/><type v="2048"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000645"/></connection><connection><identifier v="value_1"/><connRef v="1000000650"/></connection><connection><identifier v="value_2"/><connRef v="1000000651"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float4/switch_float4_2_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000655"/><function v="instance"/><type v="2048"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000646"/></connection><connection><identifier v="value_1"/><connRef v="1000000653"/></connection><connection><identifier v="value_2"/><connRef v="1000000652"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float4/switch_float4_2_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="switch_float4_8_inputs"/><uid v="1000000677"/><attributes><category v=""/><description v="Evaluates the switch_float4_8_inputs function graph. Result type: Float4. Inputs: input_selection, value_1, value_2, value_3, value_4, value_5, value_6, value_7, value_8."/><author v=""/><tags v="Various"/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000678"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000679"/><attributes><label v="Value 1"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000680"/><attributes><label v="Value 2"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_3"/><uid v="1000000681"/><attributes><label v="Value 3"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_4"/><uid v="1000000682"/><attributes><label v="Value 4"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_5"/><uid v="1000000683"/><attributes><label v="Value 5"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_6"/><uid v="1000000684"/><attributes><label v="Value 6"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_7"/><uid v="1000000685"/><attributes><label v="Value 7"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_8"/><uid v="1000000686"/><attributes><label v="Value 8"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="2048"/><paramValue><dynamicValue><rootnode v="1000000663"/><paramNodes><paramNode><uid v="1000000662"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000663"/><function v="ifelse"/><type v="2048"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000666"/></connection><connection><identifier v="ifpath"/><connRef v="1000000671"/></connection><connection><identifier v="elsepath"/><connRef v="1000000672"/></connection></connections></paramNode><paramNode><uid v="1000000664"/><function v="sub"/><type v="16"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000662"/></connection><connection><identifier v="b"/><connRef v="1000000665"/></connection></connections></paramNode><paramNode><uid v="1000000665"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000666"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000662"/></connection><connection><identifier v="b"/><connRef v="1000000665"/></connection></connections></paramNode><paramNode><uid v="1000000667"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000668"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="value_3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000669"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000670"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="value_4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000671"/><function v="instance"/><type v="2048"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000662"/></connection><connection><identifier v="value_1"/><connRef v="1000000667"/></connection><connection><identifier v="value_2"/><connRef v="1000000669"/></connection><connection><identifier v="value_3"/><connRef v="1000000668"/></connection><connection><identifier v="value_4"/><connRef v="1000000670"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float4/switch_float4_4_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input><input><identifier v="value_3"/><type v="0"/></input><input><identifier v="value_4"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000672"/><function v="instance"/><type v="2048"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000664"/></connection><connection><identifier v="value_1"/><connRef v="1000000676"/></connection><connection><identifier v="value_2"/><connRef v="1000000674"/></connection><connection><identifier v="value_3"/><connRef v="1000000673"/></connection><connection><identifier v="value_4"/><connRef v="1000000675"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float4/switch_float4_4_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input><input><identifier v="value_3"/><type v="0"/></input><input><identifier v="value_4"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000673"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="value_7"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000674"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="value_6"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000675"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="value_8"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000676"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="value_5"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="Float3"/><uid v="1000000687"/><content><function><identifier v="switch_float3_2_inputs"/><uid v="1000000694"/><attributes><category v=""/><description v="Evaluates the switch_float3_2_inputs function graph. Result type: Float3. Inputs: input_selection, value_1, value_2."/><author v=""/><tags v="Various"/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000695"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000696"/><attributes><label v="Value 1"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000697"/><attributes><label v="Value 2"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000000689"/><paramNodes><paramNode><uid v="1000000688"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000689"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000691"/></connection><connection><identifier v="ifpath"/><connRef v="1000000692"/></connection><connection><identifier v="elsepath"/><connRef v="1000000693"/></connection></connections></paramNode><paramNode><uid v="1000000690"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000691"/><function v="gt"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000688"/></connection><connection><identifier v="b"/><connRef v="1000000690"/></connection></connections></paramNode><paramNode><uid v="1000000692"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000693"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="switch_float3_4_inputs"/><uid v="1000000709"/><attributes><category v=""/><description v="Evaluates the switch_float3_4_inputs function graph. Result type: Float3. Inputs: input_selection, value_1, value_2, value_3, value_4."/><author v=""/><tags v="Various"/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000710"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000711"/><attributes><label v="Value 1"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000712"/><attributes><label v="Value 2"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_3"/><uid v="1000000713"/><attributes><label v="Value 3"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_4"/><uid v="1000000714"/><attributes><label v="Value 4"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000000700"/><paramNodes><paramNode><uid v="1000000698"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000699"/><function v="sub"/><type v="16"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000698"/></connection><connection><identifier v="b"/><connRef v="1000000701"/></connection></connections></paramNode><paramNode><uid v="1000000700"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000702"/></connection><connection><identifier v="ifpath"/><connRef v="1000000707"/></connection><connection><identifier v="elsepath"/><connRef v="1000000708"/></connection></connections></paramNode><paramNode><uid v="1000000701"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000702"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000698"/></connection><connection><identifier v="b"/><connRef v="1000000701"/></connection></connections></paramNode><paramNode><uid v="1000000703"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000704"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000705"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="value_3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000706"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="value_4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000707"/><function v="instance"/><type v="1024"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000698"/></connection><connection><identifier v="value_1"/><connRef v="1000000703"/></connection><connection><identifier v="value_2"/><connRef v="1000000704"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float3/switch_float3_2_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000708"/><function v="instance"/><type v="1024"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000699"/></connection><connection><identifier v="value_1"/><connRef v="1000000705"/></connection><connection><identifier v="value_2"/><connRef v="1000000706"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float3/switch_float3_2_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="switch_float3_8_inputs"/><uid v="1000000730"/><attributes><category v=""/><description v="Evaluates the switch_float3_8_inputs function graph. Result type: Float3. Inputs: input_selection, value_1, value_2, value_3, value_4, value_5, value_6, value_7, value_8."/><author v=""/><tags v="Various"/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000731"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000732"/><attributes><label v="Value 1"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000733"/><attributes><label v="Value 2"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_3"/><uid v="1000000734"/><attributes><label v="Value 3"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_4"/><uid v="1000000735"/><attributes><label v="Value 4"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_5"/><uid v="1000000736"/><attributes><label v="Value 5"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_6"/><uid v="1000000737"/><attributes><label v="Value 6"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_7"/><uid v="1000000738"/><attributes><label v="Value 7"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_8"/><uid v="1000000739"/><attributes><label v="Value 8"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000000716"/><paramNodes><paramNode><uid v="1000000715"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000716"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000719"/></connection><connection><identifier v="ifpath"/><connRef v="1000000728"/></connection><connection><identifier v="elsepath"/><connRef v="1000000729"/></connection></connections></paramNode><paramNode><uid v="1000000717"/><function v="sub"/><type v="16"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000715"/></connection><connection><identifier v="b"/><connRef v="1000000718"/></connection></connections></paramNode><paramNode><uid v="1000000718"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000719"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000715"/></connection><connection><identifier v="b"/><connRef v="1000000718"/></connection></connections></paramNode><paramNode><uid v="1000000720"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="value_4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000721"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000722"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="value_3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000723"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000724"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="value_6"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000725"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="value_7"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000726"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="value_8"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000727"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="value_5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000728"/><function v="instance"/><type v="1024"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000715"/></connection><connection><identifier v="value_1"/><connRef v="1000000723"/></connection><connection><identifier v="value_2"/><connRef v="1000000721"/></connection><connection><identifier v="value_3"/><connRef v="1000000722"/></connection><connection><identifier v="value_4"/><connRef v="1000000720"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float3/switch_float3_4_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input><input><identifier v="value_3"/><type v="0"/></input><input><identifier v="value_4"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000729"/><function v="instance"/><type v="1024"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000717"/></connection><connection><identifier v="value_1"/><connRef v="1000000727"/></connection><connection><identifier v="value_2"/><connRef v="1000000724"/></connection><connection><identifier v="value_3"/><connRef v="1000000725"/></connection><connection><identifier v="value_4"/><connRef v="1000000726"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float3/switch_float3_4_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input><input><identifier v="value_3"/><type v="0"/></input><input><identifier v="value_4"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="Float2"/><uid v="1000000740"/><content><function><identifier v="switch_float2_2_inputs"/><uid v="1000000747"/><attributes><category v=""/><description v="Evaluates the switch_float2_2_inputs function graph. Result type: Float2. Inputs: input_selection, value_1, value_2."/><author v=""/><tags v="Various"/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000748"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000749"/><attributes><label v="Value 1"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000750"/><attributes><label v="Value 2"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="512"/><paramValue><dynamicValue><rootnode v="1000000742"/><paramNodes><paramNode><uid v="1000000741"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000742"/><function v="ifelse"/><type v="512"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000744"/></connection><connection><identifier v="ifpath"/><connRef v="1000000746"/></connection><connection><identifier v="elsepath"/><connRef v="1000000745"/></connection></connections></paramNode><paramNode><uid v="1000000743"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000744"/><function v="gt"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000741"/></connection><connection><identifier v="b"/><connRef v="1000000743"/></connection></connections></paramNode><paramNode><uid v="1000000745"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000746"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="switch_float2_4_inputs"/><uid v="1000000762"/><attributes><category v=""/><description v="Evaluates the switch_float2_4_inputs function graph. Result type: Float2. Inputs: input_selection, value_1, value_2, value_3, value_4."/><author v=""/><tags v="Various"/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000763"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000764"/><attributes><label v="Value 1"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000765"/><attributes><label v="Value 2"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_3"/><uid v="1000000766"/><attributes><label v="Value 3"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_4"/><uid v="1000000767"/><attributes><label v="Value 4"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="512"/><paramValue><dynamicValue><rootnode v="1000000753"/><paramNodes><paramNode><uid v="1000000751"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000752"/><function v="sub"/><type v="16"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000751"/></connection><connection><identifier v="b"/><connRef v="1000000754"/></connection></connections></paramNode><paramNode><uid v="1000000753"/><function v="ifelse"/><type v="512"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000755"/></connection><connection><identifier v="ifpath"/><connRef v="1000000760"/></connection><connection><identifier v="elsepath"/><connRef v="1000000761"/></connection></connections></paramNode><paramNode><uid v="1000000754"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000755"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000751"/></connection><connection><identifier v="b"/><connRef v="1000000754"/></connection></connections></paramNode><paramNode><uid v="1000000756"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000757"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000758"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="value_4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000759"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="value_3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000760"/><function v="instance"/><type v="512"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000751"/></connection><connection><identifier v="value_1"/><connRef v="1000000757"/></connection><connection><identifier v="value_2"/><connRef v="1000000756"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float2/switch_float2_2_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000761"/><function v="instance"/><type v="512"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="value_1"/><connRef v="1000000759"/></connection><connection><identifier v="value_2"/><connRef v="1000000758"/></connection><connection><identifier v="input_selection"/><connRef v="1000000752"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float2/switch_float2_2_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input><input><identifier v="input_selection"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="switch_float2_8_inputs"/><uid v="1000000783"/><attributes><category v=""/><description v="Evaluates the switch_float2_8_inputs function graph. Result type: Float2. Inputs: input_selection, value_1, value_2, value_3, value_4, value_5, value_6, value_7, value_8."/><author v=""/><tags v="Various"/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000784"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000785"/><attributes><label v="Value 1"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000786"/><attributes><label v="Value 2"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_3"/><uid v="1000000787"/><attributes><label v="Value 3"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_4"/><uid v="1000000788"/><attributes><label v="Value 4"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_5"/><uid v="1000000789"/><attributes><label v="Value 5"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_6"/><uid v="1000000790"/><attributes><label v="Value 6"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_7"/><uid v="1000000791"/><attributes><label v="Value 7"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_8"/><uid v="1000000792"/><attributes><label v="Value 8"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="512"/><paramValue><dynamicValue><rootnode v="1000000769"/><paramNodes><paramNode><uid v="1000000768"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000769"/><function v="ifelse"/><type v="512"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000772"/></connection><connection><identifier v="ifpath"/><connRef v="1000000777"/></connection><connection><identifier v="elsepath"/><connRef v="1000000782"/></connection></connections></paramNode><paramNode><uid v="1000000770"/><function v="sub"/><type v="16"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000768"/></connection><connection><identifier v="b"/><connRef v="1000000771"/></connection></connections></paramNode><paramNode><uid v="1000000771"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000772"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000768"/></connection><connection><identifier v="b"/><connRef v="1000000771"/></connection></connections></paramNode><paramNode><uid v="1000000773"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="value_4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000774"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000775"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000776"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="value_3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000777"/><function v="instance"/><type v="512"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000768"/></connection><connection><identifier v="value_1"/><connRef v="1000000774"/></connection><connection><identifier v="value_2"/><connRef v="1000000775"/></connection><connection><identifier v="value_3"/><connRef v="1000000776"/></connection><connection><identifier v="value_4"/><connRef v="1000000773"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float2/switch_float2_4_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input><input><identifier v="value_3"/><type v="0"/></input><input><identifier v="value_4"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000778"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="value_8"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000779"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="value_5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000780"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="value_6"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000781"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="value_7"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000782"/><function v="instance"/><type v="512"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000770"/></connection><connection><identifier v="value_1"/><connRef v="1000000779"/></connection><connection><identifier v="value_2"/><connRef v="1000000780"/></connection><connection><identifier v="value_3"/><connRef v="1000000781"/></connection><connection><identifier v="value_4"/><connRef v="1000000778"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float2/switch_float2_4_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input><input><identifier v="value_3"/><type v="0"/></input><input><identifier v="value_4"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="Float1"/><uid v="1000000793"/><content><function><identifier v="switch_float1_2_inputs"/><uid v="1000000800"/><attributes><category v=""/><description v="Evaluates the switch_float1_2_inputs function graph. Result type: Float. Inputs: input_selection, value_1, value_2."/><author v=""/><tags v="Various"/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000801"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000802"/><attributes><label v="Value 1"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000803"/><attributes><label v="Value 2"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000797"/><paramNodes><paramNode><uid v="1000000794"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000795"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000796"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000797"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000799"/></connection><connection><identifier v="ifpath"/><connRef v="1000000796"/></connection><connection><identifier v="elsepath"/><connRef v="1000000795"/></connection></connections></paramNode><paramNode><uid v="1000000798"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000799"/><function v="gt"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000794"/></connection><connection><identifier v="b"/><connRef v="1000000798"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="switch_float1_4_inputs"/><uid v="1000000815"/><attributes><category v=""/><description v="Evaluates the switch_float1_4_inputs function graph. Result type: Float. Inputs: input_selection, value_1, value_2, value_3, value_4."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000816"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000817"/><attributes><label v="Value 1"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000818"/><attributes><label v="Value 2"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_3"/><uid v="1000000819"/><attributes><label v="Value 3"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_4"/><uid v="1000000820"/><attributes><label v="Value 4"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000811"/><paramNodes><paramNode><uid v="1000000804"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000805"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000806"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000807"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="value_3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000808"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="value_4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000809"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="value_1"/><connRef v="1000000805"/></connection><connection><identifier v="value_2"/><connRef v="1000000806"/></connection><connection><identifier v="input_selection"/><connRef v="1000000804"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float1/switch_float1_2_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input><input><identifier v="input_selection"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000810"/><function v="sub"/><type v="16"/><GUILayout><gpos v="344 228 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000804"/></connection><connection><identifier v="b"/><connRef v="1000000813"/></connection></connections></paramNode><paramNode><uid v="1000000811"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000814"/></connection><connection><identifier v="ifpath"/><connRef v="1000000809"/></connection><connection><identifier v="elsepath"/><connRef v="1000000812"/></connection></connections></paramNode><paramNode><uid v="1000000812"/><function v="instance"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="value_1"/><connRef v="1000000807"/></connection><connection><identifier v="value_2"/><connRef v="1000000808"/></connection><connection><identifier v="input_selection"/><connRef v="1000000810"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float1/switch_float1_2_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input><input><identifier v="input_selection"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000813"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000814"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 388 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000804"/></connection><connection><identifier v="b"/><connRef v="1000000813"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="switch_float1_8_inputs"/><uid v="1000000836"/><attributes><category v=""/><description v="Evaluates the switch_float1_8_inputs function graph. Result type: Float. Inputs: input_selection, value_1, value_2, value_3, value_4, value_5, value_6, value_7, value_8."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input_selection"/><uid v="1000000837"/><attributes><label v="Input selection"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_1"/><uid v="1000000838"/><attributes><label v="Value 1"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_2"/><uid v="1000000839"/><attributes><label v="Value 2"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_3"/><uid v="1000000840"/><attributes><label v="Value 3"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_4"/><uid v="1000000841"/><attributes><label v="Value 4"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_5"/><uid v="1000000842"/><attributes><label v="Value 5"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_6"/><uid v="1000000843"/><attributes><label v="Value 6"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_7"/><uid v="1000000844"/><attributes><label v="Value 7"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="value_8"/><uid v="1000000845"/><attributes><label v="Value 8"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000000831"/><paramNodes><paramNode><uid v="1000000821"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="input_selection"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000822"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="value_1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000823"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="value_2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000824"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="value_3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000825"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="value_4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000826"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="value_5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000827"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="value_6"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000828"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="value_7"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000829"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="value_8"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000830"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="input_selection"/><connRef v="1000000821"/></connection><connection><identifier v="value_1"/><connRef v="1000000822"/></connection><connection><identifier v="value_2"/><connRef v="1000000823"/></connection><connection><identifier v="value_3"/><connRef v="1000000824"/></connection><connection><identifier v="value_4"/><connRef v="1000000825"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float1/switch_float1_4_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_selection"/><type v="0"/></input><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input><input><identifier v="value_3"/><type v="0"/></input><input><identifier v="value_4"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000831"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000835"/></connection><connection><identifier v="ifpath"/><connRef v="1000000830"/></connection><connection><identifier v="elsepath"/><connRef v="1000000832"/></connection></connections></paramNode><paramNode><uid v="1000000832"/><function v="instance"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="value_1"/><connRef v="1000000826"/></connection><connection><identifier v="value_2"/><connRef v="1000000827"/></connection><connection><identifier v="value_3"/><connRef v="1000000828"/></connection><connection><identifier v="value_4"/><connRef v="1000000829"/></connection><connection><identifier v="input_selection"/><connRef v="1000000833"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/switch/Float1/switch_float1_4_inputs"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="value_1"/><type v="0"/></input><input><identifier v="value_2"/><type v="0"/></input><input><identifier v="value_3"/><type v="0"/></input><input><identifier v="value_4"/><type v="0"/></input><input><identifier v="input_selection"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000000833"/><function v="sub"/><type v="16"/><GUILayout><gpos v="344 284 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000821"/></connection><connection><identifier v="b"/><connRef v="1000000834"/></connection></connections></paramNode><paramNode><uid v="1000000834"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000835"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 444 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000821"/></connection><connection><identifier v="b"/><connRef v="1000000834"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group></content></group><group><identifier v="Various"/><uid v="1000000846"/><content><function><identifier v="disorder"/><uid v="1000000859"/><attributes><category v=""/><description v="Evaluates the disorder function graph. Result type: Float2. Inputs: disorder_radius, disorder_angle."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="disorder_radius"/><uid v="1000000860"/><attributes><label v="disorder_radius"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="disorder_angle"/><uid v="1000000861"/><attributes><label v="disorder_angle"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="512"/><paramValue><dynamicValue><rootnode v="1000000848"/><paramNodes><paramNode><uid v="1000000847"/><function v="rand"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000849"/></connection></connections></paramNode><paramNode><uid v="1000000848"/><function v="cartesian"/><type v="512"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="rho"/><connRef v="1000000847"/></connection><connection><identifier v="theta"/><connRef v="1000000858"/></connection></connections></paramNode><paramNode><uid v="1000000849"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="disorder_radius"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000850"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000851"/><function v="rand"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000850"/></connection></connections></paramNode><paramNode><uid v="1000000852"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000851"/></connection><connection><identifier v="b"/><connRef v="1000000853"/></connection></connections></paramNode><paramNode><uid v="1000000853"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000854"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="6.283185"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000855"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000854"/></connection><connection><identifier v="b"/><connRef v="1000000852"/></connection></connections></paramNode><paramNode><uid v="1000000856"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="disorder_angle"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000857"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000854"/></connection><connection><identifier v="b"/><connRef v="1000000856"/></connection></connections></paramNode><paramNode><uid v="1000000858"/><function v="add"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000855"/></connection><connection><identifier v="b"/><connRef v="1000000857"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="disorder_v2"/><uid v="1000000872"/><attributes><category v=""/><description v="Evaluates the disorder_v2 function graph. Result type: Float2. Inputs: disorder_radius, disorder_angle."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="disorder_radius"/><uid v="1000000873"/><attributes><label v="disorder_radius"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="disorder_angle"/><uid v="1000000874"/><attributes><label v="disorder_angle"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="512"/><paramValue><dynamicValue><rootnode v="1000000863"/><paramNodes><paramNode><uid v="1000000862"/><function v="rand"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000870"/></connection></connections></paramNode><paramNode><uid v="1000000863"/><function v="cartesian"/><type v="512"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="rho"/><connRef v="1000000871"/></connection><connection><identifier v="theta"/><connRef v="1000000868"/></connection></connections></paramNode><paramNode><uid v="1000000864"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="disorder_radius"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000865"/><function v="rand"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000870"/></connection></connections></paramNode><paramNode><uid v="1000000866"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="6.283185"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000867"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="disorder_angle"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000868"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000869"/></connection><connection><identifier v="b"/><connRef v="1000000866"/></connection></connections></paramNode><paramNode><uid v="1000000869"/><function v="add"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000865"/></connection><connection><identifier v="b"/><connRef v="1000000867"/></connection></connections></paramNode><paramNode><uid v="1000000870"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000871"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000864"/></connection><connection><identifier v="b"/><connRef v="1000000862"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="disorder_anim"/><uid v="1000000890"/><attributes><category v=""/><description v="Evaluates the disorder_anim function graph. Result type: Float2. Inputs: disorder_angle, speed."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="disorder_angle"/><uid v="1000000891"/><attributes><label v="disorder_angle"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="speed"/><uid v="1000000892"/><attributes><label v="speed"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="512"/><paramValue><dynamicValue><rootnode v="1000000876"/><paramNodes><paramNode><uid v="1000000875"/><function v="rand"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000883"/></connection></connections></paramNode><paramNode><uid v="1000000876"/><function v="cartesian"/><type v="512"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="rho"/><connRef v="1000000889"/></connection><connection><identifier v="theta"/><connRef v="1000000881"/></connection></connections></paramNode><paramNode><uid v="1000000877"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000878"/><function v="rand"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000877"/></connection></connections></paramNode><paramNode><uid v="1000000879"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="6.283185"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000880"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="disorder_angle"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000881"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000882"/></connection><connection><identifier v="b"/><connRef v="1000000879"/></connection></connections></paramNode><paramNode><uid v="1000000882"/><function v="add"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000878"/></connection><connection><identifier v="b"/><connRef v="1000000880"/></connection></connections></paramNode><paramNode><uid v="1000000883"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.75"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000884"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000887"/></connection><connection><identifier v="b"/><connRef v="1000000885"/></connection></connections></paramNode><paramNode><uid v="1000000885"/><function v="add"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000886"/></connection><connection><identifier v="b"/><connRef v="1000000875"/></connection></connections></paramNode><paramNode><uid v="1000000886"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.25"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000887"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="speed"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000888"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.15915495"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000889"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000884"/></connection><connection><identifier v="b"/><connRef v="1000000888"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="non_square_output_size"/><uid v="1000000963"/><attributes><category v=""/><description v="Evaluates the non_square_output_size function graph. Result type: Integer2. Inputs: scale, output_size, non_square."/><author v=""/><tags v="Various"/></attributes><paraminputs><paraminput><identifier v="scale"/><uid v="1000000964"/><attributes><label v="scale"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="output_size"/><uid v="1000000965"/><attributes><label v="output_size"/></attributes><type v="32"/><defaultValue><constantValueInt2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="non_square"/><uid v="1000000966"/><attributes><label v="non_square"/></attributes><type v="4"/><defaultValue><constantValueBool v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="32"/><paramValue><dynamicValue><rootnode v="1000000893"/><paramNodes><paramNode><uid v="1000000893"/><function v="sequence"/><type v="32"/><GUILayout><gpos v="6784 64 0"/></GUILayout><connections><connection><identifier v="seqin"/><connRef v="1000000957"/></connection><connection><identifier v="seqlast"/><connRef v="1000000906"/></connection></connections></paramNode><paramNode><uid v="1000000894"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000000899"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000895"/><function v="toint1"/><type v="16"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000000898"/></connection></connections></paramNode><paramNode><uid v="1000000896"/><function v="mul"/><type v="16"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000895"/></connection><connection><identifier v="b"/><connRef v="1000000901"/></connection></connections></paramNode><paramNode><uid v="1000000897"/><function v="abs"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000955"/></connection></connections></paramNode><paramNode><uid v="1000000898"/><function v="pow2"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000897"/></connection></connections></paramNode><paramNode><uid v="1000000899"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="$sizelog2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000900"/><function v="set"/><type v="16"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000000896"/></connection></connections><funcDatas><funcData><name v="set"/><constantValue><constantValueString v="real_scale"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000901"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="scale"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000902"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000000899"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000903"/><function v="sequence"/><type v="256"/><GUILayout><gpos v="6224 64 0"/></GUILayout><connections><connection><identifier v="seqin"/><connRef v="1000000907"/></connection><connection><identifier v="seqlast"/><connRef v="1000000904"/></connection></connections></paramNode><paramNode><uid v="1000000904"/><function v="set"/><type v="256"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000000955"/></connection></connections><funcDatas><funcData><name v="set"/><constantValue><constantValueString v="xy_difference"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000905"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000902"/></connection><connection><identifier v="b"/><connRef v="1000000894"/></connection></connections></paramNode><paramNode><uid v="1000000906"/><function v="get_integer2"/><type v="32"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer2"/><constantValue><constantValueString v="output_size"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000907"/><function v="sequence"/><type v="16"/><GUILayout><gpos v="5944 64 0"/></GUILayout><connections><connection><identifier v="seqin"/><connRef v="1000000928"/></connection><connection><identifier v="seqlast"/><connRef v="1000000900"/></connection></connections></paramNode><paramNode><uid v="1000000908"/><function v="set"/><type v="2048"/><GUILayout><gpos v="5104 64 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000000932"/></connection></connections><funcDatas><funcData><name v="set"/><constantValue><constantValueString v="tiling_region"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000909"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000910"/><function v="swizzle4"/><type v="2048"/><GUILayout><gpos v="4824 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000000918"/></connection></connections><funcDatas><funcData><name v="swizzle4"/><constantValue><constantValueInt4 v="2 3 0 1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000911"/><function v="mul"/><type v="2048"/><GUILayout><gpos v="4264 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000914"/></connection><connection><identifier v="b"/><connRef v="1000000953"/></connection></connections></paramNode><paramNode><uid v="1000000912"/><function v="mulscalar"/><type v="512"/><GUILayout><gpos v="2584 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000923"/></connection><connection><identifier v="scalar"/><connRef v="1000000926"/></connection></connections></paramNode><paramNode><uid v="1000000913"/><function v="const_float2"/><type v="512"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float2"/><constantValue><constantValueFloat2 v="1 1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000914"/><function v="vector4"/><type v="2048"/><GUILayout><gpos v="2304 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000000913"/></connection><connection><identifier v="componentslast"/><connRef v="1000000924"/></connection></connections></paramNode><paramNode><uid v="1000000915"/><function v="gt"/><type v="4"/><GUILayout><gpos v="1184 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000955"/></connection><connection><identifier v="b"/><connRef v="1000000909"/></connection></connections></paramNode><paramNode><uid v="1000000916"/><function v="ifelse"/><type v="2048"/><GUILayout><gpos v="5104 224 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000915"/></connection><connection><identifier v="ifpath"/><connRef v="1000000918"/></connection><connection><identifier v="elsepath"/><connRef v="1000000910"/></connection></connections></paramNode><paramNode><uid v="1000000917"/><function v="neg"/><type v="256"/><GUILayout><gpos v="1464 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000920"/></connection></connections></paramNode><paramNode><uid v="1000000918"/><function v="add"/><type v="2048"/><GUILayout><gpos v="4544 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000921"/></connection><connection><identifier v="b"/><connRef v="1000000911"/></connection></connections></paramNode><paramNode><uid v="1000000919"/><function v="pow2"/><type v="256"/><GUILayout><gpos v="1744 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000917"/></connection></connections></paramNode><paramNode><uid v="1000000920"/><function v="abs"/><type v="256"/><GUILayout><gpos v="1184 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000955"/></connection></connections></paramNode><paramNode><uid v="1000000921"/><function v="vector4"/><type v="2048"/><GUILayout><gpos v="2864 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000000925"/></connection><connection><identifier v="componentslast"/><connRef v="1000000912"/></connection></connections></paramNode><paramNode><uid v="1000000922"/><function v="const_float2"/><type v="512"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float2"/><constantValue><constantValueFloat2 v="1 1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000923"/><function v="sub"/><type v="512"/><GUILayout><gpos v="2304 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000922"/></connection><connection><identifier v="b"/><connRef v="1000000924"/></connection></connections></paramNode><paramNode><uid v="1000000924"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2024 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000000919"/></connection><connection><identifier v="componentslast"/><connRef v="1000000919"/></connection></connections></paramNode><paramNode><uid v="1000000925"/><function v="const_float2"/><type v="512"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float2"/><constantValue><constantValueFloat2 v="0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000926"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000927"/><function v="set"/><type v="2048"/><GUILayout><gpos v="5384 64 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000000916"/></connection></connections><funcDatas><funcData><name v="set"/><constantValue><constantValueString v="render_region"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000928"/><function v="sequence"/><type v="2048"/><GUILayout><gpos v="5664 64 0"/></GUILayout><connections><connection><identifier v="seqin"/><connRef v="1000000927"/></connection><connection><identifier v="seqlast"/><connRef v="1000000908"/></connection></connections></paramNode><paramNode><uid v="1000000929"/><function v="get_bool"/><type v="4"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_bool"/><constantValue><constantValueString v="non_square"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000930"/><function v="const_float4"/><type v="2048"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float4"/><constantValue><constantValueFloat4 v="0 1 0 1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000931"/><function v="neg"/><type v="256"/><GUILayout><gpos v="3144 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000938"/></connection></connections></paramNode><paramNode><uid v="1000000932"/><function v="ifelse"/><type v="2048"/><GUILayout><gpos v="4824 224 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000915"/></connection><connection><identifier v="ifpath"/><connRef v="1000000941"/></connection><connection><identifier v="elsepath"/><connRef v="1000000936"/></connection></connections></paramNode><paramNode><uid v="1000000933"/><function v="tofloat"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000000901"/></connection></connections></paramNode><paramNode><uid v="1000000934"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2864 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000000949"/></connection><connection><identifier v="componentslast"/><connRef v="1000000940"/></connection></connections></paramNode><paramNode><uid v="1000000935"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="344 544 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000000937"/></connection><connection><identifier v="componentslast"/><connRef v="1000000937"/></connection></connections></paramNode><paramNode><uid v="1000000936"/><function v="swizzle4"/><type v="2048"/><GUILayout><gpos v="4544 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000000941"/></connection></connections><funcDatas><funcData><name v="swizzle4"/><constantValue><constantValueInt4 v="2 3 0 1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000937"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1664 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000938"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2864 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000943"/></connection><connection><identifier v="b"/><connRef v="1000000950"/></connection></connections></paramNode><paramNode><uid v="1000000939"/><function v="vector4"/><type v="2048"/><GUILayout><gpos v="3704 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000000946"/></connection><connection><identifier v="componentslast"/><connRef v="1000000946"/></connection></connections></paramNode><paramNode><uid v="1000000940"/><function v="neg"/><type v="256"/><GUILayout><gpos v="2584 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000949"/></connection></connections></paramNode><paramNode><uid v="1000000941"/><function v="add"/><type v="2048"/><GUILayout><gpos v="4264 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000953"/></connection><connection><identifier v="b"/><connRef v="1000000947"/></connection></connections></paramNode><paramNode><uid v="1000000942"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1744 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000898"/></connection><connection><identifier v="b"/><connRef v="1000000951"/></connection></connections></paramNode><paramNode><uid v="1000000943"/><function v="sub"/><type v="256"/><GUILayout><gpos v="2584 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000945"/></connection><connection><identifier v="b"/><connRef v="1000000952"/></connection></connections></paramNode><paramNode><uid v="1000000944"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1824 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000945"/><function v="tofloat"/><type v="256"/><GUILayout><gpos v="2304 544 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000000896"/></connection></connections></paramNode><paramNode><uid v="1000000946"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="3424 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000000931"/></connection><connection><identifier v="componentslast"/><connRef v="1000000938"/></connection></connections></paramNode><paramNode><uid v="1000000947"/><function v="vector4"/><type v="2048"/><GUILayout><gpos v="3144 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000000935"/></connection><connection><identifier v="componentslast"/><connRef v="1000000934"/></connection></connections></paramNode><paramNode><uid v="1000000948"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2024 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000942"/></connection><connection><identifier v="b"/><connRef v="1000000944"/></connection></connections></paramNode><paramNode><uid v="1000000949"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2304 704 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000933"/></connection><connection><identifier v="b"/><connRef v="1000000948"/></connection></connections></paramNode><paramNode><uid v="1000000950"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1984 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000951"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 2144 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000952"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 2304 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000953"/><function v="add"/><type v="2048"/><GUILayout><gpos v="3984 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000939"/></connection><connection><identifier v="b"/><connRef v="1000000930"/></connection></connections></paramNode><paramNode><uid v="1000000954"/><function v="const_float4"/><type v="2048"/><GUILayout><gpos v="64 2464 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float4"/><constantValue><constantValueFloat4 v="1 1 1 1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000955"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000929"/></connection><connection><identifier v="ifpath"/><connRef v="1000000905"/></connection><connection><identifier v="elsepath"/><connRef v="1000000956"/></connection></connections></paramNode><paramNode><uid v="1000000956"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 2624 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000957"/><function v="sequence"/><type v="512"/><GUILayout><gpos v="6504 64 0"/></GUILayout><connections><connection><identifier v="seqin"/><connRef v="1000000903"/></connection><connection><identifier v="seqlast"/><connRef v="1000000958"/></connection></connections></paramNode><paramNode><uid v="1000000958"/><function v="set"/><type v="512"/><GUILayout><gpos v="2024 544 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000000962"/></connection></connections><funcDatas><funcData><name v="set"/><constantValue><constantValueString v="xy_ratio"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000959"/><function v="pow2"/><type v="256"/><GUILayout><gpos v="1184 704 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000955"/></connection></connections></paramNode><paramNode><uid v="1000000960"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 2784 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000961"/><function v="div"/><type v="256"/><GUILayout><gpos v="1464 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000960"/></connection><connection><identifier v="b"/><connRef v="1000000959"/></connection></connections></paramNode><paramNode><uid v="1000000962"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1744 544 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000000960"/></connection><connection><identifier v="componentslast"/><connRef v="1000000961"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="non_square_output_size_v2"/><uid v="1000001066"/><attributes><category v=""/><description v="Evaluates the non_square_output_size_v2 function graph. Result type: Integer2. Inputs: scale, output_size, non_square, tile_offset."/><author v=""/><tags v="Various"/></attributes><paraminputs><paraminput><identifier v="scale"/><uid v="1000001067"/><attributes><label v="scale"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="output_size"/><uid v="1000001068"/><attributes><label v="output_size"/></attributes><type v="32"/><defaultValue><constantValueInt2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="non_square"/><uid v="1000001069"/><attributes><label v="non_square"/></attributes><type v="4"/><defaultValue><constantValueBool v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="tile_offset"/><uid v="1000001070"/><attributes><label v="tile_offset"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="32"/><paramValue><dynamicValue><rootnode v="1000000967"/><paramNodes><paramNode><uid v="1000000967"/><function v="sequence"/><type v="32"/><GUILayout><gpos v="9304 64 0"/></GUILayout><connections><connection><identifier v="seqin"/><connRef v="1000001001"/></connection><connection><identifier v="seqlast"/><connRef v="1000000975"/></connection></connections></paramNode><paramNode><uid v="1000000968"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000000969"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000969"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="$sizelog2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000970"/><function v="set"/><type v="16"/><GUILayout><gpos v="3704 64 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000001008"/></connection></connections><funcDatas><funcData><name v="set"/><constantValue><constantValueString v="real_scale"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000971"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000000969"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000972"/><function v="sequence"/><type v="256"/><GUILayout><gpos v="8744 64 0"/></GUILayout><connections><connection><identifier v="seqin"/><connRef v="1000001017"/></connection><connection><identifier v="seqlast"/><connRef v="1000000973"/></connection></connections></paramNode><paramNode><uid v="1000000973"/><function v="set"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000000999"/></connection></connections><funcDatas><funcData><name v="set"/><constantValue><constantValueString v="xy_difference"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000974"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000971"/></connection><connection><identifier v="b"/><connRef v="1000000968"/></connection></connections></paramNode><paramNode><uid v="1000000975"/><function v="get_integer2"/><type v="32"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer2"/><constantValue><constantValueString v="output_size"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000976"/><function v="sequence"/><type v="16"/><GUILayout><gpos v="5944 64 0"/></GUILayout><connections><connection><identifier v="seqin"/><connRef v="1000000991"/></connection><connection><identifier v="seqlast"/><connRef v="1000000970"/></connection></connections></paramNode><paramNode><uid v="1000000977"/><function v="set"/><type v="2048"/><GUILayout><gpos v="5384 64 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000001022"/></connection></connections><funcDatas><funcData><name v="set"/><constantValue><constantValueString v="tiling_region"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000978"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000979"/><function v="swizzle4"/><type v="2048"/><GUILayout><gpos v="4264 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001040"/></connection></connections><funcDatas><funcData><name v="swizzle4"/><constantValue><constantValueInt4 v="2 3 0 1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000980"/><function v="mulscalar"/><type v="512"/><GUILayout><gpos v="2584 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000987"/></connection><connection><identifier v="scalar"/><connRef v="1000000989"/></connection></connections></paramNode><paramNode><uid v="1000000981"/><function v="gt"/><type v="4"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000999"/></connection><connection><identifier v="b"/><connRef v="1000000978"/></connection></connections></paramNode><paramNode><uid v="1000000982"/><function v="ifelse"/><type v="2048"/><GUILayout><gpos v="4544 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000981"/></connection><connection><identifier v="ifpath"/><connRef v="1000001040"/></connection><connection><identifier v="elsepath"/><connRef v="1000000979"/></connection></connections></paramNode><paramNode><uid v="1000000983"/><function v="neg"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000985"/></connection></connections></paramNode><paramNode><uid v="1000000984"/><function v="pow2"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000983"/></connection></connections></paramNode><paramNode><uid v="1000000985"/><function v="abs"/><type v="256"/><GUILayout><gpos v="1184 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000999"/></connection></connections></paramNode><paramNode><uid v="1000000986"/><function v="const_float2"/><type v="512"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float2"/><constantValue><constantValueFloat2 v="1 1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000987"/><function v="sub"/><type v="512"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000986"/></connection><connection><identifier v="b"/><connRef v="1000000988"/></connection></connections></paramNode><paramNode><uid v="1000000988"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000000984"/></connection><connection><identifier v="componentslast"/><connRef v="1000000984"/></connection></connections></paramNode><paramNode><uid v="1000000989"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000990"/><function v="set"/><type v="2048"/><GUILayout><gpos v="5384 224 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000001022"/></connection></connections><funcDatas><funcData><name v="set"/><constantValue><constantValueString v="render_region"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000991"/><function v="sequence"/><type v="2048"/><GUILayout><gpos v="5664 64 0"/></GUILayout><connections><connection><identifier v="seqin"/><connRef v="1000000990"/></connection><connection><identifier v="seqlast"/><connRef v="1000000977"/></connection></connections></paramNode><paramNode><uid v="1000000992"/><function v="get_bool"/><type v="4"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_bool"/><constantValue><constantValueString v="non_square"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000993"/><function v="neg"/><type v="256"/><GUILayout><gpos v="2584 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000994"/></connection></connections></paramNode><paramNode><uid v="1000000994"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2304 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000995"/></connection><connection><identifier v="b"/><connRef v="1000000997"/></connection></connections></paramNode><paramNode><uid v="1000000995"/><function v="sub"/><type v="256"/><GUILayout><gpos v="2024 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001028"/></connection><connection><identifier v="b"/><connRef v="1000000998"/></connection></connections></paramNode><paramNode><uid v="1000000996"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2864 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000000993"/></connection><connection><identifier v="componentslast"/><connRef v="1000000994"/></connection></connections></paramNode><paramNode><uid v="1000000997"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000998"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000000999"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000992"/></connection><connection><identifier v="ifpath"/><connRef v="1000000974"/></connection><connection><identifier v="elsepath"/><connRef v="1000001000"/></connection></connections></paramNode><paramNode><uid v="1000001000"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001001"/><function v="sequence"/><type v="512"/><GUILayout><gpos v="9024 64 0"/></GUILayout><connections><connection><identifier v="seqin"/><connRef v="1000000972"/></connection><connection><identifier v="seqlast"/><connRef v="1000001002"/></connection></connections></paramNode><paramNode><uid v="1000001002"/><function v="set"/><type v="512"/><GUILayout><gpos v="2024 384 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000001006"/></connection></connections><funcDatas><funcData><name v="set"/><constantValue><constantValueString v="xy_ratio"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001003"/><function v="pow2"/><type v="256"/><GUILayout><gpos v="1184 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000999"/></connection></connections></paramNode><paramNode><uid v="1000001004"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001005"/><function v="div"/><type v="256"/><GUILayout><gpos v="1464 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001004"/></connection><connection><identifier v="b"/><connRef v="1000001003"/></connection></connections></paramNode><paramNode><uid v="1000001006"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1744 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001004"/></connection><connection><identifier v="componentslast"/><connRef v="1000001005"/></connection></connections></paramNode><paramNode><uid v="1000001007"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 1664 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="scale"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001008"/><function v="toint1"/><type v="16"/><GUILayout><gpos v="3424 64 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000001034"/></connection></connections></paramNode><paramNode><uid v="1000001009"/><function v="ceil"/><type v="256"/><GUILayout><gpos v="1744 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001029"/></connection></connections></paramNode><paramNode><uid v="1000001010"/><function v="gt"/><type v="4"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000971"/></connection><connection><identifier v="b"/><connRef v="1000000968"/></connection></connections></paramNode><paramNode><uid v="1000001011"/><function v="ifelse"/><type v="512"/><GUILayout><gpos v="1464 384 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001010"/></connection><connection><identifier v="ifpath"/><connRef v="1000001012"/></connection><connection><identifier v="elsepath"/><connRef v="1000001015"/></connection></connections></paramNode><paramNode><uid v="1000001012"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="904 228 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000000974"/></connection><connection><identifier v="componentslast"/><connRef v="1000001013"/></connection></connections></paramNode><paramNode><uid v="1000001013"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1824 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001014"/><function v="pow2"/><type v="512"/><GUILayout><gpos v="2024 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001033"/></connection></connections></paramNode><paramNode><uid v="1000001015"/><function v="swizzle2"/><type v="512"/><GUILayout><gpos v="1184 704 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001012"/></connection></connections><funcDatas><funcData><name v="swizzle2"/><constantValue><constantValueInt2 v="1 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001016"/><function v="set"/><type v="16"/><GUILayout><gpos v="8184 64 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000001052"/></connection></connections><funcDatas><funcData><name v="set"/><constantValue><constantValueString v="total_number"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001017"/><function v="sequence"/><type v="16"/><GUILayout><gpos v="8464 64 0"/></GUILayout><connections><connection><identifier v="seqin"/><connRef v="1000000976"/></connection><connection><identifier v="seqlast"/><connRef v="1000001016"/></connection></connections></paramNode><paramNode><uid v="1000001018"/><function v="mul"/><type v="512"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001019"/></connection><connection><identifier v="b"/><connRef v="1000001030"/></connection></connections></paramNode><paramNode><uid v="1000001019"/><function v="const_float2"/><type v="512"/><GUILayout><gpos v="64 1984 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float2"/><constantValue><constantValueFloat2 v="1 -1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001020"/><function v="swizzle4"/><type v="2048"/><GUILayout><gpos v="904 388 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001021"/></connection></connections><funcDatas><funcData><name v="swizzle4"/><constantValue><constantValueInt4 v="0 0 1 1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001021"/><function v="mulscalar"/><type v="512"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001018"/></connection><connection><identifier v="scalar"/><connRef v="1000001064"/></connection></connections></paramNode><paramNode><uid v="1000001022"/><function v="add"/><type v="2048"/><GUILayout><gpos v="5104 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001041"/></connection><connection><identifier v="b"/><connRef v="1000001032"/></connection></connections></paramNode><paramNode><uid v="1000001023"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 2144 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001024"/><function v="add"/><type v="256"/><GUILayout><gpos v="2584 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001026"/></connection><connection><identifier v="b"/><connRef v="1000001027"/></connection></connections></paramNode><paramNode><uid v="1000001025"/><function v="add"/><type v="256"/><GUILayout><gpos v="2864 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001035"/></connection><connection><identifier v="b"/><connRef v="1000001024"/></connection></connections></paramNode><paramNode><uid v="1000001026"/><function v="mod"/><type v="256"/><GUILayout><gpos v="2304 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001035"/></connection><connection><identifier v="b"/><connRef v="1000001023"/></connection></connections></paramNode><paramNode><uid v="1000001027"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 2304 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001028"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1744 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001029"/></connection><connection><identifier v="b"/><connRef v="1000001064"/></connection></connections></paramNode><paramNode><uid v="1000001029"/><function v="pow2"/><type v="256"/><GUILayout><gpos v="1464 548 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000985"/></connection></connections></paramNode><paramNode><uid v="1000001030"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 2464 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="tile_offset"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001031"/><function v="swizzle4"/><type v="2048"/><GUILayout><gpos v="2584 544 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001062"/></connection></connections><funcDatas><funcData><name v="swizzle4"/><constantValue><constantValueInt4 v="0 0 1 1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001032"/><function v="mul"/><type v="2048"/><GUILayout><gpos v="2864 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001020"/></connection><connection><identifier v="b"/><connRef v="1000001031"/></connection></connections></paramNode><paramNode><uid v="1000001033"/><function v="abs"/><type v="512"/><GUILayout><gpos v="1744 704 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001011"/></connection></connections></paramNode><paramNode><uid v="1000001034"/><function v="mul"/><type v="256"/><GUILayout><gpos v="3144 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001025"/></connection><connection><identifier v="b"/><connRef v="1000001025"/></connection></connections></paramNode><paramNode><uid v="1000001035"/><function v="passthrough"/><type v="256"/><GUILayout><gpos v="2024 704 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000001009"/></connection></connections></paramNode><paramNode><uid v="1000001036"/><function v="add"/><type v="512"/><GUILayout><gpos v="3144 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000996"/></connection><connection><identifier v="b"/><connRef v="1000001037"/></connection></connections></paramNode><paramNode><uid v="1000001037"/><function v="const_float2"/><type v="512"/><GUILayout><gpos v="64 2624 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float2"/><constantValue><constantValueFloat2 v="0 1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001038"/><function v="mul"/><type v="512"/><GUILayout><gpos v="3424 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001036"/></connection><connection><identifier v="b"/><connRef v="1000000988"/></connection></connections></paramNode><paramNode><uid v="1000001039"/><function v="add"/><type v="512"/><GUILayout><gpos v="3704 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001038"/></connection><connection><identifier v="b"/><connRef v="1000000980"/></connection></connections></paramNode><paramNode><uid v="1000001040"/><function v="vector4"/><type v="2048"/><GUILayout><gpos v="3984 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001036"/></connection><connection><identifier v="componentslast"/><connRef v="1000001039"/></connection></connections></paramNode><paramNode><uid v="1000001041"/><function v="mulscalar"/><type v="2048"/><GUILayout><gpos v="4824 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000000982"/></connection><connection><identifier v="scalar"/><connRef v="1000001042"/></connection></connections></paramNode><paramNode><uid v="1000001042"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 2784 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001043"/><function v="abs"/><type v="2048"/><GUILayout><gpos v="5384 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001022"/></connection></connections></paramNode><paramNode><uid v="1000001044"/><function v="ceil"/><type v="2048"/><GUILayout><gpos v="5944 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001060"/></connection></connections></paramNode><paramNode><uid v="1000001045"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="6224 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001044"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001046"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="6224 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001044"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001047"/><function v="max"/><type v="256"/><GUILayout><gpos v="6504 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001045"/></connection><connection><identifier v="b"/><connRef v="1000001046"/></connection></connections></paramNode><paramNode><uid v="1000001048"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="6224 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001044"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001049"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="6224 544 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001044"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001050"/><function v="max"/><type v="256"/><GUILayout><gpos v="6504 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001049"/></connection><connection><identifier v="b"/><connRef v="1000001048"/></connection></connections></paramNode><paramNode><uid v="1000001051"/><function v="mul"/><type v="256"/><GUILayout><gpos v="7624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001059"/></connection><connection><identifier v="b"/><connRef v="1000001059"/></connection></connections></paramNode><paramNode><uid v="1000001052"/><function v="toint1"/><type v="16"/><GUILayout><gpos v="7904 64 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000001051"/></connection></connections></paramNode><paramNode><uid v="1000001053"/><function v="mul"/><type v="256"/><GUILayout><gpos v="6784 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001047"/></connection><connection><identifier v="b"/><connRef v="1000001054"/></connection></connections></paramNode><paramNode><uid v="1000001054"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 2944 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001055"/><function v="add"/><type v="256"/><GUILayout><gpos v="7064 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001053"/></connection><connection><identifier v="b"/><connRef v="1000001056"/></connection></connections></paramNode><paramNode><uid v="1000001056"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 3104 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001057"/><function v="add"/><type v="256"/><GUILayout><gpos v="7064 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001058"/></connection><connection><identifier v="b"/><connRef v="1000001056"/></connection></connections></paramNode><paramNode><uid v="1000001058"/><function v="mul"/><type v="256"/><GUILayout><gpos v="6784 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001050"/></connection><connection><identifier v="b"/><connRef v="1000001054"/></connection></connections></paramNode><paramNode><uid v="1000001059"/><function v="max"/><type v="256"/><GUILayout><gpos v="7344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001055"/></connection><connection><identifier v="b"/><connRef v="1000001057"/></connection></connections></paramNode><paramNode><uid v="1000001060"/><function v="sub"/><type v="2048"/><GUILayout><gpos v="5664 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001043"/></connection><connection><identifier v="b"/><connRef v="1000001061"/></connection></connections></paramNode><paramNode><uid v="1000001061"/><function v="const_float4"/><type v="2048"/><GUILayout><gpos v="64 3264 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float4"/><constantValue><constantValueFloat4 v="-0.5 0.5 -0.5 0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001062"/><function v="ifelse"/><type v="512"/><GUILayout><gpos v="2304 544 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000000992"/></connection><connection><identifier v="ifpath"/><connRef v="1000001014"/></connection><connection><identifier v="elsepath"/><connRef v="1000001063"/></connection></connections></paramNode><paramNode><uid v="1000001063"/><function v="const_float2"/><type v="512"/><GUILayout><gpos v="64 3424 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float2"/><constantValue><constantValueFloat2 v="1 1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001064"/><function v="max"/><type v="256"/><GUILayout><gpos v="344 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001007"/></connection><connection><identifier v="b"/><connRef v="1000001065"/></connection></connections></paramNode><paramNode><uid v="1000001065"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 3584 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="non_square_expansion_uv_scale"/><uid v="1000001092"/><attributes><category v=""/><description v="Evaluates the non_square_expansion_uv_scale function graph. Result type: Float2. Inputs: position, non_square_expansion."/><author v=""/><tags v="Various"/></attributes><paraminputs><paraminput><identifier v="position"/><uid v="1000001093"/><attributes><label v="Position"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="non_square_expansion"/><uid v="1000001094"/><attributes><label v="Non-square expansion"/></attributes><type v="4"/><defaultValue><constantValueBool v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="512"/><paramValue><dynamicValue><rootnode v="1000001077"/><paramNodes><paramNode><uid v="1000001071"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="position"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001072"/><function v="get_bool"/><type v="4"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_bool"/><constantValue><constantValueString v="non_square_expansion"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001073"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="$sizelog2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001074"/><function v="max"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001076"/></connection><connection><identifier v="b"/><connRef v="1000001083"/></connection></connections></paramNode><paramNode><uid v="1000001075"/><function v="const_float2"/><type v="512"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float2"/><constantValue><constantValueFloat2 v="0.5 0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001076"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001073"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001077"/><function v="ifelse"/><type v="512"/><GUILayout><gpos v="3144 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001072"/></connection><connection><identifier v="ifpath"/><connRef v="1000001081"/></connection><connection><identifier v="elsepath"/><connRef v="1000001071"/></connection></connections></paramNode><paramNode><uid v="1000001078"/><function v="ifelse"/><type v="512"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001086"/></connection><connection><identifier v="ifpath"/><connRef v="1000001085"/></connection><connection><identifier v="elsepath"/><connRef v="1000001089"/></connection></connections></paramNode><paramNode><uid v="1000001079"/><function v="mul"/><type v="512"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001080"/></connection><connection><identifier v="b"/><connRef v="1000001071"/></connection></connections></paramNode><paramNode><uid v="1000001080"/><function v="pow2"/><type v="512"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001078"/></connection></connections></paramNode><paramNode><uid v="1000001081"/><function v="sub"/><type v="512"/><GUILayout><gpos v="2864 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001079"/></connection><connection><identifier v="b"/><connRef v="1000001082"/></connection></connections></paramNode><paramNode><uid v="1000001082"/><function v="mul"/><type v="512"/><GUILayout><gpos v="2584 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001087"/></connection><connection><identifier v="b"/><connRef v="1000001075"/></connection></connections></paramNode><paramNode><uid v="1000001083"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001073"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001084"/><function v="const_float2"/><type v="512"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float2"/><constantValue><constantValueFloat2 v="1 1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001085"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001091"/></connection><connection><identifier v="componentslast"/><connRef v="1000001088"/></connection></connections></paramNode><paramNode><uid v="1000001086"/><function v="gt"/><type v="4"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001076"/></connection><connection><identifier v="b"/><connRef v="1000001083"/></connection></connections></paramNode><paramNode><uid v="1000001087"/><function v="sub"/><type v="512"/><GUILayout><gpos v="2304 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001080"/></connection><connection><identifier v="b"/><connRef v="1000001084"/></connection></connections></paramNode><paramNode><uid v="1000001088"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001089"/><function v="swizzle2"/><type v="512"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001085"/></connection></connections><funcDatas><funcData><name v="swizzle2"/><constantValue><constantValueInt2 v="1 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001090"/><function v="min"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001076"/></connection><connection><identifier v="b"/><connRef v="1000001083"/></connection></connections></paramNode><paramNode><uid v="1000001091"/><function v="sub"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001074"/></connection><connection><identifier v="b"/><connRef v="1000001090"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="compute_total_number"/><uid v="1000001128"/><attributes><category v=""/><description v="Evaluates the compute_total_number function graph. Result type: Integer. Inputs: tile_multiplier."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="tile_multiplier"/><uid v="1000001129"/><attributes><label v="tile_multiplier"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput></paraminputs><type v="16"/><paramValue><dynamicValue><rootnode v="1000001127"/><paramNodes><paramNode><uid v="1000001095"/><function v="mul"/><type v="256"/><GUILayout><gpos v="3984 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001108"/></connection><connection><identifier v="b"/><connRef v="1000001108"/></connection></connections></paramNode><paramNode><uid v="1000001096"/><function v="toint1"/><type v="16"/><GUILayout><gpos v="4264 64 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000001095"/></connection></connections></paramNode><paramNode><uid v="1000001097"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001098"/><function v="mul"/><type v="256"/><GUILayout><gpos v="3144 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001107"/></connection><connection><identifier v="b"/><connRef v="1000001097"/></connection></connections></paramNode><paramNode><uid v="1000001099"/><function v="const_float4"/><type v="2048"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float4"/><constantValue><constantValueFloat4 v="-0.5 0.5 -0.5 0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001100"/><function v="sub"/><type v="2048"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001106"/></connection><connection><identifier v="b"/><connRef v="1000001099"/></connection></connections></paramNode><paramNode><uid v="1000001101"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="2584 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001102"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001102"/><function v="ceil"/><type v="2048"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001100"/></connection></connections></paramNode><paramNode><uid v="1000001103"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001104"/><function v="mul"/><type v="256"/><GUILayout><gpos v="3144 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001114"/></connection><connection><identifier v="b"/><connRef v="1000001097"/></connection></connections></paramNode><paramNode><uid v="1000001105"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="2584 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001102"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001106"/><function v="abs"/><type v="2048"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001113"/></connection></connections></paramNode><paramNode><uid v="1000001107"/><function v="max"/><type v="256"/><GUILayout><gpos v="2864 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001109"/></connection><connection><identifier v="b"/><connRef v="1000001105"/></connection></connections></paramNode><paramNode><uid v="1000001108"/><function v="max"/><type v="256"/><GUILayout><gpos v="3704 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001110"/></connection><connection><identifier v="b"/><connRef v="1000001111"/></connection></connections></paramNode><paramNode><uid v="1000001109"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="2584 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001102"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001110"/><function v="add"/><type v="256"/><GUILayout><gpos v="3424 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001098"/></connection><connection><identifier v="b"/><connRef v="1000001103"/></connection></connections></paramNode><paramNode><uid v="1000001111"/><function v="add"/><type v="256"/><GUILayout><gpos v="3424 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001104"/></connection><connection><identifier v="b"/><connRef v="1000001103"/></connection></connections></paramNode><paramNode><uid v="1000001112"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="2584 544 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001102"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001113"/><function v="mulscalar"/><type v="2048"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001117"/></connection><connection><identifier v="scalar"/><connRef v="1000001116"/></connection></connections></paramNode><paramNode><uid v="1000001114"/><function v="max"/><type v="256"/><GUILayout><gpos v="2864 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001101"/></connection><connection><identifier v="b"/><connRef v="1000001112"/></connection></connections></paramNode><paramNode><uid v="1000001115"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="tile_multiplier"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001116"/><function v="tofloat"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000001121"/></connection></connections></paramNode><paramNode><uid v="1000001117"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="render_region"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001118"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="$tiling"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001119"/><function v="eq"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001118"/></connection><connection><identifier v="b"/><connRef v="1000001120"/></connection></connections></paramNode><paramNode><uid v="1000001120"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001121"/><function v="ifelse"/><type v="16"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001124"/></connection><connection><identifier v="ifpath"/><connRef v="1000001115"/></connection><connection><identifier v="elsepath"/><connRef v="1000001122"/></connection></connections></paramNode><paramNode><uid v="1000001122"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001123"/><function v="isdefined"/><type v="4"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="isdefined"/><constantValue><constantValueString v="tile_multiplier"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001124"/><function v="and"/><type v="4"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001119"/></connection><connection><identifier v="b"/><connRef v="1000001123"/></connection></connections></paramNode><paramNode><uid v="1000001125"/><function v="tofloat"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000001115"/></connection></connections></paramNode><paramNode><uid v="1000001126"/><function v="set"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000001125"/></connection></connections><funcDatas><funcData><name v="set"/><constantValue><constantValueString v="c_tile_multiplier"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001127"/><function v="sequence"/><type v="16"/><GUILayout><gpos v="4544 64 0"/></GUILayout><connections><connection><identifier v="seqin"/><connRef v="1000001126"/></connection><connection><identifier v="seqlast"/><connRef v="1000001096"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="colorValues"/><uid v="1000001130"/><content><function><identifier v="directionToNormal"/><uid v="1000001156"/><attributes><category v=""/><description v="Evaluates the directionToNormal function graph. Result type: Float4. Inputs: Direction, slopeAngle, yUp."/><author v=""/><tags v="Color"/></attributes><paraminputs><paraminput><identifier v="Direction"/><uid v="1000001157"/><attributes><label v="Direction"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="360"/></option></options></defaultWidget></paraminput><paraminput><identifier v="slopeAngle"/><uid v="1000001158"/><attributes><label v="slopeAngle"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="90"/></option></options></defaultWidget></paraminput><paraminput><identifier v="yUp"/><uid v="1000001159"/><attributes><label v="yUp"/></attributes><type v="4"/><defaultValue><constantValueBool v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="2048"/><paramValue><dynamicValue><rootnode v="1000001153"/><paramNodes><paramNode><uid v="1000001131"/><function v="sin"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001150"/></connection></connections></paramNode><paramNode><uid v="1000001132"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001133"/></connection><connection><identifier v="componentslast"/><connRef v="1000001133"/></connection></connections></paramNode><paramNode><uid v="1000001133"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001134"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001146"/></connection><connection><identifier v="b"/><connRef v="1000001142"/></connection></connections></paramNode><paramNode><uid v="1000001135"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="180"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001136"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001137"/><function v="instance"/><type v="118772"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="Input"/><connRef v="1000001141"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Ranges/[-1_1]_to_[0_1]"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="Input"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001138"/><function v="add"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001154"/></connection><connection><identifier v="b"/><connRef v="1000001145"/></connection></connections></paramNode><paramNode><uid v="1000001139"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="slopeAngle"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001140"/><function v="instance"/><type v="118772"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="deg"/><connRef v="1000001155"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Trigo/deg_to_rad"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="deg"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001141"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1464 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001131"/></connection><connection><identifier v="b"/><connRef v="1000001142"/></connection></connections></paramNode><paramNode><uid v="1000001142"/><function v="sin"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001140"/></connection></connections></paramNode><paramNode><uid v="1000001143"/><function v="instance"/><type v="118772"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="deg"/><connRef v="1000001149"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Trigo/deg_to_rad"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="deg"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001144"/><function v="instance"/><type v="118772"/><GUILayout><gpos v="1744 224 0"/></GUILayout><connections><connection><identifier v="Input"/><connRef v="1000001134"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Ranges/[-1_1]_to_[0_1]"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="Input"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001145"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001148"/></connection><connection><identifier v="ifpath"/><connRef v="1000001136"/></connection><connection><identifier v="elsepath"/><connRef v="1000001151"/></connection></connections></paramNode><paramNode><uid v="1000001146"/><function v="cos"/><type v="256"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001143"/></connection></connections></paramNode><paramNode><uid v="1000001147"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001144"/></connection><connection><identifier v="componentslast"/><connRef v="1000001137"/></connection></connections></paramNode><paramNode><uid v="1000001148"/><function v="get_bool"/><type v="4"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_bool"/><constantValue><constantValueString v="yUp"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001149"/><function v="add"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001154"/></connection><connection><identifier v="b"/><connRef v="1000001135"/></connection></connections></paramNode><paramNode><uid v="1000001150"/><function v="instance"/><type v="118772"/><GUILayout><gpos v="904 384 0"/></GUILayout><connections><connection><identifier v="deg"/><connRef v="1000001138"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Trigo/deg_to_rad"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="deg"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001151"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="180"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001152"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="Direction"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001153"/><function v="vector4"/><type v="2048"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001147"/></connection><connection><identifier v="componentslast"/><connRef v="1000001132"/></connection></connections></paramNode><paramNode><uid v="1000001154"/><function v="instance"/><type v="118772"/><GUILayout><gpos v="344 388 0"/></GUILayout><connections><connection><identifier v="turns"/><connRef v="1000001152"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/typeConverters/turnsToDegrees"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="turns"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001155"/><function v="instance"/><type v="118772"/><GUILayout><gpos v="344 548 0"/></GUILayout><connections><connection><identifier v="turns"/><connRef v="1000001139"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/typeConverters/turnsToDegrees"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="turns"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="RGBtoHSL"/><uid v="1000001207"/><attributes><category v=""/><description v="Evaluates the RGBtoHSL function graph. Result type: Float3. Inputs: RGB."/><author v=""/><tags v="Color"/></attributes><paraminputs><paraminput><identifier v="RGB"/><uid v="1000001208"/><attributes><label v="RGB"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="0 0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000001175"/><paramNodes><paramNode><uid v="1000001160"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001195"/></connection><connection><identifier v="ifpath"/><connRef v="1000001196"/></connection><connection><identifier v="elsepath"/><connRef v="1000001178"/></connection></connections></paramNode><paramNode><uid v="1000001161"/><function v="noteq"/><type v="4"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001174"/></connection><connection><identifier v="b"/><connRef v="1000001164"/></connection></connections></paramNode><paramNode><uid v="1000001162"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001163"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001193"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001164"/><function v="min"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001183"/></connection><connection><identifier v="b"/><connRef v="1000001191"/></connection></connections></paramNode><paramNode><uid v="1000001165"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001166"/><function v="div"/><type v="256"/><GUILayout><gpos v="1744 228 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001169"/></connection><connection><identifier v="b"/><connRef v="1000001190"/></connection></connections></paramNode><paramNode><uid v="1000001167"/><function v="div"/><type v="256"/><GUILayout><gpos v="1744 388 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001187"/></connection><connection><identifier v="b"/><connRef v="1000001190"/></connection></connections></paramNode><paramNode><uid v="1000001168"/><function v="passthrough"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000001206"/></connection></connections></paramNode><paramNode><uid v="1000001169"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001200"/></connection><connection><identifier v="b"/><connRef v="1000001163"/></connection></connections></paramNode><paramNode><uid v="1000001170"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001203"/></connection><connection><identifier v="b"/><connRef v="1000001174"/></connection></connections></paramNode><paramNode><uid v="1000001171"/><function v="div"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001190"/></connection><connection><identifier v="b"/><connRef v="1000001160"/></connection></connections></paramNode><paramNode><uid v="1000001172"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001173"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="2584 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001202"/></connection><connection><identifier v="ifpath"/><connRef v="1000001204"/></connection><connection><identifier v="elsepath"/><connRef v="1000001176"/></connection></connections></paramNode><paramNode><uid v="1000001174"/><function v="max"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001201"/></connection><connection><identifier v="b"/><connRef v="1000001191"/></connection></connections></paramNode><paramNode><uid v="1000001175"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="3704 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001161"/></connection><connection><identifier v="ifpath"/><connRef v="1000001194"/></connection><connection><identifier v="elsepath"/><connRef v="1000001198"/></connection></connections></paramNode><paramNode><uid v="1000001176"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001199"/></connection><connection><identifier v="ifpath"/><connRef v="1000001182"/></connection><connection><identifier v="elsepath"/><connRef v="1000001189"/></connection></connections></paramNode><paramNode><uid v="1000001177"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001191"/></connection><connection><identifier v="b"/><connRef v="1000001200"/></connection></connections></paramNode><paramNode><uid v="1000001178"/><function v="add"/><type v="256"/><GUILayout><gpos v="1184 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001174"/></connection><connection><identifier v="b"/><connRef v="1000001164"/></connection></connections></paramNode><paramNode><uid v="1000001179"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="3144 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001181"/></connection><connection><identifier v="componentslast"/><connRef v="1000001171"/></connection></connections></paramNode><paramNode><uid v="1000001180"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001181"/><function v="div"/><type v="256"/><GUILayout><gpos v="2864 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001173"/></connection><connection><identifier v="b"/><connRef v="1000001197"/></connection></connections></paramNode><paramNode><uid v="1000001182"/><function v="add"/><type v="256"/><GUILayout><gpos v="2024 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001205"/></connection><connection><identifier v="b"/><connRef v="1000001165"/></connection></connections></paramNode><paramNode><uid v="1000001183"/><function v="min"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001200"/></connection><connection><identifier v="b"/><connRef v="1000001163"/></connection></connections></paramNode><paramNode><uid v="1000001184"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1184 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001174"/></connection><connection><identifier v="b"/><connRef v="1000001164"/></connection></connections></paramNode><paramNode><uid v="1000001185"/><function v="const_float2"/><type v="512"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float2"/><constantValue><constantValueFloat2 v="0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001186"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="6"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001187"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001163"/></connection><connection><identifier v="b"/><connRef v="1000001191"/></connection></connections></paramNode><paramNode><uid v="1000001188"/><function v="lr"/><type v="4"/><GUILayout><gpos v="624 704 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001163"/></connection><connection><identifier v="b"/><connRef v="1000001191"/></connection></connections></paramNode><paramNode><uid v="1000001189"/><function v="add"/><type v="256"/><GUILayout><gpos v="2024 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001166"/></connection><connection><identifier v="b"/><connRef v="1000001180"/></connection></connections></paramNode><paramNode><uid v="1000001190"/><function v="passthrough"/><type v="256"/><GUILayout><gpos v="1464 224 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000001184"/></connection></connections></paramNode><paramNode><uid v="1000001191"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001193"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001192"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="904 384 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001188"/></connection><connection><identifier v="ifpath"/><connRef v="1000001186"/></connection><connection><identifier v="elsepath"/><connRef v="1000001172"/></connection></connections></paramNode><paramNode><uid v="1000001193"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="RGB"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001194"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="3424 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001179"/></connection><connection><identifier v="componentslast"/><connRef v="1000001168"/></connection></connections></paramNode><paramNode><uid v="1000001195"/><function v="gt"/><type v="4"/><GUILayout><gpos v="1464 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001206"/></connection><connection><identifier v="b"/><connRef v="1000001162"/></connection></connections></paramNode><paramNode><uid v="1000001196"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1464 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001170"/></connection><connection><identifier v="b"/><connRef v="1000001164"/></connection></connections></paramNode><paramNode><uid v="1000001197"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="6"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001198"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="1744 548 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001185"/></connection><connection><identifier v="componentslast"/><connRef v="1000001168"/></connection></connections></paramNode><paramNode><uid v="1000001199"/><function v="eq"/><type v="4"/><GUILayout><gpos v="1184 704 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001174"/></connection><connection><identifier v="b"/><connRef v="1000001163"/></connection></connections></paramNode><paramNode><uid v="1000001200"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001193"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001201"/><function v="max"/><type v="256"/><GUILayout><gpos v="624 864 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001200"/></connection><connection><identifier v="b"/><connRef v="1000001163"/></connection></connections></paramNode><paramNode><uid v="1000001202"/><function v="eq"/><type v="4"/><GUILayout><gpos v="1184 864 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001174"/></connection><connection><identifier v="b"/><connRef v="1000001200"/></connection></connections></paramNode><paramNode><uid v="1000001203"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001204"/><function v="add"/><type v="256"/><GUILayout><gpos v="2024 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001167"/></connection><connection><identifier v="b"/><connRef v="1000001192"/></connection></connections></paramNode><paramNode><uid v="1000001205"/><function v="div"/><type v="256"/><GUILayout><gpos v="1744 708 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001177"/></connection><connection><identifier v="b"/><connRef v="1000001190"/></connection></connections></paramNode><paramNode><uid v="1000001206"/><function v="instance"/><type v="118772"/><GUILayout><gpos v="1184 1024 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001174"/></connection><connection><identifier v="b"/><connRef v="1000001164"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/average_float1"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="a"/><type v="0"/></input><input><identifier v="b"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="HSLtoRGB"/><uid v="1000001252"/><attributes><category v=""/><description v="Evaluates the HSLtoRGB function graph. Result type: Float3. Inputs: HSL."/><author v=""/><tags v="Color"/></attributes><paraminputs><paraminput><identifier v="HSL"/><uid v="1000001253"/><attributes><label v="HSL"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="0 0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000001249"/><paramNodes><paramNode><uid v="1000001209"/><function v="swizzle3"/><type v="1024"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001251"/></connection></connections><funcDatas><funcData><name v="swizzle3"/><constantValue><constantValueInt3 v="0 0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001210"/><function v="sub"/><type v="1024"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001209"/></connection><connection><identifier v="b"/><connRef v="1000001216"/></connection></connections></paramNode><paramNode><uid v="1000001211"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001212"/></connection><connection><identifier v="componentslast"/><connRef v="1000001215"/></connection></connections></paramNode><paramNode><uid v="1000001212"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001213"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001214"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001215"/><function v="div"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001213"/></connection><connection><identifier v="b"/><connRef v="1000001214"/></connection></connections></paramNode><paramNode><uid v="1000001216"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001211"/></connection><connection><identifier v="componentslast"/><connRef v="1000001217"/></connection></connections></paramNode><paramNode><uid v="1000001217"/><function v="div"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001218"/></connection><connection><identifier v="b"/><connRef v="1000001214"/></connection></connections></paramNode><paramNode><uid v="1000001218"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001219"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001210"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001220"/><function v="abs"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001219"/></connection></connections></paramNode><paramNode><uid v="1000001221"/><function v="abs"/><type v="256"/><GUILayout><gpos v="1744 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001222"/></connection></connections></paramNode><paramNode><uid v="1000001222"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="1464 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001210"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001223"/><function v="abs"/><type v="256"/><GUILayout><gpos v="1744 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001224"/></connection></connections></paramNode><paramNode><uid v="1000001224"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="1464 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001210"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001225"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001220"/></connection><connection><identifier v="componentslast"/><connRef v="1000001221"/></connection></connections></paramNode><paramNode><uid v="1000001226"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001225"/></connection><connection><identifier v="componentslast"/><connRef v="1000001223"/></connection></connections></paramNode><paramNode><uid v="1000001227"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="6 -6 -6"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001228"/><function v="mul"/><type v="1024"/><GUILayout><gpos v="2584 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001226"/></connection><connection><identifier v="b"/><connRef v="1000001227"/></connection></connections></paramNode><paramNode><uid v="1000001229"/><function v="add"/><type v="1024"/><GUILayout><gpos v="2864 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001228"/></connection><connection><identifier v="b"/><connRef v="1000001230"/></connection></connections></paramNode><paramNode><uid v="1000001230"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="-1 2 2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001231"/><function v="min"/><type v="1024"/><GUILayout><gpos v="3144 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001229"/></connection><connection><identifier v="b"/><connRef v="1000001233"/></connection></connections></paramNode><paramNode><uid v="1000001232"/><function v="max"/><type v="1024"/><GUILayout><gpos v="3424 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001231"/></connection><connection><identifier v="b"/><connRef v="1000001234"/></connection></connections></paramNode><paramNode><uid v="1000001233"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="1 1 1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001234"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0 0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001235"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 544 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001251"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001236"/><function v="add"/><type v="256"/><GUILayout><gpos v="1744 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001235"/></connection><connection><identifier v="b"/><connRef v="1000001237"/></connection></connections></paramNode><paramNode><uid v="1000001237"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1464 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001242"/></connection><connection><identifier v="b"/><connRef v="1000001238"/></connection></connections></paramNode><paramNode><uid v="1000001238"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 704 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001251"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001239"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001240"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001239"/></connection><connection><identifier v="b"/><connRef v="1000001235"/></connection></connections></paramNode><paramNode><uid v="1000001241"/><function v="abs"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001240"/></connection></connections></paramNode><paramNode><uid v="1000001242"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001239"/></connection><connection><identifier v="b"/><connRef v="1000001241"/></connection></connections></paramNode><paramNode><uid v="1000001243"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001235"/></connection><connection><identifier v="b"/><connRef v="1000001244"/></connection></connections></paramNode><paramNode><uid v="1000001244"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001245"/><function v="sub"/><type v="256"/><GUILayout><gpos v="2024 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001243"/></connection><connection><identifier v="b"/><connRef v="1000001236"/></connection></connections></paramNode><paramNode><uid v="1000001246"/><function v="swizzle3"/><type v="1024"/><GUILayout><gpos v="2304 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001245"/></connection></connections><funcDatas><funcData><name v="swizzle3"/><constantValue><constantValueInt3 v="0 0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001247"/><function v="swizzle3"/><type v="1024"/><GUILayout><gpos v="2024 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001236"/></connection></connections><funcDatas><funcData><name v="swizzle3"/><constantValue><constantValueInt3 v="0 0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001248"/><function v="sub"/><type v="1024"/><GUILayout><gpos v="2584 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001247"/></connection><connection><identifier v="b"/><connRef v="1000001246"/></connection></connections></paramNode><paramNode><uid v="1000001249"/><function v="add"/><type v="1024"/><GUILayout><gpos v="3984 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001246"/></connection><connection><identifier v="b"/><connRef v="1000001250"/></connection></connections></paramNode><paramNode><uid v="1000001250"/><function v="mul"/><type v="1024"/><GUILayout><gpos v="3704 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001248"/></connection><connection><identifier v="b"/><connRef v="1000001232"/></connection></connections></paramNode><paramNode><uid v="1000001251"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 1664 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="HSL"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="Random_Color"/><uid v="1000001283"/><attributes><category v=""/><description v="Evaluates the Random_Color function graph. Result type: Float3. Inputs: RGB, RGB_Randomness."/><author v=""/><tags v="Color"/></attributes><paraminputs><paraminput><identifier v="RGB"/><uid v="1000001284"/><attributes><label v="RGB"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="0 0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="RGB_Randomness"/><uid v="1000001285"/><attributes><label v="RGB_Randomness"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="0 0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000001282"/><paramNodes><paramNode><uid v="1000001254"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001255"/></connection><connection><identifier v="b"/><connRef v="1000001269"/></connection></connections></paramNode><paramNode><uid v="1000001255"/><function v="rand"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001278"/></connection></connections></paramNode><paramNode><uid v="1000001256"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001260"/></connection><connection><identifier v="componentslast"/><connRef v="1000001261"/></connection></connections></paramNode><paramNode><uid v="1000001257"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001273"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001258"/><function v="rand"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001278"/></connection></connections></paramNode><paramNode><uid v="1000001259"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001258"/></connection><connection><identifier v="b"/><connRef v="1000001266"/></connection></connections></paramNode><paramNode><uid v="1000001260"/><function v="add"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001272"/></connection><connection><identifier v="b"/><connRef v="1000001279"/></connection></connections></paramNode><paramNode><uid v="1000001261"/><function v="add"/><type v="256"/><GUILayout><gpos v="1464 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001268"/></connection><connection><identifier v="b"/><connRef v="1000001280"/></connection></connections></paramNode><paramNode><uid v="1000001262"/><function v="sub"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001270"/></connection><connection><identifier v="b"/><connRef v="1000001278"/></connection></connections></paramNode><paramNode><uid v="1000001263"/><function v="sub"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001259"/></connection><connection><identifier v="b"/><connRef v="1000001278"/></connection></connections></paramNode><paramNode><uid v="1000001264"/><function v="add"/><type v="256"/><GUILayout><gpos v="1464 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001257"/></connection><connection><identifier v="b"/><connRef v="1000001281"/></connection></connections></paramNode><paramNode><uid v="1000001265"/><function v="rand"/><type v="256"/><GUILayout><gpos v="344 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001278"/></connection></connections></paramNode><paramNode><uid v="1000001266"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001267"/><function v="sub"/><type v="256"/><GUILayout><gpos v="904 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001254"/></connection><connection><identifier v="b"/><connRef v="1000001278"/></connection></connections></paramNode><paramNode><uid v="1000001268"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 704 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001273"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001269"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001270"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001265"/></connection><connection><identifier v="b"/><connRef v="1000001271"/></connection></connections></paramNode><paramNode><uid v="1000001271"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001272"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 864 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001273"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001273"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="RGB"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001274"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 1024 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001277"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001275"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 1184 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001277"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001276"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 1344 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001277"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001277"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="RGB_Randomness"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001278"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001279"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001267"/></connection><connection><identifier v="b"/><connRef v="1000001274"/></connection></connections></paramNode><paramNode><uid v="1000001280"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001263"/></connection><connection><identifier v="b"/><connRef v="1000001275"/></connection></connections></paramNode><paramNode><uid v="1000001281"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001262"/></connection><connection><identifier v="b"/><connRef v="1000001276"/></connection></connections></paramNode><paramNode><uid v="1000001282"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001256"/></connection><connection><identifier v="componentslast"/><connRef v="1000001264"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="Random_Luminosity"/><uid v="1000001302"/><attributes><category v=""/><description v="Evaluates the Random_Luminosity function graph. Result type: Float3. Inputs: RGB, Luminosity_Randomness."/><author v=""/><tags v="Color"/></attributes><paraminputs><paraminput><identifier v="RGB"/><uid v="1000001303"/><attributes><label v="RGB"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="0 0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="Luminosity_Randomness"/><uid v="1000001304"/><attributes><label v="Luminosity_Randomness"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000001301"/><paramNodes><paramNode><uid v="1000001286"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001287"/></connection><connection><identifier v="b"/><connRef v="1000001295"/></connection></connections></paramNode><paramNode><uid v="1000001287"/><function v="rand"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001298"/></connection></connections></paramNode><paramNode><uid v="1000001288"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001290"/></connection><connection><identifier v="componentslast"/><connRef v="1000001291"/></connection></connections></paramNode><paramNode><uid v="1000001289"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001297"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001290"/><function v="add"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001296"/></connection><connection><identifier v="b"/><connRef v="1000001299"/></connection></connections></paramNode><paramNode><uid v="1000001291"/><function v="add"/><type v="256"/><GUILayout><gpos v="1464 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001294"/></connection><connection><identifier v="b"/><connRef v="1000001299"/></connection></connections></paramNode><paramNode><uid v="1000001292"/><function v="add"/><type v="256"/><GUILayout><gpos v="1464 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001289"/></connection><connection><identifier v="b"/><connRef v="1000001299"/></connection></connections></paramNode><paramNode><uid v="1000001293"/><function v="sub"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001286"/></connection><connection><identifier v="b"/><connRef v="1000001298"/></connection></connections></paramNode><paramNode><uid v="1000001294"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001297"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001295"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001296"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 544 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001297"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001297"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="RGB"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001298"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001299"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001293"/></connection><connection><identifier v="b"/><connRef v="1000001300"/></connection></connections></paramNode><paramNode><uid v="1000001300"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="Luminosity_Randomness"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001301"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001288"/></connection><connection><identifier v="componentslast"/><connRef v="1000001292"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="RGBtoHSV"/><uid v="1000001311"/><attributes><category v=""/><description v="Evaluates the RGBtoHSV function graph. Result type: Float3. Inputs: rgb."/><author v=""/><tags v="Color"/></attributes><paraminputs><paraminput><identifier v="rgb"/><uid v="1000001312"/><attributes><label v="RGB"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000001306"/><paramNodes><paramNode><uid v="1000001305"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001307"/></connection><connection><identifier v="componentslast"/><connRef v="1000001308"/></connection></connections></paramNode><paramNode><uid v="1000001306"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001305"/></connection><connection><identifier v="componentslast"/><connRef v="1000001309"/></connection></connections></paramNode><paramNode><uid v="1000001307"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="rgb"/><connRef v="1000001310"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_hue_hexagonal"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="rgb"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001308"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="rgb"/><connRef v="1000001310"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_saturation_HSV"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="rgb"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001309"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="rgb"/><connRef v="1000001310"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_lightness_hexcone"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="rgb"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001310"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="rgb"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="RGBtoHSI"/><uid v="1000001319"/><attributes><category v=""/><description v="Evaluates the RGBtoHSI function graph. Result type: Float3. Inputs: rgb."/><author v=""/><tags v="Color"/></attributes><paraminputs><paraminput><identifier v="rgb"/><uid v="1000001320"/><attributes><label v="RGB"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000001318"/><paramNodes><paramNode><uid v="1000001313"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="rgb"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001314"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="rgb"/><connRef v="1000001313"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_saturation_HSI"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="rgb"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001315"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="rgb"/><connRef v="1000001313"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_hue_2_polar"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="rgb"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001316"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="rgb"/><connRef v="1000001313"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_lightness_average"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="rgb"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001317"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001315"/></connection><connection><identifier v="componentslast"/><connRef v="1000001314"/></connection></connections></paramNode><paramNode><uid v="1000001318"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001317"/></connection><connection><identifier v="componentslast"/><connRef v="1000001316"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="RGBtoHCL"/><uid v="1000001327"/><attributes><category v=""/><description v="Evaluates the RGBtoHCL function graph. Result type: Float3. Inputs: rgb."/><author v=""/><tags v="Color"/></attributes><paraminputs><paraminput><identifier v="rgb"/><uid v="1000001328"/><attributes><label v="RGB"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000001322"/><paramNodes><paramNode><uid v="1000001321"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001324"/></connection><connection><identifier v="componentslast"/><connRef v="1000001325"/></connection></connections></paramNode><paramNode><uid v="1000001322"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001321"/></connection><connection><identifier v="componentslast"/><connRef v="1000001326"/></connection></connections></paramNode><paramNode><uid v="1000001323"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="rgb"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001324"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="rgb"/><connRef v="1000001323"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_hue_hexagonal"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="rgb"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001325"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="rgb"/><connRef v="1000001323"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_chroma_hexagonal"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="rgb"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001326"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="rgb"/><connRef v="1000001323"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_lightness_luma_rec601"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="rgb"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="RGB_lightness_average"/><uid v="1000001337"/><attributes><category v=""/><description v="Evaluates the RGB_lightness_average function graph. Result type: Float. Inputs: rgb."/><author v=""/><tags v="Color"/></attributes><paraminputs><paraminput><identifier v="rgb"/><uid v="1000001338"/><attributes><label v="RGB"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001335"/><paramNodes><paramNode><uid v="1000001329"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="rgb"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001330"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001329"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001331"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001329"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001332"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001329"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001333"/><function v="add"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001330"/></connection><connection><identifier v="b"/><connRef v="1000001331"/></connection></connections></paramNode><paramNode><uid v="1000001334"/><function v="add"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001333"/></connection><connection><identifier v="b"/><connRef v="1000001332"/></connection></connections></paramNode><paramNode><uid v="1000001335"/><function v="div"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001334"/></connection><connection><identifier v="b"/><connRef v="1000001336"/></connection></connections></paramNode><paramNode><uid v="1000001336"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="3"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="RGB_lightness_hexcone"/><uid v="1000001345"/><attributes><category v=""/><description v="Evaluates the RGB_lightness_hexcone function graph. Result type: Float. Inputs: rgb."/><author v=""/><tags v="Color"/></attributes><paraminputs><paraminput><identifier v="rgb"/><uid v="1000001346"/><attributes><label v="RGB"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001344"/><paramNodes><paramNode><uid v="1000001339"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001342"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001340"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001342"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001341"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001342"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001342"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="rgb"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001343"/><function v="max"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001341"/></connection><connection><identifier v="b"/><connRef v="1000001340"/></connection></connections></paramNode><paramNode><uid v="1000001344"/><function v="max"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001343"/></connection><connection><identifier v="b"/><connRef v="1000001339"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="RGB_lightness_bihexcone"/><uid v="1000001358"/><attributes><category v=""/><description v="Evaluates the RGB_lightness_bihexcone function graph. Result type: Float. Inputs: rgb."/><author v=""/><tags v="Color"/></attributes><paraminputs><paraminput><identifier v="rgb"/><uid v="1000001359"/><attributes><label v="RGB"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001356"/><paramNodes><paramNode><uid v="1000001347"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="rgb"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001348"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001347"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001349"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001347"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001350"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001347"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001351"/><function v="min"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001349"/></connection><connection><identifier v="b"/><connRef v="1000001350"/></connection></connections></paramNode><paramNode><uid v="1000001352"/><function v="min"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001351"/></connection><connection><identifier v="b"/><connRef v="1000001348"/></connection></connections></paramNode><paramNode><uid v="1000001353"/><function v="max"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001349"/></connection><connection><identifier v="b"/><connRef v="1000001350"/></connection></connections></paramNode><paramNode><uid v="1000001354"/><function v="max"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001353"/></connection><connection><identifier v="b"/><connRef v="1000001348"/></connection></connections></paramNode><paramNode><uid v="1000001355"/><function v="add"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001354"/></connection><connection><identifier v="b"/><connRef v="1000001352"/></connection></connections></paramNode><paramNode><uid v="1000001356"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001355"/></connection><connection><identifier v="b"/><connRef v="1000001357"/></connection></connections></paramNode><paramNode><uid v="1000001357"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="RGB_lightness_luma_rec601"/><uid v="1000001372"/><attributes><category v=""/><description v="Evaluates the RGB_lightness_luma_rec601 function graph. Result type: Float. Inputs: rgb."/><author v=""/><tags v="Color"/></attributes><paraminputs><paraminput><identifier v="rgb"/><uid v="1000001373"/><attributes><label v="RGB"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001368"/><paramNodes><paramNode><uid v="1000001360"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001365"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001361"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.587"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001362"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.299"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001363"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001362"/></connection><connection><identifier v="b"/><connRef v="1000001360"/></connection></connections></paramNode><paramNode><uid v="1000001364"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001361"/></connection><connection><identifier v="b"/><connRef v="1000001369"/></connection></connections></paramNode><paramNode><uid v="1000001365"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="rgb"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001366"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.114"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001367"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001366"/></connection><connection><identifier v="b"/><connRef v="1000001370"/></connection></connections></paramNode><paramNode><uid v="1000001368"/><function v="add"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001371"/></connection><connection><identifier v="b"/><connRef v="1000001367"/></connection></connections></paramNode><paramNode><uid v="1000001369"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001365"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001370"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001365"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001371"/><function v="add"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001363"/></connection><connection><identifier v="b"/><connRef v="1000001364"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="RGB_lightness_luma_rec709"/><uid v="1000001386"/><attributes><category v=""/><description v="Evaluates the RGB_lightness_luma_rec709 function graph. Result type: Float. Inputs: rgb."/><author v=""/><tags v="Color"/></attributes><paraminputs><paraminput><identifier v="rgb"/><uid v="1000001387"/><attributes><label v="RGB"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001374"/><paramNodes><paramNode><uid v="1000001374"/><function v="add"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001382"/></connection><connection><identifier v="b"/><connRef v="1000001380"/></connection></connections></paramNode><paramNode><uid v="1000001375"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001377"/></connection><connection><identifier v="b"/><connRef v="1000001376"/></connection></connections></paramNode><paramNode><uid v="1000001376"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001385"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001377"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.2126"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001378"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.7152"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001379"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001378"/></connection><connection><identifier v="b"/><connRef v="1000001381"/></connection></connections></paramNode><paramNode><uid v="1000001380"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001384"/></connection><connection><identifier v="b"/><connRef v="1000001383"/></connection></connections></paramNode><paramNode><uid v="1000001381"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001385"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001382"/><function v="add"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001375"/></connection><connection><identifier v="b"/><connRef v="1000001379"/></connection></connections></paramNode><paramNode><uid v="1000001383"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001385"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001384"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.0722"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001385"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="rgb"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="RGB_chroma_hexagonal"/><uid v="1000001397"/><attributes><category v=""/><description v="Evaluates the RGB_chroma_hexagonal function graph. Result type: Float. Inputs: rgb."/><author v=""/><tags v="Color"/></attributes><paraminputs><paraminput><identifier v="rgb"/><uid v="1000001398"/><attributes><label v="RGB"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001396"/><paramNodes><paramNode><uid v="1000001388"/><function v="min"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001393"/></connection><connection><identifier v="b"/><connRef v="1000001389"/></connection></connections></paramNode><paramNode><uid v="1000001389"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001391"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001390"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001391"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001391"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="rgb"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001392"/><function v="max"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001395"/></connection><connection><identifier v="b"/><connRef v="1000001390"/></connection></connections></paramNode><paramNode><uid v="1000001393"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001391"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001394"/><function v="min"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001388"/></connection><connection><identifier v="b"/><connRef v="1000001390"/></connection></connections></paramNode><paramNode><uid v="1000001395"/><function v="max"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001393"/></connection><connection><identifier v="b"/><connRef v="1000001389"/></connection></connections></paramNode><paramNode><uid v="1000001396"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001392"/></connection><connection><identifier v="b"/><connRef v="1000001394"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="RGB_chroma_2_polar"/><uid v="1000001419"/><attributes><category v=""/><description v="Evaluates the RGB_chroma_2_polar function graph. Result type: Float. Inputs: rgb."/><author v=""/><tags v="Color"/></attributes><paraminputs><paraminput><identifier v="rgb"/><uid v="1000001420"/><attributes><label v="RGB"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001418"/><paramNodes><paramNode><uid v="1000001399"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001400"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001400"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="rgb"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001401"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001400"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001402"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001400"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001403"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001404"/></connection><connection><identifier v="b"/><connRef v="1000001401"/></connection></connections></paramNode><paramNode><uid v="1000001404"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001405"/><function v="sub"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001403"/></connection><connection><identifier v="b"/><connRef v="1000001399"/></connection></connections></paramNode><paramNode><uid v="1000001406"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001405"/></connection><connection><identifier v="b"/><connRef v="1000001402"/></connection></connections></paramNode><paramNode><uid v="1000001407"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001406"/></connection><connection><identifier v="b"/><connRef v="1000001408"/></connection></connections></paramNode><paramNode><uid v="1000001408"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001409"/><function v="sqrt"/><type v="256"/><GUILayout><gpos v="344 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001410"/></connection></connections></paramNode><paramNode><uid v="1000001410"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001411"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001409"/></connection><connection><identifier v="b"/><connRef v="1000001412"/></connection></connections></paramNode><paramNode><uid v="1000001412"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001413"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001399"/></connection><connection><identifier v="b"/><connRef v="1000001402"/></connection></connections></paramNode><paramNode><uid v="1000001414"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001413"/></connection><connection><identifier v="b"/><connRef v="1000001411"/></connection></connections></paramNode><paramNode><uid v="1000001415"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001407"/></connection><connection><identifier v="b"/><connRef v="1000001407"/></connection></connections></paramNode><paramNode><uid v="1000001416"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001414"/></connection><connection><identifier v="b"/><connRef v="1000001414"/></connection></connections></paramNode><paramNode><uid v="1000001417"/><function v="add"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001415"/></connection><connection><identifier v="b"/><connRef v="1000001416"/></connection></connections></paramNode><paramNode><uid v="1000001418"/><function v="sqrt"/><type v="256"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001417"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="RGB_hue_hexagonal"/><uid v="1000001457"/><attributes><category v=""/><description v="Evaluates the RGB_hue_hexagonal function graph. Result type: Float. Inputs: rgb."/><author v=""/><tags v="Color"/></attributes><paraminputs><paraminput><identifier v="rgb"/><uid v="1000001458"/><attributes><label v="RGB"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001451"/><paramNodes><paramNode><uid v="1000001421"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="rgb"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001422"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001421"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001423"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001428"/></connection><connection><identifier v="b"/><connRef v="1000001429"/></connection></connections></paramNode><paramNode><uid v="1000001424"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001421"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001425"/><function v="min"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001422"/></connection><connection><identifier v="b"/><connRef v="1000001426"/></connection></connections></paramNode><paramNode><uid v="1000001426"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001421"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001427"/><function v="max"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001422"/></connection><connection><identifier v="b"/><connRef v="1000001426"/></connection></connections></paramNode><paramNode><uid v="1000001428"/><function v="max"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001427"/></connection><connection><identifier v="b"/><connRef v="1000001424"/></connection></connections></paramNode><paramNode><uid v="1000001429"/><function v="min"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001425"/></connection><connection><identifier v="b"/><connRef v="1000001424"/></connection></connections></paramNode><paramNode><uid v="1000001430"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001426"/></connection><connection><identifier v="b"/><connRef v="1000001424"/></connection></connections></paramNode><paramNode><uid v="1000001431"/><function v="div"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001430"/></connection><connection><identifier v="b"/><connRef v="1000001423"/></connection></connections></paramNode><paramNode><uid v="1000001432"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001424"/></connection><connection><identifier v="b"/><connRef v="1000001422"/></connection></connections></paramNode><paramNode><uid v="1000001433"/><function v="div"/><type v="256"/><GUILayout><gpos v="1464 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001432"/></connection><connection><identifier v="b"/><connRef v="1000001423"/></connection></connections></paramNode><paramNode><uid v="1000001434"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 704 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001422"/></connection><connection><identifier v="b"/><connRef v="1000001426"/></connection></connections></paramNode><paramNode><uid v="1000001435"/><function v="div"/><type v="256"/><GUILayout><gpos v="1464 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001434"/></connection><connection><identifier v="b"/><connRef v="1000001423"/></connection></connections></paramNode><paramNode><uid v="1000001436"/><function v="mod"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001431"/></connection><connection><identifier v="b"/><connRef v="1000001437"/></connection></connections></paramNode><paramNode><uid v="1000001437"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="6"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001438"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001439"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001440"/><function v="eq"/><type v="4"/><GUILayout><gpos v="1464 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001441"/></connection><connection><identifier v="b"/><connRef v="1000001423"/></connection></connections></paramNode><paramNode><uid v="1000001441"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001442"/><function v="eq"/><type v="4"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001422"/></connection><connection><identifier v="b"/><connRef v="1000001428"/></connection></connections></paramNode><paramNode><uid v="1000001443"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="2584 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001442"/></connection><connection><identifier v="ifpath"/><connRef v="1000001436"/></connection><connection><identifier v="elsepath"/><connRef v="1000001446"/></connection></connections></paramNode><paramNode><uid v="1000001444"/><function v="eq"/><type v="4"/><GUILayout><gpos v="1184 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001426"/></connection><connection><identifier v="b"/><connRef v="1000001428"/></connection></connections></paramNode><paramNode><uid v="1000001445"/><function v="eq"/><type v="4"/><GUILayout><gpos v="1184 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001424"/></connection><connection><identifier v="b"/><connRef v="1000001428"/></connection></connections></paramNode><paramNode><uid v="1000001446"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001444"/></connection><connection><identifier v="ifpath"/><connRef v="1000001455"/></connection><connection><identifier v="elsepath"/><connRef v="1000001447"/></connection></connections></paramNode><paramNode><uid v="1000001447"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001445"/></connection><connection><identifier v="ifpath"/><connRef v="1000001456"/></connection><connection><identifier v="elsepath"/><connRef v="1000001448"/></connection></connections></paramNode><paramNode><uid v="1000001448"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001449"/><function v="mul"/><type v="256"/><GUILayout><gpos v="3144 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001453"/></connection><connection><identifier v="b"/><connRef v="1000001450"/></connection></connections></paramNode><paramNode><uid v="1000001450"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="60"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001451"/><function v="div"/><type v="256"/><GUILayout><gpos v="3424 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001449"/></connection><connection><identifier v="b"/><connRef v="1000001452"/></connection></connections></paramNode><paramNode><uid v="1000001452"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="360"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001453"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="2864 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001440"/></connection><connection><identifier v="ifpath"/><connRef v="1000001454"/></connection><connection><identifier v="elsepath"/><connRef v="1000001443"/></connection></connections></paramNode><paramNode><uid v="1000001454"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001455"/><function v="add"/><type v="256"/><GUILayout><gpos v="1744 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001433"/></connection><connection><identifier v="b"/><connRef v="1000001438"/></connection></connections></paramNode><paramNode><uid v="1000001456"/><function v="add"/><type v="256"/><GUILayout><gpos v="1744 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001435"/></connection><connection><identifier v="b"/><connRef v="1000001439"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="RGB_hue_2_polar"/><uid v="1000001487"/><attributes><category v=""/><description v="Evaluates the RGB_hue_2_polar function graph. Result type: Float. Inputs: rgb."/><author v=""/><tags v="Color"/></attributes><paraminputs><paraminput><identifier v="rgb"/><uid v="1000001488"/><attributes><label v="RGB"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001483"/><paramNodes><paramNode><uid v="1000001459"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001460"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001460"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="rgb"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001461"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001460"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001462"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001460"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001463"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001464"/></connection><connection><identifier v="b"/><connRef v="1000001461"/></connection></connections></paramNode><paramNode><uid v="1000001464"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001465"/><function v="sub"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001463"/></connection><connection><identifier v="b"/><connRef v="1000001459"/></connection></connections></paramNode><paramNode><uid v="1000001466"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001465"/></connection><connection><identifier v="b"/><connRef v="1000001462"/></connection></connections></paramNode><paramNode><uid v="1000001467"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001466"/></connection><connection><identifier v="b"/><connRef v="1000001468"/></connection></connections></paramNode><paramNode><uid v="1000001468"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001469"/><function v="sqrt"/><type v="256"/><GUILayout><gpos v="344 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001470"/></connection></connections></paramNode><paramNode><uid v="1000001470"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001471"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001469"/></connection><connection><identifier v="b"/><connRef v="1000001472"/></connection></connections></paramNode><paramNode><uid v="1000001472"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001473"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001459"/></connection><connection><identifier v="b"/><connRef v="1000001462"/></connection></connections></paramNode><paramNode><uid v="1000001474"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001473"/></connection><connection><identifier v="b"/><connRef v="1000001471"/></connection></connections></paramNode><paramNode><uid v="1000001475"/><function v="atan2"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001476"/></connection></connections></paramNode><paramNode><uid v="1000001476"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001467"/></connection><connection><identifier v="componentslast"/><connRef v="1000001474"/></connection></connections></paramNode><paramNode><uid v="1000001477"/><function v="div"/><type v="256"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001475"/></connection><connection><identifier v="b"/><connRef v="1000001478"/></connection></connections></paramNode><paramNode><uid v="1000001478"/><function v="instance"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Pi"/></constantValue></funcData></funcDatas><materialcraftInterface></materialcraftInterface></paramNode><paramNode><uid v="1000001479"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2584 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001477"/></connection><connection><identifier v="b"/><connRef v="1000001480"/></connection></connections></paramNode><paramNode><uid v="1000001480"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001481"/><function v="add"/><type v="256"/><GUILayout><gpos v="2864 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001479"/></connection><connection><identifier v="b"/><connRef v="1000001482"/></connection></connections></paramNode><paramNode><uid v="1000001482"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001483"/><function v="mod"/><type v="256"/><GUILayout><gpos v="3424 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001485"/></connection><connection><identifier v="b"/><connRef v="1000001484"/></connection></connections></paramNode><paramNode><uid v="1000001484"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001485"/><function v="add"/><type v="256"/><GUILayout><gpos v="3144 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001481"/></connection><connection><identifier v="b"/><connRef v="1000001486"/></connection></connections></paramNode><paramNode><uid v="1000001486"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="RGB_saturation_HSV"/><uid v="1000001497"/><attributes><category v=""/><description v="Evaluates the RGB_saturation_HSV function graph. Result type: Float. Inputs: rgb."/><author v=""/><tags v="Color"/></attributes><paraminputs><paraminput><identifier v="rgb"/><uid v="1000001498"/><attributes><label v="RGB"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001493"/><paramNodes><paramNode><uid v="1000001489"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="rgb"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001490"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="rgb"/><connRef v="1000001489"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_chroma_hexagonal"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="rgb"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001491"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="rgb"/><connRef v="1000001489"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_lightness_hexcone"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="rgb"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001492"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001490"/></connection><connection><identifier v="b"/><connRef v="1000001491"/></connection></connections></paramNode><paramNode><uid v="1000001493"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001494"/></connection><connection><identifier v="ifpath"/><connRef v="1000001496"/></connection><connection><identifier v="elsepath"/><connRef v="1000001492"/></connection></connections></paramNode><paramNode><uid v="1000001494"/><function v="eq"/><type v="4"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001491"/></connection><connection><identifier v="b"/><connRef v="1000001495"/></connection></connections></paramNode><paramNode><uid v="1000001495"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001496"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="RGB_saturation_HSL"/><uid v="1000001514"/><attributes><category v=""/><description v="Evaluates the RGB_saturation_HSL function graph. Result type: Float. Inputs: rgb."/><author v=""/><tags v="Color"/></attributes><paraminputs><paraminput><identifier v="rgb"/><uid v="1000001515"/><attributes><label v="RGB"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001510"/><paramNodes><paramNode><uid v="1000001499"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="rgb"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001500"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="rgb"/><connRef v="1000001499"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_chroma_hexagonal"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="rgb"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001501"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="rgb"/><connRef v="1000001499"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_lightness_bihexcone"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="rgb"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001502"/><function v="div"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001500"/></connection><connection><identifier v="b"/><connRef v="1000001509"/></connection></connections></paramNode><paramNode><uid v="1000001503"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001501"/></connection><connection><identifier v="b"/><connRef v="1000001504"/></connection></connections></paramNode><paramNode><uid v="1000001504"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001505"/><function v="sub"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001503"/></connection><connection><identifier v="b"/><connRef v="1000001506"/></connection></connections></paramNode><paramNode><uid v="1000001506"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001507"/><function v="abs"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001505"/></connection></connections></paramNode><paramNode><uid v="1000001508"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001509"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001508"/></connection><connection><identifier v="b"/><connRef v="1000001507"/></connection></connections></paramNode><paramNode><uid v="1000001510"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001511"/></connection><connection><identifier v="ifpath"/><connRef v="1000001513"/></connection><connection><identifier v="elsepath"/><connRef v="1000001502"/></connection></connections></paramNode><paramNode><uid v="1000001511"/><function v="eq"/><type v="4"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001512"/></connection><connection><identifier v="b"/><connRef v="1000001501"/></connection></connections></paramNode><paramNode><uid v="1000001512"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001513"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="RGB_saturation_HSI"/><uid v="1000001530"/><attributes><category v=""/><description v="Evaluates the RGB_saturation_HSI function graph. Result type: Float. Inputs: rgb."/><author v=""/><tags v="Color"/></attributes><paraminputs><paraminput><identifier v="rgb"/><uid v="1000001531"/><attributes><label v="RGB"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001526"/><paramNodes><paramNode><uid v="1000001516"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="rgb"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001517"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="rgb"/><connRef v="1000001516"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_lightness_average"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="rgb"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001518"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001516"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001519"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001516"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001520"/><function v="min"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001522"/></connection><connection><identifier v="b"/><connRef v="1000001518"/></connection></connections></paramNode><paramNode><uid v="1000001521"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 544 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001516"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001522"/><function v="min"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001521"/></connection><connection><identifier v="b"/><connRef v="1000001519"/></connection></connections></paramNode><paramNode><uid v="1000001523"/><function v="div"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001520"/></connection><connection><identifier v="b"/><connRef v="1000001517"/></connection></connections></paramNode><paramNode><uid v="1000001524"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001525"/></connection><connection><identifier v="b"/><connRef v="1000001523"/></connection></connections></paramNode><paramNode><uid v="1000001525"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001526"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001527"/></connection><connection><identifier v="ifpath"/><connRef v="1000001529"/></connection><connection><identifier v="elsepath"/><connRef v="1000001524"/></connection></connections></paramNode><paramNode><uid v="1000001527"/><function v="eq"/><type v="4"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001528"/></connection><connection><identifier v="b"/><connRef v="1000001517"/></connection></connections></paramNode><paramNode><uid v="1000001528"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001529"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="HSItoRGB"/><uid v="1000001603"/><attributes><category v=""/><description v="Evaluates the HSItoRGB function graph. Result type: Float3. Inputs: hsi."/><author v=""/><tags v="Color"/></attributes><paraminputs><paraminput><identifier v="hsi"/><uid v="1000001604"/><attributes><label v="HSI"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000001592"/><paramNodes><paramNode><uid v="1000001532"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="hsi"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001533"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001532"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001534"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001532"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001535"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001532"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001536"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2584 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001538"/></connection><connection><identifier v="b"/><connRef v="1000001600"/></connection></connections></paramNode><paramNode><uid v="1000001537"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001538"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001537"/></connection><connection><identifier v="b"/><connRef v="1000001539"/></connection></connections></paramNode><paramNode><uid v="1000001539"/><function v="abs"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001544"/></connection></connections></paramNode><paramNode><uid v="1000001540"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001541"/></connection><connection><identifier v="b"/><connRef v="1000001533"/></connection></connections></paramNode><paramNode><uid v="1000001541"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="6"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001542"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001540"/></connection><connection><identifier v="b"/><connRef v="1000001543"/></connection></connections></paramNode><paramNode><uid v="1000001543"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001544"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001542"/></connection><connection><identifier v="b"/><connRef v="1000001545"/></connection></connections></paramNode><paramNode><uid v="1000001545"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001546"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="4544 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001548"/></connection><connection><identifier v="ifpath"/><connRef v="1000001573"/></connection><connection><identifier v="elsepath"/><connRef v="1000001585"/></connection></connections></paramNode><paramNode><uid v="1000001547"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001549"/></connection><connection><identifier v="b"/><connRef v="1000001540"/></connection></connections></paramNode><paramNode><uid v="1000001548"/><function v="and"/><type v="4"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001547"/></connection><connection><identifier v="b"/><connRef v="1000001566"/></connection></connections></paramNode><paramNode><uid v="1000001549"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001550"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001551"/><function v="and"/><type v="4"/><GUILayout><gpos v="1184 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001553"/></connection><connection><identifier v="b"/><connRef v="1000001567"/></connection></connections></paramNode><paramNode><uid v="1000001552"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001553"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001550"/></connection><connection><identifier v="b"/><connRef v="1000001540"/></connection></connections></paramNode><paramNode><uid v="1000001554"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001552"/></connection><connection><identifier v="b"/><connRef v="1000001540"/></connection></connections></paramNode><paramNode><uid v="1000001555"/><function v="and"/><type v="4"/><GUILayout><gpos v="1184 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001554"/></connection><connection><identifier v="b"/><connRef v="1000001568"/></connection></connections></paramNode><paramNode><uid v="1000001556"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001557"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 704 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001556"/></connection><connection><identifier v="b"/><connRef v="1000001540"/></connection></connections></paramNode><paramNode><uid v="1000001558"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001559"/><function v="and"/><type v="4"/><GUILayout><gpos v="1184 704 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001557"/></connection><connection><identifier v="b"/><connRef v="1000001569"/></connection></connections></paramNode><paramNode><uid v="1000001560"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 864 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001558"/></connection><connection><identifier v="b"/><connRef v="1000001540"/></connection></connections></paramNode><paramNode><uid v="1000001561"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1664 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001562"/><function v="and"/><type v="4"/><GUILayout><gpos v="1184 864 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001560"/></connection><connection><identifier v="b"/><connRef v="1000001570"/></connection></connections></paramNode><paramNode><uid v="1000001563"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 1024 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001561"/></connection><connection><identifier v="b"/><connRef v="1000001540"/></connection></connections></paramNode><paramNode><uid v="1000001564"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1824 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="6"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001565"/><function v="and"/><type v="4"/><GUILayout><gpos v="1184 1024 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001563"/></connection><connection><identifier v="b"/><connRef v="1000001571"/></connection></connections></paramNode><paramNode><uid v="1000001566"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 1184 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001540"/></connection><connection><identifier v="b"/><connRef v="1000001550"/></connection></connections></paramNode><paramNode><uid v="1000001567"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 1344 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001540"/></connection><connection><identifier v="b"/><connRef v="1000001552"/></connection></connections></paramNode><paramNode><uid v="1000001568"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 1504 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001540"/></connection><connection><identifier v="b"/><connRef v="1000001556"/></connection></connections></paramNode><paramNode><uid v="1000001569"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 1664 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001540"/></connection><connection><identifier v="b"/><connRef v="1000001558"/></connection></connections></paramNode><paramNode><uid v="1000001570"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 1824 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001540"/></connection><connection><identifier v="b"/><connRef v="1000001561"/></connection></connections></paramNode><paramNode><uid v="1000001571"/><function v="lr"/><type v="4"/><GUILayout><gpos v="904 1984 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001540"/></connection><connection><identifier v="b"/><connRef v="1000001564"/></connection></connections></paramNode><paramNode><uid v="1000001572"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2864 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001600"/></connection><connection><identifier v="componentslast"/><connRef v="1000001536"/></connection></connections></paramNode><paramNode><uid v="1000001573"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="3144 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001572"/></connection><connection><identifier v="componentslast"/><connRef v="1000001574"/></connection></connections></paramNode><paramNode><uid v="1000001574"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1984 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001575"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2864 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001536"/></connection><connection><identifier v="componentslast"/><connRef v="1000001600"/></connection></connections></paramNode><paramNode><uid v="1000001576"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="3144 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001575"/></connection><connection><identifier v="componentslast"/><connRef v="1000001574"/></connection></connections></paramNode><paramNode><uid v="1000001577"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2584 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001574"/></connection><connection><identifier v="componentslast"/><connRef v="1000001600"/></connection></connections></paramNode><paramNode><uid v="1000001578"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="2864 384 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001577"/></connection><connection><identifier v="componentslast"/><connRef v="1000001536"/></connection></connections></paramNode><paramNode><uid v="1000001579"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="3144 384 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001580"/></connection><connection><identifier v="componentslast"/><connRef v="1000001600"/></connection></connections></paramNode><paramNode><uid v="1000001580"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2864 544 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001574"/></connection><connection><identifier v="componentslast"/><connRef v="1000001536"/></connection></connections></paramNode><paramNode><uid v="1000001581"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="3144 544 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001582"/></connection><connection><identifier v="componentslast"/><connRef v="1000001600"/></connection></connections></paramNode><paramNode><uid v="1000001582"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2864 704 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001536"/></connection><connection><identifier v="componentslast"/><connRef v="1000001574"/></connection></connections></paramNode><paramNode><uid v="1000001583"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="2864 864 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001584"/></connection><connection><identifier v="componentslast"/><connRef v="1000001536"/></connection></connections></paramNode><paramNode><uid v="1000001584"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2584 384 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001600"/></connection><connection><identifier v="componentslast"/><connRef v="1000001574"/></connection></connections></paramNode><paramNode><uid v="1000001585"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="4264 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001551"/></connection><connection><identifier v="ifpath"/><connRef v="1000001576"/></connection><connection><identifier v="elsepath"/><connRef v="1000001586"/></connection></connections></paramNode><paramNode><uid v="1000001586"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="3984 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001555"/></connection><connection><identifier v="ifpath"/><connRef v="1000001578"/></connection><connection><identifier v="elsepath"/><connRef v="1000001587"/></connection></connections></paramNode><paramNode><uid v="1000001587"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="3704 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001559"/></connection><connection><identifier v="ifpath"/><connRef v="1000001579"/></connection><connection><identifier v="elsepath"/><connRef v="1000001588"/></connection></connections></paramNode><paramNode><uid v="1000001588"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="3424 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001562"/></connection><connection><identifier v="ifpath"/><connRef v="1000001581"/></connection><connection><identifier v="elsepath"/><connRef v="1000001589"/></connection></connections></paramNode><paramNode><uid v="1000001589"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="3144 704 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001565"/></connection><connection><identifier v="ifpath"/><connRef v="1000001583"/></connection><connection><identifier v="elsepath"/><connRef v="1000001590"/></connection></connections></paramNode><paramNode><uid v="1000001590"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 2144 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0 0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001591"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001601"/></connection><connection><identifier v="b"/><connRef v="1000001534"/></connection></connections></paramNode><paramNode><uid v="1000001592"/><function v="add"/><type v="1024"/><GUILayout><gpos v="4824 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001594"/></connection><connection><identifier v="b"/><connRef v="1000001546"/></connection></connections></paramNode><paramNode><uid v="1000001593"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1184 1184 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001602"/></connection><connection><identifier v="componentslast"/><connRef v="1000001602"/></connection></connections></paramNode><paramNode><uid v="1000001594"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="1464 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001593"/></connection><connection><identifier v="componentslast"/><connRef v="1000001602"/></connection></connections></paramNode><paramNode><uid v="1000001595"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001535"/></connection><connection><identifier v="b"/><connRef v="1000001596"/></connection></connections></paramNode><paramNode><uid v="1000001596"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 2304 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001597"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 2144 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001534"/></connection><connection><identifier v="b"/><connRef v="1000001595"/></connection></connections></paramNode><paramNode><uid v="1000001598"/><function v="add"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001538"/></connection><connection><identifier v="b"/><connRef v="1000001599"/></connection></connections></paramNode><paramNode><uid v="1000001599"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 2464 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001600"/><function v="div"/><type v="256"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001597"/></connection><connection><identifier v="b"/><connRef v="1000001598"/></connection></connections></paramNode><paramNode><uid v="1000001601"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 2624 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001602"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 2304 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001591"/></connection><connection><identifier v="b"/><connRef v="1000001535"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="HSVtoRGB"/><uid v="1000001669"/><attributes><category v=""/><description v="Evaluates the HSVtoRGB function graph. Result type: Float3. Inputs: hsv."/><author v=""/><tags v="Color"/></attributes><paraminputs><paraminput><identifier v="hsv"/><uid v="1000001670"/><attributes><label v="HSV"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000001665"/><paramNodes><paramNode><uid v="1000001605"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="hsv"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001606"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001605"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001607"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001605"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001608"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001605"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001609"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001611"/></connection><connection><identifier v="b"/><connRef v="1000001668"/></connection></connections></paramNode><paramNode><uid v="1000001610"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001611"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001610"/></connection><connection><identifier v="b"/><connRef v="1000001612"/></connection></connections></paramNode><paramNode><uid v="1000001612"/><function v="abs"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001617"/></connection></connections></paramNode><paramNode><uid v="1000001613"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001614"/></connection><connection><identifier v="b"/><connRef v="1000001606"/></connection></connections></paramNode><paramNode><uid v="1000001614"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="6"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001615"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001613"/></connection><connection><identifier v="b"/><connRef v="1000001616"/></connection></connections></paramNode><paramNode><uid v="1000001616"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001617"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001615"/></connection><connection><identifier v="b"/><connRef v="1000001618"/></connection></connections></paramNode><paramNode><uid v="1000001618"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001619"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="3984 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001621"/></connection><connection><identifier v="ifpath"/><connRef v="1000001646"/></connection><connection><identifier v="elsepath"/><connRef v="1000001658"/></connection></connections></paramNode><paramNode><uid v="1000001620"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001622"/></connection><connection><identifier v="b"/><connRef v="1000001613"/></connection></connections></paramNode><paramNode><uid v="1000001621"/><function v="and"/><type v="4"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001620"/></connection><connection><identifier v="b"/><connRef v="1000001639"/></connection></connections></paramNode><paramNode><uid v="1000001622"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001623"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001624"/><function v="and"/><type v="4"/><GUILayout><gpos v="1184 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001626"/></connection><connection><identifier v="b"/><connRef v="1000001640"/></connection></connections></paramNode><paramNode><uid v="1000001625"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001626"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001623"/></connection><connection><identifier v="b"/><connRef v="1000001613"/></connection></connections></paramNode><paramNode><uid v="1000001627"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001625"/></connection><connection><identifier v="b"/><connRef v="1000001613"/></connection></connections></paramNode><paramNode><uid v="1000001628"/><function v="and"/><type v="4"/><GUILayout><gpos v="1184 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001627"/></connection><connection><identifier v="b"/><connRef v="1000001641"/></connection></connections></paramNode><paramNode><uid v="1000001629"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001630"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 704 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001629"/></connection><connection><identifier v="b"/><connRef v="1000001613"/></connection></connections></paramNode><paramNode><uid v="1000001631"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001632"/><function v="and"/><type v="4"/><GUILayout><gpos v="1184 704 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001630"/></connection><connection><identifier v="b"/><connRef v="1000001642"/></connection></connections></paramNode><paramNode><uid v="1000001633"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 864 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001631"/></connection><connection><identifier v="b"/><connRef v="1000001613"/></connection></connections></paramNode><paramNode><uid v="1000001634"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1664 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001635"/><function v="and"/><type v="4"/><GUILayout><gpos v="1184 864 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001633"/></connection><connection><identifier v="b"/><connRef v="1000001643"/></connection></connections></paramNode><paramNode><uid v="1000001636"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 1024 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001634"/></connection><connection><identifier v="b"/><connRef v="1000001613"/></connection></connections></paramNode><paramNode><uid v="1000001637"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1824 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="6"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001638"/><function v="and"/><type v="4"/><GUILayout><gpos v="1184 1024 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001636"/></connection><connection><identifier v="b"/><connRef v="1000001644"/></connection></connections></paramNode><paramNode><uid v="1000001639"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 1184 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001613"/></connection><connection><identifier v="b"/><connRef v="1000001623"/></connection></connections></paramNode><paramNode><uid v="1000001640"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 1344 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001613"/></connection><connection><identifier v="b"/><connRef v="1000001625"/></connection></connections></paramNode><paramNode><uid v="1000001641"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 1504 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001613"/></connection><connection><identifier v="b"/><connRef v="1000001629"/></connection></connections></paramNode><paramNode><uid v="1000001642"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 1664 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001613"/></connection><connection><identifier v="b"/><connRef v="1000001631"/></connection></connections></paramNode><paramNode><uid v="1000001643"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 1824 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001613"/></connection><connection><identifier v="b"/><connRef v="1000001634"/></connection></connections></paramNode><paramNode><uid v="1000001644"/><function v="lr"/><type v="4"/><GUILayout><gpos v="904 1984 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001613"/></connection><connection><identifier v="b"/><connRef v="1000001637"/></connection></connections></paramNode><paramNode><uid v="1000001645"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001668"/></connection><connection><identifier v="componentslast"/><connRef v="1000001609"/></connection></connections></paramNode><paramNode><uid v="1000001646"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="2584 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001645"/></connection><connection><identifier v="componentslast"/><connRef v="1000001647"/></connection></connections></paramNode><paramNode><uid v="1000001647"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1984 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001648"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2304 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001609"/></connection><connection><identifier v="componentslast"/><connRef v="1000001668"/></connection></connections></paramNode><paramNode><uid v="1000001649"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="2584 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001648"/></connection><connection><identifier v="componentslast"/><connRef v="1000001647"/></connection></connections></paramNode><paramNode><uid v="1000001650"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="904 2144 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001647"/></connection><connection><identifier v="componentslast"/><connRef v="1000001668"/></connection></connections></paramNode><paramNode><uid v="1000001651"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="2304 384 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001650"/></connection><connection><identifier v="componentslast"/><connRef v="1000001609"/></connection></connections></paramNode><paramNode><uid v="1000001652"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="2584 384 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001653"/></connection><connection><identifier v="componentslast"/><connRef v="1000001668"/></connection></connections></paramNode><paramNode><uid v="1000001653"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2304 544 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001647"/></connection><connection><identifier v="componentslast"/><connRef v="1000001609"/></connection></connections></paramNode><paramNode><uid v="1000001654"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="2584 544 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001655"/></connection><connection><identifier v="componentslast"/><connRef v="1000001668"/></connection></connections></paramNode><paramNode><uid v="1000001655"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2304 704 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001609"/></connection><connection><identifier v="componentslast"/><connRef v="1000001647"/></connection></connections></paramNode><paramNode><uid v="1000001656"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="2304 864 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001657"/></connection><connection><identifier v="componentslast"/><connRef v="1000001609"/></connection></connections></paramNode><paramNode><uid v="1000001657"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="904 2304 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001668"/></connection><connection><identifier v="componentslast"/><connRef v="1000001647"/></connection></connections></paramNode><paramNode><uid v="1000001658"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="3704 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001624"/></connection><connection><identifier v="ifpath"/><connRef v="1000001649"/></connection><connection><identifier v="elsepath"/><connRef v="1000001659"/></connection></connections></paramNode><paramNode><uid v="1000001659"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="3424 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001628"/></connection><connection><identifier v="ifpath"/><connRef v="1000001651"/></connection><connection><identifier v="elsepath"/><connRef v="1000001660"/></connection></connections></paramNode><paramNode><uid v="1000001660"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="3144 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001632"/></connection><connection><identifier v="ifpath"/><connRef v="1000001652"/></connection><connection><identifier v="elsepath"/><connRef v="1000001661"/></connection></connections></paramNode><paramNode><uid v="1000001661"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="2864 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001635"/></connection><connection><identifier v="ifpath"/><connRef v="1000001654"/></connection><connection><identifier v="elsepath"/><connRef v="1000001662"/></connection></connections></paramNode><paramNode><uid v="1000001662"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="2584 704 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001638"/></connection><connection><identifier v="ifpath"/><connRef v="1000001656"/></connection><connection><identifier v="elsepath"/><connRef v="1000001663"/></connection></connections></paramNode><paramNode><uid v="1000001663"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 2144 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0 0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001664"/><function v="sub"/><type v="256"/><GUILayout><gpos v="904 2464 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001608"/></connection><connection><identifier v="b"/><connRef v="1000001668"/></connection></connections></paramNode><paramNode><uid v="1000001665"/><function v="add"/><type v="1024"/><GUILayout><gpos v="4264 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001667"/></connection><connection><identifier v="b"/><connRef v="1000001619"/></connection></connections></paramNode><paramNode><uid v="1000001666"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1184 1184 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001664"/></connection><connection><identifier v="componentslast"/><connRef v="1000001664"/></connection></connections></paramNode><paramNode><uid v="1000001667"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="1464 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001666"/></connection><connection><identifier v="componentslast"/><connRef v="1000001664"/></connection></connections></paramNode><paramNode><uid v="1000001668"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001607"/></connection><connection><identifier v="b"/><connRef v="1000001608"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="HCLtoRGB"/><uid v="1000001735"/><attributes><category v=""/><description v="Evaluates the HCLtoRGB function graph. Result type: Float3. Inputs: hcl."/><author v=""/><tags v="Color"/></attributes><paraminputs><paraminput><identifier v="hcl"/><uid v="1000001736"/><attributes><label v="HCL"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000001732"/><paramNodes><paramNode><uid v="1000001671"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="hcl"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001672"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001671"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001673"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001671"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001674"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001671"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001675"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001677"/></connection><connection><identifier v="b"/><connRef v="1000001673"/></connection></connections></paramNode><paramNode><uid v="1000001676"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001677"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001676"/></connection><connection><identifier v="b"/><connRef v="1000001678"/></connection></connections></paramNode><paramNode><uid v="1000001678"/><function v="abs"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001683"/></connection></connections></paramNode><paramNode><uid v="1000001679"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001680"/></connection><connection><identifier v="b"/><connRef v="1000001672"/></connection></connections></paramNode><paramNode><uid v="1000001680"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="6"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001681"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001679"/></connection><connection><identifier v="b"/><connRef v="1000001682"/></connection></connections></paramNode><paramNode><uid v="1000001682"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001683"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001681"/></connection><connection><identifier v="b"/><connRef v="1000001684"/></connection></connections></paramNode><paramNode><uid v="1000001684"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001685"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="3984 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001687"/></connection><connection><identifier v="ifpath"/><connRef v="1000001712"/></connection><connection><identifier v="elsepath"/><connRef v="1000001724"/></connection></connections></paramNode><paramNode><uid v="1000001686"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001688"/></connection><connection><identifier v="b"/><connRef v="1000001679"/></connection></connections></paramNode><paramNode><uid v="1000001687"/><function v="and"/><type v="4"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001686"/></connection><connection><identifier v="b"/><connRef v="1000001705"/></connection></connections></paramNode><paramNode><uid v="1000001688"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001689"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001690"/><function v="and"/><type v="4"/><GUILayout><gpos v="1184 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001692"/></connection><connection><identifier v="b"/><connRef v="1000001706"/></connection></connections></paramNode><paramNode><uid v="1000001691"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001692"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001689"/></connection><connection><identifier v="b"/><connRef v="1000001679"/></connection></connections></paramNode><paramNode><uid v="1000001693"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001691"/></connection><connection><identifier v="b"/><connRef v="1000001679"/></connection></connections></paramNode><paramNode><uid v="1000001694"/><function v="and"/><type v="4"/><GUILayout><gpos v="1184 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001693"/></connection><connection><identifier v="b"/><connRef v="1000001707"/></connection></connections></paramNode><paramNode><uid v="1000001695"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001696"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 704 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001695"/></connection><connection><identifier v="b"/><connRef v="1000001679"/></connection></connections></paramNode><paramNode><uid v="1000001697"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001698"/><function v="and"/><type v="4"/><GUILayout><gpos v="1184 704 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001696"/></connection><connection><identifier v="b"/><connRef v="1000001708"/></connection></connections></paramNode><paramNode><uid v="1000001699"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 864 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001697"/></connection><connection><identifier v="b"/><connRef v="1000001679"/></connection></connections></paramNode><paramNode><uid v="1000001700"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1664 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001701"/><function v="and"/><type v="4"/><GUILayout><gpos v="1184 864 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001699"/></connection><connection><identifier v="b"/><connRef v="1000001709"/></connection></connections></paramNode><paramNode><uid v="1000001702"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 1024 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001700"/></connection><connection><identifier v="b"/><connRef v="1000001679"/></connection></connections></paramNode><paramNode><uid v="1000001703"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1824 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="6"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001704"/><function v="and"/><type v="4"/><GUILayout><gpos v="1184 1024 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001702"/></connection><connection><identifier v="b"/><connRef v="1000001710"/></connection></connections></paramNode><paramNode><uid v="1000001705"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 1184 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001679"/></connection><connection><identifier v="b"/><connRef v="1000001689"/></connection></connections></paramNode><paramNode><uid v="1000001706"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 1344 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001679"/></connection><connection><identifier v="b"/><connRef v="1000001691"/></connection></connections></paramNode><paramNode><uid v="1000001707"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 1504 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001679"/></connection><connection><identifier v="b"/><connRef v="1000001695"/></connection></connections></paramNode><paramNode><uid v="1000001708"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 1664 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001679"/></connection><connection><identifier v="b"/><connRef v="1000001697"/></connection></connections></paramNode><paramNode><uid v="1000001709"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="904 1824 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001679"/></connection><connection><identifier v="b"/><connRef v="1000001700"/></connection></connections></paramNode><paramNode><uid v="1000001710"/><function v="lr"/><type v="4"/><GUILayout><gpos v="904 1984 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001679"/></connection><connection><identifier v="b"/><connRef v="1000001703"/></connection></connections></paramNode><paramNode><uid v="1000001711"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001673"/></connection><connection><identifier v="componentslast"/><connRef v="1000001675"/></connection></connections></paramNode><paramNode><uid v="1000001712"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="2584 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001711"/></connection><connection><identifier v="componentslast"/><connRef v="1000001713"/></connection></connections></paramNode><paramNode><uid v="1000001713"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1984 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001714"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2304 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001675"/></connection><connection><identifier v="componentslast"/><connRef v="1000001673"/></connection></connections></paramNode><paramNode><uid v="1000001715"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="2584 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001714"/></connection><connection><identifier v="componentslast"/><connRef v="1000001713"/></connection></connections></paramNode><paramNode><uid v="1000001716"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001713"/></connection><connection><identifier v="componentslast"/><connRef v="1000001673"/></connection></connections></paramNode><paramNode><uid v="1000001717"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="2304 384 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001716"/></connection><connection><identifier v="componentslast"/><connRef v="1000001675"/></connection></connections></paramNode><paramNode><uid v="1000001718"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="2584 384 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001719"/></connection><connection><identifier v="componentslast"/><connRef v="1000001673"/></connection></connections></paramNode><paramNode><uid v="1000001719"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2304 544 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001713"/></connection><connection><identifier v="componentslast"/><connRef v="1000001675"/></connection></connections></paramNode><paramNode><uid v="1000001720"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="2584 544 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001721"/></connection><connection><identifier v="componentslast"/><connRef v="1000001673"/></connection></connections></paramNode><paramNode><uid v="1000001721"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2304 704 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001675"/></connection><connection><identifier v="componentslast"/><connRef v="1000001713"/></connection></connections></paramNode><paramNode><uid v="1000001722"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="2304 864 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001723"/></connection><connection><identifier v="componentslast"/><connRef v="1000001675"/></connection></connections></paramNode><paramNode><uid v="1000001723"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001673"/></connection><connection><identifier v="componentslast"/><connRef v="1000001713"/></connection></connections></paramNode><paramNode><uid v="1000001724"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="3704 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001690"/></connection><connection><identifier v="ifpath"/><connRef v="1000001715"/></connection><connection><identifier v="elsepath"/><connRef v="1000001725"/></connection></connections></paramNode><paramNode><uid v="1000001725"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="3424 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001694"/></connection><connection><identifier v="ifpath"/><connRef v="1000001717"/></connection><connection><identifier v="elsepath"/><connRef v="1000001726"/></connection></connections></paramNode><paramNode><uid v="1000001726"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="3144 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001698"/></connection><connection><identifier v="ifpath"/><connRef v="1000001718"/></connection><connection><identifier v="elsepath"/><connRef v="1000001727"/></connection></connections></paramNode><paramNode><uid v="1000001727"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="2864 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001701"/></connection><connection><identifier v="ifpath"/><connRef v="1000001720"/></connection><connection><identifier v="elsepath"/><connRef v="1000001728"/></connection></connections></paramNode><paramNode><uid v="1000001728"/><function v="ifelse"/><type v="1024"/><GUILayout><gpos v="2584 704 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001704"/></connection><connection><identifier v="ifpath"/><connRef v="1000001722"/></connection><connection><identifier v="elsepath"/><connRef v="1000001729"/></connection></connections></paramNode><paramNode><uid v="1000001729"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 2144 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0 0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001730"/><function v="instance"/><type v="256"/><GUILayout><gpos v="4264 64 0"/></GUILayout><connections><connection><identifier v="rgb"/><connRef v="1000001685"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGB_lightness_luma_rec601"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="rgb"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001731"/><function v="sub"/><type v="256"/><GUILayout><gpos v="4544 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001674"/></connection><connection><identifier v="b"/><connRef v="1000001730"/></connection></connections></paramNode><paramNode><uid v="1000001732"/><function v="add"/><type v="1024"/><GUILayout><gpos v="5384 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001734"/></connection><connection><identifier v="b"/><connRef v="1000001685"/></connection></connections></paramNode><paramNode><uid v="1000001733"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="4824 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001731"/></connection><connection><identifier v="componentslast"/><connRef v="1000001731"/></connection></connections></paramNode><paramNode><uid v="1000001734"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="5104 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001733"/></connection><connection><identifier v="componentslast"/><connRef v="1000001731"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="linear_to_sRGB_luminance"/><uid v="1000001751"/><attributes><category v=""/><description v="Evaluates the linear_to_sRGB_luminance function graph. Result type: Float. Inputs: input."/><author v=""/><tags v="Color"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000001752"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001737"/><paramNodes><paramNode><uid v="1000001737"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001739"/></connection><connection><identifier v="ifpath"/><connRef v="1000001741"/></connection><connection><identifier v="elsepath"/><connRef v="1000001748"/></connection></connections></paramNode><paramNode><uid v="1000001738"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001739"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001738"/></connection><connection><identifier v="b"/><connRef v="1000001740"/></connection></connections></paramNode><paramNode><uid v="1000001740"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.0031308"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001741"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001738"/></connection><connection><identifier v="b"/><connRef v="1000001742"/></connection></connections></paramNode><paramNode><uid v="1000001742"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="12.92"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001743"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1.055"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001744"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001743"/></connection><connection><identifier v="b"/><connRef v="1000001750"/></connection></connections></paramNode><paramNode><uid v="1000001745"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001746"/><function v="div"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001745"/></connection><connection><identifier v="b"/><connRef v="1000001747"/></connection></connections></paramNode><paramNode><uid v="1000001747"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2.4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001748"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001744"/></connection><connection><identifier v="b"/><connRef v="1000001749"/></connection></connections></paramNode><paramNode><uid v="1000001749"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.055"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001750"/><function v="pow"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001738"/></connection><connection><identifier v="b"/><connRef v="1000001746"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="linear_to_sRGB_rgb"/><uid v="1000001762"/><attributes><category v=""/><description v="Evaluates the linear_to_sRGB_rgb function graph. Result type: Float3. Inputs: input."/><author v=""/><tags v="Color"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000001763"/><attributes><label v="input"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000001760"/><paramNodes><paramNode><uid v="1000001753"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001761"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001754"/><function v="instance"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000001753"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/linear_to_sRGB_luminance"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001755"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001761"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001756"/><function v="instance"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000001755"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/linear_to_sRGB_luminance"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001757"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001761"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001758"/><function v="instance"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000001757"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/linear_to_sRGB_luminance"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001759"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001754"/></connection><connection><identifier v="componentslast"/><connRef v="1000001756"/></connection></connections></paramNode><paramNode><uid v="1000001760"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001759"/></connection><connection><identifier v="componentslast"/><connRef v="1000001758"/></connection></connections></paramNode><paramNode><uid v="1000001761"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="sRGB_to_linear_rgb"/><uid v="1000001773"/><attributes><category v=""/><description v="Evaluates the sRGB_to_linear_rgb function graph. Result type: Float3. Inputs: input."/><author v=""/><tags v="Color"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000001774"/><attributes><label v="input"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000001772"/><paramNodes><paramNode><uid v="1000001764"/><function v="instance"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000001766"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/sRGB_to_linear_luminance"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001765"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001766"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001765"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001767"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001765"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001768"/><function v="instance"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000001767"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/sRGB_to_linear_luminance"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001769"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001765"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001770"/><function v="instance"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000001769"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/sRGB_to_linear_luminance"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001771"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001764"/></connection><connection><identifier v="componentslast"/><connRef v="1000001768"/></connection></connections></paramNode><paramNode><uid v="1000001772"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001771"/></connection><connection><identifier v="componentslast"/><connRef v="1000001770"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="sRGB_to_linear_luminance"/><uid v="1000001789"/><attributes><category v=""/><description v="Evaluates the sRGB_to_linear_luminance function graph. Result type: Float. Inputs: input."/><author v=""/><tags v="Color"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000001790"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001778"/><paramNodes><paramNode><uid v="1000001775"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001776"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001775"/></connection><connection><identifier v="b"/><connRef v="1000001777"/></connection></connections></paramNode><paramNode><uid v="1000001777"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.04045"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001778"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001776"/></connection><connection><identifier v="ifpath"/><connRef v="1000001782"/></connection><connection><identifier v="elsepath"/><connRef v="1000001788"/></connection></connections></paramNode><paramNode><uid v="1000001779"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001780"/><function v="div"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001779"/></connection><connection><identifier v="b"/><connRef v="1000001781"/></connection></connections></paramNode><paramNode><uid v="1000001781"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="12.92"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001782"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001775"/></connection><connection><identifier v="b"/><connRef v="1000001780"/></connection></connections></paramNode><paramNode><uid v="1000001783"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.055"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001784"/><function v="add"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001775"/></connection><connection><identifier v="b"/><connRef v="1000001783"/></connection></connections></paramNode><paramNode><uid v="1000001785"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001784"/></connection><connection><identifier v="b"/><connRef v="1000001786"/></connection></connections></paramNode><paramNode><uid v="1000001786"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1.055"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001787"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2.4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001788"/><function v="pow"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001785"/></connection><connection><identifier v="b"/><connRef v="1000001787"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="temperature_to_rgb"/><uid v="1000001813"/><attributes><category v=""/><description v="Evaluates the temperature_to_rgb function graph. Result type: Float3. Inputs: temperature."/><author v=""/><tags v="Color"/></attributes><paraminputs><paraminput><identifier v="temperature"/><uid v="1000001814"/><attributes><label v="Temperature"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000001808"/><paramNodes><paramNode><uid v="1000001791"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001810"/></connection><connection><identifier v="componentslast"/><connRef v="1000001811"/></connection></connections></paramNode><paramNode><uid v="1000001792"/><function v="div"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001793"/></connection><connection><identifier v="b"/><connRef v="1000001795"/></connection></connections></paramNode><paramNode><uid v="1000001793"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="temperature"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001794"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001791"/></connection><connection><identifier v="componentslast"/><connRef v="1000001812"/></connection></connections></paramNode><paramNode><uid v="1000001795"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="100"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001796"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.9969671"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001797"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="-0.2677948"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001798"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2.7219892"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001799"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1344.492"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001800"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.6792997"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001801"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.04639626"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001802"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="-1.5172572"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001803"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="10.576205"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001804"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1664 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="-0.36975914"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001805"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1824 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="865.37256"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001806"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1984 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1.6870481"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001807"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 2144 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2.090228"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001808"/><function v="max"/><type v="1024"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001794"/></connection><connection><identifier v="b"/><connRef v="1000001809"/></connection></connections></paramNode><paramNode><uid v="1000001809"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 2304 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0 0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001810"/><function v="instance"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000001792"/></connection><connection><identifier v="a"/><connRef v="1000001800"/></connection><connection><identifier v="b"/><connRef v="1000001801"/></connection><connection><identifier v="c"/><connRef v="1000001803"/></connection><connection><identifier v="d"/><connRef v="1000001802"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/temperature_to_rgb_fit"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input"/><type v="0"/></input><input><identifier v="a"/><type v="0"/></input><input><identifier v="b"/><type v="0"/></input><input><identifier v="c"/><type v="0"/></input><input><identifier v="d"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001811"/><function v="instance"/><type v="256"/><GUILayout><gpos v="624 284 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000001792"/></connection><connection><identifier v="a"/><connRef v="1000001797"/></connection><connection><identifier v="b"/><connRef v="1000001799"/></connection><connection><identifier v="c"/><connRef v="1000001796"/></connection><connection><identifier v="d"/><connRef v="1000001798"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/temperature_to_rgb_fit"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input"/><type v="0"/></input><input><identifier v="a"/><type v="0"/></input><input><identifier v="b"/><type v="0"/></input><input><identifier v="c"/><type v="0"/></input><input><identifier v="d"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001812"/><function v="instance"/><type v="256"/><GUILayout><gpos v="624 504 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000001792"/></connection><connection><identifier v="a"/><connRef v="1000001804"/></connection><connection><identifier v="b"/><connRef v="1000001805"/></connection><connection><identifier v="c"/><connRef v="1000001807"/></connection><connection><identifier v="d"/><connRef v="1000001806"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/temperature_to_rgb_fit"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input"/><type v="0"/></input><input><identifier v="a"/><type v="0"/></input><input><identifier v="b"/><type v="0"/></input><input><identifier v="c"/><type v="0"/></input><input><identifier v="d"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="temperature_to_rgb_fit"/><uid v="1000001826"/><attributes><category v=""/><description v="Evaluates the temperature_to_rgb_fit function graph. Result type: Float. Inputs: input, a, b, c, d."/><author v=""/><tags v=""/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000001827"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="a"/><uid v="1000001828"/><attributes><label v="a"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="b"/><uid v="1000001829"/><attributes><label v="b"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="c"/><uid v="1000001830"/><attributes><label v="c"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="d"/><uid v="1000001831"/><attributes><label v="d"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001823"/><paramNodes><paramNode><uid v="1000001815"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001816"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="d"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001817"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="b"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001818"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="c"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001819"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="a"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001820"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001818"/></connection><connection><identifier v="b"/><connRef v="1000001825"/></connection></connections></paramNode><paramNode><uid v="1000001821"/><function v="add"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001825"/></connection><connection><identifier v="b"/><connRef v="1000001817"/></connection></connections></paramNode><paramNode><uid v="1000001822"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001819"/></connection><connection><identifier v="b"/><connRef v="1000001817"/></connection></connections></paramNode><paramNode><uid v="1000001823"/><function v="div"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001824"/></connection><connection><identifier v="b"/><connRef v="1000001821"/></connection></connections></paramNode><paramNode><uid v="1000001824"/><function v="add"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001822"/></connection><connection><identifier v="b"/><connRef v="1000001820"/></connection></connections></paramNode><paramNode><uid v="1000001825"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="n"/><connRef v="1000001816"/></connection><connection><identifier v="x"/><connRef v="1000001815"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Pow"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="n"/><type v="0"/></input><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="acescg_to_linear_srgb"/><uid v="1000001840"/><attributes><category v=""/><description v="Evaluates the acescg_to_linear_srgb function graph. Result type: Float3. Inputs: input."/><author v=""/><tags v="Color"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000001841"/><attributes><label v="input"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000001839"/><paramNodes><paramNode><uid v="1000001832"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001833"/><function v="dot"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001834"/></connection><connection><identifier v="b"/><connRef v="1000001832"/></connection></connections></paramNode><paramNode><uid v="1000001834"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="-0.0241261 -0.124633 1.14882"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001835"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="-0.129553 1.13837 -0.00876801"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001836"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="1.7049 -0.62416 -0.0809141"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001837"/><function v="dot"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001835"/></connection><connection><identifier v="b"/><connRef v="1000001832"/></connection></connections></paramNode><paramNode><uid v="1000001838"/><function v="dot"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001836"/></connection><connection><identifier v="b"/><connRef v="1000001832"/></connection></connections></paramNode><paramNode><uid v="1000001839"/><function v="instance"/><type v="1024"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000001838"/></connection><connection><identifier v="y"/><connRef v="1000001837"/></connection><connection><identifier v="z"/><connRef v="1000001833"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/merge_float3"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input><input><identifier v="y"/><type v="0"/></input><input><identifier v="z"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="linear_srgb_to_acescg"/><uid v="1000001850"/><attributes><category v=""/><description v="Evaluates the linear_srgb_to_acescg function graph. Result type: Float3. Inputs: input."/><author v=""/><tags v="Color"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000001851"/><attributes><label v="input"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000001848"/><paramNodes><paramNode><uid v="1000001842"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001843"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0.020463 0.106769 0.872716"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001844"/><function v="dot"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001843"/></connection><connection><identifier v="b"/><connRef v="1000001842"/></connection></connections></paramNode><paramNode><uid v="1000001845"/><function v="dot"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001846"/></connection><connection><identifier v="b"/><connRef v="1000001842"/></connection></connections></paramNode><paramNode><uid v="1000001846"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0.0699341 0.918103 0.0119328"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001847"/><function v="dot"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001849"/></connection><connection><identifier v="b"/><connRef v="1000001842"/></connection></connections></paramNode><paramNode><uid v="1000001848"/><function v="instance"/><type v="1024"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000001847"/></connection><connection><identifier v="y"/><connRef v="1000001845"/></connection><connection><identifier v="z"/><connRef v="1000001844"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/merge_float3"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input><input><identifier v="y"/><type v="0"/></input><input><identifier v="z"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001849"/><function v="const_float3"/><type v="1024"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float3"/><constantValue><constantValueFloat3 v="0.613118 0.341182 0.0457873"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="hsl_offset"/><uid v="1000001868"/><attributes><category v=""/><description v="Evaluates the hsl_offset function graph. Result type: Float3. Inputs: rgb, hue, saturation, lightness."/><author v=""/><tags v="Color"/></attributes><paraminputs><paraminput><identifier v="rgb"/><uid v="1000001869"/><attributes><label v="rgb"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="hue"/><uid v="1000001870"/><attributes><label v="hue"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="saturation"/><uid v="1000001871"/><attributes><label v="saturation"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="lightness"/><uid v="1000001872"/><attributes><label v="lightness"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000001860"/><paramNodes><paramNode><uid v="1000001852"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="rgb"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001853"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001865"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001854"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="hue"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001855"/><function v="add"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001854"/></connection><connection><identifier v="b"/><connRef v="1000001853"/></connection></connections></paramNode><paramNode><uid v="1000001856"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001865"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001857"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="saturation"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001858"/><function v="add"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001857"/></connection><connection><identifier v="b"/><connRef v="1000001856"/></connection></connections></paramNode><paramNode><uid v="1000001859"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001866"/></connection><connection><identifier v="componentslast"/><connRef v="1000001858"/></connection></connections></paramNode><paramNode><uid v="1000001860"/><function v="instance"/><type v="1024"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="HSL"/><connRef v="1000001861"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/HSLtoRGB"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="HSL"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001861"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001859"/></connection><connection><identifier v="componentslast"/><connRef v="1000001864"/></connection></connections></paramNode><paramNode><uid v="1000001862"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000001865"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001863"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="lightness"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001864"/><function v="add"/><type v="256"/><GUILayout><gpos v="904 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001863"/></connection><connection><identifier v="b"/><connRef v="1000001862"/></connection></connections></paramNode><paramNode><uid v="1000001865"/><function v="instance"/><type v="1024"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="RGB"/><connRef v="1000001852"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/colorValues/RGBtoHSL"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="RGB"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001866"/><function v="mod"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001855"/></connection><connection><identifier v="b"/><connRef v="1000001867"/></connection></connections></paramNode><paramNode><uid v="1000001867"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="typeConverters"/><uid v="1000001873"/><content><function><identifier v="booleanToFloat1"/><uid v="1000001878"/><attributes><category v=""/><description v="Evaluates the booleanToFloat1 function graph. Result type: Float. Inputs: Boolean."/><author v=""/><tags v="Conversion"/></attributes><paraminputs><paraminput><identifier v="Boolean"/><uid v="1000001879"/><attributes><label v="Boolean"/></attributes><type v="4"/><defaultValue><constantValueBool v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001877"/><paramNodes><paramNode><uid v="1000001874"/><function v="get_bool"/><type v="4"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_bool"/><constantValue><constantValueString v="Boolean"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001875"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001876"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001877"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001874"/></connection><connection><identifier v="ifpath"/><connRef v="1000001876"/></connection><connection><identifier v="elsepath"/><connRef v="1000001875"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="turnsToDegrees"/><uid v="1000001883"/><attributes><category v=""/><description v="Evaluates the turnsToDegrees function graph. Result type: Float. Inputs: turns."/><author v=""/><tags v="Conversion"/></attributes><paraminputs><paraminput><identifier v="turns"/><uid v="1000001884"/><attributes><label v="turns"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001882"/><paramNodes><paramNode><uid v="1000001880"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="turns"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001881"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="360"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001882"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001880"/></connection><connection><identifier v="b"/><connRef v="1000001881"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="Ranges"/><uid v="1000001885"/><content><function><identifier v="[-1_1]_to_[0_1]"/><uid v="1000001891"/><attributes><category v=""/><description v="Evaluates the [-1_1]_to_[0_1] function graph. Result type: Float. Inputs: Input."/><author v=""/><tags v="Conversion"/></attributes><paraminputs><paraminput><identifier v="Input"/><uid v="1000001892"/><attributes><label v="Input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001890"/><paramNodes><paramNode><uid v="1000001886"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="Input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001887"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001888"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001889"/><function v="add"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001886"/></connection><connection><identifier v="b"/><connRef v="1000001887"/></connection></connections></paramNode><paramNode><uid v="1000001890"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001889"/></connection><connection><identifier v="b"/><connRef v="1000001888"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="[0_1]_to_[-1_1]"/><uid v="1000001898"/><attributes><category v=""/><description v="Evaluates the [0_1]_to_[-1_1] function graph. Result type: Float. Inputs: Input."/><author v=""/><tags v="Conversion"/></attributes><paraminputs><paraminput><identifier v="Input"/><uid v="1000001899"/><attributes><label v="Input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001897"/><paramNodes><paramNode><uid v="1000001893"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="Input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001894"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001895"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001896"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001893"/></connection><connection><identifier v="b"/><connRef v="1000001895"/></connection></connections></paramNode><paramNode><uid v="1000001897"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001896"/></connection><connection><identifier v="b"/><connRef v="1000001894"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="[0_1]_to_[1_0]"/><uid v="1000001905"/><attributes><category v=""/><description v="Evaluates the [0_1]_to_[1_0] function graph. Result type: Float. Inputs: Input."/><author v=""/><tags v="Conversion"/></attributes><paraminputs><paraminput><identifier v="Input"/><uid v="1000001906"/><attributes><label v="Input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001904"/><paramNodes><paramNode><uid v="1000001900"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="Input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001901"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001902"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="-1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001903"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001900"/></connection><connection><identifier v="b"/><connRef v="1000001902"/></connection></connections></paramNode><paramNode><uid v="1000001904"/><function v="add"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001903"/></connection><connection><identifier v="b"/><connRef v="1000001901"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="negateFloat"/><uid v="1000001910"/><attributes><category v=""/><description v="Evaluates the negateFloat function graph. Result type: Float. Inputs: Input."/><author v=""/><tags v="Conversion"/></attributes><paraminputs><paraminput><identifier v="Input"/><uid v="1000001911"/><attributes><label v="Input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001909"/><paramNodes><paramNode><uid v="1000001907"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="Input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001908"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="-1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001909"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001907"/></connection><connection><identifier v="b"/><connRef v="1000001908"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="Height_Balance_Fn"/><uid v="1000001928"/><attributes><category v=""/><description v="Evaluates the Height_Balance_Fn function graph. Result type: Float4. Inputs: Depth_Balance."/><author v=""/><tags v="Conversion"/></attributes><paraminputs><paraminput><identifier v="Depth_Balance"/><uid v="1000001929"/><attributes><label v="Depth_Balance"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-1"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="2048"/><paramValue><dynamicValue><rootnode v="1000001916"/><paramNodes><paramNode><uid v="1000001912"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="Depth_Balance"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001913"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001914"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001915"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001924"/></connection><connection><identifier v="componentslast"/><connRef v="1000001925"/></connection></connections></paramNode><paramNode><uid v="1000001916"/><function v="vector4"/><type v="2048"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001915"/></connection><connection><identifier v="componentslast"/><connRef v="1000001919"/></connection></connections></paramNode><paramNode><uid v="1000001917"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001918"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001919"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001927"/></connection><connection><identifier v="componentslast"/><connRef v="1000001926"/></connection></connections></paramNode><paramNode><uid v="1000001920"/><function v="add"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001913"/></connection><connection><identifier v="b"/><connRef v="1000001912"/></connection></connections></paramNode><paramNode><uid v="1000001921"/><function v="sub"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001918"/></connection><connection><identifier v="b"/><connRef v="1000001912"/></connection></connections></paramNode><paramNode><uid v="1000001922"/><function v="add"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001914"/></connection><connection><identifier v="b"/><connRef v="1000001912"/></connection></connections></paramNode><paramNode><uid v="1000001923"/><function v="sub"/><type v="256"/><GUILayout><gpos v="344 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001917"/></connection><connection><identifier v="b"/><connRef v="1000001912"/></connection></connections></paramNode><paramNode><uid v="1000001924"/><function v="max"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001922"/></connection><connection><identifier v="b"/><connRef v="1000001914"/></connection></connections></paramNode><paramNode><uid v="1000001925"/><function v="min"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001920"/></connection><connection><identifier v="b"/><connRef v="1000001913"/></connection></connections></paramNode><paramNode><uid v="1000001926"/><function v="min"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001923"/></connection><connection><identifier v="b"/><connRef v="1000001917"/></connection></connections></paramNode><paramNode><uid v="1000001927"/><function v="max"/><type v="256"/><GUILayout><gpos v="624 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001921"/></connection><connection><identifier v="b"/><connRef v="1000001918"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="[0,1]_to_[0,1,0]"/><uid v="1000001937"/><attributes><category v=""/><description v="Evaluates the [0,1]_to_[0,1,0] function graph. Result type: Float. Inputs: input."/><author v=""/><tags v="Conversion"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000001938"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001936"/><paramNodes><paramNode><uid v="1000001930"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001931"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001930"/></connection><connection><identifier v="b"/><connRef v="1000001932"/></connection></connections></paramNode><paramNode><uid v="1000001932"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001933"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001931"/></connection><connection><identifier v="b"/><connRef v="1000001934"/></connection></connections></paramNode><paramNode><uid v="1000001934"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001935"/><function v="abs"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001933"/></connection></connections></paramNode><paramNode><uid v="1000001936"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001934"/></connection><connection><identifier v="b"/><connRef v="1000001935"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="[a,b]_to_[0,1]"/><uid v="1000001948"/><attributes><category v=""/><description v="Evaluates the [a,b]_to_[0,1] function graph. Result type: Float. Inputs: X, A, B."/><author v=""/><tags v="Conversion"/></attributes><paraminputs><paraminput><identifier v="X"/><uid v="1000001949"/><attributes><label v="X"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="A"/><uid v="1000001950"/><attributes><label v="A"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="B"/><uid v="1000001951"/><attributes><label v="B"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001945"/><paramNodes><paramNode><uid v="1000001939"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="X"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001940"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001944"/></connection><connection><identifier v="b"/><connRef v="1000001941"/></connection></connections></paramNode><paramNode><uid v="1000001941"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="A"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001942"/><function v="div"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001940"/></connection><connection><identifier v="b"/><connRef v="1000001947"/></connection></connections></paramNode><paramNode><uid v="1000001943"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="B"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001944"/><function v="max"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001939"/></connection><connection><identifier v="b"/><connRef v="1000001941"/></connection></connections></paramNode><paramNode><uid v="1000001945"/><function v="min"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001946"/></connection><connection><identifier v="b"/><connRef v="1000001942"/></connection></connections></paramNode><paramNode><uid v="1000001946"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001947"/><function v="sub"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001943"/></connection><connection><identifier v="b"/><connRef v="1000001941"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="triangle_wave"/><uid v="1000001959"/><attributes><category v=""/><description v="Evaluates the triangle_wave function graph. Result type: Float. Inputs: input."/><author v=""/><tags v="Conversion"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000001960"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001957"/><paramNodes><paramNode><uid v="1000001952"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001953"/><function v="mod"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001952"/></connection><connection><identifier v="b"/><connRef v="1000001954"/></connection></connections></paramNode><paramNode><uid v="1000001954"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001955"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001953"/></connection><connection><identifier v="b"/><connRef v="1000001956"/></connection></connections></paramNode><paramNode><uid v="1000001956"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001957"/><function v="instance"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000001958"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001958"/><function v="abs"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001955"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="sawtooth_wave"/><uid v="1000001972"/><attributes><category v=""/><description v="Evaluates the sawtooth_wave function graph. Result type: Float. Inputs: x."/><author v=""/><tags v="Conversion"/></attributes><paraminputs><paraminput><identifier v="x"/><uid v="1000001973"/><attributes><label v="x"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001964"/><paramNodes><paramNode><uid v="1000001961"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="x"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001962"/><function v="mod"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001961"/></connection><connection><identifier v="b"/><connRef v="1000001963"/></connection></connections></paramNode><paramNode><uid v="1000001963"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001964"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001967"/></connection><connection><identifier v="ifpath"/><connRef v="1000001969"/></connection><connection><identifier v="elsepath"/><connRef v="1000001962"/></connection></connections></paramNode><paramNode><uid v="1000001965"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001966"/><function v="gt"/><type v="4"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001971"/></connection><connection><identifier v="b"/><connRef v="1000001965"/></connection></connections></paramNode><paramNode><uid v="1000001967"/><function v="eq"/><type v="4"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001962"/></connection><connection><identifier v="b"/><connRef v="1000001968"/></connection></connections></paramNode><paramNode><uid v="1000001968"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001969"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001966"/></connection><connection><identifier v="ifpath"/><connRef v="1000001970"/></connection><connection><identifier v="elsepath"/><connRef v="1000001971"/></connection></connections></paramNode><paramNode><uid v="1000001970"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001971"/><function v="abs"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001961"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="Cycles"/><uid v="1000001974"/><content><function><identifier v="Wave"/><uid v="1000001984"/><attributes><category v=""/><description v="Evaluates the Wave function graph. Result type: Float. Inputs: Amplitude, Frequency, greaterThanZero."/><author v=""/><tags v="Various"/></attributes><paraminputs><paraminput><identifier v="Amplitude"/><uid v="1000001985"/><attributes><label v="Amplitude"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="Frequency"/><uid v="1000001986"/><attributes><label v="Frequency"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="greaterThanZero"/><uid v="1000001987"/><attributes><label v="greaterThanZero"/></attributes><type v="4"/><defaultValue><constantValueBool v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000001981"/><paramNodes><paramNode><uid v="1000001975"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="$time"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001976"/><function v="sin"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001979"/></connection></connections></paramNode><paramNode><uid v="1000001977"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="Amplitude"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001978"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="Frequency"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001979"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001978"/></connection><connection><identifier v="b"/><connRef v="1000001975"/></connection></connections></paramNode><paramNode><uid v="1000001980"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001977"/></connection><connection><identifier v="b"/><connRef v="1000001976"/></connection></connections></paramNode><paramNode><uid v="1000001981"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000001983"/></connection><connection><identifier v="ifpath"/><connRef v="1000001982"/></connection><connection><identifier v="elsepath"/><connRef v="1000001980"/></connection></connections></paramNode><paramNode><uid v="1000001982"/><function v="add"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001977"/></connection><connection><identifier v="b"/><connRef v="1000001980"/></connection></connections></paramNode><paramNode><uid v="1000001983"/><function v="get_bool"/><type v="4"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_bool"/><constantValue><constantValueString v="greaterThanZero"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="Transforms"/><uid v="1000001988"/><content><function><identifier v="Directional_Offset"/><uid v="1000001998"/><attributes><category v=""/><description v="Evaluates the Directional_Offset function graph. Result type: Float2. Inputs: Direction, Distance."/><author v=""/><tags v="Transformation"/></attributes><paraminputs><paraminput><identifier v="Direction"/><uid v="1000001999"/><attributes><label v="Direction"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="360"/></option></options></defaultWidget></paraminput><paraminput><identifier v="Distance"/><uid v="1000002000"/><attributes><label v="Distance"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="512"/><paramValue><dynamicValue><rootnode v="1000001991"/><paramNodes><paramNode><uid v="1000001989"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001993"/></connection><connection><identifier v="b"/><connRef v="1000001995"/></connection></connections></paramNode><paramNode><uid v="1000001990"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="Direction"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001991"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000001989"/></connection><connection><identifier v="componentslast"/><connRef v="1000001992"/></connection></connections></paramNode><paramNode><uid v="1000001992"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001994"/></connection><connection><identifier v="b"/><connRef v="1000001995"/></connection></connections></paramNode><paramNode><uid v="1000001993"/><function v="cos"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001997"/></connection></connections></paramNode><paramNode><uid v="1000001994"/><function v="sin"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000001997"/></connection></connections></paramNode><paramNode><uid v="1000001995"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="Distance"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000001996"/><function v="instance"/><type v="118772"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="turns"/><connRef v="1000001990"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/typeConverters/turnsToDegrees"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="turns"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000001997"/><function v="instance"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="deg"/><connRef v="1000001996"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Trigo/deg_to_rad"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="deg"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="MatrixMultiply"/><uid v="1000002026"/><attributes><category v=""/><description v="Evaluates the MatrixMultiply function graph. Result type: Float4. Inputs: MatrixA, MatrixB."/><author v=""/><tags v="Transformation"/></attributes><paraminputs><paraminput><identifier v="MatrixA"/><uid v="1000002027"/><attributes><label v="MatrixA"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 0 0 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="MatrixB"/><uid v="1000002028"/><attributes><label v="MatrixB"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 0 0 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="2048"/><paramValue><dynamicValue><rootnode v="1000002020"/><paramNodes><paramNode><uid v="1000002001"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002012"/></connection><connection><identifier v="componentslast"/><connRef v="1000002021"/></connection></connections></paramNode><paramNode><uid v="1000002002"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002025"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002003"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002024"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002004"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002003"/></connection><connection><identifier v="b"/><connRef v="1000002002"/></connection></connections></paramNode><paramNode><uid v="1000002005"/><function v="add"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002010"/></connection><connection><identifier v="b"/><connRef v="1000002006"/></connection></connections></paramNode><paramNode><uid v="1000002006"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002014"/></connection><connection><identifier v="b"/><connRef v="1000002019"/></connection></connections></paramNode><paramNode><uid v="1000002007"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002014"/></connection><connection><identifier v="b"/><connRef v="1000002008"/></connection></connections></paramNode><paramNode><uid v="1000002008"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002025"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002009"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002023"/></connection><connection><identifier v="b"/><connRef v="1000002008"/></connection></connections></paramNode><paramNode><uid v="1000002010"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 704 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002017"/></connection><connection><identifier v="b"/><connRef v="1000002022"/></connection></connections></paramNode><paramNode><uid v="1000002011"/><function v="add"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002015"/></connection><connection><identifier v="b"/><connRef v="1000002007"/></connection></connections></paramNode><paramNode><uid v="1000002012"/><function v="add"/><type v="256"/><GUILayout><gpos v="904 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002004"/></connection><connection><identifier v="b"/><connRef v="1000002009"/></connection></connections></paramNode><paramNode><uid v="1000002013"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 864 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002003"/></connection><connection><identifier v="b"/><connRef v="1000002022"/></connection></connections></paramNode><paramNode><uid v="1000002014"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 544 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002024"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002015"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 1024 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002017"/></connection><connection><identifier v="b"/><connRef v="1000002002"/></connection></connections></paramNode><paramNode><uid v="1000002016"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002011"/></connection><connection><identifier v="componentslast"/><connRef v="1000002005"/></connection></connections></paramNode><paramNode><uid v="1000002017"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 704 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002024"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002018"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 1184 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002023"/></connection><connection><identifier v="b"/><connRef v="1000002019"/></connection></connections></paramNode><paramNode><uid v="1000002019"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 864 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002025"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002020"/><function v="vector4"/><type v="2048"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002016"/></connection><connection><identifier v="componentslast"/><connRef v="1000002001"/></connection></connections></paramNode><paramNode><uid v="1000002021"/><function v="add"/><type v="256"/><GUILayout><gpos v="904 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002013"/></connection><connection><identifier v="b"/><connRef v="1000002018"/></connection></connections></paramNode><paramNode><uid v="1000002022"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 1024 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002025"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002023"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 1184 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002024"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002024"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="MatrixA"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002025"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="MatrixB"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="RotationMatrix"/><uid v="1000002039"/><attributes><category v=""/><description v="Evaluates the RotationMatrix function graph. Result type: Float4. Inputs: RotationW."/><author v=""/><tags v="Transformation"/></attributes><paraminputs><paraminput><identifier v="RotationW"/><uid v="1000002040"/><attributes><label v="RotationW"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-360"/></option><option><name v="max"/><value v="360"/></option></options></defaultWidget></paraminput></paraminputs><type v="2048"/><paramValue><dynamicValue><rootnode v="1000002033"/><paramNodes><paramNode><uid v="1000002029"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002035"/></connection><connection><identifier v="b"/><connRef v="1000002030"/></connection></connections></paramNode><paramNode><uid v="1000002030"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="-1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002031"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002035"/></connection><connection><identifier v="componentslast"/><connRef v="1000002032"/></connection></connections></paramNode><paramNode><uid v="1000002032"/><function v="cos"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002038"/></connection></connections></paramNode><paramNode><uid v="1000002033"/><function v="vector4"/><type v="2048"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002034"/></connection><connection><identifier v="componentslast"/><connRef v="1000002031"/></connection></connections></paramNode><paramNode><uid v="1000002034"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002032"/></connection><connection><identifier v="componentslast"/><connRef v="1000002029"/></connection></connections></paramNode><paramNode><uid v="1000002035"/><function v="sin"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002038"/></connection></connections></paramNode><paramNode><uid v="1000002036"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="RotationW"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002037"/><function v="instance"/><type v="118772"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="turns"/><connRef v="1000002036"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/typeConverters/turnsToDegrees"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="turns"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000002038"/><function v="instance"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="deg"/><connRef v="1000002037"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Trigo/deg_to_rad"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="deg"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="ScaleMatrix"/><uid v="1000002051"/><attributes><category v=""/><description v="Evaluates the ScaleMatrix function graph. Result type: Float4. Inputs: ScaleUV."/><author v=""/><tags v="Transformation"/></attributes><paraminputs><paraminput><identifier v="ScaleUV"/><uid v="1000002052"/><attributes><label v="ScaleUV"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="100 100"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="2048"/><paramValue><dynamicValue><rootnode v="1000002048"/><paramNodes><paramNode><uid v="1000002041"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002042"/></connection><connection><identifier v="b"/><connRef v="1000002044"/></connection></connections></paramNode><paramNode><uid v="1000002042"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="100"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002043"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002050"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002044"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002050"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002045"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002042"/></connection><connection><identifier v="b"/><connRef v="1000002043"/></connection></connections></paramNode><paramNode><uid v="1000002046"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002049"/></connection><connection><identifier v="componentslast"/><connRef v="1000002041"/></connection></connections></paramNode><paramNode><uid v="1000002047"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002045"/></connection><connection><identifier v="componentslast"/><connRef v="1000002049"/></connection></connections></paramNode><paramNode><uid v="1000002048"/><function v="vector4"/><type v="2048"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002047"/></connection><connection><identifier v="componentslast"/><connRef v="1000002046"/></connection></connections></paramNode><paramNode><uid v="1000002049"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002050"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="ScaleUV"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="TileMatrix"/><uid v="1000002060"/><attributes><category v=""/><description v="Evaluates the TileMatrix function graph. Result type: Float4. Inputs: tiles_xy."/><author v=""/><tags v="Transformation"/></attributes><paraminputs><paraminput><identifier v="tiles_xy"/><uid v="1000002061"/><attributes><label v="Tiles X/Y"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="100 100"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="2048"/><paramValue><dynamicValue><rootnode v="1000002056"/><paramNodes><paramNode><uid v="1000002053"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002058"/></connection><connection><identifier v="componentslast"/><connRef v="1000002054"/></connection></connections></paramNode><paramNode><uid v="1000002054"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002059"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002055"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002057"/></connection><connection><identifier v="componentslast"/><connRef v="1000002058"/></connection></connections></paramNode><paramNode><uid v="1000002056"/><function v="vector4"/><type v="2048"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002055"/></connection><connection><identifier v="componentslast"/><connRef v="1000002053"/></connection></connections></paramNode><paramNode><uid v="1000002057"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002059"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002058"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002059"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="tiles_xy"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="rotate_vec2"/><uid v="1000002079"/><attributes><category v=""/><description v="Evaluates the rotate_vec2 function graph. Result type: Float2. Inputs: vec2, angle, pivot."/><author v=""/><tags v="Transformation"/></attributes><paraminputs><paraminput><identifier v="vec2"/><uid v="1000002080"/><attributes><label v="vec2"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="angle"/><uid v="1000002081"/><attributes><label v="angle"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="pivot"/><uid v="1000002082"/><attributes><label v="pivot"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="512"/><paramValue><dynamicValue><rootnode v="1000002077"/><paramNodes><paramNode><uid v="1000002062"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="angle"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002063"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002067"/></connection><connection><identifier v="componentslast"/><connRef v="1000002064"/></connection></connections></paramNode><paramNode><uid v="1000002064"/><function v="dot"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002075"/></connection><connection><identifier v="b"/><connRef v="1000002071"/></connection></connections></paramNode><paramNode><uid v="1000002065"/><function v="neg"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002066"/></connection></connections></paramNode><paramNode><uid v="1000002066"/><function v="sin"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002072"/></connection></connections></paramNode><paramNode><uid v="1000002067"/><function v="dot"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002075"/></connection><connection><identifier v="b"/><connRef v="1000002068"/></connection></connections></paramNode><paramNode><uid v="1000002068"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002069"/></connection><connection><identifier v="componentslast"/><connRef v="1000002066"/></connection></connections></paramNode><paramNode><uid v="1000002069"/><function v="cos"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002072"/></connection></connections></paramNode><paramNode><uid v="1000002070"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002071"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1464 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002065"/></connection><connection><identifier v="componentslast"/><connRef v="1000002069"/></connection></connections></paramNode><paramNode><uid v="1000002072"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002073"/></connection><connection><identifier v="b"/><connRef v="1000002078"/></connection></connections></paramNode><paramNode><uid v="1000002073"/><function v="add"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002070"/></connection><connection><identifier v="b"/><connRef v="1000002062"/></connection></connections></paramNode><paramNode><uid v="1000002074"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="vec2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002075"/><function v="sub"/><type v="512"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002074"/></connection><connection><identifier v="b"/><connRef v="1000002076"/></connection></connections></paramNode><paramNode><uid v="1000002076"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="pivot"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002077"/><function v="add"/><type v="512"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002063"/></connection><connection><identifier v="b"/><connRef v="1000002076"/></connection></connections></paramNode><paramNode><uid v="1000002078"/><function v="instance"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/2Pi"/></constantValue></funcData></funcDatas><materialcraftInterface></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="rotate_vec2_rad"/><uid v="1000002093"/><attributes><category v=""/><description v="Evaluates the rotate_vec2_rad function graph. Result type: Float2. Inputs: vec2, angle."/><author v=""/><tags v="Transformation"/></attributes><paraminputs><paraminput><identifier v="vec2"/><uid v="1000002094"/><attributes><label v="vec2"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="angle"/><uid v="1000002095"/><attributes><label v="angle"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="512"/><paramValue><dynamicValue><rootnode v="1000002084"/><paramNodes><paramNode><uid v="1000002083"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="angle"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002084"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002088"/></connection><connection><identifier v="componentslast"/><connRef v="1000002085"/></connection></connections></paramNode><paramNode><uid v="1000002085"/><function v="dot"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002092"/></connection><connection><identifier v="b"/><connRef v="1000002091"/></connection></connections></paramNode><paramNode><uid v="1000002086"/><function v="neg"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002087"/></connection></connections></paramNode><paramNode><uid v="1000002087"/><function v="sin"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002083"/></connection></connections></paramNode><paramNode><uid v="1000002088"/><function v="dot"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002092"/></connection><connection><identifier v="b"/><connRef v="1000002089"/></connection></connections></paramNode><paramNode><uid v="1000002089"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002090"/></connection><connection><identifier v="componentslast"/><connRef v="1000002087"/></connection></connections></paramNode><paramNode><uid v="1000002090"/><function v="cos"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002083"/></connection></connections></paramNode><paramNode><uid v="1000002091"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002086"/></connection><connection><identifier v="componentslast"/><connRef v="1000002090"/></connection></connections></paramNode><paramNode><uid v="1000002092"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="vec2"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="matrix_invert"/><uid v="1000002109"/><attributes><category v="Function"/><description v="Evaluates the matrix_invert function graph. Result type: Float4. Inputs: matrix22."/><author v=""/><tags v="Transformation"/></attributes><paraminputs><paraminput><identifier v="matrix22"/><uid v="1000002110"/><attributes><label v="matrix22"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="2048"/><paramValue><dynamicValue><rootnode v="1000002107"/><paramNodes><paramNode><uid v="1000002096"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002104"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002097"/><function v="swizzle2"/><type v="512"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002103"/></connection></connections><funcDatas><funcData><name v="swizzle2"/><constantValue><constantValueInt2 v="0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002098"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002104"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002099"/><function v="swizzle2"/><type v="512"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002103"/></connection></connections><funcDatas><funcData><name v="swizzle2"/><constantValue><constantValueInt2 v="3 2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002100"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002101"/><function v="swizzle4"/><type v="2048"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002103"/></connection></connections><funcDatas><funcData><name v="swizzle4"/><constantValue><constantValueInt4 v="3 1 2 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002102"/><function v="mulscalar"/><type v="2048"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002101"/></connection><connection><identifier v="scalar"/><connRef v="1000002105"/></connection></connections></paramNode><paramNode><uid v="1000002103"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="matrix22"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002104"/><function v="mul"/><type v="512"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002097"/></connection><connection><identifier v="b"/><connRef v="1000002099"/></connection></connections></paramNode><paramNode><uid v="1000002105"/><function v="div"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002100"/></connection><connection><identifier v="b"/><connRef v="1000002106"/></connection></connections></paramNode><paramNode><uid v="1000002106"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002096"/></connection><connection><identifier v="b"/><connRef v="1000002098"/></connection></connections></paramNode><paramNode><uid v="1000002107"/><function v="mul"/><type v="2048"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002108"/></connection><connection><identifier v="b"/><connRef v="1000002102"/></connection></connections></paramNode><paramNode><uid v="1000002108"/><function v="const_float4"/><type v="2048"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float4"/><constantValue><constantValueFloat4 v="1 -1 -1 1"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="polar_to_carthesian"/><uid v="1000002129"/><attributes><category v="Function"/><description v="Evaluates the polar_to_carthesian function graph. Result type: Float3. Inputs: input."/><author v=""/><tags v="Transformation"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000002130"/><attributes><label v="input"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000002125"/><paramNodes><paramNode><uid v="1000002111"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002123"/></connection><connection><identifier v="b"/><connRef v="1000002112"/></connection></connections></paramNode><paramNode><uid v="1000002112"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002126"/></connection><connection><identifier v="b"/><connRef v="1000002127"/></connection></connections></paramNode><paramNode><uid v="1000002113"/><function v="mulscalar"/><type v="512"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002118"/></connection><connection><identifier v="scalar"/><connRef v="1000002120"/></connection></connections></paramNode><paramNode><uid v="1000002114"/><function v="sin"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002111"/></connection></connections></paramNode><paramNode><uid v="1000002115"/><function v="sin"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002124"/></connection></connections></paramNode><paramNode><uid v="1000002116"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002119"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002117"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002118"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002122"/></connection><connection><identifier v="componentslast"/><connRef v="1000002115"/></connection></connections></paramNode><paramNode><uid v="1000002119"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002120"/><function v="cos"/><type v="256"/><GUILayout><gpos v="1184 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002111"/></connection></connections></paramNode><paramNode><uid v="1000002121"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002117"/></connection><connection><identifier v="b"/><connRef v="1000002123"/></connection></connections></paramNode><paramNode><uid v="1000002122"/><function v="cos"/><type v="256"/><GUILayout><gpos v="904 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002124"/></connection></connections></paramNode><paramNode><uid v="1000002123"/><function v="instance"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Pi"/></constantValue></funcData></funcDatas><materialcraftInterface></materialcraftInterface></paramNode><paramNode><uid v="1000002124"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002116"/></connection><connection><identifier v="b"/><connRef v="1000002121"/></connection></connections></paramNode><paramNode><uid v="1000002125"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002113"/></connection><connection><identifier v="componentslast"/><connRef v="1000002128"/></connection></connections></paramNode><paramNode><uid v="1000002126"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002119"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002127"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002128"/><function v="neg"/><type v="256"/><GUILayout><gpos v="1464 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002114"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="carthesian_to_polar"/><uid v="1000002151"/><attributes><category v="Function"/><description v="Evaluates the carthesian_to_polar function graph. Result type: Float2. Inputs: input."/><author v=""/><tags v="Transformation"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000002152"/><attributes><label v="input"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="512"/><paramValue><dynamicValue><rootnode v="1000002136"/><paramNodes><paramNode><uid v="1000002131"/><function v="atan2"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002142"/></connection></connections></paramNode><paramNode><uid v="1000002132"/><function v="instance"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Pi"/></constantValue></funcData></funcDatas><materialcraftInterface></materialcraftInterface></paramNode><paramNode><uid v="1000002133"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002145"/></connection><connection><identifier v="componentslast"/><connRef v="1000002146"/></connection></connections></paramNode><paramNode><uid v="1000002134"/><function v="div"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002131"/></connection><connection><identifier v="b"/><connRef v="1000002132"/></connection></connections></paramNode><paramNode><uid v="1000002135"/><function v="instance"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/2Pi"/></constantValue></funcData></funcDatas><materialcraftInterface></materialcraftInterface></paramNode><paramNode><uid v="1000002136"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="2864 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002148"/></connection><connection><identifier v="componentslast"/><connRef v="1000002150"/></connection></connections></paramNode><paramNode><uid v="1000002137"/><function v="atan2"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002133"/></connection></connections></paramNode><paramNode><uid v="1000002138"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002139"/><function v="div"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002137"/></connection><connection><identifier v="b"/><connRef v="1000002135"/></connection></connections></paramNode><paramNode><uid v="1000002140"/><function v="add"/><type v="256"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002134"/></connection><connection><identifier v="b"/><connRef v="1000002138"/></connection></connections></paramNode><paramNode><uid v="1000002141"/><function v="dot"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002133"/></connection><connection><identifier v="b"/><connRef v="1000002133"/></connection></connections></paramNode><paramNode><uid v="1000002142"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002143"/></connection><connection><identifier v="componentslast"/><connRef v="1000002147"/></connection></connections></paramNode><paramNode><uid v="1000002143"/><function v="sqrt"/><type v="256"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002141"/></connection></connections></paramNode><paramNode><uid v="1000002144"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002145"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002144"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002146"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002144"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002147"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002144"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002148"/><function v="mod"/><type v="256"/><GUILayout><gpos v="1464 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002139"/></connection><connection><identifier v="b"/><connRef v="1000002149"/></connection></connections></paramNode><paramNode><uid v="1000002149"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002150"/><function v="instance"/><type v="256"/><GUILayout><gpos v="2584 64 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000002140"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/oneminus"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="Random"/><uid v="1000002153"/><content><function><identifier v="Uniform_[A,B["/><uid v="1000002159"/><attributes><category v=""/><description v="Evaluates the Uniform_[A,B[ function graph. Result type: Float. Inputs: A, B."/><author v=""/><tags v="Random"/></attributes><paraminputs><paraminput><identifier v="A"/><uid v="1000002160"/><attributes><label v="A"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput><paraminput><identifier v="B"/><uid v="1000002161"/><attributes><label v="B"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002155"/><paramNodes><paramNode><uid v="1000002154"/><function v="rand"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002156"/></connection></connections></paramNode><paramNode><uid v="1000002155"/><function v="add"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002154"/></connection><connection><identifier v="b"/><connRef v="1000002157"/></connection></connections></paramNode><paramNode><uid v="1000002156"/><function v="sub"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002158"/></connection><connection><identifier v="b"/><connRef v="1000002157"/></connection></connections></paramNode><paramNode><uid v="1000002157"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="A"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002158"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="B"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="Discrete_[A,B]"/><uid v="1000002169"/><attributes><category v=""/><description v="Evaluates the Discrete_[A,B] function graph. Result type: Float. Inputs: A, B, Probability."/><author v=""/><tags v="Random"/></attributes><paraminputs><paraminput><identifier v="A"/><uid v="1000002170"/><attributes><label v="A"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput><paraminput><identifier v="B"/><uid v="1000002171"/><attributes><label v="B"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput><paraminput><identifier v="Probability"/><uid v="1000002172"/><attributes><label v="Probability"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0.5"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002166"/><paramNodes><paramNode><uid v="1000002162"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="A"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002163"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="B"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002164"/><function v="rand"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002168"/></connection></connections></paramNode><paramNode><uid v="1000002165"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="Probability"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002166"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000002167"/></connection><connection><identifier v="ifpath"/><connRef v="1000002162"/></connection><connection><identifier v="elsepath"/><connRef v="1000002163"/></connection></connections></paramNode><paramNode><uid v="1000002167"/><function v="gteq"/><type v="4"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002164"/></connection><connection><identifier v="b"/><connRef v="1000002165"/></connection></connections></paramNode><paramNode><uid v="1000002168"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="Uniform_[-1,1["/><uid v="1000002177"/><attributes><category v=""/><description v="Evaluates the Uniform_[-1,1[ function graph. Result type: Float. Inputs: none."/><author v=""/><tags v="Random"/></attributes><paraminputs></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002175"/><paramNodes><paramNode><uid v="1000002173"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002174"/><function v="rand"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002173"/></connection></connections></paramNode><paramNode><uid v="1000002175"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002174"/></connection><connection><identifier v="b"/><connRef v="1000002176"/></connection></connections></paramNode><paramNode><uid v="1000002176"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="Uniform_F2_[A,B["/><uid v="1000002187"/><attributes><category v=""/><description v="Evaluates the Uniform_F2_[A,B[ function graph. Result type: Float2. Inputs: A2, B2."/><author v=""/><tags v="Random"/></attributes><paraminputs><paraminput><identifier v="A2"/><uid v="1000002188"/><attributes><label v="A2"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput><paraminput><identifier v="B2"/><uid v="1000002189"/><attributes><label v="B2"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput></paraminputs><type v="512"/><paramValue><dynamicValue><rootnode v="1000002186"/><paramNodes><paramNode><uid v="1000002178"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="A2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002179"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="B2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002180"/><function v="sub"/><type v="512"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002179"/></connection><connection><identifier v="b"/><connRef v="1000002178"/></connection></connections></paramNode><paramNode><uid v="1000002181"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002180"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002182"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002180"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002183"/><function v="rand"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002181"/></connection></connections></paramNode><paramNode><uid v="1000002184"/><function v="rand"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002182"/></connection></connections></paramNode><paramNode><uid v="1000002185"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002183"/></connection><connection><identifier v="componentslast"/><connRef v="1000002184"/></connection></connections></paramNode><paramNode><uid v="1000002186"/><function v="add"/><type v="512"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002185"/></connection><connection><identifier v="b"/><connRef v="1000002178"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="Uniform_F3_[A,B["/><uid v="1000002202"/><attributes><category v=""/><description v="Evaluates the Uniform_F3_[A,B[ function graph. Result type: Float3. Inputs: A, B."/><author v=""/><tags v="Random"/></attributes><paraminputs><paraminput><identifier v="A"/><uid v="1000002203"/><attributes><label v="A"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="0 0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput><paraminput><identifier v="B"/><uid v="1000002204"/><attributes><label v="B"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000002201"/><paramNodes><paramNode><uid v="1000002190"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="A"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002191"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="B"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002192"/><function v="sub"/><type v="1024"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002191"/></connection><connection><identifier v="b"/><connRef v="1000002190"/></connection></connections></paramNode><paramNode><uid v="1000002193"/><function v="rand"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002194"/></connection></connections></paramNode><paramNode><uid v="1000002194"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002192"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002195"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002192"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002196"/><function v="rand"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002195"/></connection></connections></paramNode><paramNode><uid v="1000002197"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002192"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002198"/><function v="rand"/><type v="256"/><GUILayout><gpos v="904 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002197"/></connection></connections></paramNode><paramNode><uid v="1000002199"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002200"/></connection><connection><identifier v="componentslast"/><connRef v="1000002198"/></connection></connections></paramNode><paramNode><uid v="1000002200"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002193"/></connection><connection><identifier v="componentslast"/><connRef v="1000002196"/></connection></connections></paramNode><paramNode><uid v="1000002201"/><function v="add"/><type v="1024"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002199"/></connection><connection><identifier v="b"/><connRef v="1000002190"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="Uniform_F4_[A,B["/><uid v="1000002220"/><attributes><category v=""/><description v="Evaluates the Uniform_F4_[A,B[ function graph. Result type: Float4. Inputs: A, B."/><author v=""/><tags v="Random"/></attributes><paraminputs><paraminput><identifier v="A"/><uid v="1000002221"/><attributes><label v="A"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="0 0 0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput><paraminput><identifier v="B"/><uid v="1000002222"/><attributes><label v="B"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput></paraminputs><type v="2048"/><paramValue><dynamicValue><rootnode v="1000002219"/><paramNodes><paramNode><uid v="1000002205"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="A"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002206"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="B"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002207"/><function v="sub"/><type v="2048"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002206"/></connection><connection><identifier v="b"/><connRef v="1000002205"/></connection></connections></paramNode><paramNode><uid v="1000002208"/><function v="rand"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002209"/></connection></connections></paramNode><paramNode><uid v="1000002209"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002207"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002210"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002207"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002211"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002207"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002212"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="624 544 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002207"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002213"/><function v="rand"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002210"/></connection></connections></paramNode><paramNode><uid v="1000002214"/><function v="rand"/><type v="256"/><GUILayout><gpos v="904 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002211"/></connection></connections></paramNode><paramNode><uid v="1000002215"/><function v="rand"/><type v="256"/><GUILayout><gpos v="904 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002212"/></connection></connections></paramNode><paramNode><uid v="1000002216"/><function v="vector4"/><type v="2048"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002217"/></connection><connection><identifier v="componentslast"/><connRef v="1000002218"/></connection></connections></paramNode><paramNode><uid v="1000002217"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002208"/></connection><connection><identifier v="componentslast"/><connRef v="1000002213"/></connection></connections></paramNode><paramNode><uid v="1000002218"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002214"/></connection><connection><identifier v="componentslast"/><connRef v="1000002215"/></connection></connections></paramNode><paramNode><uid v="1000002219"/><function v="add"/><type v="2048"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002216"/></connection><connection><identifier v="b"/><connRef v="1000002205"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="Degrees_to_Turn"/><uid v="1000002226"/><attributes><category v=""/><description v="Evaluates the Degrees_to_Turn function graph. Result type: Float. Inputs: input."/><author v=""/><tags v="Conversion"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000002227"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002224"/><paramNodes><paramNode><uid v="1000002223"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002224"/><function v="div"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002223"/></connection><connection><identifier v="b"/><connRef v="1000002225"/></connection></connections></paramNode><paramNode><uid v="1000002225"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="360"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="GlobalRandom"/><uid v="1000002364"/><attributes><category v=""/><description v="Evaluates the GlobalRandom function graph. Result type: Float. Inputs: Input, Seed."/><author v=""/><tags v="Random"/></attributes><paraminputs><paraminput><identifier v="Input"/><uid v="1000002365"/><attributes><label v="Input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="Seed"/><uid v="1000002366"/><attributes><label v="Seed"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002363"/><paramNodes><paramNode><uid v="1000002228"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="512"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002229"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="512"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002230"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="32768"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002231"/><function v="sub"/><type v="256"/><GUILayout><gpos v="4264 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002266"/></connection><connection><identifier v="b"/><connRef v="1000002304"/></connection></connections></paramNode><paramNode><uid v="1000002232"/><function v="mul"/><type v="256"/><GUILayout><gpos v="10704 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002243"/></connection><connection><identifier v="b"/><connRef v="1000002261"/></connection></connections></paramNode><paramNode><uid v="1000002233"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002295"/></connection><connection><identifier v="b"/><connRef v="1000002241"/></connection></connections></paramNode><paramNode><uid v="1000002234"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002246"/></connection><connection><identifier v="b"/><connRef v="1000002305"/></connection></connections></paramNode><paramNode><uid v="1000002235"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="16384"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002236"/><function v="add"/><type v="256"/><GUILayout><gpos v="7624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002264"/></connection><connection><identifier v="b"/><connRef v="1000002283"/></connection></connections></paramNode><paramNode><uid v="1000002237"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1024"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002238"/><function v="sub"/><type v="256"/><GUILayout><gpos v="3424 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002267"/></connection><connection><identifier v="b"/><connRef v="1000002244"/></connection></connections></paramNode><paramNode><uid v="1000002239"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002246"/></connection><connection><identifier v="b"/><connRef v="1000002228"/></connection></connections></paramNode><paramNode><uid v="1000002240"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002246"/></connection><connection><identifier v="b"/><connRef v="1000002254"/></connection></connections></paramNode><paramNode><uid v="1000002241"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="16384"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002242"/><function v="div"/><type v="256"/><GUILayout><gpos v="5104 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002282"/></connection><connection><identifier v="b"/><connRef v="1000002316"/></connection></connections></paramNode><paramNode><uid v="1000002243"/><function v="div"/><type v="256"/><GUILayout><gpos v="10424 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002268"/></connection><connection><identifier v="b"/><connRef v="1000002279"/></connection></connections></paramNode><paramNode><uid v="1000002244"/><function v="sub"/><type v="256"/><GUILayout><gpos v="3144 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002239"/></connection><connection><identifier v="b"/><connRef v="1000002272"/></connection></connections></paramNode><paramNode><uid v="1000002245"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="128"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002246"/><function v="add"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002332"/></connection><connection><identifier v="b"/><connRef v="1000002261"/></connection></connections></paramNode><paramNode><uid v="1000002247"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002246"/></connection><connection><identifier v="b"/><connRef v="1000002256"/></connection></connections></paramNode><paramNode><uid v="1000002248"/><function v="add"/><type v="256"/><GUILayout><gpos v="7904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002236"/></connection><connection><identifier v="b"/><connRef v="1000002244"/></connection></connections></paramNode><paramNode><uid v="1000002249"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 704 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002246"/></connection><connection><identifier v="b"/><connRef v="1000002301"/></connection></connections></paramNode><paramNode><uid v="1000002250"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002310"/></connection><connection><identifier v="b"/><connRef v="1000002302"/></connection></connections></paramNode><paramNode><uid v="1000002251"/><function v="add"/><type v="256"/><GUILayout><gpos v="6504 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002324"/></connection><connection><identifier v="b"/><connRef v="1000002299"/></connection></connections></paramNode><paramNode><uid v="1000002252"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 864 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002246"/></connection><connection><identifier v="b"/><connRef v="1000002230"/></connection></connections></paramNode><paramNode><uid v="1000002253"/><function v="add"/><type v="256"/><GUILayout><gpos v="9024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002312"/></connection><connection><identifier v="b"/><connRef v="1000002290"/></connection></connections></paramNode><paramNode><uid v="1000002254"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002255"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1024"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002256"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="64"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002257"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 1024 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002246"/></connection><connection><identifier v="b"/><connRef v="1000002308"/></connection></connections></paramNode><paramNode><uid v="1000002258"/><function v="add"/><type v="256"/><GUILayout><gpos v="9584 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002286"/></connection><connection><identifier v="b"/><connRef v="1000002284"/></connection></connections></paramNode><paramNode><uid v="1000002259"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1664 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="32"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002260"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 1184 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002246"/></connection><connection><identifier v="b"/><connRef v="1000002288"/></connection></connections></paramNode><paramNode><uid v="1000002261"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 1824 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="Input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002262"/><function v="sub"/><type v="256"/><GUILayout><gpos v="4544 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002265"/></connection><connection><identifier v="b"/><connRef v="1000002231"/></connection></connections></paramNode><paramNode><uid v="1000002263"/><function v="sub"/><type v="256"/><GUILayout><gpos v="2584 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002306"/></connection><connection><identifier v="b"/><connRef v="1000002287"/></connection></connections></paramNode><paramNode><uid v="1000002264"/><function v="add"/><type v="256"/><GUILayout><gpos v="7344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002275"/></connection><connection><identifier v="b"/><connRef v="1000002281"/></connection></connections></paramNode><paramNode><uid v="1000002265"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 1344 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002246"/></connection><connection><identifier v="b"/><connRef v="1000002235"/></connection></connections></paramNode><paramNode><uid v="1000002266"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 1504 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002246"/></connection><connection><identifier v="b"/><connRef v="1000002274"/></connection></connections></paramNode><paramNode><uid v="1000002267"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 1664 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002246"/></connection><connection><identifier v="b"/><connRef v="1000002255"/></connection></connections></paramNode><paramNode><uid v="1000002268"/><function v="add"/><type v="256"/><GUILayout><gpos v="10144 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002278"/></connection><connection><identifier v="b"/><connRef v="1000002273"/></connection></connections></paramNode><paramNode><uid v="1000002269"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002250"/></connection><connection><identifier v="b"/><connRef v="1000002237"/></connection></connections></paramNode><paramNode><uid v="1000002270"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1984 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="4096"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002271"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 1824 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002246"/></connection><connection><identifier v="b"/><connRef v="1000002296"/></connection></connections></paramNode><paramNode><uid v="1000002272"/><function v="sub"/><type v="256"/><GUILayout><gpos v="2864 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002234"/></connection><connection><identifier v="b"/><connRef v="1000002263"/></connection></connections></paramNode><paramNode><uid v="1000002273"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002276"/></connection><connection><identifier v="b"/><connRef v="1000002298"/></connection></connections></paramNode><paramNode><uid v="1000002274"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 2144 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="8192"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002275"/><function v="add"/><type v="256"/><GUILayout><gpos v="7064 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002294"/></connection><connection><identifier v="b"/><connRef v="1000002277"/></connection></connections></paramNode><paramNode><uid v="1000002276"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 1984 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002246"/></connection><connection><identifier v="b"/><connRef v="1000002292"/></connection></connections></paramNode><paramNode><uid v="1000002277"/><function v="div"/><type v="256"/><GUILayout><gpos v="4264 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002304"/></connection><connection><identifier v="b"/><connRef v="1000002309"/></connection></connections></paramNode><paramNode><uid v="1000002278"/><function v="add"/><type v="256"/><GUILayout><gpos v="9864 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002258"/></connection><connection><identifier v="b"/><connRef v="1000002233"/></connection></connections></paramNode><paramNode><uid v="1000002279"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 2304 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="131072"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002280"/><function v="sub"/><type v="256"/><GUILayout><gpos v="2024 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002257"/></connection><connection><identifier v="b"/><connRef v="1000002250"/></connection></connections></paramNode><paramNode><uid v="1000002281"/><function v="div"/><type v="256"/><GUILayout><gpos v="3984 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002313"/></connection><connection><identifier v="b"/><connRef v="1000002259"/></connection></connections></paramNode><paramNode><uid v="1000002282"/><function v="sub"/><type v="256"/><GUILayout><gpos v="4824 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002252"/></connection><connection><identifier v="b"/><connRef v="1000002262"/></connection></connections></paramNode><paramNode><uid v="1000002283"/><function v="div"/><type v="256"/><GUILayout><gpos v="3704 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002238"/></connection><connection><identifier v="b"/><connRef v="1000002289"/></connection></connections></paramNode><paramNode><uid v="1000002284"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1744 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002302"/></connection><connection><identifier v="b"/><connRef v="1000002270"/></connection></connections></paramNode><paramNode><uid v="1000002285"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 2464 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2048"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002286"/><function v="add"/><type v="256"/><GUILayout><gpos v="9304 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002253"/></connection><connection><identifier v="b"/><connRef v="1000002269"/></connection></connections></paramNode><paramNode><uid v="1000002287"/><function v="sub"/><type v="256"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002247"/></connection><connection><identifier v="b"/><connRef v="1000002280"/></connection></connections></paramNode><paramNode><uid v="1000002288"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 2624 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2048"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002289"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 2784 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002290"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2304 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002280"/></connection><connection><identifier v="b"/><connRef v="1000002300"/></connection></connections></paramNode><paramNode><uid v="1000002291"/><function v="div"/><type v="256"/><GUILayout><gpos v="4544 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002231"/></connection><connection><identifier v="b"/><connRef v="1000002229"/></connection></connections></paramNode><paramNode><uid v="1000002292"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 2944 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002293"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 3104 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="16"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002294"/><function v="add"/><type v="256"/><GUILayout><gpos v="6784 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002251"/></connection><connection><identifier v="b"/><connRef v="1000002291"/></connection></connections></paramNode><paramNode><uid v="1000002295"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002240"/></connection><connection><identifier v="b"/><connRef v="1000002276"/></connection></connections></paramNode><paramNode><uid v="1000002296"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 3264 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="8"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002297"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 3424 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="64"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002298"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 3584 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="65536"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002299"/><function v="div"/><type v="256"/><GUILayout><gpos v="4824 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002262"/></connection><connection><identifier v="b"/><connRef v="1000002285"/></connection></connections></paramNode><paramNode><uid v="1000002300"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 3744 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="256"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002301"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 3904 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="4096"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002302"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1464 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002271"/></connection><connection><identifier v="b"/><connRef v="1000002295"/></connection></connections></paramNode><paramNode><uid v="1000002303"/><function v="add"/><type v="256"/><GUILayout><gpos v="8464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002307"/></connection><connection><identifier v="b"/><connRef v="1000002315"/></connection></connections></paramNode><paramNode><uid v="1000002304"/><function v="sub"/><type v="256"/><GUILayout><gpos v="3984 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002249"/></connection><connection><identifier v="b"/><connRef v="1000002313"/></connection></connections></paramNode><paramNode><uid v="1000002305"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 4064 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="256"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002306"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 2144 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002246"/></connection><connection><identifier v="b"/><connRef v="1000002245"/></connection></connections></paramNode><paramNode><uid v="1000002307"/><function v="add"/><type v="256"/><GUILayout><gpos v="8184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002248"/></connection><connection><identifier v="b"/><connRef v="1000002317"/></connection></connections></paramNode><paramNode><uid v="1000002308"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 4224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="32"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002309"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 4384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="128"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002310"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 2304 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002246"/></connection><connection><identifier v="b"/><connRef v="1000002293"/></connection></connections></paramNode><paramNode><uid v="1000002311"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 4544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="16"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002312"/><function v="add"/><type v="256"/><GUILayout><gpos v="8744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002303"/></connection><connection><identifier v="b"/><connRef v="1000002314"/></connection></connections></paramNode><paramNode><uid v="1000002313"/><function v="sub"/><type v="256"/><GUILayout><gpos v="3704 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002260"/></connection><connection><identifier v="b"/><connRef v="1000002238"/></connection></connections></paramNode><paramNode><uid v="1000002314"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2584 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002287"/></connection><connection><identifier v="b"/><connRef v="1000002297"/></connection></connections></paramNode><paramNode><uid v="1000002315"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2864 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002263"/></connection><connection><identifier v="b"/><connRef v="1000002311"/></connection></connections></paramNode><paramNode><uid v="1000002316"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 4704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="8192"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002317"/><function v="mul"/><type v="256"/><GUILayout><gpos v="3144 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002272"/></connection><connection><identifier v="b"/><connRef v="1000002318"/></connection></connections></paramNode><paramNode><uid v="1000002318"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 4864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="4"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002319"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 2464 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002246"/></connection><connection><identifier v="b"/><connRef v="1000002320"/></connection></connections></paramNode><paramNode><uid v="1000002320"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 5024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="65536"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002321"/><function v="sub"/><type v="256"/><GUILayout><gpos v="5104 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002319"/></connection><connection><identifier v="b"/><connRef v="1000002282"/></connection></connections></paramNode><paramNode><uid v="1000002322"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 5184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="32768"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002323"/><function v="div"/><type v="256"/><GUILayout><gpos v="5384 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002321"/></connection><connection><identifier v="b"/><connRef v="1000002322"/></connection></connections></paramNode><paramNode><uid v="1000002324"/><function v="add"/><type v="256"/><GUILayout><gpos v="6224 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002330"/></connection><connection><identifier v="b"/><connRef v="1000002242"/></connection></connections></paramNode><paramNode><uid v="1000002325"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 5344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="131072"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002326"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 2624 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002246"/></connection><connection><identifier v="b"/><connRef v="1000002325"/></connection></connections></paramNode><paramNode><uid v="1000002327"/><function v="div"/><type v="256"/><GUILayout><gpos v="5664 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002329"/></connection><connection><identifier v="b"/><connRef v="1000002328"/></connection></connections></paramNode><paramNode><uid v="1000002328"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 5504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="131072"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002329"/><function v="sub"/><type v="256"/><GUILayout><gpos v="5384 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002326"/></connection><connection><identifier v="b"/><connRef v="1000002321"/></connection></connections></paramNode><paramNode><uid v="1000002330"/><function v="add"/><type v="256"/><GUILayout><gpos v="5944 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002327"/></connection><connection><identifier v="b"/><connRef v="1000002323"/></connection></connections></paramNode><paramNode><uid v="1000002331"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 5664 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="Seed"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002332"/><function v="tofloat"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000002331"/></connection></connections></paramNode><paramNode><uid v="1000002333"/><function v="div"/><type v="256"/><GUILayout><gpos v="3704 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002334"/></connection><connection><identifier v="b"/><connRef v="1000002336"/></connection></connections></paramNode><paramNode><uid v="1000002334"/><function v="sub"/><type v="256"/><GUILayout><gpos v="3424 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002346"/></connection><connection><identifier v="b"/><connRef v="1000002342"/></connection></connections></paramNode><paramNode><uid v="1000002335"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 5824 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="100"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002336"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 5984 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="100"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002337"/><function v="sub"/><type v="256"/><GUILayout><gpos v="2304 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002350"/></connection><connection><identifier v="b"/><connRef v="1000002359"/></connection></connections></paramNode><paramNode><uid v="1000002338"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 6144 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="4321"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002339"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 6304 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="65536"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002340"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 6464 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="100"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002341"/><function v="add"/><type v="256"/><GUILayout><gpos v="1184 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002345"/></connection><connection><identifier v="b"/><connRef v="1000002338"/></connection></connections></paramNode><paramNode><uid v="1000002342"/><function v="mod"/><type v="256"/><GUILayout><gpos v="3144 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002357"/></connection><connection><identifier v="b"/><connRef v="1000002340"/></connection></connections></paramNode><paramNode><uid v="1000002343"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 6624 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="100"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002344"/><function v="div"/><type v="256"/><GUILayout><gpos v="2584 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002337"/></connection><connection><identifier v="b"/><connRef v="1000002335"/></connection></connections></paramNode><paramNode><uid v="1000002345"/><function v="mod"/><type v="256"/><GUILayout><gpos v="904 2784 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002348"/></connection><connection><identifier v="b"/><connRef v="1000002339"/></connection></connections></paramNode><paramNode><uid v="1000002346"/><function v="mod"/><type v="256"/><GUILayout><gpos v="3144 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002357"/></connection><connection><identifier v="b"/><connRef v="1000002356"/></connection></connections></paramNode><paramNode><uid v="1000002347"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1744 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002354"/></connection><connection><identifier v="b"/><connRef v="1000002352"/></connection></connections></paramNode><paramNode><uid v="1000002348"/><function v="add"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002362"/></connection><connection><identifier v="b"/><connRef v="1000002338"/></connection></connections></paramNode><paramNode><uid v="1000002349"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 6784 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="35"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002350"/><function v="mod"/><type v="256"/><GUILayout><gpos v="2024 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002347"/></connection><connection><identifier v="b"/><connRef v="1000002360"/></connection></connections></paramNode><paramNode><uid v="1000002351"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 6944 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="Input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002352"/><function v="pow2"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002349"/></connection></connections></paramNode><paramNode><uid v="1000002353"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 7104 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1234"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002354"/><function v="div"/><type v="256"/><GUILayout><gpos v="1464 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002353"/></connection><connection><identifier v="b"/><connRef v="1000002341"/></connection></connections></paramNode><paramNode><uid v="1000002355"/><function v="div"/><type v="256"/><GUILayout><gpos v="3984 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002333"/></connection><connection><identifier v="b"/><connRef v="1000002358"/></connection></connections></paramNode><paramNode><uid v="1000002356"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 7264 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1000000"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002357"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2864 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002344"/></connection><connection><identifier v="b"/><connRef v="1000002344"/></connection></connections></paramNode><paramNode><uid v="1000002358"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 7424 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="10000"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002359"/><function v="mod"/><type v="256"/><GUILayout><gpos v="2024 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002347"/></connection><connection><identifier v="b"/><connRef v="1000002343"/></connection></connections></paramNode><paramNode><uid v="1000002360"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 7584 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1000000"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002361"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 7744 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="Seed"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002362"/><function v="tofloat"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000002361"/></connection></connections></paramNode><paramNode><uid v="1000002363"/><function v="mul"/><type v="256"/><GUILayout><gpos v="4264 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002351"/></connection><connection><identifier v="b"/><connRef v="1000002355"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="normal_distribution"/><uid v="1000002383"/><attributes><category v=""/><description v="Evaluates the normal_distribution function graph. Result type: Float2. Inputs: radius, uniform_random."/><author v=""/><tags v="Random"/></attributes><paraminputs><paraminput><identifier v="radius"/><uid v="1000002384"/><attributes><label v="radius"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="uniform_random"/><uid v="1000002385"/><attributes><label v="uniform_random"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="512"/><paramValue><dynamicValue><rootnode v="1000002370"/><paramNodes><paramNode><uid v="1000002367"/><function v="log"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002380"/></connection></connections></paramNode><paramNode><uid v="1000002368"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002379"/></connection><connection><identifier v="b"/><connRef v="1000002382"/></connection></connections></paramNode><paramNode><uid v="1000002369"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.25"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002370"/><function v="cartesian"/><type v="512"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="rho"/><connRef v="1000002375"/></connection><connection><identifier v="theta"/><connRef v="1000002368"/></connection></connections></paramNode><paramNode><uid v="1000002371"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002367"/></connection><connection><identifier v="b"/><connRef v="1000002373"/></connection></connections></paramNode><paramNode><uid v="1000002372"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002374"/></connection><connection><identifier v="b"/><connRef v="1000002369"/></connection></connections></paramNode><paramNode><uid v="1000002373"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="-2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002374"/><function v="sqrt"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002371"/></connection></connections></paramNode><paramNode><uid v="1000002375"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002372"/></connection><connection><identifier v="b"/><connRef v="1000002376"/></connection></connections></paramNode><paramNode><uid v="1000002376"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="radius"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002377"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="uniform_random"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002378"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002377"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002379"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002377"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002380"/><function v="max"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002378"/></connection><connection><identifier v="b"/><connRef v="1000002381"/></connection></connections></paramNode><paramNode><uid v="1000002381"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.0001"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002382"/><function v="instance"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/2Pi"/></constantValue></funcData></funcDatas><materialcraftInterface></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="Math"/><uid v="1000002386"/><content><function><identifier v="Ln"/><uid v="1000002392"/><attributes><category v=""/><description v="Evaluates the Ln function graph. Result type: Float. Inputs: a."/><author v=""/><tags v="Maths"/></attributes><paraminputs><paraminput><identifier v="a"/><uid v="1000002393"/><attributes><label v="a"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002389"/><paramNodes><paramNode><uid v="1000002387"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="a"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002388"/><function v="log"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002387"/></connection></connections></paramNode><paramNode><uid v="1000002389"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002388"/></connection><connection><identifier v="b"/><connRef v="1000002391"/></connection></connections></paramNode><paramNode><uid v="1000002390"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002391"/><function v="exp"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002390"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="Pi"/><uid v="1000002395"/><attributes><category v=""/><description v="Evaluates the Pi function graph. Result type: Float. Inputs: none."/><author v=""/><tags v="Constant"/></attributes><paraminputs></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002394"/><paramNodes><paramNode><uid v="1000002394"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="3.1415927"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="2Pi"/><uid v="1000002397"/><attributes><category v=""/><description v="Evaluates the 2Pi function graph. Result type: Float. Inputs: none."/><author v=""/><tags v="Constant"/></attributes><paraminputs></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002396"/><paramNodes><paramNode><uid v="1000002396"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="6.2831855"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="Pow"/><uid v="1000002409"/><attributes><category v=""/><description v="Evaluates the Pow function graph. Result type: Float. Inputs: x, n."/><author v=""/><tags v="Maths"/></attributes><paraminputs><paraminput><identifier v="x"/><uid v="1000002410"/><attributes><label v="x"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="n"/><uid v="1000002411"/><attributes><label v="n"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002407"/><paramNodes><paramNode><uid v="1000002398"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="n"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002399"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="x"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002400"/><function v="pow2"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002402"/></connection></connections></paramNode><paramNode><uid v="1000002401"/><function v="log"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002399"/></connection></connections></paramNode><paramNode><uid v="1000002402"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002405"/></connection><connection><identifier v="b"/><connRef v="1000002398"/></connection></connections></paramNode><paramNode><uid v="1000002403"/><function v="log"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002404"/></connection></connections></paramNode><paramNode><uid v="1000002404"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002405"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002401"/></connection><connection><identifier v="b"/><connRef v="1000002403"/></connection></connections></paramNode><paramNode><uid v="1000002406"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002407"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000002408"/></connection><connection><identifier v="ifpath"/><connRef v="1000002406"/></connection><connection><identifier v="elsepath"/><connRef v="1000002400"/></connection></connections></paramNode><paramNode><uid v="1000002408"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002399"/></connection><connection><identifier v="b"/><connRef v="1000002406"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="Roughness"/><uid v="1000002436"/><attributes><category v=""/><description v="Evaluates the Roughness function graph. Result type: Float. Inputs: Roughness, CurrentLevel, TotalLevel, GlobalOpacity."/><author v=""/><tags v="Various"/></attributes><paraminputs><paraminput><identifier v="Roughness"/><uid v="1000002437"/><attributes><label v="Roughness"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="CurrentLevel"/><uid v="1000002438"/><attributes><label v="CurrentLevel"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="TotalLevel"/><uid v="1000002439"/><attributes><label v="TotalLevel"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput><paraminput><identifier v="GlobalOpacity"/><uid v="1000002440"/><attributes><label v="GlobalOpacity"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002426"/><paramNodes><paramNode><uid v="1000002412"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="Roughness"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002413"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002414"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000002428"/></connection><connection><identifier v="ifpath"/><connRef v="1000002421"/></connection><connection><identifier v="elsepath"/><connRef v="1000002418"/></connection></connections></paramNode><paramNode><uid v="1000002415"/><function v="eq"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002412"/></connection><connection><identifier v="b"/><connRef v="1000002413"/></connection></connections></paramNode><paramNode><uid v="1000002416"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002417"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002418"/><function v="div"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002431"/></connection><connection><identifier v="b"/><connRef v="1000002433"/></connection></connections></paramNode><paramNode><uid v="1000002419"/><function v="sub"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002417"/></connection><connection><identifier v="b"/><connRef v="1000002412"/></connection></connections></paramNode><paramNode><uid v="1000002420"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000002415"/></connection><connection><identifier v="ifpath"/><connRef v="1000002423"/></connection><connection><identifier v="elsepath"/><connRef v="1000002414"/></connection></connections></paramNode><paramNode><uid v="1000002421"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002424"/></connection><connection><identifier v="b"/><connRef v="1000002422"/></connection></connections></paramNode><paramNode><uid v="1000002422"/><function v="tofloat"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000002427"/></connection></connections></paramNode><paramNode><uid v="1000002423"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002424"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002425"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="GlobalOpacity"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002426"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002425"/></connection><connection><identifier v="b"/><connRef v="1000002420"/></connection></connections></paramNode><paramNode><uid v="1000002427"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="TotalLevel"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002428"/><function v="eq"/><type v="4"/><GUILayout><gpos v="344 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002412"/></connection><connection><identifier v="b"/><connRef v="1000002416"/></connection></connections></paramNode><paramNode><uid v="1000002429"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="CurrentLevel"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002430"/><function v="tofloat"/><type v="256"/><GUILayout><gpos v="344 704 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000002429"/></connection></connections></paramNode><paramNode><uid v="1000002431"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002419"/></connection><connection><identifier v="b"/><connRef v="1000002434"/></connection></connections></paramNode><paramNode><uid v="1000002432"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002433"/><function v="sub"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002432"/></connection><connection><identifier v="b"/><connRef v="1000002435"/></connection></connections></paramNode><paramNode><uid v="1000002434"/><function v="pow"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002412"/></connection><connection><identifier v="b"/><connRef v="1000002430"/></connection></connections></paramNode><paramNode><uid v="1000002435"/><function v="pow"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002412"/></connection><connection><identifier v="b"/><connRef v="1000002422"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="Equality_Float2"/><uid v="1000002450"/><attributes><category v=""/><description v="Evaluates the Equality_Float2 function graph. Result type: Boolean. Inputs: A, B."/><author v=""/><tags v="Comparison"/></attributes><paraminputs><paraminput><identifier v="A"/><uid v="1000002451"/><attributes><label v="A"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput><paraminput><identifier v="B"/><uid v="1000002452"/><attributes><label v="B"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput></paraminputs><type v="4"/><paramValue><dynamicValue><rootnode v="1000002449"/><paramNodes><paramNode><uid v="1000002441"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="A"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002442"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="B"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002443"/><function v="eq"/><type v="4"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002444"/></connection><connection><identifier v="b"/><connRef v="1000002445"/></connection></connections></paramNode><paramNode><uid v="1000002444"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002441"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002445"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002442"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002446"/><function v="eq"/><type v="4"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002447"/></connection><connection><identifier v="b"/><connRef v="1000002448"/></connection></connections></paramNode><paramNode><uid v="1000002447"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002441"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002448"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 544 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002442"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002449"/><function v="and"/><type v="4"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002443"/></connection><connection><identifier v="b"/><connRef v="1000002446"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="Equality_Float3"/><uid v="1000002462"/><attributes><category v=""/><description v="Evaluates the Equality_Float3 function graph. Result type: Boolean. Inputs: A, B."/><author v=""/><tags v="Comparison"/></attributes><paraminputs><paraminput><identifier v="A"/><uid v="1000002463"/><attributes><label v="A"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="0 0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput><paraminput><identifier v="B"/><uid v="1000002464"/><attributes><label v="B"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="0 0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput></paraminputs><type v="4"/><paramValue><dynamicValue><rootnode v="1000002461"/><paramNodes><paramNode><uid v="1000002453"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="A"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002454"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="B"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002455"/><function v="swizzle2"/><type v="512"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002453"/></connection></connections><funcDatas><funcData><name v="swizzle2"/><constantValue><constantValueInt2 v="0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002456"/><function v="swizzle2"/><type v="512"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002454"/></connection></connections><funcDatas><funcData><name v="swizzle2"/><constantValue><constantValueInt2 v="0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002457"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002453"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002458"/><function v="instance"/><type v="4"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="A"/><connRef v="1000002455"/></connection><connection><identifier v="B"/><connRef v="1000002456"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Equality_Float2"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="A"/><type v="0"/></input><input><identifier v="B"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000002459"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 544 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002454"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002460"/><function v="eq"/><type v="4"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002457"/></connection><connection><identifier v="b"/><connRef v="1000002459"/></connection></connections></paramNode><paramNode><uid v="1000002461"/><function v="and"/><type v="4"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002458"/></connection><connection><identifier v="b"/><connRef v="1000002460"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="Equality_Boolean"/><uid v="1000002472"/><attributes><category v=""/><description v="Evaluates the Equality_Boolean function graph. Result type: Boolean. Inputs: A, B."/><author v=""/><tags v="Comparison"/></attributes><paraminputs><paraminput><identifier v="A"/><uid v="1000002473"/><attributes><label v="A"/></attributes><type v="4"/><defaultValue><constantValueBool v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="B"/><uid v="1000002474"/><attributes><label v="B"/></attributes><type v="4"/><defaultValue><constantValueBool v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="4"/><paramValue><dynamicValue><rootnode v="1000002468"/><paramNodes><paramNode><uid v="1000002465"/><function v="get_bool"/><type v="4"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_bool"/><constantValue><constantValueString v="A"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002466"/><function v="get_bool"/><type v="4"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_bool"/><constantValue><constantValueString v="B"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002467"/><function v="and"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002465"/></connection><connection><identifier v="b"/><connRef v="1000002466"/></connection></connections></paramNode><paramNode><uid v="1000002468"/><function v="or"/><type v="4"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002467"/></connection><connection><identifier v="b"/><connRef v="1000002471"/></connection></connections></paramNode><paramNode><uid v="1000002469"/><function v="not"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002465"/></connection></connections></paramNode><paramNode><uid v="1000002470"/><function v="not"/><type v="4"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002466"/></connection></connections></paramNode><paramNode><uid v="1000002471"/><function v="and"/><type v="4"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002469"/></connection><connection><identifier v="b"/><connRef v="1000002470"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="Equality_Float4"/><uid v="1000002484"/><attributes><category v=""/><description v="Evaluates the Equality_Float4 function graph. Result type: Boolean. Inputs: A, B."/><author v=""/><tags v="Comparison"/></attributes><paraminputs><paraminput><identifier v="A"/><uid v="1000002485"/><attributes><label v="A"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="0 0 0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput><paraminput><identifier v="B"/><uid v="1000002486"/><attributes><label v="B"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="0 0 0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput></paraminputs><type v="4"/><paramValue><dynamicValue><rootnode v="1000002483"/><paramNodes><paramNode><uid v="1000002475"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="A"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002476"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="B"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002477"/><function v="swizzle2"/><type v="512"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002475"/></connection></connections><funcDatas><funcData><name v="swizzle2"/><constantValue><constantValueInt2 v="0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002478"/><function v="swizzle2"/><type v="512"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002475"/></connection></connections><funcDatas><funcData><name v="swizzle2"/><constantValue><constantValueInt2 v="2 3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002479"/><function v="swizzle2"/><type v="512"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002476"/></connection></connections><funcDatas><funcData><name v="swizzle2"/><constantValue><constantValueInt2 v="0 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002480"/><function v="swizzle2"/><type v="512"/><GUILayout><gpos v="344 544 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002476"/></connection></connections><funcDatas><funcData><name v="swizzle2"/><constantValue><constantValueInt2 v="2 3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002481"/><function v="instance"/><type v="4"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="A"/><connRef v="1000002477"/></connection><connection><identifier v="B"/><connRef v="1000002479"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Equality_Float2"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="A"/><type v="0"/></input><input><identifier v="B"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000002482"/><function v="instance"/><type v="4"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="B"/><connRef v="1000002480"/></connection><connection><identifier v="A"/><connRef v="1000002478"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Equality_Float2"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="B"/><type v="0"/></input><input><identifier v="A"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000002483"/><function v="and"/><type v="4"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002481"/></connection><connection><identifier v="b"/><connRef v="1000002482"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="NotEqual_Float2"/><uid v="1000002491"/><attributes><category v=""/><description v="Evaluates the NotEqual_Float2 function graph. Result type: Boolean. Inputs: A, B."/><author v=""/><tags v="Comparison"/></attributes><paraminputs><paraminput><identifier v="A"/><uid v="1000002492"/><attributes><label v="A"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput><paraminput><identifier v="B"/><uid v="1000002493"/><attributes><label v="B"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput></paraminputs><type v="4"/><paramValue><dynamicValue><rootnode v="1000002490"/><paramNodes><paramNode><uid v="1000002487"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="A"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002488"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="B"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002489"/><function v="instance"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="A"/><connRef v="1000002487"/></connection><connection><identifier v="B"/><connRef v="1000002488"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Equality_Float2"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="A"/><type v="0"/></input><input><identifier v="B"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000002490"/><function v="not"/><type v="4"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002489"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="NotEqual_Float3"/><uid v="1000002498"/><attributes><category v=""/><description v="Evaluates the NotEqual_Float3 function graph. Result type: Boolean. Inputs: A, B."/><author v=""/><tags v="Comparison"/></attributes><paraminputs><paraminput><identifier v="A"/><uid v="1000002499"/><attributes><label v="A"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="0 0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput><paraminput><identifier v="B"/><uid v="1000002500"/><attributes><label v="B"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="0 0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput></paraminputs><type v="4"/><paramValue><dynamicValue><rootnode v="1000002497"/><paramNodes><paramNode><uid v="1000002494"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="A"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002495"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="B"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002496"/><function v="instance"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="A"/><connRef v="1000002494"/></connection><connection><identifier v="B"/><connRef v="1000002495"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Equality_Float3"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="A"/><type v="0"/></input><input><identifier v="B"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000002497"/><function v="not"/><type v="4"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002496"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="NotEqual_Float4"/><uid v="1000002505"/><attributes><category v=""/><description v="Evaluates the NotEqual_Float4 function graph. Result type: Boolean. Inputs: A, B."/><author v=""/><tags v="Comparison"/></attributes><paraminputs><paraminput><identifier v="A"/><uid v="1000002506"/><attributes><label v="A"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="0 0 0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput><paraminput><identifier v="B"/><uid v="1000002507"/><attributes><label v="B"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="0 0 0 0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="-100000000"/></option><option><name v="max"/><value v="100000000"/></option></options></defaultWidget></paraminput></paraminputs><type v="4"/><paramValue><dynamicValue><rootnode v="1000002504"/><paramNodes><paramNode><uid v="1000002501"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="A"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002502"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="B"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002503"/><function v="instance"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="A"/><connRef v="1000002501"/></connection><connection><identifier v="B"/><connRef v="1000002502"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Equality_Float4"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="A"/><type v="0"/></input><input><identifier v="B"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000002504"/><function v="not"/><type v="4"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002503"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="NotEqual_Boolean"/><uid v="1000002512"/><attributes><category v=""/><description v="Evaluates the NotEqual_Boolean function graph. Result type: Boolean. Inputs: A, B."/><author v=""/><tags v="Comparison"/></attributes><paraminputs><paraminput><identifier v="A"/><uid v="1000002513"/><attributes><label v="A"/></attributes><type v="4"/><defaultValue><constantValueBool v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="B"/><uid v="1000002514"/><attributes><label v="B"/></attributes><type v="4"/><defaultValue><constantValueBool v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="4"/><paramValue><dynamicValue><rootnode v="1000002511"/><paramNodes><paramNode><uid v="1000002508"/><function v="get_bool"/><type v="4"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_bool"/><constantValue><constantValueString v="A"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002509"/><function v="get_bool"/><type v="4"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_bool"/><constantValue><constantValueString v="B"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002510"/><function v="instance"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="A"/><connRef v="1000002508"/></connection><connection><identifier v="B"/><connRef v="1000002509"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Equality_Boolean"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="A"/><type v="0"/></input><input><identifier v="B"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000002511"/><function v="not"/><type v="4"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002510"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="Curve_Function"/><uid v="1000002544"/><attributes><category v=""/><description v="Evaluates the Curve_Function function graph. Result type: Float. Inputs: curve, input."/><author v=""/><tags v="Various"/></attributes><paraminputs><paraminput><identifier v="curve"/><uid v="1000002545"/><attributes><label v="curve"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="input"/><uid v="1000002546"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002542"/><paramNodes><paramNode><uid v="1000002515"/><function v="sqrt"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002520"/></connection></connections></paramNode><paramNode><uid v="1000002516"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002517"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="curve"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002518"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002519"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002518"/></connection><connection><identifier v="b"/><connRef v="1000002518"/></connection></connections></paramNode><paramNode><uid v="1000002520"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002516"/></connection><connection><identifier v="b"/><connRef v="1000002519"/></connection></connections></paramNode><paramNode><uid v="1000002521"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002522"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002521"/></connection><connection><identifier v="b"/><connRef v="1000002515"/></connection></connections></paramNode><paramNode><uid v="1000002523"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002522"/></connection><connection><identifier v="b"/><connRef v="1000002517"/></connection></connections></paramNode><paramNode><uid v="1000002524"/><function v="add"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002523"/></connection><connection><identifier v="b"/><connRef v="1000002527"/></connection></connections></paramNode><paramNode><uid v="1000002525"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002526"/><function v="sub"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002525"/></connection><connection><identifier v="b"/><connRef v="1000002517"/></connection></connections></paramNode><paramNode><uid v="1000002527"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002518"/></connection><connection><identifier v="b"/><connRef v="1000002526"/></connection></connections></paramNode><paramNode><uid v="1000002528"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002538"/></connection><connection><identifier v="b"/><connRef v="1000002543"/></connection></connections></paramNode><paramNode><uid v="1000002529"/><function v="add"/><type v="256"/><GUILayout><gpos v="1744 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002533"/></connection><connection><identifier v="b"/><connRef v="1000002528"/></connection></connections></paramNode><paramNode><uid v="1000002530"/><function v="sqrt"/><type v="256"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002537"/></connection></connections></paramNode><paramNode><uid v="1000002531"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002532"/><function v="sub"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002538"/></connection><connection><identifier v="b"/><connRef v="1000002531"/></connection></connections></paramNode><paramNode><uid v="1000002533"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1464 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002530"/></connection><connection><identifier v="b"/><connRef v="1000002539"/></connection></connections></paramNode><paramNode><uid v="1000002534"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002532"/></connection><connection><identifier v="b"/><connRef v="1000002532"/></connection></connections></paramNode><paramNode><uid v="1000002535"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002536"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002537"/><function v="sub"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002536"/></connection><connection><identifier v="b"/><connRef v="1000002534"/></connection></connections></paramNode><paramNode><uid v="1000002538"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 1344 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002539"/><function v="neg"/><type v="256"/><GUILayout><gpos v="344 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002517"/></connection></connections></paramNode><paramNode><uid v="1000002540"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 704 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002517"/></connection><connection><identifier v="b"/><connRef v="1000002541"/></connection></connections></paramNode><paramNode><uid v="1000002541"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1504 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002542"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000002540"/></connection><connection><identifier v="ifpath"/><connRef v="1000002529"/></connection><connection><identifier v="elsepath"/><connRef v="1000002524"/></connection></connections></paramNode><paramNode><uid v="1000002543"/><function v="add"/><type v="256"/><GUILayout><gpos v="344 864 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002535"/></connection><connection><identifier v="b"/><connRef v="1000002517"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="merge_float4"/><uid v="1000002554"/><attributes><category v=""/><description v="Evaluates the merge_float4 function graph. Result type: Float4. Inputs: x, y, z, w."/><author v=""/><tags v="Maths"/></attributes><paraminputs><paraminput><identifier v="x"/><uid v="1000002555"/><attributes><label v="x"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="y"/><uid v="1000002556"/><attributes><label v="y"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="z"/><uid v="1000002557"/><attributes><label v="z"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="w"/><uid v="1000002558"/><attributes><label v="w"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="2048"/><paramValue><dynamicValue><rootnode v="1000002552"/><paramNodes><paramNode><uid v="1000002547"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002548"/></connection><connection><identifier v="componentslast"/><connRef v="1000002549"/></connection></connections></paramNode><paramNode><uid v="1000002548"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="x"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002549"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="y"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002550"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="z"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002551"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002550"/></connection><connection><identifier v="componentslast"/><connRef v="1000002553"/></connection></connections></paramNode><paramNode><uid v="1000002552"/><function v="vector4"/><type v="2048"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002547"/></connection><connection><identifier v="componentslast"/><connRef v="1000002551"/></connection></connections></paramNode><paramNode><uid v="1000002553"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="w"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="merge_float3"/><uid v="1000002564"/><attributes><category v=""/><description v="Evaluates the merge_float3 function graph. Result type: Float3. Inputs: x, y, z."/><author v=""/><tags v="Maths"/></attributes><paraminputs><paraminput><identifier v="x"/><uid v="1000002565"/><attributes><label v="x"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="y"/><uid v="1000002566"/><attributes><label v="y"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="z"/><uid v="1000002567"/><attributes><label v="z"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000002559"/><paramNodes><paramNode><uid v="1000002559"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002560"/></connection><connection><identifier v="componentslast"/><connRef v="1000002563"/></connection></connections></paramNode><paramNode><uid v="1000002560"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002561"/></connection><connection><identifier v="componentslast"/><connRef v="1000002562"/></connection></connections></paramNode><paramNode><uid v="1000002561"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="x"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002562"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="y"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002563"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="z"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="distance_vec3"/><uid v="1000002572"/><attributes><category v=""/><description v="Evaluates the distance_vec3 function graph. Result type: Float. Inputs: a, b."/><author v=""/><tags v="Maths"/></attributes><paraminputs><paraminput><identifier v="a"/><uid v="1000002573"/><attributes><label v="A"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="b"/><uid v="1000002574"/><attributes><label v="B"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002570"/><paramNodes><paramNode><uid v="1000002568"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="a"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002569"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="b"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002570"/><function v="instance"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="input_v"/><connRef v="1000002571"/></connection><connection><identifier v="v"/><connRef v="1000002571"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/length_vec3"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input_v"/><type v="0"/></input><input><identifier v="v"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000002571"/><function v="sub"/><type v="1024"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002569"/></connection><connection><identifier v="b"/><connRef v="1000002568"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="distance_vec2"/><uid v="1000002579"/><attributes><category v=""/><description v="Evaluates the distance_vec2 function graph. Result type: Float. Inputs: a, b."/><author v=""/><tags v="Maths"/></attributes><paraminputs><paraminput><identifier v="a"/><uid v="1000002580"/><attributes><label v="A"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="b"/><uid v="1000002581"/><attributes><label v="B"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002578"/><paramNodes><paramNode><uid v="1000002575"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="a"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002576"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="b"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002577"/><function v="sub"/><type v="512"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002576"/></connection><connection><identifier v="b"/><connRef v="1000002575"/></connection></connections></paramNode><paramNode><uid v="1000002578"/><function v="instance"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="v"/><connRef v="1000002577"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/length_vec2"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="v"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="length_vec2"/><uid v="1000002585"/><attributes><category v=""/><description v="Evaluates the length_vec2 function graph. Result type: Float. Inputs: v."/><author v=""/><tags v="Maths"/></attributes><paraminputs><paraminput><identifier v="v"/><uid v="1000002586"/><attributes><label v="Vector"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002583"/><paramNodes><paramNode><uid v="1000002582"/><function v="dot"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002584"/></connection><connection><identifier v="b"/><connRef v="1000002584"/></connection></connections></paramNode><paramNode><uid v="1000002583"/><function v="sqrt"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002582"/></connection></connections></paramNode><paramNode><uid v="1000002584"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="v"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="length_vec3"/><uid v="1000002590"/><attributes><category v=""/><description v="Evaluates the length_vec3 function graph. Result type: Float. Inputs: v."/><author v=""/><tags v="Maths"/></attributes><paraminputs><paraminput><identifier v="v"/><uid v="1000002591"/><attributes><label v="Vector"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002589"/><paramNodes><paramNode><uid v="1000002587"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="v"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002588"/><function v="dot"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002587"/></connection><connection><identifier v="b"/><connRef v="1000002587"/></connection></connections></paramNode><paramNode><uid v="1000002589"/><function v="sqrt"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002588"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="sign"/><uid v="1000002598"/><attributes><category v=""/><description v="Evaluates the sign function graph. Result type: Float. Inputs: x."/><author v=""/><tags v="Maths"/></attributes><paraminputs><paraminput><identifier v="x"/><uid v="1000002599"/><attributes><label v="X"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002594"/><paramNodes><paramNode><uid v="1000002592"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="x"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002593"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002594"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000002597"/></connection><connection><identifier v="ifpath"/><connRef v="1000002595"/></connection><connection><identifier v="elsepath"/><connRef v="1000002596"/></connection></connections></paramNode><paramNode><uid v="1000002595"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002596"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="-1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002597"/><function v="gteq"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002592"/></connection><connection><identifier v="b"/><connRef v="1000002593"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="reflect"/><uid v="1000002607"/><attributes><category v=""/><description v="Evaluates the reflect function graph. Result type: Float3. Inputs: i, n."/><author v=""/><tags v="Maths"/></attributes><paraminputs><paraminput><identifier v="i"/><uid v="1000002608"/><attributes><label v="Incidence"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="n"/><uid v="1000002609"/><attributes><label v="Normal"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000002602"/><paramNodes><paramNode><uid v="1000002600"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="i"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002601"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="n"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002602"/><function v="sub"/><type v="1024"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002600"/></connection><connection><identifier v="b"/><connRef v="1000002604"/></connection></connections></paramNode><paramNode><uid v="1000002603"/><function v="dot"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002601"/></connection><connection><identifier v="b"/><connRef v="1000002600"/></connection></connections></paramNode><paramNode><uid v="1000002604"/><function v="mulscalar"/><type v="1024"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002605"/></connection><connection><identifier v="scalar"/><connRef v="1000002603"/></connection></connections></paramNode><paramNode><uid v="1000002605"/><function v="mulscalar"/><type v="1024"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002601"/></connection><connection><identifier v="scalar"/><connRef v="1000002606"/></connection></connections></paramNode><paramNode><uid v="1000002606"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="oneminus"/><uid v="1000002613"/><attributes><category v=""/><description v="Evaluates the oneminus function graph. Result type: Float. Inputs: x."/><author v=""/><tags v="Maths"/></attributes><paraminputs><paraminput><identifier v="x"/><uid v="1000002614"/><attributes><label v="X"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002611"/><paramNodes><paramNode><uid v="1000002610"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="x"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002611"/><function v="sub"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002612"/></connection><connection><identifier v="b"/><connRef v="1000002610"/></connection></connections></paramNode><paramNode><uid v="1000002612"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="fmod"/><uid v="1000002626"/><attributes><category v=""/><description v="Evaluates the fmod function graph. Result type: Float. Inputs: a, b."/><author v=""/><tags v="Maths"/></attributes><paraminputs><paraminput><identifier v="a"/><uid v="1000002627"/><attributes><label v="A"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="b"/><uid v="1000002628"/><attributes><label v="B"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002622"/><paramNodes><paramNode><uid v="1000002615"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="a"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002616"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="b"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002617"/><function v="instance"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000002619"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/frac"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000002618"/><function v="div"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002615"/></connection><connection><identifier v="b"/><connRef v="1000002616"/></connection></connections></paramNode><paramNode><uid v="1000002619"/><function v="abs"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002618"/></connection></connections></paramNode><paramNode><uid v="1000002620"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002617"/></connection><connection><identifier v="b"/><connRef v="1000002621"/></connection></connections></paramNode><paramNode><uid v="1000002621"/><function v="abs"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002616"/></connection></connections></paramNode><paramNode><uid v="1000002622"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000002623"/></connection><connection><identifier v="ifpath"/><connRef v="1000002625"/></connection><connection><identifier v="elsepath"/><connRef v="1000002620"/></connection></connections></paramNode><paramNode><uid v="1000002623"/><function v="lr"/><type v="4"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002615"/></connection><connection><identifier v="b"/><connRef v="1000002624"/></connection></connections></paramNode><paramNode><uid v="1000002624"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002625"/><function v="neg"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002620"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="frac"/><uid v="1000002632"/><attributes><category v=""/><description v="Evaluates the frac function graph. Result type: Float. Inputs: input."/><author v=""/><tags v="Maths"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000002633"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002630"/><paramNodes><paramNode><uid v="1000002629"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002630"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002629"/></connection><connection><identifier v="b"/><connRef v="1000002631"/></connection></connections></paramNode><paramNode><uid v="1000002631"/><function v="floor"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002629"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="cross_product"/><uid v="1000002643"/><attributes><category v=""/><description v="Evaluates the cross_product function graph. Result type: Float3. Inputs: a, b."/><author v=""/><tags v="Maths"/></attributes><paraminputs><paraminput><identifier v="a"/><uid v="1000002644"/><attributes><label v="A"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="b"/><uid v="1000002645"/><attributes><label v="B"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000002638"/><paramNodes><paramNode><uid v="1000002634"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="a"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002635"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="b"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002636"/><function v="mul"/><type v="1024"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002637"/></connection><connection><identifier v="b"/><connRef v="1000002639"/></connection></connections></paramNode><paramNode><uid v="1000002637"/><function v="swizzle3"/><type v="1024"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002634"/></connection></connections><funcDatas><funcData><name v="swizzle3"/><constantValue><constantValueInt3 v="1 2 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002638"/><function v="sub"/><type v="1024"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002636"/></connection><connection><identifier v="b"/><connRef v="1000002641"/></connection></connections></paramNode><paramNode><uid v="1000002639"/><function v="swizzle3"/><type v="1024"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002635"/></connection></connections><funcDatas><funcData><name v="swizzle3"/><constantValue><constantValueInt3 v="2 0 1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002640"/><function v="swizzle3"/><type v="1024"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002634"/></connection></connections><funcDatas><funcData><name v="swizzle3"/><constantValue><constantValueInt3 v="2 0 1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002641"/><function v="mul"/><type v="1024"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002640"/></connection><connection><identifier v="b"/><connRef v="1000002642"/></connection></connections></paramNode><paramNode><uid v="1000002642"/><function v="swizzle3"/><type v="1024"/><GUILayout><gpos v="344 544 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002635"/></connection></connections><funcDatas><funcData><name v="swizzle3"/><constantValue><constantValueInt3 v="1 2 0"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="cross_product_vec2"/><uid v="1000002657"/><attributes><category v="Function"/><description v="Evaluates the cross_product_vec2 function graph. Result type: Float. Inputs: a, b."/><author v=""/><tags v="Maths"/></attributes><paraminputs><paraminput><identifier v="a"/><uid v="1000002658"/><attributes><label v="a"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="b"/><uid v="1000002659"/><attributes><label v="b"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002653"/><paramNodes><paramNode><uid v="1000002646"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002651"/></connection><connection><identifier v="b"/><connRef v="1000002650"/></connection></connections></paramNode><paramNode><uid v="1000002647"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002648"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002648"/><function v="passthrough"/><type v="512"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000002655"/></connection></connections></paramNode><paramNode><uid v="1000002649"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002652"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002650"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002648"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002651"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="624 544 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002652"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002652"/><function v="passthrough"/><type v="512"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000002656"/></connection></connections></paramNode><paramNode><uid v="1000002653"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002654"/></connection><connection><identifier v="b"/><connRef v="1000002646"/></connection></connections></paramNode><paramNode><uid v="1000002654"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002649"/></connection><connection><identifier v="b"/><connRef v="1000002647"/></connection></connections></paramNode><paramNode><uid v="1000002655"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="a"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002656"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="b"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="step"/><uid v="1000002666"/><attributes><category v=""/><description v="Evaluates the step function graph. Result type: Float. Inputs: a, x."/><author v=""/><tags v="Maths"/></attributes><paraminputs><paraminput><identifier v="a"/><uid v="1000002667"/><attributes><label v="A"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="x"/><uid v="1000002668"/><attributes><label v="X"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002663"/><paramNodes><paramNode><uid v="1000002660"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="a"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002661"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="x"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002662"/><function v="gteq"/><type v="4"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002661"/></connection><connection><identifier v="b"/><connRef v="1000002660"/></connection></connections></paramNode><paramNode><uid v="1000002663"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000002662"/></connection><connection><identifier v="ifpath"/><connRef v="1000002664"/></connection><connection><identifier v="elsepath"/><connRef v="1000002665"/></connection></connections></paramNode><paramNode><uid v="1000002664"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002665"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="divide_float4"/><uid v="1000002682"/><attributes><category v=""/><description v="Evaluates the divide_float4 function graph. Result type: Float4. Inputs: input, scalar."/><author v=""/><tags v="Maths"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000002683"/><attributes><label v="input"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="scalar"/><uid v="1000002684"/><attributes><label v="scalar"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="2048"/><paramValue><dynamicValue><rootnode v="1000002681"/><paramNodes><paramNode><uid v="1000002669"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002670"/></connection><connection><identifier v="b"/><connRef v="1000002673"/></connection></connections></paramNode><paramNode><uid v="1000002670"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002679"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002671"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002679"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002672"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002671"/></connection><connection><identifier v="b"/><connRef v="1000002673"/></connection></connections></paramNode><paramNode><uid v="1000002673"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="scalar"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002674"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002669"/></connection><connection><identifier v="componentslast"/><connRef v="1000002672"/></connection></connections></paramNode><paramNode><uid v="1000002675"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002676"/></connection><connection><identifier v="b"/><connRef v="1000002673"/></connection></connections></paramNode><paramNode><uid v="1000002676"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002679"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002677"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 544 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002678"/></connection><connection><identifier v="b"/><connRef v="1000002673"/></connection></connections></paramNode><paramNode><uid v="1000002678"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 544 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002679"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002679"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002680"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002675"/></connection><connection><identifier v="componentslast"/><connRef v="1000002677"/></connection></connections></paramNode><paramNode><uid v="1000002681"/><function v="vector4"/><type v="2048"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002674"/></connection><connection><identifier v="componentslast"/><connRef v="1000002680"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="divide_float3"/><uid v="1000002695"/><attributes><category v=""/><description v="Evaluates the divide_float3 function graph. Result type: Float3. Inputs: input, scalar."/><author v=""/><tags v="Maths"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000002696"/><attributes><label v="input"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="scalar"/><uid v="1000002697"/><attributes><label v="scalar"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000002694"/><paramNodes><paramNode><uid v="1000002685"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002686"/></connection><connection><identifier v="b"/><connRef v="1000002689"/></connection></connections></paramNode><paramNode><uid v="1000002686"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002693"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002687"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002693"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002688"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002687"/></connection><connection><identifier v="b"/><connRef v="1000002689"/></connection></connections></paramNode><paramNode><uid v="1000002689"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="scalar"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002690"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002685"/></connection><connection><identifier v="componentslast"/><connRef v="1000002688"/></connection></connections></paramNode><paramNode><uid v="1000002691"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 384 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002692"/></connection><connection><identifier v="b"/><connRef v="1000002689"/></connection></connections></paramNode><paramNode><uid v="1000002692"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 384 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002693"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002693"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002694"/><function v="vector3"/><type v="1024"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002690"/></connection><connection><identifier v="componentslast"/><connRef v="1000002691"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="divide_float2"/><uid v="1000002705"/><attributes><category v=""/><description v="Evaluates the divide_float2 function graph. Result type: Float2. Inputs: input, scalar."/><author v=""/><tags v="Maths"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000002706"/><attributes><label v="input"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="scalar"/><uid v="1000002707"/><attributes><label v="scalar"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="512"/><paramValue><dynamicValue><rootnode v="1000002704"/><paramNodes><paramNode><uid v="1000002698"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002699"/></connection><connection><identifier v="b"/><connRef v="1000002703"/></connection></connections></paramNode><paramNode><uid v="1000002699"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002700"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002700"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002701"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002700"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002702"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002701"/></connection><connection><identifier v="b"/><connRef v="1000002703"/></connection></connections></paramNode><paramNode><uid v="1000002703"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="scalar"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002704"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002698"/></connection><connection><identifier v="componentslast"/><connRef v="1000002702"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="clamp"/><uid v="1000002713"/><attributes><category v=""/><description v="Evaluates the clamp function graph. Result type: Float. Inputs: input, min, max."/><author v=""/><tags v="Maths"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000002714"/><attributes><label v="Input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="min"/><uid v="1000002715"/><attributes><label v="Min"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="max"/><uid v="1000002716"/><attributes><label v="Max"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002711"/><paramNodes><paramNode><uid v="1000002708"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002709"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="max"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002710"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="min"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002711"/><function v="max"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002710"/></connection><connection><identifier v="b"/><connRef v="1000002712"/></connection></connections></paramNode><paramNode><uid v="1000002712"/><function v="min"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002708"/></connection><connection><identifier v="b"/><connRef v="1000002709"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="normalize_vec2"/><uid v="1000002723"/><attributes><category v=""/><description v="Evaluates the normalize_vec2 function graph. Result type: Float2. Inputs: input."/><author v=""/><tags v="Maths"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000002724"/><attributes><label v="input"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="512"/><paramValue><dynamicValue><rootnode v="1000002722"/><paramNodes><paramNode><uid v="1000002717"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002718"/><function v="dot"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002717"/></connection><connection><identifier v="b"/><connRef v="1000002717"/></connection></connections></paramNode><paramNode><uid v="1000002719"/><function v="sqrt"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002718"/></connection></connections></paramNode><paramNode><uid v="1000002720"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002721"/><function v="div"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002720"/></connection><connection><identifier v="b"/><connRef v="1000002719"/></connection></connections></paramNode><paramNode><uid v="1000002722"/><function v="mulscalar"/><type v="512"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002717"/></connection><connection><identifier v="scalar"/><connRef v="1000002721"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="normalize_vec3"/><uid v="1000002731"/><attributes><category v=""/><description v="Evaluates the normalize_vec3 function graph. Result type: Float3. Inputs: input."/><author v=""/><tags v="Maths"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000002732"/><attributes><label v="input"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000002729"/><paramNodes><paramNode><uid v="1000002725"/><function v="dot"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002730"/></connection><connection><identifier v="b"/><connRef v="1000002730"/></connection></connections></paramNode><paramNode><uid v="1000002726"/><function v="sqrt"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002725"/></connection></connections></paramNode><paramNode><uid v="1000002727"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002728"/><function v="div"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002727"/></connection><connection><identifier v="b"/><connRef v="1000002726"/></connection></connections></paramNode><paramNode><uid v="1000002729"/><function v="mulscalar"/><type v="1024"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002730"/></connection><connection><identifier v="scalar"/><connRef v="1000002728"/></connection></connections></paramNode><paramNode><uid v="1000002730"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="normalize_vec4"/><uid v="1000002739"/><attributes><category v=""/><description v="Evaluates the normalize_vec4 function graph. Result type: Float4. Inputs: input."/><author v=""/><tags v="Maths"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000002740"/><attributes><label v="input"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="2048"/><paramValue><dynamicValue><rootnode v="1000002737"/><paramNodes><paramNode><uid v="1000002733"/><function v="dot"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002738"/></connection><connection><identifier v="b"/><connRef v="1000002738"/></connection></connections></paramNode><paramNode><uid v="1000002734"/><function v="sqrt"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002733"/></connection></connections></paramNode><paramNode><uid v="1000002735"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002736"/><function v="div"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002735"/></connection><connection><identifier v="b"/><connRef v="1000002734"/></connection></connections></paramNode><paramNode><uid v="1000002737"/><function v="mulscalar"/><type v="2048"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002738"/></connection><connection><identifier v="scalar"/><connRef v="1000002736"/></connection></connections></paramNode><paramNode><uid v="1000002738"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="smoothstep"/><uid v="1000002754"/><attributes><category v=""/><description v="Evaluates the smoothstep function graph. Result type: Float. Inputs: a, b, x."/><author v=""/><tags v="Maths"/></attributes><paraminputs><paraminput><identifier v="a"/><uid v="1000002755"/><attributes><label v="A"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="b"/><uid v="1000002756"/><attributes><label v="B"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="x"/><uid v="1000002757"/><attributes><label v="X"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002748"/><paramNodes><paramNode><uid v="1000002741"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="x"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002742"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="a"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002743"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="b"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002744"/><function v="sub"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002741"/></connection><connection><identifier v="b"/><connRef v="1000002742"/></connection></connections></paramNode><paramNode><uid v="1000002745"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002744"/></connection><connection><identifier v="b"/><connRef v="1000002746"/></connection></connections></paramNode><paramNode><uid v="1000002746"/><function v="sub"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002743"/></connection><connection><identifier v="b"/><connRef v="1000002742"/></connection></connections></paramNode><paramNode><uid v="1000002747"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002753"/></connection><connection><identifier v="b"/><connRef v="1000002753"/></connection></connections></paramNode><paramNode><uid v="1000002748"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002747"/></connection><connection><identifier v="b"/><connRef v="1000002750"/></connection></connections></paramNode><paramNode><uid v="1000002749"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="3"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002750"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002749"/></connection><connection><identifier v="b"/><connRef v="1000002752"/></connection></connections></paramNode><paramNode><uid v="1000002751"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002752"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002751"/></connection><connection><identifier v="b"/><connRef v="1000002753"/></connection></connections></paramNode><paramNode><uid v="1000002753"/><function v="instance"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000002745"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/saturate"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input"/><type v="0"/></input></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="saturate_float2"/><uid v="1000002764"/><attributes><category v=""/><description v="Evaluates the saturate_float2 function graph. Result type: Float2. Inputs: input."/><author v=""/><tags v="Maths"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000002765"/><attributes><label v="input"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="512"/><paramValue><dynamicValue><rootnode v="1000002758"/><paramNodes><paramNode><uid v="1000002758"/><function v="vector2"/><type v="512"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="componentsin"/><connRef v="1000002760"/></connection><connection><identifier v="componentslast"/><connRef v="1000002759"/></connection></connections></paramNode><paramNode><uid v="1000002759"/><function v="instance"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000002761"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/saturate"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000002760"/><function v="instance"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="input"/><connRef v="1000002762"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/saturate"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="input"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000002761"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002763"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002762"/><function v="swizzle1"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002763"/></connection></connections><funcDatas><funcData><name v="swizzle1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002763"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="average_float1"/><uid v="1000002771"/><attributes><category v="Function"/><description v="Evaluates the average_float1 function graph. Result type: Float. Inputs: a, b."/><author v=""/><tags v="Maths"/></attributes><paraminputs><paraminput><identifier v="a"/><uid v="1000002772"/><attributes><label v="A"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="b"/><uid v="1000002773"/><attributes><label v="B"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002770"/><paramNodes><paramNode><uid v="1000002766"/><function v="add"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002768"/></connection><connection><identifier v="b"/><connRef v="1000002769"/></connection></connections></paramNode><paramNode><uid v="1000002767"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002768"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="a"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002769"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="b"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002770"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002766"/></connection><connection><identifier v="b"/><connRef v="1000002767"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="average_float2"/><uid v="1000002779"/><attributes><category v="Function"/><description v="Evaluates the average_float2 function graph. Result type: Float2. Inputs: a, b."/><author v=""/><tags v="Maths"/></attributes><paraminputs><paraminput><identifier v="a"/><uid v="1000002780"/><attributes><label v="a"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="b"/><uid v="1000002781"/><attributes><label v="b"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="512"/><paramValue><dynamicValue><rootnode v="1000002777"/><paramNodes><paramNode><uid v="1000002774"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="a"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002775"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="b"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002776"/><function v="add"/><type v="512"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002774"/></connection><connection><identifier v="b"/><connRef v="1000002775"/></connection></connections></paramNode><paramNode><uid v="1000002777"/><function v="mulscalar"/><type v="512"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002776"/></connection><connection><identifier v="scalar"/><connRef v="1000002778"/></connection></connections></paramNode><paramNode><uid v="1000002778"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="average_float3"/><uid v="1000002787"/><attributes><category v="Function"/><description v="Evaluates the average_float3 function graph. Result type: Float3. Inputs: a, b."/><author v=""/><tags v="Maths"/></attributes><paraminputs><paraminput><identifier v="a"/><uid v="1000002788"/><attributes><label v="a"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="b"/><uid v="1000002789"/><attributes><label v="b"/></attributes><type v="1024"/><defaultValue><constantValueFloat3 v="1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="1024"/><paramValue><dynamicValue><rootnode v="1000002783"/><paramNodes><paramNode><uid v="1000002782"/><function v="add"/><type v="1024"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002785"/></connection><connection><identifier v="b"/><connRef v="1000002786"/></connection></connections></paramNode><paramNode><uid v="1000002783"/><function v="mulscalar"/><type v="1024"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002782"/></connection><connection><identifier v="scalar"/><connRef v="1000002784"/></connection></connections></paramNode><paramNode><uid v="1000002784"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002785"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="a"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002786"/><function v="get_float3"/><type v="1024"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float3"/><constantValue><constantValueString v="b"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="average_float4"/><uid v="1000002795"/><attributes><category v="Function"/><description v="Evaluates the average_float4 function graph. Result type: Float4. Inputs: a, b."/><author v=""/><tags v="Maths"/></attributes><paraminputs><paraminput><identifier v="a"/><uid v="1000002796"/><attributes><label v="a"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="b"/><uid v="1000002797"/><attributes><label v="b"/></attributes><type v="2048"/><defaultValue><constantValueFloat4 v="1 1 1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="2048"/><paramValue><dynamicValue><rootnode v="1000002791"/><paramNodes><paramNode><uid v="1000002790"/><function v="add"/><type v="2048"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002793"/></connection><connection><identifier v="b"/><connRef v="1000002794"/></connection></connections></paramNode><paramNode><uid v="1000002791"/><function v="mulscalar"/><type v="2048"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002790"/></connection><connection><identifier v="scalar"/><connRef v="1000002792"/></connection></connections></paramNode><paramNode><uid v="1000002792"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002793"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="a"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002794"/><function v="get_float4"/><type v="2048"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float4"/><constantValue><constantValueString v="b"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="orthogonal_vec2"/><uid v="1000002802"/><attributes><category v="Function"/><description v="Evaluates the orthogonal_vec2 function graph. Result type: Float2. Inputs: input."/><author v=""/><tags v="Maths"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000002803"/><attributes><label v="input"/></attributes><type v="512"/><defaultValue><constantValueFloat2 v="1 1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="512"/><paramValue><dynamicValue><rootnode v="1000002798"/><paramNodes><paramNode><uid v="1000002798"/><function v="mul"/><type v="512"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002799"/></connection><connection><identifier v="b"/><connRef v="1000002800"/></connection></connections></paramNode><paramNode><uid v="1000002799"/><function v="swizzle2"/><type v="512"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="vector"/><connRef v="1000002801"/></connection></connections><funcDatas><funcData><name v="swizzle2"/><constantValue><constantValueInt2 v="1 0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002800"/><function v="const_float2"/><type v="512"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float2"/><constantValue><constantValueFloat2 v="1 -1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002801"/><function v="get_float2"/><type v="512"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float2"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="saturate"/><uid v="1000002809"/><attributes><category v=""/><description v="Evaluates the saturate function graph. Result type: Float. Inputs: input."/><author v=""/><tags v="Maths"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000002810"/><attributes><label v="Input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002808"/><paramNodes><paramNode><uid v="1000002804"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002805"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002806"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002807"/><function v="min"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002805"/></connection><connection><identifier v="b"/><connRef v="1000002806"/></connection></connections></paramNode><paramNode><uid v="1000002808"/><function v="max"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002804"/></connection><connection><identifier v="b"/><connRef v="1000002807"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="truncate_float1_decimals"/><uid v="1000002822"/><attributes><category v=""/><description v="Evaluates the truncate_float1_decimals function graph. Result type: Float. Inputs: input, decimals."/><author v=""/><tags v="Maths"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000002823"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput><paraminput><identifier v="decimals"/><uid v="1000002824"/><attributes><label v="decimals"/></attributes><type v="16"/><defaultValue><constantValueInt32 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="10"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002819"/><paramNodes><paramNode><uid v="1000002811"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002812"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002811"/></connection><connection><identifier v="b"/><connRef v="1000002817"/></connection></connections></paramNode><paramNode><uid v="1000002813"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="10"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002814"/><function v="floor"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002812"/></connection></connections></paramNode><paramNode><uid v="1000002815"/><function v="div"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002814"/></connection><connection><identifier v="b"/><connRef v="1000002817"/></connection></connections></paramNode><paramNode><uid v="1000002816"/><function v="get_integer1"/><type v="16"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_integer1"/><constantValue><constantValueString v="decimals"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002817"/><function v="instance"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="n"/><connRef v="1000002818"/></connection><connection><identifier v="x"/><connRef v="1000002813"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Pow"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="n"/><type v="0"/></input><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000002818"/><function v="tofloat"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="value"/><connRef v="1000002816"/></connection></connections></paramNode><paramNode><uid v="1000002819"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000002820"/></connection><connection><identifier v="ifpath"/><connRef v="1000002811"/></connection><connection><identifier v="elsepath"/><connRef v="1000002815"/></connection></connections></paramNode><paramNode><uid v="1000002820"/><function v="lreq"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002816"/></connection><connection><identifier v="b"/><connRef v="1000002821"/></connection></connections></paramNode><paramNode><uid v="1000002821"/><function v="const_int1"/><type v="16"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_int1"/><constantValue><constantValueInt32 v="0"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="round_float1"/><uid v="1000002829"/><attributes><category v=""/><description v="Evaluates the round_float1 function graph. Result type: Float. Inputs: input."/><author v=""/><tags v="Maths"/></attributes><paraminputs><paraminput><identifier v="input"/><uid v="1000002830"/><attributes><label v="input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002828"/><paramNodes><paramNode><uid v="1000002825"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002826"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002827"/><function v="add"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002825"/></connection><connection><identifier v="b"/><connRef v="1000002826"/></connection></connections></paramNode><paramNode><uid v="1000002828"/><function v="floor"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002827"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><group><identifier v="Parity"/><uid v="1000002831"/><content><function><identifier v="EvenCount"/><uid v="1000002837"/><attributes><category v=""/><description v="Evaluates the EvenCount function graph. Result type: Float. Inputs: Input."/><author v=""/><tags v="Parity"/></attributes><paraminputs><paraminput><identifier v="Input"/><uid v="1000002838"/><attributes><label v="Input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002836"/><paramNodes><paramNode><uid v="1000002832"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="Input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002833"/><function v="floor"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002832"/></connection></connections></paramNode><paramNode><uid v="1000002834"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002835"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002833"/></connection><connection><identifier v="b"/><connRef v="1000002834"/></connection></connections></paramNode><paramNode><uid v="1000002836"/><function v="ceil"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002835"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="OddCount"/><uid v="1000002844"/><attributes><category v=""/><description v="Evaluates the OddCount function graph. Result type: Float. Inputs: Input."/><author v=""/><tags v="Parity"/></attributes><paraminputs><paraminput><identifier v="Input"/><uid v="1000002845"/><attributes><label v="Input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002843"/><paramNodes><paramNode><uid v="1000002839"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="Input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002840"/><function v="floor"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002839"/></connection></connections></paramNode><paramNode><uid v="1000002841"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="2"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002842"/><function v="div"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002840"/></connection><connection><identifier v="b"/><connRef v="1000002841"/></connection></connections></paramNode><paramNode><uid v="1000002843"/><function v="floor"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002842"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="ParityTest"/><uid v="1000002856"/><attributes><category v=""/><description v="Evaluates the ParityTest function graph. Result type: Boolean. Inputs: Input."/><author v=""/><tags v="Parity"/></attributes><paraminputs><paraminput><identifier v="Input"/><uid v="1000002857"/><attributes><label v="Input"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="4"/><paramValue><dynamicValue><rootnode v="1000002846"/><paramNodes><paramNode><uid v="1000002846"/><function v="gt"/><type v="4"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002855"/></connection><connection><identifier v="b"/><connRef v="1000002854"/></connection></connections></paramNode><paramNode><uid v="1000002847"/><function v="floor"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002848"/></connection></connections></paramNode><paramNode><uid v="1000002848"/><function v="mul"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002851"/></connection><connection><identifier v="b"/><connRef v="1000002849"/></connection></connections></paramNode><paramNode><uid v="1000002849"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.25"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002850"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002851"/><function v="add"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002853"/></connection><connection><identifier v="b"/><connRef v="1000002850"/></connection></connections></paramNode><paramNode><uid v="1000002852"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="Input"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002853"/><function v="add"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002852"/></connection><connection><identifier v="b"/><connRef v="1000002852"/></connection></connections></paramNode><paramNode><uid v="1000002854"/><function v="sub"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002848"/></connection><connection><identifier v="b"/><connRef v="1000002847"/></connection></connections></paramNode><paramNode><uid v="1000002855"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group><group><identifier v="Trigo"/><uid v="1000002858"/><content><function><identifier v="deg_to_rad"/><uid v="1000002864"/><attributes><category v=""/><description v="Evaluates the deg_to_rad function graph. Result type: Float. Inputs: deg."/><author v=""/><tags v="Conversion"/></attributes><paraminputs><paraminput><identifier v="deg"/><uid v="1000002865"/><attributes><label v="deg"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="0"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002862"/><paramNodes><paramNode><uid v="1000002859"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="deg"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002860"/><function v="div"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002863"/></connection><connection><identifier v="b"/><connRef v="1000002861"/></connection></connections></paramNode><paramNode><uid v="1000002861"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="180"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002862"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002859"/></connection><connection><identifier v="b"/><connRef v="1000002860"/></connection></connections></paramNode><paramNode><uid v="1000002863"/><function v="instance"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Pi"/></constantValue></funcData></funcDatas><materialcraftInterface></materialcraftInterface></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="asin"/><uid v="1000002888"/><attributes><category v=""/><description v="Evaluates the asin function graph. Result type: Float. Inputs: x."/><author v=""/><tags v="Maths"/></attributes><paraminputs><paraminput><identifier v="x"/><uid v="1000002889"/><attributes><label v="x"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002884"/><paramNodes><paramNode><uid v="1000002866"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="-0.0187293"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002867"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1.5707288"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002868"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.074261"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002869"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 544 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="-0.2121144"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002870"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 704 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="x"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002871"/><function v="abs"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002870"/></connection></connections></paramNode><paramNode><uid v="1000002872"/><function v="mul"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002871"/></connection><connection><identifier v="b"/><connRef v="1000002866"/></connection></connections></paramNode><paramNode><uid v="1000002873"/><function v="add"/><type v="256"/><GUILayout><gpos v="904 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002872"/></connection><connection><identifier v="b"/><connRef v="1000002868"/></connection></connections></paramNode><paramNode><uid v="1000002874"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1184 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002871"/></connection><connection><identifier v="b"/><connRef v="1000002873"/></connection></connections></paramNode><paramNode><uid v="1000002875"/><function v="add"/><type v="256"/><GUILayout><gpos v="1464 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002874"/></connection><connection><identifier v="b"/><connRef v="1000002869"/></connection></connections></paramNode><paramNode><uid v="1000002876"/><function v="mul"/><type v="256"/><GUILayout><gpos v="1744 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002871"/></connection><connection><identifier v="b"/><connRef v="1000002875"/></connection></connections></paramNode><paramNode><uid v="1000002877"/><function v="add"/><type v="256"/><GUILayout><gpos v="2024 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002876"/></connection><connection><identifier v="b"/><connRef v="1000002867"/></connection></connections></paramNode><paramNode><uid v="1000002878"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002879"/></connection><connection><identifier v="b"/><connRef v="1000002871"/></connection></connections></paramNode><paramNode><uid v="1000002879"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 864 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002880"/><function v="sqrt"/><type v="256"/><GUILayout><gpos v="904 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002878"/></connection></connections></paramNode><paramNode><uid v="1000002881"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1024 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="1.5707964"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002882"/><function v="mul"/><type v="256"/><GUILayout><gpos v="2304 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002880"/></connection><connection><identifier v="b"/><connRef v="1000002877"/></connection></connections></paramNode><paramNode><uid v="1000002883"/><function v="sub"/><type v="256"/><GUILayout><gpos v="2584 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002881"/></connection><connection><identifier v="b"/><connRef v="1000002882"/></connection></connections></paramNode><paramNode><uid v="1000002884"/><function v="ifelse"/><type v="256"/><GUILayout><gpos v="2864 64 0"/></GUILayout><connections><connection><identifier v="condition"/><connRef v="1000002885"/></connection><connection><identifier v="ifpath"/><connRef v="1000002883"/></connection><connection><identifier v="elsepath"/><connRef v="1000002887"/></connection></connections></paramNode><paramNode><uid v="1000002885"/><function v="gteq"/><type v="4"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002870"/></connection><connection><identifier v="b"/><connRef v="1000002886"/></connection></connections></paramNode><paramNode><uid v="1000002886"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 1184 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002887"/><function v="sub"/><type v="256"/><GUILayout><gpos v="2584 224 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002882"/></connection><connection><identifier v="b"/><connRef v="1000002881"/></connection></connections></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function><function><identifier v="acos"/><uid v="1000002896"/><attributes><category v=""/><description v="Evaluates the acos function graph. Result type: Float. Inputs: x."/><author v=""/><tags v="Maths"/></attributes><paraminputs><paraminput><identifier v="x"/><uid v="1000002897"/><attributes><label v="x"/></attributes><type v="256"/><defaultValue><constantValueFloat1 v="1"/></defaultValue><defaultWidget><name v="slider"/><options><option><name v="min"/><value v="0"/></option><option><name v="max"/><value v="1"/></option></options></defaultWidget></paraminput></paraminputs><type v="256"/><paramValue><dynamicValue><rootnode v="1000002891"/><paramNodes><paramNode><uid v="1000002890"/><function v="get_float1"/><type v="256"/><GUILayout><gpos v="64 64 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="get_float1"/><constantValue><constantValueString v="x"/></constantValue></funcData></funcDatas></paramNode><paramNode><uid v="1000002891"/><function v="sub"/><type v="256"/><GUILayout><gpos v="624 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002892"/></connection><connection><identifier v="b"/><connRef v="1000002893"/></connection></connections></paramNode><paramNode><uid v="1000002892"/><function v="mul"/><type v="256"/><GUILayout><gpos v="344 64 0"/></GUILayout><connections><connection><identifier v="a"/><connRef v="1000002894"/></connection><connection><identifier v="b"/><connRef v="1000002895"/></connection></connections></paramNode><paramNode><uid v="1000002893"/><function v="instance"/><type v="256"/><GUILayout><gpos v="344 224 0"/></GUILayout><connections><connection><identifier v="x"/><connRef v="1000002890"/></connection></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Trigo/asin"/></constantValue></funcData></funcDatas><materialcraftInterface><input><identifier v="x"/><type v="0"/></input></materialcraftInterface></paramNode><paramNode><uid v="1000002894"/><function v="instance"/><type v="256"/><GUILayout><gpos v="64 224 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="instance"/><constantValue><constantValueString v="pkg:///Functions/Math/Pi"/></constantValue></funcData></funcDatas><materialcraftInterface></materialcraftInterface></paramNode><paramNode><uid v="1000002895"/><function v="const_float1"/><type v="256"/><GUILayout><gpos v="64 384 0"/></GUILayout><connections></connections><funcDatas><funcData><name v="const_float1"/><constantValue><constantValueFloat1 v="0.5"/></constantValue></funcData></funcDatas></paramNode></paramNodes><GUIObjects></GUIObjects></dynamicValue></paramValue></function></content></group></content></group></content></group></content></package> diff --git a/crates/core/src/canvas_annotations.rs b/crates/core/src/canvas_annotations.rs new file mode 100644 index 0000000..93b3af6 --- /dev/null +++ b/crates/core/src/canvas_annotations.rs @@ -0,0 +1,32 @@ +use crate::{Comment, Frame, Pin}; +use serde::{Deserialize, Serialize}; + +/// Editable helpers belonging to one embedded graph canvas. +#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] +pub struct CanvasAnnotations { + #[serde(default)] + pub frames: Vec<Frame>, + #[serde(default)] + pub comments: Vec<Comment>, + #[serde(default)] + pub pins: Vec<Pin>, +} + +impl CanvasAnnotations { + /// Whether the canvas has no frames, comments or pins. + pub fn is_empty(&self) -> bool { + self.frames.is_empty() && self.comments.is_empty() && self.pins.is_empty() + } + + /// The next annotation id, or none when all ids have been exhausted. + pub fn next_id(&self) -> Option<u64> { + self.frames + .iter() + .map(|frame| frame.id) + .chain(self.comments.iter().map(|comment| comment.id)) + .chain(self.pins.iter().map(|pin| pin.id)) + .max() + .unwrap_or(0) + .checked_add(1) + } +} diff --git a/crates/core/src/function_graph.rs b/crates/core/src/function_graph.rs index c3f43bc..84addc0 100644 --- a/crates/core/src/function_graph.rs +++ b/crates/core/src/function_graph.rs @@ -6,6 +6,8 @@ use crate::FunctionNode; #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] pub struct FunctionGraph { + #[serde(default, skip_serializing_if = "crate::CanvasAnnotations::is_empty")] + pub annotations: crate::CanvasAnnotations, pub nodes: Vec<FunctionNode>, #[serde(default)] pub output: Option<u32>, diff --git a/crates/core/src/lib.rs b/crates/core/src/lib.rs index 1810508..b02cfa3 100644 --- a/crates/core/src/lib.rs +++ b/crates/core/src/lib.rs @@ -3,6 +3,7 @@ mod attributes; mod base_parameters; +mod canvas_annotations; mod color; mod comment; mod component_usage; @@ -33,6 +34,7 @@ mod pattern_graph; mod pattern_node; mod pattern_node_kind; mod pin; +pub use canvas_annotations::CanvasAnnotations; mod preset; mod resource; mod resource_bytes; diff --git a/crates/core/src/pattern_graph.rs b/crates/core/src/pattern_graph.rs index d0275a8..d1c47bc 100644 --- a/crates/core/src/pattern_graph.rs +++ b/crates/core/src/pattern_graph.rs @@ -5,6 +5,8 @@ use crate::{PatternNode, PatternNodeKind}; #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] pub struct PatternGraph { + #[serde(default, skip_serializing_if = "crate::CanvasAnnotations::is_empty")] + pub annotations: crate::CanvasAnnotations, pub nodes: Vec<PatternNode>, pub root: Option<u32>, } @@ -12,6 +14,7 @@ pub struct PatternGraph { impl PatternGraph { pub fn with_root(kind: PatternNodeKind) -> Self { Self { + annotations: Default::default(), root: Some(1), nodes: vec![PatternNode { id: 1, kind, children: vec![None; kind.child_count()], parameters: BTreeMap::new(), position: [0.0; 2] }], } diff --git a/crates/engine/src/annotation_commands.rs b/crates/engine/src/annotation_commands.rs index 5825eca..e72f6df 100644 --- a/crates/engine/src/annotation_commands.rs +++ b/crates/engine/src/annotation_commands.rs @@ -8,13 +8,15 @@ pub(crate) fn specs() -> Vec<CommandSpec> { "Select annotation", [], None, - "{kind?: frame|comment, id?} clears node selection; omit kind to deselect", + "{kind?: frame|comment|pin, id?} clears node selection; omit kind to deselect", has_graph, select )] } fn select(session: &mut Session, parameters: &Value) -> Result<Value> { + let target = crate::AnnotationTarget::resolve(session, parameters)?; + let items = target.items(session)?; let selection = match strp(parameters, "kind") { None => None, Some(kind) => { @@ -22,9 +24,10 @@ fn select(session: &mut Session, parameters: &Value) -> Result<Value> { let selection = match kind { "frame" => AnnotationSelection::Frame(id), "comment" => AnnotationSelection::Comment(id), - _ => return Err(bad("graph.annotation.select", "kind must be frame or comment")), + "pin" => AnnotationSelection::Pin(id), + _ => return Err(bad("graph.annotation.select", "kind must be frame, comment or pin")), }; - if !selection.exists(session.graph()?) { + if !selection.exists(&items) { return Err(bad("graph.annotation.select", "annotation does not exist")); } @@ -32,6 +35,7 @@ fn select(session: &mut Session, parameters: &Value) -> Result<Value> { } }; + session.annotation_target = target; session.annotation_selection = selection; if selection.is_some() { session.selection.clear(); diff --git a/crates/engine/src/annotation_selection.rs b/crates/engine/src/annotation_selection.rs index 8385ca6..cd3b686 100644 --- a/crates/engine/src/annotation_selection.rs +++ b/crates/engine/src/annotation_selection.rs @@ -1,4 +1,4 @@ -use materialcraft_core::Graph; +use materialcraft_core::CanvasAnnotations; use serde::{Deserialize, Serialize}; #[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)] @@ -6,13 +6,15 @@ use serde::{Deserialize, Serialize}; pub enum AnnotationSelection { Frame(u64), Comment(u64), + Pin(u64), } impl AnnotationSelection { - pub fn exists(self, graph: &Graph) -> bool { + pub fn exists(self, graph: &CanvasAnnotations) -> bool { match self { Self::Frame(id) => graph.frames.iter().any(|frame| frame.id == id), Self::Comment(id) => graph.comments.iter().any(|comment| comment.id == id), + Self::Pin(id) => graph.pins.iter().any(|pin| pin.id == id), } } } diff --git a/crates/engine/src/annotation_target.rs b/crates/engine/src/annotation_target.rs new file mode 100644 index 0000000..255ff67 --- /dev/null +++ b/crates/engine/src/annotation_target.rs @@ -0,0 +1,150 @@ +use crate::{FrameContents, FunctionGraphTarget, Result, SelectionTarget, Session, commands::bad}; +use materialcraft_core::{CanvasAnnotations, Frame, NodeId, Value}; +use serde::{Deserialize, Serialize}; +use serde_json::{Value as Json, json}; + +/// Canvas that owns the selected frame, comment or navigation pin. +#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)] +#[serde(tag = "kind", rename_all = "camelCase")] +pub enum AnnotationTarget { + #[default] + Graph, + Function { + target: FunctionGraphTarget, + }, + Pattern { + owner: NodeId, + }, +} + +impl AnnotationTarget { + pub(crate) fn resolve(session: &Session, parameters: &Json) -> Result<Self> { + Ok(match SelectionTarget::resolve(session, parameters)? { + None | Some(SelectionTarget::Function(FunctionGraphTarget::Graph)) => Self::Graph, + Some(SelectionTarget::Function(target)) => Self::Function { target }, + Some(SelectionTarget::Pattern(owner)) => Self::Pattern { owner }, + }) + } + + /// Command parameters that address this canvas. + pub fn parameters(&self) -> Json { + match self { + Self::Graph => json!({}), + Self::Function { target } => json!({"function": target}), + Self::Pattern { owner } => json!({"pattern": owner.0}), + } + } + + /// Copy the annotations owned by this canvas. + pub fn items(&self, session: &Session) -> Result<CanvasAnnotations> { + Ok(match self { + Self::Graph => { + let graph = session.graph()?; + CanvasAnnotations { frames: graph.frames.clone(), comments: graph.comments.clone(), pins: graph.pins.clone() } + } + Self::Function { target } => target.current(session)?.annotations.clone(), + Self::Pattern { owner } => SelectionTarget::pattern(session, *owner)?.annotations.clone(), + }) + } + + pub(crate) fn replace(&self, session: &mut Session, items: CanvasAnnotations) -> Result<()> { + match self { + Self::Graph => { + let graph = session.graph_mut()?; + graph.next_id = graph.next_id.max(items.next_id().unwrap_or(u64::MAX)); + graph.frames = items.frames; + graph.comments = items.comments; + graph.pins = items.pins; + } + Self::Function { target } => { + let mut function = target.current(session)?.clone(); + function.annotations = items; + target.replace(session, function)?; + } + Self::Pattern { owner } => { + let mut graph = SelectionTarget::pattern(session, *owner)?.clone(); + graph.annotations = items; + session.graph_mut()?.node_mut(*owner)?.params.insert("pattern".into(), Value::PatternGraph(Box::new(graph))); + } + } + Ok(()) + } + + pub(crate) fn next_id(&self, session: &Session, items: &CanvasAnnotations) -> Result<u64> { + let next = items.next_id().ok_or_else(|| bad("graph annotation", "no available annotation id"))?; + Ok(if *self == Self::Graph { next.max(session.graph()?.next_id) } else { next }) + } + + /// Node positions in this canvas, using the shared node-id representation. + pub fn positions(&self, session: &Session) -> Result<Vec<(NodeId, [f32; 2])>> { + Ok(match self { + Self::Graph => { + let graph = session.graph()?; + match &graph.function { + Some(function) => function.nodes.iter().map(|node| (NodeId(u64::from(node.id)), node.pos)).collect(), + None => graph.nodes.iter().map(|node| (node.id, node.pos)).collect(), + } + } + Self::Function { target } => target.current(session)?.nodes.iter().map(|node| (NodeId(u64::from(node.id)), node.pos)).collect(), + Self::Pattern { owner } => { + SelectionTarget::pattern(session, *owner)?.nodes.iter().map(|node| (NodeId(u64::from(node.id)), node.position)).collect() + } + }) + } + + /// Capture the nodes and annotations moved with a frame. + pub fn capture_frame(&self, session: &Session, frame: &Frame) -> Result<FrameContents> { + if *self == Self::Graph { + return Ok(FrameContents::capture(session.graph()?, frame)); + } + + let items = self.items(session)?; + let nodes: Vec<_> = self.positions(session)?.into_iter().filter(|(_, position)| frame.contains_position(*position)).map(|(id, _)| id).collect(); + Ok(FrameContents { + function_nodes: nodes.iter().filter_map(|id| u32::try_from(id.0).ok()).collect(), + nodes, + comments: items.comments.iter().filter(|comment| frame.contains_position(comment.pos)).map(|comment| comment.id).collect(), + frames: items.frames.iter().filter(|candidate| candidate.id == frame.id || frame.contains_rect(candidate.rect)).map(|frame| frame.id).collect(), + pins: items.pins.iter().filter(|pin| frame.contains_position(pin.pos)).map(|pin| pin.id).collect(), + }) + } + + pub(crate) fn move_contents(&self, session: &mut Session, contents: &FrameContents, offset: [f32; 2]) -> Result<()> { + if *self == Self::Graph { + contents.translate(session.graph_mut()?, offset); + return Ok(()); + } + + let translate = |position: [f32; 2]| crate::graph_grid::snap_position([position[0] + offset[0], position[1] + offset[1]], false); + match self { + Self::Function { target } => { + let mut graph = target.current(session)?.clone(); + for node in graph.nodes.iter_mut().filter(|node| contents.function_nodes.contains(&node.id)) { + node.pos = translate(node.pos); + } + target.replace(session, graph)?; + } + Self::Pattern { owner } => { + let mut graph = SelectionTarget::pattern(session, *owner)?.clone(); + for node in graph.nodes.iter_mut().filter(|node| contents.nodes.contains(&NodeId(u64::from(node.id)))) { + node.position = translate(node.position); + } + session.graph_mut()?.node_mut(*owner)?.params.insert("pattern".into(), Value::PatternGraph(Box::new(graph))); + } + Self::Graph => {} + } + let mut items = self.items(session)?; + for comment in items.comments.iter_mut().filter(|comment| contents.comments.contains(&comment.id)) { + comment.pos = translate(comment.pos); + } + for frame in items.frames.iter_mut().filter(|frame| contents.frames.contains(&frame.id)) { + let position = translate([frame.rect[0], frame.rect[1]]); + frame.rect[0] = position[0]; + frame.rect[1] = position[1]; + } + for pin in items.pins.iter_mut().filter(|pin| contents.pins.contains(&pin.id)) { + pin.pos = translate(pin.pos); + } + self.replace(session, items) + } +} diff --git a/crates/engine/src/commands.rs b/crates/engine/src/commands.rs index 84321f3..51ccc34 100644 --- a/crates/engine/src/commands.rs +++ b/crates/engine/src/commands.rs @@ -77,6 +77,7 @@ pub fn command_specs() -> &'static [CommandSpec] { v.extend(crate::function_variable_commands::specs()); v.extend(crate::evaluation_environment_commands::specs()); v.extend(crate::comment_commands::specs()); + v.extend(crate::pin_commands::specs()); v.extend(crate::node_cmds::specs()); v.extend(crate::node_graph_commands::specs()); v.extend(crate::pattern_graph_commands::specs()); @@ -101,7 +102,7 @@ pub fn execute(s: &mut Session, id: &str, params: &J) -> Result<J> { } (spec.enabled)(s).map_err(|why| EngineError::Disabled { cmd: id.to_string(), why })?; let result = (spec.run)(s, params)?; - if !s.selection.is_empty() || s.annotation_selection.is_some_and(|selection| !s.graph().is_ok_and(|graph| selection.exists(graph))) { + if !s.selection.is_empty() || s.annotation_selection.is_some_and(|selection| !s.annotation_target.items(s).is_ok_and(|items| selection.exists(&items))) { s.annotation_selection = None; } @@ -117,6 +118,8 @@ pub fn list(s: &Session, filter: Option<&str>) -> J { .filter(|c| f.as_ref().is_none_or(|f| c.id.to_ascii_lowercase().contains(f) || c.label.to_ascii_lowercase().contains(f))) .map(|c| json!({"id": c.id, "label": c.label, "menu": c.menu, "shortcut": c.shortcut, "params": if crate::selection_commands::supports(c.id) { format!("{}; optional function: FunctionGraphTarget or pattern: owner node id, graph: owning graph index; embedded targets use explicit ids; copy returns clip", c.params) + } else if c.id.starts_with("graph.annotation.") || c.id.starts_with("graph.frame.") || c.id.starts_with("graph.comment.") { + format!("{}; optional function: FunctionGraphTarget or pattern: owner node id", c.params) } else { c.params.to_string() }, "enabled": crate::selection_commands::enabled(s, c.id, &J::Null).unwrap_or_else(|| (c.enabled)(s).is_ok())})) .collect(), ) diff --git a/crates/engine/src/comment_commands.rs b/crates/engine/src/comment_commands.rs index 103091e..ca0113e 100644 --- a/crates/engine/src/comment_commands.rs +++ b/crates/engine/src/comment_commands.rs @@ -13,13 +13,16 @@ pub(crate) fn specs() -> Vec<CommandSpec> { } fn comment_add(session: &mut Session, parameters: &J) -> Result<J> { + let target = crate::AnnotationTarget::resolve(session, parameters)?; let at = point(parameters, "at").or_else(|| nodes_rect(session, &session.selection).map(|rect| [rect[0], rect[1] - 90.0])).unwrap_or([0.0, -120.0]); let text = strp(parameters, "text").unwrap_or("Comment").to_string(); session.edit("Add comment", |session| { - let graph = session.graph_mut()?; - let id = graph.alloc_id(); - graph.comments.push(Comment { id, text, pos: at, size: [180.0, 70.0] }); + let mut items = target.items(session)?; + let id = target.next_id(session, &items)?; + items.comments.push(Comment { id, text, pos: at, size: [180.0, 70.0] }); + target.replace(session, items)?; + session.annotation_target = target; session.selection.clear(); session.annotation_selection = Some(AnnotationSelection::Comment(id)); Ok(json!({"id": id})) @@ -27,11 +30,12 @@ fn comment_add(session: &mut Session, parameters: &J) -> Result<J> { } fn comment_edit(session: &mut Session, parameters: &J) -> Result<J> { + let target = crate::AnnotationTarget::resolve(session, parameters)?; let id = u64p(parameters, "id").ok_or_else(|| bad("graph.comment.edit", "`id` is required"))?; - session.edit_merged(&format!("comment{id}"), "Edit comment", |session| { - let comment = - session.graph_mut()?.comments.iter_mut().find(|comment| comment.id == id).ok_or_else(|| bad("graph.comment.edit", format!("no comment {id}")))?; + session.edit_merged(&format!("comment:{target:?}:{id}"), "Edit comment", |session| { + let mut items = target.items(session)?; + let comment = items.comments.iter_mut().find(|comment| comment.id == id).ok_or_else(|| bad("graph.comment.edit", format!("no comment {id}")))?; if let Some(text) = strp(parameters, "text") { comment.text = text.into(); } @@ -42,16 +46,20 @@ fn comment_edit(session: &mut Session, parameters: &J) -> Result<J> { comment.size = [size[0].max(40.0), size[1].max(24.0)]; } + target.replace(session, items)?; Ok(J::Null) }) } fn comment_delete(session: &mut Session, parameters: &J) -> Result<J> { + let target = crate::AnnotationTarget::resolve(session, parameters)?; let id = u64p(parameters, "id").ok_or_else(|| bad("graph.comment.delete", "`id` is required"))?; session.edit("Delete comment", |session| { - session.graph_mut()?.comments.retain(|comment| comment.id != id); + let mut items = target.items(session)?; + items.comments.retain(|comment| comment.id != id); + target.replace(session, items)?; Ok(J::Null) }) } diff --git a/crates/engine/src/edit_cmds.rs b/crates/engine/src/edit_cmds.rs index 60321be..7dc7e10 100644 --- a/crates/engine/src/edit_cmds.rs +++ b/crates/engine/src/edit_cmds.rs @@ -172,13 +172,16 @@ fn has_deletable_selection(session: &Session) -> std::result::Result<(), String> fn delete_annotation(session: &mut Session) -> Result<J> { let selection = session.annotation_selection; + let target = session.annotation_target.clone(); + let mut items = target.items(session)?; + match selection { + Some(crate::AnnotationSelection::Frame(id)) => items.frames.retain(|frame| frame.id != id), + Some(crate::AnnotationSelection::Comment(id)) => items.comments.retain(|comment| comment.id != id), + Some(crate::AnnotationSelection::Pin(id)) => items.pins.retain(|pin| pin.id != id), + None => {} + } session.edit("Delete annotation", |session| { - let graph = session.graph_mut()?; - match selection { - Some(crate::AnnotationSelection::Frame(id)) => graph.frames.retain(|frame| frame.id != id), - Some(crate::AnnotationSelection::Comment(id)) => graph.comments.retain(|comment| comment.id != id), - None => {} - } + target.replace(session, items)?; session.annotation_selection = None; Ok(json!({"deleted": 1})) }) diff --git a/crates/engine/src/frame_commands.rs b/crates/engine/src/frame_commands.rs index a4672d4..47cf604 100644 --- a/crates/engine/src/frame_commands.rs +++ b/crates/engine/src/frame_commands.rs @@ -1,6 +1,6 @@ use crate::commands::{CommandSpec, bad, boolp, has_graph, point, strp, u64p}; use crate::graph_cmds::nodes_rect; -use crate::{AnnotationSelection, FrameContents, Result, Session, cmd}; +use crate::{AnnotationSelection, Result, Session, cmd}; use materialcraft_core::Frame; use serde_json::{Value as J, json}; @@ -32,6 +32,7 @@ fn color_of(parameters: &J) -> Option<[f32; 4]> { } fn frame_add(session: &mut Session, parameters: &J) -> Result<J> { + let target = crate::AnnotationTarget::resolve(session, parameters)?; let rect = match rect_of(parameters) { Some(rect) => rect, None => nodes_rect(session, &session.selection) @@ -45,9 +46,11 @@ fn frame_add(session: &mut Session, parameters: &J) -> Result<J> { let description = strp(parameters, "description").unwrap_or("").to_string(); session.edit("Add frame", |session| { - let graph = session.graph_mut()?; - let id = graph.alloc_id(); - graph.frames.push(Frame { id, title, title_visible, description, rect, color }); + let mut items = target.items(session)?; + let id = target.next_id(session, &items)?; + items.frames.push(Frame { id, title, title_visible, description, rect, color }); + target.replace(session, items)?; + session.annotation_target = target; session.selection.clear(); session.annotation_selection = Some(AnnotationSelection::Frame(id)); Ok(json!({"id": id})) @@ -55,10 +58,12 @@ fn frame_add(session: &mut Session, parameters: &J) -> Result<J> { } fn frame_edit(session: &mut Session, parameters: &J) -> Result<J> { + let target = crate::AnnotationTarget::resolve(session, parameters)?; let id = u64p(parameters, "id").ok_or_else(|| bad("graph.frame.edit", "`id` is required"))?; - session.edit_merged(&format!("frame{id}"), "Edit frame", |session| { - let frame = session.graph_mut()?.frames.iter_mut().find(|frame| frame.id == id).ok_or_else(|| bad("graph.frame.edit", format!("no frame {id}")))?; + session.edit_merged(&format!("frame:{target:?}:{id}"), "Edit frame", |session| { + let mut items = target.items(session)?; + let frame = items.frames.iter_mut().find(|frame| frame.id == id).ok_or_else(|| bad("graph.frame.edit", format!("no frame {id}")))?; if let Some(text) = strp(parameters, "title") { frame.title = text.into(); } @@ -75,35 +80,39 @@ fn frame_edit(session: &mut Session, parameters: &J) -> Result<J> { frame.color = color; } + target.replace(session, items)?; Ok(J::Null) }) } fn frame_delete(session: &mut Session, parameters: &J) -> Result<J> { + let target = crate::AnnotationTarget::resolve(session, parameters)?; let id = u64p(parameters, "id").ok_or_else(|| bad("graph.frame.delete", "`id` is required"))?; session.edit("Delete frame", |session| { - let graph = session.graph_mut()?; - let previous_count = graph.frames.len(); - graph.frames.retain(|frame| frame.id != id); - if previous_count == graph.frames.len() { + let mut items = target.items(session)?; + let previous_count = items.frames.len(); + items.frames.retain(|frame| frame.id != id); + if previous_count == items.frames.len() { return Err(bad("graph.frame.delete", format!("no frame {id}"))); } + target.replace(session, items)?; Ok(J::Null) }) } fn frame_move(session: &mut Session, parameters: &J) -> Result<J> { + let target = crate::AnnotationTarget::resolve(session, parameters)?; let id = u64p(parameters, "id").ok_or_else(|| bad("graph.frame.move", "`id` is required"))?; let offset = point(parameters, "by").ok_or_else(|| bad("graph.frame.move", "`by` is required"))?; let offset = crate::graph_grid::snap_position(offset, boolp(parameters, "snapToGrid").unwrap_or(false)); - let graph = session.graph()?; - let frame = graph.frames.iter().find(|frame| frame.id == id).ok_or_else(|| bad("graph.frame.move", "frame does not exist"))?; - let contents = FrameContents::capture(graph, frame); + let items = target.items(session)?; + let frame = items.frames.iter().find(|frame| frame.id == id).ok_or_else(|| bad("graph.frame.move", "frame does not exist"))?; + let contents = target.capture_frame(session, frame)?; session.edit("Move frame and contents", |session| { - contents.translate(session.graph_mut()?, offset); + target.move_contents(session, &contents, offset)?; Ok(J::Null) }) diff --git a/crates/engine/src/function_graph_target.rs b/crates/engine/src/function_graph_target.rs index 5e7f8c1..644b3ac 100644 --- a/crates/engine/src/function_graph_target.rs +++ b/crates/engine/src/function_graph_target.rs @@ -27,10 +27,9 @@ impl FunctionGraphTarget { crate::function_variables::suggestions(self, session, id) } - pub fn available_operations(&self, session: &Session) -> impl Iterator<Item = &'static materialcraft_nodes::function::FunctionDefinition> + use<> { - let value_processor = matches!(self, Self::Parameter { node, parameter } - if parameter == "function" && session.graph().ok().and_then(|graph| graph.node(*node).ok()).is_some_and(|node| node.def == "value_processor")); - materialcraft_nodes::function::FUNCTIONS.iter().filter(move |operation| !value_processor || !matches!(operation.id, "samplelum" | "samplecol")) + /// All function targets accept the native catalog, including samplers for processor image inputs. + pub fn available_operations(&self, _session: &Session) -> impl Iterator<Item = &'static materialcraft_nodes::function::FunctionDefinition> + use<> { + materialcraft_nodes::function::FUNCTIONS.iter() } pub fn current<'a>(&self, session: &'a Session) -> Result<&'a FunctionGraph> { diff --git a/crates/engine/src/graph_cmds.rs b/crates/engine/src/graph_cmds.rs index 3c4356e..ecf8077 100644 --- a/crates/engine/src/graph_cmds.rs +++ b/crates/engine/src/graph_cmds.rs @@ -2,9 +2,9 @@ use serde_json::{Value as J, json}; -use materialcraft_core::{ExposedParameter, Graph, MAX_SIZE_LOG2, MIN_SIZE_LOG2, NodeId, OutputFormat, Pin, Value}; +use materialcraft_core::{ExposedParameter, Graph, MAX_SIZE_LOG2, MIN_SIZE_LOG2, NodeId, OutputFormat, Value}; -use crate::commands::{CommandSpec, always, bad, boolp, f32p, has_graph, has_selection, i64p, ids_param, point, strp, u64p}; +use crate::commands::{CommandSpec, always, bad, boolp, f32p, has_graph, has_selection, i64p, ids_param, strp, u64p}; use crate::{Result, Session, cmd}; pub(crate) fn specs() -> Vec<CommandSpec> { @@ -31,8 +31,6 @@ pub(crate) fn specs() -> Vec<CommandSpec> { 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!( "graph.exposed.add", "Expose parameter", @@ -194,25 +192,6 @@ pub fn nodes_rect(s: &Session, ids: &[NodeId]) -> Option<[f32; 4]> { (r[0] < f32::MAX).then(|| [r[0], r[1], r[2] - r[0], r[3] - r[1]]) } -fn pin_add(s: &mut Session, p: &J) -> Result<J> { - let at = point(p, "at").unwrap_or([0.0, 0.0]); - s.edit("Add pin", |s| { - let g = s.graph_mut()?; - let id = g.alloc_id(); - let name = strp(p, "name").map(str::to_string).unwrap_or_else(|| format!("Pin {}", g.pins.len() + 1)); - g.pins.push(Pin { id, name, pos: at }); - Ok(json!({"id": id})) - }) -} - -fn pin_delete(s: &mut Session, p: &J) -> Result<J> { - let id = u64p(p, "id").ok_or_else(|| bad("graph.pin.delete", "`id` is required"))?; - s.edit("Delete pin", |s| { - s.graph_mut()?.pins.retain(|c| c.id != id); - Ok(J::Null) - }) -} - fn exposed_add(s: &mut Session, p: &J) -> Result<J> { // From a bound node parameter: its value, range and options become the input's let bind = p.get("bind").and_then(|b| Some((NodeId(b.get("node")?.as_u64()?), b.get("param")?.as_str()?.to_string()))); diff --git a/crates/engine/src/inspect.rs b/crates/engine/src/inspect.rs index 27c64b6..71942eb 100644 --- a/crates/engine/src/inspect.rs +++ b/crates/engine/src/inspect.rs @@ -70,6 +70,7 @@ pub fn session(s: &Session, graph: Option<usize>) -> J { "openGraph": g.map(|_| s.graph), "graph": graph_json, "annotationSelection": s.annotation_selection, + "annotationTarget": s.annotation_target, "selection": s.selection.iter().map(|i| i.0).collect::<Vec<_>>(), "view2d": s.view2d, "view3d": s.view3d, diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs index 0862a4c..31c0ae1 100644 --- a/crates/engine/src/lib.rs +++ b/crates/engine/src/lib.rs @@ -1,6 +1,9 @@ #![forbid(unsafe_code)] #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)] +#[cfg(test)] +extern crate self as materialcraft_engine; + mod document_path; mod evaluation_environment_commands; mod explorer_clipboard; @@ -102,12 +105,15 @@ pub use exported::Exported; mod annotation_commands; mod annotation_selection; +mod annotation_target; +pub use annotation_target::AnnotationTarget; mod comment_commands; mod frame_commands; mod frame_contents; mod function_commands; mod node_graph_commands; mod pattern_graph_commands; +mod pin_commands; mod snapshot; pub use annotation_selection::AnnotationSelection; pub use frame_contents::FrameContents; diff --git a/crates/engine/src/linked_packages.rs b/crates/engine/src/linked_packages.rs index 01fad15..f0038f3 100644 --- a/crates/engine/src/linked_packages.rs +++ b/crates/engine/src/linked_packages.rs @@ -97,8 +97,15 @@ impl Session { self.refresh_links_from(BTreeSet::new()); } + /// Refresh linked interfaces and retain ownership of installed library snapshots. pub(crate) fn refresh_links_from(&mut self, mut changed: BTreeSet<String>) { + // Replaced snapshots belong to the caller, even when their library alias is unchanged + self.library_sources.retain(|path, owned| self.linked_sources.get(path).is_some_and(|source| Arc::ptr_eq(source, owned))); + let open_paths: BTreeSet<_> = self.open_packages().into_iter().filter_map(|(_, _, path, _)| path.map(str::to_string)).collect(); + self.library_sources.retain(|path, _| !open_paths.contains(path)); + let mut sources = self.linked_sources.clone(); + // Interface types can propagate through several files; the workspace has at most 64 open packages for _ in 0..64 { for (_, package, path, _) in self.open_packages() { @@ -142,6 +149,13 @@ impl Session { } document.pkg.dependencies = sources.clone(); } + + // Interface refreshes replace Arcs without changing who owns the source + for (path, owned) in &mut self.library_sources { + if let Some(source) = sources.get(path) { + *owned = source.clone(); + } + } self.linked_sources = sources; } } diff --git a/crates/engine/src/node_library.rs b/crates/engine/src/node_library.rs index b2541aa..24bf9be 100644 --- a/crates/engine/src/node_library.rs +++ b/crates/engine/src/node_library.rs @@ -1,13 +1,21 @@ //! The node library. Every SBS package in the library folder (`assets/sbs`, or the bundled copies) //! is loaded once per process and lends its graphs: function graphs go under Functions (sorted by -//! their folder), other graphs under their attribute category. Native nodes, function operations, +//! their classification tags, with folder fallbacks), other graphs under their attribute category. Native nodes, function operations, //! FX-Map nodes and graph items fill the rest of the tree. A package whose titled frames are library //! categories ("Filters - Blurs") can also lay the library out: each node inside a frame becomes an //! entry in that category, listed as missing until a package provides it. +mod library_canvas; +mod library_entry; +mod library_item; +mod library_placement; +pub use library_canvas::LibraryCanvas; +pub use library_entry::LibraryEntry; +pub use library_item::LibraryItem; +use library_placement::LibraryPlacement; + use materialcraft_core::{Package, PatternNodeKind}; use materialcraft_formats::sbs::{LayoutItem, library}; -use serde::Serialize; use std::collections::{BTreeMap, BTreeSet}; use std::sync::{Arc, Mutex}; @@ -47,86 +55,6 @@ const SUB_KEYWORDS: &[(&str, &str, &[&str])] = &[ ("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 { @@ -135,7 +63,7 @@ pub struct NodeLibrary { /// The `sbs://` files that laid the library out pub layouts: Vec<String>, pub warnings: Vec<String>, - placements: Vec<Placement>, + placements: Vec<LibraryPlacement>, } static SHARED: Mutex<Option<Arc<NodeLibrary>>> = Mutex::new(None); @@ -165,6 +93,7 @@ impl NodeLibrary { 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), @@ -178,6 +107,7 @@ impl NodeLibrary { 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); @@ -202,6 +132,13 @@ impl NodeLibrary { let mut ids = BTreeSet::new(); let mut placed_graphs = BTreeSet::new(); let mut push = |out: &mut Vec<LibraryEntry>, mut entry: LibraryEntry| { + // Reroute nodes are placed through the shared Graph items entry + if matches!(&entry.item, LibraryItem::Operation { operation } if operation == "passthrough") + || matches!(&entry.item, LibraryItem::Pattern { kind: PatternNodeKind::Dot }) + || matches!(&entry.item, LibraryItem::Node { def } if def == "dot" && entry.category != "Graph items") + { + return; + } // 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); @@ -233,7 +170,9 @@ impl NodeLibrary { if definition.id == "graph_instance" || listed.contains(&id) { continue; } + let item = LibraryItem::Node { def: definition.id.into() }; + // Graph inputs and outputs sit with the atomic nodes; Graph items holds annotations and the Dot let category = if matches!(definition.id, "input_color" | "input_grayscale" | "input_value" | "output") { "Atomic nodes" } else { definition.category }; @@ -241,13 +180,14 @@ impl NodeLibrary { } for operation in materialcraft_nodes::function::FUNCTIONS { let id = format!("function:{}", operation.id); - if listed.contains(&id) { + if operation.id == "passthrough" || 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 { + for kind in PatternNodeKind::ALL.into_iter().filter(|kind| *kind != PatternNodeKind::Dot) { let id = format!("pattern:{}", kind.native_id()); push(&mut out, entry(id, kind.label(), "FxMap nodes", "", LibraryItem::Pattern { kind }, None)); } @@ -258,15 +198,24 @@ impl NodeLibrary { if placed_graphs.contains(&(path.clone(), name.clone())) { continue; } - let placement = if graph.function.is_some() { - let category = known_category(&graph.attributes.category).unwrap_or_else(|| function_category(&name)); - Placement { category, item: LayoutItem::FunctionInstance { package: path.clone(), graph: name } } - } else if graph.nodes.iter().any(|node| node.def == "output") { + + if graph.function.is_some() { + for category in function_categories(graph) { + let placement = LibraryPlacement { category, item: LayoutItem::FunctionInstance { package: path.clone(), graph: name.clone() } }; + if let Some(entry) = resolve(&placement, dependencies) { + push(&mut out, entry); + } + } + continue; + } + + let placement = 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() } } + LibraryPlacement { 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); } @@ -276,13 +225,14 @@ impl NodeLibrary { } } +/// Build an entry with a canvas derived from its item kind. 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> { +fn resolve(placement: &LibraryPlacement, 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) => { @@ -319,6 +269,7 @@ fn resolve(placement: &Placement, dependencies: &BTreeMap<String, Arc<Package>>) .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")?; @@ -333,12 +284,12 @@ fn resolve(placement: &Placement, dependencies: &BTreeMap<String, Arc<Package>>) } /// The categories of a layout's frames, and what each places -fn placements(frames: &[materialcraft_formats::sbs::LayoutFrame]) -> Vec<Placement> { +fn placements(frames: &[materialcraft_formats::sbs::LayoutFrame]) -> Vec<LibraryPlacement> { 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.extend(frame.items.iter().map(|item| LibraryPlacement { category: category.clone(), item: item.clone() })); } out } @@ -374,6 +325,7 @@ 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))?; + // A sub-category the tree doesn't have names no category ("Functions/colorValues" is a folder) let sub = match parts.next() { None => None, @@ -382,6 +334,27 @@ fn known_category(text: &str) -> Option<String> { Some(category_path(top, sub)) } +/// Function tags select filters; explicit category paths and package paths remain fallbacks. +fn function_categories(graph: &materialcraft_core::Graph) -> Vec<String> { + let subcategories = CATEGORIES.iter().find(|(name, _)| *name == "Functions").map_or(&[][..], |(_, subcategories)| *subcategories); + let mut categories = Vec::new(); + for tag in graph.attributes.tags.split([',', ';']) { + let tag = key(tag); + let tag = if tag == "easing" { "easings" } else { tag.as_str() }; + if let Some(subcategory) = subcategories.iter().find(|subcategory| key(subcategory) == tag) { + let category = category_path("Functions", Some(subcategory)); + if !categories.contains(&category) { + categories.push(category); + } + } + } + if categories.is_empty() { + categories.push(known_category(&graph.attributes.category).unwrap_or_else(|| function_category(&graph.sbs_path()))); + } + categories +} + +/// Join a top-level category with its optional subcategory. fn category_path(top: &str, sub: Option<&str>) -> String { match sub { Some(sub) => format!("{top}/{sub}"), @@ -394,6 +367,7 @@ 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() @@ -471,6 +445,7 @@ pub fn humanize(identifier: &str) -> String { 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()) }) diff --git a/crates/engine/src/node_library.test.rs b/crates/engine/src/node_library.test.rs index 1c6fbd4..8eef6dc 100644 --- a/crates/engine/src/node_library.test.rs +++ b/crates/engine/src/node_library.test.rs @@ -1,6 +1,10 @@ use super::*; use materialcraft_core::Graph; +#[path = "../tests/support/node_library.rs"] +mod fixture; + +/// Category aliases and frame kinds resolve only to recognized categories. #[test] fn frame_titles_map_to_library_categories() { assert_eq!(frame_category("Texture Generators - Noises", false, false).as_deref(), Some("Texture generators/Noises")); @@ -9,6 +13,7 @@ fn frame_titles_map_to_library_categories() { 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); @@ -18,6 +23,7 @@ fn frame_titles_map_to_library_categories() { assert_eq!(frame_category("Unknown", true, true), None); } +/// Identifier labels preserve recognized acronyms and omit empty words. #[test] fn identifiers_read_as_labels() { assert_eq!(humanize("3D_perlin_noise"), "3D Perlin Noise"); @@ -27,6 +33,7 @@ fn identifiers_read_as_labels() { assert_eq!(humanize("__"), ""); } +/// Function categories use exact path segments and known name overrides. #[test] fn functions_sort_into_sub_categories_by_folder_and_name() { assert_eq!(function_category("Functions/Math/Pi"), "Functions/Constant"); @@ -41,9 +48,10 @@ fn functions_sort_into_sub_categories_by_folder_and_name() { assert_eq!(function_category("Loose"), "Functions"); } +/// The isolated bundled catalog has unique entries in recognized categories. #[test] fn the_bundled_library_fills_the_tree_with_what_materialcraft_has() { - let library = NodeLibrary::shared(); + let library = fixture::library(); assert!(library.layouts.is_empty()); assert!(library.packages.contains_key("sbs://functions.sbs")); @@ -68,8 +76,10 @@ fn the_bundled_library_fills_the_tree_with_what_materialcraft_has() { assert!(count(&format!("{top}/{sub}")) > 0, "{top}/{sub} is empty"); } } + // Every bundled function has a sub-category - assert_eq!(entries.iter().filter(|entry| entry.category.starts_with("Functions/")).count(), 171); + let functions = library.packages["sbs://functions.sbs"].graphs.iter().filter(|graph| graph.function.is_some()).count(); + assert_eq!(entries.iter().filter(|entry| entry.category.starts_with("Functions/")).count(), functions); assert_eq!(count("Functions"), 0); assert_eq!(find("sbs://functions.sbs#Functions/Tonemappers/tonemap_ACES").category, "Functions/Color"); assert_eq!( @@ -99,6 +109,7 @@ const LAYOUT: &str = r#"<package><dependencies> <GUIObject><type v="COMMENT"/><GUILayout><gpos v="200 0 0"/><size v="160 200"/></GUILayout><title v="PBR Materials"/></GUIObject> </GUIObjects></graph></content></package>"#; +/// A missing layout entry becomes available when its package is supplied. #[test] fn a_layout_lists_what_it_places_and_a_library_package_makes_it_available() { let frames = materialcraft_formats::sbs::read_layout(LAYOUT.as_bytes(), "sbs://layout.sbs").unwrap(); @@ -128,6 +139,7 @@ fn a_layout_lists_what_it_places_and_a_library_package_makes_it_available() { assert_eq!((loose.category.as_str(), loose.canvas), ("Filters/Blurs", LibraryCanvas::Material)); } +/// Invalid library files produce warnings while native entries remain usable. #[test] fn unreadable_library_files_warn_instead_of_failing() { let library = NodeLibrary::load(&["sbs://does_not_exist.sbs".into(), "sbs://../escape.sbs".into()]); @@ -137,3 +149,25 @@ fn unreadable_library_files_warn_instead_of_failing() { 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")); } + +/// Classification tags take precedence over package folders and support multiple placements. +#[test] +fn function_tags_choose_library_filters_before_path_fallbacks() { + let mut package = Package::new("Functions"); + for (name, category, tags) in [("Pi", "Function", "Maths"), ("Tagged", "", "Comparison; Easing"), ("Fallback", "", "Unknown")] { + let mut graph = Graph::new(name); + graph.folder = "Functions/Math".into(); + graph.function = Some(Default::default()); + graph.attributes.category = category.into(); + graph.attributes.tags = tags.into(); + package.graphs.push(graph); + } + let dependencies = BTreeMap::from([("sbs://classification.sbs".to_string(), Arc::new(package))]); + + let entries = NodeLibrary::default().entries(&dependencies); + let categories = |name: &str| entries.iter().filter(|entry| entry.label == name).map(|entry| entry.category.as_str()).collect::<Vec<_>>(); + + assert_eq!(categories("Pi"), ["Functions/Maths"]); + assert_eq!(categories("Tagged"), ["Functions/Comparison", "Functions/Easings"]); + assert_eq!(categories("Fallback"), ["Functions/Maths"]); +} diff --git a/crates/engine/src/node_library/library_canvas.rs b/crates/engine/src/node_library/library_canvas.rs new file mode 100644 index 0000000..f119b11 --- /dev/null +++ b/crates/engine/src/node_library/library_canvas.rs @@ -0,0 +1,11 @@ +use serde::Serialize; + +/// The graph kind that can take an entry +#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)] +#[serde(rename_all = "camelCase")] +pub enum LibraryCanvas { + Any, + Material, + Function, + Pattern, +} diff --git a/crates/engine/src/node_library/library_entry.rs b/crates/engine/src/node_library/library_entry.rs new file mode 100644 index 0000000..3329858 --- /dev/null +++ b/crates/engine/src/node_library/library_entry.rs @@ -0,0 +1,22 @@ +use super::{LibraryCanvas, LibraryItem}; +use serde::Serialize; + +/// One selectable library entry and its availability on a destination canvas. +#[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 [`super::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>, +} diff --git a/crates/engine/src/node_library/library_item.rs b/crates/engine/src/node_library/library_item.rs new file mode 100644 index 0000000..583ba54 --- /dev/null +++ b/crates/engine/src/node_library/library_item.rs @@ -0,0 +1,51 @@ +use super::LibraryCanvas; +use materialcraft_core::PatternNodeKind; +use serde::Serialize; + +/// 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 { + /// Return the canvas that accepts this item. + pub fn canvas(&self) -> LibraryCanvas { + match self { + Self::Comment | Self::Frame | Self::Pin => LibraryCanvas::Any, + Self::Node { def } if def == "dot" => LibraryCanvas::Any, + Self::Operation { .. } | Self::FunctionInstance { .. } => LibraryCanvas::Function, + Self::Pattern { .. } => LibraryCanvas::Pattern, + _ => LibraryCanvas::Material, + } + } +} diff --git a/crates/engine/src/node_library/library_placement.rs b/crates/engine/src/node_library/library_placement.rs new file mode 100644 index 0000000..a4cbd2d --- /dev/null +++ b/crates/engine/src/node_library/library_placement.rs @@ -0,0 +1,8 @@ +use materialcraft_formats::sbs::LayoutItem; + +/// A layout placement, before it is resolved against the loaded packages +#[derive(Clone, Debug)] +pub(super) struct LibraryPlacement { + pub(super) category: String, + pub(super) item: LayoutItem, +} diff --git a/crates/engine/src/node_library_commands.rs b/crates/engine/src/node_library_commands.rs index 29d6709..3dab442 100644 --- a/crates/engine/src/node_library_commands.rs +++ b/crates/engine/src/node_library_commands.rs @@ -9,6 +9,7 @@ use std::collections::BTreeSet; const ADD: &str = "library.add"; +/// Register catalog queries, insertion and library reload commands. pub(crate) fn specs() -> Vec<CommandSpec> { vec![ cmd!( @@ -25,7 +26,7 @@ pub(crate) fn specs() -> Vec<CommandSpec> { "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)", + "{entry (id from library.tree), at? [x, y], snapToGrid?, function?: FunctionGraphTarget, pattern?: owner node id} adds a library entry to the open graph (function entries to a Function canvas)", has_graph, add ), @@ -40,6 +41,7 @@ impl Session { } } +/// List entries that match the requested text, category and destination canvas. 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(""); @@ -54,13 +56,14 @@ fn tree(session: &mut Session, parameters: &Value) -> Result<Value> { .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| canvas.is_none_or(|canvas| entry.canvas == LibraryCanvas::Any || 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})) } +/// Validate an entry and dispatch its insertion through the destination graph command. 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}`")))?; @@ -72,6 +75,39 @@ fn add(session: &mut Session, parameters: &Value) -> Result<Value> { 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::Any { + let destination = crate::AnnotationTarget::resolve(session, parameters)?; + let mut arguments = destination.parameters(); + arguments["at"] = json!(at); + let command = match &entry.item { + LibraryItem::Comment => "graph.comment.add", + LibraryItem::Frame => { + arguments["rect"] = json!([at[0], at[1], 400.0, 260.0]); + "graph.frame.add" + } + LibraryItem::Pin => "graph.pin.add", + LibraryItem::Node { def } if def == "dot" => match crate::SelectionTarget::resolve(session, parameters)? { + Some(crate::SelectionTarget::Function(target)) => { + arguments = json!({"target": target, "edit": {"action": "add", "operation": "passthrough", "at": at, "snap": snap}}); + "graph.function.edit" + } + Some(crate::SelectionTarget::Pattern(owner)) => { + arguments = json!({"id": owner.0, "edit": {"action": "add", "kind": "passthrough", "at": at, "snap": snap}}); + "graph.pattern.edit" + } + None => { + arguments = json!({"def": "dot", "at": at, "snapToGrid": snap}); + "graph.node.add" + } + }, + _ => return Err(bad(ADD, "unknown graph item")), + }; + let result = crate::execute(session, command, &arguments)?; + if matches!(&entry.item, LibraryItem::Node { .. }) { + session.annotation_selection = None; + } + return Ok(json!({"entry": entry.id, "result": result})); + } 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()))?, @@ -92,10 +128,12 @@ fn add(session: &mut Session, parameters: &Value) -> Result<Value> { }; 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 { + + if function_graph || target.is_some() || parameters.get("pattern").is_some() { return Err(bad(ADD, format!("{} goes in a material graph, not a Function Graph", entry.label))); } @@ -112,20 +150,45 @@ fn add(session: &mut Session, parameters: &Value) -> Result<Value> { Ok(json!({"entry": entry.id, "result": result})) } -fn reload(session: &mut Session, _: &Value) -> Result<Value> { - let library = NodeLibrary::reload(); +/// Replace library-owned snapshots while retaining explicit user dependencies. +fn replace_library(session: &mut Session, library: std::sync::Arc<NodeLibrary>) { let mut changed = BTreeSet::new(); + session.library_sources.retain(|path, owned| session.linked_sources.get(path).is_some_and(|source| std::sync::Arc::ptr_eq(source, owned))); + for path in session.library_sources.keys() { + if !library.packages.contains_key(path) { + session.linked_sources.remove(path); + changed.insert(path.clone()); + } + } + session.library_sources.retain(|path, _| library.packages.contains_key(path)); + for (path, package) in &library.packages { - if session.linked_sources.get(path).is_none_or(|current| current.graphs != package.graphs || current.resources != package.resources) { + if session.linked_sources.contains_key(path) && !session.library_sources.contains_key(path) { + continue; + } + + if session.linked_sources.get(path).is_none_or(|current| current.as_ref() != package.as_ref()) { session.linked_sources.insert(path.clone(), package.clone()); changed.insert(path.clone()); } + if let Some(source) = session.linked_sources.get(path) { + session.library_sources.insert(path.clone(), source.clone()); + } } for warning in &library.warnings { session.warn(warning.clone()); } session.library = library; session.refresh_links_from(changed); +} + +/// Reload the installed library and report the catalog visible to this session. +fn reload(session: &mut Session, _: &Value) -> Result<Value> { + replace_library(session, NodeLibrary::reload()); let entries = session.library_entries(); Ok(json!({"entries": entries.len(), "available": entries.iter().filter(|entry| entry.missing.is_none()).count(), "layouts": session.library.layouts})) } + +#[cfg(test)] +#[path = "node_library_commands.test.rs"] +mod tests; diff --git a/crates/engine/src/node_library_commands.test.rs b/crates/engine/src/node_library_commands.test.rs new file mode 100644 index 0000000..10774ac --- /dev/null +++ b/crates/engine/src/node_library_commands.test.rs @@ -0,0 +1,46 @@ +use super::*; +use materialcraft_core::{FunctionGraph, Graph, Package}; +use std::sync::Arc; + +/// Build a small library with one reusable function and no filesystem dependencies. +fn library(name: &str) -> Arc<NodeLibrary> { + let mut function = Graph::new(name); + function.function = Some(FunctionGraph::default()); + let mut package = Package::new("Custom library"); + package.graphs.push(function); + let mut library = NodeLibrary::default(); + library.packages.insert("sbs://custom.sbs".into(), Arc::new(package)); + Arc::new(library) +} + +/// Reload replaces owned sources and removes sources no longer installed. +#[test] +fn reload_updates_and_removes_library_owned_sources() { + let mut session = Session::with_library(Package::new("Project"), library("Before")); + + replace_library(&mut session, library("After")); + + assert!(session.library_entries().iter().any(|entry| entry.id == "sbs://custom.sbs#After")); + assert!(!session.library_entries().iter().any(|entry| entry.id == "sbs://custom.sbs#Before")); + + replace_library(&mut session, Arc::new(NodeLibrary::default())); + + assert!(!session.pkg.dependencies.contains_key("sbs://custom.sbs")); + assert!(!session.library_entries().iter().any(|entry| entry.id.starts_with("sbs://custom.sbs#"))); + assert!(!session.modified); +} + +/// Opening a package transfers dependency ownership even after initial session construction. +#[test] +fn reload_keeps_dependencies_supplied_by_later_opened_packages() { + let mut session = Session::with_library(Package::new("First"), library("Original")); + let custom = library("User_function"); + let mut package = Package::new("Second"); + package.dependencies = custom.packages.clone(); + session.open_package(package, None).unwrap(); + + replace_library(&mut session, library("Replacement")); + + assert!(session.library_entries().iter().any(|entry| entry.id == "sbs://custom.sbs#User_function")); + assert!(!session.library_entries().iter().any(|entry| entry.id == "sbs://custom.sbs#Replacement")); +} diff --git a/crates/engine/src/open_document.rs b/crates/engine/src/open_document.rs index df40c19..8781f1c 100644 --- a/crates/engine/src/open_document.rs +++ b/crates/engine/src/open_document.rs @@ -10,6 +10,7 @@ pub struct OpenDocument { pub modified: bool, selection: Vec<NodeId>, annotation_selection: Option<AnnotationSelection>, + annotation_target: crate::AnnotationTarget, view2d: View2d, view3d: View3d, material_preview: MaterialPreview, @@ -26,6 +27,7 @@ impl OpenDocument { graph: self.graph, selection: self.selection.clone(), annotation_selection: self.annotation_selection, + annotation_target: self.annotation_target.clone(), material_preview: self.material_preview.clone(), label: label.into(), modified: self.modified, @@ -40,6 +42,7 @@ impl OpenDocument { self.graph = snapshot.graph.min(self.pkg.graphs.len().saturating_sub(1)); self.selection = snapshot.selection; self.annotation_selection = snapshot.annotation_selection; + self.annotation_target = snapshot.annotation_target; self.material_preview = snapshot.material_preview; self.modified = snapshot.modified; } @@ -90,6 +93,7 @@ impl OpenDocument { modified: false, selection: Vec::new(), annotation_selection: None, + annotation_target: Default::default(), view2d: View2d::default(), view3d: View3d::default(), load_warnings: Vec::new(), @@ -114,6 +118,7 @@ impl OpenDocument { modified, selection, annotation_selection, + annotation_target, view2d, view3d, material_preview, diff --git a/crates/engine/src/pin_commands.rs b/crates/engine/src/pin_commands.rs new file mode 100644 index 0000000..8a92275 --- /dev/null +++ b/crates/engine/src/pin_commands.rs @@ -0,0 +1,65 @@ +use crate::commands::{CommandSpec, bad, has_graph, point, strp, u64p}; +use crate::{AnnotationSelection, AnnotationTarget, Result, Session, cmd}; +use materialcraft_core::Pin; +use serde_json::{Value, json}; + +/// Register navigation pin creation, description/position editing and deletion. +pub(crate) fn specs() -> Vec<CommandSpec> { + vec![ + cmd!("graph.pin.add", "Add Navigation pin", [], None, "{name?, description?, at? [x, y], function?, pattern?}", has_graph, add), + cmd!("graph.pin.edit", "Edit Navigation pin", [], None, "{id, description?, at? [x, y], function?, pattern?}", has_graph, edit), + cmd!("graph.pin.delete", "Delete pin", [], None, "{id, function?, pattern?}", has_graph, delete), + ] +} + +fn add(session: &mut Session, parameters: &Value) -> Result<Value> { + let target = AnnotationTarget::resolve(session, parameters)?; + let mut items = target.items(session)?; + let id = target.next_id(session, &items)?; + let name = + strp(parameters, "description").or_else(|| strp(parameters, "name")).map(str::to_string).unwrap_or_else(|| format!("Pin {}", items.pins.len() + 1)); + let pos = point(parameters, "at").unwrap_or([0.0; 2]); + items.pins.push(Pin { id, name, pos }); + + session.edit("Add pin", |session| { + target.replace(session, items)?; + session.selection.clear(); + session.annotation_target = target; + session.annotation_selection = Some(AnnotationSelection::Pin(id)); + Ok(json!({"id": id})) + }) +} + +fn edit(session: &mut Session, parameters: &Value) -> Result<Value> { + let target = AnnotationTarget::resolve(session, parameters)?; + let id = u64p(parameters, "id").ok_or_else(|| bad("graph.pin.edit", "`id` is required"))?; + let mut items = target.items(session)?; + let pin = items.pins.iter_mut().find(|pin| pin.id == id).ok_or_else(|| bad("graph.pin.edit", format!("no pin {id}")))?; + if let Some(description) = strp(parameters, "description").or_else(|| strp(parameters, "name")) { + pin.name = description.into(); + } + if let Some(position) = point(parameters, "at") { + pin.pos = position; + } + + session.edit_merged(&format!("pin:{target:?}:{id}"), "Edit pin", |session| { + target.replace(session, items)?; + Ok(Value::Null) + }) +} + +fn delete(session: &mut Session, parameters: &Value) -> Result<Value> { + let target = AnnotationTarget::resolve(session, parameters)?; + let id = u64p(parameters, "id").ok_or_else(|| bad("graph.pin.delete", "`id` is required"))?; + let mut items = target.items(session)?; + let previous = items.pins.len(); + items.pins.retain(|pin| pin.id != id); + if previous == items.pins.len() { + return Err(bad("graph.pin.delete", format!("no pin {id}"))); + } + + session.edit("Delete pin", |session| { + target.replace(session, items)?; + Ok(Value::Null) + }) +} diff --git a/crates/engine/src/session.rs b/crates/engine/src/session.rs index 03517e8..38b9ce9 100644 --- a/crates/engine/src/session.rs +++ b/crates/engine/src/session.rs @@ -123,6 +123,8 @@ pub struct Session { pub(crate) next_document_id: u64, pub(crate) documents: std::collections::BTreeMap<u64, crate::OpenDocument>, pub(crate) linked_sources: std::collections::BTreeMap<String, Arc<Package>>, + /// Snapshots inserted by the library, excluding explicitly supplied dependencies + pub(crate) library_sources: std::collections::BTreeMap<String, Arc<Package>>, pub pkg: Package, /// Where the package was opened from or last saved to. pub path: Option<String>, @@ -130,6 +132,7 @@ pub struct Session { pub graph: usize, pub selection: Vec<NodeId>, pub annotation_selection: Option<AnnotationSelection>, + pub annotation_target: crate::AnnotationTarget, pub view2d: View2d, pub view3d: View3d, pub material_preview: crate::MaterialPreview, @@ -165,10 +168,19 @@ pub struct Session { } impl Session { - pub fn new(mut pkg: Package) -> Session { - let library = crate::node_library::NodeLibrary::shared(); + /// Open a package with the process's installed node library. + pub fn new(pkg: Package) -> Session { + Self::with_library(pkg, crate::node_library::NodeLibrary::shared()) + } + + /// Open a package with an explicit library, preserving dependencies supplied by the caller. + pub fn with_library(mut pkg: Package, library: Arc<crate::NodeLibrary>) -> Session { + let mut library_sources = std::collections::BTreeMap::new(); for (path, package) in &library.packages { - pkg.dependencies.entry(path.clone()).or_insert_with(|| package.clone()); + if let std::collections::btree_map::Entry::Vacant(entry) = pkg.dependencies.entry(path.clone()) { + entry.insert(package.clone()); + library_sources.insert(path.clone(), package.clone()); + } } let mut session = Session { environment: Default::default(), @@ -177,6 +189,7 @@ impl Session { next_document_id: 1, documents: std::collections::BTreeMap::new(), linked_sources: pkg.dependencies.clone(), + library_sources, material_preview: crate::MaterialPreview::for_graph(&pkg, 0), cooked_graph: None, material_cooked: std::collections::BTreeMap::new(), @@ -185,6 +198,7 @@ impl Session { graph: 0, selection: Vec::new(), annotation_selection: None, + annotation_target: Default::default(), view2d: View2d { channel: "rgba".into(), ..View2d::default() }, view3d: View3d::default(), preview_size: Some(512), @@ -232,6 +246,7 @@ impl Session { graph: self.graph, selection: self.selection.clone(), annotation_selection: self.annotation_selection, + annotation_target: self.annotation_target.clone(), material_preview: self.material_preview.clone(), label: label.into(), modified: self.modified, @@ -330,6 +345,7 @@ impl Session { self.graph = s.graph.min(self.pkg.graphs.len().saturating_sub(1)); self.selection = s.selection; self.annotation_selection = s.annotation_selection; + self.annotation_target = s.annotation_target; self.material_preview = s.material_preview; self.modified = s.modified; self.dirty = s.dirty || self.cook_epoch != s.cook_epoch; diff --git a/crates/engine/src/snapshot.rs b/crates/engine/src/snapshot.rs index 4fe9829..cf70834 100644 --- a/crates/engine/src/snapshot.rs +++ b/crates/engine/src/snapshot.rs @@ -7,6 +7,7 @@ pub(crate) struct Snapshot { pub(crate) graph: usize, pub(crate) selection: Vec<NodeId>, pub(crate) annotation_selection: Option<AnnotationSelection>, + pub(crate) annotation_target: crate::AnnotationTarget, pub(crate) material_preview: crate::MaterialPreview, pub(crate) label: String, pub(crate) modified: bool, diff --git a/crates/engine/tests/it/annotations.rs b/crates/engine/tests/it/annotations.rs index 6ab91d0..5043728 100644 --- a/crates/engine/tests/it/annotations.rs +++ b/crates/engine/tests/it/annotations.rs @@ -66,3 +66,110 @@ fn annotation_properties_and_selection_survive_edits_undo_and_native_save() { assert!(session.graph().unwrap().frames.is_empty()); assert_eq!(session.graph().unwrap().comments.len(), 1); } + +/// Pins share annotation selection, properties, deletion and undo. +#[test] +fn navigation_pins_select_edit_delete_and_save() { + for kind in ["material", "function"] { + let mut session = new_session(); + if kind == "function" { + execute(&mut session, "file.new", &json!({"kind": kind})).unwrap(); + } + let id = execute(&mut session, "graph.pin.add", &json!({"at": [-64, 128]})).unwrap()["id"].as_u64().unwrap(); + execute(&mut session, "graph.annotation.select", &json!({"kind": "pin", "id": id})).unwrap(); + execute(&mut session, "graph.pin.edit", &json!({"id": id, "description": "Start & <finish>", "at": [48, -96]})).unwrap(); + let loaded = read_sbs(&write_sbs(&session.pkg).unwrap(), "pins.sbs", &|_| None).unwrap(); + assert!(loaded.warnings.is_empty()); + let graph = loaded.pkg.graph_by_name(&session.graph().unwrap().sbs_path()).unwrap().1; + assert_eq!(graph.pins[0].name, "Start & <finish>"); + assert_eq!(graph.pins[0].pos, [48.0, -96.0]); + + execute(&mut session, "edit.delete", &json!({})).unwrap(); + assert!(session.graph().unwrap().pins.is_empty()); + assert!(session.annotation_selection.is_none()); + session.undo().unwrap(); + assert_eq!(session.graph().unwrap().pins[0].name, "Start & <finish>"); + assert_eq!(serde_json::to_value(session.annotation_selection).unwrap(), json!({"kind": "pin", "id": id})); + let original = session.pkg.clone(); + assert!(execute(&mut session, "graph.pin.edit", &json!({"id": 999999, "description": "Missing"})).is_err()); + assert_eq!(session.pkg, original); + } +} + +/// Every graph item edits its destination canvas and survives native SBS save/reload. +#[test] +fn library_graph_items_work_in_material_function_and_embedded_canvases() { + use materialcraft_engine::{ + AnnotationTarget, FunctionGraphTarget, Session, + core::{FunctionGraph, NodeId, Value}, + }; + for kind in ["material", "function", "pixel_processor", "value_processor", "dynamic", "fx_map"] { + let mut session = new_session(); + let target = match kind { + "material" => AnnotationTarget::Graph, + "function" => { + execute(&mut session, "file.new", &json!({"kind": "function"})).unwrap(); + AnnotationTarget::Graph + } + _ => { + let definition = if kind == "dynamic" { "uniform" } else { kind }; + let node = NodeId(execute(&mut session, "graph.node.add", &json!({"def": definition})).unwrap()["id"].as_u64().unwrap()); + match kind { + "fx_map" => AnnotationTarget::Pattern { owner: node }, + "dynamic" => { + session.graph_mut().unwrap().node_mut(node).unwrap().functions.insert("color".into(), FunctionGraph::default()); + AnnotationTarget::Function { target: FunctionGraphTarget::Dynamic { node, parameter: "color".into() } } + } + _ => AnnotationTarget::Function { target: FunctionGraphTarget::Parameter { node, parameter: "function".into() } }, + } + } + }; + let mut parameters = target.parameters(); + parameters["at"] = json!([64, 128]); + for entry in ["item:comment", "item:frame", "item:pin", "node:dot"] { + parameters["entry"] = json!(entry); + let before = session.pkg.clone(); + execute(&mut session, "library.add", ¶meters).unwrap(); + let after = session.pkg.clone(); + session.undo().unwrap(); + assert_eq!(session.pkg, before, "{kind}: {entry} undo"); + session.redo().unwrap(); + assert_eq!(session.pkg, after, "{kind}: {entry} redo"); + } + let items = target.items(&session).unwrap(); + assert_eq!((items.comments.len(), items.frames.len(), items.pins.len()), (1, 1, 1), "{kind}"); + let mut pin_parameters = target.parameters(); + pin_parameters["id"] = json!(items.pins[0].id); + pin_parameters["kind"] = json!("pin"); + execute(&mut session, "graph.annotation.select", &pin_parameters).unwrap(); + pin_parameters["description"] = json!("Checkpoint & <finish>"); + execute(&mut session, "graph.pin.edit", &pin_parameters).unwrap(); + + let loaded = read_sbs(&write_sbs(&session.pkg).unwrap(), "graph-items.sbs", &|_| None).unwrap(); + let mut reopened = Session::new(loaded.pkg); + reopened.graph = reopened.pkg.graph_by_name(&session.graph().unwrap().sbs_path()).unwrap().0; + let graph = reopened.graph().unwrap(); + let saved = match kind { + "material" | "function" => AnnotationTarget::Graph.items(&reopened).unwrap(), + "fx_map" => match &graph.nodes.iter().find(|node| node.def == kind).unwrap().params["pattern"] { + Value::PatternGraph(graph) => graph.annotations.clone(), + other => panic!("unexpected {other:?}"), + }, + "dynamic" => graph.nodes.iter().find(|node| node.def == "uniform").unwrap().functions["color"].annotations.clone(), + _ => match &graph.nodes.iter().find(|node| node.def == kind).unwrap().params["function"] { + Value::Function(graph) => graph.annotations.clone(), + other => panic!("unexpected {other:?}"), + }, + }; + assert_eq!((saved.comments.len(), saved.frames.len(), saved.pins.len()), (1, 1, 1), "{kind}"); + assert_eq!(saved.pins[0].name, "Checkpoint & <finish>", "{kind}"); + assert_eq!(saved.pins[0].pos, [64.0, 128.0], "{kind}"); + if target != AnnotationTarget::Graph { + assert!(graph.frames.is_empty() && graph.comments.is_empty() && graph.pins.is_empty(), "{kind}: parent must stay untouched"); + } + execute(&mut session, "edit.delete", &json!({})).unwrap(); + assert!(target.items(&session).unwrap().pins.is_empty(), "{kind}"); + session.undo().unwrap(); + assert_eq!(target.items(&session).unwrap().pins[0].name, "Checkpoint & <finish>"); + } +} diff --git a/crates/engine/tests/it/embedded_edit.rs b/crates/engine/tests/it/embedded_edit.rs index 32bf8ad..1227d96 100644 --- a/crates/engine/tests/it/embedded_edit.rs +++ b/crates/engine/tests/it/embedded_edit.rs @@ -594,20 +594,19 @@ fn processor_node_availability_is_shared_and_preserves_existing_sampler_graphs() let target = FunctionGraphTarget::Parameter { node, parameter: "function".into() }; let operations: Vec<_> = target.available_operations(&session).map(|operation| operation.id).collect(); let full_catalog = materialcraft_engine::nodes::function::FUNCTIONS; - let sampling = definition == "pixel_processor"; - assert_eq!(operations.len(), full_catalog.len() - if sampling { 0 } else { 2 }); + assert_eq!(operations.len(), full_catalog.len()); assert!(operations.contains(&"add")); for sampler in ["samplelum", "samplecol"] { - assert_eq!(operations.contains(&sampler), sampling); + assert!(operations.contains(&sampler)); let original = session.pkg.clone(); - let history = session.history(); - let result = - execute(&mut session, "graph.function.edit", &json!({"target": target, "edit": {"action": "add", "operation": sampler, "at": [0, 0]}})); - assert_eq!(result.is_ok(), sampling); - if !sampling { - assert_eq!(session.pkg, original); - assert_eq!(session.history(), history); - } + + execute(&mut session, "graph.function.edit", &json!({"target": target, "edit": {"action": "add", "operation": sampler, "at": [0, 0]}})).unwrap(); + + let inserted = session.pkg.clone(); + session.undo().unwrap(); + assert_eq!(session.pkg, original); + session.redo().unwrap(); + assert_eq!(session.pkg, inserted); } let mut existing = FunctionGraph::default(); existing.add("samplelum", &[], Some(Value::Int2([0, 1]))); @@ -619,3 +618,41 @@ fn processor_node_availability_is_shared_and_preserves_existing_sampler_graphs() assert_eq!(target.available_operations(&session).count(), materialcraft_engine::nodes::function::FUNCTIONS.len()); } } + +#[test] +fn library_samplers_read_image_inputs_in_both_processors() { + for definition in ["pixel_processor", "value_processor"] { + for sampler in ["samplelum", "samplecol"] { + let mut session = new_session(); + session.preview_size = Some(16); + let color = [0.25, 0.5, 0.75, 1.0]; + let image = NodeId( + execute(&mut session, "graph.node.add", &json!({"def": "uniform", "params": {"color_mode": true, "color": color}})).unwrap()["id"] + .as_u64() + .unwrap(), + ); + let parameters = if definition == "pixel_processor" { json!({"color_mode": sampler == "samplecol"}) } else { json!({}) }; + let owner = NodeId(execute(&mut session, "graph.node.add", &json!({"def": definition, "params": parameters})).unwrap()["id"].as_u64().unwrap()); + session.graph_mut().unwrap().connect(image, "output", owner, "input0").unwrap(); + let target = FunctionGraphTarget::Parameter { node: owner, parameter: "function".into() }; + let mut function = FunctionGraph::default(); + let position = function.add_constant(Value::Float2([0.5; 2])); + execute(&mut session, "graph.function.set", &json!({"target": target, "function": function})).unwrap(); + + let result = execute(&mut session, "library.add", &json!({"entry": format!("function:{sampler}"), "function": target, "at": [160, 0]})).unwrap(); + let id = result["result"]["id"].as_u64().unwrap(); + execute(&mut session, "graph.function.edit", &json!({"target": target, "edit": {"action": "connect", "from": position, "to": id, "input": 0}})) + .unwrap(); + execute(&mut session, "graph.function.edit", &json!({"target": target, "edit": {"action": "output", "id": id}})).unwrap(); + session.cook(); + + if definition == "value_processor" { + let expected = if sampler == "samplecol" { Value::Float4(color) } else { Value::Float(color[0]) }; + assert_eq!(session.cooked.value(owner, 0), Some(&expected)); + } else { + let expected = if sampler == "samplecol" { color } else { [color[0], color[0], color[0], 1.0] }; + assert_eq!(session.cooked.image(owner, 0).unwrap().get(0, 0, false), expected); + } + } + } +} diff --git a/crates/engine/tests/it/node_library.rs b/crates/engine/tests/it/node_library.rs index 720c6e6..0b97843 100644 --- a/crates/engine/tests/it/node_library.rs +++ b/crates/engine/tests/it/node_library.rs @@ -1,17 +1,22 @@ use materialcraft_engine::{ Session, core::{FunctionGraph, Graph, Package}, - execute, new_session, + execute, }; use serde_json::{Value, json}; +#[path = "../support/node_library.rs"] +mod fixture; + +/// Return the catalog entries exposed by the library command. fn entries(session: &mut Session, parameters: Value) -> Vec<Value> { execute(session, "library.tree", ¶meters).unwrap()["entries"].as_array().unwrap().clone() } +/// Catalog filters preserve matching entries and reject unknown canvases. #[test] fn the_library_tree_lists_categories_and_filters_entries() { - let mut session = new_session(); + let mut session = fixture::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"]); @@ -21,19 +26,21 @@ fn the_library_tree_lists_categories_and_filters_entries() { let constants = entries(&mut session, json!({"category": "Functions/Constant"})); assert!(constants.iter().any(|entry| entry["label"] == "Pi")); let functions = entries(&mut session, json!({"category": "Functions"})); - assert_eq!(functions.len(), 171, "every bundled function, across the sub-categories"); + let expected = fixture::library().packages["sbs://functions.sbs"].graphs.iter().filter(|graph| graph.function.is_some()).count(); + assert_eq!(functions.len(), expected, "every bundled function, across the sub-categories"); assert!(entries(&mut session, json!({})).iter().all(|entry| entry["missing"].is_null())); assert!(entries(&mut session, json!({"category": "Texture generators"})).is_empty()); 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!(functions.iter().all(|entry| entry["canvas"] == "function" || entry["canvas"] == "any")); assert!(execute(&mut session, "library.tree", &json!({"canvas": "teapot"})).is_err()); } +/// Library additions use compatible canvases and participate in undo. #[test] fn library_entries_add_to_the_graph_they_fit() { - let mut session = new_session(); + let mut session = fixture::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"); @@ -51,6 +58,7 @@ fn library_entries_add_to_the_graph_they_fit() { 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()); @@ -59,7 +67,7 @@ fn library_entries_add_to_the_graph_they_fit() { let mut graph = Graph::new("Caller"); graph.function = Some(FunctionGraph::default()); package.graphs.push(graph); - let mut session = Session::new(package); + let mut session = Session::with_library(package, fixture::library()); 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(); @@ -71,12 +79,32 @@ fn library_entries_add_to_the_graph_they_fit() { assert_eq!(session.graph().unwrap().function.as_ref().unwrap().nodes.len(), 1); } +/// Reload reports the installed catalog without modifying an unrelated graph. #[test] fn reloading_the_library_keeps_open_work_unmodified() { - let mut session = new_session(); + let mut session = fixture::session(); let reloaded = execute(&mut session, "library.reload", &json!({})).unwrap(); - assert!(reloaded["entries"].as_u64().unwrap() > 250); - assert_eq!(reloaded["available"], reloaded["entries"]); + let entries = session.library_entries(); + assert_eq!(reloaded["entries"].as_u64(), Some(entries.len() as u64)); + assert_eq!(reloaded["available"].as_u64(), Some(entries.iter().filter(|entry| entry.missing.is_none()).count() as u64)); assert!(!session.modified); - assert!(session.pkg.dependencies.contains_key("sbs://functions.sbs")); + assert!(session.library.packages.keys().all(|path| session.pkg.dependencies.contains_key(path))); +} + +/// Reload must retain an explicitly supplied package even when its alias matches the library. +#[test] +fn review_reload_preserves_user_library_alias() { + let mut dependency = Package::new("User functions"); + let mut function = Graph::new("User_function"); + function.function = Some(FunctionGraph::default()); + dependency.graphs.push(function); + let mut package = Package::new("Project"); + package.graphs.push(Graph::new("Material")); + package.dependencies.insert("sbs://functions.sbs".into(), std::sync::Arc::new(dependency.clone())); + let mut session = Session::with_library(package, fixture::library()); + + execute(&mut session, "library.reload", &json!({})).unwrap(); + + assert!(session.pkg.dependencies["sbs://functions.sbs"].graphs == dependency.graphs, "the user dependency was replaced"); + assert!(entries(&mut session, json!({})).iter().any(|entry| entry["id"] == "sbs://functions.sbs#User_function")); } diff --git a/crates/engine/tests/support/node_library.rs b/crates/engine/tests/support/node_library.rs new file mode 100644 index 0000000..1af8ecd --- /dev/null +++ b/crates/engine/tests/support/node_library.rs @@ -0,0 +1,27 @@ +//! An isolated catalog fixture shared by the library unit and integration tests. + +use materialcraft_core::{Graph, Package}; +use materialcraft_engine::{NodeLibrary, Session}; +use std::sync::{Arc, OnceLock}; + +/// Load only the embedded functions, independent of the installed library directory. +pub fn library() -> Arc<NodeLibrary> { + static LIBRARY: OnceLock<Arc<NodeLibrary>> = OnceLock::new(); + LIBRARY + .get_or_init(|| { + let read = materialcraft_formats::sbs::read_sbs(include_bytes!("../../../../assets/sbs/functions.sbs"), "sbs://functions.sbs", &|_| None).unwrap(); + assert!(read.warnings.is_empty(), "{:?}", read.warnings); + let mut library = NodeLibrary::default(); + library.packages.insert("sbs://functions.sbs".into(), Arc::new(read.pkg)); + Arc::new(library) + }) + .clone() +} + +/// Start an empty material graph with the isolated bundled library. +#[allow(dead_code)] +pub fn session() -> Session { + let mut package = Package::new("Library tests"); + package.graphs.push(Graph::new("Material")); + Session::with_library(package, library()) +} diff --git a/crates/eval/src/tests.rs b/crates/eval/src/tests.rs index ee5991b..4684531 100644 --- a/crates/eval/src/tests.rs +++ b/crates/eval/src/tests.rs @@ -265,7 +265,11 @@ fn input_change_recooks_only_readers() { value: Some(Value::Text("a".into())), pos: [0.0; 2], }; - p.graphs[0].node_mut(reader).unwrap().params.insert("function".into(), Value::Function(Box::new(FunctionGraph { nodes: vec![get_a], output: Some(1) }))); + p.graphs[0] + .node_mut(reader) + .unwrap() + .params + .insert("function".into(), Value::Function(Box::new(FunctionGraph { nodes: vec![get_a], output: Some(1), ..Default::default() }))); let cache = &Mutex::new(Cache::default()); let mut opts = Options::new(&no_res); opts.overrides.insert("a".into(), Value::Float(0.25)); diff --git a/crates/formats/examples/standard_function_library/convert.rs b/crates/formats/examples/standard_function_library/convert.rs index 6c88540..19e7912 100644 --- a/crates/formats/examples/standard_function_library/convert.rs +++ b/crates/formats/examples/standard_function_library/convert.rs @@ -32,11 +32,9 @@ pub(super) fn package(bytes: &[u8], source: &str) -> Result<Package, Box<dyn std graph.exposed.iter().map(|parameter| parameter.id.as_str()).collect::<Vec<_>>().join(", ") }; graph.attributes.description = format!("Evaluates the {} function graph. Result type: {}. Inputs: {inputs}.", graph.name, result.label()); - graph.attributes.category = graph.folder.clone(); graph.attributes.author.clear(); graph.attributes.author_url.clear(); graph.attributes.user_data.clear(); - graph.attributes.tags.clear(); graph.frames.clear(); graph.comments.clear(); graph.pins.clear(); diff --git a/crates/formats/examples/standard_function_library/tests.rs b/crates/formats/examples/standard_function_library/tests.rs index 45bcdff..1d82f19 100644 --- a/crates/formats/examples/standard_function_library/tests.rs +++ b/crates/formats/examples/standard_function_library/tests.rs @@ -10,7 +10,8 @@ fn conversion_preserves_function_bodies_and_replaces_presentation_metadata() { graph.attributes.author = "Source author".into(); graph.attributes.author_url = "https://example.org/source".into(); graph.attributes.user_data = "Source notes".into(); - graph.attributes.tags = "Source tags".into(); + graph.attributes.category = "Function".into(); + graph.attributes.tags = "Maths".into(); graph.function_type = 256; let mut body = FunctionGraph::default(); let left = body.add_constant(Value::Float(1.0)); @@ -30,7 +31,10 @@ fn conversion_preserves_function_bodies_and_replaces_presentation_metadata() { assert!(converted.graphs[0].attributes.author.is_empty()); assert!(converted.graphs[0].attributes.author_url.is_empty()); assert!(converted.graphs[0].attributes.user_data.is_empty()); - assert!(converted.graphs[0].attributes.tags.is_empty()); + assert_eq!(converted.graphs[0].attributes.category, "Function"); + assert_eq!(converted.graphs[0].attributes.tags, "Maths"); + assert_eq!(reopened.graphs[0].attributes.category, "Function"); + assert_eq!(reopened.graphs[0].attributes.tags, "Maths"); assert_eq!(converted.graphs[0].function, reopened.graphs[0].function); let mut restored = converted.graphs[0].function.clone().unwrap(); let original = imported.graphs[0].function.as_ref().unwrap(); @@ -64,3 +68,21 @@ fn layout_separates_nodes_and_rejects_invalid_connections_without_partial_edits( function.nodes[0].inputs = vec![Some(9999)]; assert!(super::layout::reposition(&mut function).unwrap_err().contains("missing node")); } + +#[test] +fn conversion_preserves_empty_classification_attributes() { + let mut package = Package::new("Functions"); + let mut graph = Graph::new("EmptyMetadata"); + graph.folder = "Functions/Math".into(); + let mut function = FunctionGraph::default(); + function.output = Some(function.add_constant(Value::Float(1.0))); + graph.function = Some(function); + graph.function_type = 256; + package.graphs.push(graph); + let bytes = write_sbs(&package).unwrap(); + + let converted = super::convert::package(&bytes, "source.sbs").unwrap(); + + assert!(converted.graphs[0].attributes.category.is_empty()); + assert!(converted.graphs[0].attributes.tags.is_empty()); +} diff --git a/crates/formats/src/sbs/canvas.rs b/crates/formats/src/sbs/canvas.rs index c4d536f..1aec328 100644 --- a/crates/formats/src/sbs/canvas.rs +++ b/crates/formats/src/sbs/canvas.rs @@ -8,9 +8,13 @@ use roxmltree::Node as XmlNode; use std::fmt::Write as _; pub(super) fn write_canvas_items(output: &mut String, graph: &Graph, writer: &mut SbsWriter) { + write_items(output, &graph.frames, &graph.comments, &graph.pins, writer); +} + +pub(super) fn write_items(output: &mut String, frames: &[Frame], comments: &[Comment], pins: &[Pin], writer: &mut SbsWriter) { output.push_str("<GUIObjects>"); - for frame in &graph.frames { + for frame in frames { let [x, y, width, height] = frame.rect.map(format_float); let [red, green, blue] = [0, 1, 2].map(|channel| format_float(linear_to_srgb(frame.color[channel]))); let _ = write!( @@ -24,7 +28,7 @@ pub(super) fn write_canvas_items(output: &mut String, graph: &Graph, writer: &mu ); } - for comment in &graph.comments { + for comment in comments { let [x, y] = comment.pos.map(format_float); let [width, height] = comment.size.map(format_float); let _ = write!( @@ -35,7 +39,7 @@ pub(super) fn write_canvas_items(output: &mut String, graph: &Graph, writer: &mu ); } - for pin in &graph.pins { + for pin in pins { let [x, y] = pin.pos.map(format_float); let _ = write!( output, @@ -85,3 +89,10 @@ pub(super) fn read_canvas_items(element: XmlNode, graph: &mut Graph, warnings: & } } } + +/// Embedded canvases use the same GUIObjects schema as document graphs. +pub(super) fn read_embedded(element: XmlNode) -> materialcraft_core::CanvasAnnotations { + let mut graph = Graph::new("embedded"); + read_canvas_items(element, &mut graph, &mut Warnings::default()); + materialcraft_core::CanvasAnnotations { frames: graph.frames, comments: graph.comments, pins: graph.pins } +} diff --git a/crates/formats/src/sbs/function_graph.rs b/crates/formats/src/sbs/function_graph.rs index f07c4ea..fee5210 100644 --- a/crates/formats/src/sbs/function_graph.rs +++ b/crates/formats/src/sbs/function_graph.rs @@ -8,7 +8,11 @@ use std::collections::{BTreeMap, BTreeSet}; use std::fmt::Write; pub(super) fn read(element: XmlNode<'_, '_>) -> Result<FunctionGraph, String> { - let mut graph = FunctionGraph { output: child_value(element, "rootnode").and_then(|value| value.parse().ok()), nodes: Vec::new() }; + let mut graph = FunctionGraph { + output: child_value(element, "rootnode").and_then(|value| value.parse().ok()), + nodes: Vec::new(), + annotations: super::canvas::read_embedded(element), + }; let mut ids = BTreeSet::new(); for element in child_element(element, "paramNodes").into_iter().flat_map(|nodes| children_named(nodes, "paramNode")) { if graph.nodes.len() >= 4096 { @@ -153,7 +157,11 @@ pub(super) fn write(graph: &FunctionGraph, writer: &mut SbsWriter) -> Result<Str } output.push_str("</paramNode>"); } - output.push_str("</paramNodes></dynamicValue>"); + output.push_str("</paramNodes>"); + if !graph.annotations.is_empty() { + super::canvas::write_items(&mut output, &graph.annotations.frames, &graph.annotations.comments, &graph.annotations.pins, writer); + } + output.push_str("</dynamicValue>"); Ok(output) } diff --git a/crates/formats/src/sbs/layout_frame.rs b/crates/formats/src/sbs/layout_frame.rs new file mode 100644 index 0000000..4a5396b --- /dev/null +++ b/crates/formats/src/sbs/layout_frame.rs @@ -0,0 +1,10 @@ +use super::LayoutItem; + +/// 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>, +} diff --git a/crates/formats/src/sbs/layout_item.rs b/crates/formats/src/sbs/layout_item.rs new file mode 100644 index 0000000..49450cc --- /dev/null +++ b/crates/formats/src/sbs/layout_item.rs @@ -0,0 +1,17 @@ +/// 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 }, +} diff --git a/crates/formats/src/sbs/library.rs b/crates/formats/src/sbs/library.rs index 535ebeb..14ada77 100644 --- a/crates/formats/src/sbs/library.rs +++ b/crates/formats/src/sbs/library.rs @@ -10,6 +10,7 @@ pub fn relative_path(uri: &str) -> Result<&str, String> { { return Err("invalid SBS library path".into()); } + Ok(path) } @@ -51,15 +52,18 @@ pub fn root() -> std::path::PathBuf { if let Some(root) = std::env::var_os("MATERIALCRAFT_SBS_DIR") { return root.into(); } + if let Ok(executable) = std::env::current_exe() && let Some(parent) = executable.parent() && parent.join("assets/sbs").is_dir() { return parent.join("assets/sbs"); } + std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../assets/sbs") } +/// Read a validated library alias from the configured directory or the embedded fallback. pub fn read(uri: &str) -> Result<Vec<u8>, String> { let relative = relative_path(uri)?; #[cfg(not(target_arch = "wasm32"))] @@ -106,6 +110,7 @@ pub fn files() -> Vec<String> { BUNDLED.iter().map(|uri| uri.to_string()).collect() } +/// Discover packages in deterministic order within the depth and file limits. #[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 }; @@ -115,9 +120,11 @@ fn scan(directory: &std::path::Path, prefix: &str, depth: usize, found: &mut Vec 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); @@ -132,6 +139,7 @@ fn scan(directory: &std::path::Path, prefix: &str, depth: usize, found: &mut Vec mod tests { use super::*; + /// Discovered packages have unique valid aliases and the embedded fallback is present. #[test] fn the_library_lists_every_package_once_and_bundles_a_fallback() { let files = files(); diff --git a/crates/formats/src/sbs/library_layout.rs b/crates/formats/src/sbs/library_layout.rs index c127a15..8dff9d6 100644 --- a/crates/formats/src/sbs/library_layout.rs +++ b/crates/formats/src/sbs/library_layout.rs @@ -4,6 +4,7 @@ //! which frame titles are library categories. use super::{ + LayoutFrame, LayoutItem, constant::MAX_XML_NODES, filter_map::FILTERS, xml::{child_element, child_value, children_named, parse_floats}, @@ -16,33 +17,6 @@ use std::collections::HashMap; 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}")))?; @@ -57,8 +31,8 @@ pub fn read_layout(bytes: &[u8], uri: &str) -> Result<Vec<LayoutFrame>> { 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 file = if file == "?himself" { uri.to_string() } else { super::library::resolve(uri, file).map_err(FormatError::BadPackage)? }; + dependencies.insert(uid, file); } } @@ -85,6 +59,7 @@ pub fn read_layout(bytes: &[u8], uri: &str) -> Result<Vec<LayoutFrame>> { 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() @@ -95,6 +70,7 @@ pub fn read_layout(bytes: &[u8], uri: &str) -> Result<Vec<LayoutFrame>> { 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)); @@ -112,6 +88,7 @@ pub fn read_layout(bytes: &[u8], uri: &str) -> Result<Vec<LayoutFrame>> { if frames.len() >= MAX_FRAMES { break; } + frames.push(LayoutFrame { title, function, items }); } } @@ -136,6 +113,7 @@ fn scope_frames(scope: XmlNode) -> Vec<(String, [f32; 4])> { .collect() } +/// Read a node position when its layout has both coordinates. fn position(node: XmlNode) -> Option<[f32; 2]> { let at = parse_floats(child_value(child_element(node, "GUILayout")?, "gpos")?); Some([*at.first()?, *at.get(1)?]) @@ -151,6 +129,7 @@ fn reference(path: &str, dependencies: &HashMap<&str, String>) -> Option<(String (!graph.is_empty()).then(|| (graph.chars().take(1024).collect(), package)) } +/// Translate a graph node into a library placement without cooking it. 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() { @@ -163,6 +142,7 @@ fn graph_item(graph: XmlNode, node: XmlNode, dependencies: &HashMap<&str, String 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" => { @@ -193,6 +173,7 @@ fn graph_item(graph: XmlNode, node: XmlNode, dependencies: &HashMap<&str, String } } +/// Translate a native operation or reusable function reference into a placement. fn function_item(node: XmlNode, dependencies: &HashMap<&str, String>) -> Option<LayoutItem> { let operation = child_value(node, "function")?; if operation != "instance" { @@ -209,6 +190,7 @@ fn function_item(node: XmlNode, dependencies: &HashMap<&str, String>) -> Option< Some(LayoutItem::FunctionInstance { package, graph }) } +/// Read a named static string parameter from an atomic filter. fn string_parameter<'a>(filter: XmlNode<'a, '_>, name: &str) -> Option<&'a str> { child_element(filter, "parameters") .into_iter() @@ -251,6 +233,7 @@ mod tests { <GUIObject><type v="COMMENT"/><GUILayout><gpos v="0 0 0"/><size v="10 10"/></GUILayout></GUIObject> </GUIObjects></graph></content></package>"#; + /// Frames preserve spatial ordering and distinguish material and function entries. #[test] fn frames_list_what_sits_inside_them_top_to_bottom() { let frames = read_layout(LAYOUT.as_bytes(), "sbs://layout.sbs").unwrap(); @@ -274,6 +257,7 @@ mod tests { assert_eq!(function[1].items, vec![LayoutItem::FunctionInstance { package: "sbs://functions.sbs".into(), graph: "Functions/Math/Pi".into() }]); } + /// Missing layouts and malformed input remain nonfatal. #[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()); @@ -281,4 +265,17 @@ mod tests { 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()); } + + /// Relative layout references resolve beside the layout, including parent directories. + #[test] + fn review_layout_resolves_relative_dependencies() { + let layout = LAYOUT.replace("sbs://noise.sbs", "../noise.sbs").replace("sbs://functions.sbs", "functions.sbs"); + + let frames = read_layout(layout.as_bytes(), "sbs://layouts/library.sbs").unwrap(); + + assert!(frames.iter().flat_map(|frame| &frame.items).any(|item| matches!(item, + LayoutItem::Instance { package, .. } if package == "sbs://noise.sbs"))); + assert!(frames.iter().flat_map(|frame| &frame.items).any(|item| matches!(item, + LayoutItem::FunctionInstance { package, .. } if package == "sbs://layouts/functions.sbs"))); + } } diff --git a/crates/formats/src/sbs/mod.rs b/crates/formats/src/sbs/mod.rs index ea54381..583e6d6 100644 --- a/crates/formats/src/sbs/mod.rs +++ b/crates/formats/src/sbs/mod.rs @@ -11,6 +11,8 @@ mod graph_attributes; mod group_layout; mod image_input; mod input_bridge; +mod layout_frame; +mod layout_item; pub mod library; mod library_layout; mod node_identifiers; @@ -30,7 +32,9 @@ mod warnings; mod xml; pub use constant::SBS_EXT; -pub use library_layout::{LayoutFrame, LayoutItem, read_layout}; +pub use layout_frame::LayoutFrame; +pub use layout_item::LayoutItem; +pub use library_layout::read_layout; pub use read::{is_sbs, read_sbs}; pub use sbs_read::SbsRead; pub use write::write_sbs; diff --git a/crates/formats/src/sbs/pattern_graph.rs b/crates/formats/src/sbs/pattern_graph.rs index 6e707ad..6fa72c8 100644 --- a/crates/formats/src/sbs/pattern_graph.rs +++ b/crates/formats/src/sbs/pattern_graph.rs @@ -32,7 +32,11 @@ pub(super) fn read(element: XmlNode<'_, '_>) -> Result<PatternGraph, String> { } } - let mut graph = PatternGraph { root: child_value(element, "rootnode").and_then(|id| id.parse().ok()), nodes: Vec::new() }; + let mut graph = PatternGraph { + root: child_value(element, "rootnode").and_then(|id| id.parse().ok()), + nodes: Vec::new(), + annotations: super::canvas::read_embedded(element), + }; for element in child_element(element, "paramsGraphNodes").into_iter().flat_map(|nodes| children_named(nodes, "paramsGraphNode")) { if graph.nodes.len() >= 4096 { return Err("pattern graph exceeds the 4096-node limit".into()); @@ -111,6 +115,10 @@ pub(super) fn write(graph: &PatternGraph, writer: &mut SbsWriter) -> Result<Stri } output.push_str("</connections></paramsGraphNode>"); } - output.push_str("</paramsGraphNodes></paramsGraph></paramsGraphs>"); + output.push_str("</paramsGraphNodes>"); + if !graph.annotations.is_empty() { + super::canvas::write_items(&mut output, &graph.annotations.frames, &graph.annotations.comments, &graph.annotations.pins, writer); + } + output.push_str("</paramsGraph></paramsGraphs>"); Ok(output) } diff --git a/crates/formats/src/sbs/sbs_reader.rs b/crates/formats/src/sbs/sbs_reader.rs index a945775..52552db 100644 --- a/crates/formats/src/sbs/sbs_reader.rs +++ b/crates/formats/src/sbs/sbs_reader.rs @@ -184,7 +184,10 @@ impl<'text> SbsReader<'text, '_> { let dynamic = child_element(element, "paramValue").and_then(|value| child_element(value, "dynamicValue")); let function = dynamic.ok_or_else(|| "missing function body".to_string()).and_then(super::function_graph::read); graph.function = Some(match function { - Ok(function) => function, + Ok(mut function) => { + function.annotations = Default::default(); + function + } Err(error) => { self.warnings.add(format!("function graph `{name}`: {error}")); materialcraft_core::FunctionGraph::default() diff --git a/crates/formats/tests/function_library.rs b/crates/formats/tests/function_library.rs index 6b0d5e9..2a4bd94 100644 --- a/crates/formats/tests/function_library.rs +++ b/crates/formats/tests/function_library.rs @@ -167,9 +167,19 @@ fn bundled_library_has_complete_bodies_and_current_export_metadata() { assert!(function.output.is_some(), "{}", graph.sbs_path()); assert!(function.nodes.iter().all(|node| node.missing.is_none()), "{}", graph.sbs_path()); assert!(!graph.attributes.description.is_empty()); - assert!(graph.attributes.author.is_empty() && graph.attributes.tags.is_empty()); + assert!(graph.attributes.author.is_empty()); assert!(graph.frames.is_empty() && graph.comments.is_empty() && graph.pins.is_empty()); } + let pi = &read.pkg.graph_by_name("Functions/Math/Pi").unwrap().1.attributes; + assert!(pi.category.is_empty()); + assert_eq!(pi.tags, "Constant"); + let saved = write_sbs(&read.pkg).unwrap(); + let reopened = read_sbs(&saved, "functions.sbs", &|_| None).unwrap(); + for graph in &read.pkg.graphs { + let reloaded = reopened.pkg.graph_by_name(&graph.sbs_path()).unwrap().1; + assert_eq!(reloaded.attributes.category, graph.attributes.category); + assert_eq!(reloaded.attributes.tags, graph.attributes.tags); + } assert!(!xml.descendants().any(|element| element.has_tag_name("icon"))); } diff --git a/crates/ui-egui/src/annotation/comment_properties.rs b/crates/ui-egui/src/annotation/comment_properties.rs index a073e42..bdaa950 100644 --- a/crates/ui-egui/src/annotation/comment_properties.rs +++ b/crates/ui-egui/src/annotation/comment_properties.rs @@ -3,7 +3,13 @@ use egui::Ui; use serde_json::json; pub(super) fn show(app: &mut MaterialCraftApp, ui: &mut Ui, id: u64) { - let Some(mut text) = app.session.graph().ok().and_then(|graph| graph.comments.iter().find(|comment| comment.id == id)).map(|comment| comment.text.clone()) + let Some(mut text) = app + .session + .annotation_target + .items(&app.session) + .ok() + .and_then(|items| items.comments.into_iter().find(|comment| comment.id == id)) + .map(|comment| comment.text) else { return; }; diff --git a/crates/ui-egui/src/annotation/frame_properties.rs b/crates/ui-egui/src/annotation/frame_properties.rs index 7cc12e9..0748b6a 100644 --- a/crates/ui-egui/src/annotation/frame_properties.rs +++ b/crates/ui-egui/src/annotation/frame_properties.rs @@ -3,7 +3,7 @@ use egui::Ui; use serde_json::json; pub(super) fn show(app: &mut MaterialCraftApp, ui: &mut Ui, id: u64) { - let Some(mut frame) = app.session.graph().ok().and_then(|graph| graph.frames.iter().find(|frame| frame.id == id)).cloned() else { + let Some(mut frame) = app.session.annotation_target.items(&app.session).ok().and_then(|items| items.frames.into_iter().find(|frame| frame.id == id)) else { return; }; diff --git a/crates/ui-egui/src/annotation/mod.rs b/crates/ui-egui/src/annotation/mod.rs index 3068951..afe078d 100644 --- a/crates/ui-egui/src/annotation/mod.rs +++ b/crates/ui-egui/src/annotation/mod.rs @@ -1,5 +1,6 @@ mod comment_properties; mod frame_properties; +mod pin_properties; use crate::MaterialCraftApp; use egui::Ui; @@ -9,5 +10,42 @@ pub(crate) fn show(app: &mut MaterialCraftApp, ui: &mut Ui, selection: Annotatio match selection { AnnotationSelection::Frame(id) => frame_properties::show(app, ui, id), AnnotationSelection::Comment(id) => comment_properties::show(app, ui, id), + AnnotationSelection::Pin(id) => pin_properties::show(app, ui, id), + } +} + +/// Resolve the destination before an editor is temporarily borrowed for drawing. +pub(crate) fn target(app: &MaterialCraftApp) -> materialcraft_engine::AnnotationTarget { + use materialcraft_engine::{AnnotationTarget, FunctionGraphTarget}; + if let Some(target) = app.function_editor.as_ref().and_then(|editor| editor.command_target()) { + return match target { + FunctionGraphTarget::Graph => AnnotationTarget::Graph, + target => AnnotationTarget::Function { target }, + }; + } + if crate::pattern::active(app) + && let Some(editor) = &app.pattern_editor + { + return AnnotationTarget::Pattern { owner: editor.node }; + } + AnnotationTarget::Graph +} + +pub(crate) fn activate(app: &mut MaterialCraftApp, target: materialcraft_engine::AnnotationTarget) { + if app.graph.annotation_target != target { + app.session.annotation_selection = None; + app.graph.cancel_drag(); + } + app.graph.annotation_target = target; +} + +/// Read the active editor camera without replacing the parent graph's saved view. +pub(crate) fn camera(app: &MaterialCraftApp) -> crate::state::GraphCamera { + if let Some(editor) = &app.function_editor { + editor.camera() + } else if let Some(editor) = &app.pattern_editor { + editor.camera() + } else { + app.ui.graph_camera } } diff --git a/crates/ui-egui/src/annotation/pin_properties.rs b/crates/ui-egui/src/annotation/pin_properties.rs new file mode 100644 index 0000000..c6d4b4a --- /dev/null +++ b/crates/ui-egui/src/annotation/pin_properties.rs @@ -0,0 +1,28 @@ +use crate::{MaterialCraftApp, i18n::tr}; +use egui::Ui; +use serde_json::json; + +/// The SBS pin label is edited as its Description property. +pub(super) fn show(app: &mut MaterialCraftApp, ui: &mut Ui, id: u64) { + let Some(mut name) = + app.session.annotation_target.items(&app.session).ok().and_then(|items| items.pins.into_iter().find(|pin| pin.id == id)).map(|pin| pin.name) + else { + return; + }; + + crate::properties::section(ui, "pin-parameters", tr("Parameters"), |ui| { + ui.label(tr("Description")); + let description = ui.add(egui::TextEdit::multiline(&mut name).desired_rows(4).desired_width(f32::INFINITY)); + crate::widgets::name(&description, egui::Role::TextInput, "Navigation Pin description"); + if app.graph.pin_description_focus == Some(id) { + description.request_focus(); + app.graph.pin_description_focus = None; + } + if description.changed() { + app.run("graph.pin.edit", json!({"id": id, "description": name})); + } + if description.lost_focus() { + app.session.finish_edit(); + } + }); +} diff --git a/crates/ui-egui/src/control.rs b/crates/ui-egui/src/control.rs index 127fffc..90f9df9 100644 --- a/crates/ui-egui/src/control.rs +++ b/crates/ui-egui/src/control.rs @@ -311,6 +311,8 @@ fn handle_inner(app: &mut MaterialCraftApp, ctx: &egui::Context, method: &str, p crate::graph::editor_target::EditorTarget::Material => None, }, "annotationSelection": app.session.annotation_selection, + "annotationTarget": app.session.annotation_target, + "pins": app.graph.pins.iter().map(|(id, bounds)| json!({"id": id, "rect": rect(*bounds)})).collect::<Vec<_>>(), "frames": app.graph.frames.iter().map(|(id, bounds)| json!({"id": id, "rect": rect(*bounds)})).collect::<Vec<_>>(), "comments": app.graph.comments.iter().map(|(id, bounds)| json!({"id": id, "rect": rect(*bounds)})).collect::<Vec<_>>(), "nodes": nodes.iter().map(|(id, r)| json!({"id": id.0, "rect": rect(*r)})).collect::<Vec<_>>(), diff --git a/crates/ui-egui/src/explorer.rs b/crates/ui-egui/src/explorer.rs index 81cbcdb..b030179 100644 --- a/crates/ui-egui/src/explorer.rs +++ b/crates/ui-egui/src/explorer.rs @@ -4,6 +4,8 @@ use egui::Ui; mod actions; mod context_menu; +mod explorer_menu_state; +pub(crate) mod explorer_row; mod explorer_state; mod explorer_target; mod explorer_tree; @@ -16,6 +18,7 @@ use serde_json::json; use crate::MaterialCraftApp; use crate::i18n::tr; +/// Draw open packages and dispatch selection, resource and context-menu actions. pub fn show(app: &mut MaterialCraftApp, ui: &mut Ui) { ui.horizontal(|ui| { ui.spacing_mut().item_spacing.x = 2.0; @@ -115,9 +118,10 @@ 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() { + if !app.ui.dock.is_visible(crate::docking::Panel::Explorer) || !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")] @@ -134,10 +138,12 @@ pub(crate) fn shortcuts(app: &mut MaterialCraftApp, ctx: &egui::Context) -> bool true } +/// Match an unmodified Explorer shortcut key. fn pressed(ctx: &egui::Context, key: egui::Key) -> bool { ctx.input(|input| input.modifiers.is_none() && input.key_pressed(key)) } +/// Draw the pending Explorer rename dialog. pub(crate) fn dialogs(app: &mut MaterialCraftApp, ctx: &egui::Context) { actions::rename_dialog(app, ctx); } diff --git a/crates/ui-egui/src/explorer/actions.rs b/crates/ui-egui/src/explorer/actions.rs index b04b908..aa08cc9 100644 --- a/crates/ui-egui/src/explorer/actions.rs +++ b/crates/ui-egui/src/explorer/actions.rs @@ -2,10 +2,12 @@ use super::ExplorerTarget; use crate::{MaterialCraftApp, i18n::tr}; use serde_json::json; +/// Activate the target package before dispatching its Explorer action. pub(super) fn activate(app: &mut MaterialCraftApp, document: u64) -> bool { document == app.session.document_id || app.run("package.activate", json!({"document": document})).is_some() } +/// Dispatch an Explorer action using the selected item and its owning package. pub(super) fn invoke(app: &mut MaterialCraftApp, ctx: &egui::Context, target: ExplorerTarget, command: &str) { if command == "graph.resource.add" { let mut parameters = target.parameters(); @@ -106,11 +108,13 @@ fn compute_outputs(app: &mut MaterialCraftApp, target: &ExplorerTarget) { } } +/// Return the active package path for native file actions. #[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)) } +/// Reveal the active package file when supported by the platform. #[cfg(not(target_arch = "wasm32"))] fn show_in_folder(app: &mut MaterialCraftApp) { let Some(path) = package_path(app) else { return }; @@ -119,6 +123,7 @@ fn show_in_folder(app: &mut MaterialCraftApp) { } } +/// Reveal the active package file when supported by the platform. #[cfg(target_arch = "wasm32")] fn show_in_folder(_: &mut MaterialCraftApp) {} @@ -133,9 +138,11 @@ fn open_dependencies(app: &mut MaterialCraftApp) { activate(app, document); } +/// Native dependency-file actions are unavailable in the browser. #[cfg(target_arch = "wasm32")] fn open_dependencies(_: &mut MaterialCraftApp) {} +/// Apply a validated graph or folder rename through the engine. 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; diff --git a/crates/ui-egui/src/explorer/context_menu.rs b/crates/ui-egui/src/explorer/context_menu.rs index 0ef8253..3bc73f5 100644 --- a/crates/ui-egui/src/explorer/context_menu.rs +++ b/crates/ui-egui/src/explorer/context_menu.rs @@ -1,38 +1,13 @@ -use super::ExplorerTarget; +use super::{ExplorerTarget, explorer_menu_state::ExplorerMenuState}; use crate::menus::{self, ExplorerRow}; use crate::{i18n::tr, menus::shortcut_label}; -/// 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) } +/// Draw one action with its shortcut and disabled-state explanation. 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 { @@ -46,7 +21,8 @@ fn item(ui: &mut egui::Ui, label: &str, command: &'static str, shortcut: Option< } } -fn rows(ui: &mut egui::Ui, rows: &[ExplorerRow], state: &MenuState, resources: bool, action: &mut Option<&'static str>) { +/// Draw menu rows while respecting resource-folder and platform restrictions. +fn rows(ui: &mut egui::Ui, rows: &[ExplorerRow], state: &ExplorerMenuState, resources: bool, action: &mut Option<&'static str>) { for row in rows { match *row { ExplorerRow::Separator => { @@ -63,6 +39,7 @@ fn rows(ui: &mut egui::Ui, rows: &[ExplorerRow], state: &MenuState, resources: b if resources && label == "New" && *command != "folder.create" { continue; } + item(ui, entry, command, None, state.enabled(command), action); } }); @@ -73,7 +50,8 @@ fn rows(ui: &mut egui::Ui, rows: &[ExplorerRow], state: &MenuState, resources: b } } -pub(super) fn show(ui: &mut egui::Ui, target: &ExplorerTarget, state: &MenuState) -> Option<&'static str> { +/// Build the context menu for a package, folder, graph or resource. +pub(super) fn show(ui: &mut egui::Ui, target: &ExplorerTarget, state: &ExplorerMenuState) -> Option<&'static str> { ui.set_min_width(220.0); let mut action = None; let resources = target.is_resources(); diff --git a/crates/ui-egui/src/explorer/explorer_menu_state.rs b/crates/ui-egui/src/explorer/explorer_menu_state.rs new file mode 100644 index 0000000..8ba54fd --- /dev/null +++ b/crates/ui-egui/src/explorer/explorer_menu_state.rs @@ -0,0 +1,28 @@ +use crate::menus; + +/// What the right-clicked item allows right now +#[derive(Clone, Copy, Debug, Default)] +pub(super) struct ExplorerMenuState { + /// 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 ExplorerMenuState { + /// Check the selected item supports this context-menu command. + pub(super) 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, + } + } +} diff --git a/crates/ui-egui/src/explorer/explorer_row.rs b/crates/ui-egui/src/explorer/explorer_row.rs new file mode 100644 index 0000000..c6b1979 --- /dev/null +++ b/crates/ui-egui/src/explorer/explorer_row.rs @@ -0,0 +1,9 @@ +/// 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, +} diff --git a/crates/ui-egui/src/explorer/explorer_tree.rs b/crates/ui-egui/src/explorer/explorer_tree.rs index 5c80cbe..9fef628 100644 --- a/crates/ui-egui/src/explorer/explorer_tree.rs +++ b/crates/ui-egui/src/explorer/explorer_tree.rs @@ -163,7 +163,8 @@ impl ExplorerTree<'_> { _ => 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 }; + let state = + super::explorer_menu_state::ExplorerMenuState { 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)); } diff --git a/crates/ui-egui/src/function/actions.rs b/crates/ui-egui/src/function/actions.rs index 88f5c4b..c866979 100644 --- a/crates/ui-egui/src/function/actions.rs +++ b/crates/ui-egui/src/function/actions.rs @@ -1,4 +1,4 @@ -use super::{FunctionEditor, FunctionTarget}; +use super::FunctionEditor; use crate::MaterialCraftApp; pub(super) fn editor_enabled(app: &MaterialCraftApp, editor: &FunctionEditor, command: &str) -> Option<bool> { @@ -12,8 +12,8 @@ pub(super) fn editor_enabled(app: &MaterialCraftApp, editor: &FunctionEditor, co if let Some(enabled) = crate::graph::wire_actions::enabled(app, command, &editor.selected_wires, target.as_ref()) { return Some(enabled && editor.current(app).is_some()); } - let standalone = matches!(editor.target, FunctionTarget::Graph); - if standalone && app.session.annotation_selection.is_some() && matches!(command, "edit.delete" | "edit.deleteRelink") { + + if app.session.annotation_selection.is_some() && matches!(command, "edit.delete" | "edit.deleteRelink") { return None; } if let Some(target) = editor.command_target() @@ -28,7 +28,7 @@ pub(super) fn editor_enabled(app: &MaterialCraftApp, editor: &FunctionEditor, co } match command { "edit.undo" | "edit.redo" | "edit.finish" | "graph.cook" | "ui.graph.snapToGrid" => None, - "ui.graph.previousPin" | "ui.graph.nextPin" | "graph.comment.add" | "graph.frame.add" | "graph.pin.add" if standalone => None, + "ui.graph.previousPin" | "ui.graph.nextPin" | "graph.comment.add" | "graph.frame.add" | "graph.pin.add" => None, command if command.starts_with("graph.") || command.starts_with("ui.graph.") || command.starts_with("edit.") => Some(false), _ => None, } diff --git a/crates/ui-egui/src/function/canvas.rs b/crates/ui-egui/src/function/canvas.rs index 36978e0..d400785 100644 --- a/crates/ui-egui/src/function/canvas.rs +++ b/crates/ui-egui/src/function/canvas.rs @@ -11,9 +11,10 @@ pub(super) fn canvas(app: &mut MaterialCraftApp, editor: &mut FunctionEditor, ui app.ui.frame_all = false; if standalone { app.ui.graph_camera = frame.camera.state(); - app.graph.frames = frame.frames.iter().map(|frame| (frame.id, frame.rect)).collect(); - app.graph.comments = frame.comments.clone(); } + app.graph.frames = frame.frames.iter().map(|frame| (frame.id, frame.rect)).collect(); + app.graph.comments = frame.comments.clone(); + app.graph.pins = frame.pins.clone(); if frame.clear_annotation { app.run("graph.annotation.select", json!({})); } @@ -30,25 +31,24 @@ pub(super) fn canvas(app: &mut MaterialCraftApp, editor: &mut FunctionEditor, ui super::context_menu::show(app, editor, ui, Some(*id)); }); } - let on_annotation = ui - .input(|input| input.pointer.hover_pos()) - .is_some_and(|pointer| frame.frames.iter().any(|frame| frame.contains(pointer)) || frame.comments.iter().any(|(_, rect)| rect.contains(pointer))); + let on_annotation = ui.input(|input| input.pointer.hover_pos()).is_some_and(|pointer| { + frame.frames.iter().any(|frame| frame.contains(pointer)) + || frame.comments.iter().any(|(_, rect)| rect.contains(pointer)) + || frame.pins.iter().any(|(_, rect)| rect.contains(pointer)) + }); super::input::handle(app, editor, ui, &frame.response, &frame.ports, &frame.geometry, on_annotation); frame.geometry.publish(&mut app.graph, frame.response.rect); - if standalone { - if editor.drag.is_none() { - let camera = GraphCamera { origin: frame.response.rect.min, pan: editor.pan, zoom: editor.zoom }; - crate::graph::annotation_input::handle(app, ui, &camera, &frame.frames, &frame.comments); - if app.session.annotation_selection.is_some() { - editor.selection.clear(); - editor.selected_wires.clear(); - } + if editor.drag.is_none() { + let camera = GraphCamera { origin: frame.response.rect.min, pan: editor.pan, zoom: editor.zoom }; + crate::graph::annotation_input::handle(app, ui, &camera, &frame.frames, &frame.comments, &frame.pins); + if app.session.annotation_selection.is_some() { + editor.selection.clear(); + editor.selected_wires.clear(); } - app.ui.graph_camera = crate::state::GraphCamera { pan: editor.pan.into(), zoom: editor.zoom }; + } + if standalone { + app.ui.graph_camera = editor.camera(); app.session.selection = editor.selection.iter().map(|id| materialcraft_engine::core::NodeId(u64::from(*id))).collect(); - } else { - app.graph.frames.clear(); - app.graph.comments.clear(); } editor.inspected_node = crate::graph::node_selection::inspected(&editor.selection, editor.inspected_node); } diff --git a/crates/ui-egui/src/function/context_menu.rs b/crates/ui-egui/src/function/context_menu.rs index 98b0b12..84befd3 100644 --- a/crates/ui-egui/src/function/context_menu.rs +++ b/crates/ui-egui/src/function/context_menu.rs @@ -1,4 +1,4 @@ -use super::{FunctionEditor, FunctionTarget}; +use super::FunctionEditor; use crate::{MaterialCraftApp, graph::edit_menu, i18n::tr, menus}; use egui::Ui; use materialcraft_engine::FunctionEdit; @@ -54,14 +54,13 @@ fn background_actions(app: &mut MaterialCraftApp, editor: &mut FunctionEditor, u let Some(target) = editor.command_target() else { return }; let mut add = None; - let standalone = matches!(editor.target, FunctionTarget::Graph); ui.menu_button(tr("Add node"), |ui| { let entries = target.available_operations(&app.session).filter(|operation| operation.id != "passthrough").map(|operation| (operation.id, operation.label, "")); add = crate::graph::add_node_menu::show(app, ui, entries); }); annotations(app, editor, ui); - if edit_menu::button(ui, "Add Navigation pin", "graph.pin.add", standalone) { + if edit_menu::button(ui, "Add Navigation pin", "graph.pin.add", true) { app.run("graph.pin.add", json!({"at": [editor.menu_at.x, editor.menu_at.y]})); editor.selection.clear(); } @@ -77,7 +76,7 @@ fn background_actions(app: &mut MaterialCraftApp, editor: &mut FunctionEditor, u selection_action(app, editor, ui, label, command); } for (label, command) in [("Previous pin", "ui.graph.previousPin"), ("Next pin", "ui.graph.nextPin")] { - if edit_menu::button(ui, label, command, standalone && menus::enabled(app, command)) { + if edit_menu::button(ui, label, command, menus::enabled(app, command)) { crate::graph::actions::invoke(app, command); editor.set_camera(app.ui.graph_camera); } @@ -89,12 +88,11 @@ fn background_actions(app: &mut MaterialCraftApp, editor: &mut FunctionEditor, u } fn annotations(app: &mut MaterialCraftApp, editor: &mut FunctionEditor, ui: &mut Ui) { - let standalone = matches!(editor.target, FunctionTarget::Graph); for (label, command, parameters) in [ ("Add Comment", "graph.comment.add", json!({"at": [editor.menu_at.x, editor.menu_at.y]})), ("Add Frame", "graph.frame.add", json!({"rect": [editor.menu_at.x, editor.menu_at.y, 400, 260]})), ] { - if edit_menu::button(ui, label, command, standalone) { + if edit_menu::button(ui, label, command, true) { app.run(command, parameters); editor.selection.clear(); } diff --git a/crates/ui-egui/src/function/function_canvas.rs b/crates/ui-egui/src/function/function_canvas.rs index 16b6099..c17d9a8 100644 --- a/crates/ui-egui/src/function/function_canvas.rs +++ b/crates/ui-egui/src/function/function_canvas.rs @@ -12,5 +12,6 @@ pub(super) struct FunctionCanvas { pub values: Vec<(u32, Value)>, pub frames: Vec<FrameHit>, pub comments: Vec<(u64, Rect)>, + pub pins: Vec<(u64, Rect)>, pub clear_annotation: bool, } diff --git a/crates/ui-egui/src/function/function_editor.rs b/crates/ui-egui/src/function/function_editor.rs index 67ca80b..ea1304d 100644 --- a/crates/ui-egui/src/function/function_editor.rs +++ b/crates/ui-egui/src/function/function_editor.rs @@ -26,6 +26,10 @@ impl FunctionEditor { Self::with_target(graph, None, FunctionTarget::Graph) } + pub(crate) fn camera(&self) -> crate::state::GraphCamera { + crate::state::GraphCamera { pan: self.pan.into(), zoom: self.zoom } + } + pub(crate) fn set_camera(&mut self, camera: crate::state::GraphCamera) { self.pan = camera.pan.into(); self.zoom = camera.zoom; diff --git a/crates/ui-egui/src/function/geometry.rs b/crates/ui-egui/src/function/geometry.rs index ffdd941..e08fe20 100644 --- a/crates/ui-egui/src/function/geometry.rs +++ b/crates/ui-egui/src/function/geometry.rs @@ -1,4 +1,4 @@ -use super::{FunctionDrag, FunctionEditor, FunctionTarget}; +use super::{FunctionDrag, FunctionEditor}; use crate::{MaterialCraftApp, graph::node_card}; use egui::{Color32, Pos2, Rect, vec2}; use materialcraft_engine::core::FunctionNode; @@ -39,8 +39,6 @@ pub(super) fn preview_rect(app: &MaterialCraftApp, editor: &FunctionEditor, node let position = materialcraft_engine::graph_grid::translate(node.pos, (*delta).into(), snap); bounds = bounds.translate(vec2(position[0] - node.pos[0], position[1] - node.pos[1])); } - if matches!(editor.target, FunctionTarget::Graph) { - bounds = bounds.translate(crate::graph::annotation_canvas::offset(app, |contents| contents.function_nodes.contains(&node.id))); - } + bounds = bounds.translate(crate::graph::annotation_canvas::offset(app, |contents| contents.function_nodes.contains(&node.id))); bounds } diff --git a/crates/ui-egui/src/function/input.rs b/crates/ui-egui/src/function/input.rs index 67571c5..8a83934 100644 --- a/crates/ui-egui/src/function/input.rs +++ b/crates/ui-egui/src/function/input.rs @@ -30,11 +30,7 @@ pub(super) fn handle( && !on_annotation && !ui.input(|input| input.modifiers.alt) && crate::graph::wire_selection::handle(&mut editor.selected_wires, &mut editor.selection, ui, response, &geometry.wires); - if on_wire - && matches!(editor.target, super::FunctionTarget::Graph) - && app.session.annotation_selection.is_some() - && (ui.input(|input| input.pointer.primary_pressed()) || response.secondary_clicked()) - { + if on_wire && app.session.annotation_selection.is_some() && (ui.input(|input| input.pointer.primary_pressed()) || response.secondary_clicked()) { app.run("graph.annotation.select", serde_json::json!({})); } @@ -68,7 +64,7 @@ pub(super) fn handle( && !on_annotation && !on_wire { - if matches!(editor.target, super::FunctionTarget::Graph) && app.session.annotation_selection.is_some() { + if app.session.annotation_selection.is_some() { app.run("graph.annotation.select", serde_json::json!({})); } editor.drag = Some(FunctionDrag::Box { start }); @@ -170,6 +166,20 @@ pub(super) fn handle( } } + if let Some(payload) = crate::widgets::dnd_release::<crate::graph::LibraryDrag>(response) + && let Some(pointer) = pointer + { + let at = camera.to_graph(pointer); + if let Some(result) = app.run("library.add", serde_json::json!({"entry": payload.0, "at": [at.x, at.y], "snapToGrid": snap})) { + editor.selection = if app.session.annotation_selection.is_some() { + Vec::new() + } else { + result["result"]["id"].as_u64().and_then(|id| u32::try_from(id).ok()).into_iter().collect() + }; + editor.selected_wires.clear(); + } + } + // Adding operations if response.secondary_clicked() && let Some(pointer_position) = pointer diff --git a/crates/ui-egui/src/function/library.rs b/crates/ui-egui/src/function/library.rs index 5c6a63a..8b63115 100644 --- a/crates/ui-egui/src/function/library.rs +++ b/crates/ui-egui/src/function/library.rs @@ -11,8 +11,7 @@ pub(crate) fn add(app: &mut MaterialCraftApp, entry: &FunctionLibraryDrag) { } } -/// The native operations the open Function canvas can take (processors that only compute a -/// value cannot sample images) +/// The native operations accepted by the open Function canvas. pub(crate) fn available_operations(app: &MaterialCraftApp) -> Vec<&'static str> { app.function_editor .as_ref() diff --git a/crates/ui-egui/src/function/render.rs b/crates/ui-egui/src/function/render.rs index 9658e38..e172532 100644 --- a/crates/ui-egui/src/function/render.rs +++ b/crates/ui-egui/src/function/render.rs @@ -1,12 +1,14 @@ use super::geometry::{in_port, node_rect, out_port, preview_rect}; -use super::{FunctionDrag, FunctionEditor, FunctionTarget, port_label::port_label}; +use super::{FunctionDrag, FunctionEditor, port_label::port_label}; use super::{function_canvas::FunctionCanvas, function_port::FunctionPort}; use crate::graph::canvas_geometry::CanvasGeometry; use crate::{MaterialCraftApp, graph::node_card, theme::Tokens}; use egui::{Align2, Color32, Rect, Sense, Stroke, Ui, Vec2, pos2, vec2}; use std::collections::{BTreeMap, BTreeSet}; -pub(super) fn paint(app: &MaterialCraftApp, editor: &mut FunctionEditor, ui: &mut Ui) -> Option<FunctionCanvas> { +pub(super) fn paint(app: &mut MaterialCraftApp, editor: &mut FunctionEditor, ui: &mut Ui) -> Option<FunctionCanvas> { + let (canvas_bounds, response) = ui.allocate_exact_size(ui.available_size().max(vec2(200.0, 200.0)), Sense::click_and_drag()); + app.graph.view = canvas_bounds; let graph = editor.current(app)?; let snap = app.ui.prefs.snap_to_grid; let selected: BTreeSet<_> = editor.selection.iter().copied().collect(); @@ -21,9 +23,8 @@ pub(super) fn paint(app: &MaterialCraftApp, editor: &mut FunctionEditor, ui: &mu .is_some_and(Option::is_some) }); editor.inspected_node = crate::graph::node_selection::inspected(&editor.selection, editor.inspected_node); - let standalone = matches!(editor.target, FunctionTarget::Graph); + let document = app.graph.annotation_target.items(&app.session).ok(); let tokens = Tokens::get(ui.ctx()); - let (canvas_bounds, response) = ui.allocate_exact_size(ui.available_size().max(vec2(200.0, 200.0)), Sense::click_and_drag()); crate::widgets::name(&response, egui::Role::Canvas, "Function Graph"); let painter = ui.painter_at(canvas_bounds); painter.rect_filled(canvas_bounds, 4.0, Color32::from_rgb(0x26, 0x28, 0x2c)); @@ -42,10 +43,7 @@ pub(super) fn paint(app: &MaterialCraftApp, editor: &mut FunctionEditor, ui: &mu .filter(|node| !selected_only || selected.contains(&node.id)) .map(|node| node_rect(node, app.ui.prefs.thumbnails)) .fold(Rect::NOTHING, |combined, bounds| combined.union(bounds)); - if standalone - && !selected_only - && let Ok(document) = app.session.graph() - { + if !selected_only && let Some(document) = &document { for frame in &document.frames { destination = destination.union(Rect::from_min_size(pos2(frame.rect[0], frame.rect[1] - 32.0), vec2(frame.rect[2], frame.rect[3] + 32.0))); } @@ -59,7 +57,7 @@ pub(super) fn paint(app: &MaterialCraftApp, editor: &mut FunctionEditor, ui: &mu camera.zoom_from_input(ui, canvas_bounds); editor.pan = camera.pan; editor.zoom = camera.zoom; - let document = standalone.then(|| app.session.graph().ok()).flatten(); + let frame_hits = document.as_ref().map(|graph| crate::graph::annotation_canvas::frames(app, ui, &graph.frames, &camera)).unwrap_or_default(); crate::graph::grid::paint(&painter, &camera, canvas_bounds); @@ -167,7 +165,7 @@ pub(super) fn paint(app: &MaterialCraftApp, editor: &mut FunctionEditor, ui: &mu if !keep_wires { editor.selected_wires.clear(); } - if standalone && app.session.annotation_selection.is_some() { + if app.session.annotation_selection.is_some() { clear_annotation = true; } } @@ -193,8 +191,6 @@ pub(super) fn paint(app: &MaterialCraftApp, editor: &mut FunctionEditor, ui: &mu .collect(); let comments = document.as_ref().map(|document| crate::graph::annotation_canvas::comments(app, ui, &document.comments, &camera)).unwrap_or_default(); - if let Some(document) = &document { - crate::graph::annotation_canvas::pins(app, ui, &document.pins, &camera); - } - Some(FunctionCanvas { response, camera, geometry, ports, nodes, values, frames: frame_hits, comments, clear_annotation }) + let pins = document.as_ref().map(|document| crate::graph::annotation_canvas::pins(app, ui, &document.pins, &camera)).unwrap_or_default(); + Some(FunctionCanvas { response, camera, geometry, ports, nodes, values, frames: frame_hits, comments, pins, clear_annotation }) } diff --git a/crates/ui-egui/src/graph/actions.rs b/crates/ui-egui/src/graph/actions.rs index b44ef1c..edce941 100644 --- a/crates/ui-egui/src/graph/actions.rs +++ b/crates/ui-egui/src/graph/actions.rs @@ -7,7 +7,7 @@ pub(crate) fn enabled(app: &MaterialCraftApp, command: &str) -> Option<bool> { match command { "ui.graph.viewOutputs" | "ui.graph.resetViewOutputs" => Some(app.session.graph().is_ok_and(|graph| graph.function.is_none())), - "ui.graph.previousPin" | "ui.graph.nextPin" => Some(app.session.graph().is_ok_and(|graph| !graph.pins.is_empty())), + "ui.graph.previousPin" | "ui.graph.nextPin" => Some(app.graph.annotation_target.items(&app.session).is_ok_and(|items| !items.pins.is_empty())), command if command.starts_with("ui.graph.") => Some(app.session.graph().is_ok()), _ => None, } @@ -73,12 +73,12 @@ pub(crate) fn invoke(app: &mut MaterialCraftApp, command: &str) -> bool { } fn navigate_pin(app: &mut MaterialCraftApp, forward: bool) { - let Ok(graph) = app.session.graph() else { return }; + let Ok(graph) = app.graph.annotation_target.items(&app.session) else { return }; if graph.pins.is_empty() { return; } - let camera = &mut app.ui.graph_camera; + let mut camera = crate::annotation::camera(app); let zoom = camera.zoom.clamp(0.08, 4.0); let center = [camera.pan[0] + app.graph.view.width() * 0.5 / zoom, camera.pan[1] + app.graph.view.height() * 0.5 / zoom]; let current = graph.pins.iter().position(|pin| (pin.pos[0] - center[0]).abs() < 0.1 && (pin.pos[1] - center[1]).abs() < 0.1); @@ -92,9 +92,11 @@ fn navigate_pin(app: &mut MaterialCraftApp, forward: bool) { let Some(pin) = graph.pins.get(index) else { return }; camera.pan = [pin.pos[0] - app.graph.view.width() * 0.5 / zoom, pin.pos[1] - app.graph.view.height() * 0.5 / zoom]; - if let Some(editor) = &mut app.function_editor - && editor.target == crate::function::FunctionTarget::Graph - { - editor.set_camera(*camera); + if let Some(editor) = &mut app.function_editor { + editor.set_camera(camera); + } else if let Some(editor) = &mut app.pattern_editor { + editor.set_camera(camera); + } else { + app.ui.graph_camera = camera; } } diff --git a/crates/ui-egui/src/graph/annotation_canvas.rs b/crates/ui-egui/src/graph/annotation_canvas.rs index e37bb4d..e448f8e 100644 --- a/crates/ui-egui/src/graph/annotation_canvas.rs +++ b/crates/ui-egui/src/graph/annotation_canvas.rs @@ -87,16 +87,28 @@ pub(crate) fn comments(app: &MaterialCraftApp, ui: &Ui, comments: &[Comment], ca hits } -pub(crate) fn pins(app: &MaterialCraftApp, ui: &Ui, pins: &[Pin], camera: &GraphCamera) { +pub(crate) fn pins(app: &MaterialCraftApp, ui: &Ui, pins: &[Pin], camera: &GraphCamera) -> Vec<(u64, Rect)> { let painter = ui.painter_at(app.graph.view); let theme = Tokens::get(ui.ctx()); - + let mut hits = Vec::with_capacity(pins.len()); for pin in pins { - let position = pos2(pin.pos[0], pin.pos[1]) + offset(app, |contents| contents.pins.contains(&pin.id)); + let mut position = pos2(pin.pos[0], pin.pos[1]) + offset(app, |contents| contents.pins.contains(&pin.id)); + if let Some(GraphDrag::Pin { id, delta }) = &app.graph.drag + && *id == pin.id + { + position += *delta; + } let position = camera.to_screen(position); - painter.text(position, Align2::CENTER_BOTTOM, icon::MAP_PIN, FontId::proportional(18.0), theme.accent); - painter.text(position + vec2(10.0, -10.0), Align2::LEFT_CENTER, &pin.name, FontId::proportional(11.0), theme.text); + let selected = app.session.annotation_selection == Some(AnnotationSelection::Pin(pin.id)); + let marker = painter.text(position, Align2::CENTER_BOTTOM, icon::MAP_PIN, FontId::proportional(18.0), theme.accent); + let label = painter.text(position + vec2(10.0, -10.0), Align2::LEFT_CENTER, &pin.name, FontId::proportional(11.0), theme.text); + let bounds = marker.union(label).expand(3.0); + if selected { + painter.rect_stroke(bounds, 2.0, Stroke::new(1.0, theme.accent), StrokeKind::Outside); + } + hits.push((pin.id, bounds)); } + hits } pub(crate) fn offset(app: &MaterialCraftApp, contains: impl FnOnce(&materialcraft_engine::FrameContents) -> bool) -> Vec2 { diff --git a/crates/ui-egui/src/graph/annotation_input.rs b/crates/ui-egui/src/graph/annotation_input.rs index 565462a..e08ee3a 100644 --- a/crates/ui-egui/src/graph/annotation_input.rs +++ b/crates/ui-egui/src/graph/annotation_input.rs @@ -3,7 +3,7 @@ use crate::MaterialCraftApp; use egui::{Rect, Ui, Vec2}; use serde_json::json; -pub(crate) fn handle(app: &mut MaterialCraftApp, ui: &Ui, camera: &GraphCamera, frames: &[FrameHit], comments: &[(u64, Rect)]) { +pub(crate) fn handle(app: &mut MaterialCraftApp, ui: &Ui, camera: &GraphCamera, frames: &[FrameHit], comments: &[(u64, Rect)], pins: &[(u64, Rect)]) { if super::gesture::cancelled(ui) { app.graph.drag = None; return; @@ -12,17 +12,24 @@ pub(crate) fn handle(app: &mut MaterialCraftApp, ui: &Ui, camera: &GraphCamera, let Some(pointer) = ui.input(|input| input.pointer.interact_pos()) else { return }; let pressed = ui.input(|input| input.pointer.primary_pressed()); + if ui.input(|input| input.pointer.secondary_clicked()) + && let Some((id, _)) = pins.iter().rev().find(|(_, rect)| rect.contains(pointer)) + { + app.run("graph.annotation.select", json!({"kind": "pin", "id": id})); + } let motion = ui.input(|input| input.pointer.delta()) / camera.zoom; if pressed && app.graph.view.contains(pointer) && app.graph.drag.is_none() && !app.graph.rects.iter().any(|(_, rect)| rect.contains(pointer)) { - if let Some((id, _)) = comments.iter().rev().find(|(_, rect)| rect.contains(pointer)) { + if let Some((id, _)) = pins.iter().rev().find(|(_, rect)| rect.contains(pointer)) { + begin_pin(app, *id); + } else if let Some((id, _)) = comments.iter().rev().find(|(_, rect)| rect.contains(pointer)) { begin_comment(app, *id); } else if let Some(hit) = frames.iter().rev().find(|hit| hit.contains(pointer)) { begin_frame(app, hit.id, hit.grip.contains(pointer)); } else { app.run("graph.annotation.select", json!({})); } - } else if let Some(GraphDrag::Frame { delta, .. } | GraphDrag::Comment { delta, .. }) = &mut app.graph.drag { + } else if let Some(GraphDrag::Frame { delta, .. } | GraphDrag::Comment { delta, .. } | GraphDrag::Pin { delta, .. }) = &mut app.graph.drag { *delta += motion; } @@ -40,10 +47,13 @@ pub(super) fn begin_comment(app: &mut MaterialCraftApp, id: u64) { pub(super) fn begin_frame(app: &mut MaterialCraftApp, id: u64, resize: bool) { let contents = app - .session - .graph() + .graph + .annotation_target + .items(&app.session) .ok() - .and_then(|graph| graph.frames.iter().find(|frame| frame.id == id).map(|frame| materialcraft_engine::FrameContents::capture(graph, frame))) + .and_then(|items| { + items.frames.iter().find(|frame| frame.id == id).and_then(|frame| app.graph.annotation_target.capture_frame(&app.session, frame).ok()) + }) .unwrap_or_default(); app.run("graph.annotation.select", json!({"kind": "frame", "id": id})); app.graph.drag = Some(GraphDrag::Frame { id, delta: Vec2::ZERO, resize, contents }); @@ -53,7 +63,9 @@ pub(super) fn finish(app: &mut MaterialCraftApp, drag: GraphDrag) { match drag { GraphDrag::Frame { id, delta, resize, .. } if delta.length() > 0.5 => { if resize { - if let Some(frame) = app.session.graph().ok().and_then(|graph| graph.frames.iter().find(|frame| frame.id == id)) { + if let Some(frame) = + app.graph.annotation_target.items(&app.session).ok().and_then(|items| items.frames.into_iter().find(|frame| frame.id == id)) + { let rect = [frame.rect[0], frame.rect[1], frame.rect[2] + delta.x, frame.rect[3] + delta.y]; app.run("graph.frame.edit", json!({"id": id, "rect": rect})); } @@ -62,11 +74,26 @@ pub(super) fn finish(app: &mut MaterialCraftApp, drag: GraphDrag) { } } GraphDrag::Comment { id, delta } if delta.length() > 0.5 => { - if let Some(comment) = app.session.graph().ok().and_then(|graph| graph.comments.iter().find(|comment| comment.id == id)) { + if let Some(comment) = + app.graph.annotation_target.items(&app.session).ok().and_then(|items| items.comments.into_iter().find(|comment| comment.id == id)) + { let position = [comment.pos[0] + delta.x, comment.pos[1] + delta.y]; app.run("graph.comment.edit", json!({"id": id, "at": position})); } } + GraphDrag::Pin { id, delta } if delta.length() > 0.5 => { + if let Some(pin) = app.graph.annotation_target.items(&app.session).ok().and_then(|items| items.pins.into_iter().find(|pin| pin.id == id)) { + app.run("graph.pin.edit", json!({"id": id, "at": [pin.pos[0] + delta.x, pin.pos[1] + delta.y]})); + app.session.finish_edit(); + } + } _ => {} } } + +pub(super) fn begin_pin(app: &mut MaterialCraftApp, id: u64) { + app.run("graph.annotation.select", json!({"kind": "pin", "id": id})); + app.inspected_folder = None; + app.inspected_graph = None; + app.graph.drag = Some(GraphDrag::Pin { id, delta: Vec2::ZERO }); +} diff --git a/crates/ui-egui/src/graph/canvas.rs b/crates/ui-egui/src/graph/canvas.rs index 14e09a1..87c8d4b 100644 --- a/crates/ui-egui/src/graph/canvas.rs +++ b/crates/ui-egui/src/graph/canvas.rs @@ -33,6 +33,7 @@ pub fn show(app: &mut MaterialCraftApp, ui: &mut Ui) { } } + crate::annotation::activate(app, crate::annotation::target(app)); super::toolbar::show(app, ui); if app.function_editor.is_some() { crate::function::show_graph(app, ui); @@ -278,7 +279,8 @@ fn canvas(app: &mut MaterialCraftApp, ui: &mut Ui) { let comment_hits = super::annotation_canvas::comments(app, ui, &graph.comments, &camera); app.graph.comments = comment_hits.clone(); - super::annotation_canvas::pins(app, ui, &graph.pins, &camera); + let pin_hits = super::annotation_canvas::pins(app, ui, &graph.pins, &camera); + app.graph.pins = pin_hits.clone(); // Ports (drawn last, interactable over the node cards) // except on a dot's body: its port hit circles would otherwise cover it and it could never be moved @@ -311,7 +313,7 @@ fn canvas(app: &mut MaterialCraftApp, ui: &mut Ui) { ctx.set_cursor_icon(egui::CursorIcon::PointingHand); } app.graph.inspected_node = super::node_selection::inspected(&app.session.selection, app.graph.inspected_node); - super::input::handle(app, ui, &resp, rect, &camera, &node_responses, &frame_hits, &comment_hits, port_hover, wire_hover); + super::input::handle(app, ui, &resp, rect, &camera, &node_responses, &frame_hits, &comment_hits, &pin_hits, port_hover, wire_hover); app.graph.inspected_node = super::node_selection::inspected(&app.session.selection, app.graph.inspected_node); // GraphDrag previews diff --git a/crates/ui-egui/src/graph/editor_target.rs b/crates/ui-egui/src/graph/editor_target.rs index 18f7b31..5f619a6 100644 --- a/crates/ui-egui/src/graph/editor_target.rs +++ b/crates/ui-egui/src/graph/editor_target.rs @@ -1,4 +1,4 @@ -use crate::{MaterialCraftApp, function::FunctionTarget}; +use crate::MaterialCraftApp; #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub(crate) enum EditorTarget { @@ -9,12 +9,7 @@ pub(crate) enum EditorTarget { impl EditorTarget { pub(crate) fn annotation_active(app: &MaterialCraftApp) -> bool { - app.session.annotation_selection.is_some() - && match Self::resolve(app) { - Self::Material => true, - Self::Function => app.function_editor.as_ref().is_some_and(|editor| matches!(editor.target, FunctionTarget::Graph)), - Self::Pattern => false, - } + app.session.annotation_selection.is_some() && app.session.annotation_target == app.graph.annotation_target } pub(crate) fn resolve(app: &MaterialCraftApp) -> Self { diff --git a/crates/ui-egui/src/graph/graph_drag.rs b/crates/ui-egui/src/graph/graph_drag.rs index ea463ae..6524145 100644 --- a/crates/ui-egui/src/graph/graph_drag.rs +++ b/crates/ui-egui/src/graph/graph_drag.rs @@ -30,6 +30,10 @@ pub(super) enum GraphDrag { resize: bool, contents: materialcraft_engine::FrameContents, }, + Pin { + id: u64, + delta: Vec2, + }, Comment { id: u64, delta: Vec2, diff --git a/crates/ui-egui/src/graph/graph_view.rs b/crates/ui-egui/src/graph/graph_view.rs index 5dc9e9d..f032e46 100644 --- a/crates/ui-egui/src/graph/graph_view.rs +++ b/crates/ui-egui/src/graph/graph_view.rs @@ -13,6 +13,9 @@ pub struct GraphView { pub ports: Vec<PortHit>, pub frames: Vec<(u64, Rect)>, pub comments: Vec<(u64, Rect)>, + pub pins: Vec<(u64, Rect)>, + pub(crate) annotation_target: materialcraft_engine::AnnotationTarget, + pub(crate) pin_description_focus: Option<u64>, /// The canvas rectangle last frame pub view: Rect, /// Graph point of the last right-click (context menu actions add things there) @@ -28,10 +31,14 @@ pub struct GraphView { } impl GraphView { - pub(crate) fn cancel_gesture(&mut self) { + pub(crate) fn cancel_drag(&mut self) { self.drag = None; self.search = None; self.menu_wire = None; + } + + pub(crate) fn cancel_gesture(&mut self) { + self.cancel_drag(); self.framed_graph = None; } pub(crate) fn is_dragging(&self) -> bool { @@ -51,6 +58,9 @@ impl Default for GraphView { ports: Vec::new(), frames: Vec::new(), comments: Vec::new(), + pins: Vec::new(), + annotation_target: Default::default(), + pin_description_focus: None, view: Rect::NOTHING, menu_at: Pos2::ZERO, framed_graph: None, diff --git a/crates/ui-egui/src/graph/input.rs b/crates/ui-egui/src/graph/input.rs index 9e2a5bb..503ab73 100644 --- a/crates/ui-egui/src/graph/input.rs +++ b/crates/ui-egui/src/graph/input.rs @@ -15,6 +15,7 @@ pub(super) fn handle( nodes: &[(NodeId, egui::Response)], frames: &[super::frame_hit::FrameHit], comments: &[(u64, Rect)], + pins: &[(u64, Rect)], port_hover: Option<PortHit>, wire_hover: Option<WireRef>, ) { @@ -42,7 +43,9 @@ pub(super) fn handle( app.run("graph.annotation.select", json!({})); } - let on_card = nodes.iter().any(|(_, response)| response.rect.contains(position)) || comments.iter().any(|(_, bounds)| bounds.contains(position)); + let on_card = nodes.iter().any(|(_, response)| response.rect.contains(position)) + || comments.iter().any(|(_, bounds)| bounds.contains(position)) + || pins.iter().any(|(_, bounds)| bounds.contains(position)); let wire = wire_hover.as_ref().filter(|_| port_hover.is_none() && !on_card); if wire.is_none() { super::node_selection::select(&mut app.graph.selected_wires, None, modifiers); @@ -59,6 +62,8 @@ pub(super) fn handle( } else { app.graph.drag = Some(GraphDrag::InputWire { to: (port.node, port.port.clone()) }); } + } else if let Some((id, _)) = pins.iter().rev().find(|(_, bounds)| bounds.contains(position)) { + super::annotation_input::begin_pin(app, *id); } else if let Some((id, _)) = comments.iter().rev().find(|(_, bounds)| bounds.contains(position)) { super::annotation_input::begin_comment(app, *id); } else if let Some((id, _)) = nodes.iter().rev().find(|(_, response)| response.rect.contains(position)) { @@ -78,7 +83,10 @@ pub(super) fn handle( let delta = context.input(|input| input.pointer.delta()) / zoom; app.ui.graph_camera.pan = [app.ui.graph_camera.pan[0] - delta.x, app.ui.graph_camera.pan[1] - delta.y]; } - Some(GraphDrag::Nodes { delta }) | Some(GraphDrag::Frame { delta, .. }) | Some(GraphDrag::Comment { delta, .. }) => *delta += motion, + Some(GraphDrag::Nodes { delta }) + | Some(GraphDrag::Frame { delta, .. }) + | Some(GraphDrag::Comment { delta, .. }) + | Some(GraphDrag::Pin { delta, .. }) => *delta += motion, Some(GraphDrag::WirePress { wire, start }) => { // Dragged far enough: a reroute dot where the press was, carried by the pointer if let Some(position) = pointer @@ -145,7 +153,7 @@ pub(super) fn handle( app.run("graph.connect", json!({"from": source.node.0, "fromPort": source.port, "to": to.0.0, "toPort": to.1})); } } - GraphDrag::Frame { .. } | GraphDrag::Comment { .. } => super::annotation_input::finish(app, drag), + GraphDrag::Frame { .. } | GraphDrag::Comment { .. } | GraphDrag::Pin { .. } => super::annotation_input::finish(app, drag), } } @@ -183,6 +191,7 @@ pub(super) fn handle( let on_node = pointer.is_some_and(|position| { nodes.iter().any(|(_, response)| response.rect.contains(position)) || comments.iter().any(|(_, bounds)| bounds.contains(position)) + || pins.iter().any(|(_, bounds)| bounds.contains(position)) || frames.iter().any(|frame| frame.contains(position)) }); if canvas.double_clicked() @@ -204,7 +213,9 @@ pub(super) fn handle( && let Some(position) = pointer { app.graph.menu_at = camera.to_graph(position); - if let Some((id, _)) = comments.iter().rev().find(|(_, rect)| rect.contains(position)) { + if let Some((id, _)) = pins.iter().rev().find(|(_, rect)| rect.contains(position)) { + app.run("graph.annotation.select", json!({"kind": "pin", "id": id})); + } else if let Some((id, _)) = comments.iter().rev().find(|(_, rect)| rect.contains(position)) { app.run("graph.annotation.select", json!({"kind": "comment", "id": id})); } else if let Some(hit) = frames.iter().rev().find(|frame| frame.contains(position)) { app.run("graph.annotation.select", json!({"kind": "frame", "id": hit.id})); @@ -247,7 +258,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("library.add", json!({"entry": payload.0, "at": at})); + app.run("library.add", json!({"entry": payload.0, "at": at, "snapToGrid": app.ui.prefs.snap_to_grid})); } // Keys over the canvas diff --git a/crates/ui-egui/src/graph/interaction_tests.rs b/crates/ui-egui/src/graph/interaction_tests.rs index acb396f..76d0481 100644 --- a/crates/ui-egui/src/graph/interaction_tests.rs +++ b/crates/ui-egui/src/graph/interaction_tests.rs @@ -867,3 +867,58 @@ fn wires_pulled_from_an_unconnected_input_connect_on_an_output() { frames.app.session.undo().unwrap(); assert_eq!(wires(&frames).len(), 2); } + +/// A library drop uses the same snapping preference as other node additions. +#[test] +fn review_library_drop_respects_grid_preference() { + for snapping in [true, false] { + let mut frames = Frames::new(new_session()); + frames.app.ui.prefs.snap_to_grid = snapping; + let position = frames.app.graph.view.center() + vec2(113.0, 77.0); + frames.run(vec![Event::PointerMoved(position)], Modifiers::NONE); + frames.run(vec![Event::PointerButton { pos: position, button: PointerButton::Primary, pressed: true, modifiers: Modifiers::NONE }], Modifiers::NONE); + egui::DragAndDrop::set_payload(&frames.ctx, super::LibraryDrag("node:blur".into())); + let camera = + super::GraphCamera { origin: frames.app.graph.view.min, pan: frames.app.ui.graph_camera.pan.into(), zoom: frames.app.ui.graph_camera.zoom }; + let graph_position = camera.to_graph(position); + let expected = materialcraft_engine::graph_grid::snap_position([graph_position.x - super::NODE_W * 0.5, graph_position.y - 20.0], snapping); + let before = frames.app.session.graph().unwrap().nodes.len(); + + frames.run(vec![Event::PointerButton { pos: position, button: PointerButton::Primary, pressed: false, modifiers: Modifiers::NONE }], Modifiers::NONE); + + let graph = frames.app.session.graph().unwrap(); + assert_eq!(graph.nodes.len(), before + 1); + assert_eq!(graph.nodes.last().unwrap().pos, expected, "snapping: {snapping}"); + } +} + +/// Both standalone canvases hit the pin marker and description and preserve drag undo. +#[test] +fn navigation_pins_can_be_selected_dragged_and_deleted() { + for function in [false, true] { + let mut session = new_session(); + if function { + materialcraft_engine::execute(&mut session, "file.new", &json!({"kind": "function"})).unwrap(); + } + let mut frames = Frames::new(session); + let camera = &frames.app.ui.graph_camera; + let position = egui::Pos2::from(camera.pan) + frames.app.graph.view.size() * 0.5 / camera.zoom; + let id = frames.app.run("graph.pin.add", json!({"at": [position.x, position.y], "name": "Review checkpoint"})).unwrap()["id"].as_u64().unwrap(); + frames.app.run("graph.annotation.select", json!({})); + frames.run(Vec::new(), Modifiers::NONE); + let from = frames.app.graph.view.center() + vec2(30.0, -10.0); + frames.click(from, Modifiers::NONE); + assert_eq!(serde_json::to_value(frames.app.session.annotation_selection).unwrap(), json!({"kind": "pin", "id": id})); + assert_eq!(crate::properties::title(&frames.app), "Navigation Pin - Properties"); + let before = frames.app.session.graph().unwrap().pins[0].pos; + let zoom = frames.app.ui.graph_camera.zoom; + drag(&mut frames, from, from + vec2(64.0, 32.0) * zoom); + let after = frames.app.session.graph().unwrap().pins[0].pos; + assert!((after[0] - before[0] - 64.0).abs() < 0.01); + assert!((after[1] - before[1] - 32.0).abs() < 0.01); + frames.app.session.undo().unwrap(); + assert_eq!(frames.app.session.graph().unwrap().pins[0].pos, before); + menus::invoke(&mut frames.app, &frames.ctx, "edit.delete"); + assert!(frames.app.session.graph().unwrap().pins.is_empty()); + } +} diff --git a/crates/ui-egui/src/graph/toolbar.rs b/crates/ui-egui/src/graph/toolbar.rs index c880127..0b1f34c 100644 --- a/crates/ui-egui/src/graph/toolbar.rs +++ b/crates/ui-egui/src/graph/toolbar.rs @@ -7,7 +7,6 @@ use serde_json::json; pub(super) fn show(app: &mut MaterialCraftApp, ui: &mut Ui) { let function = app.function_editor.is_some(); let pattern = !function && crate::pattern::active(app); - let embedded_function = app.function_editor.as_ref().is_some_and(|editor| editor.target != crate::function::FunctionTarget::Graph); let function_target = app.function_editor.as_ref().and_then(|editor| editor.command_target()); let selection: Vec<u64> = if pattern { app.pattern_editor.as_ref().map(|editor| editor.selection.iter().copied().map(u64::from).collect()).unwrap_or_default() @@ -32,10 +31,10 @@ pub(super) fn show(app: &mut MaterialCraftApp, ui: &mut Ui) { }) { app.ui.frame_all = true; } - if !pattern && !embedded_function { + { ui.separator(); if b(ui, icon::SELECTION, tr("Add frame around the selection")) { - let parameters = if function { function_frame(app, &selection) } else { json!({}) }; + let parameters = annotation_frame(app, &selection); app.run("graph.frame.add", parameters); } if b(ui, icon::NOTE, tr("Add comment")) { @@ -169,8 +168,9 @@ fn parent_size(app: &mut MaterialCraftApp, ui: &mut Ui) { } } -fn function_frame(app: &MaterialCraftApp, selection: &[u64]) -> serde_json::Value { - let camera = super::GraphCamera { origin: app.graph.view.min, pan: app.ui.graph_camera.pan.into(), zoom: app.ui.graph_camera.zoom }; +fn annotation_frame(app: &MaterialCraftApp, selection: &[u64]) -> serde_json::Value { + let camera = crate::annotation::camera(app); + let camera = super::GraphCamera { origin: app.graph.view.min, pan: camera.pan.into(), zoom: camera.zoom }; let bounds = app.graph.rects.iter().filter(|(id, _)| selection.contains(&id.0)).fold(egui::Rect::NOTHING, |bounds, (_, rect)| bounds.union(*rect)); if !bounds.is_finite() { return json!({}); diff --git a/crates/ui-egui/src/library.rs b/crates/ui-egui/src/library.rs index 5227ff3..6048677 100644 --- a/crates/ui-egui/src/library.rs +++ b/crates/ui-egui/src/library.rs @@ -12,16 +12,18 @@ use materialcraft_engine::{LibraryCanvas, LibraryEntry, LibraryItem}; use crate::MaterialCraftApp; use crate::function::library::FunctionLibraryDrag; -use crate::graph::editor_target::EditorTarget; +mod library_target; use crate::graph::{LibraryDrag, header_color}; use crate::i18n::tr; use crate::theme::Tokens; +pub(crate) use library_target::LibraryTarget; /// 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); +/// Choose the icon for a known category or fall back to a folder. fn category_icon(category: &str) -> &'static str { match category { FAVORITES => icon::STAR, @@ -68,50 +70,6 @@ fn category_icon(category: &str) -> &'static str { } } -/// 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>>); @@ -125,22 +83,24 @@ fn entries(app: &MaterialCraftApp, ctx: &egui::Context) -> Arc<Vec<LibraryEntry> { 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 } +/// Draw the shared library tree and search results for the active editor. pub fn show(app: &mut MaterialCraftApp, ui: &mut Ui) { - let tk = Tokens::get(ui.ctx()); - let here = Here::of(app); + let tokens = Tokens::get(ui.ctx()); + let target = LibraryTarget::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 hint = match here.canvas { + ui.label(RichText::new(icon::MAGNIFYING_GLASS).color(tokens.text_dim)); + let hint = match target.canvas { LibraryCanvas::Function => tr("Search functions"), LibraryCanvas::Pattern => tr("Search FX-Map nodes"), - LibraryCanvas::Material => tr("Search"), + LibraryCanvas::Any | 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)); @@ -166,21 +126,23 @@ pub fn show(app: &mut MaterialCraftApp, ui: &mut Ui) { } }); ui.add_space(2.0); - let avail = ui.available_size(); + let available_size = ui.available_size(); + // 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 tree_width = (available_size.x * 0.6).clamp(120.0, 230.0).min(available_size.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| { + ui.allocate_ui_with_layout(vec2(tree_width, available_size.y), top_down, |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, &all, &here)); + ui.allocate_ui_with_layout(vec2(ui.available_width(), available_size.y), top_down, |ui| { + egui::ScrollArea::vertical().id_salt("lib-items").auto_shrink([false, false]).show(ui, |ui| items(app, ui, &all, &target)); }); }); } +/// Expose availability and canvas filters without changing the selected category. 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); @@ -191,6 +153,7 @@ fn filter_menu(app: &mut MaterialCraftApp, ui: &mut Ui) { }); } +/// Toggle an entry while bounding the saved favorites list. 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); @@ -201,24 +164,24 @@ fn toggle_favorite(app: &mut MaterialCraftApp, id: &str) { /// 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 tokens = Tokens::get(ui.ctx()); 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); + ui.painter().rect_filled(rect, 4.0, tokens.row_selected); } else if response.hovered() { - ui.painter().rect_filled(rect, 4.0, tk.row_hover); + ui.painter().rect_filled(rect, 4.0, tokens.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); + ui.painter().text(chevron.center(), egui::Align2::CENTER_CENTER, symbol, egui::FontId::proportional(11.0), tokens.text_dim); } let x = chevron.right() + 2.0; - let color = if selected { tk.text_strong } else { tk.text }; + let color = if selected { tokens.text_strong } else { tokens.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); @@ -236,6 +199,7 @@ fn tree_row(app: &mut MaterialCraftApp, ui: &mut Ui, label: &str, category: &str } } +/// Persist the expansion state of one category. fn set_open(app: &mut MaterialCraftApp, category: &str, open: bool) { if open { app.ui.library_expanded.insert(category.to_string()); @@ -249,6 +213,7 @@ 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() } +/// Draw known categories first, followed by categories supplied by packages. 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(); @@ -263,6 +228,7 @@ fn category_tree(app: &mut MaterialCraftApp, ui: &mut Ui, entries: &[LibraryEntr } } } + // Packages can name categories the tree doesn't have; they go last let mut extra: Vec<&str> = Vec::new(); for entry in entries { @@ -276,72 +242,63 @@ fn category_tree(app: &mut MaterialCraftApp, ui: &mut Ui, entries: &[LibraryEntr } } -/// 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> { +/// Matching entries ordered by their displayed names in tiles and list views. +pub(crate) fn visible<'a>(app: &MaterialCraftApp, entries: &'a [LibraryEntry], target: &LibraryTarget) -> Vec<&'a LibraryEntry> { let search = app.ui.library_search.trim().to_lowercase(); let category = app.ui.library_category.as_str(); - let mut out: Vec<(u8, &LibraryEntry)> = entries + let mut visible: Vec<_> = 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| { + .filter(|entry| app.ui.library_show_other || entry.canvas == LibraryCanvas::Any || entry.canvas == target.canvas) + .filter(|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)); + return tr(&entry.label).to_lowercase().contains(&search) || entry.id.to_lowercase().contains(&search); } - let fits = match category { + + 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() + visible.sort_by_cached_key(|entry| (tr(&entry.label).to_lowercase(), entry.id.as_str())); + visible } -fn items(app: &mut MaterialCraftApp, ui: &mut Ui, entries: &[LibraryEntry], here: &Here) { - let tk = Tokens::get(ui.ctx()); +/// Draw matching entries and dispatch compatible additions or favorite changes. +fn items(app: &mut MaterialCraftApp, ui: &mut Ui, entries: &[LibraryEntry], target: &LibraryTarget) { + let tokens = Tokens::get(ui.ctx()); let ctx = ui.ctx().clone(); - let list = visible(app, entries, here); + let list = visible(app, entries, target); if list.is_empty() { 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)); + ui.label(RichText::new(text).color(tokens.text_dim)); return; } + let as_list = app.ui.prefs.library_list; 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 columns = 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) { + for chunk in list.chunks(columns) { ui.horizontal(|ui| { ui.spacing_mut().item_spacing = vec2(4.0, 4.0); for entry in chunk { let size = if as_list { vec2(ui.available_width(), 26.0) } else { tile }; 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 takes = target.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); + ui.painter().rect_filled(rect, 6.0, tokens.row_selected); } else if response.hovered() { - ui.painter().rect_filled(rect, 6.0, tk.row_hover); + ui.painter().rect_filled(rect, 6.0, tokens.row_hover); } let fade = if takes { 1.0 } else { 0.4 }; let image = if as_list { @@ -350,7 +307,7 @@ fn items(app: &mut MaterialCraftApp, ui: &mut Ui, entries: &[LibraryEntry], here Rect::from_min_size(rect.min + vec2(5.0, 4.0), vec2(68.0, 68.0)) }; preview(app, ui, &ctx, entry, image, fade); - let color = if entry.warning.is_some() { WARNING } else { tk.text }; + let color = if entry.warning.is_some() { WARNING } else { tokens.text }; let color = color.gamma_multiply(if takes { 1.0 } else { 0.55 }); if as_list { let galley = crate::widgets::elided(ui.painter(), entry.label.clone(), 11.5, color, rect.width() - 34.0); @@ -361,14 +318,20 @@ fn items(app: &mut MaterialCraftApp, ui: &mut Ui, entries: &[LibraryEntry], here ui.painter().with_clip_rect(rect).galley(pos, galley, color); } 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); + ui.painter().text( + rect.right_top() + vec2(-8.0, 9.0), + egui::Align2::CENTER_CENTER, + icon::STAR, + egui::FontId::proportional(10.0), + tokens.accent, + ); } 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()) { + if let Some(reason) = target.refusal(entry).or_else(|| entry.warning.clone()) { tip.push_str(&format!("\n\n{reason}")); } let response = response.on_hover_text(tip); @@ -441,6 +404,7 @@ fn preview(app: &mut MaterialCraftApp, ui: &Ui, ctx: &egui::Context, entry: &Lib } } +/// Choose the preview accent for an entry category. fn category_color(category: &str) -> Color32 { match category.split('/').next().unwrap_or("") { "Graph items" | "Atomic nodes" | "FxMap nodes" => Color32::from_rgb(0x5c, 0x62, 0x6e), @@ -456,6 +420,7 @@ fn category_color(category: &str) -> Color32 { } } +/// Create the payload accepted by the destination canvas. fn drag(ctx: &egui::Context, entry: &LibraryEntry) { match &entry.item { LibraryItem::Operation { operation } => egui::DragAndDrop::set_payload(ctx, FunctionLibraryDrag::Operation(operation.clone())), @@ -469,6 +434,25 @@ fn drag(ctx: &egui::Context, entry: &LibraryEntry) { /// 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) { + if entry.canvas == LibraryCanvas::Any { + let target = crate::annotation::target(app); + crate::annotation::activate(app, target); + let camera = crate::annotation::camera(app); + let at = [camera.pan[0] + app.graph.view.width() * 0.5 / camera.zoom, camera.pan[1] + app.graph.view.height() * 0.5 / camera.zoom]; + if let Some(result) = app.run("library.add", serde_json::json!({"entry": entry.id, "at": at, "snapToGrid": app.ui.prefs.snap_to_grid})) { + let id = result["result"]["id"].as_u64().and_then(|id| u32::try_from(id).ok()); + let selection = if app.session.annotation_selection.is_some() { Vec::new() } else { id.into_iter().collect() }; + if let Some(editor) = &mut app.function_editor { + editor.selection = selection.clone(); + editor.selected_wires.clear(); + } + if let Some(editor) = &mut app.pattern_editor { + editor.selection = selection; + editor.selected_wires.clear(); + } + } + return; + } match &entry.item { LibraryItem::Operation { operation } => crate::function::library::add(app, &FunctionLibraryDrag::Operation(operation.clone())), LibraryItem::FunctionInstance { package, graph } => { diff --git a/crates/ui-egui/src/library.test.rs b/crates/ui-egui/src/library.test.rs index 522ca15..03f38c4 100644 --- a/crates/ui-egui/src/library.test.rs +++ b/crates/ui-egui/src/library.test.rs @@ -2,15 +2,18 @@ use super::*; use materialcraft_engine::core::NodeId; use serde_json::json; +/// Create a headless material editor for library interactions. fn app() -> MaterialCraftApp { MaterialCraftApp::headless(materialcraft_engine::new_session(), crate::UiState::default()) } +/// Collect labels visible under the current library filter. 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() + visible(app, &entries, &LibraryTarget::of(app)).into_iter().map(|entry| entry.label.clone()).collect() } +/// Open project graphs remain separate from reusable library entries. #[test] fn open_package_graphs_are_explorer_resources_not_library_entries() { let mut app = app(); @@ -26,6 +29,7 @@ fn open_package_graphs_are_explorer_resources_not_library_entries() { assert!(labels(&app).iter().any(|label| label == "Uniform color")); } +/// Category filtering includes descendants and favorite toggles update membership. #[test] fn categories_include_their_sub_categories_and_favorites_follow_the_star() { let mut app = app(); @@ -45,41 +49,57 @@ fn categories_include_their_sub_categories_and_favorites_follow_the_star() { assert_eq!(labels(&app), ["Pi"]); } +/// Tiles and list rows stay alphabetical across categories, favorites and search. #[test] -fn search_puts_what_the_open_graph_takes_first_and_filters_hide_the_rest() { +fn library_previews_are_alphabetical_in_every_view() { let mut app = app(); - // "Uniform" names a native node and random functions; a material graph takes only the node - app.ui.library_search = "uniform".into(); - let found = labels(&app); - assert_eq!(found.first().map(String::as_str), Some("Uniform color"), "{found:?}"); - assert!(found.len() > 1, "{found:?}"); - 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"); + for (category, search) in [("", ""), ("Graph items", ""), ("Atomic nodes", ""), ("Functions", ""), ("", "uniform")] { + app.ui.library_category = category.into(); + app.ui.library_search = search.into(); + let found = labels(&app); + assert!(found.len() > 1); + let keys: Vec<_> = found.iter().map(|label| tr(label).to_lowercase()).collect(); + assert!(keys.windows(2).all(|pair| pair[0] <= pair[1]), "{category}/{search}: {found:?}"); + } 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))); + let target = LibraryTarget::of(&app); + assert!(visible(&app, &entries, &target).iter().all(|entry| target.takes(entry))); } +/// The FX-Map category contains its three processing nodes, without a Dot tile. +#[test] +fn fx_map_library_does_not_list_dot() { + let mut app = app(); + app.ui.library_category = "FxMap nodes".into(); + let mut found = labels(&app); + found.sort(); + assert_eq!(found, ["Iterate", "Quadrant", "Switch"]); +} + +/// Both processor canvases accept samplers and keep material operations separate. #[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()); + for definition in ["pixel_processor", "value_processor"] { + let mut app = app(); + let owner = NodeId(app.run("graph.node.add", json!({"def": definition})).unwrap()["id"].as_u64().unwrap()); + app.function_editor = + Some(crate::function::FunctionEditor::new(app.session.graph, owner, crate::function::FunctionTarget::Parameter("function".into()))); + let target = LibraryTarget::of(&app); + let entries = app.session.library_entries(); + let find = |id: &str| entries.iter().find(|entry| entry.id == id).unwrap(); + + for id in ["function:add", "function:samplelum", "function:samplecol", "sbs://functions.sbs#Functions/Math/Pi"] { + assert!(target.takes(find(id)), "{definition}: {id}"); + } + assert!(!target.takes(find("node:blur"))); + assert!(target.refusal(find("node:blur")).is_some()); + } } +/// Known categories have icons and compatible entries can be inserted. #[test] fn every_tree_category_has_an_icon_and_double_click_adds() { for (top, subs) in CATEGORIES { @@ -92,10 +112,11 @@ fn every_tree_category_has_an_icon_and_double_click_adds() { let mut app = app(); let before = app.session.graph().unwrap().nodes.len(); let entries = app.session.library_entries(); + // A material graph takes the Blur node, not a function for id in ["node:blur", "sbs://functions.sbs#Functions/Math/Pi"] { let entry = entries.iter().find(|entry| entry.id == id).unwrap(); - if Here::of(&app).takes(entry) { + if LibraryTarget::of(&app).takes(entry) { add_entry(&mut app, entry); } } @@ -104,3 +125,43 @@ fn every_tree_category_has_an_icon_and_double_click_adds() { add_entry(&mut app, entries.iter().find(|entry| entry.id == "item:comment").unwrap()); assert_eq!(app.session.graph().unwrap().comments.len(), comments + 1); } + +/// Dot is a graph item rather than a second entry among function operations. +#[test] +fn function_control_library_does_not_list_dot() { + let mut app = app(); + app.ui.library_category = "Function nodes/Control".into(); + assert!(!labels(&app).iter().any(|label| label.to_lowercase().contains("dot"))); +} + +/// The shared Graph items remain available when hiding entries for other canvas types. +#[test] +fn graph_items_are_available_and_insertable_in_every_editor() { + for kind in ["material", "function", "pixel_processor", "value_processor", "fx_map"] { + let mut app = app(); + if kind == "function" { + app.run("file.new", json!({"kind": "function"})).unwrap(); + app.function_editor = Some(crate::function::FunctionEditor::standalone(app.session.graph)); + } else if kind != "material" { + let owner = NodeId(app.run("graph.node.add", json!({"def": kind})).unwrap()["id"].as_u64().unwrap()); + if kind == "fx_map" { + app.pattern_editor = Some(crate::pattern::PatternEditor::new(app.session.graph, owner)); + } else { + app.function_editor = + Some(crate::function::FunctionEditor::new(app.session.graph, owner, crate::function::FunctionTarget::Parameter("function".into()))); + } + } + app.graph.view = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(800.0, 600.0)); + app.ui.library_category = "Graph items".into(); + app.ui.library_show_other = false; + assert_eq!(labels(&app), ["Comment", "Dot node", "Frame", "Pin"], "{kind}"); + let entries = app.session.library_entries(); + let target = LibraryTarget::of(&app); + for entry in entries.iter().filter(|entry| entry.category == "Graph items") { + assert!(target.takes(entry), "{kind}: {}", entry.label); + add_entry(&mut app, entry); + } + let items = crate::annotation::target(&app).items(&app.session).unwrap(); + assert_eq!((items.comments.len(), items.frames.len(), items.pins.len()), (1, 1, 1), "{kind}"); + } +} diff --git a/crates/ui-egui/src/library/library_target.rs b/crates/ui-egui/src/library/library_target.rs new file mode 100644 index 0000000..cdb2908 --- /dev/null +++ b/crates/ui-egui/src/library/library_target.rs @@ -0,0 +1,48 @@ +use crate::{MaterialCraftApp, graph::editor_target::EditorTarget, i18n::tr}; +use materialcraft_engine::{LibraryCanvas, LibraryEntry, LibraryItem}; + +/// The graph the library adds to, and which native function operations it can take +pub(crate) struct LibraryTarget { + pub(super) canvas: LibraryCanvas, + operations: Vec<&'static str>, +} + +impl LibraryTarget { + /// Resolve the active editor and its permitted operations. + pub(crate) fn of(app: &MaterialCraftApp) -> LibraryTarget { + match EditorTarget::resolve(app) { + EditorTarget::Material => LibraryTarget { canvas: LibraryCanvas::Material, operations: Vec::new() }, + EditorTarget::Pattern => LibraryTarget { canvas: LibraryCanvas::Pattern, operations: Vec::new() }, + EditorTarget::Function => LibraryTarget { 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 == LibraryCanvas::Any || 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 + pub(super) fn refusal(&self, entry: &LibraryEntry) -> Option<String> { + if let Some(missing) = &entry.missing { + return Some(missing.clone()); + } + + if entry.canvas != LibraryCanvas::Any && entry.canvas != self.canvas { + return Some( + match entry.canvas { + LibraryCanvas::Any | 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()) + } +} diff --git a/crates/ui-egui/src/material_craft_app.rs b/crates/ui-egui/src/material_craft_app.rs index e89d73c..d958caa 100644 --- a/crates/ui-egui/src/material_craft_app.rs +++ b/crates/ui-egui/src/material_craft_app.rs @@ -147,6 +147,21 @@ impl MaterialCraftApp { /// Run an engine command, reporting errors as toasts. Returns the result on success pub fn run(&mut self, id: &str, mut params: Value) -> Option<Value> { + if id.starts_with("graph.annotation.") + || id.starts_with("graph.frame.") + || id.starts_with("graph.comment.") + || id.starts_with("graph.pin.") + || id == "library.add" + { + if params.is_null() { + params = serde_json::json!({}); + } + if let (Some(parameters), Some(target)) = (params.as_object_mut(), self.graph.annotation_target.parameters().as_object()) { + for (name, value) in target { + parameters.entry(name).or_insert_with(|| value.clone()); + } + } + } if id.starts_with("file.") || id.starts_with("package.") || matches!(id, "graph.open" | "graph.delete" | "graph.duplicate" | "folder.remove" | "explorer.paste" | "edit.undo" | "edit.redo") @@ -186,6 +201,14 @@ impl MaterialCraftApp { match cook::execute_guarded(&mut self.session, id, ¶ms) { Ok(v) => { + if matches!(id, "graph.pin.add" | "library.add") + && let Some(materialcraft_engine::AnnotationSelection::Pin(pin)) = self.session.annotation_selection + { + self.graph.pin_description_focus = Some(pin); + self.inspected_folder = None; + self.inspected_graph = None; + self.ui.dock.focus(docking::Panel::Properties); + } if id == "view.previewSize" { self.ui.prefs.preview_size = self.session.preview_size.unwrap_or(0); } @@ -384,6 +407,7 @@ impl MaterialCraftApp { /// Draw the whole window into `ui` pub fn draw(&mut self, ui: &mut egui::Ui) { + crate::annotation::activate(self, crate::annotation::target(self)); if !self.fonts_ready { self.fonts_ready = true; return; @@ -395,6 +419,7 @@ impl MaterialCraftApp { menus::menu_bar(self, ui); toolbar::main_toolbar(self, ui); toolbar::status_bar(self, ui); + self.ui.explorer.hovered = false; egui::CentralPanel::default().frame(egui::Frame::NONE.fill(theme::Tokens::get(&ctx).chrome)).show(ui, |ui| docking::show(self, ui)); windows::show(self, &ctx); #[cfg(not(target_arch = "wasm32"))] diff --git a/crates/ui-egui/src/material_craft_app.test.rs b/crates/ui-egui/src/material_craft_app.test.rs index 2cbb012..7363dbc 100644 --- a/crates/ui-egui/src/material_craft_app.test.rs +++ b/crates/ui-egui/src/material_craft_app.test.rs @@ -5,6 +5,20 @@ mod lib_tests { use materialcraft_engine::sample_session; use serde_json::json; + /// A frame which does not draw Explorer clears hover state left by its previous frame. + #[test] + fn review_hidden_explorer_drawing_clears_hover() { + let mut app = MaterialCraftApp::headless(sample_session(), UiState::default()); + app.fonts_ready = true; + app.ui.explorer.hovered = true; + app.ui.dock.close(crate::docking::Panel::Explorer); + let context = egui::Context::default(); + + context.run_ui(egui::RawInput::default(), |ui| app.draw(ui)).textures_delta.clear(); + + assert!(!app.ui.explorer.hovered); + } + #[test] fn run_reports_errors_as_toasts_and_keeps_the_session() { let mut app = MaterialCraftApp::headless(sample_session(), UiState::default()); diff --git a/crates/ui-egui/src/menus.rs b/crates/ui-egui/src/menus.rs index cc70356..18ef4cf 100644 --- a/crates/ui-egui/src/menus.rs +++ b/crates/ui-egui/src/menus.rs @@ -1,6 +1,7 @@ //! Menu actions and shortcuts share stable command ids use craft_keymap::{Active, Bindable, Binding, Chord, Keymap, Platform, Scope, Scopes}; +use egui::class::HasClasses as _; use serde_json::Value; use crate::MaterialCraftApp; @@ -27,15 +28,7 @@ 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")]; -/// 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, -} +pub(crate) use crate::explorer::explorer_row::ExplorerRow; use ExplorerRow::{Item, Separator, Sub}; /// Linking keeps a resource outside the package; MaterialCraft only embeds resources so far @@ -294,44 +287,49 @@ pub fn shortcut_of(id: &str) -> Option<&'static str> { CATALOG.iter().find(|i| i.id == id).and_then(|i| i.shortcut).or_else(|| materialcraft_engine::find(id).and_then(|c| c.shortcut)) } +/// Draw menu bars with aligned labels and a separate gutter for checkmarks. pub fn menu_bar(app: &mut MaterialCraftApp, ui: &mut egui::Ui) { - let tk = Tokens::get(ui.ctx()); - egui::Panel::top("menu_bar").exact_size(24.0).frame(egui::Frame::NONE.fill(tk.chrome).inner_margin(egui::Margin::symmetric(6, 0))).show(ui, |ui| { + let tokens = Tokens::get(ui.ctx()); + egui::Panel::top("menu_bar").exact_size(24.0).frame(egui::Frame::NONE.fill(tokens.chrome).inner_margin(egui::Margin::symmetric(6, 0))).show(ui, |ui| { #[cfg(not(target_arch = "wasm32"))] let window_layout = app.window_layout.clone(); #[cfg(not(target_arch = "wasm32"))] if window_layout.is_some() { craft_window::title_bar::empty_area(ui, ui.max_rect()); } + egui::MenuBar::new().ui(ui, |ui| { - let ctx = ui.ctx().clone(); + let context = ui.ctx().clone(); #[cfg(not(target_arch = "wasm32"))] if let Some(layout) = &window_layout { - crate::window_controls::buttons(ui, &ctx, &layout.left); + crate::window_controls::buttons(ui, &context, &layout.left); } for top in TOP { ui.menu_button(tr(top), |ui| { ui.set_min_width(220.0); - let mut current_sub: Option<&str> = None; - let items: Vec<MenuItem> = CATALOG.iter().filter(|i| i.menu == top).copied().collect(); + let mut current_submenu: Option<&str> = None; + let items: Vec<MenuItem> = CATALOG.iter().filter(|item| item.menu == top).copied().collect(); for item in &items { - if let Some(s) = item.sub { - if current_sub == Some(s) { + if let Some(submenu) = item.sub { + if current_submenu == Some(submenu) { continue; } - current_sub = Some(s); - ui.menu_button(tr(s), |ui| { - for x in items.iter().filter(|x| x.sub == Some(s)) { - menu_item(app, &ctx, ui, x); + + current_submenu = Some(submenu); + ui.menu_button(menu_label(tr(submenu)), |ui| { + for entry in items.iter().filter(|entry| entry.sub == Some(submenu)) { + menu_item(app, &context, ui, entry); } }); continue; } + if item.label == "-" { ui.separator(); continue; } - menu_item(app, &ctx, ui, item); + + menu_item(app, &context, ui, item); } }); } @@ -340,46 +338,71 @@ pub fn menu_bar(app: &mut MaterialCraftApp, ui: &mut egui::Ui) { ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| { let mut right = layout.right.clone(); right.reverse(); - crate::window_controls::buttons(ui, &ctx, &right); + crate::window_controls::buttons(ui, &context, &right); }); } }); }); } -fn menu_item(app: &mut MaterialCraftApp, ctx: &egui::Context, ui: &mut egui::Ui, item: &MenuItem) { - let modality = Modality::capture(app, ctx); - let on = modality.allows(item.id) && enabled(app, item.id); - let mut b = egui::Button::new(tr(item.label)); - if let Some(sc) = item.shortcut { - b = b.shortcut_text(shortcut_label(ctx, sc)); +/// Reserve the same checkmark gutter for commands, toggles and submenus. +fn menu_label(label: &str) -> (egui::Atom<'_>, &str) { + (egui::Atom::custom(egui::IdSalt::new("menu-checkmark"), egui::vec2(12.0, 12.0)), label) +} + +/// Draw a command with an optional checkmark and dispatch it when activated. +fn menu_item(app: &mut MaterialCraftApp, context: &egui::Context, ui: &mut egui::Ui, item: &MenuItem) { + let modality = Modality::capture(app, context); + let is_enabled = modality.allows(item.id) && enabled(app, item.id); + let mut button = egui::Button::new(menu_label(tr(item.label))); + if let Some(shortcut) = item.shortcut { + button = button.shortcut_text(shortcut_label(context, shortcut)); } let checked = match item.id { "ui.view.graph" => Some(true), "ui.graph.snapToGrid" => Some(app.ui.prefs.snap_to_grid), - id if id.starts_with("ui.preview.") => id.strip_prefix("ui.preview.").and_then(|s| s.parse::<u32>().ok()).map(|s| s == app.ui.prefs.preview_size), - id => crate::docking::view_panel(id).map(|p| app.ui.dock.is_open(p)), + id if id.starts_with("ui.preview.") => { + id.strip_prefix("ui.preview.").and_then(|size| size.parse::<u32>().ok()).map(|size| size == app.ui.prefs.preview_size) + } + id => crate::docking::view_panel(id).map(|panel| app.ui.dock.is_open(panel)), }; - - if let Some(c) = checked { - b = b.selected(c); + if let Some(checked) = checked { + // Keep the accessible toggle state without styling the entire row as selected + button = button.selected(checked); + button.remove_class(egui::Button::CLASS_SELECTED); } - if ui.add_enabled(on, b).clicked() { - invoke(app, ctx, item.id); + + let response = ui.add_enabled(is_enabled, |ui: &mut egui::Ui| { + let response = button.atom_ui(ui); + if checked == Some(true) + && let Some(rect) = response.rect(egui::IdSalt::new("menu-checkmark")) + { + let center = rect.center(); + let color = ui.style().interact(&response).fg_stroke.color; + ui.painter().add(egui::Shape::line( + vec![center + egui::vec2(-4.0, 0.0), center + egui::vec2(-1.0, 3.0), center + egui::vec2(4.0, -3.0)], + egui::Stroke::new(1.5, color), + )); + } + response.response + }); + if response.clicked() { + invoke(app, context, item.id); ui.close(); } + #[cfg(not(target_arch = "wasm32"))] if item.id == "file.open" { ui.add_enabled_ui(!modality.is_blocked() && !app.ui.recent.is_empty(), |ui| { - ui.menu_button(tr("Recent packages"), |ui| { + ui.menu_button(menu_label(tr("Recent packages")), |ui| { for path in app.ui.recent.clone() { - if ui.button(&path).clicked() { + if ui.button(menu_label(&path)).clicked() { crate::windows::open_path(app, &path); ui.close(); } } ui.separator(); - if ui.button(tr("Clear recent packages")).clicked() { + if ui.button(menu_label(tr("Clear recent packages"))).clicked() { app.ui.recent.clear(); ui.close(); } @@ -641,6 +664,7 @@ mod tests { assert!(app.ui.windows.export); } + /// Explorer shortcuts affect the hovered selection and leave graph shortcuts elsewhere. #[test] fn explorer_keys_act_on_its_selection_only_while_hovered() { use crate::explorer::ExplorerTarget; @@ -666,6 +690,7 @@ mod tests { assert_eq!(app.session.pkg.graphs.len(), graphs, "removing a graph undoes"); } + /// Explorer menu actions resolve through their documented UI or engine handler. #[test] fn explorer_menus_name_only_actions_that_exist() { for rows in [EXPLORER_PACKAGE, EXPLORER_FOLDER, EXPLORER_GRAPH] { @@ -823,4 +848,17 @@ mod tests { ctx.set_os(egui::os::OperatingSystem::Windows); assert_eq!(shortcut_label(&ctx, "Ctrl+Shift+E"), "Ctrl+Shift+E"); } + /// A hidden Explorer must not delete its selection using stale hover state. + #[test] + fn review_hidden_explorer_ignores_delete() { + let mut app = app(); + let graphs = app.session.pkg.graphs.len(); + app.ui.explorer.selected = Some(crate::explorer::ExplorerTarget::Graph { document: app.session.document_id, index: 0 }); + app.ui.explorer.hovered = true; + app.ui.dock.close(crate::docking::Panel::Explorer); + + dispatched(egui::Key::Delete, egui::Modifiers::NONE, &mut app); + + assert_eq!(app.session.pkg.graphs.len(), graphs); + } } diff --git a/crates/ui-egui/src/pattern/actions.rs b/crates/ui-egui/src/pattern/actions.rs index 9b3c96b..83ff7ae 100644 --- a/crates/ui-egui/src/pattern/actions.rs +++ b/crates/ui-egui/src/pattern/actions.rs @@ -16,7 +16,14 @@ pub(crate) fn enabled(app: &MaterialCraftApp, command: &str) -> Option<bool> { return Some(enabled); } match command { - "ui.graph.snapToGrid" | "graph.cook" | "edit.finish" => None, + "ui.graph.snapToGrid" + | "graph.cook" + | "edit.finish" + | "graph.frame.add" + | "graph.comment.add" + | "graph.pin.add" + | "ui.graph.nextPin" + | "ui.graph.previousPin" => None, command if command.starts_with("graph.") || command.starts_with("ui.graph.") @@ -43,6 +50,10 @@ pub(crate) fn invoke(app: &mut MaterialCraftApp, command: &str) -> bool { } pub(super) fn invoke_editor(app: &mut MaterialCraftApp, editor: &mut PatternEditor, command: &str) { + if app.session.annotation_selection.is_some() && matches!(command, "edit.delete" | "edit.deleteRelink") { + app.run(command, serde_json::json!({})); + return; + } if editor_enabled(app, editor, command) != Some(true) { return; } @@ -61,6 +72,9 @@ pub(super) fn invoke_editor(app: &mut MaterialCraftApp, editor: &mut PatternEdit } pub(super) fn editor_enabled(app: &MaterialCraftApp, editor: &PatternEditor, command: &str) -> Option<bool> { + if app.session.annotation_selection.is_some() && matches!(command, "edit.delete" | "edit.deleteRelink") { + return Some(true); + } let target = materialcraft_engine::SelectionTarget::Pattern(editor.node); if let Some(enabled) = crate::graph::wire_actions::enabled(app, command, &editor.selected_wires, Some(&target)) { return Some(enabled && editor.current(app).is_some()); diff --git a/crates/ui-egui/src/pattern/canvas.rs b/crates/ui-egui/src/pattern/canvas.rs index ba8688e..b8b1f2c 100644 --- a/crates/ui-egui/src/pattern/canvas.rs +++ b/crates/ui-egui/src/pattern/canvas.rs @@ -4,7 +4,7 @@ use materialcraft_engine::core::NodeId; use materialcraft_engine::nodes::PortKind; use std::collections::BTreeMap; -use super::{PatternDrag, PatternEditor, geometry}; +use super::{PatternDrag, PatternEditor, geometry, pattern_canvas::PatternCanvas}; use crate::{ MaterialCraftApp, graph::{GraphCamera, PortHit}, @@ -21,13 +21,24 @@ pub(crate) fn show(app: &mut MaterialCraftApp, ui: &mut Ui) { let present: std::collections::BTreeSet<_> = graph.nodes.iter().map(|node| node.id).collect(); editor.selection.retain(|id| present.contains(id)); } - let Some((geometry, response, camera)) = paint(app, &mut editor, ui) else { return }; + let Some(PatternCanvas { geometry, response, camera, frames, comments, pins }) = paint(app, &mut editor, ui) else { return }; app.ui.frame_all = false; geometry.publish(&mut app.graph, response.rect); - app.graph.frames.clear(); - app.graph.comments.clear(); - super::input::handle(app, &mut editor, ui, &response, &camera); + app.graph.frames = frames.iter().map(|frame| (frame.id, frame.rect)).collect(); + app.graph.comments = comments.clone(); + app.graph.pins = pins.clone(); + let on_annotation = ui + .input(|input| input.pointer.hover_pos()) + .is_some_and(|pointer| frames.iter().any(|frame| frame.contains(pointer)) || comments.iter().chain(&pins).any(|(_, rect)| rect.contains(pointer))); + super::input::handle(app, &mut editor, ui, &response, &camera, on_annotation); + if editor.drag.is_none() { + crate::graph::annotation_input::handle(app, ui, &camera, &frames, &comments, &pins); + if app.session.annotation_selection.is_some() { + editor.selection.clear(); + editor.selected_wires.clear(); + } + } if let Some(PatternDrag::Wire { node, slot }) = editor.drag && let Some(source) = app.graph.ports.iter().find(|port| { port.node.0 == u64::from(node) @@ -44,11 +55,12 @@ pub(crate) fn show(app: &mut MaterialCraftApp, ui: &mut Ui) { app.pattern_editor = Some(editor); } -fn paint(app: &MaterialCraftApp, editor: &mut PatternEditor, ui: &mut Ui) -> Option<(CanvasGeometry, egui::Response, GraphCamera)> { +fn paint(app: &mut MaterialCraftApp, editor: &mut PatternEditor, ui: &mut Ui) -> Option<PatternCanvas> { + let (bounds, response) = ui.allocate_exact_size(ui.available_size().max(vec2(100.0, 100.0)), Sense::click_and_drag()); + app.graph.view = bounds; let graph = editor.current(app)?; let selected: std::collections::BTreeSet<_> = editor.selection.iter().copied().collect(); let mut geometry = CanvasGeometry::default(); - let (bounds, response) = ui.allocate_exact_size(ui.available_size().max(vec2(100.0, 100.0)), Sense::click_and_drag()); crate::widgets::name(&response, egui::Role::Canvas, "FX-Map graph"); let painter = ui.painter_at(bounds); painter.rect_filled(bounds, 0.0, Color32::from_rgb(0x26, 0x28, 0x2c)); @@ -56,12 +68,18 @@ fn paint(app: &MaterialCraftApp, editor: &mut PatternEditor, ui: &mut Ui) -> Opt let frame_key = GraphCamera::frame_key(ui, bounds) && !crate::shell::modality::Modality::capture(app, ui.ctx()).is_blocked(); if !editor.framed || app.ui.frame_all || frame_key { let selected_only = frame_key && !editor.selection.is_empty(); - let destination = graph + let mut destination = graph .nodes .iter() .filter(|node| !selected_only || selected.contains(&node.id)) .map(|node| geometry::bounds(node, editor, snap, selected.contains(&node.id))) .fold(Rect::NOTHING, |all, node| all.union(node)); + if !selected_only { + for frame in &graph.annotations.frames { + destination = + destination.union(Rect::from_min_size(egui::pos2(frame.rect[0], frame.rect[1] - 32.0), vec2(frame.rect[2], frame.rect[3] + 32.0))); + } + } let camera = GraphCamera::fit(bounds, destination); editor.pan = camera.pan; editor.zoom = camera.zoom; @@ -73,12 +91,14 @@ fn paint(app: &MaterialCraftApp, editor: &mut PatternEditor, ui: &mut Ui) -> Opt editor.pan = camera.pan; editor.zoom = camera.zoom; crate::graph::grid::paint(&painter, &camera, bounds); + let frames = crate::graph::annotation_canvas::frames(app, ui, &graph.annotations.frames, &camera); let tokens = Tokens::get(ui.ctx()); let rectangles: BTreeMap<_, _> = graph .nodes .iter() .map(|node| { - let bounds = geometry::bounds(node, editor, snap, selected.contains(&node.id)); + let bounds = geometry::bounds(node, editor, snap, selected.contains(&node.id)) + .translate(crate::graph::annotation_canvas::offset(app, |contents| contents.nodes.contains(&NodeId(u64::from(node.id))))); (node.id, Rect::from_min_max(camera.to_screen(bounds.min), camera.to_screen(bounds.max))) }) .collect(); @@ -140,5 +160,7 @@ fn paint(app: &MaterialCraftApp, editor: &mut PatternEditor, ui: &mut Ui) -> Opt } } - Some((geometry, response, camera)) + let comments = crate::graph::annotation_canvas::comments(app, ui, &graph.annotations.comments, &camera); + let pins = crate::graph::annotation_canvas::pins(app, ui, &graph.annotations.pins, &camera); + Some(PatternCanvas { geometry, response, camera, frames, comments, pins }) } diff --git a/crates/ui-egui/src/pattern/context_menu.rs b/crates/ui-egui/src/pattern/context_menu.rs index e514097..2c930f9 100644 --- a/crates/ui-egui/src/pattern/context_menu.rs +++ b/crates/ui-egui/src/pattern/context_menu.rs @@ -11,6 +11,13 @@ pub(super) fn show(app: &mut MaterialCraftApp, editor: &mut PatternEditor, ui: & add = PatternNodeKind::ALL.into_iter().find(|kind| kind.native_id() == id); } }); + for (label, entry) in [("Add Comment", "item:comment"), ("Add Frame", "item:frame"), ("Add Navigation pin", "item:pin")] { + if ui.button(tr(label)).clicked() { + app.run("library.add", serde_json::json!({"entry": entry, "at": [editor.menu_at.x, editor.menu_at.y]})); + editor.selection.clear(); + ui.close(); + } + } if ui.button(tr("Add Dot node")).clicked() { add = Some(PatternNodeKind::Dot); ui.close(); diff --git a/crates/ui-egui/src/pattern/input.rs b/crates/ui-egui/src/pattern/input.rs index 3d262b6..e78598b 100644 --- a/crates/ui-egui/src/pattern/input.rs +++ b/crates/ui-egui/src/pattern/input.rs @@ -4,7 +4,7 @@ use materialcraft_engine::PatternEdit; use super::{PatternDrag, PatternEditor}; use crate::{MaterialCraftApp, graph::GraphCamera}; -pub(super) fn handle(app: &mut MaterialCraftApp, editor: &mut PatternEditor, ui: &Ui, response: &Response, camera: &GraphCamera) { +pub(super) fn handle(app: &mut MaterialCraftApp, editor: &mut PatternEditor, ui: &Ui, response: &Response, camera: &GraphCamera, on_annotation: bool) { if crate::graph::gesture::cancelled(ui) { editor.drag = None; return; @@ -21,7 +21,8 @@ pub(super) fn handle(app: &mut MaterialCraftApp, editor: &mut PatternEditor, ui: let node = app.graph.rects.iter().rev().find(|(_, bounds)| bounds.contains(pointer)).map(|(id, _)| id.0 as u32); let modifiers = ui.input(|input| input.modifiers); - let on_wire = editor.drag.is_none() + let on_wire = !on_annotation + && editor.drag.is_none() && port.is_none() && node.is_none() && !modifiers.alt @@ -32,7 +33,16 @@ pub(super) fn handle(app: &mut MaterialCraftApp, editor: &mut PatternEditor, ui: && !(port.is_some() && modifiers.alt && ui.input(|input| input.pointer.primary_pressed())) { editor.drag = Some(PatternDrag::Pan(crate::graph::gesture::pan_button(ui))); - } else if editor.drag.is_none() && !on_wire && response.hovered() && ui.input(|input| input.pointer.button_pressed(PointerButton::Primary)) { + } else if !on_annotation + && !app.graph.is_dragging() + && editor.drag.is_none() + && !on_wire + && response.hovered() + && ui.input(|input| input.pointer.button_pressed(PointerButton::Primary)) + { + if app.session.annotation_selection.is_some() { + app.run("graph.annotation.select", serde_json::json!({})); + } crate::graph::node_selection::select(&mut editor.selected_wires, None, modifiers); if let Some((id, slot)) = port { if modifiers.alt { @@ -87,6 +97,17 @@ pub(super) fn handle(app: &mut MaterialCraftApp, editor: &mut PatternEditor, ui: _ => {} } } + if let Some(payload) = crate::widgets::dnd_release::<crate::graph::LibraryDrag>(response) + && let Some(result) = + app.run("library.add", serde_json::json!({"entry": payload.0, "at": [position.x, position.y], "snapToGrid": app.ui.prefs.snap_to_grid})) + { + editor.selection = if app.session.annotation_selection.is_some() { + Vec::new() + } else { + result["result"]["id"].as_u64().and_then(|id| u32::try_from(id).ok()).into_iter().collect() + }; + editor.selected_wires.clear(); + } if response.secondary_clicked() { editor.menu_at = position; if let Some(id) = node diff --git a/crates/ui-egui/src/pattern/mod.rs b/crates/ui-egui/src/pattern/mod.rs index dc56d04..a4ab07a 100644 --- a/crates/ui-egui/src/pattern/mod.rs +++ b/crates/ui-egui/src/pattern/mod.rs @@ -6,6 +6,7 @@ mod input; pub(crate) mod library; mod node_canvas; mod parameter_value; +mod pattern_canvas; mod pattern_drag; mod pattern_editor; pub(crate) mod properties; diff --git a/crates/ui-egui/src/pattern/pattern_canvas.rs b/crates/ui-egui/src/pattern/pattern_canvas.rs new file mode 100644 index 0000000..7e956af --- /dev/null +++ b/crates/ui-egui/src/pattern/pattern_canvas.rs @@ -0,0 +1,12 @@ +use crate::graph::{GraphCamera, canvas_geometry::CanvasGeometry, frame_hit::FrameHit}; +use egui::{Rect, Response}; + +/// Geometry and annotation hit targets produced by one FX-Map canvas frame. +pub(super) struct PatternCanvas { + pub geometry: CanvasGeometry, + pub response: Response, + pub camera: GraphCamera, + pub frames: Vec<FrameHit>, + pub comments: Vec<(u64, Rect)>, + pub pins: Vec<(u64, Rect)>, +} diff --git a/crates/ui-egui/src/pattern/pattern_editor.rs b/crates/ui-egui/src/pattern/pattern_editor.rs index ccb1b6c..2565adf 100644 --- a/crates/ui-egui/src/pattern/pattern_editor.rs +++ b/crates/ui-egui/src/pattern/pattern_editor.rs @@ -19,6 +19,15 @@ pub struct PatternEditor { } impl PatternEditor { + pub(crate) fn camera(&self) -> crate::state::GraphCamera { + crate::state::GraphCamera { pan: self.pan.into(), zoom: self.zoom } + } + + pub(crate) fn set_camera(&mut self, camera: crate::state::GraphCamera) { + self.pan = camera.pan.into(); + self.zoom = camera.zoom; + } + pub fn new(graph: usize, node: NodeId) -> Self { Self { node, diff --git a/crates/ui-egui/src/property/mod.rs b/crates/ui-egui/src/property/mod.rs index da9ae90..9eadab1 100644 --- a/crates/ui-egui/src/property/mod.rs +++ b/crates/ui-egui/src/property/mod.rs @@ -31,7 +31,7 @@ pub fn title(app: &MaterialCraftApp) -> String { } match EditorTarget::resolve(app) { - EditorTarget::Pattern => return crate::pattern::properties::title(app), + EditorTarget::Pattern if !EditorTarget::annotation_active(app) => return crate::pattern::properties::title(app), EditorTarget::Function if !EditorTarget::annotation_active(app) => { return crate::function::properties::title(app).unwrap_or_else(|| { let name = app.session.graph().ok().filter(|graph| graph.function.is_some()).map_or(tr("Function Graph"), |graph| graph.name.as_str()); @@ -45,6 +45,7 @@ pub fn title(app: &MaterialCraftApp) -> String { let name = match selection { materialcraft_engine::AnnotationSelection::Frame(_) => tr("Frame"), materialcraft_engine::AnnotationSelection::Comment(_) => tr("Comment"), + materialcraft_engine::AnnotationSelection::Pin(_) => tr("Navigation Pin"), }; return format!("{name} - {}", tr("Properties")); } @@ -73,7 +74,7 @@ pub fn show(app: &mut MaterialCraftApp, ui: &mut Ui) { } match EditorTarget::resolve(app) { - EditorTarget::Pattern => { + EditorTarget::Pattern if !EditorTarget::annotation_active(app) => { crate::pattern::properties::show(app, ui); return; } diff --git a/crates/ui-egui/tests/snapshot.rs b/crates/ui-egui/tests/snapshot.rs index afede05..426b0c6 100644 --- a/crates/ui-egui/tests/snapshot.rs +++ b/crates/ui-egui/tests/snapshot.rs @@ -1,3 +1,6 @@ +#[path = "snapshot/graph_items.rs"] +mod graph_items; + #[path = "snapshot/explorer.rs"] mod explorer; @@ -16,6 +19,9 @@ mod embedded_graphs; #[path = "snapshot/library.rs"] mod library; +#[path = "snapshot/menu.rs"] +mod menu; + use std::time::Duration; use egui::vec2; @@ -1379,19 +1385,29 @@ fn embedded_function_toolbar_and_panels_share_the_active_target() { save(&mut harness, &directory, &format!("{definition}-inline-function")); harness.state_mut().ui.library_search = "Sample".into(); settle(&mut harness, 2); - for label in ["Sample gray", "Sample color"] { - assert_eq!(harness.query_all(By::new().label(label)).next().is_some(), definition == "pixel_processor"); + for (label, operation) in [("Sample gray", "samplelum"), ("Sample color", "samplecol")] { + let tile = harness.get(By::new().role(egui::accesskit::Role::ListItem).label(label)); + let position = tile.rect().center(); + + double_click(&mut harness, position); + + assert!(target.current(&harness.state().session).unwrap().nodes.iter().any(|node| node.op == operation)); + materialcraft_ui_egui::menus::invoke(harness.state_mut(), &context, "edit.undo"); + settle(&mut harness, 2); + assert_eq!(harness.state().session.pkg, original); } + save(&mut harness, &directory, &format!("{definition}-library-samplers")); + harness.get(By::new().role(egui::accesskit::Role::Canvas).label("Function Graph")).click_secondary(); settle(&mut harness, 2); harness.get_by_label("Add node").click(); settle(&mut harness, 2); for label in ["Sample gray", "Sample color"] { - assert_eq!(harness.query_all(query(label)).next().is_some(), definition == "pixel_processor"); + assert!(harness.query_all(query(label)).next().is_some()); } let labels: Vec<_> = target.available_operations(&harness.state().session).filter(|operation| operation.id != "passthrough").map(|operation| operation.label).collect(); - assert_eq!(labels.len(), if definition == "pixel_processor" { 84 } else { 82 }); + assert_eq!(labels.len(), materialcraft_engine::nodes::function::FUNCTIONS.iter().filter(|operation| operation.id != "passthrough").count()); assert!(harness.query(query("Dot")).is_none()); save(&mut harness, &directory, &format!("{definition}-node-menu")); assert_node_menu_order(&harness, &labels); diff --git a/crates/ui-egui/tests/snapshot/function_library.rs b/crates/ui-egui/tests/snapshot/function_library.rs index 615254c..212976c 100644 --- a/crates/ui-egui/tests/snapshot/function_library.rs +++ b/crates/ui-egui/tests/snapshot/function_library.rs @@ -124,3 +124,44 @@ fn bundled_even_count_opens_as_an_editable_arithmetic_tree() { assert_eq!(function.node(function.output.unwrap()).unwrap().op, "ceil"); save(&mut harness, &directory, "even-count-arithmetic-tree"); } + +#[test] +#[ignore = "requires an offscreen GPU; run explicitly with --ignored"] +fn samplers_drag_into_both_processor_canvases() { + let directory = std::path::PathBuf::from(std::env::var_os("MC_SNAPSHOT_DIR").unwrap()); + std::fs::create_dir_all(&directory).unwrap(); + for definition in ["pixel_processor", "value_processor"] { + let mut app = MaterialCraftApp::headless(materialcraft_engine::new_session(), UiState::default()); + let owner = NodeId(app.run("graph.node.add", json!({"def": definition})).unwrap()["id"].as_u64().unwrap()); + app.ui.library_search = "Sample".into(); + app.ui.prefs.snap_to_grid = false; + let mut harness = harness(app, 1600.0, 960.0); + settle(&mut harness, 5); + harness.key_press_modifiers(egui::Modifiers::CTRL | egui::Modifiers::COMMAND, egui::Key::E); + settle(&mut harness, 4); + let target = FunctionGraphTarget::Parameter { node: owner, parameter: "function".into() }; + let parent_position = harness.state().session.graph().unwrap().node(owner).unwrap().pos; + let parent_count = harness.state().session.graph().unwrap().nodes.len(); + + for (label, operation, offset) in [("Sample gray", "samplelum", vec2(-150.0, 0.0)), ("Sample color", "samplecol", vec2(150.0, 0.0))] { + let before = target.current(&harness.state().session).unwrap().clone(); + + drag(&mut harness, label, offset); + + let function = target.current(&harness.state().session).unwrap(); + assert_eq!(function.nodes.len(), before.nodes.len() + 1, "{definition}: {label}"); + let added = function.nodes.iter().find(|node| !before.nodes.iter().any(|previous| previous.id == node.id)).unwrap(); + assert_eq!(added.op, operation); + harness.get(By::new().role(egui::accesskit::Role::Button).label(label)); + let after = function.clone(); + harness.state_mut().session.undo().unwrap(); + assert_eq!(target.current(&harness.state().session).unwrap(), &before); + harness.state_mut().session.redo().unwrap(); + assert_eq!(target.current(&harness.state().session).unwrap(), &after); + settle(&mut harness, 2); + } + assert_eq!(harness.state().session.graph().unwrap().nodes.len(), parent_count); + assert_eq!(harness.state().session.graph().unwrap().node(owner).unwrap().pos, parent_position); + save(&mut harness, &directory, &format!("library-sampler-drag-{definition}")); + } +} diff --git a/crates/ui-egui/tests/snapshot/graph_items.rs b/crates/ui-egui/tests/snapshot/graph_items.rs new file mode 100644 index 0000000..852ebe6 --- /dev/null +++ b/crates/ui-egui/tests/snapshot/graph_items.rs @@ -0,0 +1,68 @@ +use super::{By, MaterialCraftApp, Queryable, UiState, harness, save, settle}; +use egui::{Event, Key, Modifiers, PointerButton, accesskit::Role, vec2}; +use serde_json::json; + +/// A Library pin can be dropped, renamed, reselected and deleted on every canvas. +#[test] +#[ignore = "requires an offscreen GPU; run explicitly with --ignored"] +fn navigation_pin_library_drop_and_properties_in_every_canvas() { + let directory = std::path::PathBuf::from(std::env::var_os("MC_SNAPSHOT_DIR").unwrap()); + std::fs::create_dir_all(&directory).unwrap(); + for kind in ["material", "function", "pixel_processor", "value_processor", "fx_map"] { + let mut app = MaterialCraftApp::headless(materialcraft_engine::new_session(), UiState::default()); + if kind == "function" { + app.run("file.new", json!({"kind": "function"})).unwrap(); + } else if kind != "material" { + app.run("graph.node.add", json!({"def": kind})).unwrap(); + materialcraft_ui_egui::menus::invoke(&mut app, &egui::Context::default(), "graph.node.edit"); + } + app.ui.library_category = "Graph items".into(); + app.ui.library_show_other = false; + let mut harness = harness(app, 1600.0, 960.0); + settle(&mut harness, 6); + for label in ["Comment", "Dot node", "Frame", "Pin"] { + assert!(harness.query(By::new().role(Role::ListItem).label(label)).is_some(), "{kind}: {label}"); + } + let start = harness.get(By::new().role(Role::ListItem).label("Pin")).rect().center(); + let end = harness.state().graph.view.center() + vec2(130.0, 80.0); + harness.event(Event::PointerMoved(start)); + harness.step(); + harness.event(Event::PointerButton { pos: start, button: PointerButton::Primary, pressed: true, modifiers: Modifiers::NONE }); + harness.step(); + for position in [start + vec2(15.0, 0.0), end] { + harness.event(Event::PointerMoved(position)); + harness.step(); + } + harness.event(Event::PointerButton { pos: end, button: PointerButton::Primary, pressed: false, modifiers: Modifiers::NONE }); + settle(&mut harness, 4); + let target = harness.state().session.annotation_target.clone(); + assert_eq!(target.items(&harness.state().session).unwrap().pins.len(), 1, "{kind}"); + let input = By::new().role(Role::TextInput).label("Navigation Pin description"); + assert!(harness.query(input.clone()).is_some(), "{kind}"); + assert!(harness.ctx.egui_wants_keyboard_input(), "new pin description must receive focus: {kind}"); + harness.event(Event::ModifiersChanged(Modifiers::COMMAND)); + harness.event(Event::Key { key: Key::A, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::COMMAND }); + harness.step(); + harness.event(Event::Key { key: Key::A, physical_key: None, pressed: false, repeat: false, modifiers: Modifiers::COMMAND }); + harness.event(Event::ModifiersChanged(Modifiers::NONE)); + harness.event(Event::Text("Review checkpoint".into())); + settle(&mut harness, 3); + assert_eq!(target.items(&harness.state().session).unwrap().pins[0].name, "Review checkpoint", "{kind}"); + save(&mut harness, &directory, &format!("navigation-pin-{kind}")); + + let marker = harness.state().graph.pins[0].1.left_center() + vec2(6.0, 0.0); + harness.event(Event::PointerMoved(marker)); + harness.step(); + for pressed in [true, false] { + harness.event(Event::PointerButton { pos: marker, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE }); + harness.step(); + } + harness.event(Event::Key { key: Key::Delete, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE }); + harness.step(); + harness.event(Event::Key { key: Key::Delete, physical_key: None, pressed: false, repeat: false, modifiers: Modifiers::NONE }); + settle(&mut harness, 3); + assert!(target.items(&harness.state().session).unwrap().pins.is_empty(), "Delete must remove the selected pin in {kind}"); + harness.state_mut().session.undo().unwrap(); + assert_eq!(target.items(&harness.state().session).unwrap().pins[0].name, "Review checkpoint"); + } +} diff --git a/crates/ui-egui/tests/snapshot/library.rs b/crates/ui-egui/tests/snapshot/library.rs index 7a92bb8..2525483 100644 --- a/crates/ui-egui/tests/snapshot/library.rs +++ b/crates/ui-egui/tests/snapshot/library.rs @@ -1,14 +1,17 @@ use super::{By, MaterialCraftApp, Queryable, UiState, harness, save, settle, vec2}; use egui::accesskit::Role; +/// Find a category by its accessible tree label. fn tree(label: &str) -> By<'_> { By::new().role(Role::TreeItem).label(label) } +/// Find an entry by its accessible list-item label. fn tile(label: &str) -> By<'_> { By::new().role(Role::ListItem).label(label) } +/// Render categories, search and favorites while exercising a library drag. #[test] #[ignore = "requires an offscreen GPU; run explicitly with --ignored"] fn library_tree_shows_every_category_and_adds_what_the_graph_takes() { @@ -110,6 +113,7 @@ fn library_tree_shows_every_category_and_adds_what_the_graph_takes() { 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); diff --git a/crates/ui-egui/tests/snapshot/menu.rs b/crates/ui-egui/tests/snapshot/menu.rs new file mode 100644 index 0000000..77c05b6 --- /dev/null +++ b/crates/ui-egui/tests/snapshot/menu.rs @@ -0,0 +1,55 @@ +use super::{By, MaterialCraftApp, NodeT, Queryable, UiState, harness, save, settle}; +use egui::accesskit::{Role, Toggled}; + +/// A menu toggle keeps the row neutral and exposes its state with a checkmark. +fn check_menu_toggle(menu: &str, label: &str) { + 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, 4); + let button = |label| By::new().role(Role::Button).label(label); + let anchor = if menu == "Tools" { "Compute graph" } else { "Reset layout" }; + let mut fills = Vec::new(); + let mut marks = Vec::new(); + + for checked in [true, false] { + harness.get(button(menu)).click(); + settle(&mut harness, 3); + harness.event(egui::Event::PointerMoved(egui::pos2(800.0, 250.0))); + settle(&mut harness, 3); + let menu_items = harness.get(button(anchor)).parent().unwrap(); + let item = menu_items.get(button(label)); + assert_eq!(item.accesskit_node().toggled(), Some(if checked { Toggled::True } else { Toggled::False })); + let rect = item.rect(); + let image = harness.render().unwrap(); + fills.push(*image.get_pixel((rect.right() - 8.0) as u32, rect.center().y as u32)); + let mut mark = Vec::new(); + for y in (rect.center().y as u32 - 5)..(rect.center().y as u32 + 5) { + for x in (rect.left() as u32 + 3)..(rect.left() as u32 + 19) { + mark.push(*image.get_pixel(x, y)); + } + } + marks.push(mark); + save(&mut harness, &directory, &format!("menu-{}-{}", menu.to_lowercase(), if checked { "checked" } else { "unchecked" })); + harness.get(button(anchor)).parent().unwrap().get(button(label)).click(); + settle(&mut harness, 3); + } + + assert_eq!(fills[0], fills[1], "checked items must not have a persistent row highlight"); + assert_ne!(marks[0], marks[1], "the checkmark must show the toggle state"); +} + +/// Tools uses a checkmark for snapping while the rest of the row stays neutral. +#[test] +#[ignore = "requires an offscreen GPU; run explicitly with --ignored"] +fn tools_menu_uses_checkmarks_for_toggles() { + check_menu_toggle("Tools", "Snap to grid"); +} + +/// Windows uses the same checkmark treatment for visible panels. +#[test] +#[ignore = "requires an offscreen GPU; run explicitly with --ignored"] +fn windows_menu_uses_checkmarks_for_panels() { + check_menu_toggle("Windows", "Explorer"); +} diff --git a/docs/architecture.md b/docs/architecture.md index 83f5136..b02d32e 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -196,7 +196,7 @@ them. Alignment uses the same engine command for all three models, with explicit and an explicit Function target or FX-Map owner ID, so overlapping IDs cannot move the parent material nodes. Pixel Processor, Value Processor and parameter functions use that same main panel and function node catalog, with one target-aware availability rule shared by node creation, Library and Add node. -Value Processor omits the two sampler entries; saved functions retain their existing operations. +Both processor types accept Sample gray and Sample color to read their image inputs. A breadcrumb and parent action return from nested functions, FX-Maps and local graph instances while retaining the parent view and material preview. diff --git a/docs/atomic-workflow.md b/docs/atomic-workflow.md index 9ef2c15..26c9ef5 100644 --- a/docs/atomic-workflow.md +++ b/docs/atomic-workflow.md @@ -122,8 +122,9 @@ saved files still needs external verification. Function Graphs share the main canvas card geometry and styling, including compact Dot nodes. The Graph, Function Graph and FX-Map Add node menus remain flat and preserve their native catalog -order, also used by the Library. The regular graph menu separates primitives, inputs and output; -Dot is excluded from every Add node list and is added through its separate action. The function -and Pixel Processor menus list 84 operations; Value Processor omits the two samplers. FX-Map lists +order; Library previews are sorted by name. The regular graph menu separates primitives, inputs and output; +Dot is excluded from every Add node list and is added through its separate action. Function +Graph and both processor menus include Sample gray and Sample color. These samplers can also be +dragged from the Library into either processor function. FX-Map lists Quadrant, Switch, Iterate in that order. Type a letter to enable names starting with it while keeping the full list visible; Backspace clears the filter. diff --git a/docs/control-protocol.md b/docs/control-protocol.md index f5051aa..99cfb37 100644 --- a/docs/control-protocol.md +++ b/docs/control-protocol.md @@ -113,8 +113,8 @@ 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.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 (`any` for shared graph items), `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, pattern?: owner node id}`: 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 | @@ -122,9 +122,9 @@ Types: `move`, `down`, `up`, `click`, `doubleClick`, `drag`, `scroll`, `key` (eg Every `.sbs` file in the library folder (`assets/sbs`, or `MATERIALCRAFT_SBS_DIR`; installed and browser builds use the bundled `functions.sbs`) loads once per process, and its graphs join every -session's dependencies. Function graphs are listed under Functions, in the sub-category their folder -names (`Functions/colorValues` → Color, `Functions/easings` → Easings); other graphs under the -category in their attributes. A package whose graphs group nodes in titled frames lays the library +session's dependencies. Function graphs are listed under Functions using recognized Tags, then +Category or package-path fallbacks (`Functions/colorValues` → Color, `Functions/easings` → Easings). +Other graphs use the category in their attributes. A package whose graphs group nodes in titled frames lays the library out instead: a frame titled `Top - Sub` (or `Top`) is a Library category, and every node inside it becomes an entry there, `missing` until its package is in the folder. Function frames name only the sub-category. The older category name "SDF functions" reads as MCF functions. @@ -270,12 +270,12 @@ The catalog in `crates/nodes/src/function/catalog.rs` defines all native operati Processors and dynamic parameters use the same function representation. Graph validation and execution use bounded iterative traversal and reject cycles. -`graph.annotation.select {"kind": "frame"|"comment", "id": ...}` selects an annotation. +`graph.annotation.select {"kind": "frame"|"comment"|"pin", "id": ...}` selects an annotation. `graph.frame.edit` accepts `title`, `titleVisible`, `description`, `color` and `rect`. `graph.frame.move {"id": ..., "by": [dx, dy], "snapToGrid": true}` moves enclosed nodes, comments, nested frames and pins together. `graph.comment.edit` accepts `text`, `at` and `size`. `session.inspect` includes annotation selection and the standalone function; `ui.inspect` -includes frame and comment rectangles for synthetic input. +includes frame, comment and pin rectangles for synthetic input. ## Portable materials (TextureCraft) @@ -347,3 +347,19 @@ Bitmap Color space selects sRGB or Linear. `graph.input.bind` accepts `linear: t height and other data maps. Input preview bindings persist in native SBS graph options with the `materialcraft.previewImage.` and `materialcraft.previewLinear.` prefixes; these options describe MaterialCraft editor previews and do not establish external application interoperability. + +### Shared graph items and classification metadata + +The Library sorts previews by their displayed names. Graph items (Comment, Dot node, Frame and +Pin) are available in material, standalone Function, embedded Function and FX-Map canvases. +Dot node appears only in Graph items. To address an embedded canvas, annotation commands and +`library.add` accept `function: FunctionGraphTarget` or `pattern: owner node id`. +`graph.pin.edit {id, description?, at?}` edits a pin's description or position. Selecting a pin +shows its Description field; creating one focuses that field. Delete and undo apply to the +selected pin. `session.inspect` reports `annotationTarget`; `ui.inspect` also reports pin bounds. +Frames, comments and pins are saved in the owning canvas's SBS `GUIObjects` section. + +Function-library conversion preserves Category and Tags, including empty values. Recognized +function tags select Library filters before category-path and package-path fallbacks; multiple +recognized tags can place the function in multiple filters. The tag `Easing` maps to the +`Functions/Easings` filter. This does not implement project-configurable Library filters. diff --git a/docs/file-format-parity.md b/docs/file-format-parity.md index 0d8b1d6..cd51cab 100644 --- a/docs/file-format-parity.md +++ b/docs/file-format-parity.md @@ -17,7 +17,7 @@ material artists exchange. | Format | Read | Write | Fidelity | Tests | |---|---|---|---|---| -| `.sbs` package (XML), the main format | Yes: atomic filters, library nodes with a MaterialCraft node of the same name (88 of the 491 in a sample that instanced every library node), graph instances, graph inputs/outputs, exposed values, parameters linked to inputs, base parameters, frames, comments, embedded and linked bitmaps and SVGs. Anything else (missing nodes, curve points, gradient keys, function graphs, environment maps) is a Console warning; missing nodes stay as placeholders | Yes: SBS data with bitmaps embedded, plus MaterialCraft's exact copy | Lossless for files MaterialCraft saved (exact copy, guarded by a content hash); placeholders round-trip their SBS data | `formats::sbs::tests`, engine `sbs_is_the_default_save_format_and_mcraft_still_works`, `an_sbs_file_with_missing_nodes_opens_softly` | +| `.sbs` package (XML), the main format | Yes: atomic filters, linked library graphs when their source SBS package is available, graph instances, graph inputs/outputs, exposed values, parameters linked to inputs, base parameters, frames, comments, embedded and linked bitmaps and SVGs. Anything else (missing nodes, curve points, gradient keys, function graphs, environment maps) is a Console warning; missing nodes stay as placeholders | Yes: SBS data with bitmaps embedded, plus MaterialCraft's exact copy | Lossless for files MaterialCraft saved (exact copy, guarded by a content hash); placeholders round-trip their SBS data | `formats::sbs::tests`, engine `sbs_is_the_default_save_format_and_mcraft_still_works`, `an_sbs_file_with_missing_nodes_opens_softly` | | `.mcraft` package (zip: `package.json` + `resources/`), older | Yes | Yes | Lossless (graphs, parameters, frames, comments, pins, exposed inputs, embedded bitmaps) | `formats::tests::package_round_trip`, engine `package_save_and_open_round_trip` | | PNG | Yes (8/16-bit, gray and color) | Yes (8/16-bit) | 16-bit gray round-trips within 1/65535 | `formats::tests::export_every_format` | | JPEG | Yes | Yes (8-bit) | Lossy | same | @@ -41,3 +41,10 @@ roughness, metallic, height, ambient occlusion, opacity) linear. | 2026-11-04 | major | SBS packages become the main project format; `.mcraft` kept | | 2026-11-02 | minor | `.mcmat` portable materials replace the published-archive gap | | 2026-11-02 | major | First version | + +## Canvas annotations + +Frames, comments and navigation pins round-trip in material graphs, standalone functions, +embedded functions and FX-Map graphs. Pin descriptions and positions are preserved. Pin +attachment references (`GUIDependency`) are not modeled. Dynamic functions on unsupported base +parameters, including `pixelsize`, are not imported, so annotations inside them are not retained. From c7b5a4381d8b681893e484663813da2a6d51e5f3 Mon Sep 17 00:00:00 2001 From: chasse20 <chasse20@gmail.com> Date: Tue, 10 Nov 2026 00:18:09 -0500 Subject: [PATCH 5/5] Remove unused library bitmap --- assets/sbs/all_nodes.resources/test.bmp | Bin 3302 -> 0 bytes 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 assets/sbs/all_nodes.resources/test.bmp diff --git a/assets/sbs/all_nodes.resources/test.bmp b/assets/sbs/all_nodes.resources/test.bmp deleted file mode 100644 index 5a54b4a034cb87309248809848ec1e473038c6b6..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3302 zcmb8yeT>uQ836G2a>X_64Cl_Qt#i9>$tcajPNB+(sOqeg$P&s}rcA|)PGe?ko0>l| zo!5-D4zn%>l~5O@f4E`C>VY6cps-w(fzmr2N~&@xxi!6!%Q{`c*CkLcTq?}&d|XJR zdA-xMEA6^QeqTL)EWbZL@yBaFz2(|Bz$d@;TK|~VR%`9sT5AIjX*~b~+V*!>EVNG& zTF0wkOof^%GOc3ARlQp^bf_ksYDpbB*{9mitB$7XyrH_|k8S;_O0QJCI@R|wMF?tO zTn#qWP)!X-)yPj&d4(EnSL2VX$vx^|QBAkh?39{6q85LwmJzjLf3Ej<=D}Cg+kmfw z`0vK%j1Mby>{MO9y>7tkCQ!F@)@{$$?WwxsR^8dCyGQFDu1^1;?$y<OE9!n{J@Dsx zu<O11{{IEkmHGCKfUknlDl}h3W~x}as_(5D)>KVxRm+O1ZFAM$Uv*rnI$Kru^{OXU zrMFhStExUw^><YRzpj1_@8+*|uBj?*Rjs}fI9Gz^O33XJHd@m6l?>}krh7}4WhL9X zlKth9<7~;PmfZ6tPrgL&DS0=Pd~nHsPbtt{`cjWQarExGUn?maOPW^zBL!%-fHVr& zctIa77|4RDqhJ9ATW7)EQ*azBI4cD=hBfY9ZsGsDd)(c>Y2BUFGE)U5QP8{`csB># z$|21hb|I%flr#K1XX?yZK+cBb?Dm}FZe}U-h2t(Ip@+*$u@>CUDf2na%YaM<x|u;* z8SH9CpU4<?WK3%_7ARv|8h0URX6TuW_gu!eH{*9?0uN-q^#A-UvlI_xlxrEyOMx>f zsGdSvDQr5WA5Ix|rA+peWeMAua`vU%>6GW=6#YkvxRLS=rTknf@MP-id5)BV{4fLf z1Q<#{QwgM%z-}e<qX|PeVOqkLB^;|0&Ypz3KjGOj`Y$!%9lr08YQmpP1pJAw@P?m$ zX{k6ZXiq4QB((Zs;O!Xn<oHB0hRwzFAI1zvVvFAWF*}GkI%3WZF?Vmw6OYjsV&3_f zuMzWKjs*r{U*UZg(_%cP=wg~DgU0^9PRd9_#u~EzifmXYj+AY<Y}d(-cG=k}yEn_8 zKABF*-iqwIBl{b2;IjN*-r3~$J_mem^(9%^Bx{}ok`i=LLT*b~Q_|O@MQ@vA>z3?@ z<N%U$x#V6Wd7hEzeUkSk^xdnH|Be)BNWrQU8j`|$rO3}D`B5nfOYwzcwMc1N%Dy4x zvr=(dDz~J{oK!1I%3G4=iC{p4CPZXb#9E?$VTa?QWv6H(MSGX%fJ7${-77>-w@CMh z-q%Fmu;{Odfq6056hk+}@HsJZP?TQ~qZ`EdDlxe*!nefi6Jnkbi+>W!Ik7S=)|#R+ zFKV6uP6|*_KokLM35(vaU<nJh?Sg&1;8-O%b%MK1@Sp;{PVn{!zLou}QbOQ@5LAUw zO9;;hkqJRg3ei16e5<hN0U>*jkbg)hJ|UE!7b<TEwRZ&Ns-SrsIKe?<98%}7Cb#H) zz*&xSwq2av%{kU`&JNDq#(8ucjdI>@&i4%G@8be-E_j{`eawZMT;vWX-{7KoE*|3+ zz3+3`m0Z4!E9$uNH@S+1t5KYin-~E+3t}uZ$|BcUY@S{8F0qz0YwKt2y{uz1>+G<t zS;2bRSh|h%u3&v@SpQ}=(8~t<*-)AdUt%LOtlVOw^KAS&yXgIa&2DA$kF&)Y-ShXb z6~NY(vq~4M)yIIt<I6@EWRk&VnMH4!v5YgeQ;a>#ICd~jl5wwLJRJ<JW4wUzEoc0l zOke{O>|sKEO!ycRd5@7ROjKp!EoRXxFxe!N-_I0ZV9GbrnMax0N=DH!nn#1fG}QCh zJ2QPx-K6z%>US1S_*L5WK5b9Xjw1)AcF^w4v}Y|%ucEyW?E|#Goep%+!PRtVBOTsO zM|RWlF*<sdUc5e=boxY>V}{O8(#3Oh`2=0rOV^&Gm9roA1D*mh1r1S1k;0}Z{T%h5 z`$1p0?-pgdLfH>D)+Q+DE2)FMl*dic>nU#+<@?3q?K&y|sNgaxgi_(vRK!lnJyi5% zYSBASr9YywDwS_h#U@prp(<6Xc5wHlB&F5o0$a`-PP>r23!8N56_=smT714JF8dXi z<9(O&l*`@k^6YZa<$c!SL)*Gte%uwf-xbukLckSncSR7F-06yH2l`fh-?Og4K3Dop zS2pF!kGYB!S9z+V_l~R9aw!d$=8@n42@R0Q2#HOQ`YF;dOMd$NyhS>$lFo6`ohCiU zNqXPIf7?m=wvm3446GxAU1X?(3`1lDkn+M=(E3htu$xS8BC|bY{zbC*8d*L@R))#i zc~Ys6nnwVMfKCv|83G$4^p^=koiM4yr}KkKIHw8sCBpLoK@St&<AkqQ-n5Gdc!{8! z2-%77S|YN9wGl}`4C;t9Ok`0a-$fL=iSkCG@(fYiK`4EM=2^k(R_Le|Ic>#8toowW zFljZ_t(IBq=jXp^D}BZ49k=?<TK%W2fg{%760;Djx5n34lel%T!<vSzS)DZxtVQ&} zUG3J&a%&B>DxFr%GlTtRNH!xU&Dg!!E$7UJqS<uWY?(6K6tjKK{J-Y+CGU_~4x6KW z=6J6;x!pYIHm5h4v+K=yleySsF0V3I5OeKbv!XL=o)Nrigw_o?jvBE6qkhO}7%`g0 zjFt(bZPI9;GCFP=owLR-et*%tX=C`RF>=8uj~k<-#`pt&|Hmog;BjO6O=C7}%<nc9 zcN)t(jFoN1n%k(5M$N;)UL1O=6CA{`qqzPgZn*f%*cse1g4^=Ay@)%?xN{PBU&lRl zoK|q}EbhCF`wcJtrHKbyc&LSkTX>|2%MCnw8;{T6Nd+IA#?v3+*(-Rygcry0^80w@ zEM6PNl~cIpp<oXRy^12Qqu2pdFQbN|sObc189;5PQTq_;$e_*<)IExN#!$M5dM8ld zMbtlu2CkvODKu0^!#B~$EmWRGqjP9{9!)mT!6uq+q1hIiZ=uB&T5h40CR)3LDh*Wg zU=W0%JutEt#$JW>`(eZDu<5t^t{s4F2VuJmI}XFnqp&*$drrXgN!U98`;xH#G#q#v z4i3SgGjKQqN8W|y5jc7dj*r60JUloCrweel2<Jb9ixY6U3|B6~wac(F32UDA2>~D; zAUwc$pyz>s2PPg^cwpm!od*scIC<dafrke)54=3^@xaf6zyrVE&w~&T!aRuZK;}V| i2XP)Gc`(R>G!L>o$n&7cgE9{)Jg9B_QHck)!M_2M)v9s;