Broken layer tree

Bye

Author: 0HyperCube

document-legacy/src/document.rs

@@ -1,3 +1,4 @@
+use crate::document_metadata::DocumentMetadata;
 use crate::intersection::Quad;
 use crate::layers::folder_layer::FolderLayer;
 use crate::layers::layer_info::{Layer, LayerData, LayerDataType, LayerDataTypeDiscriminant};
@@ -28,6 +29,8 @@ pub struct Document {
 	pub state_identifier: DefaultHasher,
 	#[serde(default)]
 	pub document_network: graph_craft::document::NodeNetwork,
+	#[serde(skip)]
+	pub metadata: DocumentMetadata,
 	#[serde(default)]
 	pub commit_hash: String,
 }
@@ -56,6 +59,7 @@ impl Default for Document {
 				network.push_node(node, false);
 				network
 			},
+			metadata: Default::default(),
 			commit_hash: String::new(),
 		}
 	}

document-legacy/src/document_metadata.rs

@@ -0,0 +1,289 @@
+use glam::DAffine2;
+use std::collections::HashMap;
+use std::num::NonZeroU64;
+
+use graph_craft::document::{NodeId, NodeNetwork};
+
+#[derive(Debug, Clone)]
+pub struct DocumentMetadata {
+	transforms: HashMap<NodeId, DAffine2>,
+	structure: HashMap<LayerNodeIdentifier, NodeRelations>,
+}
+
+impl Default for DocumentMetadata {
+	fn default() -> Self {
+		Self {
+			transforms: HashMap::new(),
+			structure: HashMap::from_iter([(LayerNodeIdentifier::ROOT, NodeRelations::default())]),
+		}
+	}
+}
+
+impl DocumentMetadata {
+	pub const fn root(&self) -> LayerNodeIdentifier {
+		LayerNodeIdentifier::ROOT
+	}
+	fn get_structure(&self, node_identifier: LayerNodeIdentifier) -> Option<&NodeRelations> {
+		self.structure.get(&node_identifier)
+	}
+	fn get_structure_mut(&mut self, node_identifier: LayerNodeIdentifier) -> &mut NodeRelations {
+		self.structure.entry(node_identifier).or_default()
+	}
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct LayerNodeIdentifier(NonZeroU64);
+impl LayerNodeIdentifier {
+	const ROOT: Self = LayerNodeIdentifier::new_unchecked(0);
+	const fn new_unchecked(node_id: NodeId) -> Self {
+		// Safety: will always be >=1
+		Self(unsafe { NonZeroU64::new_unchecked(node_id + 1) })
+	}
+	pub fn new(node_id: NodeId, network: &NodeNetwork) -> Self {
+		debug_assert!(
+			is_layer_node(node_id, network),
+			"Layer identifer constructed from non layer node {node_id}: {:#?}",
+			network.nodes.get(&node_id)
+		);
+		Self::new_unchecked(node_id)
+	}
+	pub fn to_node(self) -> NodeId {
+		u64::from(self.0) - 1
+	}
+	pub fn parent(self, document_metadata: &DocumentMetadata) -> Option<LayerNodeIdentifier> {
+		document_metadata.get_structure(self).and_then(|relations| relations.parent)
+	}
+	pub fn previous_sibling(self, document_metadata: &DocumentMetadata) -> Option<LayerNodeIdentifier> {
+		document_metadata.get_structure(self).and_then(|relations| relations.previous_sibling)
+	}
+	pub fn next_sibling(self, document_metadata: &DocumentMetadata) -> Option<LayerNodeIdentifier> {
+		document_metadata.get_structure(self).and_then(|relations| relations.next_sibling)
+	}
+	pub fn first_child(self, document_metadata: &DocumentMetadata) -> Option<LayerNodeIdentifier> {
+		document_metadata.get_structure(self).and_then(|relations| relations.first_child)
+	}
+	pub fn last_child(self, document_metadata: &DocumentMetadata) -> Option<LayerNodeIdentifier> {
+		document_metadata.get_structure(self).and_then(|relations| relations.last_child)
+	}
+	pub fn has_children(self, document_metadata: &DocumentMetadata) -> bool {
+		self.first_child(document_metadata).is_some()
+	}
+	pub fn children(self, document_metadata: &DocumentMetadata) -> AxisIter {
+		AxisIter {
+			layer_node: self.first_child(document_metadata),
+			next_node: Self::next_sibling,
+			document_metadata,
+		}
+	}
+	pub fn ancestors(self, document_metadata: &DocumentMetadata) -> AxisIter {
+		AxisIter {
+			layer_node: Some(self),
+			next_node: Self::parent,
+			document_metadata,
+		}
+	}
+	pub fn last_children(self, document_metadata: &DocumentMetadata) -> AxisIter {
+		AxisIter {
+			layer_node: Some(self),
+			next_node: Self::last_child,
+			document_metadata,
+		}
+	}
+	pub fn decendants(self, document_metadata: &DocumentMetadata) -> DecendantsIter {
+		DecendantsIter {
+			front: self.first_child(document_metadata),
+			back: self.last_child(document_metadata),
+			document_metadata,
+		}
+	}
+	pub fn push_front_child(self, document_metadata: &mut DocumentMetadata, new: LayerNodeIdentifier) {
+		let parent = document_metadata.get_structure_mut(self);
+		let old_first_child = parent.first_child.replace(new);
+		parent.last_child.get_or_insert(new);
+		if let Some(old_first_child) = old_first_child {
+			document_metadata.get_structure_mut(old_first_child).previous_sibling = Some(new);
+			document_metadata.get_structure_mut(new).next_sibling = Some(old_first_child);
+		}
+		document_metadata.get_structure_mut(new).parent = Some(self);
+	}
+	pub fn push_child(self, document_metadata: &mut DocumentMetadata, new: LayerNodeIdentifier) {
+		let parent = document_metadata.get_structure_mut(self);
+		let old_last_child = parent.last_child.replace(new);
+		parent.first_child.get_or_insert(new);
+		if let Some(old_last_child) = old_last_child {
+			document_metadata.get_structure_mut(old_last_child).next_sibling = Some(new);
+			document_metadata.get_structure_mut(new).previous_sibling = Some(old_last_child);
+		}
+		document_metadata.get_structure_mut(new).parent = Some(self);
+	}
+	pub fn add_before(self, document_metadata: &mut DocumentMetadata, new: LayerNodeIdentifier) {
+		document_metadata.get_structure_mut(new).next_sibling = Some(self);
+		document_metadata.get_structure_mut(new).parent = self.parent(document_metadata);
+		let old_previous_sibling = document_metadata.get_structure_mut(self).previous_sibling.replace(new);
+		if let Some(old_previous_sibling) = old_previous_sibling {
+			document_metadata.get_structure_mut(old_previous_sibling).next_sibling = Some(new);
+			document_metadata.get_structure_mut(new).previous_sibling = Some(old_previous_sibling);
+		} else {
+			self.parent(document_metadata)
+				.map(|parent| document_metadata.get_structure_mut(parent))
+				.filter(|structure| structure.first_child == Some(self))
+				.map(|structure| structure.first_child = Some(new));
+		}
+	}
+	pub fn add_after(self, document_metadata: &mut DocumentMetadata, new: LayerNodeIdentifier) {
+		document_metadata.get_structure_mut(new).previous_sibling = Some(self);
+		document_metadata.get_structure_mut(new).parent = self.parent(document_metadata);
+		let old_next_sibling = document_metadata.get_structure_mut(self).next_sibling.replace(new);
+		if let Some(old_next_sibling) = old_next_sibling {
+			document_metadata.get_structure_mut(old_next_sibling).previous_sibling = Some(new);
+			document_metadata.get_structure_mut(new).next_sibling = Some(old_next_sibling);
+		} else {
+			self.parent(document_metadata)
+				.map(|parent| document_metadata.get_structure_mut(parent))
+				.filter(|structure| structure.last_child == Some(self))
+				.map(|structure| structure.last_child = Some(new));
+		}
+	}
+	pub fn delete(self, document_metadata: &mut DocumentMetadata) {
+		let previous_sibling = self.previous_sibling(document_metadata);
+		let next_sibling = self.next_sibling(document_metadata);
+
+		if let Some(previous_sibling) = previous_sibling.map(|node| document_metadata.get_structure_mut(node)) {
+			previous_sibling.next_sibling = next_sibling;
+		}
+
+		if let Some(next_sibling) = next_sibling.map(|node| document_metadata.get_structure_mut(node)) {
+			next_sibling.previous_sibling = previous_sibling;
+		}
+		let mut parent = self.parent(document_metadata).map(|parent| document_metadata.get_structure_mut(parent));
+		parent
+			.as_mut()
+			.filter(|structure| structure.first_child == Some(self))
+			.map(|structure| structure.first_child = next_sibling);
+		parent.filter(|structure| structure.last_child == Some(self)).map(|structure| structure.last_child = previous_sibling);
+
+		let mut delete = vec![self];
+		delete.extend(self.decendants(document_metadata));
+		for node in delete {
+			document_metadata.structure.remove(&node);
+		}
+	}
+}
+impl From<NodeId> for LayerNodeIdentifier {
+	fn from(node_id: NodeId) -> Self {
+		Self::new_unchecked(node_id)
+	}
+}
+impl From<LayerNodeIdentifier> for NodeId {
+	fn from(identifer: LayerNodeIdentifier) -> Self {
+		identifer.to_node()
+	}
+}
+/// Iterator over specified axis.
+#[derive(Clone)]
+pub struct AxisIter<'a> {
+	layer_node: Option<LayerNodeIdentifier>,
+	next_node: fn(LayerNodeIdentifier, &DocumentMetadata) -> Option<LayerNodeIdentifier>,
+	document_metadata: &'a DocumentMetadata,
+}
+
+impl<'a> Iterator for AxisIter<'a> {
+	type Item = LayerNodeIdentifier;
+
+	fn next(&mut self) -> Option<Self::Item> {
+		let layer_node = self.layer_node.take();
+		self.layer_node = layer_node.and_then(|node| (self.next_node)(node, self.document_metadata));
+		layer_node
+	}
+}
+
+#[derive(Clone)]
+pub struct DecendantsIter<'a> {
+	front: Option<LayerNodeIdentifier>,
+	back: Option<LayerNodeIdentifier>,
+	document_metadata: &'a DocumentMetadata,
+}
+
+impl<'a> Iterator for DecendantsIter<'a> {
+	type Item = LayerNodeIdentifier;
+
+	fn next(&mut self) -> Option<Self::Item> {
+		if self.front == self.back {
+			self.back = None;
+			self.front.take()
+		} else {
+			let layer_node = self.front.take();
+			if let Some(layer_node) = layer_node {
+				self.front = layer_node
+					.first_child(self.document_metadata)
+					.or_else(|| layer_node.ancestors(self.document_metadata).find_map(|ancestor| ancestor.next_sibling(self.document_metadata)));
+			}
+			layer_node
+		}
+	}
+}
+impl<'a> DoubleEndedIterator for DecendantsIter<'a> {
+	fn next_back(&mut self) -> Option<Self::Item> {
+		if self.front == self.back {
+			self.front = None;
+			self.back.take()
+		} else {
+			let layer_node = self.back.take();
+			if let Some(layer_node) = layer_node {
+				self.back = layer_node
+					.previous_sibling(self.document_metadata)
+					.and_then(|sibling| sibling.last_children(self.document_metadata).last())
+					.or_else(|| layer_node.parent(self.document_metadata));
+			}
+
+			layer_node
+		}
+	}
+}
+
+#[derive(Debug, Clone, Copy, Default)]
+pub struct NodeRelations {
+	parent: Option<LayerNodeIdentifier>,
+	previous_sibling: Option<LayerNodeIdentifier>,
+	next_sibling: Option<LayerNodeIdentifier>,
+	first_child: Option<LayerNodeIdentifier>,
+	last_child: Option<LayerNodeIdentifier>,
+}
+
+fn is_layer_node(node: NodeId, network: &NodeNetwork) -> bool {
+	node == LayerNodeIdentifier::ROOT.to_node() || network.nodes.get(&node).is_some_and(|node| node.name == "Layer")
+}
+
+#[test]
+fn test_tree() {
+	let mut document_metadata = DocumentMetadata::default();
+	let root = document_metadata.root();
+	let document_metadata = &mut document_metadata;
+	root.push_child(document_metadata, LayerNodeIdentifier::new_unchecked(3));
+	assert_eq!(root.children(document_metadata).collect::<Vec<_>>(), vec![LayerNodeIdentifier::new_unchecked(3)]);
+	root.push_child(document_metadata, LayerNodeIdentifier::new_unchecked(6));
+	assert_eq!(root.children(document_metadata).map(LayerNodeIdentifier::to_node).collect::<Vec<_>>(), vec![3, 6]);
+	assert_eq!(root.decendants(document_metadata).map(LayerNodeIdentifier::to_node).collect::<Vec<_>>(), vec![3, 6]);
+	LayerNodeIdentifier::new_unchecked(3).add_after(document_metadata, LayerNodeIdentifier::new_unchecked(4));
+	LayerNodeIdentifier::new_unchecked(3).add_before(document_metadata, LayerNodeIdentifier::new_unchecked(2));
+	LayerNodeIdentifier::new_unchecked(6).add_before(document_metadata, LayerNodeIdentifier::new_unchecked(5));
+	LayerNodeIdentifier::new_unchecked(6).add_after(document_metadata, LayerNodeIdentifier::new_unchecked(9));
+	LayerNodeIdentifier::new_unchecked(6).push_child(document_metadata, LayerNodeIdentifier::new_unchecked(8));
+	LayerNodeIdentifier::new_unchecked(6).push_front_child(document_metadata, LayerNodeIdentifier::new_unchecked(7));
+	root.push_front_child(document_metadata, LayerNodeIdentifier::new_unchecked(1));
+	assert_eq!(root.children(document_metadata).map(LayerNodeIdentifier::to_node).collect::<Vec<_>>(), vec![1, 2, 3, 4, 5, 6, 9]);
+	assert_eq!(
+		root.decendants(document_metadata).map(LayerNodeIdentifier::to_node).collect::<Vec<_>>(),
+		vec![1, 2, 3, 4, 5, 6, 7, 8, 9]
+	);
+	assert_eq!(
+		root.decendants(document_metadata).map(LayerNodeIdentifier::to_node).rev().collect::<Vec<_>>(),
+		vec![9, 8, 7, 6, 5, 4, 3, 2, 1]
+	);
+	assert!(root.children(document_metadata).all(|child| child.parent(document_metadata) == Some(root)));
+	LayerNodeIdentifier::new_unchecked(6).delete(document_metadata);
+	LayerNodeIdentifier::new_unchecked(1).delete(document_metadata);
+	assert_eq!(root.children(document_metadata).map(LayerNodeIdentifier::to_node).collect::<Vec<_>>(), vec![2, 3, 4, 5, 9]);
+	assert_eq!(root.decendants(document_metadata).map(LayerNodeIdentifier::to_node).collect::<Vec<_>>(), vec![2, 3, 4, 5, 9]);
+	assert_eq!(root.decendants(document_metadata).map(LayerNodeIdentifier::to_node).rev().collect::<Vec<_>>(), vec![9, 5, 4, 3, 2]);
+}

