Cleanup texture upload / download

TrueDoctor · TrueDoctor · commit 490e2912b053 · 2025-09-25T09:48:40.000+02:00
diff --git a/node-graph/interpreted-executor/src/node_registry.rs b/node-graph/interpreted-executor/src/node_registry.rs
@@ -61,6 +61,10 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 		convert_node!(from: DVec2, to: String),
 		convert_node!(from: IVec2, to: String),
 		convert_node!(from: DAffine2, to: String),
+		convert_node!(from: Table<Raster<CPU>>, to: Table<Raster<CPU>>, converter: &WgpuExecutor),
+		convert_node!(from: Table<Raster<CPU>>, to: Table<Raster<GPU>>, converter: &WgpuExecutor),
+		convert_node!(from: Table<Raster<GPU>>, to: Table<Raster<GPU>>, converter: &WgpuExecutor),
+		convert_node!(from: Table<Raster<GPU>>, to: Table<Raster<CPU>>, converter: &WgpuExecutor),
 		// =============
 		// MONITOR NODES
 		// =============
@@ -401,9 +405,10 @@ mod node_registry_macros {
 				ProtoNodeIdentifier::new(concat!["graphene_core::ops::ConvertNode<", stringify!($to), ">"]),
 				|mut args| {
 					Box::pin(async move {
+						let mut args = args.drain(..);
 						let node = graphene_core::ops::ConvertNode::new(
-							graphene_std::any::downcast_node::<Context, $from>(args.pop().expect("Construct node did not get first argument")),
-							graphene_std::any::downcast_node::<Context, $convert>(args.pop().expect("Convert node did not get converter argument")),
+							graphene_std::any::downcast_node::<Context, $from>(args.next().expect("Convert node did not get first argument")),
+							graphene_std::any::downcast_node::<Context, $convert>(args.next().expect("Convert node did not get converter argument")),
 							graphene_std::any::FutureWrapperNode::new(graphene_std::value::ClonedNode::new(std::marker::PhantomData::<$to>))
 						);
 						let any: DynAnyNode<Context, $to, _> = graphene_std::any::DynAnyNode::new(node);
diff --git a/node-graph/preprocessor/src/lib.rs b/node-graph/preprocessor/src/lib.rs
@@ -67,6 +67,7 @@ pub fn generate_node_substitutions() -> HashMap<ProtoNodeIdentifier, DocumentNod
 						1 => {
 							let input = inputs.iter().next().unwrap();
 							let input_ty = input.nested_type();
+							let mut inputs = vec![NodeInput::import(input.clone(), i)];
 
 							let into_node_identifier = ProtoNodeIdentifier {
 								name: format!("graphene_core::ops::IntoNode<{}>", input_ty.clone()).into(),
@@ -80,13 +81,14 @@ pub fn generate_node_substitutions() -> HashMap<ProtoNodeIdentifier, DocumentNod
 								into_node_identifier
 							} else if into_node_registry.keys().any(|ident| ident.name.as_ref() == convert_node_identifier.name.as_ref()) {
 								generated_nodes += 1;
+								inputs.push(NodeInput::value(TaggedValue::None, false));
 								convert_node_identifier
 							} else {
 								identity_node.clone()
 							};
 
 							DocumentNode {
-								inputs: vec![NodeInput::import(input.clone(), i)],
+								inputs,
 								implementation: DocumentNodeImplementation::ProtoNode(proto_node),
 								visible: true,
 								..Default::default()
diff --git a/node-graph/wgpu-executor/src/texture_upload.rs b/node-graph/wgpu-executor/src/texture_upload.rs
@@ -10,11 +10,84 @@ use graphene_core::transform::Footprint;
 use wgpu::util::{DeviceExt, TextureDataOrder};
 use wgpu::{Extent3d, TextureDescriptor, TextureDimension, TextureFormat, TextureUsages};
 
+/// Uploads CPU image data to a GPU texture
+///
+/// Creates a new WGPU texture with RGBA8UnormSrgb format and uploads the provided
+/// image data. The texture is configured for binding, copying, and source operations.
+fn upload_to_texture(device: &std::sync::Arc<wgpu::Device>, queue: &std::sync::Arc<wgpu::Queue>, image: &Raster<CPU>) -> wgpu::Texture {
+	let rgba8_data: Vec<SRGBA8> = image.data.iter().map(|x| (*x).into()).collect();
+
+	device.create_texture_with_data(
+		queue,
+		&TextureDescriptor {
+			label: Some("upload_texture node texture"),
+			size: Extent3d {
+				width: image.width,
+				height: image.height,
+				depth_or_array_layers: 1,
+			},
+			mip_level_count: 1,
+			sample_count: 1,
+			dimension: TextureDimension::D2,
+			format: TextureFormat::Rgba8UnormSrgb,
+			usage: TextureUsages::TEXTURE_BINDING | TextureUsages::COPY_DST | TextureUsages::COPY_SRC,
+			view_formats: &[],
+		},
+		TextureDataOrder::LayerMajor,
+		bytemuck::cast_slice(rgba8_data.as_slice()),
+	)
+}
+
+/// Downloads GPU texture data to a CPU buffer
+///
+/// Creates a buffer and adds a copy operation from the texture to the buffer
+/// using the provided command encoder. Returns dimensions and the buffer for
+/// later mapping and data extraction.
+fn download_to_buffer(device: &std::sync::Arc<wgpu::Device>, encoder: &mut wgpu::CommandEncoder, texture: &wgpu::Texture) -> (u32, u32, wgpu::Buffer) {
+	let width = texture.width();
+	let height = texture.height();
+	let bytes_per_pixel = 4; // RGBA8
+	let buffer_size = (width * height * bytes_per_pixel) as u64;
+
+	let output_buffer = device.create_buffer(&wgpu::BufferDescriptor {
+		label: Some("texture_download_buffer"),
+		size: buffer_size,
+		usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
+		mapped_at_creation: false,
+	});
+
+	encoder.copy_texture_to_buffer(
+		wgpu::TexelCopyTextureInfo {
+			texture,
+			mip_level: 0,
+			origin: wgpu::Origin3d::ZERO,
+			aspect: wgpu::TextureAspect::All,
+		},
+		wgpu::TexelCopyBufferInfo {
+			buffer: &output_buffer,
+			layout: wgpu::TexelCopyBufferLayout {
+				offset: 0,
+				bytes_per_row: Some(width * bytes_per_pixel),
+				rows_per_image: Some(height),
+			},
+		},
+		Extent3d {
+			width,
+			height,
+			depth_or_array_layers: 1,
+		},
+	);
+	(width, height, output_buffer)
+}
+
+/// Passthrough conversion for GPU tables - no conversion needed
 impl<'i> Convert<Table<Raster<GPU>>, &'i WgpuExecutor> for Table<Raster<GPU>> {
 	async fn convert(self, _: Footprint, _converter: &'i WgpuExecutor) -> Table<Raster<GPU>> {
 		self
 	}
 }
+
+/// Converts CPU raster table to GPU by uploading each image to a texture
 impl<'i> Convert<Table<Raster<GPU>>, &'i WgpuExecutor> for Table<Raster<CPU>> {
 	async fn convert(self, _: Footprint, executor: &'i WgpuExecutor) -> Table<Raster<GPU>> {
 		let device = &executor.context.device;
@@ -23,28 +96,7 @@ impl<'i> Convert<Table<Raster<GPU>>, &'i WgpuExecutor> for Table<Raster<CPU>> {
 			.iter()
 			.map(|row| {
 				let image = row.element;
-				let rgba8_data: Vec<SRGBA8> = image.data.iter().map(|x| (*x).into()).collect();
-
-				let texture = device.create_texture_with_data(
-					queue,
-					&TextureDescriptor {
-						label: Some("upload_texture node texture"),
-						size: Extent3d {
-							width: image.width,
-							height: image.height,
-							depth_or_array_layers: 1,
-						},
-						mip_level_count: 1,
-						sample_count: 1,
-						dimension: TextureDimension::D2,
-						format: TextureFormat::Rgba8UnormSrgb,
-						// I don't know what usages are actually necessary
-						usage: TextureUsages::TEXTURE_BINDING | TextureUsages::COPY_DST | TextureUsages::COPY_SRC,
-						view_formats: &[],
-					},
-					TextureDataOrder::LayerMajor,
-					bytemuck::cast_slice(rgba8_data.as_slice()),
-				);
+				let texture = upload_to_texture(device, queue, image);
 
 				TableRow {
 					element: Raster::new_gpu(texture),
@@ -59,72 +111,51 @@ impl<'i> Convert<Table<Raster<GPU>>, &'i WgpuExecutor> for Table<Raster<CPU>> {
 		table
 	}
 }
+
+/// Converts single CPU raster to GPU by uploading to texture
+impl<'i> Convert<Raster<GPU>, &'i WgpuExecutor> for Raster<CPU> {
+	async fn convert(self, _: Footprint, executor: &'i WgpuExecutor) -> Raster<GPU> {
+		let device = &executor.context.device;
+		let queue = &executor.context.queue;
+		let texture = upload_to_texture(device, queue, &self);
+
+		queue.submit([]);
+		Raster::new_gpu(texture)
+	}
+}
+
+/// Passthrough conversion for CPU tables - no conversion needed
 impl<'i> Convert<Table<Raster<CPU>>, &'i WgpuExecutor> for Table<Raster<CPU>> {
 	async fn convert(self, _: Footprint, _converter: &'i WgpuExecutor) -> Table<Raster<CPU>> {
 		self
 	}
 }
+
+/// Converts GPU raster table to CPU by downloading texture data in one go
+///
+/// then asynchronously maps all buffers and processes the results.
 impl<'i> Convert<Table<Raster<CPU>>, &'i WgpuExecutor> for Table<Raster<GPU>> {
 	async fn convert(self, _: Footprint, executor: &'i WgpuExecutor) -> Table<Raster<CPU>> {
 		let device = &executor.context.device;
 		let queue = &executor.context.queue;
 
-		// Create a single command encoder for all copy operations
 		let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
 			label: Some("batch_texture_download_encoder"),
 		});
 
-		// Collect all buffer and texture info for batch processing
 		let mut buffers_and_info = Vec::new();
 
 		for row in self.iter() {
 			let gpu_raster = row.element;
 			let texture = gpu_raster.data();
 
-			// Get texture dimensions
-			let width = texture.width();
-			let height = texture.height();
-			let bytes_per_pixel = 4; // RGBA8
-			let buffer_size = (width * height * bytes_per_pixel) as u64;
-
-			// Create a buffer to copy texture data to
-			let output_buffer = device.create_buffer(&wgpu::BufferDescriptor {
-				label: Some("texture_download_buffer"),
-				size: buffer_size,
-				usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
-				mapped_at_creation: false,
-			});
-
-			// Add copy operation to the batch encoder
-			encoder.copy_texture_to_buffer(
-				wgpu::TexelCopyTextureInfo {
-					texture,
-					mip_level: 0,
-					origin: wgpu::Origin3d::ZERO,
-					aspect: wgpu::TextureAspect::All,
-				},
-				wgpu::TexelCopyBufferInfo {
-					buffer: &output_buffer,
-					layout: wgpu::TexelCopyBufferLayout {
-						offset: 0,
-						bytes_per_row: Some(width * bytes_per_pixel),
-						rows_per_image: Some(height),
-					},
-				},
-				Extent3d {
-					width,
-					height,
-					depth_or_array_layers: 1,
-				},
-			);
+			let (width, height, output_buffer) = download_to_buffer(device, &mut encoder, texture);
 
 			buffers_and_info.push((output_buffer, width, height, *row.transform, *row.alpha_blending, *row.source_node_id));
 		}
 
-		// Submit all copy operations in a single batch
 		queue.submit([encoder.finish()]);
 
-		// Now async map all buffers and collect futures
 		let mut map_futures = Vec::new();
 		for (buffer, _width, _height, _transform, _alpha_blending, _source_node_id) in &buffers_and_info {
 			let buffer_slice = buffer.slice(..);
@@ -135,25 +166,19 @@ impl<'i> Convert<Table<Raster<CPU>>, &'i WgpuExecutor> for Table<Raster<GPU>> {
 			map_futures.push(receiver);
 		}
 
-		// Wait for all mapping operations to complete
-		let map_results = futures::future::try_join_all(map_futures).await.map_err(|_| "Failed to receive map result").unwrap();
+		let map_results = futures::future::try_join_all(map_futures)
+			.await
+			.map_err(|_| "Failed to receive map result")
+			.expect("Buffer mapping communication failed");
 
-		// Process all mapped buffers
 		let mut table = Vec::new();
 		for (i, (buffer, width, height, transform, alpha_blending, source_node_id)) in buffers_and_info.into_iter().enumerate() {
 			if let Err(e) = &map_results[i] {
-				panic!("Buffer mapping failed: {:?}", e);
+				panic!("Buffer mapping failed: {e:?}");
 			}
 
 			let data = buffer.slice(..).get_mapped_range();
-			// Convert bytes directly to Color via SRGBA8
-			let cpu_data: Vec<Color> = data
-				.chunks_exact(4)
-				.map(|chunk| {
-					// Create SRGBA8 from bytes, then convert to Color
-					Color::from_rgba8_srgb(chunk[0], chunk[1], chunk[2], chunk[3])
-				})
-				.collect();
+			let cpu_data: Vec<Color> = data.chunks_exact(4).map(|chunk| Color::from_rgba8_srgb(chunk[0], chunk[1], chunk[2], chunk[3])).collect();
 
 			drop(data);
 			buffer.unmap();
@@ -177,6 +202,51 @@ impl<'i> Convert<Table<Raster<CPU>>, &'i WgpuExecutor> for Table<Raster<GPU>> {
 	}
 }
 
+/// Converts single GPU raster to CPU by downloading texture data
+impl<'i> Convert<Raster<CPU>, &'i WgpuExecutor> for Raster<GPU> {
+	async fn convert(self, _: Footprint, executor: &'i WgpuExecutor) -> Raster<CPU> {
+		let device = &executor.context.device;
+		let queue = &executor.context.queue;
+
+		let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
+			label: Some("single_texture_download_encoder"),
+		});
+
+		let gpu_raster = &self;
+		let texture = gpu_raster.data();
+
+		let (width, height, output_buffer) = download_to_buffer(device, &mut encoder, texture);
+
+		queue.submit([encoder.finish()]);
+
+		let buffer_slice = output_buffer.slice(..);
+		let (sender, receiver) = futures::channel::oneshot::channel();
+		buffer_slice.map_async(wgpu::MapMode::Read, move |result| {
+			let _ = sender.send(result);
+		});
+		receiver.await.expect("Failed to receive map result").expect("Buffer mapping failed");
+
+		let data = output_buffer.slice(..).get_mapped_range();
+		let cpu_data: Vec<Color> = data.chunks_exact(4).map(|chunk| Color::from_rgba8_srgb(chunk[0], chunk[1], chunk[2], chunk[3])).collect();
+
+		drop(data);
+		output_buffer.unmap();
+		let cpu_image = Image {
+			data: cpu_data,
+			width,
+			height,
+			base64_string: None,
+		};
+
+		Raster::new_cpu(cpu_image)
+	}
+}
+
+/// Node for uploading textures from CPU to GPU. This Is now deprecated and
+/// we should use the Convert node in the future.
+///
+/// Accepts either individual rasters or tables of rasters and converts them
+/// to GPU format using the WgpuExecutor's device and queue.
 #[node_macro::node(category(""))]
 pub async fn upload_texture<'a: 'n, T: Convert<Table<Raster<GPU>>, &'a WgpuExecutor>>(
 	_: impl Ctx,
