@woosh/meep-engine 3.65.0 → 3.68.0

package/src/shade/renderer/global_illumination/screen_probe/shader_screen_probe_trace_screen.js

@@ -0,0 +1,275 @@
+import { chunk_project_position_from_depth } from "../../shader/chunk/camera/chunk_project_position_from_depth.js";
+import { chunk_get_view_space_depth } from "../../shader/chunk/depth/chunk_get_view_space_depth.js";
+import { chunk_is_background } from "../../shader/chunk/depth/chunk_is_background.js";
+import {
+    chunk_decode_g_buffer_face_normal
+} from "../../shader/chunk/geometry/normal/chunk_decode_g_buffer_face_normal.js";
+import { chunk_uv_equal_area_sphere } from "../../shader/chunk/geometry/octahedron/chunk_uv_equal_area_sphere.js";
+import {
+    chunk_uv_octahedral_unit_decode
+} from "../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_decode.js";
+import { chunk_folded_workgroup_index } from "../../shader/chunk/grid/chunk_folded_workgroup_index.js";
+import { chunk_stbn_sample_vec2 } from "../../shader/chunk/noise/chunk_stbn_sample_vec2.js";
+import { SCREEN_HZB_RESOURCE } from "../../shader/chunk/screen_space/SCREEN_SPACE_RESOURCES.js";
+import {
+    chunk_subgroup_append_slot,
+    SUBGROUP_APPEND_NONE
+} from "../../shader/chunk/subgroup/chunk_subgroup_append_slot.js";
+import { chunk_ndc_to_uv } from "../../shader/chunk/texture/chunk_ndc_to_uv.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceDescriptor } from "../../shader/resource/ShaderResourceDescriptor.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { STBN_VEC2_RESOURCE } from "../../STATIC_GRAPHICS_ENGINE_ASSET_RESOURCES.js";
+import {
+    chunk_screen_probe,
+    chunk_screen_probe_counts,
+    chunk_screen_probe_ray_jitter,
+    SCREEN_PROBE_COUNTERS_RESOURCE,
+    SCREEN_PROBE_DISPATCH_READ_RESOURCE,
+    SCREEN_PROBE_EXPOSURE_RESOURCE,
+    SCREEN_PROBE_FRAME_RESOURCE,
+    SCREEN_PROBE_PICKS_READ_RESOURCE,
+    SCREEN_PROBE_RAY_INFO_READ_RESOURCE,
+    SCREEN_PROBE_RAYS_WRITE_RESOURCE,
+    SCREEN_PROBE_TRACE_HIT_WRITE_RESOURCE,
+    SCREEN_PROBE_TRACE_RADIANCE_WRITE_RESOURCE,
+    SCREEN_PROBES_READ_RESOURCE
+} from "./chunk_screen_probe.js";
+import {
+    chunk_screen_probe_object_speed,
+    SCREEN_PROBE_CAMERA_PREVIOUS_RESOURCE,
+    SCREEN_PROBE_CAMERA_RESOURCE,
+    SCREEN_PROBE_DEPTH_RESOURCE,
+    SCREEN_PROBE_PBR_RESOURCE,
+    SCREEN_PROBE_VELOCITY_RESOURCE
+} from "./chunk_screen_probe_surface.js";
+import { chunk_screen_probe_march_distance } from "./chunk_screen_probe_march_distance.js";
+import { chunk_screen_probe_screen_march } from "./chunk_screen_probe_screen_march.js";
+import {
+    SCREEN_PROBE_COUNTER_BRICK_RAYS,
+    SCREEN_PROBE_MOVING_SPEED,
+    SCREEN_PROBE_SCREEN_EDGE,
+    SCREEN_PROBE_SCREEN_THICKNESS,
+    SCREEN_PROBE_THREAD_WORKGROUP_SIZE
+} from "./SCREEN_PROBE.js";
+
+/** Last frame's lit colour of the opaque surfaces, the view's size, before transparencies and fog. @type {ShaderResourceDescriptor} */
+export const SCREEN_PROBE_COLOR_HISTORY_RESOURCE = ShaderResourceDescriptor.texture("screen_probe_color_history", "unfilterable-float");
+
+/** The TAA's history confidence a pixel, in `r` (`shader_depth_occlusion_clip`). @type {ShaderResourceDescriptor} */
+export const SCREEN_PROBE_OCCLUSION_RESOURCE = ShaderResourceDescriptor.texture("tOcclusion", "unfilterable-float");
+
+/**
+ * Settings of the screen trace.
+ * @type {WebGPUStruct}
+ */
+export const SCREEN_PROBE_TRACE_SCREEN_SETTINGS = WebGPUStruct.from({
+    /** slots of the list of rays left to the bricks */
+    capacity: u32,
+}, "ScreenProbeTraceScreenSettings");
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", SCREEN_PROBE_TRACE_SCREEN_SETTINGS);
+
+resources.createGroup()
+    .add(SCREEN_PROBE_FRAME_RESOURCE)
+    .add(SCREEN_PROBE_EXPOSURE_RESOURCE)
+    .add(SCREEN_PROBE_CAMERA_RESOURCE)
+    .add(SCREEN_PROBE_CAMERA_PREVIOUS_RESOURCE)
+    .add(SCREEN_PROBES_READ_RESOURCE)
+    .add(SCREEN_PROBE_PICKS_READ_RESOURCE)
+    .add(SCREEN_PROBE_DISPATCH_READ_RESOURCE)
+    .add(SCREEN_PROBE_COUNTERS_RESOURCE)
+    .add(SCREEN_PROBE_RAYS_WRITE_RESOURCE)
+    .add(STBN_VEC2_RESOURCE);
+
+resources.createGroup()
+    .add(SCREEN_PROBE_RAY_INFO_READ_RESOURCE)
+    .add(SCREEN_PROBE_DEPTH_RESOURCE)
+    .add(SCREEN_HZB_RESOURCE)
+    .add(SCREEN_PROBE_PBR_RESOURCE)
+    .add(SCREEN_PROBE_VELOCITY_RESOURCE)
+    .add(SCREEN_PROBE_COLOR_HISTORY_RESOURCE)
+    .add(SCREEN_PROBE_OCCLUSION_RESOURCE)
+    .add(SCREEN_PROBE_TRACE_RADIANCE_WRITE_RESOURCE)
+    .add(SCREEN_PROBE_TRACE_HIT_WRITE_RESOURCE);
+
+/**
+ * The screen trace (Lumen's `ScreenProbeTraceScreenTexturesCS`): a thread a ray of the frame's probes, through the
+ * thread-a-ray command; a ray finds its probe and slot from its index, and its direction from its info and its probe's
+ * jitter (`screen_probe_ray_direction`).
+ *
+ * - **Origin**: the probe's surface point, lifted along its face normal by twice the depth half a pixel's offset makes
+ *   along it (Lumen's normal bias): the depth buffer's texels stand proud of the plane they sample. An origin the lift
+ *   moves off the screen traces nothing in it.
+ * - **Reach**: the march covers the probe's reach (`screen_probe_picks`), cut short of the camera's plane, 0.99 of the
+ *   way, for a ray heading toward it, as Lumen's `TraceScreen` cuts it.
+ * - **March**: the depth buffer's hierarchy from the full-resolution level, `ffx_sssr_hierarchical_raymarch`, the
+ *   engine's HZB traversal (SSR's), `SCREEN_PROBE_SCREEN_TRACE_STEPS` steps at most; past the reach's end it is a miss.
+ * - **A hit** stands at most `SCREEN_PROBE_SCREEN_THICKNESS` of the surface's depth behind it, on a surface the ray
+ *   meets from its front (its face normal against the ray), and holds when two dithered tests pass, as Lumen's: the
+ *   screen-edge fade at the hit (`SCREEN_PROBE_SCREEN_EDGE`) and the TAA's confidence in the hit pixel's history, so
+ *   last frame's colour is that surface's. Its radiance is last frame's lit colour of the opaque surfaces at the hit
+ *   pixel's place last frame (its velocity), a bounce more each frame, pre-exposed (`screen_probe_exposure`). It is moving when its speed and the probe's
+ *   differ by `SCREEN_PROBE_MOVING_SPEED` of the probe's depth, held to a metre from below.
+ * - **Anything else** is left to the bricks, appended to their list (one atomic a subgroup) with how far the screen
+ *   showed it clear: to the end of the march, or to a hit the tests refused, so the bricks resume in front of that
+ *   surface. A ray of a probe on no surface ends here, NONE.
+ *
+ * Every lane appends, wanting or not, from uniform control flow.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_screen_probe_trace_screen = ComputeShader.from({
+    label: "Screen Probe Trace Screen",
+    resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+// the dithered fade toward the screen's edges at a screen position in [-1, 1], Lumen's ComputeHitVignetteFromScreenPos
+fn screen_probe_edge_fade(ndc: vec2<f32>) -> f32 {
+    let v = saturate((abs(ndc) - ${1 - SCREEN_PROBE_SCREEN_EDGE}) / ${SCREEN_PROBE_SCREEN_EDGE});
+
+    return saturate(1.0 - dot(v, v));
+}
+
+@compute @workgroup_size(${SCREEN_PROBE_THREAD_WORKGROUP_SIZE})
+fn main(
+    @builtin(workgroup_id) workgroup_id: vec3<u32>,
+    @builtin(local_invocation_index) lane: u32,
+) {
+    let frame = screen_probe_frame;
+    let ray = folded_workgroup_index(workgroup_id) * ${SCREEN_PROBE_THREAD_WORKGROUP_SIZE}u + lane;
+    let ray_shift = 2u * frame.octahedron_shift;
+    let probe = ray >> ray_shift;
+    let slot = ray & ((1u << ray_shift) - 1u);
+    let size = vec2<f32>(frame.view_size);
+
+    var pending = false;
+    var clear = 0.0;
+    var packed = 0u;
+    var texel = vec2<u32>(0u);
+
+    if (probe < screen_probe_count()) {
+        texel = screen_probe_texel(probe, slot);
+
+        let record = screen_probes[probe];
+
+        if (record.depth <= 0.0) {
+            textureStore(screen_probe_trace_hit, texel, vec4<u32>(screen_probe_trace_hit_pack(SCREEN_PROBE_TRACE_NONE, 0.0, false), 0u, 0u, 0u));
+        } else {
+            let pixel = screen_probe_pixel_decode(record.pixel);
+            let tile = screen_probe_noise_tile(probe, pixel);
+            let direction = screen_probe_ray_direction(textureLoad(screen_probe_ray_info, texel, 0).r, screen_probe_ray_jitter(tile));
+            let normal = uv_octahedral_unit_decode(unpack2x16unorm(record.normal));
+            let reach = screen_probe_picks[probe].reach;
+            let noise = stbn_sample_vec2(vec3<u32>(texel, frame.frame_index));
+
+            packed = pack2x16unorm(uv_equal_area_sphere_encode(direction));
+            pending = true;
+
+            if (frame.screen_traces != 0u) {
+                // the lift: twice how far half a pixel's offset at the probe's depth moves along the normal
+                let uv = (vec2<f32>(pixel) + 0.5) / size;
+                let device_depth = textureLoad(tDepth, pixel, 0).r;
+                let corner = project_position_from_depth(uv + 0.5 / size, device_depth, camera.view_projection_matrix_inverse);
+                let origin = record.position + normal * (2.0 * abs(dot(corner - record.position, normal)));
+                let origin_clip = camera.view_projection_matrix * vec4<f32>(origin, 1.0);
+
+                if (origin_clip.w > 0.0 && all(abs(origin_clip.xy) <= vec2<f32>(origin_clip.w))) {
+                    // a ray heading toward the camera's plane stops short of it
+                    let forward = -camera.transform[2].xyz;
+                    let toward = dot(direction, forward);
+                    let plane_distance = dot(origin - camera.transform[3].xyz, forward);
+                    let segment = select(reach, min(reach, 0.99 * plane_distance / -toward), toward < 0.0);
+
+                    let origin_ndc = origin_clip.xyz / origin_clip.w;
+                    let end_clip = camera.view_projection_matrix * vec4<f32>(origin + direction * segment, 1.0);
+                    let end_ndc = end_clip.xyz / end_clip.w;
+
+                    let start = vec3<f32>(ndc_to_uv(origin_ndc.xy), origin_ndc.z);
+                    let span = vec3<f32>(ndc_to_uv(end_ndc.xy), end_ndc.z) - start;
+
+                    let march = screen_probe_screen_march(start, span, size);
+
+                    clear = screen_probe_march_distance(march.t, segment, origin_clip.w, end_clip.w);
+
+                    if (march.hit) {
+                        let hit_pixel = vec2<u32>(clamp(march.reached.xy * size, vec2<f32>(0.0), size - 1.0));
+                        let surface_device = textureLoad(tDepth, hit_pixel, 0).r;
+
+                        if (!is_background(surface_device)) {
+                            let surface_depth = get_view_space_depth(surface_device, camera);
+                            let ray_depth = get_view_space_depth(march.reached.z, camera);
+                            let hit_uv = (vec2<f32>(hit_pixel) + 0.5) / size;
+                            let hit_position = project_position_from_depth(hit_uv, surface_device, camera.view_projection_matrix_inverse);
+                            let face = decode_g_buffer_face_normal(textureLoad(tPBR, hit_pixel, 0));
+
+                            // how far the ray is clear of the surface it reached, whether the hit holds or not
+                            clear = min(clear, length(hit_position - origin));
+
+                            let thick_enough = ray_depth - surface_depth < ${SCREEN_PROBE_SCREEN_THICKNESS} * surface_depth;
+                            let facing = dot(face, direction) < 0.0;
+                            let in_frame = screen_probe_edge_fade(march.reached.xy * vec2<f32>(2.0, -2.0) + vec2<f32>(-1.0, 1.0)) >= noise.x;
+                            let history = textureLoad(tOcclusion, hit_pixel, 0).r >= noise.y;
+
+                            let previous = vec2<f32>(hit_pixel) + 0.5 - textureLoad(tVelocity, hit_pixel, 0).rg;
+                            let on_screen = all(previous >= vec2<f32>(0.0)) && all(previous < size);
+
+                            if (thick_enough && facing && in_frame && history && on_screen && frame.history != 0u) {
+                                let radiance = textureLoad(screen_probe_color_history, vec2<u32>(previous), 0).rgb;
+                                let speed = screen_probe_object_speed(hit_pixel, hit_position, surface_depth);
+                                let moving = abs(record.speed - speed) > ${SCREEN_PROBE_MOVING_SPEED} * max(record.depth, 1.0);
+
+                                textureStore(screen_probe_trace_radiance, texel, vec4<f32>(radiance * screen_probe_exposure.value, 0.0));
+                                textureStore(screen_probe_trace_hit, texel, vec4<u32>(screen_probe_trace_hit_pack(SCREEN_PROBE_TRACE_SCREEN, length(hit_position - record.position), moving), 0u, 0u, 0u));
+
+                                pending = false;
+                            }
+                        }
+                    }
+                }
+            }
+
+            if (pending) {
+                textureStore(screen_probe_trace_hit, texel, vec4<u32>(screen_probe_trace_hit_pack(SCREEN_PROBE_TRACE_PENDING, clear, false), 0u, 0u, 0u));
+            }
+        }
+    }
+
+    // every lane, pending or not, for the subgroup's one atomic
+    let at = subgroup_append_slot(&screen_probe_counters[${SCREEN_PROBE_COUNTER_BRICK_RAYS}u], pending, settings.capacity);
+
+    if (at != ${SUBGROUP_APPEND_NONE}u) {
+        var entry: ScreenProbeRay;
+
+        entry.ray = (probe << SCREEN_PROBE_RAY_SLOT_BITS) | slot;
+        entry.t = clear;
+        entry.direction = packed;
+
+        screen_probe_rays[at] = entry;
+    }
+}
+`, [
+            chunk_screen_probe,
+            chunk_screen_probe_counts,
+            chunk_screen_probe_ray_jitter,
+            chunk_screen_probe_object_speed,
+            chunk_screen_probe_march_distance,
+            chunk_screen_probe_screen_march,
+            chunk_folded_workgroup_index,
+            chunk_uv_octahedral_unit_decode,
+            chunk_uv_equal_area_sphere,
+            chunk_stbn_sample_vec2,
+            chunk_project_position_from_depth,
+            chunk_get_view_space_depth,
+            chunk_is_background,
+            chunk_decode_g_buffer_face_normal,
+            chunk_ndc_to_uv,
+            chunk_subgroup_append_slot,
+        ]),
+});

package/src/shade/renderer/grass/blade/GPUGrassBlades.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUGrassBlades.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/grass/blade/GPUGrassBlades.js"],"names":[],"mappings":"AAsFA;;;;;;;;;;;;;GAaG;AACH;IAEI;;;;OAIG;IACH,iCAFW,eAAe,QAWzB;IAmED;;;OAGG;IACH,sBAHW,eAAe,YACf,gBAAgB,EAW1B;IA9ED;;;;;OAKG;IACH,gBAFU,aAAa,CAEjB;IA0EN;;OAEG;IACH,6BAEC;IAED;;OAEG;IACH,2BAEC;IAED;;;;OAIG;IACH,0BAEC;IAED;;;;OAIG;IACH,wBAEC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,mBAjBW,MAAM;QAEU,YAAY,EAA5B,MAAM;QACU,WAAW,EAA3B,MAAM;QACU,OAAO,EAAvB,MAAM;QACU,SAAS,EAAzB,MAAM;QACY,UAAU,EAA5B,MAAM,EAAE;QACU,SAAS,EAA3B,MAAM,EAAE;QACQ,gBAAgB,EAAhC,MAAM;QACU,IAAI,EAApB,MAAM;QACU,IAAI,EAApB,MAAM;QACU,IAAI,EAApB,MAAM;QACU,SAAS,EAAzB,MAAM;QACU,eAAe,EAA/B,MAAM;QACU,WAAW,EAA3B,MAAM;QACU,UAAU,EAA1B,MAAM;aA0ChB;IAED;;;;;;OAMG;IACH,2BAFW,MAAM,QAyDhB;IAED;;;;;;;;;OASG;IACH;QAL+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACiB,OAAO,GAAtC,eAAe,GAAC,IAAI;aA8J9B;IAED;;;;;;OAMG;IACH,kBAFW,YAAY,QAqItB;IAED;;OAEG;IACH,gBAQC;;CACJ;yBA/nBY,OAAO,8DAA8D,EAAE,UAAU;8BACjF,OAAO,6CAA6C,EAAE,eAAe;2BACrE,OAAO,iCAAiC,EAAE,YAAY;8BACtD,OAAO,wCAAwC,EAAE,eAAe;8BAChE,OAAO,0BAA0B,EAAE,eAAe;6BAClD,OAAO,8BAA8B,EAAE,cAAc;+BACrD,OAAO,gCAAgC,EAAE,gBAAgB;8BA1BxC,2BAA2B"}
+{"version":3,"file":"GPUGrassBlades.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/grass/blade/GPUGrassBlades.js"],"names":[],"mappings":"AA0FA;;;;;;;;;;;;;GAaG;AACH;IAEI;;;;OAIG;IACH,iCAFW,eAAe,QAYzB;IAmED;;;OAGG;IACH,sBAHW,eAAe,YACf,gBAAgB,EAW1B;IA9ED;;;;;OAKG;IACH,gBAFU,aAAa,CAEjB;IA0EN;;OAEG;IACH,6BAEC;IAED;;OAEG;IACH,2BAEC;IAED;;;;OAIG;IACH,0BAEC;IAED;;;;OAIG;IACH,wBAEC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,mBAjBW,MAAM;QAEU,YAAY,EAA5B,MAAM;QACU,WAAW,EAA3B,MAAM;QACU,OAAO,EAAvB,MAAM;QACU,SAAS,EAAzB,MAAM;QACY,UAAU,EAA5B,MAAM,EAAE;QACU,SAAS,EAA3B,MAAM,EAAE;QACQ,gBAAgB,EAAhC,MAAM;QACU,IAAI,EAApB,MAAM;QACU,IAAI,EAApB,MAAM;QACU,IAAI,EAApB,MAAM;QACU,SAAS,EAAzB,MAAM;QACU,eAAe,EAA/B,MAAM;QACU,WAAW,EAA3B,MAAM;QACU,UAAU,EAA1B,MAAM;aA0ChB;IAED;;;;;;OAMG;IACH,2BAFW,MAAM,QAyDhB;IAED;;;;;;;;;OASG;IACH;QAL+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACiB,OAAO,GAAtC,eAAe,GAAC,IAAI;aA8J9B;IAED;;;;;;OAMG;IACH,kBAFW,YAAY,QA+ItB;IAED;;OAEG;IACH,gBAQC;;CACJ;yBA1oBY,OAAO,8DAA8D,EAAE,UAAU;8BACjF,OAAO,6CAA6C,EAAE,eAAe;2BACrE,OAAO,iCAAiC,EAAE,YAAY;8BACtD,OAAO,wCAAwC,EAAE,eAAe;8BAChE,OAAO,0BAA0B,EAAE,eAAe;6BAClD,OAAO,8BAA8B,EAAE,cAAc;+BACrD,OAAO,gCAAgC,EAAE,gBAAgB;8BA9BxC,2BAA2B"}

package/src/shade/renderer/grass/blade/GPUGrassBlades.js

@@ -28,7 +28,11 @@ import {
     GRASS_SPECIES_WORDS
 } from "./GRASS_BLADE.js";
 import { GRASS_BLADE_ID_PIPELINE, GRASS_BLADE_ID_RESOURCES } from "./grass_blade_id_draw.js";
-import { GRASS_BLADE_RESOLVE_PIPELINE, GRASS_BLADE_RESOLVE_RESOURCES } from "./grass_blade_resolve.js";
+import {
+    GRASS_BLADE_MOTION_PIPELINE,
+    GRASS_BLADE_RESOLVE_PIPELINE,
+    GRASS_BLADE_RESOLVE_RESOURCES
+} from "./grass_blade_resolve.js";
 import { shader_grass_blade_draw_args } from "./shader_grass_blade_draw_args.js";
 import { shader_grass_blade_expand } from "./shader_grass_blade_expand.js";
 import { GRASS_CELL_COUNT_WORKGROUP_SIZE, shader_grass_cell_count } from "./shader_grass_cell_count.js";
@@ -112,6 +116,7 @@ export class GPUGrassBlades {
         enquiry.compute.push(shader_prefix_sum_to_command.pipeline);
         enquiry.render.push(GRASS_BLADE_ID_PIPELINE);
         enquiry.render.push(GRASS_BLADE_RESOLVE_PIPELINE);
+        enquiry.render.push(GRASS_BLADE_MOTION_PIPELINE);
 
         GPUGrassPress.enquirePipelines(enquiry);
     }
@@ -629,12 +634,22 @@ export class GPUGrassBlades {
                     attachment(data.albedo),
                     attachment(data.emissive),
                     attachment(data.visibility),
-                    attachment(data.velocity),
                 ],
             });
 
             pass.draw(3);
             pass.end();
+
+            // the velocity on its own: with the surface's targets it would pass the device floor's attachment bytes
+            const motion = encoder.constructRenderPass({
+                label: "Grass Blade Motion",
+                pipeline: GRASS_BLADE_MOTION_PIPELINE,
+                bindings,
+                colorAttachments: [attachment(data.velocity)],
+            });
+
+            motion.draw(3);
+            motion.end();
         });
 
         resolve_data.blades = resolve_pass.read(product.blades);

package/src/shade/renderer/grass/blade/grass_blade_resolve.d.ts

@@ -1,15 +1,18 @@
 /**
- * The bindings of {@link GRASS_BLADE_RESOLVE_PIPELINE}: `camera`, `scene_database`, `grass_blades` (the
- * list the ids were drawn from), `grass_species`, `grass_ids` (the blade id target), `scene_depth` (the
- * depth the blades were drawn into), and the two matrices of `view_velocity_matrices`.
+ * The bindings of {@link GRASS_BLADE_RESOLVE_PIPELINE} and {@link GRASS_BLADE_MOTION_PIPELINE}, one layout for both:
+ * `camera`, `scene_database`, `grass_blades` (the list the ids were drawn from), `grass_species`, `grass_ids` (the
+ * blade id target), `scene_depth` (the depth the blades were drawn into), and the two matrices of
+ * `view_velocity_matrices`.
  *
  * @type {ShaderResourceSetDescriptor}
  */
 export const GRASS_BLADE_RESOLVE_RESOURCES: ShaderResourceSetDescriptor;
 /**
  * Turns the blade id target into the G-buffer's surface under every pixel a blade covers, and leaves every
- * other pixel as it was: a full-screen triangle (three vertices) over six targets, loaded: the four
- * G-buffer targets in `G_BUFFER_COLOR_TARGETS`' order, then the visibility buffer and the velocity buffer.
+ * other pixel as it was: a full-screen triangle (three vertices) over five targets, loaded: the four
+ * G-buffer targets in `G_BUFFER_COLOR_TARGETS`' order, then the visibility buffer. Its velocity is
+ * {@link GRASS_BLADE_MOTION_PIPELINE}'s: the six targets together do not fit the colour attachment bytes a
+ * sample that the device floor asks for.
  *
  * A blade's pixel takes its species' colour from root to tip, tinted by the blade's own seed; the normal
  * of the blade's face on the view's side, turned towards the edge the pixel is nearer; no metalness, no
@@ -17,13 +20,20 @@ export const GRASS_BLADE_RESOLVE_RESOURCES: ShaderResourceSetDescriptor;
  * normal towards the ground's and its roughness towards one by as much.
  *
  * The pixel's visibility word becomes `VISIBILITY_NONE`: no meshlet is the surface there, and a reader that
- * decoded the word would find the ground under the blade. Its velocity is the blade point's own, in the
- * velocity buffer's units: where the point was a frame ago, on the blade as it was bent then
- * (`grass_blade_previous`) and on its surface where that was.
+ * decoded the word would find the ground under the blade.
  *
  * @type {RenderPipelineDescriptor}
  */
 export const GRASS_BLADE_RESOLVE_PIPELINE: RenderPipelineDescriptor;
