Merge branch 'master' into gradient

Author: Keavon

.github/workflows/build-dev-and-ci.yml

@@ -108,17 +108,6 @@ jobs:
       - name: 📥 Clone and checkout repository
         uses: actions/checkout@v3
 
-      - name: 🔒 Check crate security advisories for root workspace
-        uses: EmbarkStudios/cargo-deny-action@v2
-        with:
-          command: check advisories
-
-      - name: 🔒 Check crate security advisories for /libraries/rawkit
-        uses: EmbarkStudios/cargo-deny-action@v2
-        with:
-          command: check advisories
-          manifest-path: libraries/rawkit/Cargo.toml
-
       - name: 📜 Check crate license compatibility for root workspace
         uses: EmbarkStudios/cargo-deny-action@v2
         with:

.github/workflows/cargo-deny.yml

@@ -0,0 +1,25 @@
+name: "Audit Security Advisories"
+
+on:
+  # Run once each day
+  schedule:
+    - cron: "0 0 * * *"
+
+jobs:
+  cargo-deny:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: 📥 Clone and checkout repository
+        uses: actions/checkout@v3
+
+      - name: 🔒 Check crate security advisories for root workspace
+        uses: EmbarkStudios/cargo-deny-action@v2
+        with:
+          command: check advisories
+
+      - name: 🔒 Check crate security advisories for /libraries/rawkit
+        uses: EmbarkStudios/cargo-deny-action@v2
+        with:
+          command: check advisories
+          manifest-path: libraries/rawkit/Cargo.toml

Cargo.lock

