merge: brush-stroke-types + master

Author: timon-schelling

Cargo.lock

@@ -80,6 +80,7 @@ no-std-types = { path = "node-graph/libraries/no-std-types" }
 raster-types = { path = "node-graph/libraries/raster-types" }
 vector-types = { path = "node-graph/libraries/vector-types" }
 graphic-types = { path = "node-graph/libraries/graphic-types" }
+brush-types = { path = "node-graph/libraries/brush-types" }
 rendering = { path = "node-graph/libraries/rendering" }
 brush-nodes = { path = "node-graph/nodes/brush" }
 blending-nodes = { path = "node-graph/nodes/blending" }

Cargo.toml

@@ -492,6 +492,15 @@ impl TableItemLayout for Artboard {
 	}
 }
 
+impl TableItemLayout for graphene_std::brush::Stroke {
+	fn type_name() -> &'static str {
+		"Stroke"
+	}
+	fn identifier(&self) -> String {
+		format!("Stroke ({} {})", self.len(), if self.len() == 1 { "sample" } else { "samples" })
+	}
+}
+
 impl TableItemLayout for DashPattern {
 	fn type_name() -> &'static str {
 		"DashPattern"
@@ -605,6 +614,7 @@ impl TableItemLayout for Graphic {
 			Self::ColorList(list) => list.identifier(),
 			Self::GradientList(list) => list.identifier(),
 			Self::TextList(list) => list.identifier(),
+			Self::StrokeList(list) => list.identifier(),
 		}
 	}
 	// Don't put a breadcrumb for Graphic
@@ -629,6 +639,7 @@ impl TableItemLayout for Graphic {
 			Self::ColorList(list) => list.layout_with_breadcrumb(data),
 			Self::GradientList(list) => list.layout_with_breadcrumb(data),
 			Self::TextList(list) => list.layout_with_breadcrumb(data),
+			Self::StrokeList(list) => list.layout_with_breadcrumb(data),
 		}
 	}
 }

editor/src/messages/portfolio/document/data_panel/data_panel_message_handler.rs

@@ -2,6 +2,7 @@ use super::DocumentNode;
 use crate::application_io::PlatformEditorApi;
 use crate::application_io::resource::Resource;
 use crate::proto::{Any as DAny, FutureAny};
+use brush_nodes::Stroke;
 use brush_nodes::brush_stroke::{BrushStroke, BrushTrace};
 use core_types::color::SRGBA8;
 use core_types::list::{Item, List, NodeIdPath};
