global shadow

src/client/render/voxel/shader.wgsl

@@ -75,13 +75,13 @@ const DEPTH = 20;
 const FULL_ALPHA = 0.9999;
 const GLOBAL_LIGHT = vec3<f32>(-0.5, -4.0, 2.0);
 
-fn trace_full(pos_view: vec4<f32>, dir_view: vec4<f32>) -> vec4<f32> {
+fn trace_full(pos: vec4<f32>, dir: vec4<f32>) -> vec4<f32> {
     // GPUs hate this
     var depths = array<f32,DEPTH>();
     var colors = array<u32,DEPTH>();
 
     for (var gi: u32 = 0; gi < arrayLength(&voxel_groups); gi = gi + 1) {
-        apply_group(gi, pos_view, dir_view, &depths, &colors);
+        apply_group(gi, pos, dir, &depths, &colors);
     }
     var color = vec4<f32>(0.0);
     for (var di = 0; di < DEPTH; di += 1) {
@@ -181,7 +181,7 @@ fn apply_group(
         // hit a voxel
         if vcolor.a > 0.0 {
             let full_t = t_offset + prev_t;
-            // skip closer depth hits, or completely if behind opaque
+            // skip closer depth hits, or finish if behind opaque
             var a = unpack4x8unorm((*colors)[depth]).a;
             while (*depths)[depth] < full_t && a != 0.0 {
                 alpha += (1.0 - alpha) * a;
@@ -198,9 +198,21 @@ fn apply_group(
                 (*depths)[move_d + 1] = (*depths)[move_d];
                 move_d += 1;
             }
+            let full_pos = pos_view + dir_view * full_t;
+
+            // lighting
+            let shadow = trace_light(full_pos);
+            let diffuse = max(dot(norm_light, normal) * 1.3 + 0.1, 0.0);
+            let ambient = 0.2;
+            let specular = (exp(max(
+                -(dot(reflect(dir_view.xyz, normal), norm_light) + 0.90) * 4.0, 0.0
+            )) - 1.0) * shadow;
+            let lighting = max(diffuse, ambient) * shadow;
+            let new_rgb = min(vcolor.xyz * lighting + vec3<f32>(specular), vec3<f32>(1.0));
+            let new_a = min(vcolor.a + specular, 1.0);
+            let color = vec4<f32>(new_rgb, new_a);
+
             // add hit
-            let light = max(dot(norm_light, normal) * 1.3 + 0.1, 0.1);
-            var color = vec4<f32>(vcolor.xyz * light, vcolor.a);
             (*depths)[depth] = full_t;
             (*colors)[depth] = pack4x8unorm(color);
             prev_a = vcolor.a;
@@ -214,6 +226,87 @@ fn apply_group(
     }
 }
 
+fn trace_light(
+    pos: vec4<f32>
+) -> f32 {
+    let dir = vec4<f32>(-normalize(GLOBAL_LIGHT), 0.0);
+    var mask = 1.0;
+    let start = pos + dir * .001;
+    for (var gi: u32 = 0; gi < arrayLength(&voxel_groups); gi = gi + 1) {
+        let color = trace_one(gi, start, dir);
+        mask -= mask * color.a;
+        if mask <= .0001 {
+            return mask;
+        }
+    }
+    return mask;
+}
+
+fn trace_one(gi: u32, pos_view: vec4<f32>, dir_view: vec4<f32>) -> vec4<f32> {
+    let group = voxel_groups[gi];
+    let dim_f = vec3<f32>(group.dimensions);
+    let dim_i = vec3<i32>(group.dimensions);
+
+    // transform so that group is at 0,0
+    var pos = (group.transform_inv * pos_view).xyz;
+    let dir = (group.transform_inv * dir_view).xyz;
+
+    let dir_if = sign(dir);
+
+
+
+    // find where ray intersects with group
+    let plane_point = (vec3<f32>(1.0) - dir_if) / 2.0 * dim_f;
+    var t_offset = 0.0;
+    if outside3f(pos, ZERO3F, dim_f) {
+        // time of intersection; x = td + p, solve for t
+        let t_i = (plane_point - pos) / dir;
+        // points of intersection
+        let px = pos + t_i.x * dir;
+        let py = pos + t_i.y * dir;
+        let pz = pos + t_i.z * dir;
+
+        // check if point is in bounds
+        let hit = vec3<bool>(
+            inside2f(px.yz, ZERO2F, dim_f.yz),
+            inside2f(py.xz, ZERO2F, dim_f.xz),
+            inside2f(pz.xy, ZERO2F, dim_f.xy),
+        ) && (t_i > ZERO3F);
+        if !any(hit) {
+            return vec4<f32>(0.0);
+        }
+        pos = select(select(pz, py, hit.y), px, hit.x);
+        t_offset = select(select(t_i.z, t_i.y, hit.y), t_i.x, hit.x);
+    }
+    var vox_pos = clamp(vec3<i32>(pos), vec3<i32>(0), dim_i - vec3<i32>(1));
+
+
+
+    let dir_i = vec3<i32>(dir_if);
+    // time to move 1 unit using dir
+    let inc_t = abs(1.0 / dir);
+    let corner = vec3<f32>(vox_pos) + vec3<f32>(0.5) + dir_if / 2.0;
+
+    // time of next plane hit for each direction
+    var next_t = inc_t * abs(pos - corner);
+    var color = vec4<f32>(0.0);
+    loop {
+        let i = u32(vox_pos.x + vox_pos.y * dim_i.x + vox_pos.z * dim_i.x * dim_i.y) + group.offset;
+        var vcolor = unpack4x8unorm(voxels[i]);
+
+        // select next voxel to move to next based on least time
+        let axis = select(select(2, 1, next_t.y < next_t.z), 0, next_t.x < next_t.y && next_t.x < next_t.z);
+        vox_pos[axis] += dir_i[axis];
+        next_t[axis] += inc_t[axis];
+        color += vec4<f32>(vcolor.xyz * vcolor.a * (1.0 - color.a), (1.0 - color.a) * vcolor.a);
+
+        if color.a >= FULL_ALPHA || vox_pos[axis] < 0 || vox_pos[axis] >= dim_i[axis] {
+            break;
+        }
+    }
+    return color;
+}
+
 fn outside3f(v: vec3<f32>, low: vec3<f32>, high: vec3<f32>) -> bool {
     return any(v < low) || any(v > high);
 }