Remove unused field

src/fill.wgsl

@@ -0,0 +1,27 @@
+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

@@ -1,135 +0,0 @@
-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,12 +1,16 @@
 use std::error::Error;
 
+use glam::uvec2;
 use winit::{
 	event::{Event, WindowEvent},
 	event_loop::EventLoop,
 	window::{Window, WindowAttributes},
 };
 
-mod mailbox;
+struct GameState {
+	last: wgpu::TextureView,
+	next: wgpu::TextureView,
+}
 
 fn main() {
 	let event_loop = EventLoop::new().unwrap();
@@ -17,38 +21,189 @@ 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: physical_size.width,
+							width: size.x,
-							height: physical_size.height,
+							height: size.y,
 							present_mode: wgpu::PresentMode::Fifo,
 							alpha_mode: wgpu::CompositeAlphaMode::Auto,
 							view_formats: vec![],
 							desired_maximum_frame_latency: 2,
 						},
 					);
-					surface_configured = true;
+					let [last, next] = [(), ()].map(|_| {
+						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 => {
-					if !surface_configured {
+					let Some(state) = &mut state else {
 						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,
@@ -62,9 +217,63 @@ 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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,30 @@
+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; }
+	}
+}