Rename Instances<T> to Table<T> and the "instance" terminology to "TableRow" and "element" (#2981)

* Instances -> Table

* instances.rs -> table.rs

* Rename occurrances of the word "instances"

* .instance -> .element

* Instance* -> TableRow*

* Rename Table and TableRow methods to not say "instance"

* Remove presumed unused serde defaults now that tables default to length 0 not 1

* Rename occurences of the word "instance"

* Un-alias the RasterDataTable<Storage>, VectorDataTable, GraphicGroupTable, ArtboardGroupTable typedefs

* Move artboard type and node code out of graphic_element.rs to a new artboard.rs

* Organize the TaggedValues

* Fix tests

* Fix prior regression with Image Value node not upgrading

node-graph/gcore/src/vector/algorithms/instance.rs

@@ -1,33 +1,33 @@
-use crate::instances::{InstanceRef, Instances};
-use crate::raster_types::{CPU, RasterDataTable};
-use crate::vector::VectorDataTable;
-use crate::{CloneVarArgs, Context, Ctx, ExtractAll, ExtractIndex, ExtractVarArgs, GraphicElement, GraphicGroupTable, OwnedContextImpl};
+use crate::raster_types::{CPU, Raster};
+use crate::table::{Table, TableRowRef};
+use crate::vector::VectorData;
+use crate::{CloneVarArgs, Context, Ctx, ExtractAll, ExtractIndex, ExtractVarArgs, GraphicElement, OwnedContextImpl};
 use glam::DVec2;
 
 #[node_macro::node(name("Instance on Points"), category("Instancing"), path(graphene_core::vector))]
 async fn instance_on_points<T: Into<GraphicElement> + Default + Send + Clone + 'static>(
 	ctx: impl ExtractAll + CloneVarArgs + Sync + Ctx,
-	points: VectorDataTable,
+	points: Table<VectorData>,
 	#[implementations(
-		Context -> GraphicGroupTable,
-		Context -> VectorDataTable,
-		Context -> RasterDataTable<CPU>
+		Context -> Table<GraphicElement>,
+		Context -> Table<VectorData>,
+		Context -> Table<Raster<CPU>>
 	)]
-	instance: impl Node<'n, Context<'static>, Output = Instances<T>>,
+	instance: impl Node<'n, Context<'static>, Output = Table<T>>,
 	reverse: bool,