@@ -515,6 +515,7 @@ mod test {
 		// 	include_str!("../../demo-artwork/isometric-fountain.graphite"),
 		// 	include_str!("../../demo-artwork/painted-dreams.graphite"),
 		// 	include_str!("../../demo-artwork/procedural-string-lights.graphite"),
+		// 	include_str!("../../demo-artwork/parametric-dunescape.graphite"),
 		// 	include_str!("../../demo-artwork/red-dress.graphite"),
 		// 	include_str!("../../demo-artwork/valley-of-spires.graphite"),
 		// ];

demo-artwork/parametric-dunescape.graphite

@@ -11,55 +11,72 @@ pub enum AnimationTimeMode {
 	FrameBased,
 }
 
-#[derive(Debug, Default)]
+#[derive(Default, Debug, Clone, PartialEq)]
+enum AnimationState {
+	#[default]
+	Stopped,
+	Playing {
+		start: f64,
+	},
+	Paused {
+		start: f64,
+		pause_time: f64,
+	},
+}
+
+#[derive(Default, Debug, Clone, PartialEq)]
 pub struct AnimationMessageHandler {
-	live_preview: bool,
 	/// Used to re-send the UI on the next frame after playback starts
 	live_preview_recently_zero: bool,
 	timestamp: f64,
 	frame_index: f64,
-	animation_start: Option<f64>,
+	animation_state: AnimationState,
 	fps: f64,
 	animation_time_mode: AnimationTimeMode,
 }
 impl AnimationMessageHandler {
 	pub(crate) fn timing_information(&self) -> TimingInformation {
-		let animation_time = self.timestamp - self.animation_start.unwrap_or(self.timestamp);
+		let animation_time = self.timestamp - self.animation_start();
 		let animation_time = match self.animation_time_mode {
 			AnimationTimeMode::TimeBased => Duration::from_millis(animation_time as u64),
 			AnimationTimeMode::FrameBased => Duration::from_secs((self.frame_index / self.fps) as u64),
 		};
 		TimingInformation { time: self.timestamp, animation_time }
 	}
 
+	pub(crate) fn animation_start(&self) -> f64 {
+		match self.animation_state {
+			AnimationState::Stopped => self.timestamp,
+			AnimationState::Playing { start } => start,
+			AnimationState::Paused { start, pause_time } => start + self.timestamp - pause_time,
+		}
+	}
+
 	pub fn is_playing(&self) -> bool {
-		self.live_preview
+		matches!(self.animation_state, AnimationState::Playing { .. })
 	}
 }
 
 impl MessageHandler<AnimationMessage, ()> for AnimationMessageHandler {
 	fn process_message(&mut self, message: AnimationMessage, responses: &mut VecDeque<Message>, _data: ()) {
 		match message {
-			AnimationMessage::ToggleLivePreview => {
-				if self.animation_start.is_none() {
-					self.animation_start = Some(self.timestamp);
-				}
-				self.live_preview = !self.live_preview;
-
-				// Update the restart and pause/play buttons
-				responses.add(PortfolioMessage::UpdateDocumentWidgets);
-			}
+			AnimationMessage::ToggleLivePreview => match self.animation_state {
+				AnimationState::Stopped => responses.add(AnimationMessage::EnableLivePreview),
+				AnimationState::Playing { .. } => responses.add(AnimationMessage::DisableLivePreview),
+				AnimationState::Paused { .. } => responses.add(AnimationMessage::EnableLivePreview),
+			},
 			AnimationMessage::EnableLivePreview => {
-				if self.animation_start.is_none() {
-					self.animation_start = Some(self.timestamp);
-				}
-				self.live_preview = true;
+				self.animation_state = AnimationState::Playing { start: self.animation_start() };
 
 				// Update the restart and pause/play buttons
 				responses.add(PortfolioMessage::UpdateDocumentWidgets);
 			}
 			AnimationMessage::DisableLivePreview => {
-				self.live_preview = false;
+				match self.animation_state {
+					AnimationState::Stopped => (),
+					AnimationState::Playing { start } => self.animation_state = AnimationState::Paused { start, pause_time: self.timestamp },
+					AnimationState::Paused { .. } => (),
+				}
 
 				// Update the restart and pause/play buttons
 				responses.add(PortfolioMessage::UpdateDocumentWidgets);
@@ -72,18 +89,16 @@ impl MessageHandler<AnimationMessage, ()> for AnimationMessageHandler {
 			}
 			AnimationMessage::SetTime(time) => {
 				self.timestamp = time;
-				if self.live_preview {
-					responses.add(AnimationMessage::UpdateTime);
-				}
+				responses.add(AnimationMessage::UpdateTime);
 			}
 			AnimationMessage::IncrementFrameCounter => {
-				if self.live_preview {
+				if self.is_playing() {
 					self.frame_index += 1.;
 					responses.add(AnimationMessage::UpdateTime);
 				}
 			}
 			AnimationMessage::UpdateTime => {
-				if self.live_preview {
+				if self.is_playing() {
 					responses.add(PortfolioMessage::SubmitActiveGraphRender);
 
 					if self.live_preview_recently_zero {
@@ -95,7 +110,10 @@ impl MessageHandler<AnimationMessage, ()> for AnimationMessageHandler {
 			}
 			AnimationMessage::RestartAnimation => {
 				self.frame_index = 0.;
-				self.animation_start = None;
+				self.animation_state = match self.animation_state {
+					AnimationState::Playing { .. } => AnimationState::Playing { start: self.timestamp },
+					_ => AnimationState::Stopped,
+				};
 				self.live_preview_recently_zero = true;
 				responses.add(PortfolioMessage::SubmitActiveGraphRender);
 				// Update the restart and pause/play buttons

editor/src/dispatcher.rs

@@ -5,10 +5,11 @@ use crate::messages::prelude::*;
 pub struct DemoArtworkDialog;
 
 /// `(name, thumbnail, filename)`
-pub const ARTWORK: [(&str, &str, &str); 6] = [
+pub const ARTWORK: [(&str, &str, &str); 7] = [
 	("Isometric Fountain", "ThumbnailIsometricFountain", "isometric-fountain.graphite"),
 	("Changing Seasons", "ThumbnailChangingSeasons", "changing-seasons.graphite"),
 	("Painted Dreams", "ThumbnailPaintedDreams", "painted-dreams.graphite"),
+	("Parametric Dunescape", "ThumbnailParametricDunescape", "parametric-dunescape.graphite"),
 	("Red Dress", "ThumbnailRedDress", "red-dress.graphite"),
 	("Procedural String Lights", "ThumbnailProceduralStringLights", "procedural-string-lights.graphite"),
 	("Valley of Spires", "ThumbnailValleyOfSpires", "valley-of-spires.graphite"),
@@ -28,7 +29,7 @@ impl DialogLayoutHolder for DemoArtworkDialog {
 impl LayoutHolder for DemoArtworkDialog {
 	fn layout(&self) -> Layout {
 		let mut rows_of_images_with_buttons: Vec<_> = ARTWORK
-			.chunks(3)
+			.chunks(4)
 			.flat_map(|chunk| {
 				fn make_dialog(name: &str, filename: &str) -> Message {
 					DialogMessage::CloseDialogAndThen {

editor/src/messages/animation/animation_message_handler.rs

@@ -42,6 +42,7 @@ pub struct DocumentMessageData<'a> {
 	pub executor: &'a mut NodeGraphExecutor,
 	pub current_tool: &'a ToolType,
 	pub preferences: &'a PreferencesMessageHandler,
+	pub device_pixel_ratio: f64,
 }
 
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
@@ -173,6 +174,7 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
 			executor,
 			current_tool,
 			preferences,
+			device_pixel_ratio,
 		} = data;
 
 		let selected_nodes_bounding_box_viewport = self.network_interface.selected_nodes_bounding_box_viewport(&self.breadcrumb_network_path);
@@ -197,7 +199,15 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
 			}
 			DocumentMessage::Overlays(message) => {
 				let overlays_visible = self.overlays_visible;
-				self.overlays_message_handler.process_message(message, responses, OverlaysMessageData { overlays_visible, ipp });
+				self.overlays_message_handler.process_message(
+					message,
+					responses,
+					OverlaysMessageData {
+						overlays_visible,
+						ipp,
+						device_pixel_ratio,
+					},
+				);
 			}
 			DocumentMessage::PropertiesPanel(message) => {
 				let properties_panel_message_handler_data = PropertiesPanelMessageHandlerData {
@@ -1199,14 +1209,14 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
 
 				if is_collapsed {
 					if recursive {
-						let children: HashSet<_> = layer.children(metadata).collect();
+						let children: HashSet<_> = layer.descendants(metadata).collect();
 						self.collapsed.0.retain(|collapsed_layer| !children.contains(collapsed_layer) && collapsed_layer != &layer);
 					} else {
 						self.collapsed.0.retain(|collapsed_layer| collapsed_layer != &layer);
 					}
 				} else {
 					if recursive {
-						let children_to_add: Vec<_> = layer.children(metadata).filter(|child| !self.collapsed.0.contains(child)).collect();
+						let children_to_add: Vec<_> = layer.descendants(metadata).filter(|child| !self.collapsed.0.contains(child)).collect();
 						self.collapsed.0.extend(children_to_add);
 					}
 					self.collapsed.0.push(layer);

editor/src/messages/dialog/simple_dialogs/demo_artwork_dialog.rs

@@ -292,7 +292,7 @@ impl<'a> ModifyInputsContext<'a> {
 		// If inserting a path node, insert a flatten vector elements if the type is a graphic group.
 		// TODO: Allow the path node to operate on Graphic Group data by utilizing the reference for each vector data in a group.
 		if node_definition.identifier == "Path" {
-			let layer_input_type = self.network_interface.input_type(&InputConnector::node(output_layer.to_node(), 1), &[]).0.nested_type();
+			let layer_input_type = self.network_interface.input_type(&InputConnector::node(output_layer.to_node(), 1), &[]).0.nested_type().clone();
 			if layer_input_type == concrete!(GraphicGroupTable) {
 				let Some(flatten_vector_elements_definition) = resolve_document_node_type("Flatten Vector Elements") else {
 					log::error!("Flatten Vector Elements does not exist in ModifyInputsContext::existing_node_id");

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

@@ -809,6 +809,7 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 						NodeInput::value(TaggedValue::ImageFrame(ImageFrameTable::one_empty_image()), true),
 						NodeInput::value(TaggedValue::ImageFrame(ImageFrameTable::one_empty_image()), true),
 					],
+					manual_composition: Some(generic!(T)),
 					..Default::default()
 				},
 				persistent_node_metadata: DocumentNodePersistentMetadata {
@@ -2663,6 +2664,7 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 	let node_registry = graphene_core::registry::NODE_REGISTRY.lock().unwrap();
 	'outer: for (id, metadata) in graphene_core::registry::NODE_METADATA.lock().unwrap().iter() {
 		use graphene_core::registry::*;
+		let id = id.clone();
 
 		for node in custom.iter() {
 			let DocumentNodeDefinition {
@@ -2673,7 +2675,7 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 				..
 			} = node;
 			match implementation {
-				DocumentNodeImplementation::ProtoNode(ProtoNodeIdentifier { name }) if name == id => continue 'outer,
+				DocumentNodeImplementation::ProtoNode(ProtoNodeIdentifier { name }) if name == &id => continue 'outer,
 				_ => (),
 			}
 		}
@@ -2685,12 +2687,12 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 			description,
 			properties,
 		} = metadata;
-		let Some(implementations) = &node_registry.get(id) else { continue };
+		let Some(implementations) = &node_registry.get(&id) else { continue };
 		let valid_inputs: HashSet<_> = implementations.iter().map(|(_, node_io)| node_io.call_argument.clone()).collect();
 		let first_node_io = implementations.first().map(|(_, node_io)| node_io).unwrap_or(const { &NodeIOTypes::empty() });
 		let mut input_type = &first_node_io.call_argument;
 		if valid_inputs.len() > 1 {
-			input_type = &const { generic!(T) };
+			input_type = &const { generic!(D) };
 		}
 		let output_type = &first_node_io.return_value;
 
@@ -2740,6 +2742,7 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 					output_names: vec![output_type.to_string()],
 					has_primary_output: true,
 					locked: false,
+
 					..Default::default()
 				},
 			},