Jengamon/rexweb - Change PAOLWMH7TLJLNAWBJBWP7KB7YGDFUPASMTFU33KZ3QW5JXJMPXCAC

naga-oil cuz that HDR bloom had my name written on it

Created by Jengamon on February 5, 2024

PAOLWMH7TLJLNAWBJBWP7KB7YGDFUPASMTFU33KZ3QW5JXJMPXCAC

Dependencies

In channels

main

Change contents

Insertion in src/world_shader.wgsl at line 35 [3.42]

[3.988]


fn meets_thresh(color: vec4<f32>) -> bool {
    // stack overflow magic \sqrt{0.299\cdot r^{2}+0.587\cdot g^{2}+0.114\cdot b^{2}}
    let brightness = sqrt(dot(color.rgb * color.rgb, vec3<f32>(0.299, 0.587, 0.114)));
    return brightness > 0.1;
}
const PI = 3.14159265359;
const STD_DEV: f32 = 6.8;
fn weight_calc(i: u32) -> f32 {
    let STD_DEV_P2 = pow(STD_DEV, 2.0);
    // use the gaussian kernel, until it's too slow otherwise
    return (1.0 / sqrt(2.0 * PI * STD_DEV_P2)) * exp(-pow(f32(i), 2.0) / (2.0 * STD_DEV_P2));
}

Insertion in src/world_shader.wgsl at line 53 [3.42]

[3.1056]

    var textureOffset = vec2<f32>(1) / vec2<f32>(textureDimensions(t_world));
    var result = in.color * textureSample(t_world, s_world, in.tex_coords);
    let strength = 2.0;
    var added: vec4<f32>;
    // let offset = vec2<f32>(textureOffset.x, textureOffset.y);
    let offset_y = vec2<f32>(0.0, textureOffset.y);
    let offset_x = vec2<f32>(textureOffset.x, 0.0);
    for(var i: u32 = 0; i < 5; i++) {
        let new_color_a = textureSample(t_world, s_world, in.tex_coords + offset_x * f32(i));
        let new_color_b = textureSample(t_world, s_world, in.tex_coords - offset_x * f32(i));
        if (meets_thresh(new_color_a)) {
            // result += vec4<f32>(new_color_a.rgb * weight[i], 0);
            added += vec4<f32>(new_color_a.rgb, 1.0 / strength) * weight_calc(i) * strength;
        }
        if (meets_thresh(new_color_b)) {
            // result += vec4<f32>(new_color_b.rgb * weight[i], 0);
            added += vec4<f32>(new_color_b.rgb, 1.0 / strength) * weight_calc(i) * strength;
        }
        let new_color_c = textureSample(t_world, s_world, in.tex_coords + offset_y * f32(i)) + added;
        let new_color_d = textureSample(t_world, s_world, in.tex_coords - offset_y * f32(i)) + added;
        if (meets_thresh(new_color_c)) {
            // result += vec4<f32>(new_color_a.rgb * weight[i], 0);
            added += vec4<f32>(new_color_c.rgb, 1.0 / strength) * weight_calc(i) * strength;
        }
        if (meets_thresh(new_color_d)) {
            // result += vec4<f32>(new_color_b.rgb * weight[i], 0);
            added += vec4<f32>(new_color_d.rgb, 1.0 / strength) * weight_calc(i) * strength;
        }
    }
    // We do it this weird way, cuz the world texture is *not* HDR atm
    let hdr = result + added;
    let sdr = hdr::aces_tone_map(hdr.rgb);
    result = vec4<f32>(sdr, hdr.a);

Replacement in src/world_shader.wgsl at line 87 [3.42]

B:BD[3.1080] → [3.1080:1150]

    return in.color * textureSample(t_world, s_world, in.tex_coords);

[3.1080]

[3.1150]

    // return in.color * textureSample(t_world, s_world, in.tex_coords);
    return result;

Replacement in src/text.rs at line 60 [4.32]