@@ -97,6 +98,7 @@ macro_rules! tagged_value {
 			#[serde(deserialize_with = "brush_nodes::migrations::migrate_to_brush_strokes")] // TODO: Eventually remove this document upgrade code
 			#[serde(alias = "BrushStrokeTable")]
 			BrushStrokes(Vec<BrushStroke>),
+			Strokes(Vec<Stroke>),
 			// =======================
 			// AUTO-GENERATED VARIANTS
 			// =======================
@@ -140,6 +142,7 @@ macro_rules! tagged_value {
 					Self::BoxCorners(values) => values.cache_hash(state),
 					Self::GradientRamp(ramp) => ramp.cache_hash(state),
 					Self::BrushStrokes(strokes) => strokes.cache_hash(state),
+					Self::Strokes(strokes) => strokes.cache_hash(state),
 					// =======================
 					// NON-SERIALIZED VARIANTS
 					// =======================
@@ -203,6 +206,10 @@ macro_rules! tagged_value {
 					Self::BoxCorners(values) => Box::new(Item::new_from_element(BoxCorners::from(values))),
 					Self::GradientRamp(ramp) => Box::new(Item::<Gradient>::from(ramp)),
 					Self::BrushStrokes(strokes) => Box::new(core_types::list::Item::new_from_element(BrushTrace::from(strokes))),
+					Self::Strokes(strokes) => {
+						let list: List<Stroke> = strokes.into_iter().map(core_types::list::Item::new_from_element).collect();
+						Box::new(list)
+					}
 					// =======================
 					// AUTO-GENERATED VARIANTS
 					// =======================
@@ -266,6 +273,10 @@ macro_rules! tagged_value {
 					Self::BoxCorners(values) => Arc::new(Item::new_from_element(BoxCorners::from(values))),
 					Self::GradientRamp(ramp) => Arc::new(Item::<Gradient>::from(ramp)),
 					Self::BrushStrokes(strokes) => Arc::new(core_types::list::Item::new_from_element(BrushTrace::from(strokes))),
+					Self::Strokes(strokes) => {
+						let list: List<Stroke> = strokes.into_iter().map(core_types::list::Item::new_from_element).collect();
+						Arc::new(list)
+					}
 					// =======================
 					// AUTO-GENERATED VARIANTS
 					// =======================
@@ -295,6 +306,7 @@ macro_rules! tagged_value {
 					Self::BoxCorners(_) => item!(BoxCorners),
 					Self::GradientRamp(_) => item!(Gradient),
 					Self::BrushStrokes(_) => item!(BrushTrace),
+					Self::Strokes(_) => list!(Stroke),
 					// =======================
 					// AUTO-GENERATED VARIANTS
 					// =======================
@@ -335,6 +347,7 @@ macro_rules! tagged_value {
 					x if x == TypeId::of::<Item<Gradient>>() => Ok(TaggedValue::GradientRamp(GradientRamp::from(&*downcast::<Item<Gradient>>(input).unwrap()))),
 					x if x == TypeId::of::<Vec<BrushStroke>>() => Ok(TaggedValue::BrushStrokes(*downcast(input).unwrap())),
 					x if x == TypeId::of::<Item<BrushTrace>>() => Ok(TaggedValue::BrushStrokes(downcast::<Item<BrushTrace>>(input).unwrap().into_element().0.iter_element_values().cloned().collect())),
+					x if x == TypeId::of::<List<Stroke>>() => Ok(TaggedValue::Strokes(downcast::<List<Stroke>>(input).unwrap().into_iter().map(Item::into_element).collect())),
 					// =======================
 					// AUTO-GENERATED VARIANTS
 					// =======================
@@ -369,6 +382,7 @@ macro_rules! tagged_value {
 					x if x == TypeId::of::<Item<Gradient>>() => Ok(TaggedValue::GradientRamp(GradientRamp::from(input.downcast_ref::<Item<Gradient>>().unwrap()))),
 					x if x == TypeId::of::<Vec<BrushStroke>>() => Ok(TaggedValue::BrushStrokes(input.downcast_ref::<Vec<BrushStroke>>().unwrap().clone())),
 					x if x == TypeId::of::<Item<BrushTrace>>() => Ok(TaggedValue::BrushStrokes(input.downcast_ref::<Item<BrushTrace>>().unwrap().element().0.iter_element_values().cloned().collect())),
+					x if x == TypeId::of::<List<Stroke>>() => Ok(TaggedValue::Strokes(input.downcast_ref::<List<Stroke>>().unwrap().iter_element_values().cloned().collect())),
 					// =======================
 					// AUTO-GENERATED VARIANTS
 					// =======================
@@ -398,6 +412,7 @@ macro_rules! tagged_value {
 						if name == std::any::type_name::<BoxCorners>() { return Some(TaggedValue::BoxCorners(Vec::new())) }
 						$( if name == std::any::type_name::<$ty>() { return Some(TaggedValue::$identifier(Default::default())) } )*
 						if name == std::any::type_name::<BrushTrace>() { return Some(TaggedValue::BrushStrokes(Vec::new())) }
+						if name == std::any::type_name::<List<Stroke>>() { return Some(TaggedValue::Strokes(Vec::new())) }
 						// Unranked types without a variant route through `TypeDefault`, with `to_dynany`/`to_any` constructing the actual default at execution time
 						macro_rules! check_bare {
 							($type_default:ty) => {
@@ -451,6 +466,7 @@ macro_rules! tagged_value {
 					Self::BoxCorners(values) => format!("BoxCorners({values:?})"),
 					Self::GradientRamp(ramp) => format!("GradientRamp({ramp:?})"),
 					Self::BrushStrokes(strokes) => format!("BrushStrokes({strokes:?})"),
+					Self::Strokes(strokes) => format!("Strokes({strokes:?})"),
 					// =======================
 					// AUTO-GENERATED VARIANTS
 					// =======================

node-graph/graph-craft/src/document/value.rs

@@ -6,6 +6,7 @@ use graph_craft::document::value::RenderOutput;
 use graph_craft::proto::{NodeConstructor, TypeErasedBox};
 use graphene_std::animation::RealTimeMode;
 use graphene_std::any::DynAnyNode;
+use graphene_std::brush::Stroke;
 use graphene_std::brush::brush_stroke::BrushTrace;
 use graphene_std::extract_xy::XY;
 use graphene_std::gradient::Gradient;
@@ -82,6 +83,7 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => Item<AttributeValueDyn>]),
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => ListDyn]),
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => Item<BrushTrace>]),
+		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => List<graphene_std::brush::Stroke>]),
 		// Context nullification
 		#[cfg(feature = "gpu")]
 		async_node!(graphene_core::context_modification::ContextModificationNode<_, _>, input: Context, fn_params: [Context => Item<&PlatformEditorApi>, Context => Item<graphene_std::ContextFeatures>]),
@@ -145,6 +147,7 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 		#[cfg(feature = "gpu")]
 		async_node!(graphene_core::memo::MemoizeNode<_, _>, input: Context, fn_params: [Context => List<Raster<GPU>>]),
 		async_node!(graphene_core::memo::MemoizeNode<_, _>, input: Context, fn_params: [Context => Item<BrushTrace>]),
+		async_node!(graphene_core::memo::MemoizeNode<_, _>, input: Context, fn_params: [Context => List<graphene_std::brush::Stroke>]),
 		async_node!(graphene_core::memo::MemoizeNode<_, _>, input: Context, fn_params: [Context => Item<RenderIntermediate>]),
 		async_node!(graphene_core::memo::MemoizeNode<_, _>, input: Context, fn_params: [Context => Item<&wgpu_executor::WgpuExecutor>]),
 		async_node!(graphene_core::memo::MemoizeNode<_, _>, input: Context, fn_params: [Context => Item<Option<&wgpu_executor::WgpuExecutor>>]),
@@ -353,6 +356,7 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 				RelativeAbsolute,
 				SelectiveColorChoice,
 				BrushTrace,
+				Stroke,
 				XY,
 				ScaleType,
 				ReferencePoint,

node-graph/interpreted-executor/src/node_registry.rs

@@ -0,0 +1,23 @@
+[package]
+name = "brush-types"
+version = "0.1.0"
+edition = "2024"
+description = "The brush stroke data format for Graphene"
+authors = ["Graphite Authors <contact@graphite.art>"]
+license = "MIT OR Apache-2.0"
+
+[features]
+default = ["serde"]
+serde = ["dep:serde", "core-types/serde"]
+
+[dependencies]
+# Local dependencies
+core-types = { workspace = true }
+graphene-hash = { workspace = true }
+
+# Workspace dependencies
+dyn-any = { workspace = true }
+glam = { workspace = true }
+
+# Optional workspace dependencies
+serde = { workspace = true, optional = true }

node-graph/libraries/brush-types/Cargo.toml

@@ -0,0 +1,131 @@
+use core_types::CacheHash;
+use core_types::bounds::{BoundingBox, RenderBoundingBox};
+use core_types::render_complexity::RenderComplexity;
+use dyn_any::DynAny;
+use glam::{DAffine2, DVec2, Vec2};
+use std::f32::consts::{PI, TAU};
+
+#[derive(Clone, Debug, PartialEq, CacheHash)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub enum Channel<T> {
+	Uniform(T),
+	Samples(Vec<T>),
+}
+
+impl<T: Copy> Channel<T> {
+	pub fn get(&self, index: usize) -> T {
+		match self {
+			Self::Uniform(value) => *value,
+			Self::Samples(values) => values[index],
+		}
+	}
+
+	fn len(&self) -> Option<usize> {
+		match self {
+			Self::Uniform(_) => None,
+			Self::Samples(values) => Some(values.len()),
+		}
+	}
+}
+
+unsafe impl<T: dyn_any::StaticTypeSized> dyn_any::StaticType for Channel<T> {
+	type Static = Channel<T::Static>;
+}
+
+#[derive(Clone, Debug, PartialEq, CacheHash, DynAny)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct Stroke {
+	pub position: Vec<DVec2>,
+	pub pressure: Channel<f32>,
+	pub tilt: Channel<Vec2>,
+	pub twist: Channel<f32>,
+	pub time: Channel<f64>,
+	pub seed: u64,
+}
+
+impl Default for Stroke {
+	fn default() -> Self {
+		Self {
+			position: Vec::new(),
+			pressure: Channel::Uniform(1.),
+			tilt: Channel::Uniform(Vec2::ZERO),
+			twist: Channel::Uniform(0.),
+			time: Channel::Uniform(0.),
+			seed: 0,
+		}
+	}
+}
+
+impl Stroke {
+	pub fn len(&self) -> usize {
+		self.position.len()
+	}
+
+	pub fn is_empty(&self) -> bool {
+		self.position.is_empty()
+	}
+
+	pub fn is_valid(&self) -> bool {
+		let n = self.len();
+		[self.pressure.len(), self.tilt.len(), self.twist.len(), self.time.len()].into_iter().flatten().all(|len| len == n)
+	}
+
+	pub fn sample(&self, index: usize) -> Sample {
+		Sample {
+			position: self.position[index],
+			pressure: self.pressure.get(index),
+			tilt: self.tilt.get(index),
+			twist: self.twist.get(index),
+			time: self.time.get(index),
+		}
+	}
+
+	pub fn sample_lerp(&self, index: usize, t: f32) -> Sample {
+		let a = self.sample(index);
+		let b = self.sample(index + 1);
+		Sample {
+			position: a.position.lerp(b.position, t as f64),
+			pressure: a.pressure + (b.pressure - a.pressure) * t,
+			tilt: a.tilt.lerp(b.tilt, t),
+			twist: {
+				let delta = (b.twist - a.twist).rem_euclid(TAU);
+				let delta = if delta > PI { delta - TAU } else { delta };
+				a.twist + delta * t
+			},
+			time: a.time + (b.time - a.time) * t as f64,
+		}
+	}
+
+	pub fn samples(&self) -> impl Iterator<Item = Sample> + '_ {
+		(0..self.len()).map(|index| self.sample(index))
+	}
+}
+
+impl BoundingBox for Stroke {
+	fn bounding_box(&self, transform: DAffine2, _include_stroke: bool) -> RenderBoundingBox {
+		let Some(first) = self.position.first() else { return RenderBoundingBox::None };
+		let (min, max) = self.position.iter().fold((*first, *first), |(min, max), &point| (min.min(point), max.max(point)));
+		let corners = [min, DVec2::new(max.x, min.y), max, DVec2::new(min.x, max.y)].map(|corner| transform.transform_point2(corner));
+		let (min, max) = corners.iter().fold((corners[0], corners[0]), |(min, max), &point| (min.min(point), max.max(point)));
+		RenderBoundingBox::Rectangle([min, max])
+	}
+
+	fn thumbnail_bounding_box(&self, transform: DAffine2, include_stroke: bool) -> RenderBoundingBox {
+		self.bounding_box(transform, include_stroke)
+	}
+}
+
+impl RenderComplexity for Stroke {
+	fn render_complexity(&self) -> usize {
+		self.len()
+	}
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Sample {
+	pub position: DVec2,
+	pub pressure: f32,
+	pub tilt: Vec2,
+	pub twist: f32,
+	pub time: f64,
+}

node-graph/libraries/brush-types/src/lib.rs

@@ -97,6 +97,14 @@ pub const ATTR_JOIN: &str = "join";
 pub const ATTR_JOIN_MITER_LIMIT: &str = "join_miter_limit";
 /// Stroke coverage's `StrokeAlign` (implicit default `Center`), on the `Item<Cover>` inside a `Coverage`.
 pub const ATTR_ALIGN: &str = "align";
+/// Brush stroke item's `Color` its strokes are painted with.
+pub const ATTR_COLOR: &str = "color";
+/// Brush stroke item's tip diameter in document-space units (`f64`).
+pub const ATTR_DIAMETER: &str = "diameter";
+/// Brush stroke item's edge hardness from `0.` (softest) to `1.` (hardest) (`f64`).
+pub const ATTR_HARDNESS: &str = "hardness";
+/// Brush stroke item's per-pass paint coverage from `0.` to `1.` (`f64`).
+pub const ATTR_FLOW: &str = "flow";
 /// Text item's font size in document-space units (`f64`, implicit default `24.`).
 pub const ATTR_FONT_SIZE: &str = "font_size";
 /// Text item's font, as a `Resource` of the loaded font file.

node-graph/libraries/core-types/src/list.rs

@@ -20,6 +20,7 @@ wasm = [
 # Local dependencies
 core-types = { workspace = true }
 graphene-hash = { workspace = true }
+brush-types = { workspace = true }
 raster-types = { workspace = true, features = ["wgpu"] }
 vector-types = { workspace = true }
 node-macro = { workspace = true }