Simplify sphere parameter generation

src/bin/minitracer/anim.rs

@@ -11,41 +11,22 @@ pub struct SphereParams {
 	pub phases: Vec3,
 }
 
-pub struct SphereParamsDistribution {
+pub fn distr<R: rand::Rng>() -> impl Fn(&mut R) -> SphereParams {
-	pub rad: Uniform<f32>,
+	let rad = Uniform::new(-6., -4.);
-	pub pos: Uniform<f32>,
+	let pos = Uniform::new(-1.0, 1.0);
-	pub emit: Bernoulli,
+	let emit = Bernoulli::new(0.1).unwrap();
-	pub ampl: Uniform<f32>,
+	let ampl = Uniform::new(0.3, 0.8);
-	pub freq: Uniform<f32>,
+	let freq = Uniform::new(0.2, 1.5);
-	pub phase: Uniform<f32>,
+	let phase = Uniform::new(0., 2. * std::f32::consts::PI);
-	pub gloss: Uniform<f32>,
+	let gloss = Uniform::new(0., 1.);
-}
+	move |rgen| SphereParams {
-
+		origin: pos.sample3(rgen),
-impl Default for SphereParamsDistribution {
+		radius: 2.0f32.powf(rad.sample(rgen)),
-	fn default() -> Self {
+		alpha: if emit.sample(rgen) { 10.0 } else { 0.0 },
-		Self {
+		glossiness: gloss.sample(rgen),
-			rad: Uniform::new(-6., -4.),
+		amplitudes: ampl.sample3(rgen),
-			pos: Uniform::new(-1.0, 1.0),
+		frequencies: freq.sample3(rgen),
-			emit: Bernoulli::new(0.1).unwrap(),
+		phases: phase.sample3(rgen),
-			ampl: Uniform::new(0.3, 0.8),
-			freq: Uniform::new(0.2, 1.5),
-			phase: Uniform::new(0., 2. * std::f32::consts::PI),
-			gloss: Uniform::new(0., 1.),
-		}
-	}
-}
-
-impl SphereParamsDistribution {
-	pub fn make_params(&self, rgen: &mut impl rand::Rng) -> SphereParams {
-		SphereParams {
-			origin: self.pos.sample3(rgen),
-			radius: 2.0f32.powf(self.rad.sample(rgen)),
-			alpha: if self.emit.sample(rgen) { 10.0 } else { 0.0 },
-			glossiness: self.gloss.sample(rgen),
-			amplitudes: self.ampl.sample3(rgen),
-			frequencies: self.freq.sample3(rgen),
-			phases: self.phase.sample3(rgen),
-		}
 	}
 }
 

src/bin/minitracer/main.rs

@@ -32,6 +32,7 @@ fn make_viewport(w: u32, h: u32) -> [Vertex; 4] {
 }
 
 const N_SPHERES: u32 = 100;
+const RAYS_PER_PIXEL: u32 = 4;
 
 fn main() {
 	let event_loop = EventLoop::new().unwrap();
@@ -50,15 +51,14 @@ fn main() {
 	let mut tracer = Tracer::new(&device, hdr_format);
 	let sphere_params: Vec<_> = {
 		let mut rng = rand_pcg::Pcg32::new(42, 0);
-		let distr = anim::SphereParamsDistribution::default();
+		let distr = anim::distr();
-		(0..N_SPHERES).map(|_| distr.make_params(&mut rng)).collect()
+		(0..N_SPHERES).map(|_| distr(&mut rng)).collect()
 	};
 	let tracer_env = TracerEnv::new(&device, &tracer, &envmap);
 
 	let presenter = Presenter::new(&device, output_format);
 
 	let mut frame = 0;
-	let mut time = 0.0;
 
 	let mut surface_configured = false;
 	#[allow(deprecated)]
@@ -88,30 +88,13 @@ fn main() {
 					if !surface_configured {
 						return;
 					}
-					time += 1. / 60.;
-					frame += 1;
-					let spheres: Vec<_> = sphere_params.iter().map(|p| p.to_sphere(time)).collect();
-					let data = TracerData::new(&device, &tracer, &spheres);
-					tracer.set_params(
-						&queue,
-						trace::Params {
-							max_reflections: 3,
-							min_strength: 0.1,
-							sphere_count: N_SPHERES,
-							seed: frame,
-						},
-					);
 
 					let output = surface.get_current_texture().unwrap();
 					let view = output.texture.create_view(&wgpu::TextureViewDescriptor::default());
 					let size = output.texture.size();
 					let hdr = device.create_texture(&wgpu::TextureDescriptor {
 						label: None,
-						size: wgpu::Extent3d {
+						size,
-							width: 2 * size.width,
-							height: 2 * size.height,
-							depth_or_array_layers: 1,
-						},
 						mip_level_count: 1,
 						sample_count: 1,
 						dimension: wgpu::TextureDimension::D2,
@@ -136,7 +119,23 @@ fn main() {
 							occlusion_query_set: None,
 							timestamp_writes: None,
 						});
-						tracer.render(&mut render_pass, &data, &tracer_env);
+						for _ in 0..RAYS_PER_PIXEL {
+							frame += 1;
+							let time = frame as f32 / (60. * RAYS_PER_PIXEL as f32);
+							let spheres: Vec<_> = sphere_params.iter().map(|p| p.to_sphere(time)).collect();
+							let data = TracerData::new(&device, &tracer, &spheres);
+							tracer.render(
+								&mut render_pass,
+								&data,
+								&tracer_env,
+								trace::Params {
+									max_reflections: 3,
+									min_strength: 0.1,
+									sphere_count: N_SPHERES,
+									seed: frame,
+								},
+							);
+						}
 					}
 					{
 						let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
@@ -153,7 +152,14 @@ fn main() {
 							occlusion_query_set: None,
 							timestamp_writes: None,
 						});
-						presenter.render(&device, &mut render_pass, &hdr);
+						presenter.render(
+							&device,
+							&mut render_pass,
+							&hdr,
+							present::Params {
+								divisor: RAYS_PER_PIXEL as f32,
+							},
+						);
 					}
 					queue.submit(std::iter::once(encoder.finish()));
 					output.present();
@@ -183,8 +189,11 @@ async fn init_gpu(wnd: &Window) -> Result<(wgpu::Device, wgpu::Queue, wgpu::Surf
 		.request_device(
 			&wgpu::DeviceDescriptor {
 				label: None,
-				required_features: wgpu::Features::empty(),
+				required_features: wgpu::Features::PUSH_CONSTANTS,
-				required_limits: wgpu::Limits::default(),
+				required_limits: wgpu::Limits {
+					max_push_constant_size: 32,
+					..Default::default()
+				},
 				memory_hints: Default::default(),
 			},
 			None,

src/bin/minitracer/present.rs

@@ -10,6 +10,12 @@ struct Vertex {
 	pub screen: Vec2,
 }
 
+#[derive(Debug, Clone, Copy, Pod, Zeroable)]
+#[repr(C)]
+pub struct Params {
+	pub divisor: f32,
+}
+
 pub struct Presenter {
 	view_buf: wgpu::Buffer,
 	sampler: wgpu::Sampler,
@@ -80,7 +86,18 @@ impl Presenter {
 		}
 	}
 
-	pub fn render(&self, device: &wgpu::Device, pass: &mut wgpu::RenderPass, texture: &wgpu::TextureView) {
+	pub fn render(
+		&self,
+		device: &wgpu::Device,
+		pass: &mut wgpu::RenderPass,
+		texture: &wgpu::TextureView,
+		params: Params,
+	) {
+		let params_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+			label: None,
+			contents: bytes_of(&params),
+			usage: wgpu::BufferUsages::UNIFORM,
+		});
 		let bindings = device.create_bind_group(&wgpu::BindGroupDescriptor {
 			label: None,
 			layout: &self.pipeline.get_bind_group_layout(0),
@@ -93,6 +110,10 @@ impl Presenter {
 					binding: 1,
 					resource: wgpu::BindingResource::TextureView(texture),
 				},
+				wgpu::BindGroupEntry {
+					binding: 2,
+					resource: params_buf.as_entire_binding(),
+				},
 			],
 		});
 		pass.set_pipeline(&self.pipeline);

src/bin/minitracer/present.wgsl

@@ -1,3 +1,7 @@
+struct Params {
+	divisor: f32,
+}
+
 struct Vertex {
 	@location(0) screen: vec2f,
 }
@@ -9,6 +13,7 @@ struct Varying {
 
 @group(0) @binding(0) var smp: sampler;
 @group(0) @binding(1) var tex: texture_2d<f32>;
+@group(0) @binding(2) var<uniform> params: Params;
 
 @vertex
 fn on_vertex(in: Vertex) -> Varying {
@@ -19,7 +24,7 @@ fn on_vertex(in: Vertex) -> Varying {
 
 @fragment
 fn on_fragment(in: Varying) -> @location(0) vec4f {
-	let pixel = textureSample(tex, smp, in.tex);
+	let pixel = textureSample(tex, smp, in.tex) / params.divisor;
 	return vec4(rational_tone_map(pixel.xyz), 1.0);
 }
 

src/bin/minitracer/trace.rs

@@ -43,7 +43,6 @@ struct SphereData {
 
 pub struct Tracer {
 	view_buf: wgpu::Buffer,
-	params_buf: wgpu::Buffer,
 	pipeline: wgpu::RenderPipeline,
 }
 
@@ -65,19 +64,55 @@ impl Tracer {
 			usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
 			mapped_at_creation: false,
 		});
-		let params_buf = device.create_buffer(&wgpu::BufferDescriptor {
-			label: None,
-			size: mem::size_of::<Params>() as u64,
-			usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
-			mapped_at_creation: false,
-		});
 		let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
 			label: None,
 			source: wgpu::ShaderSource::Wgsl(SHADER.into()),
 		});
+		let spheres_bgl = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+			label: None,
+			entries: &[wgpu::BindGroupLayoutEntry {
+				binding: 1,
+				visibility: wgpu::ShaderStages::FRAGMENT,
+				ty: wgpu::BindingType::Buffer {
+					ty: wgpu::BufferBindingType::Storage { read_only: true },
+					has_dynamic_offset: false,
+					min_binding_size: None,
+				},
+				count: None,
+			}],
+		});
+		let envmap_bgl = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+			label: None,
+			entries: &[
+				wgpu::BindGroupLayoutEntry {
+					binding: 0,
+					visibility: wgpu::ShaderStages::FRAGMENT,
+					ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
+					count: None,
+				},
+				wgpu::BindGroupLayoutEntry {
+					binding: 1,
+					visibility: wgpu::ShaderStages::FRAGMENT,
+					ty: wgpu::BindingType::Texture {
+						sample_type: wgpu::TextureSampleType::Float { filterable: true },
+						view_dimension: wgpu::TextureViewDimension::Cube,
+						multisampled: false,
+					},
+					count: None,
+				},
+			],
+		});
+		let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+			label: None,
+			bind_group_layouts: &[&spheres_bgl, &envmap_bgl],
+			push_constant_ranges: &[wgpu::PushConstantRange {
+				stages: wgpu::ShaderStages::FRAGMENT,
+				range: 0..16,
+			}],
+		});
 		let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
 			label: None,
