Wake up

It looks bad either way

src/fill.wgsl

@@ -1,27 +0,0 @@
-const SEED = 0x4ae95672u;
-
-struct Varying {
-        @builtin(position) screen: vec4f,
-}
-
-@vertex
-fn on_vertex(@builtin(vertex_index) vi: u32) -> Varying {
-	let uv = vec2f(vec2(vi, vi >> 1u) & vec2(1u));
-	let screen = vec4(uv * 2. - 1., 0., 1.);
-	return Varying(screen);
-}
-
-@fragment
-fn on_fragment(in: Varying) -> @location(0) u32 {
-	let x = bitcast<u32>(in.screen.x);
-	let y = bitcast<u32>(in.screen.y);
-	let rand = hash(hash(hash(SEED) ^ hash(x)) ^ hash(y));
-	return rand >> 31;
-}
-
-fn hash(key : u32) -> u32 {
-        var v = key;
-        v *= 0xb384af1bu;
-        v ^= v >> 15u;
-        return v;
-}

src/mailbox.rs

@@ -0,0 +1,135 @@
+use std::{
+	future::Future,
+	pin::Pin,
+	sync::{Mutex, MutexGuard},
+	task::{Context, Poll, Waker},
+};
+
+pub struct Mailbox<T>(Mutex<MailboxInner<T>>);
+
+impl<T> Mailbox<T> {
+	pub fn new() -> Self {
+		Mailbox(Mutex::new(MailboxInner {
+			waker: None,
+			value: None,
+		}))
+	}
+}
+
+struct MailboxInner<T> {
+	waker: Option<Waker>,
+	value: Option<T>,
+}
+
+fn wake<T>(mut mb: MutexGuard<MailboxInner<T>>) {
+	let waker = mb.waker.take();
+	drop(mb);
+	if let Some(waker) = waker {
+		waker.wake();
+	}
+}
+
+struct MailboxPut<'a, T>(&'a Mailbox<T>, Option<T>);
+impl<'a, T> Unpin for MailboxPut<'a, T> {}
+impl<'a, T> Future for MailboxPut<'a, T> {
+	type Output = ();
+
+	fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+		let mut mb = self.0 .0.lock().unwrap();
+		let None = mb.value else {
+			mb.waker = Some(cx.waker().clone());
+			return Poll::Pending;
+		};
+		mb.value = self.1.take();
+		wake(mb);
+		Poll::Ready(())
+	}
+}
+
+struct MailboxGet<'a, T>(&'a Mailbox<T>);
+impl<'a, T> Future for MailboxGet<'a, T> {
+	type Output = T;
+
+	fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+		let mut mb = self.0 .0.lock().unwrap();
+		let Some(value) = mb.value.take() else {
+			mb.waker = Some(cx.waker().clone());
+			return Poll::Pending;
+		};
+		wake(mb);
+		Poll::Ready(value)
+	}
+}
+
+impl<T> Mailbox<T> {
+	pub fn put(&self, value: T) -> impl Future<Output = ()> + '_ {
+		MailboxPut(&self, Some(value))
+	}
+
+	pub fn get(&self) -> impl Future<Output = T> + '_ {
+		MailboxGet(&self)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use std::{pin::pin, sync::Arc, task::Wake};
+
+	use super::*;
+
+	struct NoopWaker;
+	impl Wake for NoopWaker {
+		fn wake(self: std::sync::Arc<Self>) {}
+	}
+
+	fn ready(f: impl Future) -> bool {
+		let f = pin!(f);
+		matches!(
+			f.poll(&mut Context::from_waker(&Arc::new(NoopWaker).into())),
+			Poll::Ready(_)
+		)
+	}
+
+	#[test]
+	fn test_mailbox_empty() {
+		let mb = Mailbox::<i32>::new();
+		assert!(!ready(mb.get()));
+	}
+
+	#[test]
+	fn test_mailbox_once() {
+		let mb = Mailbox::<i32>::new();
+		pollster::block_on(mb.put(42));
+		assert_eq!(pollster::block_on(mb.get()), 42);
+		assert!(!ready(mb.get()));
+	}
+
+	#[test]
+	fn test_mailbox_once_oor() {
+		let mb = Mailbox::<i32>::new();
+		let f = mb.get();
+		pollster::block_on(mb.put(42));
+		assert_eq!(pollster::block_on(f), 42);
+	}
+
+	#[test]
+	fn test_mailbox_twice_no_wait() {
+		let mb = Mailbox::<i32>::new();
+		pollster::block_on(mb.put(42));
+		assert!(!ready(mb.put(13)));
+		assert_eq!(pollster::block_on(mb.get()), 42);
+		assert!(!ready(mb.get()));
+	}
+
+	#[test]
+	fn test_mailbox_twice_in_order() {
+		let mb = Mailbox::<i32>::new();
+		let f = mb.get();
+		pollster::block_on(mb.put(42));
+		assert_eq!(pollster::block_on(f), 42);
+		let f = mb.get();
+		pollster::block_on(mb.put(13));
+		assert_eq!(pollster::block_on(f), 13);
+		assert!(!ready(mb.get()));
+	}
+}