+/**
+ * The velocity under every pixel a blade covers, every other pixel left as it was: a full-screen triangle over the
+ * velocity buffer, loaded. A blade's pixel takes the blade point's own motion as the velocity buffer's texel
+ * (`chunk_velocity_texel`): where the point was a frame ago, on the blade as it was bent then
+ * (`grass_blade_previous`) and on its surface where that was.
+ *
+ * @type {RenderPipelineDescriptor}
+ */
+export const GRASS_BLADE_MOTION_PIPELINE: RenderPipelineDescriptor;
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
 import { RenderPipelineDescriptor } from "../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
 //# sourceMappingURL=grass_blade_resolve.d.ts.map

package/src/shade/renderer/grass/blade/grass_blade_resolve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"grass_blade_resolve.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/grass/blade/grass_blade_resolve.js"],"names":[],"mappings":"AAsIA;;;;;;GAMG;AACH,4CAFU,2BAA2B,CAEkB;AAEvD;;;;;;;;;;;;;;;;GAgBG;AACH,2CAFU,wBAAwB,CAgB/B;4CAjKyC,sDAAsD;yCAZzD,iEAAiE"}
+{"version":3,"file":"grass_blade_resolve.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/grass/blade/grass_blade_resolve.js"],"names":[],"mappings":"AAgMA;;;;;;;GAOG;AACH,4CAFU,2BAA2B,CAEkB;AAIvD;;;;;;;;;;;;;;;;GAgBG;AACH,2CAFU,wBAAwB,CAe/B;AAEH;;;;;;;GAOG;AACH,0CAFU,wBAAwB,CAc/B;4CAjPyC,sDAAsD;yCAdzD,iEAAiE"}

