vert 0.1.1

The 51th Rust Game Engine, to write the 6th Game in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

// Source: Adapted from Bevy Source code, which in turn is from COD GDC talk.

struct VertexOutput {
    @location(0) uv: vec2<f32>,
    @builtin(position) clip_position: vec4<f32>,
};


struct ScreenSpace {
    width: f32,
    height: f32,
    aspect: f32,
}

@group(0) @binding(0)
var<uniform> screen: ScreenSpace;

@group(1)
@binding(0)
var hdr_image: texture_2d<f32>;

@group(1)
@binding(1)
var hdr_sampler: sampler;

@fragment
fn downsample(vs: VertexOutput) -> @location(0) vec4<f32> {
    let sample = sample_input_13_tap(vs.uv);
    return vec4(sample, 1.0);
}

@fragment
fn threshold_downsample(vs: VertexOutput) -> @location(0) vec4<f32> {
    let sample = sample_input_13_tap(vs.uv);
    return vec4(soft_threshold(sample.xyz), 1.0);
}

@fragment
fn upsample(vs: VertexOutput) -> @location(0) vec4<f32> {
    let sample = sample_input_3x3_tent(vs.uv);
    return vec4(sample,1.0);
}


// // [COD] slide 162
fn sample_input_3x3_tent(uv: vec2<f32>) -> vec3<f32> {
    // Radius. Empirically chosen by and tweaked from the LearnOpenGL article.
    let x = 0.004 / screen.aspect;
    let y = 0.004;

    let a = textureSample(hdr_image, hdr_sampler, vec2<f32>(uv.x - x, uv.y + y)).rgb;
    let b = textureSample(hdr_image, hdr_sampler, vec2<f32>(uv.x, uv.y + y)).rgb;
    let c = textureSample(hdr_image, hdr_sampler, vec2<f32>(uv.x + x, uv.y + y)).rgb;

    let d = textureSample(hdr_image, hdr_sampler, vec2<f32>(uv.x - x, uv.y)).rgb;
    let e = textureSample(hdr_image, hdr_sampler, vec2<f32>(uv.x, uv.y)).rgb;
    let f = textureSample(hdr_image, hdr_sampler, vec2<f32>(uv.x + x, uv.y)).rgb;

    let g = textureSample(hdr_image, hdr_sampler, vec2<f32>(uv.x - x, uv.y - y)).rgb;
    let h = textureSample(hdr_image, hdr_sampler, vec2<f32>(uv.x, uv.y - y)).rgb;
    let i = textureSample(hdr_image, hdr_sampler, vec2<f32>(uv.x + x, uv.y - y)).rgb;

    var sample = e * 0.25;
    sample += (b + d + f + h) * 0.125;
    sample += (a + c + g + i) * 0.0625;

    return sample;
}

/// Todo! look at bevy code where this comes from and 
const x: f32 = 0.5;
const y: f32 = 1.0;
const z: f32 = 1.0;
const w: f32 = 1.0;

fn soft_threshold(color: vec3<f32>) -> vec3<f32> {
    let brightness = max(color.r, max(color.g, color.b));
    var softness = brightness - y;
    softness = clamp(softness, 0.0, z);
    softness = softness * softness * w;
    var contribution = max(brightness - x, softness);
    contribution /= max(brightness, 0.00001); // Prevent division by 0
    return color * contribution;
}


