src/bin/minitracer/anim.rs

@@ -11,22 +11,41 @@ pub struct SphereParams {
 	pub phases: Vec3,
 }
 
-pub fn distr<R: rand::Rng>() -> impl Fn(&mut R) -> SphereParams {
+pub struct SphereParamsDistribution {
-	let rad = Uniform::new(-6., -4.);
+	pub rad: Uniform<f32>,
-	let pos = Uniform::new(-1.0, 1.0);
+	pub pos: Uniform<f32>,
-	let emit = Bernoulli::new(0.1).unwrap();
+	pub emit: Bernoulli,
-	let ampl = Uniform::new(0.3, 0.8);
+	pub ampl: Uniform<f32>,
-	let freq = Uniform::new(0.2, 1.5);
+	pub freq: Uniform<f32>,
-	let phase = Uniform::new(0., 2. * std::f32::consts::PI);
+	pub phase: Uniform<f32>,
-	let gloss = Uniform::new(0., 1.);
+	pub gloss: Uniform<f32>,
-	move |rgen| SphereParams {
+}
-		origin: pos.sample3(rgen),
+
-		radius: 2.0f32.powf(rad.sample(rgen)),
+impl Default for SphereParamsDistribution {
-		alpha: if emit.sample(rgen) { 10.0 } else { 0.0 },
+	fn default() -> Self {
-		glossiness: gloss.sample(rgen),
+		Self {
-		amplitudes: ampl.sample3(rgen),
+			rad: Uniform::new(-6., -4.),
-		frequencies: freq.sample3(rgen),
+			pos: Uniform::new(-1.0, 1.0),
-		phases: phase.sample3(rgen),
+			emit: Bernoulli::new(0.1).unwrap(),
+			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,7 +32,6 @@ 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();
@@ -51,14 +50,15 @@ 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::distr();
+		let distr = anim::SphereParamsDistribution::default();
-		(0..N_SPHERES).map(|_| distr(&mut rng)).collect()
+		(0..N_SPHERES).map(|_| distr.make_params(&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,13 +88,30 @@ 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,
+						size: wgpu::Extent3d {
+							width: 2 * size.width,
+							height: 2 * size.height,
+							depth_or_array_layers: 1,
+						},
 						mip_level_count: 1,
 						sample_count: 1,
 						dimension: wgpu::TextureDimension::D2,
@@ -119,23 +136,7 @@ fn main() {
 							occlusion_query_set: None,
 							timestamp_writes: None,
 						});
-						for _ in 0..RAYS_PER_PIXEL {
+						tracer.render(&mut render_pass, &data, &tracer_env);
-							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 {
@@ -152,14 +153,7 @@ fn main() {
 							occlusion_query_set: None,
 							timestamp_writes: None,
 						});
-						presenter.render(
+						presenter.render(&device, &mut render_pass, &hdr);
-							&device,
-							&mut render_pass,
-							&hdr,
-							present::Params {
-								divisor: RAYS_PER_PIXEL as f32,
-							},
-						);
 					}
 					queue.submit(std::iter::once(encoder.finish()));
 					output.present();
@@ -189,11 +183,8 @@ async fn init_gpu(wnd: &Window) -> Result<(wgpu::Device, wgpu::Queue, wgpu::Surf
 		.request_device(
 			&wgpu::DeviceDescriptor {
 				label: None,
-				required_features: wgpu::Features::PUSH_CONSTANTS,
+				required_features: wgpu::Features::empty(),
-				required_limits: wgpu::Limits {
+				required_limits: wgpu::Limits::default(),
-					max_push_constant_size: 32,
-					..Default::default()
-				},
 				memory_hints: Default::default(),
 			},
 			None,

src/bin/minitracer/present.rs

@@ -10,12 +10,6 @@ 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,
@@ -86,18 +80,7 @@ impl Presenter {
 		}
 	}
 
-	pub fn render(
+	pub fn render(&self, device: &wgpu::Device, pass: &mut wgpu::RenderPass, texture: &wgpu::TextureView) {
-		&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),
@@ -110,10 +93,6 @@ 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,7 +1,3 @@
-struct Params {
-	divisor: f32,
-}
-
 struct Vertex {
 	@location(0) screen: vec2f,
 }
@@ -13,7 +9,6 @@ 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 {
@@ -24,7 +19,7 @@ fn on_vertex(in: Vertex) -> Varying {
 
 @fragment
 fn on_fragment(in: Varying) -> @location(0) vec4f {
-	let pixel = textureSample(tex, smp, in.tex) / params.divisor;
+	let pixel = textureSample(tex, smp, in.tex);
 	return vec4(rational_tone_map(pixel.xyz), 1.0);
 }
 

src/bin/minitracer/trace.rs

@@ -43,6 +43,7 @@ struct SphereData {
 
 pub struct Tracer {
 	view_buf: wgpu::Buffer,
+	params_buf: wgpu::Buffer,
 	pipeline: wgpu::RenderPipeline,
 }
 
@@ -64,55 +65,19 @@ 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: Some(&pipeline_layout),
+			layout: None,
 			vertex: wgpu::VertexState {
 				module: &shader,
 				entry_point: None,
@@ -155,34 +120,30 @@ impl Tracer {
 				compilation_options: wgpu::PipelineCompilationOptions::default(),
 				targets: &[Some(wgpu::ColorTargetState {
 					format,
-					blend: Some(wgpu::BlendState {
+					blend: Some(wgpu::BlendState::REPLACE),
-						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 { view_buf, pipeline }
+		Self {
+			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, params: Params) {
+	pub fn render(&self, pass: &mut wgpu::RenderPass, data: &TracerData, env: &TracerEnv) {
 		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, &[]);
@@ -211,10 +172,16 @@ impl TracerData {
 		let bindings = device.create_bind_group(&wgpu::BindGroupDescriptor {
 			label: None,
 			layout: &tracer.pipeline.get_bind_group_layout(0),
-			entries: &[wgpu::BindGroupEntry {
+			entries: &[
-				binding: 1,
+				wgpu::BindGroupEntry {
-				resource: spheres_buf.as_entire_binding(),
+					binding: 0,
-			}],
+					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,
 }
 
-var<push_constant> params: Params;
+@group(0) @binding(0) var<uniform> 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,9 +69,7 @@ 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;
-	let off_px = vec2(rand_float(), rand_float()) - .5;
+	ray = normalize(in.world - in.eye);
-	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;