Add raymarched fog

res/shaders/fog.wgsl

@@ -1,46 +1,72 @@
 #include globals.wgsl
+#include constants.wgsl
+#include noise.wgsl
+
+struct FogVertexOutput {
+    @builtin(position) clip_position: vec4<f32>,
+    @location(0) world_position: vec3<f32>,
+    @location(1) light_world_position: vec3<f32>,
+}
 
 @vertex
 fn vs_main(
     model: VertexInput,
     instance: InstanceInput,
-) -> VertexOutput {
+) -> FogVertexOutput {
     let model_matrix = mat4x4<f32>(
         instance.model_matrix_0,
         instance.model_matrix_1,
         instance.model_matrix_2,
         instance.model_matrix_3,
     );
-    let normal_matrix = mat3x3<f32>(
-        instance.normal_matrix_0,
-        instance.normal_matrix_1,
-        instance.normal_matrix_2,
-    );
-
-    let world_normal = normalize(normal_matrix * model.normal);
-    let world_tangent = normalize(normal_matrix * model.tangent);
-    let world_bitangent = normalize(normal_matrix * model.bitangent);
-    let tangent_matrix = transpose(mat3x3<f32>(
-        world_tangent,
-        world_bitangent,
-        world_normal,
-    ));
 
     let world_position = model_matrix * vec4<f32>(model.position, 1.0);
 
-    var out: VertexOutput;
+    var out: FogVertexOutput;
     out.clip_position = camera.proj * camera.view * world_position;
-    out.tex_coords = model.tex_coords;
-    out.tangent_position = tangent_matrix * world_position.xyz;
-    out.tangent_light_position = tangent_matrix * light.position;
-    out.tangent_view_position = tangent_matrix * camera.position.xyz;
-
-    out.world_position = world_position;
+    out.world_position = world_position.xyz / world_position.w;
+    out.light_world_position = light.position;
 
     return out;
 }
 
-@fragment
-fn fs_main(vert: VertexOutput) -> @location(0) vec4<f32> {
-    return vec4<f32>(0.5, 0.5, 0.5, 0.1);
+fn fog_noise(pos: vec3<f32>) -> f32 {
+    var p = pos * FOG_SCALE;
+    p.x += global_uniforms.time * 0.01;
+    p.y += global_uniforms.time * 0.1;
+    p.z += sin(global_uniforms.time * 0.1) * 0.1;
+    return fbm(p);
+}
+
+fn ray_march(origin: vec3<f32>, direction: vec3<f32>, scene_depth: f32) -> f32 {
+    var density = 0.0;
+    var depth = 0.0;
+    for (var i = 0; i < FOG_MAX_STEPS; i++)
+    {
+        depth += FOG_MAX_DIST / f32(FOG_MAX_STEPS);
+        let p = origin + direction * depth;
+        density += fog_noise(p) * FOG_DENSITY / f32(FOG_MAX_STEPS);
+        if (density >= 1.0)
+        {
+            density = 1.0;
+            break;
+        }
+        if (depth >= scene_depth)
+        {
+            break;
+        }
+    }
+    return density;
+}
+
+@fragment
+fn fs_main(vert: FogVertexOutput) -> @location(0) vec4<f32> {
+    var color = vec4<f32>(0.5, 0.5, 0.5, 1.0);
+
+    let direction = normalize(vert.world_position.xyz - camera.position.xyz);
+    let scene_depth = FOG_MAX_DIST; // TODO: sample geometry pass depth buffer
+    let density = ray_march(vert.world_position.xyz, direction, scene_depth);
+    color.a *= density;
+
+    return color;
 }