// [COD] slide 153
fn sample_input_13_tap(uv: vec2<f32>) -> vec3<f32> {
    let a = textureSample(hdr_image, hdr_sampler, uv, vec2<i32>(-2, 2)).rgb;
    let b = textureSample(hdr_image, hdr_sampler, uv, vec2<i32>(0, 2)).rgb;
    let c = textureSample(hdr_image, hdr_sampler, uv, vec2<i32>(2, 2)).rgb;
    let d = textureSample(hdr_image, hdr_sampler, uv, vec2<i32>(-2, 0)).rgb;
    let e = textureSample(hdr_image, hdr_sampler, uv).rgb;
    let f = textureSample(hdr_image, hdr_sampler, uv, vec2<i32>(2, 0)).rgb;
    let g = textureSample(hdr_image, hdr_sampler, uv, vec2<i32>(-2, -2)).rgb;
    let h = textureSample(hdr_image, hdr_sampler, uv, vec2<i32>(0, -2)).rgb;
    let i = textureSample(hdr_image, hdr_sampler, uv, vec2<i32>(2, -2)).rgb;
    let j = textureSample(hdr_image, hdr_sampler, uv, vec2<i32>(-1, 1)).rgb;
    let k = textureSample(hdr_image, hdr_sampler, uv, vec2<i32>(1, 1)).rgb;
    let l = textureSample(hdr_image, hdr_sampler, uv, vec2<i32>(-1, -1)).rgb;
    let m = textureSample(hdr_image, hdr_sampler, uv, vec2<i32>(1, -1)).rgb;

    var sample = (a + c + g + i) * 0.03125;
    sample += (b + d + f + h) * 0.0625;
    sample += (e + j + k + l + m) * 0.125;
    return sample;
}



// fn sample_input_13_tap_initial(uv: vec2<f32>) -> vec3<f32> {
//     let a = textureSample(hdr_image, hdr_sampler, uv, vec2<i32>(-2, 2)).rgb;
//     let b = textureSample(hdr_image, hdr_sampler, uv, vec2<i32>(0, 2)).rgb;
//     let c = textureSample(hdr_image, hdr_sampler, uv, vec2<i32>(2, 2)).rgb;
//     let d = textureSample(hdr_image, hdr_sampler, uv, vec2<i32>(-2, 0)).rgb;
//     let e = textureSample(hdr_image, hdr_sampler, uv).rgb;
//     let f = textureSample(hdr_image, hdr_sampler, uv, vec2<i32>(2, 0)).rgb;
//     let g = textureSample(hdr_image, hdr_sampler, uv, vec2<i32>(-2, -2)).rgb;
//     let h = textureSample(hdr_image, hdr_sampler, uv, vec2<i32>(0, -2)).rgb;
//     let i = textureSample(hdr_image, hdr_sampler, uv, vec2<i32>(2, -2)).rgb;
//     let j = textureSample(hdr_image, hdr_sampler, uv, vec2<i32>(-1, 1)).rgb;
//     let k = textureSample(hdr_image, hdr_sampler, uv, vec2<i32>(1, 1)).rgb;
//     let l = textureSample(hdr_image, hdr_sampler, uv, vec2<i32>(-1, -1)).rgb;
//     let m = textureSample(hdr_image, hdr_sampler, uv, vec2<i32>(1, -1)).rgb;

//     // [COD] slide 168
//     //
//     // The first downsample pass reads from the rendered frame which may exhibit
//     // 'fireflies' (individual very bright pixels) that should not cause the bloom effect.
//     //
//     // The first downsample uses a firefly-reduction method proposed by Brian Karis
//     // which takes a weighted-average of the samples to limit their luma range to [0, 1].
//     // This implementation matches the LearnOpenGL article [PBB].
//     var group0 = (a + b + d + e) * (0.125f / 4.0f);
//     var group1 = (b + c + e + f) * (0.125f / 4.0f);
//     var group2 = (d + e + g + h) * (0.125f / 4.0f);
//     var group3 = (e + f + h + i) * (0.125f / 4.0f);
//     var group4 = (j + k + l + m) * (0.5f / 4.0f);
//     // group0 *= karis_average(group0);
//     // group1 *= karis_average(group1);
//     // group2 *= karis_average(group2);
//     // group3 *= karis_average(group3);
//     // group4 *= karis_average(group4);
//     return group0 + group1 + group2 + group3 + group4;
// }


// fn karis_average(color: vec3<f32>) -> f32 {
//     // Luminance calculated by gamma-correcting linear RGB to non-linear sRGB using pow(color, 1.0 / 2.2)
//     // and then calculating luminance based on Rec. 709 color primaries.
//     let luma = tonemapping_luminance(rgb_to_srgb_simple(color)) / 4.0;
//     return 1.0 / (1.0 + luma);
// }