@woosh/meep-engine 3.64.0 → 3.65.0

package/src/shade/renderer/grass/surface/shader_grass_surface_want.js

@@ -0,0 +1,251 @@
+import { CAMERA_RESOURCE } from "../../camera/CAMERA_RESOURCE.js";
+import { COLLECTION_U32_STRUCT_READ } from "../../gpu_primitive/COLLECTION_U32_STRUCT_READ.js";
+import { COLLECTION_U32_STRUCT_WRITE } from "../../gpu_primitive/COLLECTION_U32_STRUCT_WRITE.js";
+import { chunk_slot_stack } from "../../gpu_primitive/slot_stack/chunk_slot_stack.js";
+import { TRANSFORMS_TABLE } from "../../scene/chunk_scene_database_access.js";
+import { SCENE_DATABASE_RESOURCE } from "../../scene/SCENE_DATABASE_RESOURCE.js";
+import { chunk_aabb3_from_transformed_corners } from "../../shader/chunk/geometry/aabb3/chunk_aabb3_from_transformed_corners.js";
+import { chunk_aabb3_intersects_frustum } from "../../shader/chunk/geometry/aabb3/chunk_aabb3_intersects_frustum.js";
+import { chunk_folded_workgroup_index } from "../../shader/chunk/grid/chunk_folded_workgroup_index.js";
+import { chunk_lower_bound_branchless } from "../../shader/chunk/math/chunk_lower_bound_branchless.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { COMPUTE_SHADER_DEFAULT_GROUP_SIZE } from "../../shader/COMPUTE_SHADER_DEFAULT_GROUP_SIZE.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { chunk_grass_directory } from "./chunk_grass_directory.js";
+import { chunk_grass_surface_frame } from "./chunk_grass_surface_frame.js";
+import { chunk_grass_surface_window } from "./chunk_grass_surface_window.js";
+import {
+    GRASS_COLUMN_CROSSINGS,
+    GRASS_POOL_FREE_COUNT,
+    GRASS_POOL_STARVED,
+    GRASS_SLOT_HEIGHT_MAX,
+    GRASS_SLOT_HEIGHT_MIN,
+    GRASS_SLOT_LAYER_COUNT,
+    GRASS_SLOT_LEVEL_LAYER,
+    GRASS_SLOT_NORMAL_SPREAD,
+    GRASS_SLOT_STATE,
+    GRASS_SLOT_STATE_BAKED,
+    GRASS_SLOT_STATE_ORPHAN,
+    GRASS_SLOT_STATE_PENDING,
+    GRASS_SLOT_STATE_STALE,
+    GRASS_SLOT_SURFACE,
+    GRASS_SLOT_SURFEL_COUNT,
+    GRASS_SLOT_TILE_X,
+    GRASS_SLOT_TILE_Z,
+    GRASS_SLOT_WANTED_FRAME
+} from "./GRASS_SURFACE.js";
+import {
+    GRASS_DIRECTORY_RESOURCE,
+    GRASS_POOL_RESOURCE,
+    GRASS_SURFACE_VIEW_SETTINGS,
+    GRASS_SURFACES_RESOURCE
+} from "./GRASS_SURFACE_VIEW.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", GRASS_SURFACE_VIEW_SETTINGS);
+
+resources.createGroup()
+    .add(CAMERA_RESOURCE)
+    .add(SCENE_DATABASE_RESOURCE)
+    .add(GRASS_SURFACES_RESOURCE)
+    .addStorageBuffer("prefix_sums", COLLECTION_U32_STRUCT_READ)
+    .add(GRASS_POOL_RESOURCE)
+    .add(GRASS_DIRECTORY_RESOURCE)
+    .addStorageBuffer("grass_free", WebGPUArray.u32, true)
+    .addStorageBuffer("grass_jobs", COLLECTION_U32_STRUCT_WRITE, true);
+
+/**
+ * Asks for the tiles of the grass surfaces a view wants, a thread a tile of a window
+ * ({@link shader_grass_surface_window_count}, whose counts, summed, are `prefix_sums`).
+ *
+ * A thread finds its level of its surface from the sums and its tile from its place among that window's
+ * threads. A tile outside its level's ring (`grass_tile_wanted`) or outside the view's frustum is not
+ * wanted, and the thread ends.
+ *
+ * **A wanted tile's layers.** Layer 0 always; and once layer 0 is baked, the layers past it that its record
+ * counts. For each:
+ *
+ * - held by a slot (`grass_directory_find`): the slot's record is stamped with the frame. A stale slot also
+ *   takes a place in the frame's bake list, with what a bake gathers into its record reset, and keeps its
+ *   state: it reads as it was until the bake has run;
+ * - not held: the thread takes a place in the frame's bake list (`grass_jobs`, at most `job_capacity`
+ *   places, a count that keeps rising past them) and a slot off the free stack, writes the slot's record
+ *   for the layer, pending, and lists it in the directory. With the bake list full the layer waits for a
+ *   later frame. With no slot free the place holds `GRASS_SLOT_NONE` and the pool's starved count rises.
+ *   A slot the directory has no room for is marked an orphan and its place holds `GRASS_SLOT_NONE`.
+ *
+ * Every thread's layers are its own, so no two threads of a dispatch ask for the same one; two views ask
+ * in two dispatches, and the second finds what the first took.
+ *
+ * Dispatched through `shader_prefix_sum_to_command`'s folded command.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_grass_surface_want = ComputeShader.from({
+    label: "Grass Surface Want",
+    resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+// what a bake counts and gathers into a slot's record, as a bake is to find it
+fn grass_slot_reset_bake(record: u32) {
+    atomicStore(&grass_pool[record + ${GRASS_SLOT_LAYER_COUNT}u], 0u);
+    atomicStore(&grass_pool[record + ${GRASS_SLOT_SURFEL_COUNT}u], 0u);
+    atomicStore(&grass_pool[record + ${GRASS_SLOT_HEIGHT_MIN}u], 0xFFFFFFFFu);
+    atomicStore(&grass_pool[record + ${GRASS_SLOT_HEIGHT_MAX}u], 0u);
+    atomicStore(&grass_pool[record + ${GRASS_SLOT_NORMAL_SPREAD}u], 0u);
+}
+
+// stamp the layer's slot as wanted, or take a slot and a place in the bake for it; the slot that holds it, or none yet
+fn grass_want_layer(surface: u32, level: u32, layer: u32, tile: vec2<i32>) -> u32 {
+    let level_layer = level | (layer << 8u);
+
+    let held = grass_directory_find(surface, level_layer, tile);
+
+    if (held != GRASS_SLOT_NONE) {
+        let record = grass_slot_record(held);
+
+        atomicStore(&grass_pool[record + ${GRASS_SLOT_WANTED_FRAME}u], settings.frame);
+
+        if (atomicLoad(&grass_pool[record + ${GRASS_SLOT_STATE}u]) == ${GRASS_SLOT_STATE_STALE}u) {
+            // baked again where it is, once the frame's bake has a place for it; until then it reads as it was
+            let place = atomicAdd(&grass_jobs.count, 1u);
+
+            if (place < settings.job_capacity) {
+                grass_slot_reset_bake(record);
+
+                grass_jobs.elements[place] = held;
+            }
+        }
+
+        return held;
+    }
+
+    let place = atomicAdd(&grass_jobs.count, 1u);
+
+    if (place >= settings.job_capacity) {
+        return GRASS_SLOT_NONE;
+    }
+
+    let slot = slot_stack_pop(&grass_pool[${GRASS_POOL_FREE_COUNT}u], &grass_free, settings.slot_capacity);
+
+    grass_jobs.elements[place] = slot;
+
+    if (slot == SLOT_STACK_NONE) {
+        atomicAdd(&grass_pool[${GRASS_POOL_STARVED}u], 1u);
+
+        return GRASS_SLOT_NONE;
+    }
+
+    let record = grass_slot_record(slot);
+
+    atomicStore(&grass_pool[record + ${GRASS_SLOT_SURFACE}u], surface);
+    atomicStore(&grass_pool[record + ${GRASS_SLOT_LEVEL_LAYER}u], level_layer);
+    atomicStore(&grass_pool[record + ${GRASS_SLOT_TILE_X}u], bitcast<u32>(tile.x));
+    atomicStore(&grass_pool[record + ${GRASS_SLOT_TILE_Z}u], bitcast<u32>(tile.y));
+    atomicStore(&grass_pool[record + ${GRASS_SLOT_STATE}u], ${GRASS_SLOT_STATE_PENDING}u);
+    atomicStore(&grass_pool[record + ${GRASS_SLOT_WANTED_FRAME}u], settings.frame);
+
+    grass_slot_reset_bake(record);
+
+    if (!grass_directory_insert(surface, level_layer, tile, slot)) {
+        atomicStore(&grass_pool[record + ${GRASS_SLOT_STATE}u], ${GRASS_SLOT_STATE_ORPHAN}u);
+
+        grass_jobs.elements[place] = GRASS_SLOT_NONE;
+
+        return GRASS_SLOT_NONE;
+    }
+
+    return slot;
+}
+
+@compute @workgroup_size(${COMPUTE_SHADER_DEFAULT_GROUP_SIZE})
+fn main(
+    @builtin(workgroup_id) workgroup_id: vec3<u32>,
+    @builtin(local_invocation_index) lane: u32,
+) {
+    let thread = folded_workgroup_index(workgroup_id) * ${COMPUTE_SHADER_DEFAULT_GROUP_SIZE}u + lane;
+
+    // the sums are inclusive: a thread belongs to the first window whose sum is past it
+    let windows = prefix_sums.count;
+    let index = lower_bound_branchless(&prefix_sums.elements, thread + 1u, windows);
+
+    if (index >= windows) {
+        return;
+    }
+
+    var place = thread;
+
+    if (index > 0u) {
+        place -= prefix_sums.elements[index - 1u];
+    }
+
+    let surface = grass_surfaces[index / settings.level_count];
+    let level = index % settings.level_count;
+
+    let frame = grass_surface_frame(${TRANSFORMS_TABLE.marshalling_method_read_field('global')}(&scene_database, surface.node));
+    let eye = grass_world_to_frame(frame, camera.transform[3].xyz);
+
+    let window = grass_surface_window(settings, surface, level, eye);
+
+    let tile = window.corner + vec2<i32>(i32(place % window.size.x), i32(place / window.size.x));
+
+    let tile_box = grass_tile_box(settings, surface, level, tile);
+
+    if (!grass_tile_wanted(settings, surface, level, tile_box, eye)) {
+        return;
+    }
+
+    // where the tile's grass can be, against the view's frustum
+    let low = tile_box.low;
+    let high = tile_box.high;
+
+    let box = aabb3_from_transformed_corners(array<vec3<f32>, 8>(
+        vec3<f32>(low.x, low.y, low.z),
+        vec3<f32>(high.x, low.y, low.z),
+        vec3<f32>(low.x, high.y, low.z),
+        vec3<f32>(high.x, high.y, low.z),
+        vec3<f32>(low.x, low.y, high.z),
+        vec3<f32>(high.x, low.y, high.z),
+        vec3<f32>(low.x, high.y, high.z),
+        vec3<f32>(high.x, high.y, high.z),
+    ), frame);
+
+    if (!aabb3_intersects_frustum(box, camera.frustum)) {
+        return;
+    }
+
+    let top = grass_want_layer(surface.node, level, 0u, tile);
+
+    if (top == GRASS_SLOT_NONE) {
+        return;
+    }
+
+    let record = grass_slot_record(top);
+
+    if (atomicLoad(&grass_pool[record + ${GRASS_SLOT_STATE}u]) != ${GRASS_SLOT_STATE_BAKED}u) {
+        return;
+    }
+
+    // a tile has no more layers than a column's walk has crossings
+    let layers = min(atomicLoad(&grass_pool[record + ${GRASS_SLOT_LAYER_COUNT}u]), ${GRASS_COLUMN_CROSSINGS}u);
+
+    for (var layer = 1u; layer < layers; layer++) {
+        grass_want_layer(surface.node, level, layer, tile);
+    }
+}
+`, [
+            chunk_folded_workgroup_index,
+            chunk_lower_bound_branchless,
+            chunk_slot_stack,
+            chunk_aabb3_from_transformed_corners,
+            chunk_aabb3_intersects_frustum,
+            chunk_grass_surface_frame,
+            chunk_grass_surface_window,
+            chunk_grass_directory,
+            TRANSFORMS_TABLE.chunk_read_field('global'),
+        ]),
+});

package/src/shade/renderer/grass/surface/shader_grass_surface_window_count.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Threads in a workgroup of {@link shader_grass_surface_window_count}.
+ *
+ * @type {number}
+ */
+export const GRASS_SURFACE_WINDOW_COUNT_WORKGROUP_SIZE: number;
+/**
+ * Counts the tiles a view may want of each level of each grass surface, a thread a level of a surface.
+ *
+ * Thread `s * level_count + l` writes how many tiles the window of level `l` of surface `s` has
+ * (`grass_surface_window`) to `grass_window_counts.elements` at its own index, and thread 0 writes how many
+ * counts there are to `grass_window_counts.count`. Threads past `surface_count * level_count` write nothing,
+ * so the dispatch covers that many threads and need not be exact.
+ *
+ * The counts are what a prefix scan turns into a thread a tile for {@link shader_grass_surface_want}.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_grass_surface_window_count: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_grass_surface_window_count.d.ts.map

package/src/shade/renderer/grass/surface/shader_grass_surface_window_count.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_grass_surface_window_count.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/grass/surface/shader_grass_surface_window_count.js"],"names":[],"mappings":"AAWA;;;;GAIG;AACH,wDAFU,MAAM,CAE4C;AAY5D;;;;;;;;;;;GAWG;AACH,gDAFU,aAAa,CAoCpB;8BArE2B,+BAA+B"}

package/src/shade/renderer/grass/surface/shader_grass_surface_window_count.js

@@ -0,0 +1,75 @@
+import { CAMERA_RESOURCE } from "../../camera/CAMERA_RESOURCE.js";
+import { COLLECTION_U32_STRUCT_READ } from "../../gpu_primitive/COLLECTION_U32_STRUCT_READ.js";
+import { TRANSFORMS_TABLE } from "../../scene/chunk_scene_database_access.js";
+import { SCENE_DATABASE_RESOURCE } from "../../scene/SCENE_DATABASE_RESOURCE.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { chunk_grass_surface_frame } from "./chunk_grass_surface_frame.js";
+import { chunk_grass_surface_window } from "./chunk_grass_surface_window.js";
+import { GRASS_SURFACE_VIEW_SETTINGS, GRASS_SURFACES_RESOURCE } from "./GRASS_SURFACE_VIEW.js";
+
+/**
+ * Threads in a workgroup of {@link shader_grass_surface_window_count}.
+ *
+ * @type {number}
+ */
+export const GRASS_SURFACE_WINDOW_COUNT_WORKGROUP_SIZE = 64;
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", GRASS_SURFACE_VIEW_SETTINGS);
+
+resources.createGroup()
+    .add(CAMERA_RESOURCE)
+    .add(SCENE_DATABASE_RESOURCE)
+    .add(GRASS_SURFACES_RESOURCE)
+    .addStorageBuffer("grass_window_counts", COLLECTION_U32_STRUCT_READ, true);
+
+/**
+ * Counts the tiles a view may want of each level of each grass surface, a thread a level of a surface.
+ *
+ * Thread `s * level_count + l` writes how many tiles the window of level `l` of surface `s` has
+ * (`grass_surface_window`) to `grass_window_counts.elements` at its own index, and thread 0 writes how many
+ * counts there are to `grass_window_counts.count`. Threads past `surface_count * level_count` write nothing,
+ * so the dispatch covers that many threads and need not be exact.
+ *
+ * The counts are what a prefix scan turns into a thread a tile for {@link shader_grass_surface_want}.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_grass_surface_window_count = ComputeShader.from({
+    label: "Grass Surface Window Count",
+    resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(${GRASS_SURFACE_WINDOW_COUNT_WORKGROUP_SIZE})
+fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+    let index = id.x;
+    let total = settings.surface_count * settings.level_count;
+
+    if (index == 0u) {
+        grass_window_counts.count = total;
+    }
+
+    if (index >= total) {
+        return;
+    }
+
+    let surface = grass_surfaces[index / settings.level_count];
+    let level = index % settings.level_count;
+
+    let frame = grass_surface_frame(${TRANSFORMS_TABLE.marshalling_method_read_field('global')}(&scene_database, surface.node));
+    let eye = grass_world_to_frame(frame, camera.transform[3].xyz);
+
+    let window = grass_surface_window(settings, surface, level, eye);
+
+    grass_window_counts.elements[index] = window.size.x * window.size.y;
+}
+`, [
+            chunk_grass_surface_frame,
+            chunk_grass_surface_window,
+            TRANSFORMS_TABLE.chunk_read_field('global'),
+        ]),
+});

package/src/shade/renderer/postprocess/velocity/graph_add_per_object_velocity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_add_per_object_velocity.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/velocity/graph_add_per_object_velocity.js"],"names":[],"mappings":"AAkRA;;;;GAIG;AACH,+DAFW,eAAe,QAIzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH;IAhB4B,KAAK;IACT,aAAa,EAA1B,MAAM;IACO,kBAAkB,EAA/B,MAAM;IACO,uBAAuB,EAApC,MAAM;IACO,qBAAqB,EAAlC,MAAM;IACO,uBAAuB,EAApC,MAAM;IACO,mBAAmB,EAAhC,MAAM;IACO,4BAA4B,EAAzC,MAAM;IACO,qBAAqB,EAAlC,MAAM;IACQ,eAAe,EAA7B,OAAO;IAGQ,UAAU,EAAzB,MAAM,EAAE;IACa,IAAI;IACvB,MAAM,CA8ElB;8BAhXY,OAAO,6CAA6C,EAAE,eAAe"}
+{"version":3,"file":"graph_add_per_object_velocity.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/velocity/graph_add_per_object_velocity.js"],"names":[],"mappings":"AA8QA;;;;GAIG;AACH,+DAFW,eAAe,QAIzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH;IAhB4B,KAAK;IACT,aAAa,EAA1B,MAAM;IACO,kBAAkB,EAA/B,MAAM;IACO,uBAAuB,EAApC,MAAM;IACO,qBAAqB,EAAlC,MAAM;IACO,uBAAuB,EAApC,MAAM;IACO,mBAAmB,EAAhC,MAAM;IACO,4BAA4B,EAAzC,MAAM;IACO,qBAAqB,EAAlC,MAAM;IACQ,eAAe,EAA7B,OAAO;IAGQ,UAAU,EAAzB,MAAM,EAAE;IACa,IAAI;IACvB,MAAM,CA+DlB;8BA9VY,OAAO,6CAA6C,EAAE,eAAe"}

package/src/shade/renderer/postprocess/velocity/graph_add_per_object_velocity.js

@@ -1,6 +1,4 @@
 import { assert } from "../../../../core/assert.js";
-import { m4_invert } from "../../../../core/geom/3d/mat4/m4_invert.js";
-import { m4_multiply } from "../../../../core/geom/3d/mat4/m4_multiply.js";
 import { mat4x4f, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
 import { U32_CONTAINER_STRUCT } from "../../shader/type/U32_CONTAINER_STRUCT.js";
@@ -33,6 +31,7 @@ import { ImageShader } from "../../shader/ImageShader.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
 import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
 import { construct_pixel_reprojection_matrix } from "./construct_pixel_reprojection_matrix.js";
+import { view_velocity_matrices } from "./view_velocity_matrices.js";
 import {
     construct_reprojection_matrix_rotation_only,
 } from "./construct_reprojection_matrix.js";
@@ -266,9 +265,6 @@ const shader = new ImageShader({
     }]
 });
 
-const scratch_unjit_view_proj_curr_f64 = new Float64Array(16);
-const scratch_unjit_view_proj_prev_f64 = new Float64Array(16);
-const scratch_unjit_inv_view_proj_curr_f64 = new Float64Array(16);
 const scratch_unjit_view_proj_prev_f32 = new Float32Array(16);
 const scratch_unjit_inv_view_proj_curr_f32 = new Float32Array(16);
 
@@ -359,24 +355,9 @@ export function graph_add_per_object_velocity({
     const current_camera = view.camera.camera;
     const previous_camera = view.gpu_previous_camera_state.camera;
 
-    // Un-jittered current-frame inverse view-projection (for
-    // unprojecting depth → world without folding in jitter shift).
-    m4_multiply(
-        scratch_unjit_view_proj_curr_f64,
-        current_camera.projection_matrix,
-        current_camera.view_matrix
-    );
-    m4_invert(scratch_unjit_inv_view_proj_curr_f64, scratch_unjit_view_proj_curr_f64);
-
-    // Un-jittered previous-frame view-projection.
-    m4_multiply(
-        scratch_unjit_view_proj_prev_f64,
-        previous_camera.projection_matrix,
-        previous_camera.view_matrix
-    );
-
-    scratch_unjit_inv_view_proj_curr_f32.set(scratch_unjit_inv_view_proj_curr_f64);
-    scratch_unjit_view_proj_prev_f32.set(scratch_unjit_view_proj_prev_f64);
+    // Un-jittered: this frame's inverse view-projection (depth → world without the jitter's shift)
+    // and last frame's view-projection.
+    view_velocity_matrices(view, scratch_unjit_inv_view_proj_curr_f32, scratch_unjit_view_proj_prev_f32);
 
     // Background rotation-only reprojection (pixel space).
     const reprojection_matrix_64 = new Float64Array(16);

package/src/shade/renderer/postprocess/velocity/view_velocity_matrices.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The two matrices a pass needs to say how far a pixel's surface moved on screen: this frame's inverse
+ * view-projection, to take a pixel and its depth to the world, and last frame's view-projection, to take
+ * where that point was back to the screen. Both are free of the sub-pixel jitter, as the velocity buffer
+ * is: a still surface has no velocity however the frame is jittered.
+ *
+ * @param {GPUViewContext} view
+ * @param {Float32Array} inverse_view_projection receives this frame's, 16 elements
+ * @param {Float32Array} view_projection_previous receives last frame's, 16 elements
+ */
+export function view_velocity_matrices(view: GPUViewContext, inverse_view_projection: Float32Array, view_projection_previous: Float32Array): void;
+//# sourceMappingURL=view_velocity_matrices.d.ts.map

