Merge branch 'master' into merge-spline-path

Author: indierusty

.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

@@ -16,6 +16,8 @@ pub const VIEWPORT_ZOOM_LEVELS: [f64; 74] = [
 	0.04, 0.05, 0.06, 0.08, 0.1, 0.125, 0.15, 0.2, 0.25, 0.33333333, 0.4, 0.5, 0.66666666, 0.8, 1., 1.25, 1.6, 2., 2.5, 3.2, 4., 5., 6.4, 8., 10., 12.5, 16., 20., 25., 32., 40., 50., 64., 80., 100.,
 	128., 160., 200., 256., 320., 400., 512., 640., 800., 1024., 1280., 1600., 2048., 2560.,
 ];
+/// Higher values create a steeper curve (a faster zoom rate change)
+pub const VIEWPORT_ZOOM_WHEEL_RATE_CHANGE: f64 = 3.;
 
 /// Helps push values that end in approximately half, plus or minus some floating point imprecision, towards the same side of the round() function.
 pub const VIEWPORT_GRID_ROUNDING_BIAS: f64 = 0.002;

demo-artwork/parametric-dunescape.graphite

@@ -13,6 +13,7 @@ pub struct Dispatcher {
 
 #[derive(Debug, Default)]
 pub struct DispatcherMessageHandlers {
+	animation_message_handler: AnimationMessageHandler,
 	broadcast_message_handler: BroadcastMessageHandler,
 	debug_message_handler: DebugMessageHandler,
 	dialog_message_handler: DialogMessageHandler,
@@ -50,12 +51,9 @@ const SIDE_EFFECT_FREE_MESSAGES: &[MessageDiscriminant] = &[
 	MessageDiscriminant::Frontend(FrontendMessageDiscriminant::UpdateDocumentLayerStructure),
 	MessageDiscriminant::Frontend(FrontendMessageDiscriminant::TriggerFontLoad),
 ];
-const DEBUG_MESSAGE_BLOCK_LIST: &[MessageDiscriminant] = &[
-	MessageDiscriminant::Broadcast(BroadcastMessageDiscriminant::TriggerEvent(BroadcastEventDiscriminant::AnimationFrame)),
-	MessageDiscriminant::InputPreprocessor(InputPreprocessorMessageDiscriminant::FrameTimeAdvance),
-];
+const DEBUG_MESSAGE_BLOCK_LIST: &[MessageDiscriminant] = &[MessageDiscriminant::Broadcast(BroadcastMessageDiscriminant::TriggerEvent(BroadcastEventDiscriminant::AnimationFrame))];
 // TODO: Find a way to combine these with the list above. We use strings for now since these are the standard variant names used by multiple messages. But having these also type-checked would be best.
-const DEBUG_MESSAGE_ENDING_BLOCK_LIST: &[&str] = &["PointerMove", "PointerOutsideViewport", "Overlays", "Draw"];
+const DEBUG_MESSAGE_ENDING_BLOCK_LIST: &[&str] = &["PointerMove", "PointerOutsideViewport", "Overlays", "Draw", "CurrentTime", "Time"];
 
 impl Dispatcher {
 	pub fn new() -> Self {
@@ -177,6 +175,9 @@ impl Dispatcher {
 					// Finish loading persistent data from the browser database
 					queue.add(FrontendMessage::TriggerLoadRestAutoSaveDocuments);
 				}
+				Message::Animation(message) => {
+					self.message_handlers.animation_message_handler.process_message(message, &mut queue, ());
+				}
 				Message::Batched(messages) => {
 					messages.iter().for_each(|message| self.handle_message(message.to_owned(), false));
 				}
@@ -232,6 +233,8 @@ impl Dispatcher {
 					let preferences = &self.message_handlers.preferences_message_handler;
 					let current_tool = &self.message_handlers.tool_message_handler.tool_state.tool_data.active_tool_type;
 					let message_logging_verbosity = self.message_handlers.debug_message_handler.message_logging_verbosity;
+					let timing_information = self.message_handlers.animation_message_handler.timing_information();
+					let animation = &self.message_handlers.animation_message_handler;
 
 					self.message_handlers.portfolio_message_handler.process_message(
 						message,
@@ -241,6 +244,8 @@ impl Dispatcher {
 							preferences,
 							current_tool,
 							message_logging_verbosity,
+							timing_information,
+							animation,
 						},
 					);
 				}
@@ -283,6 +288,7 @@ impl Dispatcher {
 		// TODO: Reduce the number of heap allocations
 		let mut list = Vec::new();
 		list.extend(self.message_handlers.dialog_message_handler.actions());
+		list.extend(self.message_handlers.animation_message_handler.actions());
 		list.extend(self.message_handlers.input_preprocessor_message_handler.actions());
 		list.extend(self.message_handlers.key_mapping_message_handler.actions());
 		list.extend(self.message_handlers.debug_message_handler.actions());
@@ -509,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"),
 		// ];

editor/src/consts.rs

@@ -0,0 +1,17 @@
+use crate::messages::prelude::*;
+
+use super::animation_message_handler::AnimationTimeMode;
+
+#[impl_message(Message, Animation)]
+#[derive(PartialEq, Clone, Debug, serde::Serialize, serde::Deserialize)]
+pub enum AnimationMessage {
+	ToggleLivePreview,
+	EnableLivePreview,
+	DisableLivePreview,
+	RestartAnimation,
+	SetFrameIndex(f64),
+	SetTime(f64),
+	UpdateTime,
+	IncrementFrameCounter,
+	SetAnimationTimeMode(AnimationTimeMode),
+}

editor/src/dispatcher.rs

@@ -0,0 +1,133 @@
+use std::time::Duration;
+
+use crate::messages::prelude::*;
+
+use super::TimingInformation;
+
+#[derive(PartialEq, Clone, Default, Debug, serde::Serialize, serde::Deserialize)]
+pub enum AnimationTimeMode {
+	#[default]
+	TimeBased,
+	FrameBased,
+}
+
+#[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 {
+	/// Used to re-send the UI on the next frame after playback starts
+	live_preview_recently_zero: bool,
+	timestamp: f64,
+	frame_index: 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();
+		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 {
+		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 => match self.animation_state {
+				AnimationState::Stopped => responses.add(AnimationMessage::EnableLivePreview),
+				AnimationState::Playing { .. } => responses.add(AnimationMessage::DisableLivePreview),
+				AnimationState::Paused { .. } => responses.add(AnimationMessage::EnableLivePreview),
+			},
+			AnimationMessage::EnableLivePreview => {
+				self.animation_state = AnimationState::Playing { start: self.animation_start() };
+
+				// Update the restart and pause/play buttons
+				responses.add(PortfolioMessage::UpdateDocumentWidgets);
+			}
+			AnimationMessage::DisableLivePreview => {
+				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);
+			}
+			AnimationMessage::SetFrameIndex(frame) => {
+				self.frame_index = frame;
+				responses.add(PortfolioMessage::SubmitActiveGraphRender);
+				// Update the restart and pause/play buttons
+				responses.add(PortfolioMessage::UpdateDocumentWidgets);
+			}
+			AnimationMessage::SetTime(time) => {
+				self.timestamp = time;
+				responses.add(AnimationMessage::UpdateTime);
+			}
+			AnimationMessage::IncrementFrameCounter => {
+				if self.is_playing() {
+					self.frame_index += 1.;
+					responses.add(AnimationMessage::UpdateTime);
+				}
+			}
+			AnimationMessage::UpdateTime => {
+				if self.is_playing() {
+					responses.add(PortfolioMessage::SubmitActiveGraphRender);
+
+					if self.live_preview_recently_zero {
+						// Update the restart and pause/play buttons
+						responses.add(PortfolioMessage::UpdateDocumentWidgets);
+						self.live_preview_recently_zero = false;
+					}
+				}
+			}
+			AnimationMessage::RestartAnimation => {
+				self.frame_index = 0.;
+				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
+				responses.add(PortfolioMessage::UpdateDocumentWidgets);
+			}
+			AnimationMessage::SetAnimationTimeMode(animation_time_mode) => {
+				self.animation_time_mode = animation_time_mode;
+			}
+		}
+	}
+
+	advertise_actions!(AnimationMessageDiscriminant;
+		ToggleLivePreview,
+		SetFrameIndex,
+		RestartAnimation,
+	);
+}

editor/src/messages/animation/animation_message.rs

@@ -0,0 +1,9 @@
+mod animation_message;
+mod animation_message_handler;
+
+#[doc(inline)]
+pub use animation_message::{AnimationMessage, AnimationMessageDiscriminant};
+#[doc(inline)]
+pub use animation_message_handler::AnimationMessageHandler;
+
+pub use graphene_core::application_io::TimingInformation;

editor/src/messages/animation/animation_message_handler.rs

@@ -1,3 +1,4 @@
+use crate::consts::{VIEWPORT_ZOOM_WHEEL_RATE, VIEWPORT_ZOOM_WHEEL_RATE_CHANGE};
 use crate::messages::layout::utility_types::widget_prelude::*;
 use crate::messages::portfolio::document::node_graph::utility_types::GraphWireStyle;
 use crate::messages::preferences::SelectionMode;
@@ -39,6 +40,32 @@ impl PreferencesDialogMessageHandler {
 
 		let navigation_header = vec![TextLabel::new("Navigation").italic(true).widget_holder()];
 
+		let zoom_rate_tooltip = "Adjust how fast zooming occurs when using the scroll wheel or pinch gesture (relative to a default of 50)";
+		let zoom_rate_label = vec![
+			Separator::new(SeparatorType::Unrelated).widget_holder(),
+			Separator::new(SeparatorType::Unrelated).widget_holder(),
+			TextLabel::new("Zoom Rate").tooltip(zoom_rate_tooltip).widget_holder(),
+		];
+		let zoom_rate = vec![
+			Separator::new(SeparatorType::Unrelated).widget_holder(),
+			Separator::new(SeparatorType::Unrelated).widget_holder(),
+			NumberInput::new(Some(map_zoom_rate_to_display(preferences.viewport_zoom_wheel_rate)))
+				.tooltip(zoom_rate_tooltip)
+				.mode_range()
+				.int()
+				.min(1.)
+				.max(100.)
+				.on_update(|number_input: &NumberInput| {
+					if let Some(display_value) = number_input.value {
+						let actual_rate = map_display_to_zoom_rate(display_value);
+						PreferencesMessage::ViewportZoomWheelRate { rate: actual_rate }.into()
+					} else {
+						PreferencesMessage::ViewportZoomWheelRate { rate: VIEWPORT_ZOOM_WHEEL_RATE }.into()
+					}
+				})
+				.widget_holder(),
+		];
+
 		let zoom_with_scroll_tooltip = "Use the scroll wheel for zooming instead of vertically panning (not recommended for trackpads)";
 		let zoom_with_scroll = vec![
 			Separator::new(SeparatorType::Unrelated).widget_holder(),
@@ -184,6 +211,8 @@ impl PreferencesDialogMessageHandler {
 
 		Layout::WidgetLayout(WidgetLayout::new(vec![
 			LayoutGroup::Row { widgets: navigation_header },
+			LayoutGroup::Row { widgets: zoom_rate_label },
+			LayoutGroup::Row { widgets: zoom_rate },
 			LayoutGroup::Row { widgets: zoom_with_scroll },
 			LayoutGroup::Row { widgets: editing_header },
 			LayoutGroup::Row { widgets: selection_label },
@@ -250,3 +279,20 @@ impl PreferencesDialogMessageHandler {
 		});
 	}
 }
+
+/// Maps display values (1-100) to actual zoom rates.
+fn map_display_to_zoom_rate(display: f64) -> f64 {
+	// Calculate the relative distance from the reference point (50)
+	let distance_from_reference = display - 50.;
+	let scaling_factor = (VIEWPORT_ZOOM_WHEEL_RATE_CHANGE * distance_from_reference / 50.).exp();
+	VIEWPORT_ZOOM_WHEEL_RATE * scaling_factor
+}
+
+/// Maps actual zoom rates back to display values (1-100).
+fn map_zoom_rate_to_display(rate: f64) -> f64 {
+	// Calculate the scaling factor from the reference rate
+	let scaling_factor = rate / VIEWPORT_ZOOM_WHEEL_RATE;
+	let distance_from_reference = 50. * scaling_factor.ln() / VIEWPORT_ZOOM_WHEEL_RATE_CHANGE;
+	let display = 50. + distance_from_reference;
+	display.clamp(1., 100.).round()
+}

editor/src/messages/animation/mod.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 {