src/main.rs

@@ -1,16 +1,12 @@
 use std::error::Error;
 
-use glam::uvec2;
 use winit::{
 	event::{Event, WindowEvent},
 	event_loop::EventLoop,
 	window::{Window, WindowAttributes},
 };
 
-struct GameState {
+mod mailbox;
-	last: wgpu::TextureView,
-	next: wgpu::TextureView,
-}
 
 fn main() {
 	let event_loop = EventLoop::new().unwrap();
@@ -21,189 +17,38 @@ fn main() {
 		.unwrap();
 
 	let (device, queue, surface) = pollster::block_on(init_gpu(window)).unwrap();
+
 	let format = wgpu::TextureFormat::Bgra8UnormSrgb;
-
+	let mut surface_configured = false;
-	let fill_shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
-		label: Some("fill"),
-		source: wgpu::ShaderSource::Wgsl(include_str!("fill.wgsl").into()),
-	});
-	let fill_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
-		label: None,
-		layout: None,
-		vertex: wgpu::VertexState {
-			module: &fill_shader,
-			entry_point: None,
-			compilation_options: wgpu::PipelineCompilationOptions::default(),
-			buffers: &[],
-		},
-		primitive: wgpu::PrimitiveState {
-			topology: wgpu::PrimitiveTopology::TriangleStrip,
-			..Default::default()
-		},
-		depth_stencil: None,
-		multisample: wgpu::MultisampleState::default(),
-		fragment: Some(wgpu::FragmentState {
-			module: &fill_shader,
-			entry_point: None,
-			compilation_options: wgpu::PipelineCompilationOptions::default(),
-			targets: &[Some(wgpu::ColorTargetState {
-				format: wgpu::TextureFormat::R8Uint,
-				blend: None,
-				write_mask: wgpu::ColorWrites::ALL,
-			})],
-		}),
-		multiview: None,
-		cache: None,
-	});
-
-	let step_shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
-		label: Some("step"),
-		source: wgpu::ShaderSource::Wgsl(include_str!("step.wgsl").into()),
-	});
-	let step_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
-		label: None,
-		layout: None,
-		vertex: wgpu::VertexState {
-			module: &step_shader,
-			entry_point: None,
-			compilation_options: wgpu::PipelineCompilationOptions::default(),
-			buffers: &[],
-		},
-		primitive: wgpu::PrimitiveState {
-			topology: wgpu::PrimitiveTopology::TriangleStrip,
-			..Default::default()
-		},
-		depth_stencil: None,
-		multisample: wgpu::MultisampleState::default(),
-		fragment: Some(wgpu::FragmentState {
-			module: &step_shader,
-			entry_point: None,
-			compilation_options: wgpu::PipelineCompilationOptions::default(),
-			targets: &[Some(wgpu::ColorTargetState {
-				format: wgpu::TextureFormat::R8Uint,
-				blend: None,
-				write_mask: wgpu::ColorWrites::ALL,
-			})],
-		}),
-		multiview: None,
-		cache: None,
-	});
-
-	let present_shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
-		label: Some("present"),
-		source: wgpu::ShaderSource::Wgsl(include_str!("present.wgsl").into()),
-	});
-	let present_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
-		label: None,
-		layout: None,
-		vertex: wgpu::VertexState {
-			module: &present_shader,
-			entry_point: None,
-			compilation_options: wgpu::PipelineCompilationOptions::default(),
-			buffers: &[],
-		},
-		primitive: wgpu::PrimitiveState {
-			topology: wgpu::PrimitiveTopology::TriangleStrip,
-			..Default::default()
-		},
-		depth_stencil: None,
-		multisample: wgpu::MultisampleState::default(),
-		fragment: Some(wgpu::FragmentState {
-			module: &present_shader,
-			entry_point: None,
-			compilation_options: wgpu::PipelineCompilationOptions::default(),
-			targets: &[Some(wgpu::ColorTargetState {
-				format,
-				blend: None,
-				write_mask: wgpu::ColorWrites::ALL,
-			})],
-		}),
-		multiview: None,
-		cache: None,
-	});
-
-	let state_sampler = device.create_sampler(&wgpu::SamplerDescriptor {
-		label: None,
-		address_mode_u: wgpu::AddressMode::Repeat,
-		address_mode_v: wgpu::AddressMode::Repeat,
-		address_mode_w: wgpu::AddressMode::Repeat,
-		mag_filter: wgpu::FilterMode::Nearest,
-		min_filter: wgpu::FilterMode::Nearest,
-		mipmap_filter: wgpu::FilterMode::Nearest,
-		..Default::default()
-	});
-
-	let mut state = None;
 	#[allow(deprecated)]
 	event_loop
 		.run(move |event, control_flow| match event {
 			Event::WindowEvent { ref event, window_id } if window_id == window.id() => match event {
 				WindowEvent::CloseRequested => control_flow.exit(),
 				WindowEvent::Resized(physical_size) => {
-					let size = uvec2(physical_size.width, physical_size.height);
 					surface.configure(
 						&device,
 						&wgpu::SurfaceConfiguration {
 							usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_DST,
 							format,
-							width: size.x,
+							width: physical_size.width,
-							height: size.y,
+							height: physical_size.height,
 							present_mode: wgpu::PresentMode::Fifo,
 							alpha_mode: wgpu::CompositeAlphaMode::Auto,
 							view_formats: vec![],
 							desired_maximum_frame_latency: 2,
 						},
 					);
-					let [last, next] = [(), ()].map(|_| {
+					surface_configured = true;
-						device
-							.create_texture(&wgpu::TextureDescriptor {
-								label: None,
-								size: wgpu::Extent3d {
-									width: size.x,
-									height: size.y,
-									depth_or_array_layers: 1,
-								},
-								mip_level_count: 1,
-								sample_count: 1,
-								dimension: wgpu::TextureDimension::D2,
-								format: wgpu::TextureFormat::R8Uint,
-								usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
-								view_formats: &[],
-							})
-							.create_view(&Default::default())
-					});
-
-					let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
-					let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
-						label: None,
-						color_attachments: &[Some(wgpu::RenderPassColorAttachment {
-							view: &last,
-							resolve_target: None,
-							ops: wgpu::Operations {
-								load: wgpu::LoadOp::Clear(wgpu::Color::BLUE),
-								store: wgpu::StoreOp::Store,
-							},
-						})],
-						depth_stencil_attachment: None,
-						occlusion_query_set: None,
-						timestamp_writes: None,
-					});
-					render_pass.set_pipeline(&fill_pipeline);
-					render_pass.draw(0..4, 0..1);
-					drop(render_pass);
-					queue.submit(std::iter::once(encoder.finish()));
-
-					state = Some(GameState { last, next });
 				}
 				WindowEvent::RedrawRequested => {
-					let Some(state) = &mut state else {
+					if !surface_configured {
 						return;
-					};
+					}
 					let output = surface.get_current_texture().unwrap();
 					let view = output.texture.create_view(&wgpu::TextureViewDescriptor::default());
 					let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
-
+					let render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
-					let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
 						label: None,
 						color_attachments: &[Some(wgpu::RenderPassColorAttachment {
 							view: &view,
@@ -217,63 +62,9 @@ fn main() {
 						occlusion_query_set: None,
 						timestamp_writes: None,
 					});
-					render_pass.set_pipeline(&present_pipeline);
-					render_pass.set_bind_group(
-						0,
-						&device.create_bind_group(&wgpu::BindGroupDescriptor {
-							label: None,
-							layout: &present_pipeline.get_bind_group_layout(0),
-							entries: &[wgpu::BindGroupEntry {
-								binding: 0,
-								resource: wgpu::BindingResource::TextureView(&state.last),
-							}],
-						}),
-						&[],
-					);
-					render_pass.draw(0..4, 0..1);
 					drop(render_pass);
-
-					let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
-						label: None,
-						color_attachments: &[Some(wgpu::RenderPassColorAttachment {
-							view: &state.next,
-							resolve_target: None,
-							ops: wgpu::Operations {
-								load: wgpu::LoadOp::Clear(wgpu::Color::BLUE),
-								store: wgpu::StoreOp::Store,
-							},
-						})],
-						depth_stencil_attachment: None,
-						occlusion_query_set: None,
-						timestamp_writes: None,
-					});
-					render_pass.set_pipeline(&step_pipeline);
-					render_pass.set_bind_group(
-						0,
-						&device.create_bind_group(&wgpu::BindGroupDescriptor {
-							label: None,
-							layout: &step_pipeline.get_bind_group_layout(0),
-							entries: &[
-								wgpu::BindGroupEntry {
-									binding: 0,
-									resource: wgpu::BindingResource::TextureView(&state.last),
-								},
-								wgpu::BindGroupEntry {
-									binding: 1,
-									resource: wgpu::BindingResource::Sampler(&state_sampler),
-								},
-							],
-						}),
-						&[],
-					);
-					render_pass.draw(0..4, 0..1);
-					drop(render_pass);
-
 					queue.submit(std::iter::once(encoder.finish()));
 					output.present();
-
-					std::mem::swap(&mut state.last, &mut state.next);
-					window.request_redraw();
 				}
 				_ => {}
 			},