package/src/shade/renderer/postprocess/velocity/view_velocity_matrices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"view_velocity_matrices.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/velocity/view_velocity_matrices.js"],"names":[],"mappings":"AAMA;;;;;;;;;GASG;AACH,sFAHW,YAAY,4BACZ,YAAY,QActB"}

package/src/shade/renderer/postprocess/velocity/view_velocity_matrices.js

@@ -0,0 +1,29 @@
+import { m4_invert } from "../../../../core/geom/3d/mat4/m4_invert.js";
+import { m4_multiply } from "../../../../core/geom/3d/mat4/m4_multiply.js";
+
+const scratch_view_projection = new Float64Array(16);
+const scratch_inverse = new Float64Array(16);
+
+/**
+ * The two matrices a pass needs to say how far a pixel's surface moved on screen: this frame's inverse
+ * view-projection, to take a pixel and its depth to the world, and last frame's view-projection, to take
+ * where that point was back to the screen. Both are free of the sub-pixel jitter, as the velocity buffer
+ * is: a still surface has no velocity however the frame is jittered.
+ *
+ * @param {GPUViewContext} view
+ * @param {Float32Array} inverse_view_projection receives this frame's, 16 elements
+ * @param {Float32Array} view_projection_previous receives last frame's, 16 elements
+ */
+export function view_velocity_matrices(view, inverse_view_projection, view_projection_previous) {
+    const current = view.camera.camera;
+    const previous = view.gpu_previous_camera_state.camera;
+
+    m4_multiply(scratch_view_projection, current.projection_matrix, current.view_matrix);
+    m4_invert(scratch_inverse, scratch_view_projection);
+
+    inverse_view_projection.set(scratch_inverse);
+
+    m4_multiply(scratch_view_projection, previous.projection_matrix, previous.view_matrix);
+
+    view_projection_previous.set(scratch_view_projection);
+}

