to rebase

src/shaders/colorize.wgsl

@@ -31,8 +31,16 @@ struct Uniforms {
     shadow: u32,
 };
 
+struct Light {
+    azimuth: f32,
+    altitude: f32,
+    color: u32,
+    _pad: u32
+};
+
 @group(0) @binding(0) var<uniform> u: Uniforms;
 @group(0) @binding(1) var data_tex: texture_2d<f32>;
+@group(0) @binding(2) var<uniform> lights: array<Light, 16>;
 
 // Smooth cyclic palettes (Inigo Quilez cosine palettes). Must match the palette
 // in mandelbrot.wgsl.
@@ -71,11 +79,10 @@ fn load(x: i32, y: i32) -> vec3<f32> {
 }
 
 fn compute_light(normal: vec3<f32>, light: vec3<f32>) -> vec3<f32> {
-    return vec3<f32>((dot(normal, normalize(light)) + 0.2) / 1.2);
+    return vec3<f32>(max(0., dot(normal, normalize(light))));
 }
 
 fn uncharted2tonemap(x: vec3<f32>) -> vec3<f32> {
-// Paramètres de la courbe de Hable
     let A = 0.15; // Shoulder strength
     let B = 0.50; // Linear strength
     let C = 0.10; // Linear angle
@@ -84,20 +91,32 @@ fn uncharted2tonemap(x: vec3<f32>) -> vec3<f32> {
     let F = 0.30; // Toe denominator
 
     return ((x * (A * x + C * B) + D * E) / (x * (A * x + B) + D * F)) - E / F;
-}fn filmic(color: vec3<f32>) -> vec3<f32> {
+}
+
+fn filmic(color: vec3<f32>, white_point: f32) -> vec3<f32> {
     let exposure_bias = 2.0;
     let curr = uncharted2tonemap(color * exposure_bias);
     
     // Valeur blanche maximale de référence
-    let white_scale = vec3(1.0) / uncharted2tonemap(vec3(4.2));
+    let white_scale = vec3(1.0) / uncharted2tonemap(vec3(white_point));
     return curr * white_scale;
 }
 
+fn s(color: vec3<f32>, k: f32, c: f32) -> vec3<f32> {
+    return 1. / (1. + exp(-k * (color - c)));
+}
+
+fn contrast(color: vec3<f32>, k: f32, c: f32) -> vec3<f32> {
+    let color_c = s(color, k, c);
+
+    return (color_c - s(vec3<f32>(0), k, c)) / (s(vec3<f32>(1), k, c) - s(vec3<f32>(0), k, c));
+}
+
 @fragment
 fn fs_main(@builtin(position) pos: vec4<f32>) -> @location(0) vec4<f32> {
     if u.shadow != 0u {
         if textureLoad(data_tex, vec2<i32>(i32(pos.x), i32(pos.y)), 0).b != 0. {
-            return vec4<f32>(0., 0.11, 0.54, 1.0);
+            return vec4<f32>(0.1, 0.1, 0.1, 1.0);
         } else {
             let d = array<vec3<f32>, 3>(load(i32(pos.x), i32(pos.y)), load(i32(pos.x + 1), i32(pos.y)), load(i32(pos.x), i32(pos.y + 1)));
 
@@ -105,11 +124,30 @@ fn fs_main(@builtin(position) pos: vec4<f32>) -> @location(0) vec4<f32> {
 
             var color: vec3<f32>;
             if u.shadow_palette_id == 0u {
-                color = compute_light(normal,vec3<f32>(.5, .5, .5));
-            } else {
+                color = compute_light(normal,vec3<f32>(.5, .5, .5)) + vec3<f32>(0.58, 0.85, 1.) * 0.2;
+
+                color = filmic(color, 2.5);
+                color = contrast(color, 4., 0.67);
+            } else if u.shadow_palette_id == 1u {
                 color = compute_light(normal, vec3<f32>(0., .5, .5)) * vec3<f32>(1., 0.5, 0.5) + compute_light(normal, vec3<f32>(0.5, 0., .5)) * vec3<f32>(0.5, 1., 1.);
 
-                color = filmic(color);
+                color = filmic(color, 4.2);
+            } else {
+                color = vec3<f32>(0);
+                var light_count = 0;
+                for (var i = 0u ; i < 16; i++) {
+                    let light_color = unpack4x8unorm(lights[i].color);
+                    if any(light_color != vec4<f32>(0)) {
+                        light_count       += 1;
+                    }
+
+                    color       += compute_light(normal, vec3<f32>(
+                        cos(lights[i].azimuth) * cos(lights[i].altitude),
+                        sin(lights[i].azimuth) * cos(lights[i].altitude),
+                        sin(lights[i].altitude))) * light_color.xyz * light_color.a;
+                }
+
+                color = filmic(color, 1. + f32(light_count));
             }
 
             return vec4<f32>(color, 1.0);