src/present.wgsl

@@ -1,20 +0,0 @@
-struct Varying {
-	@location(0) uv: vec2f,
-	@builtin(position) screen: vec4f,
-}
-
-@vertex
-fn on_vertex(@builtin(vertex_index) vi: u32) -> Varying {
-	let uv = vec2f(vec2(vi, vi >> 1u) & vec2(1u));
-	let screen = vec4(uv * 2. - 1., 0., 1.);
-	return Varying(vec2(uv.x, 1. - uv.y), screen);
-}
-
-@group(0) @binding(0) var field: texture_2d<u32>;
-
-@fragment
-fn on_fragment(in: Varying) -> @location(0) vec4f {
-	let pos = vec2u(in.screen.xy);
-	let state = textureLoad(field, pos, 0).x;
-	return vec4f(f32(state));
-}

src/step.wgsl

@@ -1,30 +0,0 @@
-struct Varying {
-	@location(0) uv: vec2f,
-	@builtin(position) screen: vec4f,
-}
-
-@vertex
-fn on_vertex(@builtin(vertex_index) vi: u32) -> Varying {
-	let uv = vec2f(vec2(vi, vi >> 1u) & vec2(1u));
-	let screen = vec4(uv * 2. - 1., 0., 1.);
-	let off = .5 / vec2f(textureDimensions(field));
-	return Varying(vec2(uv.x, 1. - uv.y) - off, screen);
-}
-
-@group(0) @binding(0) var field: texture_2d<u32>;
-@group(0) @binding(1) var smp: sampler;
-
-@fragment
-fn on_fragment(in: Varying) -> @location(0) u32 {
-	let a = textureGather(0, field, smp, in.uv, vec2(0, 0));
-	let b = textureGather(0, field, smp, in.uv, vec2(0, 1));
-	let c = textureGather(0, field, smp, in.uv, vec2(1, 0));
-	let d = textureGather(0, field, smp, in.uv, vec2(1, 1));
-	let state = a.y;
-	let n = a.x + a.z + a.w + b.x + b.y + c.y + c.z + d.y;
-	switch (n) {
-	case 2u: { return state; }
-	case 3u: { return 1u; }
-	default: { return 0u; }
-	}
-}