Some more glare stuff

src/bin/minitracer/main.rs

@@ -65,7 +65,7 @@ fn main() {
 					let output = surface.get_current_texture().unwrap();
 					let view = output.texture.create_view(&wgpu::TextureViewDescriptor::default());
 					let size = output.texture.size();
-					let hdr1 = device.create_texture(&wgpu::TextureDescriptor {
+					let hdr = device.create_texture(&wgpu::TextureDescriptor {
 						label: None,
 						size,
 						mip_level_count: 1,
@@ -75,10 +75,10 @@ fn main() {
 						usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
 						view_formats: &[],
 					});
-					let hdr1 = hdr1.create_view(&wgpu::TextureViewDescriptor::default());
+					let hdr1v = hdr.create_view(&wgpu::TextureViewDescriptor::default());
 					let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
 					{
-						let mut render_pass = renderer.prepare(&mut encoder, &hdr1);
+						let mut render_pass = renderer.prepare(&mut encoder, &hdr1v);
 						let time = frame as f32 / (60. * RAYS_PER_PIXEL as f32);
 						for _ in 0..RAYS_PER_PIXEL {
 							frame += 1;
@@ -92,30 +92,12 @@ fn main() {
 							);
 						}
 					}
-					let hdr2 = device.create_texture(&wgpu::TextureDescriptor {
+					let sigma = vec2(size.width as f32, size.height as f32).length();
-						label: None,
+					glarer.render(&device, &mut encoder, &hdr, raytracing3::glare::Params { sigma });
-						size,
-						mip_level_count: 1,
-						sample_count: 1,
-						dimension: wgpu::TextureDimension::D2,
-						format: hdr_format,
-						usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
-						view_formats: &[],
-					});
-					let hdr2 = hdr2.create_view(&wgpu::TextureViewDescriptor::default());
-					let sigma = 3000. / vec2(size.width as f32, size.height as f32).length();
-					glarer.render(
-						&device,
-						&mut encoder,
-						uvec2(size.width, size.height),
-						&hdr1,
-						&hdr2,
-						raytracing3::glare::Params { sigma },
-					);
 					presenter.render(
 						&device,
 						&mut encoder,
-						&hdr2,
+						&hdr1v,
 						&view,
 						present::Params {
 							divisor: RAYS_PER_PIXEL as f32,

src/glare.rs

@@ -89,7 +89,18 @@ impl Glarer {
 				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,
 				})],
 			}),
@@ -108,18 +119,16 @@ impl Glarer {
 		&self,
 		device: &wgpu::Device,
 		encoder: &mut wgpu::CommandEncoder,
-		size: UVec2,
+		source: &wgpu::Texture,
-		source: &wgpu::TextureView,
+		// target: &wgpu::Texture,
-		target: &wgpu::TextureView,
 		params: Params,
 	) {
+		let target = source;
+		let size = target.size();
+		// assert_eq!(source.size(), size);
 		let intermediate = device.create_texture(&wgpu::TextureDescriptor {
 			label: None,
-			size: wgpu::Extent3d {
+			size,
-				width: size.x,
-				height: size.y,
-				depth_or_array_layers: 1,
-			},
 			mip_level_count: 1,
 			sample_count: 1,
 			dimension: wgpu::TextureDimension::D2,
@@ -133,6 +142,8 @@ impl Glarer {
 			contents: bytes_of(&params),
 			usage: wgpu::BufferUsages::UNIFORM,
 		});
+		let source = &source.create_view(&wgpu::TextureViewDescriptor::default());
+		let target = &target.create_view(&wgpu::TextureViewDescriptor::default());
 		{
 			let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
 				label: None,
@@ -174,6 +185,7 @@ impl Glarer {
 					view: target,
 					resolve_target: None,
 					ops: wgpu::Operations {
+						// load: wgpu::LoadOp::Load,
 						load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),
 						store: wgpu::StoreOp::Store,
 					},

src/glare.wgsl

@@ -21,7 +21,7 @@ fn on_vertex(in: Vertex) -> Varying {
 	return Varying(uv, vec4(xy, 0., 1.));
 }
 
-const CUTOFF: i32 = 1000;
+const CUTOFF: i32 = 10000;
 
 @fragment
 fn pass_h(in: Varying) -> @location(0) vec4f {
@@ -53,13 +53,29 @@ fn pass_v(in: Varying) -> @location(0) vec4f {
 	return vec4(accum.xyz, params.sigma);
 }
 
-fn weight(dist: i32) -> f32 {
+// fn weight(dist: i32) -> f32 {
-// 	if (dist == 0) {
+// 	let σ = 50.;
-// 		return 1.0;
+// 	let d = f32(dist);
+// 	let w = max(0., 1. - abs(d) / σ) / σ;
+// 	return .1 * w;
 // }
-	let σ = params.sigma;
+
-	let d = σ * f32(dist);
+// fn weight(dist: i32) -> f32 {
-// 	let w = exp(-0.5 * d*d / (σ*σ)) / (2.5 * σ);
+// 	let σ = params.sigma / 3000.;
-// 	return 0.1 * w;
+// 	let d = f32(dist) / σ;
-	return .33 * σ / (1. + d*d);
+// 	return .1 / (1. + d*d) / σ;
+// }
+
+// fn weight(dist: i32) -> f32 {
+// 	let σ = params.sigma / 300.;
+// 	let d = abs(f32(dist) / σ);
+// 	return 1. / (1. + d*d*d) / σ;
+// }
+
+fn weight(dist: i32) -> f32 {
+	let d = f32(abs(dist));
+	let c = mix(.01, 1., exp(-d*d));
+// 	return c * pow(1.2, -d);
+	return c / (1. + pow(d, 2.0));
+// 	return .25 * c / (1. + pow(.1 * d, 4.0));
 }