package/src/shade/renderer/grass/blade/grass_blade_resolve.js

@@ -2,6 +2,8 @@ import { ColorTargetState } from "../../../descriptor/pipeline/render/ColorTarge
 import { RenderPipelineDescriptor } from "../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
 import { CAMERA_RESOURCE } from "../../camera/CAMERA_RESOURCE.js";
 import { G_BUFFER_COLOR_TARGETS } from "../../gbuffer/G_BUFFER_COLOR_TARGETS.js";
+import { chunk_velocity_texel } from "../../postprocess/velocity/chunk_velocity_texel.js";
+import { VELOCITY_FORMAT } from "../../postprocess/velocity/VELOCITY_BUFFER.js";
 import { VISIBILITY_FORMAT, VISIBILITY_NONE } from "../../rasterize/visibility/VISIBILITY_BUFFER.js";
 import { TRANSFORMS_TABLE } from "../../scene/chunk_scene_database_access.js";
 import { SCENE_DATABASE_RESOURCE } from "../../scene/SCENE_DATABASE_RESOURCE.js";
@@ -34,7 +36,45 @@ resources.createGroup()
 const ALONG_STEPS = 2 ** GRASS_BLADE_ID_ALONG_BITS - 1;
 const ACROSS_STEPS = 2 ** GRASS_BLADE_ID_ACROSS_BITS - 1;
 