-) -> Instances<T> {
-	let mut result_table = Instances::<T>::default();
+) -> Table<T> {
+	let mut result_table = Table::new();
 
-	for InstanceRef { instance: points, transform, .. } in points.instance_ref_iter() {
+	for TableRowRef { element: points, transform, .. } in points.iter_ref() {
 		let mut iteration = async |index, point| {
 			let transformed_point = transform.transform_point2(point);
 
 			let new_ctx = OwnedContextImpl::from(ctx.clone()).with_index(index).with_vararg(Box::new(transformed_point));
 			let generated_instance = instance.eval(new_ctx.into_context()).await;
 
-			for mut instanced in generated_instance.instance_iter() {
-				instanced.transform.translation = transformed_point;
-				result_table.push(instanced);
+			for mut generated_row in generated_instance.iter() {
+				generated_row.transform.translation = transformed_point;
+				result_table.push(generated_row);
 			}
 		};
 
@@ -50,17 +50,17 @@ async fn instance_on_points<T: Into<GraphicElement> + Default + Send + Clone + '
 async fn instance_repeat<T: Into<GraphicElement> + Default + Send + Clone + 'static>(
 	ctx: impl ExtractAll + CloneVarArgs + Ctx,
 	#[implementations(
-		Context -> GraphicGroupTable,
-		Context -> VectorDataTable,
-		Context -> RasterDataTable<CPU>
+		Context -> Table<GraphicElement>,
+		Context -> Table<VectorData>,
+		Context -> Table<Raster<CPU>>
 	)]
-	instance: impl Node<'n, Context<'static>, Output = Instances<T>>,
+	instance: impl Node<'n, Context<'static>, Output = Table<T>>,
 	#[default(1)] count: u64,
 	reverse: bool,
-) -> Instances<T> {
+) -> Table<T> {
 	let count = count.max(1) as usize;
 
-	let mut result_table = Instances::<T>::default();
+	let mut result_table = Table::new();
 
 	for index in 0..count {
 		let index = if reverse { count - index - 1 } else { index };
@@ -68,8 +68,8 @@ async fn instance_repeat<T: Into<GraphicElement> + Default + Send + Clone + 'sta
 		let new_ctx = OwnedContextImpl::from(ctx.clone()).with_index(index);
 		let generated_instance = instance.eval(new_ctx.into_context()).await;
 
-		for instanced in generated_instance.instance_iter() {
-			result_table.push(instanced);
+		for generated_row in generated_instance.iter() {
+			result_table.push(generated_row);
 		}
 	}
 
@@ -128,11 +128,11 @@ mod test {
 		);
 
 		let positions = [DVec2::new(40., 20.), DVec2::ONE, DVec2::new(-42., 9.), DVec2::new(10., 345.)];
-		let points = VectorDataTable::new(VectorData::from_subpath(Subpath::from_anchors_linear(positions, false)));
-		let repeated = super::instance_on_points(owned, points, &rect, false).await;
-		assert_eq!(repeated.len(), positions.len());
-		for (position, instanced) in positions.into_iter().zip(repeated.instance_ref_iter()) {
-			let bounds = instanced.instance.bounding_box_with_transform(*instanced.transform).unwrap();
+		let points = Table::new_from_element(VectorData::from_subpath(Subpath::from_anchors_linear(positions, false)));
+		let generated = super::instance_on_points(owned, points, &rect, false).await;
+		assert_eq!(generated.len(), positions.len());
+		for (position, generated_row) in positions.into_iter().zip(generated.iter_ref()) {
+			let bounds = generated_row.element.bounding_box_with_transform(*generated_row.transform).unwrap();
 			assert!(position.abs_diff_eq((bounds[0] + bounds[1]) / 2., 1e-10));
 			assert_eq!((bounds[1] - bounds[0]).x, position.y);
 		}

node-graph/gcore/src/vector/generator_nodes.rs

@@ -2,21 +2,22 @@ use super::misc::{ArcType, AsU64, GridType};
 use super::{PointId, SegmentId, StrokeId};
 use crate::Ctx;
 use crate::registry::types::{Angle, PixelSize};
-use crate::vector::{HandleId, VectorData, VectorDataTable};
+use crate::table::Table;
+use crate::vector::{HandleId, VectorData};
 use bezier_rs::Subpath;
 use glam::DVec2;
 
 trait CornerRadius {
-	fn generate(self, size: DVec2, clamped: bool) -> VectorDataTable;
+	fn generate(self, size: DVec2, clamped: bool) -> Table<VectorData>;
 }
 impl CornerRadius for f64 {
-	fn generate(self, size: DVec2, clamped: bool) -> VectorDataTable {
+	fn generate(self, size: DVec2, clamped: bool) -> Table<VectorData> {
 		let clamped_radius = if clamped { self.clamp(0., size.x.min(size.y).max(0.) / 2.) } else { self };
-		VectorDataTable::new(VectorData::from_subpath(Subpath::new_rounded_rect(size / -2., size / 2., [clamped_radius; 4])))
+		Table::new_from_element(VectorData::from_subpath(Subpath::new_rounded_rect(size / -2., size / 2., [clamped_radius; 4])))
 	}
 }
 impl CornerRadius for [f64; 4] {
-	fn generate(self, size: DVec2, clamped: bool) -> VectorDataTable {
+	fn generate(self, size: DVec2, clamped: bool) -> Table<VectorData> {
 		let clamped_radius = if clamped {
 			// Algorithm follows the CSS spec: <https://drafts.csswg.org/css-backgrounds/#corner-overlap>
 
@@ -32,7 +33,7 @@ impl CornerRadius for [f64; 4] {
 		} else {
 			self
 		};
-		VectorDataTable::new(VectorData::from_subpath(Subpath::new_rounded_rect(size / -2., size / 2., clamped_radius)))
+		Table::new_from_element(VectorData::from_subpath(Subpath::new_rounded_rect(size / -2., size / 2., clamped_radius)))
 	}
 }
 
@@ -43,9 +44,9 @@ fn circle(
 	#[unit(" px")]
 	#[default(50.)]
 	radius: f64,
-) -> VectorDataTable {
+) -> Table<VectorData> {
 	let radius = radius.abs();
-	VectorDataTable::new(VectorData::from_subpath(Subpath::new_ellipse(DVec2::splat(-radius), DVec2::splat(radius))))
+	Table::new_from_element(VectorData::from_subpath(Subpath::new_ellipse(DVec2::splat(-radius), DVec2::splat(radius))))
 }
 
 #[node_macro::node(category("Vector: Shape"))]
@@ -60,8 +61,8 @@ fn arc(
 	#[range((0., 360.))]
 	sweep_angle: Angle,
 	arc_type: ArcType,
-) -> VectorDataTable {
-	VectorDataTable::new(VectorData::from_subpath(Subpath::new_arc(
+) -> Table<VectorData> {
+	Table::new_from_element(VectorData::from_subpath(Subpath::new_arc(
 		radius,
 		start_angle / 360. * std::f64::consts::TAU,
 		sweep_angle / 360. * std::f64::consts::TAU,
@@ -83,7 +84,7 @@ fn ellipse(
 	#[unit(" px")]
 	#[default(25)]
 	radius_y: f64,
-) -> VectorDataTable {
+) -> Table<VectorData> {
 	let radius = DVec2::new(radius_x, radius_y);
 	let corner1 = -radius;
 	let corner2 = radius;
@@ -97,7 +98,7 @@ fn ellipse(
 			.push([HandleId::end(ellipse.segment_domain.ids()[i]), HandleId::primary(ellipse.segment_domain.ids()[(i + 1) % len])]);
 	}
 
-	VectorDataTable::new(ellipse)
+	Table::new_from_element(ellipse)
 }
 
 #[node_macro::node(category("Vector: Shape"), properties("rectangle_properties"))]
@@ -113,7 +114,7 @@ fn rectangle<T: CornerRadius>(
 	_individual_corner_radii: bool, // TODO: Move this to the bottom once we have a migration capability
 	#[implementations(f64, [f64; 4])] corner_radius: T,
 	#[default(true)] clamped: bool,
-) -> VectorDataTable {
+) -> Table<VectorData> {
 	corner_radius.generate(DVec2::new(width, height), clamped)
 }
 
@@ -128,10 +129,10 @@ fn regular_polygon<T: AsU64>(
 	#[unit(" px")]
 	#[default(50)]
 	radius: f64,
-) -> VectorDataTable {
+) -> Table<VectorData> {
 	let points = sides.as_u64();
 	let radius: f64 = radius * 2.;
-	VectorDataTable::new(VectorData::from_subpath(Subpath::new_regular_polygon(DVec2::splat(-radius), points, radius)))
+	Table::new_from_element(VectorData::from_subpath(Subpath::new_regular_polygon(DVec2::splat(-radius), points, radius)))
 }
 
 #[node_macro::node(category("Vector: Shape"))]
@@ -148,17 +149,17 @@ fn star<T: AsU64>(
 	#[unit(" px")]
 	#[default(25)]
 	radius_2: f64,
-) -> VectorDataTable {
+) -> Table<VectorData> {
 	let points = sides.as_u64();
 	let diameter: f64 = radius_1 * 2.;
 	let inner_diameter = radius_2 * 2.;
 
-	VectorDataTable::new(VectorData::from_subpath(Subpath::new_star_polygon(DVec2::splat(-diameter), points, diameter, inner_diameter)))
+	Table::new_from_element(VectorData::from_subpath(Subpath::new_star_polygon(DVec2::splat(-diameter), points, diameter, inner_diameter)))
 }
 
 #[node_macro::node(category("Vector: Shape"))]
-fn line(_: impl Ctx, _primary: (), #[default(0., 0.)] start: PixelSize, #[default(100., 100.)] end: PixelSize) -> VectorDataTable {
-	VectorDataTable::new(VectorData::from_subpath(Subpath::new_line(start, end)))
+fn line(_: impl Ctx, _primary: (), #[default(0., 0.)] start: PixelSize, #[default(100., 100.)] end: PixelSize) -> Table<VectorData> {
+	Table::new_from_element(VectorData::from_subpath(Subpath::new_line(start, end)))
 }
 
 trait GridSpacing {
@@ -188,7 +189,7 @@ fn grid<T: GridSpacing>(
 	#[default(10)] columns: u32,
 	#[default(10)] rows: u32,
 	#[default(30., 30.)] angles: DVec2,
-) -> VectorDataTable {
+) -> Table<VectorData> {
 	let (x_spacing, y_spacing) = spacing.as_dvec2().into();
 	let (angle_a, angle_b) = angles.into();
 
@@ -270,7 +271,7 @@ fn grid<T: GridSpacing>(
 		}
 	}
 
-	VectorDataTable::new(vector_data)
+	Table::new_from_element(vector_data)
 }
 
 #[cfg(test)]
@@ -284,9 +285,9 @@ mod tests {
 
 		// Works properly
 		let grid = grid((), (), GridType::Isometric, 10., 5, 5, (30., 30.).into());
-		assert_eq!(grid.instance_ref_iter().next().unwrap().instance.point_domain.ids().len(), 5 * 5);
-		assert_eq!(grid.instance_ref_iter().next().unwrap().instance.segment_bezier_iter().count(), 4 * 5 + 4 * 9);
-		for (_, bezier, _, _) in grid.instance_ref_iter().next().unwrap().instance.segment_bezier_iter() {
+		assert_eq!(grid.iter_ref().next().unwrap().element.point_domain.ids().len(), 5 * 5);
+		assert_eq!(grid.iter_ref().next().unwrap().element.segment_bezier_iter().count(), 4 * 5 + 4 * 9);
+		for (_, bezier, _, _) in grid.iter_ref().next().unwrap().element.segment_bezier_iter() {
 			assert_eq!(bezier.handles, bezier_rs::BezierHandles::Linear);
 			assert!(
 				((bezier.start - bezier.end).length() - 10.).abs() < 1e-5,
@@ -299,9 +300,9 @@ mod tests {
 	#[test]
 	fn skew_isometric_grid_test() {
 		let grid = grid((), (), GridType::Isometric, 10., 5, 5, (40., 30.).into());
-		assert_eq!(grid.instance_ref_iter().next().unwrap().instance.point_domain.ids().len(), 5 * 5);
-		assert_eq!(grid.instance_ref_iter().next().unwrap().instance.segment_bezier_iter().count(), 4 * 5 + 4 * 9);
-		for (_, bezier, _, _) in grid.instance_ref_iter().next().unwrap().instance.segment_bezier_iter() {
+		assert_eq!(grid.iter_ref().next().unwrap().element.point_domain.ids().len(), 5 * 5);
+		assert_eq!(grid.iter_ref().next().unwrap().element.segment_bezier_iter().count(), 4 * 5 + 4 * 9);
+		for (_, bezier, _, _) in grid.iter_ref().next().unwrap().element.segment_bezier_iter() {
 			assert_eq!(bezier.handles, bezier_rs::BezierHandles::Linear);
 			let vector = bezier.start - bezier.end;
 			let angle = (vector.angle_to(DVec2::X).to_degrees() + 180.) % 180.;

node-graph/gcore/src/vector/vector_data.rs

@@ -5,11 +5,11 @@ mod modification;
 use super::misc::{dvec2_to_point, point_to_dvec2};
 use super::style::{PathStyle, Stroke};
 use crate::bounds::BoundingBox;
-use crate::instances::Instances;
 use crate::math::quad::Quad;
+use crate::table::Table;
 use crate::transform::Transform;
 use crate::vector::click_target::{ClickTargetType, FreePoint};
-use crate::{AlphaBlending, Color, GraphicGroupTable};
+use crate::{AlphaBlending, Color, GraphicElement};
 pub use attributes::*;
 use bezier_rs::{BezierHandles, ManipulatorGroup};
 use core::borrow::Borrow;
@@ -22,7 +22,7 @@ pub use modification::*;
 use std::collections::HashMap;
 
 // TODO: Eventually remove this migration document upgrade code
-pub fn migrate_vector_data<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<VectorDataTable, D::Error> {
+pub fn migrate_vector_data<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<Table<VectorData>, D::Error> {
 	use serde::Deserialize;
 
 	#[derive(Clone, Debug, PartialEq, DynAny, serde::Serialize, serde::Deserialize)]
@@ -41,7 +41,7 @@ pub fn migrate_vector_data<'de, D: serde::Deserializer<'de>>(deserializer: D) ->
 		pub region_domain: RegionDomain,
 
 		// Used to store the upstream graphic group during destructive Boolean Operations (and other nodes with a similar effect) so that click targets can be preserved.
-		pub upstream_graphic_group: Option<GraphicGroupTable>,
+		pub upstream_graphic_group: Option<Table<GraphicElement>>,
 	}
 
 	#[derive(serde::Serialize, serde::Deserialize)]
@@ -50,13 +50,13 @@ pub fn migrate_vector_data<'de, D: serde::Deserializer<'de>>(deserializer: D) ->
 	enum EitherFormat {
 		VectorData(VectorData),
 		OldVectorData(OldVectorData),
-		VectorDataTable(VectorDataTable),
+		VectorDataTable(Table<VectorData>),
 	}
 
 	Ok(match EitherFormat::deserialize(deserializer)? {
-		EitherFormat::VectorData(vector_data) => VectorDataTable::new(vector_data),
+		EitherFormat::VectorData(vector_data) => Table::new_from_element(vector_data),
 		EitherFormat::OldVectorData(old) => {
-			let mut vector_data_table = VectorDataTable::new(VectorData {
+			let mut vector_data_table = Table::new_from_element(VectorData {
 				style: old.style,
 				colinear_manipulators: old.colinear_manipulators,
 				point_domain: old.point_domain,
@@ -64,16 +64,14 @@ pub fn migrate_vector_data<'de, D: serde::Deserializer<'de>>(deserializer: D) ->
 				region_domain: old.region_domain,
 				upstream_graphic_group: old.upstream_graphic_group,
 			});
-			*vector_data_table.instance_mut_iter().next().unwrap().transform = old.transform;
-			*vector_data_table.instance_mut_iter().next().unwrap().alpha_blending = old.alpha_blending;
+			*vector_data_table.iter_mut().next().unwrap().transform = old.transform;
+			*vector_data_table.iter_mut().next().unwrap().alpha_blending = old.alpha_blending;
 			vector_data_table
 		}
 		EitherFormat::VectorDataTable(vector_data_table) => vector_data_table,
 	})
 }
 
-pub type VectorDataTable = Instances<VectorData>;
-
 /// [VectorData] is passed between nodes.
 /// It contains a list of subpaths (that may be open or closed), a transform, and some style information.
 ///
@@ -91,7 +89,7 @@ pub struct VectorData {
 	pub region_domain: RegionDomain,
 
 	// Used to store the upstream graphic group during destructive Boolean Operations (and other nodes with a similar effect) so that click targets can be preserved.
-	pub upstream_graphic_group: Option<GraphicGroupTable>,
+	pub upstream_graphic_group: Option<Table<GraphicElement>>,
 }
 
 impl Default for VectorData {
@@ -495,24 +493,24 @@ impl VectorData {
 	}
 }
 
-impl BoundingBox for VectorDataTable {
+impl BoundingBox for Table<VectorData> {
 	fn bounding_box(&self, transform: DAffine2, include_stroke: bool) -> Option<[DVec2; 2]> {
-		self.instance_ref_iter()
-			.flat_map(|instance| {
+		self.iter_ref()
+			.flat_map(|row| {
 				if !include_stroke {
-					return instance.instance.bounding_box_with_transform(transform * *instance.transform);
+					return row.element.bounding_box_with_transform(transform * *row.transform);
 				}
 
-				let stroke_width = instance.instance.style.stroke().map(|s| s.weight()).unwrap_or_default();
+				let stroke_width = row.element.style.stroke().map(|s| s.weight()).unwrap_or_default();
 
-				let miter_limit = instance.instance.style.stroke().map(|s| s.join_miter_limit).unwrap_or(1.);
+				let miter_limit = row.element.style.stroke().map(|s| s.join_miter_limit).unwrap_or(1.);
 
 				let scale = transform.decompose_scale();
 
 				// We use the full line width here to account for different styles of stroke caps
 				let offset = DVec2::splat(stroke_width * scale.x.max(scale.y) * miter_limit);
 
-				instance.instance.bounding_box_with_transform(transform * *instance.transform).map(|[a, b]| [a - offset, b + offset])
+				row.element.bounding_box_with_transform(transform * *row.transform).map(|[a, b]| [a - offset, b + offset])
 			})
 			.reduce(Quad::combine_bounds)
 	}

node-graph/gcore/src/vector/vector_data/attributes.rs

@@ -48,7 +48,7 @@ macro_rules! create_ids {
 	};
 }
 
-create_ids! { InstanceId, PointId, SegmentId, RegionId, StrokeId, FillId }
+create_ids! { PointId, SegmentId, RegionId, StrokeId, FillId }
 
 /// A no-op hasher that allows writing u64s (the id type).
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]

node-graph/gcore/src/vector/vector_data/modification.rs

@@ -1,6 +1,6 @@
 use super::*;
 use crate::Ctx;
-use crate::instances::Instance;
+use crate::table::TableRow;
 use crate::uuid::{NodeId, generate_uuid};
 use bezier_rs::BezierHandles;
 use dyn_any::DynAny;
@@ -420,35 +420,35 @@ impl Hash for VectorModification {
 
 /// Applies a diff modification to a vector path.
 #[node_macro::node(category(""))]
-async fn path_modify(_ctx: impl Ctx, mut vector_data: VectorDataTable, modification: Box<VectorModification>, node_path: Vec<NodeId>) -> VectorDataTable {
+async fn path_modify(_ctx: impl Ctx, mut vector_data: Table<VectorData>, modification: Box<VectorModification>, node_path: Vec<NodeId>) -> Table<VectorData> {
 	if vector_data.is_empty() {
-		vector_data.push(Instance::default());
+		vector_data.push(TableRow::default());
 	}
-	let vector_data_instance = vector_data.get_mut(0).expect("push should give one item");
-	modification.apply(vector_data_instance.instance);
+	let row = vector_data.get_mut(0).expect("push should give one item");
+	modification.apply(row.element);
 
 	// Update the source node id
 	let this_node_path = node_path.iter().rev().nth(1).copied();
-	*vector_data_instance.source_node_id = vector_data_instance.source_node_id.or(this_node_path);
+	*row.source_node_id = row.source_node_id.or(this_node_path);
 
 	if vector_data.len() > 1 {
-		warn!("The path modify ran on {} instances of vector data. Only the first can be modified.", vector_data.len());
+		warn!("The path modify ran on {} rows of vector data. Only the first can be modified.", vector_data.len());
 	}
 	vector_data
 }
 
 /// Applies the vector path's local transformation to its geometry and resets it to the identity.
 #[node_macro::node(category("Vector"))]
-async fn apply_transform(_ctx: impl Ctx, mut vector_data: VectorDataTable) -> VectorDataTable {
-	for vector_data_instance in vector_data.instance_mut_iter() {
-		let vector_data = vector_data_instance.instance;
-		let transform = *vector_data_instance.transform;
+async fn apply_transform(_ctx: impl Ctx, mut vector_data: Table<VectorData>) -> Table<VectorData> {
+	for row in vector_data.iter_mut() {
+		let vector_data = row.element;
+		let transform = *row.transform;
 
 		for (_, point) in vector_data.point_domain.positions_mut() {
 			*point = transform.transform_point2(*point);
 		}
 
-		*vector_data_instance.transform = DAffine2::IDENTITY;
+		*row.transform = DAffine2::IDENTITY;
 	}
 
 	vector_data