Merge branch 'master' into spline_test1

Author: 0HyperCube

demo-artwork/changing-seasons.graphite

@@ -30,7 +30,9 @@ ron = ["dep:ron"]
 # Local dependencies
 graphite-proc-macros = { path = "../proc-macros" }
 graph-craft = { path = "../node-graph/graph-craft" }
-interpreted-executor = { path = "../node-graph/interpreted-executor", features = ["serde"] }
+interpreted-executor = { path = "../node-graph/interpreted-executor", features = [
+	"serde",
+] }
 graphene-core = { path = "../node-graph/gcore" }
 graphene-std = { path = "../node-graph/gstd", features = ["serde"] }
 
@@ -58,6 +60,9 @@ web-sys = { workspace = true, features = [
 	"Element",
 	"HtmlCanvasElement",
 	"CanvasRenderingContext2d",
+	"CanvasPattern",
+	"OffscreenCanvas",
+	"OffscreenCanvasRenderingContext2d",
 	"TextMetrics",
 ] }
 

demo-artwork/procedural-string-lights.graphite

@@ -282,6 +282,7 @@ pub fn input_mappings() -> Mapping {
 		entry!(KeyDown(Enter); action_dispatch=SplineToolMessage::Confirm),
 		//
 		// FillToolMessage
+		entry!(PointerMove; refresh_keys=[Shift], action_dispatch=FillToolMessage::PointerMove),
 		entry!(KeyDown(MouseLeft); action_dispatch=FillToolMessage::FillPrimaryColor),
 		entry!(KeyDown(MouseLeft); modifiers=[Shift], action_dispatch=FillToolMessage::FillSecondaryColor),
 		entry!(KeyUp(MouseLeft); action_dispatch=FillToolMessage::PointerUp),

editor/Cargo.toml

@@ -276,13 +276,13 @@ impl LayoutMessageHandler {
 
 				responses.add(callback_message);
 			}
-			Widget::PivotInput(pivot_input) => {
+			Widget::ReferencePointInput(reference_point_input) => {
 				let callback_message = match action {
-					WidgetValueAction::Commit => (pivot_input.on_commit.callback)(&()),
+					WidgetValueAction::Commit => (reference_point_input.on_commit.callback)(&()),
 					WidgetValueAction::Update => {
-						let update_value = value.as_str().expect("PivotInput update was not of type: u64");
-						pivot_input.position = update_value.into();
-						(pivot_input.on_update.callback)(pivot_input)
+						let update_value = value.as_str().expect("ReferencePointInput update was not of type: u64");
+						reference_point_input.value = update_value.into();
+						(reference_point_input.on_update.callback)(reference_point_input)
 					}
 				};
 

editor/src/messages/input_mapper/input_mappings.rs

@@ -373,7 +373,7 @@ impl LayoutGroup {
 				Widget::TextInput(x) => &mut x.tooltip,
 				Widget::TextLabel(x) => &mut x.tooltip,
 				Widget::BreadcrumbTrailButtons(x) => &mut x.tooltip,
-				Widget::InvisibleStandinInput(_) | Widget::PivotInput(_) | Widget::RadioInput(_) | Widget::Separator(_) | Widget::WorkingColorsInput(_) | Widget::NodeCatalog(_) => continue,
+				Widget::InvisibleStandinInput(_) | Widget::ReferencePointInput(_) | Widget::RadioInput(_) | Widget::Separator(_) | Widget::WorkingColorsInput(_) | Widget::NodeCatalog(_) => continue,
 			};
 			if val.is_empty() {
 				val.clone_from(&tooltip);
@@ -546,7 +546,7 @@ pub enum Widget {
 	NodeCatalog(NodeCatalog),
 	NumberInput(NumberInput),
 	ParameterExposeButton(ParameterExposeButton),
-	PivotInput(PivotInput),
+	ReferencePointInput(ReferencePointInput),
 	PopoverButton(PopoverButton),
 	RadioInput(RadioInput),
 	Separator(Separator),
@@ -621,7 +621,7 @@ impl DiffUpdate {
 				| Widget::CurveInput(_)
 				| Widget::InvisibleStandinInput(_)
 				| Widget::NodeCatalog(_)
-				| Widget::PivotInput(_)
+				| Widget::ReferencePointInput(_)
 				| Widget::RadioInput(_)
 				| Widget::Separator(_)
 				| Widget::TextAreaInput(_)

editor/src/messages/layout/layout_message_handler.rs

@@ -1,9 +1,9 @@
 use crate::messages::input_mapper::utility_types::misc::ActionKeys;
 use crate::messages::layout::utility_types::widget_prelude::*;
 use derivative::*;
-use glam::DVec2;
 use graphene_core::Color;
 use graphene_core::raster::curve::Curve;
+use graphene_std::transform::ReferencePoint;
 use graphite_proc_macros::WidgetBuilder;
 
 #[derive(Clone, Derivative, serde::Serialize, serde::Deserialize, WidgetBuilder, specta::Type)]
@@ -411,100 +411,18 @@ pub struct CurveInput {
 
 #[derive(Clone, Default, Derivative, serde::Serialize, serde::Deserialize, WidgetBuilder, specta::Type)]
 #[derivative(Debug, PartialEq)]
-pub struct PivotInput {
+pub struct ReferencePointInput {
 	#[widget_builder(constructor)]
-	pub position: PivotPosition,
+	pub value: ReferencePoint,
 
 	pub disabled: bool,
 
 	// Callbacks
 	#[serde(skip)]
 	#[derivative(Debug = "ignore", PartialEq = "ignore")]
-	pub on_update: WidgetCallback<PivotInput>,
+	pub on_update: WidgetCallback<ReferencePointInput>,
 
 	#[serde(skip)]
 	#[derivative(Debug = "ignore", PartialEq = "ignore")]
 	pub on_commit: WidgetCallback<()>,
 }
-
-#[derive(Clone, Copy, serde::Serialize, serde::Deserialize, Debug, Default, PartialEq, Eq, specta::Type)]
-pub enum PivotPosition {
-	#[default]
-	None,
-	TopLeft,
-	TopCenter,
-	TopRight,
-	CenterLeft,
-	Center,
-	CenterRight,
-	BottomLeft,
-	BottomCenter,
-	BottomRight,
-}
-
-impl From<&str> for PivotPosition {
-	fn from(input: &str) -> Self {
-		match input {
-			"None" => PivotPosition::None,
-			"TopLeft" => PivotPosition::TopLeft,
-			"TopCenter" => PivotPosition::TopCenter,
-			"TopRight" => PivotPosition::TopRight,
-			"CenterLeft" => PivotPosition::CenterLeft,
-			"Center" => PivotPosition::Center,
-			"CenterRight" => PivotPosition::CenterRight,
-			"BottomLeft" => PivotPosition::BottomLeft,
-			"BottomCenter" => PivotPosition::BottomCenter,
-			"BottomRight" => PivotPosition::BottomRight,
-			_ => panic!("Failed parsing unrecognized PivotPosition enum value '{input}'"),
-		}
-	}
-}
-
-impl From<PivotPosition> for Option<DVec2> {
-	fn from(input: PivotPosition) -> Self {
-		match input {
-			PivotPosition::None => None,
-			PivotPosition::TopLeft => Some(DVec2::new(0., 0.)),
-			PivotPosition::TopCenter => Some(DVec2::new(0.5, 0.)),
-			PivotPosition::TopRight => Some(DVec2::new(1., 0.)),
-			PivotPosition::CenterLeft => Some(DVec2::new(0., 0.5)),
-			PivotPosition::Center => Some(DVec2::new(0.5, 0.5)),
-			PivotPosition::CenterRight => Some(DVec2::new(1., 0.5)),
-			PivotPosition::BottomLeft => Some(DVec2::new(0., 1.)),
-			PivotPosition::BottomCenter => Some(DVec2::new(0.5, 1.)),
-			PivotPosition::BottomRight => Some(DVec2::new(1., 1.)),
-		}
-	}
-}
-
-impl From<DVec2> for PivotPosition {
-	fn from(input: DVec2) -> Self {
-		const TOLERANCE: f64 = 1e-5_f64;
-		if input.y.abs() < TOLERANCE {
-			if input.x.abs() < TOLERANCE {
-				return PivotPosition::TopLeft;
-			} else if (input.x - 0.5).abs() < TOLERANCE {
-				return PivotPosition::TopCenter;
-			} else if (input.x - 1.).abs() < TOLERANCE {
-				return PivotPosition::TopRight;
-			}
-		} else if (input.y - 0.5).abs() < TOLERANCE {
-			if input.x.abs() < TOLERANCE {
-				return PivotPosition::CenterLeft;
-			} else if (input.x - 0.5).abs() < TOLERANCE {
-				return PivotPosition::Center;
-			} else if (input.x - 1.).abs() < TOLERANCE {
-				return PivotPosition::CenterRight;
-			}
-		} else if (input.y - 1.).abs() < TOLERANCE {
-			if input.x.abs() < TOLERANCE {
-				return PivotPosition::BottomLeft;
-			} else if (input.x - 0.5).abs() < TOLERANCE {
-				return PivotPosition::BottomCenter;
-			} else if (input.x - 1.).abs() < TOLERANCE {
-				return PivotPosition::BottomRight;
-			}
-		}
-		PivotPosition::None
-	}
-}

editor/src/messages/layout/utility_types/layout_widget.rs

@@ -15,7 +15,7 @@ use graph_craft::document::value::*;
 use graph_craft::document::*;
 use graphene_core::raster::brush_cache::BrushCache;
 use graphene_core::raster::image::ImageFrameTable;
-use graphene_core::raster::{Color, RedGreenBlue, RedGreenBlueAlpha};
+use graphene_core::raster::{CellularDistanceFunction, CellularReturnType, Color, DomainWarpType, FractalType, NoiseType, RedGreenBlue, RedGreenBlueAlpha};
 use graphene_core::text::{Font, TypesettingConfig};
 use graphene_core::transform::Footprint;
 use graphene_core::vector::VectorDataTable;
@@ -128,6 +128,87 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 			description: Cow::Borrowed("Passes-through the input value without changing it. This is useful for rerouting wires for organization purposes."),
 			properties: Some("identity_properties"),
 		},
+		DocumentNodeDefinition {
+			identifier: "Cache",
+			category: "General",
+			node_template: NodeTemplate {
+				document_node: DocumentNode {
+					implementation: DocumentNodeImplementation::Network(NodeNetwork {
+						exports: vec![NodeInput::node(NodeId(2), 0)],
+						nodes: [
+							DocumentNode {
+								inputs: vec![NodeInput::network(generic!(T), 0)],
+								implementation: DocumentNodeImplementation::ProtoNode(ProtoNodeIdentifier::new("graphene_core::memo::MemoNode")),
+								manual_composition: Some(generic!(T)),
+								..Default::default()
+							},
+							DocumentNode {
+								inputs: vec![NodeInput::node(NodeId(0), 0)],
+								implementation: DocumentNodeImplementation::ProtoNode(ProtoNodeIdentifier::new("graphene_core::transform::FreezeRealTimeNode")),
+								manual_composition: Some(generic!(T)),
+								..Default::default()
+							},
+							DocumentNode {
+								inputs: vec![NodeInput::node(NodeId(1), 0)],
+								implementation: DocumentNodeImplementation::ProtoNode(ProtoNodeIdentifier::new("graphene_core::transform::BoundlessFootprintNode")),
+								manual_composition: Some(generic!(T)),
+								..Default::default()
+							},
+						]
+						.into_iter()
+						.enumerate()
+						.map(|(id, node)| (NodeId(id as u64), node))
+						.collect(),
+						..Default::default()
+					}),
+					inputs: vec![NodeInput::value(TaggedValue::None, true)],
+					..Default::default()
+				},
+				persistent_node_metadata: DocumentNodePersistentMetadata {
+					network_metadata: Some(NodeNetworkMetadata {
+						persistent_metadata: NodeNetworkPersistentMetadata {
+							node_metadata: [
+								DocumentNodeMetadata {
+									persistent_metadata: DocumentNodePersistentMetadata {
+										display_name: "Memoize".to_string(),
+										node_type_metadata: NodeTypePersistentMetadata::node(IVec2::new(0, 0)),
+										..Default::default()
+									},
+									..Default::default()
+								},
+								DocumentNodeMetadata {
+									persistent_metadata: DocumentNodePersistentMetadata {
+										display_name: "Freeze Real Time".to_string(),
+										node_type_metadata: NodeTypePersistentMetadata::node(IVec2::new(7, 0)),
+										..Default::default()
+									},
+									..Default::default()
+								},
+								DocumentNodeMetadata {
+									persistent_metadata: DocumentNodePersistentMetadata {
+										display_name: "Boundless Footprint".to_string(),
+										node_type_metadata: NodeTypePersistentMetadata::node(IVec2::new(14, 0)),
+										..Default::default()
+									},
+									..Default::default()
+								},
+							]
+							.into_iter()
+							.enumerate()
+							.map(|(id, node)| (NodeId(id as u64), node))
+							.collect(),
+							..Default::default()
+						},
+						..Default::default()
+					}),
+					input_properties: vec![("Data", "TODO").into()],
+					output_names: vec!["Data".to_string()],
+					..Default::default()
+				},
+			},
+			description: Cow::Borrowed("TODO"),
+			properties: None,
+		},
 		// TODO: Auto-generate this from its proto node macro
 		DocumentNodeDefinition {
 			identifier: "Monitor",
@@ -716,6 +797,87 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 			description: Cow::Borrowed("Rasterizes the given vector data"),
 			properties: None,
 		},
+		DocumentNodeDefinition {
+			identifier: "Noise Pattern",
+			category: "Raster",
+			node_template: NodeTemplate {
+				document_node: DocumentNode {
+					manual_composition: Some(concrete!(Context)),
+					implementation: DocumentNodeImplementation::ProtoNode(ProtoNodeIdentifier::new("graphene_std::raster::NoisePatternNode")),
+					inputs: vec![
+						NodeInput::value(TaggedValue::None, false),
+						NodeInput::value(TaggedValue::Bool(true), false),
+						NodeInput::value(TaggedValue::U32(0), false),
+						NodeInput::value(TaggedValue::F64(10.), false),
+						NodeInput::value(TaggedValue::NoiseType(NoiseType::default()), false),
+						NodeInput::value(TaggedValue::DomainWarpType(DomainWarpType::default()), false),
+						NodeInput::value(TaggedValue::F64(100.), false),
+						NodeInput::value(TaggedValue::FractalType(FractalType::default()), false),
+						NodeInput::value(TaggedValue::U32(3), false),
+						NodeInput::value(TaggedValue::F64(2.), false),
+						NodeInput::value(TaggedValue::F64(0.5), false),
+						NodeInput::value(TaggedValue::F64(0.), false), // 0-1 range
+						NodeInput::value(TaggedValue::F64(2.), false),
+						NodeInput::value(TaggedValue::CellularDistanceFunction(CellularDistanceFunction::default()), false),
+						NodeInput::value(TaggedValue::CellularReturnType(CellularReturnType::default()), false),
+						NodeInput::value(TaggedValue::F64(1.), false),
+					],
+					..Default::default()
+				},
+				persistent_node_metadata: DocumentNodePersistentMetadata {
+					input_properties: vec![
+						("Spacer", "TODO").into(),
+						("Clip", "TODO").into(),
+						("Seed", "TODO").into(),
+						PropertiesRow::with_override("Scale", "TODO", WidgetOverride::Custom("noise_properties_scale".to_string())),
+						PropertiesRow::with_override("Noise Type", "TODO", WidgetOverride::Custom("noise_properties_noise_type".to_string())),
+						PropertiesRow::with_override("Domain Warp Type", "TODO", WidgetOverride::Custom("noise_properties_domain_warp_type".to_string())),
+						PropertiesRow::with_override("Domain Warp Amplitude", "TODO", WidgetOverride::Custom("noise_properties_domain_warp_amplitude".to_string())),
+						PropertiesRow::with_override("Fractal Type", "TODO", WidgetOverride::Custom("noise_properties_fractal_type".to_string())),
+						PropertiesRow::with_override("Fractal Octaves", "TODO", WidgetOverride::Custom("noise_properties_fractal_octaves".to_string())),
+						PropertiesRow::with_override("Fractal Lacunarity", "TODO", WidgetOverride::Custom("noise_properties_fractal_lacunarity".to_string())),
+						PropertiesRow::with_override("Fractal Gain", "TODO", WidgetOverride::Custom("noise_properties_fractal_gain".to_string())),
+						PropertiesRow::with_override("Fractal Weighted Strength", "TODO", WidgetOverride::Custom("noise_properties_fractal_weighted_strength".to_string())),
+						PropertiesRow::with_override("Fractal Ping Pong Strength", "TODO", WidgetOverride::Custom("noise_properties_ping_pong_strength".to_string())),
+						PropertiesRow::with_override("Cellular Distance Function", "TODO", WidgetOverride::Custom("noise_properties_cellular_distance_function".to_string())),
+						PropertiesRow::with_override("Cellular Return Type", "TODO", WidgetOverride::Custom("noise_properties_cellular_return_type".to_string())),
+						PropertiesRow::with_override("Cellular Jitter", "TODO", WidgetOverride::Custom("noise_properties_cellular_jitter".to_string())),
+					],
+					output_names: vec!["Image".to_string()],
+					network_metadata: Some(NodeNetworkMetadata {
+						persistent_metadata: NodeNetworkPersistentMetadata {
+							node_metadata: [
+								DocumentNodeMetadata {
+									persistent_metadata: DocumentNodePersistentMetadata {
+										display_name: "Noise Pattern".to_string(),
+										node_type_metadata: NodeTypePersistentMetadata::node(IVec2::new(0, 0)),
+										..Default::default()
+									},
+									..Default::default()
+								},
+								DocumentNodeMetadata {
+									persistent_metadata: DocumentNodePersistentMetadata {
+										display_name: "Cull".to_string(),
+										node_type_metadata: NodeTypePersistentMetadata::node(IVec2::new(0, 0)),
+										..Default::default()
+									},
+									..Default::default()
+								},
+							]
+							.into_iter()
+							.enumerate()
+							.map(|(id, node)| (NodeId(id as u64), node))
+							.collect(),
+							..Default::default()
+						},
+						..Default::default()
+					}),
+					..Default::default()
+				},
+			},
+			description: Cow::Borrowed("Generates different noise patterns."),
+			properties: None,
+		},
 		// TODO: This needs to work with resolution-aware (raster with footprint, post-Cull node) data.
 		// TODO: Auto-generate this from its proto node macro
 		DocumentNodeDefinition {
@@ -3559,7 +3721,7 @@ impl DocumentNodeDefinition {
 				};
 				nested_node_metadata.persistent_metadata.input_properties.resize_with(input_length, PropertiesRow::default);
 
-				//Recurse over all sub nodes if the current node is a network implementation
+				// Recurse over all sub-nodes if the current node is a network implementation
 				let mut current_path = path.clone();
 				current_path.push(current_node);
 				let DocumentNodeImplementation::Network(template_network) = &node_template.document_node.implementation else {