@woosh/meep-engine 3.23.0 → 3.24.0

package/src/shade/renderer/shadow/map/PointLightShadowmap.js

@@ -62,7 +62,7 @@ export class PointLightShadowmap extends Shadowmap {
         assert.defined(scene_ctx, 'scene_ctx');
 
         const light = this.light;
-        const t = light.transform_global;
+        const t = light.transform;
         const px = t.translation_x;
         const py = t.translation_y;
         const pz = t.translation_z;

package/src/shade/renderer/shadow/map/SpotLightShadowmap.js

@@ -24,7 +24,7 @@ export class SpotLightShadowmap extends Shadowmap {
 
         // both sides are Transform64 now, so this is one buffer copy rather than a component-by-
         // component transfer across two representations
-        camera.transform.copy(light.transform_global);
+        camera.transform.copy(light.transform);
 
         camera.fov = light.angle * 2;
         camera.aspect = 1;

package/src/shade/renderer/shadow/map/TetrahedronPointLightShadowmap.js

@@ -38,7 +38,7 @@ export class TetrahedronPointLightShadowmap extends Shadowmap {
         assert.defined(scene_ctx, 'scene_ctx');
 
         const light = this.light;
-        const t = light.transform_global;
+        const t = light.transform;
         const px = t.translation_x;
         const py = t.translation_y;
         const pz = t.translation_z;

package/src/shade/renderer/shadow/map/csm/CSM_CASTER_RANGE_STRUCT.d.ts

@@ -0,0 +1,29 @@
+/**
+ * What the caster-range pass publishes for one directional shadow map: per cascade, how near
+ * along the light's axis the nearest shadow caster inside the cascade's side planes reaches.
+ *
+ * A row of the light database's `shadow_csm_caster_range` table, written on the GPU by
+ * `shader_csm_caster_range_publish` and read back to the CPU, which fits the next frame's cascade
+ * near plane to it. The CPU writes it once, at {@link CSM_CASTER_RANGE_UNKNOWN}, when the row is
+ * claimed; a cascade nothing was measured for keeps that value, and a reader treats it as "no
+ * caster".
+ *
+ * @type {WebGPUStruct}
+ */
+export const CSM_CASTER_RANGE_STRUCT: WebGPUStruct;
+/**
+ * The largest finite f32: what a cascade's slot holds before anything is merged into it, and after
+ * the publish reset it. Not +inf, because WGSL will not const-fold `bitcast<f32>(0x7F800000u)`;
+ * no world coordinate comes within orders of magnitude of it.
+ *
+ * @type {number}
+ */
+export const CSM_CASTER_RANGE_UNKNOWN: number;
+/**
+ * {@link CSM_CASTER_RANGE_UNKNOWN} as the u32 bit pattern a scratch word is seeded with.
+ *
+ * @type {number}
+ */
+export const CSM_CASTER_RANGE_UNKNOWN_BITS: number;
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+//# sourceMappingURL=CSM_CASTER_RANGE_STRUCT.d.ts.map

package/src/shade/renderer/shadow/map/csm/CSM_CASTER_RANGE_STRUCT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CSM_CASTER_RANGE_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shadow/map/csm/CSM_CASTER_RANGE_STRUCT.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;GAWG;AACH,sCAFU,YAAY,CAUM;AAE5B;;;;;;GAMG;AACH,uCAFU,MAAM,CAEoC;AAEpD;;;;GAIG;AACH,4CAFU,MAAM,CAEwC;6BAvC3B,sCAAsC"}

package/src/shade/renderer/shadow/map/csm/CSM_CASTER_RANGE_STRUCT.js

@@ -0,0 +1,43 @@
+import { FLOAT32_MAX } from "../../../../../core/binary/FLOAT32_MAX.js";
+import { f32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { SHADOWMAP_CSM_CASCADE_COUNT } from "./SHADOWMAP_CSM_CASCADE_COUNT.js";
+
+/**
+ * What the caster-range pass publishes for one directional shadow map: per cascade, how near
+ * along the light's axis the nearest shadow caster inside the cascade's side planes reaches.
+ *
+ * A row of the light database's `shadow_csm_caster_range` table, written on the GPU by
+ * `shader_csm_caster_range_publish` and read back to the CPU, which fits the next frame's cascade
+ * near plane to it. The CPU writes it once, at {@link CSM_CASTER_RANGE_UNKNOWN}, when the row is
+ * claimed; a cascade nothing was measured for keeps that value, and a reader treats it as "no
+ * caster".
+ *
+ * @type {WebGPUStruct}
+ */
+export const CSM_CASTER_RANGE_STRUCT = WebGPUStruct.from({
+    /**
+     * Per cascade, `min(dot(light_z_axis, corner))` over the corners of every mesh row's world
+     * bounds that intersect the cascade's four side planes — measured from the world origin, so
+     * that a cascade whose centre moved between the frame it was measured for and the frame it is
+     * applied to can add its own translation.
+     */
+    near: WebGPUArray.from(f32, SHADOWMAP_CSM_CASCADE_COUNT),
+}, "CSMCasterRange").pack();
+
+/**
+ * The largest finite f32: what a cascade's slot holds before anything is merged into it, and after
+ * the publish reset it. Not +inf, because WGSL will not const-fold `bitcast<f32>(0x7F800000u)`;
+ * no world coordinate comes within orders of magnitude of it.
+ *
+ * @type {number}
+ */
+export const CSM_CASTER_RANGE_UNKNOWN = FLOAT32_MAX;
+
+/**
+ * {@link CSM_CASTER_RANGE_UNKNOWN} as the u32 bit pattern a scratch word is seeded with.
+ *
+ * @type {number}
+ */
+export const CSM_CASTER_RANGE_UNKNOWN_BITS = 0x7F7FFFFF;

package/src/shade/renderer/shadow/map/csm/SHADOWMAP_CSM_CASTER_RANGE_MARGIN_FRACTION.d.ts

@@ -0,0 +1,13 @@
+/**
+ * How far past the measured nearest caster a cascade's near plane is pushed, as a fraction of the
+ * cascade's own depth.
+ *
+ * The caster range is measured on the GPU against one frame's cascade frusta and applied to the
+ * next frame's — a frame of camera motion between them, and a frame of caster motion too. The
+ * margin is what keeps a caster that edged past the measured range from flickering in and out of
+ * shadow; a GPU-built cascade matrix is the fix if it ever shows.
+ *
+ * @type {number}
+ */
+export const SHADOWMAP_CSM_CASTER_RANGE_MARGIN_FRACTION: number;
+//# sourceMappingURL=SHADOWMAP_CSM_CASTER_RANGE_MARGIN_FRACTION.d.ts.map

package/src/shade/renderer/shadow/map/csm/SHADOWMAP_CSM_CASTER_RANGE_MARGIN_FRACTION.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SHADOWMAP_CSM_CASTER_RANGE_MARGIN_FRACTION.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shadow/map/csm/SHADOWMAP_CSM_CASTER_RANGE_MARGIN_FRACTION.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,yDAFU,MAAM,CAE8C"}

package/src/shade/renderer/shadow/map/csm/SHADOWMAP_CSM_CASTER_RANGE_MARGIN_FRACTION.js

@@ -0,0 +1,12 @@
+/**
+ * How far past the measured nearest caster a cascade's near plane is pushed, as a fraction of the
+ * cascade's own depth.
+ *
+ * The caster range is measured on the GPU against one frame's cascade frusta and applied to the
+ * next frame's — a frame of camera motion between them, and a frame of caster motion too. The
+ * margin is what keeps a caster that edged past the measured range from flickering in and out of
+ * shadow; a GPU-built cascade matrix is the fix if it ever shows.
+ *
+ * @type {number}
+ */
+export const SHADOWMAP_CSM_CASTER_RANGE_MARGIN_FRACTION = 0.1;

package/src/shade/renderer/shadow/map/csm/shader/shader_csm_caster_range.d.ts

@@ -0,0 +1,49 @@
+export const CSM_CASTER_RANGE_WORKGROUP_SIZE: number;
+/**
+ * What one directional shadow map's accumulate pass runs with: the frusta the CPU fitted this
+ * frame, and where in the scratch buffer this map's cascades accumulate.
+ *
+ * @type {WebGPUStruct}
+ */
+export const CSM_CASTER_RANGE_SETTINGS_STRUCT: WebGPUStruct;
+/**
+ * What the publish pass runs with.
+ *
+ * @type {WebGPUStruct}
+ */
+export const CSM_CASTER_RANGE_PUBLISH_STRUCT: WebGPUStruct;
+/**
+ * Measure how near along the light every mesh row's world bounds reach, per cascade, over the
+ * rows that intersect the cascade's side planes.
+ *
+ * **This is what makes the cascade's near plane the GPU's to fit.** The CPU used to walk its own
+ * copy of the scene's bounds tree to tighten each cascade's near plane against the casters between
+ * the light and the view slice; that copy does not exist for a row the GPU composes — a skinned
+ * character under a clip, a subtree the CPU stopped composing — so the measure is taken where the
+ * bounds are: the `meshes` table, one thread per occupied row, after the bounds pass has refreshed
+ * it for the frame. The result is read back and applied to the next frame's fit, with a margin.
+ *
+ * The test per cascade is the one the tree walk made: a box survives the four fixed side planes if
+ * its corner furthest along each plane's normal is inside; the plane a survivor pushes is the
+ * near one, to the box corner nearest along the light's axis. Per-thread CAS minimum rather than
+ * a subgroup reduction first, because a scene has hundreds of rows and three cascades, and the
+ * same CAS helper already bounds the skinned meshes.
+ *
+ * Dispatch with {@link GPUTypedTable#dispatch_group_count} of the `meshes` table at
+ * {@link CSM_CASTER_RANGE_WORKGROUP_SIZE}, once per directional shadow map being drawn.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_csm_caster_range_accumulate: ComputeShader;
+/**
+ * Copy one map's accumulated ranges into its row of the light database's `shadow_csm_caster_range`
+ * table — where the readback reads them from — and reset the scratch for the next frame.
+ *
+ * One workgroup, one thread: the row is one record, written whole.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_csm_caster_range_publish: ComputeShader;
+import { WebGPUStruct } from "../../../../shader/type/WebGPUStruct.js";
+import { ComputeShader } from "../../../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_csm_caster_range.d.ts.map

package/src/shade/renderer/shadow/map/csm/shader/shader_csm_caster_range.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_csm_caster_range.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shadow/map/csm/shader/shader_csm_caster_range.js"],"names":[],"mappings":"AAaA,qDAAiF;AAEjF;;;;;GAKG;AACH,+CAFU,YAAY,CAmBc;AAEpC;;;;GAIG;AACH,8CAFU,YAAY,CAQa;AAenC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,iDAFU,aAAa,CA2DpB;AAUH;;;;;;;GAOG;AACH,8CAFU,aAAa,CAgCpB;6BA/L0B,yCAAyC;8BAGxC,qCAAqC"}

package/src/shade/renderer/shadow/map/csm/shader/shader_csm_caster_range.js

@@ -0,0 +1,194 @@
+import { atomic_u32, u32, vec4f } from "../../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../../../shader/type/WebGPUStruct.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 { chunk_aabb_atomic_f32 } from "../../../../animation/skinning/bounds_refresh/chunk_aabb_atomic_f32.js";
+import { LIGHT_DATABASE_SPEC } from "../../../../light/LIGHT_DATABASE_SPEC.js";
+import { MESHES_TABLE } from "../../../../scene/chunk_scene_database_access.js";
+import { CSM_CASTER_RANGE_UNKNOWN } from "../CSM_CASTER_RANGE_STRUCT.js";
+import { SHADOWMAP_CSM_CASCADE_COUNT } from "../SHADOWMAP_CSM_CASCADE_COUNT.js";
+
+export const CSM_CASTER_RANGE_WORKGROUP_SIZE = COMPUTE_SHADER_DEFAULT_GROUP_SIZE;
+
+/**
+ * What one directional shadow map's accumulate pass runs with: the frusta the CPU fitted this
+ * frame, and where in the scratch buffer this map's cascades accumulate.
+ *
+ * @type {WebGPUStruct}
+ */
+export const CSM_CASTER_RANGE_SETTINGS_STRUCT = WebGPUStruct.from({
+    /**
+     * The light's z axis in world space — the axis a caster's light-view depth is measured along —
+     * without the cascade's own translation, which the CPU adds back when it applies the range.
+     * `w` is unused.
+     */
+    z_axis: vec4f,
+    /**
+     * The four side planes of each cascade's light frustum, four per cascade in cascade order,
+     * inward: `dot(n, p) + w >= 0` is inside. Not normalized, and they need not be.
+     */
+    planes: WebGPUArray.from(vec4f, SHADOWMAP_CSM_CASCADE_COUNT * 4),
+    /**
+     * First scratch word of this map's cascades: cascade `c` accumulates into `base + c`.
+     */
+    base: u32,
+    cascade_count: u32,
+}, "CSMCasterRangeSettings").pack();
+
+/**
+ * What the publish pass runs with.
+ *
+ * @type {WebGPUStruct}
+ */
+export const CSM_CASTER_RANGE_PUBLISH_STRUCT = WebGPUStruct.from({
+    /** the map's row of the light database's `shadow_csm_caster_range` table */
+    row: u32,
+    /** see {@link CSM_CASTER_RANGE_SETTINGS_STRUCT#base} */
+    base: u32,
+    cascade_count: u32,
+}, "CSMCasterRangePublish").pack();
+
+const WG = CSM_CASTER_RANGE_WORKGROUP_SIZE;
+const PG = MESHES_TABLE.page_iterator_symbol_prefix(WG);
+const RANGE_TABLE = LIGHT_DATABASE_SPEC.get('shadow_csm_caster_range');
+
+const accumulate_resources = new ShaderResourceSetDescriptor();
+
+accumulate_resources.createGroup()
+    .addStorageBuffer('scene_database', WebGPUArray.from(u32), false)
+    .addUniform('settings', CSM_CASTER_RANGE_SETTINGS_STRUCT)
+    // one word per cascade per map, holding plain f32 bit patterns, seeded to the largest finite
+    // f32 and reset to it by the publish
+    .addStorageBuffer('ranges', WebGPUArray.from(atomic_u32), true);
+
+/**
+ * Measure how near along the light every mesh row's world bounds reach, per cascade, over the
+ * rows that intersect the cascade's side planes.
+ *
+ * **This is what makes the cascade's near plane the GPU's to fit.** The CPU used to walk its own
+ * copy of the scene's bounds tree to tighten each cascade's near plane against the casters between
+ * the light and the view slice; that copy does not exist for a row the GPU composes — a skinned
+ * character under a clip, a subtree the CPU stopped composing — so the measure is taken where the
+ * bounds are: the `meshes` table, one thread per occupied row, after the bounds pass has refreshed
+ * it for the frame. The result is read back and applied to the next frame's fit, with a margin.
+ *
+ * The test per cascade is the one the tree walk made: a box survives the four fixed side planes if
+ * its corner furthest along each plane's normal is inside; the plane a survivor pushes is the
+ * near one, to the box corner nearest along the light's axis. Per-thread CAS minimum rather than
+ * a subgroup reduction first, because a scene has hundreds of rows and three cascades, and the
+ * same CAS helper already bounds the skinned meshes.
+ *
+ * Dispatch with {@link GPUTypedTable#dispatch_group_count} of the `meshes` table at
+ * {@link CSM_CASTER_RANGE_WORKGROUP_SIZE}, once per directional shadow map being drawn.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_csm_caster_range_accumulate = ComputeShader.from({
+    label: "CSM/CasterRangeAccumulate",
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(${WG},1,1)
+fn main(
+    @builtin(workgroup_id) wg_id: vec3<u32>,
+    @builtin(local_invocation_index) local_id: u32,
+) {
+    // page_address is uniform across the workgroup, so this branch is uniform
+    if !${PG}_setup(&scene_database, wg_id.x, local_id) {
+        return;
+    }
+
+    let slot = ${PG}_slot_in_page(local_id);
+
+    if slot >= ${PG}_ELEMENTS_PER_PAGE || !${PG}_is_occupied(slot) {
+        return;
+    }
+
+    let mesh = ${PG}_read(&scene_database, slot);
+
+    let low = vec3<f32>(mesh.bounding_box[0], mesh.bounding_box[1], mesh.bounding_box[2]);
+    let high = vec3<f32>(mesh.bounding_box[3], mesh.bounding_box[4], mesh.bounding_box[5]);
+
+    // the corner nearest along the light's axis: the low end wherever the axis points up
+    let axis = settings.z_axis.xyz;
+    let nearest = select(high, low, axis >= vec3<f32>(0.0));
+    let z = dot(axis, nearest);
+
+    let cascade_count = settings.cascade_count;
+
+    for (var c = 0u; c < cascade_count; c += 1u) {
+        var inside = true;
+
+        for (var p = 0u; p < 4u; p += 1u) {
+            let plane = settings.planes[c * 4u + p];
+
+            // the corner furthest along the normal decides whether any of the box is inside
+            let furthest = select(low, high, plane.xyz >= vec3<f32>(0.0));
+
+            if dot(plane.xyz, furthest) + plane.w < 0.0 {
+                inside = false;
+            }
+        }
+
+        if inside {
+            aabb_atomic_min_f32(&ranges[settings.base + c], z);
+        }
+    }
+}
+`, [
+            MESHES_TABLE.chunk_iterate(WG),
+            chunk_aabb_atomic_f32,
+        ]),
+    resources: accumulate_resources,
+});
+
+const publish_resources = new ShaderResourceSetDescriptor();
+
+publish_resources.setImmediate('publish', CSM_CASTER_RANGE_PUBLISH_STRUCT);
+
+publish_resources.createGroup()
+    .addStorageBuffer('ranges', WebGPUArray.from(atomic_u32), true)
+    .addStorageBuffer('light_database', WebGPUArray.from(u32), true);
+
+/**
+ * Copy one map's accumulated ranges into its row of the light database's `shadow_csm_caster_range`
+ * table — where the readback reads them from — and reset the scratch for the next frame.
+ *
+ * One workgroup, one thread: the row is one record, written whole.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_csm_caster_range_publish = ComputeShader.from({
+    label: "CSM/CasterRangePublish",
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+// the reset value: see CSM_CASTER_RANGE_UNKNOWN
+const RANGE_UNKNOWN = ${CSM_CASTER_RANGE_UNKNOWN};
+
+@compute @workgroup_size(1,1,1)
+fn main() {
+    var near: array<f32, ${SHADOWMAP_CSM_CASCADE_COUNT}>;
+
+    for (var c = 0u; c < ${SHADOWMAP_CSM_CASCADE_COUNT}u; c += 1u) {
+        if c < publish.cascade_count {
+            let word = publish.base + c;
+
+            near[c] = bitcast<f32>(atomicLoad(&ranges[word]));
+
+            atomicStore(&ranges[word], bitcast<u32>(RANGE_UNKNOWN));
+        } else {
+            near[c] = RANGE_UNKNOWN;
+        }
+    }
+
+    ${RANGE_TABLE.marshalling_method_write_field('near')}(&light_database, publish.row, near);
+}
+`, [
+            RANGE_TABLE.wgsl_gen_write_field_code('near'),
+        ]),
+    resources: publish_resources,
+});

package/src/shade/renderer/shadow/map/csm_debug_draw_preview.js

@@ -150,7 +150,7 @@ export function csm_debug_draw_preview({
     Array.prototype.push.apply(vertices, polygons.map(l => l.points).flat());
 
     const projection_matrix = new Float32Array(16);
-    m4_invert(projection_matrix, shadowmap.light.transform_global.matrix);
+    m4_invert(projection_matrix, shadowmap.light.transform.matrix);
 
     // project
     for (let i = 0; i < vertices.length; i++) {

package/src/shade/renderer/shadow/map/shadowmap_update_score.js

@@ -96,7 +96,7 @@ export function compute_light_projected_area_px(light, main_camera, view_resolut
         return full_area;
     }
 
-    const t = light.transform_global;
+    const t = light.transform;
     return compute_projected_sphere_area_pixels(
         t.translation_x, t.translation_y, t.translation_z,
         radius,

package/src/shade/renderer/shadow/ray/RTXShadows.js

@@ -158,7 +158,7 @@ export class RTXShadows {
             // (same one the path tracer uses) so glass occluders attenuate
             // shadow rays via the view-Fresnel mix in ray_shaded_query_occluded.
             const r_materials = context.graphics.materials_resident;
-            r_materials.ensure_scene_materials(scene_ctx.scene);
+            r_materials.ensure_scene_materials(scene_ctx);
             r_materials.update();
 
             shader_ray_shadow_code.dispatch({

package/src/shade/renderer/shadow/ray/staged/trace/graph_trace_rays.js

@@ -43,7 +43,7 @@ export function graph_trace_rays({
         // the path tracer uses, so a glass occluder's view-Fresnel coverage
         // can be sampled inside the shadow trace.
         const r_materials = context.graphics.materials_resident;
-        r_materials.ensure_scene_materials(scene_ctx.scene);
+        r_materials.ensure_scene_materials(scene_ctx);
         r_materials.update();
 
         // Per-frame seed for the stochastic alpha test along the shadow ray.

package/src/shade/renderer/shadow/sdf/cascade/CascadedSceneSDF.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CascadedSceneSDF.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shadow/sdf/cascade/CascadedSceneSDF.js"],"names":[],"mappings":"AAkBA;IAqDI;;;OAGG;IACH,+BAmCC;IArFD;;;OAGG;IACH,QAFU,KAAK,CAE8B;IAa7C,iCAEC;IAED;;;OAGG;IACH,yBAFW,MAAM,QAqBhB;IA2CD;;;;OAIG;IACH,oBAHW,sBAAsB,SACtB,eAAe,QAwDzB;IAED;;;;OAIG;IACH,WAHW,sBAAsB,SACtB,eAAe,QAOzB;IAED;;;OAGG;IACH,kBAFW,YAAY,iBA4BtB;IAED,0BAQC;IAED;;;OAGG;IACH,oBAFW,YAAY,QAkEtB;IAED,gBAEC;;CACJ;8BA/RY,OAAO,mCAAmC,EAAE,eAAe;sBATlD,2CAA2C;kCAK/B,uCAAuC;uCAFlC,8CAA8C;6BANxD,4CAA4C"}
+{"version":3,"file":"CascadedSceneSDF.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shadow/sdf/cascade/CascadedSceneSDF.js"],"names":[],"mappings":"AAkBA;IAqDI;;;OAGG;IACH,+BAmCC;IArFD;;;OAGG;IACH,QAFU,KAAK,CAE8B;IAa7C,iCAEC;IAED;;;OAGG;IACH,yBAFW,MAAM,QAqBhB;IA2CD;;;;OAIG;IACH,oBAHW,sBAAsB,SACtB,eAAe,QAwDzB;IAED;;;;OAIG;IACH,WAHW,sBAAsB,SACtB,eAAe,QASzB;IAED;;;OAGG;IACH,kBAFW,YAAY,iBA4BtB;IAED,0BAQC;IAED;;;OAGG;IACH,oBAFW,YAAY,QAkEtB;IAED,gBAEC;;CACJ;8BAjSY,OAAO,mCAAmC,EAAE,eAAe;sBATlD,2CAA2C;kCAK/B,uCAAuC;uCAFlC,8CAA8C;6BANxD,4CAA4C"}

package/src/shade/renderer/shadow/sdf/cascade/CascadedSceneSDF.js

@@ -178,7 +178,9 @@ export class CascadedSceneSDF {
      */
     build(ctx, scene) {
 
-        this.bounds.copy(scene.scene.instances.bounding_box);
+        // sized to what the CPU placed, under the ECS's own composition — the rows' union, exact
+        // for a static scene, which is what a volume built once is for
+        scene.rows.compute_world_bounds(this.bounds);
         this.update(ctx, scene);
 
     }

package/src/shade/renderer/texture/bindless/GPUBindlessTextureManager.js

@@ -126,17 +126,17 @@ export class GPUBindlessTextureManager {
         const old_buffer = this.#data_buffer;
         const old_size = old_buffer.size;
 
-        // The allocator bins free runs by rounding down and requests by rounding up, up to 9/8
-        // apart, so room for exactly `required_size` can still be refused — hence the headroom.
-        // Doubling on top of that keeps a run of small textures from paying for a copy of the whole
-        // arena apiece. The ceiling is the device's: `createBuffer` answers a size past
-        // `maxBufferSize` with an *invalid* buffer rather than an exception, and swapping one of
-        // those in would destroy the arena and leave the allocator sized for space that is not
-        // there, silently.
+        // Room for exactly `required_size` can still be refused — the allocator bins free runs by
+        // rounding down and requests by rounding up — so the arena to ask for is the allocator's own
+        // answer rather than a margin worked out here. Doubling on top of that keeps a run of small
+        // textures from paying for a copy of the whole arena apiece. The ceiling is the device's:
+        // `createBuffer` answers a size past `maxBufferSize` with an *invalid* buffer rather than an
+        // exception, and swapping one of those in would destroy the arena and leave the allocator
+        // sized for space that is not there, silently.
         const new_size = Math.min(
             round_up_to_arena_granularity(Math.max(
                 old_size * 2,
-                old_size + required_size * 9 / 8
+                this.#allocator.grow_target_for(required_size)
             )),
             Math.floor(device.limits.maxBufferSize / ARENA_GRANULARITY_BYTES) * ARENA_GRANULARITY_BYTES
         );

package/src/shade/renderer/volumetrics/GPUViewVolumetrics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUViewVolumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/GPUViewVolumetrics.js"],"names":[],"mappings":"AAiCA;IAkII;;;;OAIG;IACH,kBAHW,cAAc,qBAwBxB;IAxHD;;OAEG;IACH,4BAOC;IAjBD;;OAEG;IACH,2BAEC;IAsCD;;OAEG;IACH,0BAEC;IAZD;;OAEG;IACH,yBAEC;IAwFD,gBAWC;IA4ND;;;;;;;;OAQG;IACH;QAN+B,KAAK,EAAzB,UAAU;QACM,kBAAkB,EAAlC,MAAM;QACU,oBAAoB,EAApC,MAAM;QACU,wBAAwB,EAAxC,MAAM;QACU,eAAe,EAA/B,MAAM;;;;MA2EhB;;CAEJ;yBAleY,OAAO,2DAA2D,EAAE,UAAU;6BAC9E,OAAO,2BAA2B,EAAE,cAAc"}
+{"version":3,"file":"GPUViewVolumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/GPUViewVolumetrics.js"],"names":[],"mappings":"AAiCA;IAkII;;;;OAIG;IACH,kBAHW,cAAc,qBAwBxB;IAxHD;;OAEG;IACH,4BAOC;IAjBD;;OAEG;IACH,2BAEC;IAsCD;;OAEG;IACH,0BAEC;IAZD;;OAEG;IACH,yBAEC;IAwFD,gBAWC;IA6ND;;;;;;;;OAQG;IACH;QAN+B,KAAK,EAAzB,UAAU;QACM,kBAAkB,EAAlC,MAAM;QACU,oBAAoB,EAApC,MAAM;QACU,wBAAwB,EAAxC,MAAM;QACU,eAAe,EAA/B,MAAM;;;;MA2EhB;;CAEJ;yBAneY,OAAO,2DAA2D,EAAE,UAAU;6BAC9E,OAAO,2BAA2B,EAAE,cAAc"}

package/src/shade/renderer/volumetrics/GPUViewVolumetrics.js

@@ -287,8 +287,9 @@ export class GPUViewVolumetrics {
         const resolution = VOLUMETRICS_SUN_SHADOW_RESOLUTION;
 
         // `forward` is the direction light TRAVELS — the same vector light_record_directional
-        // writes into the table, which the shader then negates to point at the light.
-        const direction = sun.forward;
+        // writes into the table, which the shader then negates to point at the light. Read off the
+        // CPU copy of the pose: the cascade is built here, on this side.
+        const direction = sun.transform.forward;
 
         const view_matrix = camera.view_matrix;
         const position = camera.transform;
@@ -311,7 +312,7 @@ export class GPUViewVolumetrics {
             this.#sun_shadow_step_ws[cascade] = build_volumetrics_sun_shadow_transform({
                 ws_to_uvw: this.#sun_shadow_ws_to_uvw[cascade],
                 uvw_to_ws: this.#sun_shadow_uvw_to_ws[cascade],
-                light_direction: [direction.x, direction.y, direction.z],
+                light_direction: [direction[0], direction[1], direction[2]],
                 camera_position: [position.translation_x, position.translation_y, position.translation_z],
                 camera_forward,
                 fov_y: camera.fov,