From fd640459a2f065e02c0e891e53a386c92a5c0407 Mon Sep 17 00:00:00 2001 From: Dennis Kobert Date: Mon, 14 Sep 2026 01:25:04 +0200 Subject: [PATCH] Add a generic map over a graphic's leaves, reaching every depth --- .../libraries/core-types/src/record/run.rs | 21 ++ .../graphic-types/src/graphic/map.rs | 236 ++++++++++++++++++ .../graphic-types/src/graphic/mod.rs | 10 + node-graph/node-macro/src/codegen/ir.rs | 18 +- 4 files changed, 284 insertions(+), 1 deletion(-) create mode 100644 node-graph/libraries/graphic-types/src/graphic/map.rs diff --git a/node-graph/libraries/core-types/src/record/run.rs b/node-graph/libraries/core-types/src/record/run.rs index 0d04ecf0fe..1d509a10ca 100644 --- a/node-graph/libraries/core-types/src/record/run.rs +++ b/node-graph/libraries/core-types/src/record/run.rs @@ -155,6 +155,27 @@ impl<'e> RunBuilder<'e> { unsafe { (info.write_stored)(value, self.frames.add(lane * self.layout.lane_stride() + offset), self.arena) } } + /// Copies a source lane's fields onto an already pushed lane through `plan`. + /// The columns move as bytes rather than through a read-write round trip, so a + /// parked payload carries as its arena reference and stays valid for the + /// evaluation, exactly as a lane's own carry does. + /// + /// # Safety + /// `src` must be a live record of `plan`'s source layout, `plan` must target + /// this builder's layout, and `src` must not overlap the frames. + pub unsafe fn carry(&mut self, lane: usize, src: crate::record::Rec<'_>, plan: &[(usize, usize, usize)]) { + assert!(lane < self.pushed, "a carry lands on a pushed lane"); + // SAFETY: the lane is below `pushed`, so its frame is within the allocation. + let dst = unsafe { self.frames.add(lane * self.layout.lane_stride()) }; + // SAFETY: the caller's contract. + unsafe { crate::record::apply_plan(src, dst, plan) }; + } + + /// The layout the finished run carries, for computing a carry plan into it. + pub fn layout(&self) -> &Layout { + &self.layout + } + /// The finished run. Panics unless every lane was pushed, since an /// unwritten parked element slot must never become readable. pub fn finish(self) -> GroupItem<'e> { diff --git a/node-graph/libraries/graphic-types/src/graphic/map.rs b/node-graph/libraries/graphic-types/src/graphic/map.rs new file mode 100644 index 0000000000..ca062428f5 --- /dev/null +++ b/node-graph/libraries/graphic-types/src/graphic/map.rs @@ -0,0 +1,236 @@ +//! The element-wise map over a graphic's leaves: a modifier defined on one leaf +//! type reaches every leaf of that type in the tree, whatever its depth. + +use super::{Graphic, TryFromGraphic}; +use core_types::ATTR_TRANSFORM; +use core_types::arena::Arena; +use core_types::attribute::{Attribute, Transform as TransformAttr}; +use core_types::graphene_hash::CacheHash; + +use core_types::lane::LaneColumn; +use core_types::record::{FieldDesc, FieldWrite, Group, GroupItem, RunBuilder, copy_plan, element_write_hashed}; +use glam::DAffine2; +use vector_types::Vector; + +/// A leaf a graphic can be mapped over: its `Graphic` variant, plus the record +/// glue a rebuilt run needs to store it. +pub trait MappableLeaf: TryFromGraphic + Clone + Send + Sync + CacheHash + PartialEq + dyn_any::StaticTypeSized + 'static +where + Self::Static: Clone + Send + Sync, +{ +} + +impl MappableLeaf for T +where + T: TryFromGraphic + Clone + Send + Sync + CacheHash + PartialEq + dyn_any::StaticTypeSized + 'static, + T::Static: Clone + Send + Sync, +{ +} + +impl<'e> Graphic<'e> { + /// Applies `map` to every `T` leaf reachable from the graphic, handing each leaf + /// the transform of the lane holding it and taking back the one it returns. + /// Groups recurse, since geometry is never inherited, and leaves of other types + /// pass through untouched. Returns this graphic's own transform, which only a + /// mapped leaf changes. `None` reports arena exhaustion while rebuilding a group. + /// + /// A rebuilt group stays resident in `arena`, the form a consumer can read: the + /// owned form refuses lane reads until something replays it, and an ordinary + /// element write parks a value rather than running the re-park glue. + pub fn map(&mut self, arena: &'e Arena, transform: DAffine2, map: &mut impl FnMut(T, DAffine2) -> (T, DAffine2)) -> Option + where + T::Static: Clone + Send + Sync, + { + if let Some(leaf) = T::leaf_mut(self) { + let (mapped, transform) = map(leaf.clone(), transform); + *leaf = mapped; + return Some(transform); + } + + match self { + // The legacy interior is owned outright, so its lanes map in place. + Graphic::Graphic(children) => { + for row in 0..children.len() { + let lane_transform: DAffine2 = children.attribute_cloned_or_default(ATTR_TRANSFORM, row); + let Some(child) = children.element_mut(row) else { continue }; + let mapped = child.map::(arena, lane_transform, map)?; + if mapped != lane_transform { + children.set_attribute(ATTR_TRANSFORM, row, mapped); + } + } + } + // A run is shared and cannot be written through, so a mapped lane rebuilds it. + Graphic::Group(group) => { + let content = map_run::(&group.content, arena, map)?; + *self = Graphic::Group(Group { row: group.row.clone(), content }); + } + _ => {} + } + + Some(transform) + } + + /// [`Graphic::map`] over the vector leaves, the shape the vector modifier nodes use. + pub fn map_vectors(&mut self, arena: &'e Arena, transform: DAffine2, map: &mut impl FnMut(Vector, DAffine2) -> (Vector, DAffine2)) -> Option { + self.map::(arena, transform, map) + } +} + +/// Content a vector modifier runs over: a bare vector maps directly, a graphic maps +/// every vector leaf it reaches. One kernel then serves both of a modifier's rows. +pub trait MapVectorContent: Sized { + /// The mapped content at the arena's lifetime, since a rebuilt group is resident + /// there. Tying the result to the arena is what keeps the mapping safe: the content + /// cannot outlive the frames it now points into. + type Mapped<'a>; + + /// `None` reports arena exhaustion while rebuilding a group. + fn map_vector_content<'a>(self, arena: &'a Arena, transform: DAffine2, map: &mut impl FnMut(Vector, DAffine2) -> (Vector, DAffine2)) -> Option<(Self::Mapped<'a>, DAffine2)>; +} + +impl MapVectorContent for Vector { + type Mapped<'a> = Vector; + + fn map_vector_content(self, _arena: &Arena, transform: DAffine2, map: &mut impl FnMut(Vector, DAffine2) -> (Vector, DAffine2)) -> Option<(Vector, DAffine2)> { + Some(map(self, transform)) + } +} + +impl MapVectorContent for Graphic<'static> { + type Mapped<'a> = Graphic<'a>; + + fn map_vector_content<'a>(self, arena: &'a Arena, transform: DAffine2, map: &mut impl FnMut(Vector, DAffine2) -> (Vector, DAffine2)) -> Option<(Graphic<'a>, DAffine2)> { + // `Graphic` is covariant in its lifetime, so the node's `'static` spelling narrows + // to the arena's without a cast; the rebuilt run then lands at that same lifetime. + let mut content: Graphic<'a> = self; + let transform = content.map_vectors(arena, transform, map)?; + + Some((content, transform)) + } +} + +/// The run with every reachable `T` leaf mapped: a run of `T` maps its own lanes, +/// a run of graphics recurses, and any other element type is left alone. +fn map_run<'e, T: MappableLeaf>(item: &GroupItem<'e>, arena: &'e Arena, map: &mut impl FnMut(T, DAffine2) -> (T, DAffine2)) -> Option> +where + T::Static: Clone + Send + Sync, +{ + let transforms = core_types::record::RunColumn::::of(item); + let lane_transform = |lane: usize| transforms.try_get(lane).unwrap_or(DAffine2::IDENTITY); + + if let Some(lanes) = item.typed_lanes::() { + let mapped: Vec<(T, DAffine2)> = (0..lanes.len()).map(|lane| map(lanes.element_ref(lane).clone(), lane_transform(lane))).collect(); + return rebuild_run(item, arena, mapped); + } + + if let Some(lanes) = item.typed_lanes::>() { + let mut mapped = Vec::with_capacity(lanes.len()); + for lane in 0..lanes.len() { + let mut child = lanes.element_ref(lane).clone(); + let transform = child.map::(arena, lane_transform(lane), map)?; + mapped.push((child, transform)); + } + return rebuild_run(item, arena, mapped); + } + + Some(item.clone()) +} + +/// A fresh run over `mapped`, carrying the source's columns across and writing each +/// lane's returned transform. Only the elements change, so the columns move as bytes +/// rather than through the census: a parked payload carries as its arena reference +/// and stays valid. `None` reports arena exhaustion. +fn rebuild_run<'e, E>(item: &GroupItem<'e>, arena: &'e Arena, mapped: Vec<(E, DAffine2)>) -> Option> +where + E: Clone + Send + Sync + CacheHash + PartialEq + dyn_any::StaticTypeSized, + E::Static: Clone + Send + Sync, +{ + // A lane whose transform the map changed needs the column even where the source run carried none. + let mut writes: Vec = item.layout().fields.iter().map(FieldDesc::as_write).collect(); + if !writes.iter().any(|write| write.name == TransformAttr::NAME && write.level == 0) { + writes.push(FieldWrite::of::(0)); + } + + let mut builder = RunBuilder::new(arena, element_write_hashed::(), &writes, mapped.len())?; + // The element is written by the push, so the plan carries the columns alone. + let plan = copy_plan(item.layout(), builder.layout(), false, &[]); + + for (lane, (element, transform)) in mapped.into_iter().enumerate() { + builder.push(element)?; + // SAFETY: the plan runs from the source run's own layout into the builder's, and + // the fresh frames cannot overlap the source. + unsafe { builder.carry(lane, item.lanes().get(lane).rec(), &plan) }; + builder.attr::(lane, transform); + } + + Some(builder.finish()) +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::graphic::test_support::unit_square_at; + use core_types::attribute::Opacity; + use core_types::lane::LaneSource; + use core_types::list::{Item, List}; + use core_types::record::{FieldWrite, RunView}; + use glam::DVec2; + + /// A rebuilt run keeps the columns the map never touched, so a modifier + /// cannot silently drop a lane's blending or layer routing. + #[test] + fn a_mapped_run_keeps_its_untouched_columns() { + let arena = Arena::new(1 << 16).unwrap(); + let mut builder = RunBuilder::new(&arena, element_write_hashed::(), &[FieldWrite::of::(0), FieldWrite::of::(0)], 2).unwrap(); + for lane in 0..2 { + builder.push(unit_square_at(DVec2::ZERO)).unwrap(); + builder.attr::(lane, DAffine2::from_translation(DVec2::new(lane as f64, 0.))); + } + builder.attr::(1, 0.25); + let content = builder.finish(); + + let mut graphic = Graphic::Group(Group { row: None, content }); + let mut seen = Vec::new(); + graphic + .map_vectors(&arena, DAffine2::IDENTITY, &mut |vector, transform| { + seen.push(transform); + (vector, transform * DAffine2::from_scale(DVec2::splat(2.))) + }) + .expect("the rebuild fits the arena"); + + assert_eq!(seen.len(), 2, "every lane of the run is mapped"); + assert_eq!(seen[1], DAffine2::from_translation(DVec2::new(1., 0.)), "each lane is handed its own transform"); + + let Graphic::Group(group) = &graphic else { panic!("the group form survives the map") }; + let view = RunView::::new(&group.content).expect("the run still holds vectors"); + assert_eq!( + view.attr::(1), + DAffine2::from_translation(DVec2::new(1., 0.)) * DAffine2::from_scale(DVec2::splat(2.)), + "the returned transform is written back" + ); + assert_eq!(view.attr::(1), 0.25, "a column the map never touched survives the rebuild"); + } + + /// A leaf type the map does not target is left alone, so a vector modifier + /// cannot disturb raster or color content sharing the tree. + #[test] + fn a_map_skips_the_leaves_of_other_types() { + let arena = Arena::new(1 << 16).unwrap(); + let mut children = List::new(); + children.push(Item::new_from_element(Graphic::Color(core_types::Color::WHITE))); + children.push(Item::new_from_element(Graphic::Vector(unit_square_at(DVec2::ZERO)))); + let mut graphic = Graphic::Graphic(children); + + let mut mapped = 0; + graphic + .map_vectors(&arena, DAffine2::IDENTITY, &mut |vector, transform| { + mapped += 1; + (vector, transform) + }) + .expect("no rebuild is needed"); + + assert_eq!(mapped, 1, "only the vector leaf is mapped"); + let Graphic::Graphic(children) = &graphic else { panic!("the list form survives") }; + assert!(matches!(children.element(0), Some(Graphic::Color(_))), "the color leaf passes through untouched"); + } +} diff --git a/node-graph/libraries/graphic-types/src/graphic/mod.rs b/node-graph/libraries/graphic-types/src/graphic/mod.rs index ffe32b010d..2285191b86 100644 --- a/node-graph/libraries/graphic-types/src/graphic/mod.rs +++ b/node-graph/libraries/graphic-types/src/graphic/mod.rs @@ -1,8 +1,11 @@ mod glue; mod legacy; +mod map; mod paint; mod walk; +pub use map::{MapVectorContent, MappableLeaf}; + pub(crate) use glue::{list_contains_groups, map_attribute_groups_to_owned, map_attribute_groups_to_persistent, map_attribute_groups_to_resident}; pub use glue::{map_groups_to_owned, map_groups_to_persistent, map_groups_to_resident}; pub(crate) use legacy::run_to_legacy_list; @@ -256,6 +259,9 @@ pub trait TryFromGraphic: Clone + Sized { /// The leaf's element, borrowed, where `graphic` is this type's variant. fn leaf_of<'a>(graphic: &'a Graphic<'_>) -> Option<&'a Self>; + + /// The leaf's element, mutably, where `graphic` is this type's variant. + fn leaf_mut<'a>(graphic: &'a mut Graphic<'_>) -> Option<&'a mut Self>; } macro_rules! try_from_graphic { @@ -269,6 +275,10 @@ macro_rules! try_from_graphic { fn leaf_of<'a>(graphic: &'a Graphic<'_>) -> Option<&'a Self> { if let Graphic::$variant(t) = graphic { Some(t) } else { None } } + + fn leaf_mut<'a>(graphic: &'a mut Graphic<'_>) -> Option<&'a mut Self> { + if let Graphic::$variant(t) = graphic { Some(t) } else { None } + } } )* }; diff --git a/node-graph/node-macro/src/codegen/ir.rs b/node-graph/node-macro/src/codegen/ir.rs index 5be38c8242..4c097d1927 100644 --- a/node-graph/node-macro/src/codegen/ir.rs +++ b/node-graph/node-macro/src/codegen/ir.rs @@ -181,10 +181,26 @@ fn element_of(ty: &Type, generics: &[Ident]) -> Element { } match bare_ident(ty) { Some(ident) if generics.contains(ident) => Element::Generic(ident.clone()), - _ => Element::Concrete(ty.clone()), + _ => match projected_generic(ty, generics) { + Some(ident) => Element::Generic(ident), + None => Element::Concrete(ty.clone()), + }, } } +/// The carried generic an associated type is projected off, as in `V::Mapped<'a>`. +/// Such an output is that generic's element re-stated at another lifetime, so it +/// rides as the carried element rather than as a freshly written one. +fn projected_generic(ty: &Type, generics: &[Ident]) -> Option { + let Type::Path(path) = ty else { return None }; + if path.qself.is_some() || path.path.segments.len() < 2 { + return None; + } + let head = &path.path.segments.first()?.ident; + + generics.contains(head).then(|| head.clone()) +} + pub(crate) fn strip_ilist(ty: &Type) -> (Type, u8) { let mut element = ty.clone(); let mut depth = 0;