Make round stroke caps for tool strokes

editor/src/messages/tool/common_functionality/color_selector.rs

@@ -2,7 +2,7 @@ use crate::messages::layout::utility_types::widget_prelude::*;
 use crate::messages::portfolio::document::utility_types::document_metadata::LayerNodeIdentifier;
 use crate::messages::prelude::*;
 use graphene_std::Color;
-use graphene_std::vector::style::FillChoice;
+use graphene_std::vector::style::{FillChoice, StrokeCap};
 
 #[cfg_attr(feature = "wasm", derive(tsify::Tsify))]
 #[derive(PartialEq, Clone, Debug, serde::Serialize, serde::Deserialize)]
@@ -68,7 +68,7 @@ impl ToolColorOptions {
 
 	pub fn apply_stroke(&self, weight: f64, layer: LayerNodeIdentifier, responses: &mut VecDeque<Message>) {
 		if let Some(color) = self.active_color() {
-			let stroke = graphene_std::vector::style::Stroke::new(Some(color.to_gamma_srgb()), weight);
+			let stroke = graphene_std::vector::style::Stroke::new(Some(color.to_gamma_srgb()), weight).with_stroke_cap(StrokeCap::Round);
 			responses.add(GraphOperationMessage::StrokeSet { layer, stroke });
 		}
 	}

editor/src/node_graph_executor.rs

@@ -115,8 +115,8 @@ impl NodeGraphExecutor {
 		Ok(instrumented)
 	}
 
-	/// Update the cached network if necessary.
-	fn update_node_graph(&mut self, document: &mut DocumentMessageHandler, node_to_inspect: Option<NodeId>, ignore_hash: bool) -> Result<(), String> {
+	/// Update the cached network if necessary. Returns the current document network hash (same value used for cache sync).
+	fn update_node_graph(&mut self, document: &mut DocumentMessageHandler, node_to_inspect: Option<NodeId>, ignore_hash: bool) -> Result<u64, String> {
 		let network_hash = document.network_interface.network_hash();
 		// Refresh the graph when it changes or the inspect node changes
 		if network_hash != self.node_graph_hash || self.previous_node_to_inspect != node_to_inspect || ignore_hash {
@@ -129,7 +129,7 @@ impl NodeGraphExecutor {
 				.map_err(|e| e.to_string())?;
 		}
 
-		Ok(())
+		Ok(network_hash)
 	}
 
 	/// Adds an evaluate request for whatever current network is cached.
@@ -141,6 +141,7 @@ impl NodeGraphExecutor {
 		viewport_scale: f64,
 		time: TimingInformation,
 		pointer: DVec2,
+		document_network_hash: u64,
 	) -> Result<Message, String> {
 		let viewport = Footprint {
 			transform: document.metadata().document_to_viewport,
@@ -157,6 +158,7 @@ impl NodeGraphExecutor {
 			hide_artboards: false,
 			for_export: false,
 			for_eyedropper: false,
+			document_network_hash,
 		};
 
 		// Execute the node graph
@@ -180,8 +182,16 @@ impl NodeGraphExecutor {
 		ignore_hash: bool,
 		pointer: DVec2,
 	) -> Result<Message, String> {
-		self.update_node_graph(document, node_to_inspect, ignore_hash)?;
-		self.submit_current_node_graph_evaluation(document, document_id, viewport_resolution, viewport_scale, time, pointer)
+		let document_network_hash = self.update_node_graph(document, node_to_inspect, ignore_hash)?;
+		self.submit_current_node_graph_evaluation(
+			document,
+			document_id,
+			viewport_resolution,
+			viewport_scale,
+			time,
+			pointer,
+			document_network_hash,
+		)
 	}
 
 	#[allow(clippy::too_many_arguments)]
@@ -212,6 +222,7 @@ impl NodeGraphExecutor {
 		#[cfg(target_family = "wasm")]
 		let render_mode = document.render_mode;
 
+		let document_network_hash = document.network_interface.network_hash();
 		let render_config = RenderConfig {
 			viewport,
 			scale: viewport_scale,
@@ -222,6 +233,7 @@ impl NodeGraphExecutor {
 			hide_artboards: false,
 			for_export: false,
 			for_eyedropper: true,
+			document_network_hash,
 		};
 
 		// Execute the node graph
@@ -260,6 +272,7 @@ impl NodeGraphExecutor {
 			..Default::default()
 		};
 
+		let document_network_hash = document.network_interface.network_hash();
 		let render_config = RenderConfig {
 			viewport,
 			scale: export_config.scale_factor,
@@ -270,6 +283,7 @@ impl NodeGraphExecutor {
 			hide_artboards: export_config.transparent_background,
 			for_export: true,
 			for_eyedropper: false,
+			document_network_hash,
 		};
 		export_config.size = resolution;
 

editor/src/test_utils.rs

@@ -44,7 +44,16 @@ impl EditorTestUtils {
 				Err(e) => return Err(format!("update_node_graph_instrumented failed\n\n{e}")),
 			};
 
-			if let Err(e) = exector.submit_current_node_graph_evaluation(document, document_id, UVec2::ONE, 1., Default::default(), DVec2::ZERO) {
+			let document_network_hash = document.network_interface.network_hash();
+			if let Err(e) = exector.submit_current_node_graph_evaluation(
+				document,
+				document_id,
+				UVec2::ONE,
+				1.,
+				Default::default(),
+				DVec2::ZERO,
+				document_network_hash,
+			) {
 				return Err(format!("submit_current_node_graph_evaluation failed\n\n{e}"));
 			}
 			runtime.run().await;

node-graph/libraries/application-io/src/lib.rs

@@ -241,6 +241,9 @@ pub struct RenderConfig {
 	pub hide_artboards: bool,
 	pub for_export: bool,
 	pub for_eyedropper: bool,
+	/// Hash of the document network (inputs and topology). Drives viewport tile-cache invalidation when node data changes.
+	#[serde(default)]
+	pub document_network_hash: u64,
 }
 
 struct Logger;

node-graph/libraries/rendering/src/renderer.rs

@@ -172,6 +172,8 @@ pub struct RenderParams {
 	pub hide_artboards: bool,
 	/// Are we exporting
 	pub for_export: bool,
+	/// Sampling pixels for the eyedropper (distinct from main viewport cache identity).
+	pub for_eyedropper: bool,
 	/// Are we generating a mask in this render pass? Used to see if fill should be multiplied with alpha.
 	pub for_mask: bool,
 	/// Are we generating a mask for alignment? Used to prevent unnecessary transforms in masks
@@ -181,6 +183,8 @@ pub struct RenderParams {
 	pub artboard_background: Option<Color>,
 	/// Viewport zoom level (document-space scale). Used to compute constant viewport-pixel stroke widths in Outline mode.
 	pub viewport_zoom: f64,
+	/// Matches [`graphene_application_io::RenderConfig::document_network_hash`]. When it changes, tile caches must drop stale pixels.
+	pub document_network_hash: u64,
 }
 
 impl Hash for RenderParams {
@@ -191,6 +195,7 @@ impl Hash for RenderParams {
 		self.thumbnail.hash(state);
 		self.hide_artboards.hash(state);
 		self.for_export.hash(state);
+		self.for_eyedropper.hash(state);
 		self.for_mask.hash(state);
 		if let Some(x) = self.alignment_parent_transform {
 			x.to_cols_array().iter().for_each(|x| x.to_bits().hash(state))
@@ -199,6 +204,7 @@ impl Hash for RenderParams {
 		self.override_paint_order.hash(state);
 		self.artboard_background.hash(state);
 		self.viewport_zoom.to_bits().hash(state);
+		self.document_network_hash.hash(state);
 	}
 }
 

node-graph/nodes/gstd/src/render_cache.rs

@@ -43,13 +43,15 @@ pub struct CacheKey {
 	pub rotation: u64,
 	pub hide_artboards: bool,
 	pub for_export: bool,
+	pub for_eyedropper: bool,
 	pub for_mask: bool,
 	pub thumbnail: bool,
 	pub aligned_strokes: bool,
 	pub override_paint_order: bool,
 	pub animation_time_ms: i64,
 	pub real_time_ms: i64,
 	pub pointer: [u8; 16],
+	pub document_network_hash: u64,
 }
 
 impl CacheKey {
@@ -62,13 +64,15 @@ impl CacheKey {
 		rotation: f64,
 		hide_artboards: bool,
 		for_export: bool,
+		for_eyedropper: bool,
 		for_mask: bool,
 		thumbnail: bool,
 		aligned_strokes: bool,
 		override_paint_order: bool,
 		animation_time: f64,
 		real_time: f64,
 		pointer: Option<DVec2>,
+		document_network_hash: u64,
 	) -> Self {
 		let pointer_bytes = pointer
 			.map(|p| {
@@ -89,13 +93,15 @@ impl CacheKey {
 			rotation: quantized_rotation.to_bits(),
 			hide_artboards,
 			for_export,
+			for_eyedropper,
 			for_mask,
 			thumbnail,
 			aligned_strokes,
 			override_paint_order,
 			animation_time_ms: (animation_time * 1000.0).round() as i64,
 			real_time_ms: (real_time * 1000.0).round() as i64,
 			pointer: pointer_bytes,
+			document_network_hash,
 		}
 	}
 }
@@ -413,13 +419,15 @@ pub async fn render_output_cache<'a: 'n>(
 		rotation,
 		render_params.hide_artboards,
 		render_params.for_export,
+		render_params.for_eyedropper,
 		render_params.for_mask,
 		render_params.thumbnail,
 		render_params.aligned_strokes,
 		render_params.override_paint_order,
 		ctx.try_animation_time().unwrap_or(0.0),
 		ctx.try_real_time().unwrap_or(0.0),
 		ctx.try_pointer_position(),
+		render_params.document_network_hash,
 	);
 
 	let cache_query = tile_cache.query(&viewport_bounds_device, &cache_key, max_region_area);

node-graph/nodes/gstd/src/render_node.rs

@@ -105,10 +105,12 @@ async fn create_context<'a: 'n>(
 		render_mode: render_config.render_mode,
 		hide_artboards: render_config.hide_artboards,
 		for_export: render_config.for_export,
+		for_eyedropper: render_config.for_eyedropper,
 		render_output_type,
 		footprint: Footprint::default(),
 		scale: render_config.scale,
 		viewport_zoom: footprint.decompose_scale().x,
+		document_network_hash: render_config.document_network_hash,
 		..Default::default()
 	};
 

node-graph/nodes/raster/shaders/build.rs

@@ -5,6 +5,14 @@ use std::path::PathBuf;
 pub fn main() -> Result<(), Box<dyn std::error::Error>> {
 	env_logger::builder().filter_level(log::LevelFilter::Debug).init();
 
+	// This crate is often built for wasm32 via wasm-pack, which sets `CARGO_BUILD_TARGET`.
+	// cargo-gpu then spawns nested `cargo` to build `rustc_codegen_spirv` for the host; if that
+	// variable is inherited, the nested build targets wasm32 and fails with "cannot produce dylib".
+	// SAFETY: Build script is single-threaded.
+	unsafe {
+		std::env::remove_var("CARGO_BUILD_TARGET");
+	}
+
 	// Skip building the shaders if they are provided externally
 	println!("cargo:rerun-if-env-changed=RASTER_NODES_SHADER_PATH");
 	if !std::env::var("RASTER_NODES_SHADER_PATH").unwrap_or_default().is_empty() {