-const body = CodeChunk.from(
+/**
+ * The blade a pixel of the blade id target names, and where on it:
+ *
+ * ```wgsl
+ * fn grass_blade_at(id: u32) -> GrassBladePlace   // the id is never GRASS_BLADE_ID_NONE
+ * ```
+ *
+ * `along` from root (0) to tip (1), `across` from one edge (-1) to the other (1), and the frame of the surface the
+ * blade stands on.
+ *
+ * @type {CodeChunk}
+ */
+const chunk_grass_blade_at = CodeChunk.from(
+    //language=WGSL
+    `
+struct GrassBladePlace {
+    blade: GrassBlade,
+    along: f32,
+    across: f32,
+    frame: mat4x4<f32>,
+}
+
+fn grass_blade_at(id: u32) -> GrassBladePlace {
+    var place: GrassBladePlace;
+
+    place.blade = grass_blade_unpack(grass_blades.records[(id >> ${GRASS_BLADE_ID_ALONG_BITS + GRASS_BLADE_ID_ACROSS_BITS}u) - 1u]);
+    place.along = f32((id >> ${GRASS_BLADE_ID_ACROSS_BITS}u) & ${ALONG_STEPS}u) / ${ALONG_STEPS}.0;
+    place.across = f32(id & ${ACROSS_STEPS}u) / ${ACROSS_STEPS}.0 * 2.0 - 1.0;
+    place.frame = grass_surface_frame(${TRANSFORMS_TABLE.marshalling_method_read_field('global')}(&scene_database, place.blade.surface));
+
+    return place;
+}
+`, [
+        chunk_grass_surface_frame,
+        chunk_grass_blade,
+        TRANSFORMS_TABLE.chunk_read_field('global'),
+    ]);
+
+const surface_body = CodeChunk.from(
     //language=WGSL
     `
 struct GrassResolveOutput {
@@ -43,7 +83,6 @@ struct GrassResolveOutput {
     @location(2) albedo: vec4<f32>,
     @location(3) emissive: u32,
     @location(4) visibility: u32,
-    @location(5) velocity: vec2<f32>,
 }
 
 @fragment
@@ -54,15 +93,14 @@ fn fs_main(@builtin(position) position: vec4<f32>) -> GrassResolveOutput {
         discard;
     }
 
-    let blade = grass_blade_unpack(grass_blades.records[(id >> ${GRASS_BLADE_ID_ALONG_BITS + GRASS_BLADE_ID_ACROSS_BITS}u) - 1u]);
-
-    let along = f32((id >> ${GRASS_BLADE_ID_ACROSS_BITS}u) & ${ALONG_STEPS}u) / ${ALONG_STEPS}.0;
-    let across = f32(id & ${ACROSS_STEPS}u) / ${ACROSS_STEPS}.0 * 2.0 - 1.0;
+    let place = grass_blade_at(id);
+    let blade = place.blade;
+    let along = place.along;
+    let across = place.across;
+    let frame = place.frame;
 
     let species = grass_species[blade.species];
 
-    let frame = grass_surface_frame(${TRANSFORMS_TABLE.marshalling_method_read_field('global')}(&scene_database, blade.surface));
-
     // the face the view sees, rounded across the blade's width
     let side = grass_blade_across(blade);
 
@@ -92,6 +130,31 @@ fn fs_main(@builtin(position) position: vec4<f32>) -> GrassResolveOutput {
     // no meshlet is under a blade
     out.visibility = ${VISIBILITY_NONE}u;
 
+    return out;
+}
+`, [
+        chunk_grass_blade_at,
+        chunk_encode_g_buffer_normal,
+        chunk_encode_g_buffer_face_normal,
+        chunk_rgbe9995_encode,
+    ]);
+
+const motion_body = CodeChunk.from(
+    //language=WGSL
+    `
+@fragment
+fn fs_main(@builtin(position) position: vec4<f32>) -> @location(0) vec4<f32> {
+    let id = textureLoad(grass_ids, vec2<i32>(position.xy), 0).x;
+
+    if (id == ${GRASS_BLADE_ID_NONE}u) {
+        discard;
+    }
+
+    let place = grass_blade_at(id);
+    let blade = place.blade;
+    let along = place.along;
+    let across = place.across;
+
     // where this point of the blade was a frame ago: on the blade as it was bent then, carried by its surface
     let pixel = position.xy;
     let size = vec2<f32>(textureDimensions(scene_depth));
@@ -107,44 +170,44 @@ fn fs_main(@builtin(position) position: vec4<f32>) -> GrassResolveOutput {
     let half = 0.5 * blade.width * grass_blade_taper(along) * across;
 
     // how far the point has moved on its surface over the frame, in the frame and then in the world
-    let moved = grass_blade_point(blade, along) + side * half
+    let moved = grass_blade_point(blade, along) + grass_blade_across(blade) * half
         - grass_blade_point(blade_before, along) - grass_blade_across(blade_before) * half;
 
-    let there = here.xyz / here.w - (frame * vec4<f32>(moved, 0.0)).xyz;
+    let there = here.xyz / here.w - (place.frame * vec4<f32>(moved, 0.0)).xyz;
 
     let before = view_projection_previous * (global_previous * (mat4_inverse(global) * vec4<f32>(there, 1.0)));
-    let before_ndc = before.xy / before.w;
-
-    out.velocity = pixel - vec2<f32>((before_ndc.x + 1.0) * 0.5 * size.x, (1.0 - before_ndc.y) * 0.5 * size.y);
 
-    return out;
+    // this frame's clip w, the point's view depth, is the reciprocal of the w its unprojection came out with
+    return velocity_texel(pixel, 1.0 / here.w, before, size);
 }
 `, [
-        chunk_grass_surface_frame,
-        chunk_grass_blade,
-        chunk_encode_g_buffer_normal,
-        chunk_encode_g_buffer_face_normal,
-        chunk_rgbe9995_encode,
+        chunk_grass_blade_at,
+        chunk_velocity_texel,
         chunk_mat4_inverse,
-        TRANSFORMS_TABLE.chunk_read_field('global'),
         TRANSFORMS_TABLE.chunk_read_field('prev_global'),
     ]);
 
-const descriptor = ShaderDescriptor.from({ label: "Grass Blade Resolve", body, resources });
+const surface_descriptor = ShaderDescriptor.from({ label: "Grass Blade Resolve", body: surface_body, resources });
+const motion_descriptor = ShaderDescriptor.from({ label: "Grass Blade Motion", body: motion_body, resources });
 
 /**
- * The bindings of {@link GRASS_BLADE_RESOLVE_PIPELINE}: `camera`, `scene_database`, `grass_blades` (the
- * list the ids were drawn from), `grass_species`, `grass_ids` (the blade id target), `scene_depth` (the
- * depth the blades were drawn into), and the two matrices of `view_velocity_matrices`.
+ * The bindings of {@link GRASS_BLADE_RESOLVE_PIPELINE} and {@link GRASS_BLADE_MOTION_PIPELINE}, one layout for both:
+ * `camera`, `scene_database`, `grass_blades` (the list the ids were drawn from), `grass_species`, `grass_ids` (the
+ * blade id target), `scene_depth` (the depth the blades were drawn into), and the two matrices of
+ * `view_velocity_matrices`.
  *
  * @type {ShaderResourceSetDescriptor}
  */
 export const GRASS_BLADE_RESOLVE_RESOURCES = resources;
 
+const layout = resources.generatePipelineLayout(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT);
+
 /**
  * Turns the blade id target into the G-buffer's surface under every pixel a blade covers, and leaves every
- * other pixel as it was: a full-screen triangle (three vertices) over six targets, loaded: the four
- * G-buffer targets in `G_BUFFER_COLOR_TARGETS`' order, then the visibility buffer and the velocity buffer.
+ * other pixel as it was: a full-screen triangle (three vertices) over five targets, loaded: the four
+ * G-buffer targets in `G_BUFFER_COLOR_TARGETS`' order, then the visibility buffer. Its velocity is
+ * {@link GRASS_BLADE_MOTION_PIPELINE}'s: the six targets together do not fit the colour attachment bytes a
+ * sample that the device floor asks for.
  *
  * A blade's pixel takes its species' colour from root to tip, tinted by the blade's own seed; the normal
  * of the blade's face on the view's side, turned towards the edge the pixel is nearer; no metalness, no
@@ -152,23 +215,42 @@ export const GRASS_BLADE_RESOLVE_RESOURCES = resources;
  * normal towards the ground's and its roughness towards one by as much.
  *
  * The pixel's visibility word becomes `VISIBILITY_NONE`: no meshlet is the surface there, and a reader that
- * decoded the word would find the ground under the blade. Its velocity is the blade point's own, in the
- * velocity buffer's units: where the point was a frame ago, on the blade as it was bent then
- * (`grass_blade_previous`) and on its surface where that was.
+ * decoded the word would find the ground under the blade.
  *
  * @type {RenderPipelineDescriptor}
  */
 export const GRASS_BLADE_RESOLVE_PIPELINE = RenderPipelineDescriptor.from({
     label: "Grass Blade Resolve",
-    layout: resources.generatePipelineLayout(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
+    layout,
     vertex: { module: { code: vertex_full_viewport_quad }, entryPoint: "main" },
     fragment: {
-        module: { code: descriptor.source },
+        module: { code: surface_descriptor.source },
         entryPoint: "fs_main",
         targets: [
             ...G_BUFFER_COLOR_TARGETS.map(target => ColorTargetState.from({ format: target.format })),
             ColorTargetState.from({ format: VISIBILITY_FORMAT }),
-            ColorTargetState.from({ format: "rg16float" }),
+        ],
+    },
+    primitive: { topology: "triangle-list", cullMode: "none" },
+});
+
+/**
+ * The velocity under every pixel a blade covers, every other pixel left as it was: a full-screen triangle over the
+ * velocity buffer, loaded. A blade's pixel takes the blade point's own motion as the velocity buffer's texel
+ * (`chunk_velocity_texel`): where the point was a frame ago, on the blade as it was bent then
+ * (`grass_blade_previous`) and on its surface where that was.
+ *
+ * @type {RenderPipelineDescriptor}
+ */
+export const GRASS_BLADE_MOTION_PIPELINE = RenderPipelineDescriptor.from({
+    label: "Grass Blade Motion",
+    layout,
+    vertex: { module: { code: vertex_full_viewport_quad }, entryPoint: "main" },
+    fragment: {
+        module: { code: motion_descriptor.source },
+        entryPoint: "fs_main",
+        targets: [
+            ColorTargetState.from({ format: VELOCITY_FORMAT }),
         ],
     },
     primitive: { topology: "triangle-list", cullMode: "none" },

package/src/shade/renderer/light/GPULightCollection.d.ts

@@ -1,7 +1,7 @@
 export class GPULightCollection {
     /**
      * Offer the pipelines a scene's lights are updated with — the environment map's filtering and
-     * projection, and the pose refresh — see {@link PipelineEnquiry}.
+     * projection, procedural sky mip-0 synthesis, and the pose refresh — see {@link PipelineEnquiry}.
      *
      * @param {PipelineEnquiry} enquiry
      */

package/src/shade/renderer/light/GPULightCollection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPULightCollection.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/light/GPULightCollection.js"],"names":[],"mappings":"AAoDA;IAEI;;;;;OAKG;IACH,iCAFW,eAAe,QAOzB;IAmLD;;;;;;OAMG;IACH,sBALW,eAAe,aACf,eAAe,EA6CzB;IA3ND;;;OAGG;IACH,6DAEC;IAeD;;OAEG;IACH,4BAEC;IAED;;;;;;OAMG;IACH,6BAEC;IAED;;;;;;;OAOG;IACH,qFAEC;IAWD;;OAEG;IACH,+CAEC;IAmED;;;OAGG;IACH,qCAEC;IAED;;;;;;OAMG;IACH,gCAEC;IAED;;;;;;OAMG;IACH,yCAEC;IAGD,4BAMC;IAsMD;;;OAGG;IACH,YAFW,eAAe,QAoCzB;IAED;;;;;;;;;;;OAWG;IACH,gBAFW,OAAO,+BAA+B,EAAE,YAAY,QA2B9D;IAqBD;;;;;;OAMG;IACH,uBAHW,sBAAsB,mCA6BhC;IAwED,gBAaC;;CACJ;8BAnnBY,OAAO,0CAA0C,EAAE,eAAe;8BAClE,OAAO,uBAAuB,EAAE,eAAe;8BAC/C,OAAO,6BAA6B,EAAE,eAAe;8BACrD,OAAO,sBAAsB,EAAE,eAAe;4BA7B/B,gCAAgC;yCACnB,2CAA2C;kCAClD,iCAAiC;uCAH5B,wCAAwC"}
+{"version":3,"file":"GPULightCollection.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/light/GPULightCollection.js"],"names":[],"mappings":"AA8DA;IAEI;;;;;OAKG;IACH,iCAFW,eAAe,QAQzB;IAqND;;;;;;OAMG;IACH,sBALW,eAAe,aACf,eAAe,EA+CzB;IA1PD;;;OAGG;IACH,6DAEC;IAeD;;OAEG;IACH,4BAEC;IAED;;;;;;OAMG;IACH,6BAEC;IAED;;;;;;;OAOG;IACH,qFAEC;IAWD;;OAEG;IACH,+CAEC;IAgGD;;;OAGG;IACH,qCAEC;IAED;;;;;;OAMG;IACH,gCAEC;IAED;;;;;;OAMG;IACH,yCAEC;IAGD,4BAMC;IA8RD;;;OAGG;IACH,YAFW,eAAe,QAoCzB;IAED;;;;;;;;;;;OAWG;IACH,gBAFW,OAAO,+BAA+B,EAAE,YAAY,QA2B9D;IAqBD;;;;;;OAMG;IACH,uBAHW,sBAAsB,mCA6BhC;IAwED,gBAaC;;CACJ;8BArvBY,OAAO,0CAA0C,EAAE,eAAe;8BAClE,OAAO,uBAAuB,EAAE,eAAe;8BAC/C,OAAO,6BAA6B,EAAE,eAAe;8BACrD,OAAO,sBAAsB,EAAE,eAAe;4BA7B/B,gCAAgC;yCACnB,2CAA2C;kCAClD,iCAAiC;uCAL5B,wCAAwC"}