-			layout: None,
+			layout: Some(&pipeline_layout),
 			vertex: wgpu::VertexState {
 				module: &shader,
 				entry_point: None,
@@ -120,30 +155,34 @@ impl Tracer {
 				compilation_options: wgpu::PipelineCompilationOptions::default(),
 				targets: &[Some(wgpu::ColorTargetState {
 					format,
-					blend: Some(wgpu::BlendState::REPLACE),
+					blend: Some(wgpu::BlendState {
+						color: wgpu::BlendComponent {
+							src_factor: wgpu::BlendFactor::One,
+							dst_factor: wgpu::BlendFactor::One,
+							operation: wgpu::BlendOperation::Add,
+						},
+						alpha: wgpu::BlendComponent {
+							src_factor: wgpu::BlendFactor::One,
+							dst_factor: wgpu::BlendFactor::One,
+							operation: wgpu::BlendOperation::Add,
+						},
+					}),
 					write_mask: wgpu::ColorWrites::ALL,
 				})],
 			}),
 			multiview: None,
 			cache: None,
 		});
-		Self {
+		Self { view_buf, pipeline }
-			view_buf,
-			params_buf,
-			pipeline,
-		}
-	}
-
-	pub fn set_params(&mut self, queue: &wgpu::Queue, params: Params) {
-		queue.write_buffer(&self.params_buf, 0, bytes_of(&params));
 	}
 
 	pub fn set_view(&mut self, queue: &wgpu::Queue, vertices: &[Vertex; 4]) {
 		queue.write_buffer(&self.view_buf, 0, bytes_of(vertices));
 	}
 