package/src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_rasterize_meshes_transparent_avboit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.js"],"names":[],"mappings":"AA4DA;;;;;GAKG;AACH,oDAHW,UAAU,MAAM,CAAC,GACf,MAAM,EAAE,CAOpB;AAED;;;;;;;;;;;;GAYG;AACH;IAT+B,KAAK;IACA,KAAK;IACd,MAAM,EAAtB,MAAM;IACqB,kBAAkB,EAA7C,UAAU,MAAM,CAAC;IACD,kBAAkB,EAAlC,MAAM;IACU,wBAAwB,EAAxC,MAAM;IACW,SAAS,GAA1B,MAAM;IACJ,MAAM,CA4DlB;AAED;;;;;;;;;;GAUG;AACH;IAP+B,KAAK;IACT,SAAS,EAAzB,MAAM;IACY,gBAAgB,EAAlC,MAAM,EAAE;IACmB,kBAAkB,EAA7C,UAAU,MAAM,CAAC;IACQ,MAAM,GAA/B,cAAc;IACZ,MAAM,CAuDlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,6KAFa;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAiJjE;AAED;;;;;;;;;;GAUG;AACH;IAP+B,KAAK;IACT,IAAI,EAApB,MAAM;IACU,UAAU,EAA1B,MAAM;IACU,QAAQ,EAAxB,MAAM;IACY,gBAAgB,EAAlC,MAAM,EAAE;IACN,MAAM,CAoClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,sUAFa;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,CA4M7D;AAED;;;;;;;;GAQG;AACH,+EAHW,UAAU,MAAM,CAAC,GACf;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAe/E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH;IA3B+B,KAAK;IACT,OAAO,EAAvB,MAAM;IACkB,QAAQ;IACd,QAAQ,EAA1B,MAAM,EAAE;IACQ,aAAa,EAA7B,MAAM;IACU,aAAa,EAA7B,MAAM;IACuB,MAAM;IACnB,wBAAwB,EAAxC,MAAM;IACU,oBAAoB,EAApC,MAAM;IACU,kBAAkB,EAAlC,MAAM;IACU,eAAe,EAA/B,MAAM;IACU,eAAe,EAA/B,MAAM;IACU,oBAAoB,EAApC,MAAM;IAC6B,sBAAsB,EAAzD;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC;IAGC,eAAe,GAAzC,eAAe;IAGsF,MAAM,EAA3G,OAAO,iEAAiE,EAAE,iBAAiB;IAGlE,MAAM,GAA/B,cAAc;IACiD,aAAa,GAA5E,OAAO,wBAAwB,EAAE,iBAAiB,EAAE;IAElD,MAAM,CAsTlB;+BAz9B8B,qBAAqB;gCAIpB,6CAA6C"}
+{"version":3,"file":"graph_rasterize_meshes_transparent_avboit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.js"],"names":[],"mappings":"AA4DA;;;;;GAKG;AACH,oDAHW,UAAU,MAAM,CAAC,GACf,MAAM,EAAE,CAOpB;AAED;;;;;;;;;;;;GAYG;AACH;IAT+B,KAAK;IACA,KAAK;IACd,MAAM,EAAtB,MAAM;IACqB,kBAAkB,EAA7C,UAAU,MAAM,CAAC;IACD,kBAAkB,EAAlC,MAAM;IACU,wBAAwB,EAAxC,MAAM;IACW,SAAS,GAA1B,MAAM;IACJ,MAAM,CA4DlB;AAED;;;;;;;;;;GAUG;AACH;IAP+B,KAAK;IACT,SAAS,EAAzB,MAAM;IACY,gBAAgB,EAAlC,MAAM,EAAE;IACmB,kBAAkB,EAA7C,UAAU,MAAM,CAAC;IACQ,MAAM,GAA/B,cAAc;IACZ,MAAM,CAuDlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,6KAFa;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAiJjE;AAED;;;;;;;;;;GAUG;AACH;IAP+B,KAAK;IACT,IAAI,EAApB,MAAM;IACU,UAAU,EAA1B,MAAM;IACU,QAAQ,EAAxB,MAAM;IACY,gBAAgB,EAAlC,MAAM,EAAE;IACN,MAAM,CAoClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,sUAFa;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,CA4M7D;AAED;;;;;;;;GAQG;AACH,+EAHW,UAAU,MAAM,CAAC,GACf;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAe/E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH;IA3B+B,KAAK;IACT,OAAO,EAAvB,MAAM;IACkB,QAAQ;IACd,QAAQ,EAA1B,MAAM,EAAE;IACQ,aAAa,EAA7B,MAAM;IACU,aAAa,EAA7B,MAAM;IACuB,MAAM;IACnB,wBAAwB,EAAxC,MAAM;IACU,oBAAoB,EAApC,MAAM;IACU,kBAAkB,EAAlC,MAAM;IACU,eAAe,EAA/B,MAAM;IACU,eAAe,EAA/B,MAAM;IACU,oBAAoB,EAApC,MAAM;IAC6B,sBAAsB,EAAzD;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC;IAGC,eAAe,GAAzC,eAAe;IAGsF,MAAM,EAA3G,OAAO,iEAAiE,EAAE,iBAAiB;IAGlE,MAAM,GAA/B,cAAc;IACiD,aAAa,GAA5E,OAAO,wBAAwB,EAAE,iBAAiB,EAAE;IAElD,MAAM,CA4UlB;+BA/+B8B,qBAAqB;gCAIpB,6CAA6C"}

