[Merged by Bors] - Revamp Bloom

crates/bevy_core_pipeline/src/bloom/bloom.wgsl

@@ -1,22 +1,25 @@
+// References:
+// * http://www.iryoku.com/next-generation-post-processing-in-call-of-duty-advanced-warfare
+// * https://learnopengl.com/Guest-Articles/2022/Phys.-Based-Bloom
+
 #import bevy_core_pipeline::fullscreen_vertex_shader
 
-struct BloomUniforms {
-    threshold: f32,
-    knee: f32,
-    scale: f32,
+struct BloomSettings {
     intensity: f32,
+    threshold_base: f32,
+    threshold_knee: f32,
 };
 
 @group(0) @binding(0)
-var original: texture_2d<f32>;
+var input_texture: texture_2d<f32>;
 @group(0) @binding(1)
-var original_sampler: sampler;
+var s: sampler;
 @group(0) @binding(2)
-var<uniform> uniforms: BloomUniforms;
+var<uniform> settings: BloomSettings;
 @group(0) @binding(3)
-var up: texture_2d<f32>;
+var main_pass_texture: texture_2d<f32>;
 
-fn quadratic_threshold(color: vec4<f32>, threshold: f32, curve: vec3<f32>) -> vec4<f32> {
+fn quadratic_threshold(color: vec3<f32>, threshold: f32, curve: vec3<f32>) -> vec3<f32> {
     let br = max(max(color.r, color.g), color.b);
 
     var rq: f32 = clamp(br - curve.x, 0.0, curve.y);
@@ -25,112 +28,84 @@ fn quadratic_threshold(color: vec4<f32>, threshold: f32, curve: vec3<f32>) -> ve
     return color * max(rq, br - threshold) / max(br, 0.0001);
 }
 
-// Samples original around the supplied uv using a filter.
-//
-// o   o   o
-//   o   o
-// o   o   o
-//   o   o
-// o   o   o
-//
-// This is used because it has a number of advantages that
-// outweigh the cost of 13 samples that basically boil down
-// to it looking better.
-//
-// These advantages are outlined in a youtube video by the Cherno:
-//   https://www.youtube.com/watch?v=tI70-HIc5ro
-fn sample_13_tap(uv: vec2<f32>, scale: vec2<f32>) -> vec4<f32> {
-    let a = textureSample(original, original_sampler, uv + vec2<f32>(-1.0, -1.0) * scale);
-    let b = textureSample(original, original_sampler, uv + vec2<f32>(0.0, -1.0) * scale);
-    let c = textureSample(original, original_sampler, uv + vec2<f32>(1.0, -1.0) * scale);
-    let d = textureSample(original, original_sampler, uv + vec2<f32>(-0.5, -0.5) * scale);
-    let e = textureSample(original, original_sampler, uv + vec2<f32>(0.5, -0.5) * scale);
-    let f = textureSample(original, original_sampler, uv + vec2<f32>(-1.0, 0.0) * scale);
-    let g = textureSample(original, original_sampler, uv + vec2<f32>(0.0, 0.0) * scale);
-    let h = textureSample(original, original_sampler, uv + vec2<f32>(1.0, 0.0) * scale);
-    let i = textureSample(original, original_sampler, uv + vec2<f32>(-0.5, 0.5) * scale);
-    let j = textureSample(original, original_sampler, uv + vec2<f32>(0.5, 0.5) * scale);
-    let k = textureSample(original, original_sampler, uv + vec2<f32>(-1.0, 1.0) * scale);
-    let l = textureSample(original, original_sampler, uv + vec2<f32>(0.0, 1.0) * scale);
-    let m = textureSample(original, original_sampler, uv + vec2<f32>(1.0, 1.0) * scale);
-
-    let div = (1.0 / 4.0) * vec2<f32>(0.5, 0.125);
-
-    var o: vec4<f32> = (d + e + i + j) * div.x;
-    o = o + (a + b + g + f) * div.y;
-    o = o + (b + c + h + g) * div.y;
-    o = o + (f + g + l + k) * div.y;
-    o = o + (g + h + m + l) * div.y;
-
-    return o;
+// "Next Generation Post Processing in Call of Duty: Advanced Warfare" slide 100
+fn sample_input_13_tap(uv: vec2<f32>) -> vec3<f32> {
+    let texel_size = 1.0 / vec2<f32>(textureDimensions(input_texture));
+    let x = texel_size.x;
+    let y = texel_size.y;
+
+    let a = textureSample(input_texture, s, vec2<f32>(uv.x - 2.0 * x, uv.y + 2.0 * y)).rgb;
+    let b = textureSample(input_texture, s, vec2<f32>(uv.x, uv.y + 2.0 * y)).rgb;
+    let c = textureSample(input_texture, s, vec2<f32>(uv.x + 2.0 * x, uv.y + 2.0 * y)).rgb;
+
+    let d = textureSample(input_texture, s, vec2<f32>(uv.x - 2.0 * x, uv.y)).rgb;
+    let e = textureSample(input_texture, s, vec2<f32>(uv.x, uv.y)).rgb;
+    let f = textureSample(input_texture, s, vec2<f32>(uv.x + 2.0 * x, uv.y)).rgb;
+
+    let g = textureSample(input_texture, s, vec2<f32>(uv.x - 2.0 * x, uv.y - 2.0 * y)).rgb;
+    let h = textureSample(input_texture, s, vec2<f32>(uv.x, uv.y - 2.0 * y)).rgb;
+    let i = textureSample(input_texture, s, vec2<f32>(uv.x + 2.0 * x, uv.y - 2.0 * y)).rgb;
+
+    let j = textureSample(input_texture, s, vec2<f32>(uv.x - x, uv.y + y)).rgb;
+    let k = textureSample(input_texture, s, vec2<f32>(uv.x + x, uv.y + y)).rgb;
+    let l = textureSample(input_texture, s, vec2<f32>(uv.x - x, uv.y - y)).rgb;
+    let m = textureSample(input_texture, s, vec2<f32>(uv.x + x, uv.y - y)).rgb;
+
+    var sample = e * 0.125;
+    sample += (a + c + g + i) * 0.03125;
+    sample += (b + d + f + h) * 0.0625;
+    sample += (j + k + l + m) * 0.125;
+    return sample;
 }
 
-// Samples original using a 3x3 tent filter.
-//
-// NOTE: Use a 2x2 filter for better perf, but 3x3 looks better.
-fn sample_original_3x3_tent(uv: vec2<f32>, scale: vec2<f32>) -> vec4<f32> {
-    let d = vec4<f32>(1.0, 1.0, -1.0, 0.0);
+// "Next Generation Post Processing in Call of Duty: Advanced Warfare" slide 109
+fn sample_input_3x3_tent(uv: vec2<f32>) -> vec3<f32> {
+    let x = 0.005;
+    let y = 0.005;
+
+    let a = textureSample(input_texture, s, vec2<f32>(uv.x - x, uv.y + y)).rgb;
+    let b = textureSample(input_texture, s, vec2<f32>(uv.x, uv.y + y)).rgb;
+    let c = textureSample(input_texture, s, vec2<f32>(uv.x + x, uv.y + y)).rgb;
 
-    var s: vec4<f32> = textureSample(original, original_sampler, uv - d.xy * scale);
-    s = s + textureSample(original, original_sampler, uv - d.wy * scale) * 2.0;
-    s = s + textureSample(original, original_sampler, uv - d.zy * scale);
+    let d = textureSample(input_texture, s, vec2<f32>(uv.x - x, uv.y)).rgb;
+    let e = textureSample(input_texture, s, vec2<f32>(uv.x, uv.y)).rgb;
+    let f = textureSample(input_texture, s, vec2<f32>(uv.x + x, uv.y)).rgb;
 
-    s = s + textureSample(original, original_sampler, uv + d.zw * scale) * 2.0;
-    s = s + textureSample(original, original_sampler, uv) * 4.0;
-    s = s + textureSample(original, original_sampler, uv + d.xw * scale) * 2.0;
+    let g = textureSample(input_texture, s, vec2<f32>(uv.x - x, uv.y - y)).rgb;
+    let h = textureSample(input_texture, s, vec2<f32>(uv.x, uv.y - y)).rgb;
+    let i = textureSample(input_texture, s, vec2<f32>(uv.x + x, uv.y - y)).rgb;
 
-    s = s + textureSample(original, original_sampler, uv + d.zy * scale);
-    s = s + textureSample(original, original_sampler, uv + d.wy * scale) * 2.0;
-    s = s + textureSample(original, original_sampler, uv + d.xy * scale);
+    var sample = e * 4.0;
+    sample += (b + d + f + h) * 2.0;
+    sample += (a + c + g + i);
+    sample /= 16.0;
 
-    return s / 16.0;
+    return sample;
 }
 
 @fragment
-fn downsample_prefilter(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> {
-    let texel_size = 1.0 / vec2<f32>(textureDimensions(original));
-
-    let scale = texel_size;
-
-    let curve = vec3<f32>(
-        uniforms.threshold - uniforms.knee,
-        uniforms.knee * 2.0,
-        0.25 / uniforms.knee,
-    );
-
-    var o: vec4<f32> = sample_13_tap(uv, scale);
-
-    o = quadratic_threshold(o, uniforms.threshold, curve);
-    o = max(o, vec4<f32>(0.00001));
-
-    return o;
+fn downsample_first(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> {
+    // TODO: Threshold
+    // TODO: Karis average
+    return vec4<f32>(sample_input_13_tap(uv), 1.0);
 }
 
 @fragment
 fn downsample(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> {
-    let texel_size = 1.0 / vec2<f32>(textureDimensions(original));
-
-    let scale = texel_size;
-
-    return sample_13_tap(uv, scale);
+    return vec4<f32>(sample_input_13_tap(uv), 1.0);
 }
 
 @fragment
 fn upsample(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> {
-    let texel_size = 1.0 / vec2<f32>(textureDimensions(original));
-
-    let upsample = sample_original_3x3_tent(uv, texel_size * uniforms.scale);
-    var color: vec4<f32> = textureSample(up, original_sampler, uv);
-    color = vec4<f32>(color.rgb + upsample.rgb, upsample.a);
-
-    return color;
+    return vec4<f32>(sample_input_3x3_tent(uv), 1.0);
 }
 
 @fragment
 fn upsample_final(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> {
-    let texel_size = 1.0 / vec2<f32>(textureDimensions(original));
+    let main_pass_sample = textureSample(main_pass_texture, s, uv);
+    let bloom_sample = sample_input_3x3_tent(uv);
 
-    let upsample = sample_original_3x3_tent(uv, texel_size * uniforms.scale);
+    let mixed_sample = mix(main_pass_sample.rgb, bloom_sample, settings.intensity);
 
-    return vec4<f32>(upsample.rgb * uniforms.intensity, upsample.a);
+    return vec4<f32>(mixed_sample, main_pass_sample.a);
 }