-	pub fn render(&self, pass: &mut wgpu::RenderPass, data: &TracerData, env: &TracerEnv) {
+	pub fn render(&self, pass: &mut wgpu::RenderPass, data: &TracerData, env: &TracerEnv, params: Params) {
 		pass.set_pipeline(&self.pipeline);
+		pass.set_push_constants(wgpu::ShaderStages::FRAGMENT, 0, bytes_of(&params));
 		pass.set_vertex_buffer(0, self.view_buf.slice(..));
 		pass.set_bind_group(0, &data.bindings, &[]);
 		pass.set_bind_group(1, &env.bindings, &[]);
@@ -172,16 +211,10 @@ impl TracerData {
 		let bindings = device.create_bind_group(&wgpu::BindGroupDescriptor {
 			label: None,
 			layout: &tracer.pipeline.get_bind_group_layout(0),
-			entries: &[
+			entries: &[wgpu::BindGroupEntry {
-				wgpu::BindGroupEntry {
+				binding: 1,
-					binding: 0,
+				resource: spheres_buf.as_entire_binding(),
-					resource: tracer.params_buf.as_entire_binding(),
+			}],
-				},
-				wgpu::BindGroupEntry {
-					binding: 1,
-					resource: spheres_buf.as_entire_binding(),
-				},
-			],
 		});
 		Self { bindings }
 	}

src/bin/minitracer/trace.wgsl

@@ -25,7 +25,7 @@ struct Varying {
 	@builtin(position) screen: vec4f,
 }
 
-@group(0) @binding(0) var<uniform> params: Params;
+var<push_constant> params: Params;
 @group(0) @binding(1) var<storage, read> spheres: array<Sphere>;
 @group(1) @binding(0) var env_sampler: sampler;
 @group(1) @binding(1) var env_texture: texture_cube<f32>;
@@ -69,7 +69,9 @@ fn trace_fragment(in: Varying) -> vec4f {
 	var result = vec4(0.0, 0.0, 0.0, 0.0);
 	var color = vec3(1.0, 1.0, 1.0);
 	pos = in.eye;
-	ray = normalize(in.world - in.eye);
+	let off_px = vec2(rand_float(), rand_float()) - .5;
+	let off_w = mat2x3(dpdx(in.world), dpdy(in.world));
+	ray = normalize(in.world + off_w * off_px - in.eye);
 
 	for (var k = 0; k < params.max_reflections; k++) {
 		var sphere = -1;