package/src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.js

@@ -867,6 +867,28 @@ export function graph_rasterize_meshes_transparent_avboit({
         label: `${view_ctx.label}/AVBOIT-double`,
     });
 
+    // The meshes' fragments pick the probes around them, which no pixel of the G-buffer asked for: their meshlets
+    // ask, for the frame after. A bucket of no material lists none.
+    if (material_count_front > 0) {
+        probes.graph_want_meshlets({
+            graph,
+            scene: scene_ctx,
+            camera: gr_camera,
+            meshlet_collection: prep_front.meshlet_collection,
+            meshlet_iterator_command: prep_front.meshlet_iterator_command,
+        });
+    }
+
+    if (material_count_double > 0) {
+        probes.graph_want_meshlets({
+            graph,
+            scene: scene_ctx,
+            camera: gr_camera,
+            meshlet_collection: prep_double.meshlet_collection,
+            meshlet_iterator_command: prep_double.meshlet_iterator_command,
+        });
+    }
+
     // Occupancy and warp
     // ======
 

package/src/shade/renderer/scene/GPUSceneContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUSceneContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUSceneContext.js"],"names":[],"mappings":"AA4EA;;;;;;;;;GASG;AACH;IAEI;;;;;;;OAOG;IACH,iCAFW,eAAe,QASzB;IA4KD;;;;OAIG;IACH,sBAHW,eAAe,SACf,KAAK,EAyCf;IAtND;;;OAGG;IACH,aAFU,MAAM,CAEE;IAElB;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAGV;;OAEG;IACH,sBAFU,cAAc,CAEH;IASrB;;;OAGG;IACH,mBAEC;IAOD,uCAEC;IAOD;;;;;OAKG;IACH,yBAEC;IAUD;;;;;OAKG;IACH,kBAEC;IAQD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,8CAEC;IAOD;;;OAGG;IACH,8CAEC;IA2ID;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,gDAEC;IAED;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,+CAEC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH;QAH0C,SAAS,GAAxC,oBAAoB;QAClB,yBAAyB,CA4DrC;IAED;;OAEG;IACH,6CAEC;IAYD;;;;;OAKG;IACH,gEAEC;IAED;;;OAGG;IACH,kCAEC;IAED;;;;;OAKG;IACH,uCAEC;IAED;;;;;;;;;;;OAWG;IACH,uCAUC;IAED,+BAUC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,yBAEC;IAED;;;;;OAKG;IACH,sCAMC;IAOD;;;;;;;OAOG;IACH,8EAEC;IA6BD;;;;;OAKG;IACH,cAsEC;IAED;;;;;OAKG;IACH,YAFW,eAAe,QAyBzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAHW,sBAAsB,cACtB,MAAM,QAuBhB;IAUD;;;;;;;;;;;OAWG;IACH,oBAHW,UAAU,GACR,MAAM,CAQlB;IAoCD;;;;;;;OAOG;IACH,gBAuBC;IAwCL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;8BAl3BY,OAAO,0CAA0C,EAAE,eAAe;8BAClE,OAAO,uBAAuB,EAAE,eAAe;iCAC/C,OAAO,mCAAmC,EAAE,kBAAkB;iCAC9D,OAAO,mCAAmC,EAAE,kBAAkB;4BAC9D,OAAO,8BAA8B,EAAE,aAAa;8BACpD,OAAO,iDAAiD,EAAE,eAAe;yBACzE,OAAO,2DAA2D,EAAE,UAAU;+BA5B5D,iDAAiD;sBAM1D,YAAY;oCAFE,uCAAuC;6BAC9C,yBAAyB;uBAH/B,yBAAyB;mCACb,gCAAgC;oCAF/B,mDAAmD;kDAMrC,wCAAwC;0CAlBhD,0DAA0D;8BAItE,8CAA8C;iCAF3C,iDAAiD;+BAInD,2CAA2C;qCADrC,qDAAqD;oCAItD,qCAAqC;4BAC7C,gCAAgC;uCASrB,iDAAiD;6BAQ3D,wBAAwB;wCADb,mCAAmC;uCAlBpC,wCAAwC"}
+{"version":3,"file":"GPUSceneContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUSceneContext.js"],"names":[],"mappings":"AA4EA;;;;;;;;;GASG;AACH;IAEI;;;;;;;OAOG;IACH,iCAFW,eAAe,QASzB;IA4KD;;;;OAIG;IACH,sBAHW,eAAe,SACf,KAAK,EAyCf;IAtND;;;OAGG;IACH,aAFU,MAAM,CAEE;IAElB;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAGV;;OAEG;IACH,sBAFU,cAAc,CAEH;IASrB;;;OAGG;IACH,mBAEC;IAOD,uCAEC;IAOD;;;;;OAKG;IACH,yBAEC;IAUD;;;;;OAKG;IACH,kBAEC;IAQD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,8CAEC;IAOD;;;OAGG;IACH,8CAEC;IA2ID;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,gDAEC;IAED;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,+CAEC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH;QAH0C,SAAS,GAAxC,oBAAoB;QAClB,yBAAyB,CA4DrC;IAED;;OAEG;IACH,6CAEC;IAYD;;;;;OAKG;IACH,gEAEC;IAED;;;OAGG;IACH,kCAEC;IAED;;;;;OAKG;IACH,uCAEC;IAED;;;;;;;;;;;OAWG;IACH,uCAUC;IAED,+BAUC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,yBAEC;IAED;;;;;OAKG;IACH,sCAMC;IAOD;;;;;;;OAOG;IACH,8EAEC;IA6BD;;;;;OAKG;IACH,cAsEC;IAED;;;;;OAKG;IACH,YAFW,eAAe,QA4BzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAHW,sBAAsB,cACtB,MAAM,QAuBhB;IAUD;;;;;;;;;;;OAWG;IACH,oBAHW,UAAU,GACR,MAAM,CAQlB;IAoCD;;;;;;;OAOG;IACH,gBAuBC;IAwCL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;8BAr3BY,OAAO,0CAA0C,EAAE,eAAe;8BAClE,OAAO,uBAAuB,EAAE,eAAe;iCAC/C,OAAO,mCAAmC,EAAE,kBAAkB;iCAC9D,OAAO,mCAAmC,EAAE,kBAAkB;4BAC9D,OAAO,8BAA8B,EAAE,aAAa;8BACpD,OAAO,iDAAiD,EAAE,eAAe;yBACzE,OAAO,2DAA2D,EAAE,UAAU;+BA5B5D,iDAAiD;sBAM1D,YAAY;oCAFE,uCAAuC;6BAC9C,yBAAyB;uBAH/B,yBAAyB;mCACb,gCAAgC;oCAF/B,mDAAmD;kDAMrC,wCAAwC;0CAlBhD,0DAA0D;8BAItE,8CAA8C;iCAF3C,iDAAiD;+BAInD,2CAA2C;qCADrC,qDAAqD;oCAItD,qCAAqC;4BAC7C,gCAAgC;uCASrB,iDAAiD;6BAQ3D,wBAAwB;wCADb,mCAAmC;uCAlBpC,wCAAwC"}

