Fix warnings

Author: TrueDoctor

editor/src/dispatcher.rs

@@ -436,9 +436,9 @@ mod test {
 			// UNCOMMENT THIS FOR RUNNING UNDER MIRI
 			//
 			// let files = [
-			// 	include_str!("../../demo-artwork/isometric-fountain.graphite"),
-			// 	include_str!("../../demo-artwork/just-a-potted-cactus.graphite"),
-			// 	include_str!("../../demo-artwork/procedural-string-lights.graphite"),
+			// 	include_str!("../../demo-artwork/isometric-fountain.graphite").to_string(),
+			// 	include_str!("../../demo-artwork/just-a-potted-cactus.graphite").to_string(),
+			// 	include_str!("../../demo-artwork/procedural-string-lights.graphite").to_string(),
 			// 	include_str!("../../demo-artwork/red-dress.graphite"),
 			// 	include_str!("../../demo-artwork/valley-of-spires.graphite"),
 			// ];
@@ -456,14 +456,14 @@ mod test {
 
 				let responses = editor.handle_message(PortfolioMessage::OpenDocumentFile {
 					document_name: document_name.into(),
-					document_serialized_content: document_serialized_content.into(),
+					document_serialized_content,
 				});
 
 				// Check if the graph renders
 				let portfolio = &mut editor.dispatcher.message_handlers.portfolio_message_handler;
 				portfolio
 					.executor
-					.submit_node_graph_evaluation(portfolio.documents.get_mut(&portfolio.active_document_id.unwrap()).unwrap(), glam::UVec2::ONE)
+					.submit_node_graph_evaluation(portfolio.documents.get_mut(&portfolio.active_document_id.unwrap()).unwrap(), glam::UVec2::ONE, true)
 					.expect("submit_node_graph_evaluation failed");
 				crate::node_graph_executor::run_node_graph().await;
 				let mut messages = VecDeque::new();

editor/src/messages/portfolio/document/node_graph/document_node_types.rs

@@ -6,8 +6,6 @@ use crate::messages::portfolio::utility_types::PersistentData;
 use crate::messages::prelude::Message;
 use crate::node_graph_executor::NodeGraphExecutor;
 
-#[cfg(feature = "gpu")]
-use gpu_executor::*;
 use graph_craft::concrete;
 use graph_craft::document::value::*;
 use graph_craft::document::*;

editor/src/messages/portfolio/portfolio_message_handler.rs

@@ -289,7 +289,7 @@ impl MessageHandler<PortfolioMessage, PortfolioMessageData<'_>> for PortfolioMes
 				self.executor.update_font_cache(self.persistent_data.font_cache.clone());
 				for document_id in self.document_ids.iter() {
 					let _ = self.executor.submit_node_graph_evaluation(
-						self.documents.get_mut(&document_id).expect("Tried to render no existent Document"),
+						self.documents.get_mut(document_id).expect("Tried to render no existent Document"),
 						ipp.viewport_bounds.size().as_uvec2(),
 						true,
 					);

editor/src/node_graph_executor.rs

@@ -25,9 +25,6 @@ use interpreted_executor::dynamic_executor::{DynamicExecutor, ResolvedDocumentNo
 
 use glam::{DAffine2, DVec2, UVec2};
 use std::cell::RefCell;
-use std::collections::hash_map::DefaultHasher;
-use std::hash::Hash;
-use std::hash::Hasher;
 use std::rc::Rc;
 use std::sync::mpsc::{Receiver, Sender};
 use std::sync::Arc;
@@ -43,8 +40,6 @@ pub struct NodeRuntime {
 	recompile_graph: bool,
 
 	editor_api: Arc<WasmEditorApi>,
-
-	graph_hash: Option<u64>,
 	node_graph_errors: GraphErrors,
 	resolved_types: ResolvedDocumentNodeTypes,
 	monitor_nodes: Vec<Vec<NodeId>>,
@@ -92,7 +87,7 @@ pub struct ExecutionResponse {
 	new_upstream_transforms: HashMap<NodeId, (Footprint, DAffine2)>,
 	transform: DAffine2,
 }
-pub(crate) struct CompilationResponse {
+pub struct CompilationResponse {
 	result: Result<(), String>,
 	resolved_types: ResolvedDocumentNodeTypes,
 	node_graph_errors: GraphErrors,
@@ -144,7 +139,6 @@ impl NodeRuntime {
 			}
 			.into(),
 
-			graph_hash: None,
 			node_graph_errors: Vec::new(),
 			resolved_types: ResolvedDocumentNodeTypes::default(),
 			monitor_nodes: Vec::new(),

node-graph/gcore/src/application_io.rs

@@ -5,7 +5,7 @@ use crate::vector::style::ViewMode;
 use dyn_any::{DynAny, StaticType, StaticTypeSized};
 
 use alloc::sync::Arc;
-use core::fmt::{Debug, Write};
+use core::fmt::Debug;
 use core::future::Future;
 use core::hash::{Hash, Hasher};
 use core::pin::Pin;

node-graph/gcore/src/graphic_element.rs

@@ -1,11 +1,10 @@
-use crate::application_io::{SurfaceHandle, SurfaceHandleFrame};
+use crate::application_io::SurfaceHandleFrame;
 use crate::raster::{BlendMode, ImageFrame};
 use crate::renderer::GraphicElementRendered;
 use crate::transform::Footprint;
 use crate::vector::VectorData;
 use crate::{Color, Node, SurfaceFrame};
 
-use bezier_rs::BezierHandles;
 use dyn_any::{DynAny, StaticType};
 use node_macro::node_fn;
 use web_sys::HtmlCanvasElement;
@@ -328,15 +327,3 @@ impl GraphicGroup {
 		tree
 	}
 }
-
-impl<'a> Into<&'a dyn GraphicElementRendered> for &'a GraphicElement {
-	fn into(self) -> &'a dyn GraphicElementRendered {
-		match self {
-			GraphicElement::VectorData(vector_data) => vector_data.as_ref(),
-			GraphicElement::ImageFrame(image_frame) => image_frame,
-			GraphicElement::GraphicGroup(graphic_group) => graphic_group,
-			GraphicElement::Artboard(artboard) => artboard,
-			GraphicElement::Surface(surface) => surface,
-		}
-	}
-}

node-graph/gcore/src/graphic_element/renderer.rs

@@ -1,7 +1,5 @@
 mod quad;
 
-use core::ops::Deref;
-
 use crate::raster::bbox::Bbox;
 use crate::raster::{BlendMode, Image, ImageFrame};
 use crate::transform::Transform;

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

@@ -337,7 +337,7 @@ impl HandleId {
 }
 
 #[cfg(test)]
-fn assert_subpath_eq(generated: &Vec<bezier_rs::Subpath<PointId>>, expected: &[bezier_rs::Subpath<PointId>]) {
+fn assert_subpath_eq(generated: &[bezier_rs::Subpath<PointId>], expected: &[bezier_rs::Subpath<PointId>]) {
 	assert_eq!(generated.len(), expected.len());
 	for (generated, expected) in generated.iter().zip(expected) {
 		assert_eq!(generated.manipulator_groups().len(), expected.manipulator_groups().len());

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

@@ -443,7 +443,7 @@ fn modify_existing() {
 			false,
 		),
 	];
-	let mut vector_data = VectorData::from_subpaths(&subpaths, false);
+	let mut vector_data = VectorData::from_subpaths(subpaths, false);
 
 	let mut modify_new = VectorModification::create_from_vector(&vector_data);
 	let mut modify_original = VectorModification::default();

node-graph/graph-craft/Cargo.toml

@@ -8,7 +8,7 @@ license = "MIT OR Apache-2.0"
 default = ["dealloc_nodes"]
 serde = ["dep:serde", "graphene-core/serde", "glam/serde", "bezier-rs/serde"]
 dealloc_nodes = []
-wgpu = ["wgpu-executor"]
+wgpu = []
 
 [dependencies]
 # Local dependencies
@@ -32,7 +32,7 @@ url = { workspace = true }
 reqwest = { workspace = true }
 
 # Optional workspace dependencies
-wgpu-executor = { workspace = true, optional = true }
+wgpu-executor = { workspace = true }
 serde = { workspace = true, optional = true }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]

node-graph/graph-craft/src/wasm_application_io.rs

@@ -12,8 +12,8 @@ use std::pin::Pin;
 #[cfg(target_arch = "wasm32")]
 use std::sync::atomic::AtomicU64;
 use std::sync::Arc;
-#[cfg(not(target_arch = "wasm32"))]
-use std::sync::Mutex;
+// #[cfg(not(target_arch = "wasm32"))]
+// use std::sync::Mutex;
 #[cfg(feature = "tokio")]
 use tokio::io::AsyncReadExt;
 #[cfg(target_arch = "wasm32")]

node-graph/gstd/src/gpu_nodes.rs

@@ -11,7 +11,7 @@ use graphene_core::*;
 use wgpu_executor::Shader;
 use wgpu_executor::WgpuExecutor;
 use wgpu_executor::WgpuShaderInput;
-use wgpu_executor::{Bindgroup, GpuExecutor, PipelineLayout, ShaderIO, ShaderInput};
+use wgpu_executor::{Bindgroup, PipelineLayout, ShaderIO, ShaderInput};
 
 #[cfg(feature = "quantization")]
 use graphene_core::quantization::PackedPixel;

node-graph/gstd/src/vector.rs

@@ -1,7 +1,6 @@
 use crate::Node;
 
 use bezier_rs::{ManipulatorGroup, Subpath};
-use graphene_core::raster::ImageFrame;
 use graphene_core::transform::Transform;
 pub use graphene_core::vector::*;
 use graphene_core::Color;

node-graph/gstd/src/wasm_application_io.rs

@@ -1,4 +1,6 @@
-use graphene_core::application_io::{ApplicationIo, ExportFormat, RenderConfig, SurfaceHandle, SurfaceHandleFrame};
+#[cfg(all(any(feature = "resvg", feature = "vello"), target_arch = "wasm32"))]
+use graphene_core::application_io::SurfaceHandleFrame;
+use graphene_core::application_io::{ApplicationIo, ExportFormat, RenderConfig, SurfaceHandle};
 use graphene_core::raster::bbox::Bbox;
 use graphene_core::raster::Image;
 use graphene_core::raster::ImageFrame;
@@ -9,12 +11,11 @@ use graphene_core::Node;
 
 use base64::Engine;
 use glam::DAffine2;
-use wgpu_executor::WgpuSurface;
 
 use core::future::Future;
 use std::marker::PhantomData;
 use std::sync::Arc;
-use wasm_bindgen::{Clamped, JsCast};
+use wasm_bindgen::JsCast;
 use web_sys::{CanvasRenderingContext2d, HtmlCanvasElement};
 
 pub use graph_craft::wasm_application_io::*;
@@ -26,6 +27,7 @@ async fn create_surface_node<'a: 'input>(editor: &'a WasmEditorApi) -> WasmSurfa
 	editor.application_io.as_ref().unwrap().create_surface()
 }
 
+#[cfg(target_arch = "wasm32")]
 pub struct DrawImageFrameNode<Surface> {
 	surface_handle: Surface,
 }

node-graph/interpreted-executor/src/node_registry.rs

@@ -10,11 +10,11 @@ use graphene_core::transform::Footprint;
 use graphene_core::value::{ClonedNode, CopiedNode, ValueNode};
 use graphene_core::vector::brush_stroke::BrushStroke;
 use graphene_core::vector::VectorData;
-use graphene_core::{application_io::SurfaceHandle, SurfaceFrame, WasmSurfaceHandleFrame};
 use graphene_core::{concrete, generic, Artboard, ArtboardGroup, GraphicGroup};
 use graphene_core::{fn_type, raster::*};
 use graphene_core::{Cow, ProtoNodeIdentifier, Type};
 use graphene_core::{Node, NodeIO, NodeIOTypes};
+use graphene_core::{SurfaceFrame, WasmSurfaceHandleFrame};
 use graphene_std::any::{ComposeTypeErased, DowncastBothNode, DynAnyNode, FutureWrapperNode, IntoTypeErasedNode};
 use graphene_std::application_io::RenderConfig;
 use graphene_std::wasm_application_io::*;
@@ -25,7 +25,7 @@ use graphene_std::wasm_application_io::WasmEditorApi;
 use wgpu_executor::WgpuExecutor;
 use wgpu_executor::WindowHandle;
 #[cfg(feature = "gpu")]
-use wgpu_executor::{CommandBuffer, GpuExecutor, ShaderHandle, ShaderInput, ShaderInputFrame, WgpuShaderInput};
+use wgpu_executor::{CommandBuffer, ShaderHandle, ShaderInputFrame, WgpuShaderInput};
 
 use dyn_any::StaticType;
 use glam::{DAffine2, DVec2, UVec2};

node-graph/wgpu-executor/src/lib.rs

@@ -2,7 +2,7 @@ mod context;
 mod executor;
 
 pub use context::Context;
-use dyn_any::{DynAny, StaticType, StaticTypeSized};
+use dyn_any::{DynAny, StaticType};
 pub use executor::GpuExecutor;
 use glam::DAffine2;
 use gpu_executor::{ComputePassDimensions, GPUConstant, StorageBufferOptions, TextureBufferOptions, TextureBufferType, ToStorageBuffer, ToUniformBuffer};
@@ -12,9 +12,11 @@ use anyhow::{bail, Result};
 use futures::Future;
 use graphene_core::application_io::{ApplicationIo, EditorApi, SurfaceHandle};
 use graphene_core::raster::color::RGBA16F;
-use graphene_core::raster::{Image, ImageFrame, Pixel, SRGBA8};
+use graphene_core::raster::{Image, ImageFrame};
 use graphene_core::transform::{Footprint, Transform};
-use graphene_core::{Color, Cow, Node, SurfaceFrame, WasmSurfaceHandle};
+#[cfg(target_arch = "wasm32")]
+use graphene_core::WasmSurfaceHandle;
+use graphene_core::{Color, Cow, Node, SurfaceFrame};
 
 use std::pin::Pin;
 use std::sync::Arc;
@@ -294,7 +296,7 @@ impl WgpuExecutor {
 		Ok(CommandBuffer(encoder.finish()))
 	}
 
-	pub fn create_render_pass(&self, footprint: Footprint, texture: ShaderInputFrame, canvas: Arc<SurfaceHandle<Surface>>) -> Result<()> {
+	pub fn create_render_pass(&self, _footprint: Footprint, texture: ShaderInputFrame, canvas: Arc<SurfaceHandle<Surface>>) -> Result<()> {
 		let transform = texture.transform;
 		let texture = texture.shader_input;
 		let texture = texture.texture().expect("Expected texture input");
@@ -312,7 +314,7 @@ impl WgpuExecutor {
 		// TODO:
 		let resolution = transform.decompose_scale().as_uvec2();
 		let surface_format = wgpu::TextureFormat::Bgra8Unorm;
-		let config = wgpu::SurfaceConfiguration {
+		let config = SurfaceConfiguration {
 			usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
 			format: surface_format,
 			width: resolution.x,
@@ -448,7 +450,7 @@ impl WgpuExecutor {
 		})
 	}
 
-	fn create_texture_view(&self, texture: WgpuShaderInput) -> Result<WgpuShaderInput> {
+	pub fn create_texture_view(&self, texture: WgpuShaderInput) -> Result<WgpuShaderInput> {
 		// Ok(ShaderInput::TextureView(texture.create_view(&wgpu::TextureViewDescriptor::default()), ) )
 		let ShaderInput::TextureBuffer(texture, ty) = &texture else {
 			bail!("Tried to create a texture view from a non texture");
@@ -488,7 +490,7 @@ impl WgpuExecutor {
 		let surface_caps = surface.get_capabilities(&self.context.adapter);
 		println!("{surface_caps:?}");
 		let surface_format = wgpu::TextureFormat::Rgba16Float;
-		let config = wgpu::SurfaceConfiguration {
+		let _config = wgpu::SurfaceConfiguration {
 			usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
 			format: surface_format,
 			width: size.width,
@@ -896,7 +898,7 @@ async fn render_texture_node<'a: 'input, InFut: Future<Output = ShaderInputFrame
 ) -> SurfaceFrame {
 	let surface_id = surface.surface_id;
 	let image = self.image.eval(footprint).await;
-	let transform = image.transform.clone();
+	let transform = image.transform;
 
 	executor.create_render_pass(footprint, image, surface).unwrap();