document-legacy/src/lib.rs

@@ -6,6 +6,7 @@ pub mod boolean_ops;
 /// Contains constant values used by this crate.
 pub mod consts;
 pub mod document;
+pub mod document_metadata;
 /// Defines errors that can occur when using this crate.
 pub mod error;
 /// Utilities for computing intersections.

editor/src/messages/portfolio/document/document_message_handler.rs

@@ -17,6 +17,7 @@ use crate::messages::tool::utility_types::ToolType;
 use crate::node_graph_executor::NodeGraphExecutor;
 
 use document_legacy::document::Document as DocumentLegacy;
+use document_legacy::document_metadata::LayerNodeIdentifier;
 use document_legacy::layers::blend_mode::BlendMode;
 use document_legacy::layers::folder_layer::FolderLayer;
 use document_legacy::layers::layer_info::{LayerDataType, LayerDataTypeDiscriminant};
@@ -1209,13 +1210,14 @@ impl DocumentMessageHandler {
 			)
 	}
 
-	fn serialize_structure(&self, folder: &FolderLayer, structure: &mut Vec<u64>, data: &mut Vec<LayerId>, path: &mut Vec<LayerId>) {
+	fn serialize_structure(&self, folder: LayerNodeIdentifier, structure: &mut Vec<u64>, data: &mut Vec<LayerId>, path: &mut Vec<LayerId>) {
 		let mut space = 0;
-		for (id, layer) in folder.layer_ids.iter().zip(folder.layers()).rev() {
-			data.push(*id);
+		for layer_node in folder.children(&self.document_legacy.metadata) {
+			data.push(layer_node.to_node());
+			info!("Pushed child");
 			space += 1;
-			if let LayerDataType::Folder(ref folder) = layer.data {
-				path.push(*id);
+			if layer_node.has_children(&self.document_legacy.metadata) {
+				path.push(layer_node.to_node());
 				if self.layer_metadata(path).expanded {
 					structure.push(space);
 					self.serialize_structure(folder, structure, data, path);
@@ -1261,7 +1263,7 @@ impl DocumentMessageHandler {
 	/// ```
 	pub fn serialize_root(&self) -> Vec<u64> {
 		let (mut structure, mut data) = (vec![0], Vec::new());
-		self.serialize_structure(self.document_legacy.root.as_folder().unwrap(), &mut structure, &mut data, &mut vec![]);
+		self.serialize_structure(self.document_legacy.metadata.root(), &mut structure, &mut data, &mut vec![]);
 		structure[0] = structure.len() as u64 - 1;
 		structure.extend(data);