B:BD[4.1022] → [4.1022:1103]

    pub fn prepare(&mut self, _data: &TextSystemData, assets: &mut AssetCache) {

[4.1022]

[4.1103]

    pub fn prepare(&mut self, _data: &TextSystemData, assets: &AssetCache) {

Replacement in src/text.rs at line 111 [4.32]

B:BD[5.1188] → [6.0:78]

            BufferMapper::new(self.convert_world_to_glyphon_world(loc), 2.0),

[5.1188]

[5.1266]

            BufferMapper::new(self.convert_world_to_glyphon_world(loc), 1.0),

Replacement in src/screen.rs at line 1 [7.51]
B:BD[7.51] → [8.0:20]
```
use std::sync::Arc;
```
[7.51]
[8.20]
```
use std::{collections::HashMap, sync::Arc};
```
Insertion in src/screen.rs at line 3 [7.51]
[8.21]
[7.52]
```
use assets_manager::AssetCache;
```
Insertion in src/screen.rs at line 7 [7.51]
[3.2871]
[3.2871]
```
use naga_oil::compose;
```

Insertion in src/screen.rs at line 36 [7.51]

[3.3507]

[8.129]

    // Shader fun
    // composer: compose::Composer,

Replacement in src/screen.rs at line 69 [7.51]

B:BD[3.4153] → [2.249:275]

∅:D[2.275] → [3.4179:4206]

B:BD[3.4179] → [3.4179:4206]

            width: 600.0,
            height: 400.0,

[3.4153]

[2.276]

            width: 300.0,
            height: 200.0,

Replacement in src/screen.rs at line 259 [7.51]

∅:D[3.7491] → [7.386:453]

B:BD[7.386] → [7.386:453]

    pub async fn new(window: Window) -> color_eyre::Result<Self> {

[3.7491]

[7.453]

    fn create_composer(_assets: &AssetCache) -> Result<compose::Composer, compose::ComposerError> {
        let mut composer = compose::Composer::default();
        // HDR module
        let hdr_module_src = include_str!("./hdr.wgsl");
        let (name, imports, shader_defs) = compose::get_preprocessor_data(hdr_module_src);
        composer.add_composable_module(compose::ComposableModuleDescriptor {
            as_name: name,
            source: hdr_module_src,
            file_path: "hdr.wgsl",
            language: compose::ShaderLanguage::Wgsl,
            additional_imports: &imports,
            shader_defs,
        })?;
        Ok(composer)
    }
    pub async fn new(window: Window, assets: &AssetCache) -> color_eyre::Result<Self> {

Replacement in src/screen.rs at line 301 [7.51]

B:BD[7.1264] → [8.402:466]

                    required_features: wgpu::Features::empty(),

[7.1264]

[8.466]

                    required_features: wgpu::Features::all_webgpu_mask(),

Replacement in src/screen.rs at line 303 [7.51]

∅:D[8.537] → [7.1381:1447]

B:BD[7.1381] → [7.1381:1447]

                        wgpu::Limits::downlevel_webgl2_defaults()

[8.537]

[7.1447]

                        wgpu::Limits::downlevel_defaults()

Insertion in src/screen.rs at line 340 [7.51]

[7.2758]

[8.585]


        // World texture is HDR, so the format must be a HDR format
        let world_texture_format = wgpu::TextureFormat::Rgba16Float;

Replacement in src/screen.rs at line 346 [7.51]

B:BD[7.2759] → [3.7553:7637]

        let world_atlas = glyphon::TextAtlas::new(&device, &queue, surface_format);

[7.2759]

[3.7637]

        let world_atlas = glyphon::TextAtlas::new(&device, &queue, world_texture_format);

Insertion in src/screen.rs at line 349 [7.51]

[3.7723]

        let mut composer = Self::create_composer(assets)?;

Replacement in src/screen.rs at line 372 [7.51]

B:BD[3.8754] → [3.8754:8868]

            // Use the same format as the surface we will have to write to...
            format: surface_format,

[3.8754]

[3.8868]

            format: world_texture_format,

Replacement in src/screen.rs at line 383 [7.51]

B:BD[3.9468] → [3.9468:9519]

            min_filter: wgpu::FilterMode::Nearest,

[3.9468]

[3.9519]

            min_filter: wgpu::FilterMode::Linear,

Insertion in src/screen.rs at line 455 [7.51]

[3.12711]

        // let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
        // label: Some("world shader"),
        // source: wgpu::ShaderSource::Wgsl(include_str!("world_shader.wgsl").into()),
        // });
        let composed_world_shader = composer.make_naga_module(compose::NagaModuleDescriptor {
            source: include_str!("world_shader.wgsl"),
            file_path: "world_shader.wgsl",
            shader_type: compose::ShaderType::Wgsl,
            shader_defs: HashMap::new(),
            additional_imports: &[],
        })?;
        let mut validator = naga::valid::Validator::new(
            naga::valid::ValidationFlags::default(),
            naga::valid::Capabilities::default(),
        );
        let composed_world_shader_module_info = validator.validate(&composed_world_shader)?;
        let shader_source = naga::back::wgsl::write_string(
            &composed_world_shader,
            &composed_world_shader_module_info,
            naga::back::wgsl::WriterFlags::EXPLICIT_TYPES,
        )?;

Replacement in src/screen.rs at line 479 [7.51]

B:BD[3.12832] → [3.12832:12920]

            source: wgpu::ShaderSource::Wgsl(include_str!("world_shader.wgsl").into()),

[3.12832]

[3.12920]

            source: wgpu::ShaderSource::Wgsl(shader_source.into()),

Insertion in src/screen.rs at line 545 [7.51]
[3.15205]
[8.666]
```
            // composer,
```

Replacement in src/main.rs at line 54 [7.5397]

B:BD[7.6873] → [7.6873:6912]

    let mut game = Game::new(window)?;

[7.6873]

[7.6912]

    let mut game = match Game::new(window) {
        Ok(game) => game,
        Err(e) => {
            log::error!("{}", e);
            return Err(e);
        }
    };

File addition: hdr.wgsl (----------)

[7.15]

#define_import_path hdr
// Maps HDR values to linear values
// Based on http://www.oscars.org/science-technology/sci-tech-projects/aces
fn aces_tone_map(hdr: vec3<f32>) -> vec3<f32> {
    let m1 = mat3x3(
        0.59719, 0.07600, 0.02840,
        0.35458, 0.90834, 0.13383,
        0.04823, 0.01566, 0.83777,
    );
    let m2 = mat3x3(
        1.60475, -0.10208, -0.00327,
        -0.53108,  1.10813, -0.07276,
        -0.07367, -0.00605,  1.07602,
    );
    let v = m1 * hdr;
    let a = v * (v + 0.0245786) - 0.000090537;
    let b = v * (0.983729 * v + 0.4329510) + 0.238081;
    return clamp(m2 * (a / b), vec3(0.0), vec3(1.0));
}

Deletion in src/game.rs at line 60 [7.9635]
B:BD[7.9925] → [8.3403:3423]
```
            assets,
```

Replacement in src/game.rs at line 63 [7.9635]

∅:D[8.3484] → [7.10012:10074]

B:BD[7.10012] → [7.10012:10074]

            screen: pollster::block_on(Screen::new(window))?,

[8.3484]

[3.19290]

            screen: pollster::block_on(Screen::new(window, &assets))?,
            assets,

Replacement in src/game.rs at line 176 [7.9635]

B:BD[4.7826] → [4.7826:7883]

        self.text.prepare(&text_data, &mut self.assets);

[4.7826]

[4.7883]

        self.text.prepare(&text_data, &self.assets);

Insertion in Cargo.toml at line 24 [7.12025]

[7.12485]

naga = { version = "0.19.0", features = ["spv-out", "wgsl-out"] }
naga_oil = "0.13.0"

Replacement in Cargo.toml at line 36 [7.12025]
∅:D[9.377] → [8.7241:7255]
∅:D[10.1898] → [8.7241:7255]
B:BD[7.12668] → [8.7241:7255]
```
wgpu = "0.19"
```
[10.1898]
[8.7255]
```
wgpu = { version = "0.19", features = ["spirv", "naga"] }
```
Insertion in Cargo.lock at line 415 [7.12974]
[7.24203]
[7.24203]
```
 "naga",
 "naga_oil",
```

Insertion in Cargo.lock at line 774 [7.12974]

[7.35929]

name = "data-encoding"
version = "2.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7e962a19be5cfc3f3bf6dd8f61eb50107f356ad6270fbb3ed41476571db78be5"
[[package]]

Insertion in Cargo.lock at line 1031 [7.12974]

[7.41520]

name = "fixedbitset"
version = "0.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
[[package]]

Insertion in Cargo.lock at line 1839 [7.12974]
[7.65220]
[7.65220]
```
 "petgraph",
 "pp-rs",
```

Insertion in Cargo.lock at line 1849 [7.12974]

[7.65529]

name = "naga_oil"
version = "0.13.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c0ea62ae0f2787456afca7209ca180522b41f00cbe159ee369eba1e07d365cd1"
dependencies = [
 "bit-set",
 "codespan-reporting",
 "data-encoding",
 "indexmap",
 "naga",
 "once_cell",
 "regex",
 "regex-syntax",
 "rustc-hash",
 "thiserror",
 "tracing",
 "unicode-ident",
]
[[package]]

Insertion in Cargo.lock at line 2200 [7.12974]

[7.76867]

[7.77624]

name = "petgraph"
version = "0.6.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e1d3afd2628e69da2be385eb6f2fd57c8ac7977ceeff6dc166ff1657b0e386a9"
dependencies = [
 "fixedbitset",
 "indexmap",
]
[[package]]

Insertion in Cargo.lock at line 2284 [7.12974]

[7.79406]

name = "pp-rs"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bb458bb7f6e250e6eb79d5026badc10a3ebb8f9a15d1fff0f13d17c71f4d6dee"
dependencies = [
 "unicode-xid",
]
[[package]]

Insertion in Cargo.lock at line 3126 [7.12974]
[7.102404]
[7.102404]
```
 "tracing-attributes",
```

Insertion in Cargo.lock at line 3128 [7.12974]

[7.102421]

]
[[package]]
name = "tracing-attributes"
version = "0.1.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
dependencies = [
 "proc-macro2",
 "quote",
 "syn 2.0.48",