package/src/shade/renderer/scene/GPUSceneContext.js

@@ -723,6 +723,9 @@ export class GPUSceneContext {
         this.#light_probe_volume.update();
         this.#lights.update(ctx);
         this.#volumetrics.update(ctx, 0);
+
+        // what the frame before read is this frame's history; producers write after this
+        this.#wind.advance_frame();
         this.#wind.update();
 
         // Per-frame animation database flush — picks up any new clips,

package/src/shade/renderer/scene/GRASS_SURFACE_PARAMS_STRUCT.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The `lattice_bits` of a surface whose densest species has `density` blades a square metre, on surfels
+ * `finest_spacing` apart: the least whole number of doublings of a surfel's side that reaches the density.
+ *
+ * @param {number} density blades a square metre, above zero
+ * @param {number} finest_spacing metres
+ * @returns {number}
+ */
+export function grass_surface_lattice_bits(density: number, finest_spacing: number): number;
+/**
+ * What grows on a grass surface, taken over every species its members grow: a record of the scene
+ * database's `grass_surface_params` table, at the surface's own `transforms` row. A row nothing has written
+ * reads as zeros, a surface on which nothing grows.
+ *
+ * - `lattice_bits`: the surface's blade lattice has `2^lattice_bits` points along a side of a finest
+ *   surfel's square, the fewest that make the lattice as dense as the densest species.
+ * - `density`: the densest species' blades in a square metre.
+ * - `blade_length`, `blade_length_min`: the longest and the shortest species' blade, metres.
+ * - `blade_width_min`: the narrowest species' blade, metres.
+ * - `cover`: the greatest product of a species' density and its blade's width, a metre of blade a square
+ *   metre of ground.
+ *
+ * @type {WebGPUStruct}
+ */
+export const GRASS_SURFACE_PARAMS_STRUCT: WebGPUStruct;
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+//# sourceMappingURL=GRASS_SURFACE_PARAMS_STRUCT.d.ts.map

package/src/shade/renderer/scene/GRASS_SURFACE_PARAMS_STRUCT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GRASS_SURFACE_PARAMS_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GRASS_SURFACE_PARAMS_STRUCT.js"],"names":[],"mappings":"AA2BA;;;;;;;GAOG;AACH,oDAJW,MAAM,kBACN,MAAM,GACJ,MAAM,CAIlB;AAlCD;;;;;;;;;;;;;;GAcG;AACH,0CAFU,YAAY,CASU;6BAxBH,gCAAgC"}

package/src/shade/renderer/scene/GRASS_SURFACE_PARAMS_STRUCT.js

@@ -0,0 +1,38 @@
+import { f32, u32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+
+/**
+ * What grows on a grass surface, taken over every species its members grow: a record of the scene
+ * database's `grass_surface_params` table, at the surface's own `transforms` row. A row nothing has written
+ * reads as zeros, a surface on which nothing grows.
+ *
+ * - `lattice_bits`: the surface's blade lattice has `2^lattice_bits` points along a side of a finest
+ *   surfel's square, the fewest that make the lattice as dense as the densest species.
+ * - `density`: the densest species' blades in a square metre.
+ * - `blade_length`, `blade_length_min`: the longest and the shortest species' blade, metres.
+ * - `blade_width_min`: the narrowest species' blade, metres.
+ * - `cover`: the greatest product of a species' density and its blade's width, a metre of blade a square
+ *   metre of ground.
+ *
+ * @type {WebGPUStruct}
+ */
+export const GRASS_SURFACE_PARAMS_STRUCT = WebGPUStruct.from({
+    lattice_bits: u32,
+    density: f32,
+    blade_length: f32,
+    blade_length_min: f32,
+    blade_width_min: f32,
+    cover: f32,
+}, "GrassSurfaceParams").pack();
+
+/**
+ * The `lattice_bits` of a surface whose densest species has `density` blades a square metre, on surfels
+ * `finest_spacing` apart: the least whole number of doublings of a surfel's side that reaches the density.
+ *
+ * @param {number} density blades a square metre, above zero
+ * @param {number} finest_spacing metres
+ * @returns {number}
+ */
+export function grass_surface_lattice_bits(density, finest_spacing) {
+    return Math.max(0, Math.ceil(Math.log2(finest_spacing * Math.sqrt(density)) - 1e-9));
+}

package/src/shade/renderer/scene/MESH_GROUND_COVER_STRUCT.d.ts

@@ -0,0 +1,28 @@
+/**
+ * A mesh row's membership of a grass surface: which surface it is ground of, what a column of that
+ * surface traces to find it, and what grows on it.
+ *
+ * A record of the scene database's `mesh_ground_covers` table, which shares the `meshes` table's index
+ * space: a row's ground cover is at the row's own index.
+ *
+ * **`flags` says what holds.** A row nothing has written, and a row on a page the table has never
+ * allocated, both read as a record of zeros, so zero flags is "not ground of any surface" and the other
+ * fields are read only when {@link MESH_GROUND_COVER_FLAG_MEMBER} is set.
+ */
+export const MESH_GROUND_COVER_STRUCT: WebGPUStruct;
+/**
+ * The row is a member of the surface its record names. Its faces are ground of that surface: they
+ * hold surfels, and they hide the ground of other members under them.
+ *
+ * @type {number}
+ */
+export const MESH_GROUND_COVER_FLAG_MEMBER: number;
+/**
+ * Something grows on the member, and its record's `species` holds. A member without it only hides
+ * ground.
+ *
+ * @type {number}
+ */
+export const MESH_GROUND_COVER_FLAG_GROWS: number;
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+//# sourceMappingURL=MESH_GROUND_COVER_STRUCT.d.ts.map

package/src/shade/renderer/scene/MESH_GROUND_COVER_STRUCT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MESH_GROUND_COVER_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/MESH_GROUND_COVER_STRUCT.js"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,oDA2B6B;AAE7B;;;;;GAKG;AACH,4CAFU,MAAM,CAE+B;AAE/C;;;;;GAKG;AACH,2CAFU,MAAM,CAE8B;6BAxDjB,gCAAgC"}