@woosh/meep-engine 3.17.1 → 3.18.0

package/src/shade/renderer/Renderer.js

@@ -201,16 +201,6 @@ export class Renderer {
      */
     feature_particles_enabled = false;
 
-    /**
-     * Most particles alive at once in a scene — the pool every emitter of that scene draws its
-     * records from. Read once, when the scene's {@link GPUParticleSystem} is created on the first
-     * frame {@link feature_particles_enabled} is on for it; the pool does not grow afterwards, so
-     * set this before that frame. Left undefined, the system's own default applies.
-     *
-     * @type {number|undefined}
-     */
-    particle_capacity = undefined;
-
     feature_ssr_enabled = false;
     feature_ssao_enabled = true;
     /**
@@ -397,21 +387,6 @@ export class Renderer {
      */
     get dof_unreal() { return this.#depth_of_field_unreal; }
 
-    /**
-     * When true and {@link indirect_lighting_mode} is Brick4, run a single fused
-     * pass that produces the resolved indirect lighting directly (combining the
-     * brick4 diffuse, brick4 specular and indirect resolve passes). Trades a
-     * bit of cache pressure inside the pass for substantially less memory
-     * bandwidth: no intermediate rgba16float diffuse/specular targets, the
-     * g-buffer is read once, and a single brick4 probe pair is shared between
-     * the diffuse and specular evaluations.
-     *
-     * SSR is mutually exclusive with the fused path (it needs the standalone
-     * specular target as input), so when SSR is enabled the split path is used.
-     * @type {boolean}
-     */
-    fused_indirect = true;
-
     /**
      * RCAS
      * @type {boolean}
@@ -796,8 +771,7 @@ export class Renderer {
     }
 
     /**
-     * Compute deferred indirect specular and diffuse contributions
-     * based on the active indirect lighting mode.
+     * Build and composite deferred indirect lighting, including fused and SSR paths.
      *
      * @param {object} params
      * @param {FrameGraph} params.graph
@@ -805,6 +779,7 @@ export class Renderer {
      * @param {GPUSceneContext} params.scene_ctx
      * @param {number} params.bent_normals - graph resource ID
      * @param {number} params.current_color_out - graph resource ID (scene color, needed for SSR)
+     * @param {number} params.gr_texture_depth_previous
      * @param {number} params.gr_texture_depth_current
      * @param {number} params.gr_texture_hzb
      * @param {number} params.gr_texture_material_albedo_ao
@@ -816,7 +791,7 @@ export class Renderer {
      * @param {number} params.gr_buffer_camera_current
      * @param {number} params.gr_buffer_camera_previous
      * @param {Vector2} params.resolution
-     * @returns {{indirect_specular: number, indirect_diffuse: number}}
+     * @returns {number} Updated scene-color graph resource ID
      */
     #graph_indirect_lighting({
                                  graph,
@@ -826,6 +801,7 @@ export class Renderer {
                                  current_color_out,
                                  //
                                  gr_texture_depth_current,
+                                 gr_texture_depth_previous,
                                  gr_texture_hzb,
                                  gr_texture_material_albedo_ao,
                                  gr_texture_pbr,
@@ -838,24 +814,136 @@ export class Renderer {
                                  resolution,
                              }) {
 
-        const mode = this.indirect_lighting_mode;
-
-        let indirect_specular = -1;
-        let indirect_diffuse = -1;
+        const mode = this.indirect_lighting_mode;
+        // Prefer fusion where supported to avoid intermediate diffuse/specular
+        // targets and repeated G-buffer reads. This is a local graph policy.
+        const prefer_fused = true;
+        const lpv = scene_ctx.light_probe_volume;
+        let diffuse_pass;
+        let specular_pass;
+        let ssr_inputs;
+
+        // Each mode owns its diffuse/specular pair and any fused implementation.
+        // SSR overrides specular below using the same explicitly selected mode.
+        switch (mode) {
+            case ShadeIndirectLightingMode.IBL:
+                ssr_inputs = { input_environment: gr_texture_environment };
+                diffuse_pass = {
+                    shader: shader_diffuse_IBL,
+                    inputs: {
+                        tBentNormals: bent_normals,
+                        tGBufferAlbedo: gr_texture_material_albedo_ao,
+                        tEnvironment: gr_texture_environment,
+                    },
+                };
+                specular_pass = {
+                    shader: shader_specular_IBL,
+                    inputs: {
+                        tBentNormals: bent_normals,
+                        tNormals: gr_texture_normal,
+                        tDepth: gr_texture_depth_current,
+                        tPBR: gr_texture_pbr,
+                        tEnvironment: gr_texture_environment,
+                        camera: gr_buffer_camera_current,
+                    },
+                };
+                break;
 
-        const lpv = scene_ctx.light_probe_volume;
+            case ShadeIndirectLightingMode.Brick4:
+                // SSR needs its own specular resolve and denoising passes.
+                if (prefer_fused && !this.feature_ssr_enabled) {
+                    [current_color_out] = graph_image_pass({
+                        graph,
+                        shader: shader_brick4_indirect_lighting,
+                        output: [current_color_out],
+                        input_depth: gr_texture_depth_current,
+                        load_op: "load",
+                        inputs: {
+                            tDepth: gr_texture_depth_current,
+                            tGBufferNormals: gr_texture_normal,
+                            tBentNormals: bent_normals,
+                            tGBufferAlbedo: gr_texture_material_albedo_ao,
+                            tGBufferPBR: gr_texture_pbr,
+                            tSTBN_vec2: STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec2,
+                            view: view_ctx.uniform_buffer.buffer,
+                            camera: gr_buffer_camera_current,
+                            //
+                            brick4: scene_ctx.volumetric_light_map.buffer,
+                            tSplitSum: STATIC_GRAPHICS_ENGINE_ASSETS.split_sum,
+                        },
+                    });
+                    return current_color_out;
+                }
+                ssr_inputs = { brick4: scene_ctx.volumetric_light_map };
+                diffuse_pass = {
+                    shader: shader_brick4_diffuse,
+                    inputs: {
+                        tDepth: gr_texture_depth_current,
+                        tBentNormals: bent_normals,
+                        tAlbedoAO: gr_texture_material_albedo_ao,
+                        tSTBN_vec2: STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec2,
+                        camera: gr_buffer_camera_current,
+                        view: view_ctx.uniform_buffer.buffer,
+                        brick4: scene_ctx.volumetric_light_map.buffer,
+                    },
+                };
+                specular_pass = {
+                    shader: shader_brick4_specular,
+                    inputs: {
+                        tDepth: gr_texture_depth_current,
+                        tNormals: gr_texture_normal,
+                        tPBR: gr_texture_pbr,
+                        tSTBN_vec2: STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec2,
+                        camera: gr_buffer_camera_current,
+                        view: view_ctx.uniform_buffer.buffer,
+                        brick4: scene_ctx.volumetric_light_map.buffer,
+                    },
+                };
+                break;
 
-        //
-        // ── SPECULAR ────────────────────────────────────────────
-        //
+            case ShadeIndirectLightingMode.LPV:
+                ssr_inputs = { lpv, input_environment: gr_texture_environment };
+                diffuse_pass = {
+                    shader: shader_diffuse_LPV,
+                    inputs: {
+                        camera: gr_buffer_camera_current,
+                        tDepth: gr_texture_depth_current,
+                        tBentNormals: bent_normals,
+                        tGBufferAlbedo: gr_texture_material_albedo_ao,
+                        lpv_atlas_radiance: lpv.atlas.texture_radiance,
+                        lpv_atlas_depth: lpv.atlas.texture_depth,
+                        lpv_lookup: lpv.buffer_mesh_bvh,
+                        lpv_metadata: lpv.buffer_metadata,
+                        lpv_mesh: lpv.buffer_mesh,
+                        lpv_probes: lpv.buffer_probes,
+                    },
+                };
+                // Without SSR, LPV uses environment-map specular.
+                specular_pass = {
+                    shader: shader_specular_IBL,
+                    inputs: {
+                        tBentNormals: bent_normals,
+                        tNormals: gr_texture_normal,
+                        tDepth: gr_texture_depth_current,
+                        tPBR: gr_texture_pbr,
+                        tEnvironment: gr_texture_environment,
+                        camera: gr_buffer_camera_current,
+                    },
+                };
+                break;
 
-        // SSR replaces the specular IBL fallback when enabled.
-        // NOTE: SSR is currently not supported in Brick4 mode — this is a known
-        // limitation and will be addressed in a future update.
-        if (this.feature_ssr_enabled && mode !== ShadeIndirectLightingMode.Brick4) {
+            default:
+                throw new Error(`Unsupported indirect lighting mode: ${mode}`);
+        }
 
-            const ssr = this.#postprocess.ssr.graph_pass({
-                graph,
+        let indirect_specular;
+        if (this.feature_ssr_enabled) {
+            const ssr = this.#postprocess.ssr.graph_pass({
+                graph,
+                ...ssr_inputs,
+                view_ctx,
+                jitter: view_ctx.jitter,
+                input_depth_previous: gr_texture_depth_previous,
                 input_depth: gr_texture_depth_current,
                 input_hzb: gr_texture_hzb,
                 input_scene_color: current_color_out,
@@ -864,118 +952,53 @@ export class Renderer {
                 input_normal: gr_texture_normal,
                 input_velocity: gr_velocity,
                 input_occlusion: gr_occlusion_clip,
-                input_environment: gr_texture_environment,
                 camera_current: gr_buffer_camera_current,
                 camera_previous: gr_buffer_camera_previous,
-                lpv: mode === ShadeIndirectLightingMode.LPV ? lpv : undefined,
+                indirect_lighting_mode: mode,
                 resolution,
             });
 
             indirect_specular = ssr.denoised;
-
-        } else if (mode === ShadeIndirectLightingMode.Brick4) {
-
-            // Brick4 specular from volumetric lightmap
-            [indirect_specular] = graph_image_pass({
-                graph,
-                shader: shader_brick4_specular,
-                input_depth: gr_texture_depth_current,
-                inputs: {
-                    tDepth: gr_texture_depth_current,
-                    tNormals: gr_texture_normal,
-                    tPBR: gr_texture_pbr,
-                    tSTBN_vec2: STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec2,
-                    camera: gr_buffer_camera_current,
-                    view: view_ctx.uniform_buffer.buffer,
-                    brick4: scene_ctx.volumetric_light_map.buffer,
-                },
-                output_resolution: view_ctx.resolution,
-            });
-
         } else {
-            // IBL / LPV fallback — environment map specular
             [indirect_specular] = graph_image_pass({
                 graph,
-                shader: shader_specular_IBL,
+                ...specular_pass,
                 input_depth: gr_texture_depth_current,
-                inputs: {
-                    tBentNormals: bent_normals,
-                    tNormals: gr_texture_normal,
-                    tDepth: gr_texture_depth_current,
-                    tPBR: gr_texture_pbr,
-                    tEnvironment: gr_texture_environment,
-                    camera: gr_buffer_camera_current,
-                },
                 output_resolution: view_ctx.resolution,
             });
         }
 
-        //
-        // ── DIFFUSE ─────────────────────────────────────────────
-        //
-
-        switch (mode) {
-
-            case ShadeIndirectLightingMode.IBL:
-                // Environment map irradiance
-                [indirect_diffuse] = graph_image_pass({
-                    graph,
-                    shader: shader_diffuse_IBL,
-                    input_depth: gr_texture_depth_current,
-                    inputs: {
-                        tBentNormals: bent_normals,
-                        tGBufferAlbedo: gr_texture_material_albedo_ao,
-                        tEnvironment: gr_texture_environment,
-                    },
-                    output_resolution: view_ctx.resolution,
-                });
-                break;
-
-            case ShadeIndirectLightingMode.Brick4:
-                // Brick4 diffuse from volumetric lightmap
-                [indirect_diffuse] = graph_image_pass({
-                    graph,
-                    shader: shader_brick4_diffuse,
-                    input_depth: gr_texture_depth_current,
-                    inputs: {
-                        tDepth: gr_texture_depth_current,
-                        tBentNormals: bent_normals,
-                        tAlbedoAO: gr_texture_material_albedo_ao,
-                        tSTBN_vec2: STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec2,
-                        camera: gr_buffer_camera_current,
-                        view: view_ctx.uniform_buffer.buffer,
-                        brick4: scene_ctx.volumetric_light_map.buffer,
-                    },
-                    output_resolution: view_ctx.resolution,
-                });
-                break;
+        const [indirect_diffuse] = graph_image_pass({
+            graph,
+            ...diffuse_pass,
+            input_depth: gr_texture_depth_current,
+            output_resolution: view_ctx.resolution,
+        });
 
-            case ShadeIndirectLightingMode.LPV:
-                // Light Probe Volume diffuse
-                [indirect_diffuse] = graph_image_pass({
-                    graph,
-                    shader: shader_diffuse_LPV,
-                    input_depth: gr_texture_depth_current,
-                    inputs: {
-                        camera: gr_buffer_camera_current,
-                        tDepth: gr_texture_depth_current,
-                        tBentNormals: bent_normals,
-                        tGBufferAlbedo: gr_texture_material_albedo_ao,
-                        //
-                        lpv_atlas_radiance: lpv.atlas.texture_radiance,
-                        lpv_atlas_depth: lpv.atlas.texture_depth,
-                        //
-                        lpv_lookup: lpv.buffer_mesh_bvh,
-                        lpv_metadata: lpv.buffer_metadata,
-                        lpv_mesh: lpv.buffer_mesh,
-                        lpv_probes: lpv.buffer_probes,
-                    },
-                    output_resolution: view_ctx.resolution,
-                });
-                break;
-        }
+        // resolve indirect lighting
+        [current_color_out] = graph_image_pass({
+            graph,
+            shader: shader_resolve_indirect_lighting,
+            output: [current_color_out],
+            input_depth: gr_texture_depth_current,
+            load_op: "load",
+            inputs: {
+                tIndirectDiffuse: indirect_diffuse,
+                tIndirectSpecular: indirect_specular,
+                //
+                tGBufferNormals: gr_texture_normal,
+                tBentNormals: bent_normals,
+                tGBufferAlbedo: gr_texture_material_albedo_ao,
+                tGBufferPBR: gr_texture_pbr,
+                tDepth: gr_texture_depth_current,
+                //
+                camera: gr_buffer_camera_current,
+                //
+                tSplitSum: STATIC_GRAPHICS_ENGINE_ASSETS.split_sum,
+            },
+        });
 
-        return { indirect_specular, indirect_diffuse };
+        return current_color_out;
     }
 
     /**
@@ -983,6 +1006,9 @@ export class Renderer {
      */
     #postprocess
 
+    /** SSR settings, available after initialize(). @returns {import("./postprocess/ssr/SSR.js").SSR} */
+    get ssr() { return this.#postprocess.ssr; }
+
     /**
      * @type {ReSTIRDI}
      */
@@ -1021,7 +1047,7 @@ export class Renderer {
         let system = this.#particle_systems.get(scene_ctx);
 
         if (system === undefined) {
-            system = new GPUParticleSystem(this.#graphics, scene_ctx, { capacity: this.particle_capacity });
+            system = new GPUParticleSystem(this.#graphics, scene_ctx);
             this.#particle_systems.set(scene_ctx, system);
         }
 
@@ -2203,85 +2229,26 @@ export class Renderer {
             output: [current_color_out],
         });
 
-        {
-            // Fused brick4 path: skip the intermediate diffuse/specular targets and the
-            // separate resolve, doing it all in a single shader. SSR isn't compatible
-            // since it consumes the standalone specular target.
-            const use_fused_indirect = this.fused_indirect
-                && this.indirect_lighting_mode === ShadeIndirectLightingMode.Brick4
-                && !this.feature_ssr_enabled;
-
-            if (use_fused_indirect) {
-
-                [current_color_out] = graph_image_pass({
-                    graph,
-                    shader: shader_brick4_indirect_lighting,
-                    output: [current_color_out],
-                    input_depth: gr_texture_depth_current,
-                    load_op: "load",
-                    inputs: {
-                        tDepth: gr_texture_depth_current,
-                        tGBufferNormals: gr_texture_normal,
-                        tBentNormals: bent_normals,
-                        tGBufferAlbedo: gr_texture_material_albedo_ao,
-                        tGBufferPBR: gr_texture_pbr,
-                        tSTBN_vec2: STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec2,
-                        view: view_ctx.uniform_buffer.buffer,
-                        camera: gr_buffer_camera_current,
-                        //
-                        brick4: scene_ctx.volumetric_light_map.buffer,
-                        tSplitSum: STATIC_GRAPHICS_ENGINE_ASSETS.split_sum,
-                    },
-                });
-
-            } else {
-
-                const { indirect_specular, indirect_diffuse } = this.#graph_indirect_lighting({
-                    graph,
-                    view_ctx,
-                    scene_ctx,
-                    bent_normals,
-                    current_color_out,
-                    //
-                    gr_texture_depth_current,
-                    gr_texture_hzb,
-                    gr_texture_material_albedo_ao,
-                    gr_texture_pbr,
-                    gr_texture_normal,
-                    gr_texture_environment,
-                    gr_velocity,
-                    gr_occlusion_clip,
-                    gr_buffer_camera_current,
-                    gr_buffer_camera_previous,
-                    resolution,
-                });
-
-                // resolve indirect lighting
-                [current_color_out] = graph_image_pass({
-                    graph,
-                    shader: shader_resolve_indirect_lighting,
-                    output: [current_color_out],
-                    input_depth: gr_texture_depth_current,
-                    load_op: "load",
-                    inputs: {
-                        tIndirectDiffuse: indirect_diffuse,
-                        tIndirectSpecular: indirect_specular,
-                        //
-                        tGBufferNormals: gr_texture_normal,
-                        tBentNormals: bent_normals,
-                        tGBufferAlbedo: gr_texture_material_albedo_ao,
-                        tGBufferPBR: gr_texture_pbr,
-                        tDepth: gr_texture_depth_current,
-                        //
-                        camera: gr_buffer_camera_current,
-                        //
-                        tSplitSum: STATIC_GRAPHICS_ENGINE_ASSETS.split_sum,
-                    },
-                });
-
-            }
-
-        }
+        current_color_out = this.#graph_indirect_lighting({
+            graph,
+            view_ctx,
+            scene_ctx,
+            bent_normals,
+            current_color_out,
+            //
+            gr_texture_depth_current,
+            gr_texture_depth_previous,
+            gr_texture_hzb,
+            gr_texture_material_albedo_ao,
+            gr_texture_pbr,
+            gr_texture_normal,
+            gr_texture_environment,
+            gr_velocity,
+            gr_occlusion_clip,
+            gr_buffer_camera_current,
+            gr_buffer_camera_previous,
+            resolution,
+        });
 
         // Composite volumetric fog over the finalized opaque + background + indirect colour.
         // A dedicated pass (not inline in the shading shaders) because indirect lighting is added

package/src/shade/renderer/animation/GPUAnimationManager.d.ts

@@ -478,14 +478,11 @@ export class GPUAnimationManager {
      * clamped to {@link MAX_DT_SECONDS} to keep a stall from
      * leaking multiple seconds into the next tick.
      *
-     * Early-outs: the clip passes (tick/apply/resolve/hierarchy)
-     * gate on the `animation_bound_track_groups` table being
-     * non-empty; skin matrix prep + skinning gate on registered
-     * skins instead — a skin whose joints are host-driven (no
-     * clips bound) still gets fresh skinning matrices every frame.
-     * With nothing registered no GPU work is encoded beyond the
-     * database flush — safe to call every frame regardless of
-     * registration state.
+     * Clip tick/apply/resolve gate on bound tracks; hierarchy propagation runs
+     * every frame, before skin matrix prep and skinning. CPU-driven nodes need it
+     * too: scene uploads seed global with the previous pose, and propagation
+     * composes the current one. On idle frames it advances prev_global so motion
+     * vectors settle to zero. Skin passes still gate on registered skins.
      *
      * @param {ShadeGPUCommandContext} cmd_ctx
      * @param {number} dt_seconds wall-clock seconds since last call

package/src/shade/renderer/animation/GPUAnimationManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUAnimationManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/GPUAnimationManager.js"],"names":[],"mappings":"AAiIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IA6OI;;;;OAIG;IACH,sCAHW,MAAM,kCAgBhB;IAED;;OAEG;IACH,4BAEC;IAED;;;;;;;;;;;;OAYG;IACH,gCAEC;IAED;;;;;;;;;;OAUG;IACH,qCAEC;IAED;;;;;;OAMG;IACH,gCAEC;IAED;;;;;;;;;;OAUG;IACH,mCAEC;IAED;;;;;;;;;;;;OAYG;IACH,4CAFW,MAAM,QA6BhB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ;QAAC,gBAAgB,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAC,CAK3D;IAED;;;;;;;;;;;;OAYG;IACH,gCAHW,MAAM,GACJ,MAAM,CAOlB;IAED;;;;;;;;;;;OAWG;IACH,kCAFa,MAAM,CA+BlB;IAED;;;;;;;;;;;;;;OAcG;IACH,oBAJW;QAAE,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAA;KAAE,GAEhD,MAAM,CA2BlB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH;eAPc,MAAM;qBACA,MAAM;mBACR,MAAM;kBACP,MAAM;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAC;QAEhE,MAAM,CAkElB;IAgCD;;;;;;;;;;;;;;;;;OAiBG;IACH,kBAHW,MAAM,QACN,MAAM,QAKhB;IAED;;;;;;;;OAQG;IACH,2BAHW,MAAM,QACN,MAAM,QAKhB;IAED;;;;;;;;;;;;;;OAcG;IACH,6BAHW,MAAM,UACN,MAAM,QAKhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,mBAHW,MAAM,SACN,MAAM,QAShB;IAED;;;;;;;OAOG;IACH,qBAHW,MAAM,SACN,MAAM,QAShB;IAED;;;;;;;;;;;OAWG;IACH,eAFW,MAAM,QAShB;IAED;;;;;;;;;OASG;IACH,cAFW,MAAM,QAShB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH;gBAJe,MAAM;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,YAAY,EAAE,YAAY,GAAG,MAAM,EAAE,CAAA;SAAE,CAAC;QAEhE,MAAM,CAoElB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,2BAFa,MAAM,CA0FlB;IAyLD;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,yCAFa,MAAM,CAsElB;IAwDD;;;;;;;;;;;;;;;OAeG;IACH,yBAFW,MAAM,QAoChB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,yBAFW,MAAM,QA6ChB;IAqHD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,8CAIC;IAoBD;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,iEA2CC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,kDAFW,MAAM,QAgChB;IA8FD,gBAYC;;CACJ;4BAn6D2B,gCAAgC"}
+{"version":3,"file":"GPUAnimationManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/GPUAnimationManager.js"],"names":[],"mappings":"AAiIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IA6OI;;;;OAIG;IACH,sCAHW,MAAM,kCAgBhB;IAED;;OAEG;IACH,4BAEC;IAED;;;;;;;;;;;;OAYG;IACH,gCAEC;IAED;;;;;;;;;;OAUG;IACH,qCAEC;IAED;;;;;;OAMG;IACH,gCAEC;IAED;;;;;;;;;;OAUG;IACH,mCAEC;IAED;;;;;;;;;;;;OAYG;IACH,4CAFW,MAAM,QA6BhB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ;QAAC,gBAAgB,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAC,CAK3D;IAED;;;;;;;;;;;;OAYG;IACH,gCAHW,MAAM,GACJ,MAAM,CAOlB;IAED;;;;;;;;;;;OAWG;IACH,kCAFa,MAAM,CA+BlB;IAED;;;;;;;;;;;;;;OAcG;IACH,oBAJW;QAAE,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAA;KAAE,GAEhD,MAAM,CA2BlB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH;eAPc,MAAM;qBACA,MAAM;mBACR,MAAM;kBACP,MAAM;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAC;QAEhE,MAAM,CAkElB;IAgCD;;;;;;;;;;;;;;;;;OAiBG;IACH,kBAHW,MAAM,QACN,MAAM,QAKhB;IAED;;;;;;;;OAQG;IACH,2BAHW,MAAM,QACN,MAAM,QAKhB;IAED;;;;;;;;;;;;;;OAcG;IACH,6BAHW,MAAM,UACN,MAAM,QAKhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,mBAHW,MAAM,SACN,MAAM,QAShB;IAED;;;;;;;OAOG;IACH,qBAHW,MAAM,SACN,MAAM,QAShB;IAED;;;;;;;;;;;OAWG;IACH,eAFW,MAAM,QAShB;IAED;;;;;;;;;OASG;IACH,cAFW,MAAM,QAShB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH;gBAJe,MAAM;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,YAAY,EAAE,YAAY,GAAG,MAAM,EAAE,CAAA;SAAE,CAAC;QAEhE,MAAM,CAoElB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,2BAFa,MAAM,CA0FlB;IAyLD;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,yCAFa,MAAM,CAsElB;IAwDD;;;;;;;;;;;;;;;OAeG;IACH,yBAFW,MAAM,QAoChB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,yBAFW,MAAM,QA6ChB;IAqHD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,8CAIC;IAoBD;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,iEA2CC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,kDAFW,MAAM,QAmChB;IA8FD,gBAYC;;CACJ;4BAn6D2B,gCAAgC"}

package/src/shade/renderer/animation/GPUAnimationManager.js

@@ -1806,14 +1806,11 @@ export class GPUAnimationManager {
      * clamped to {@link MAX_DT_SECONDS} to keep a stall from
      * leaking multiple seconds into the next tick.
      *
-     * Early-outs: the clip passes (tick/apply/resolve/hierarchy)
-     * gate on the `animation_bound_track_groups` table being
-     * non-empty; skin matrix prep + skinning gate on registered
-     * skins instead — a skin whose joints are host-driven (no
-     * clips bound) still gets fresh skinning matrices every frame.
-     * With nothing registered no GPU work is encoded beyond the
-     * database flush — safe to call every frame regardless of
-     * registration state.
+     * Clip tick/apply/resolve gate on bound tracks; hierarchy propagation runs
+     * every frame, before skin matrix prep and skinning. CPU-driven nodes need it
+     * too: scene uploads seed global with the previous pose, and propagation
+     * composes the current one. On idle frames it advances prev_global so motion
+     * vectors settle to zero. Skin passes still gate on registered skins.
      *
      * @param {ShadeGPUCommandContext} cmd_ctx
      * @param {number} dt_seconds wall-clock seconds since last call
@@ -1829,16 +1826,19 @@ export class GPUAnimationManager {
         // Flush database + drain pending registrations.
         this.update(cmd_ctx);
 
-        // Clip-pass gate: no bound tracks → apply has nothing to
-        // do, and resolve + hierarchy propagation cascade from
-        // apply. Skipping them keeps the per-frame cost at "one
-        // database update" when the scene has no clip animation.
+        // Only clip evaluation is conditional. Every scene needs current globals.
         const apply_groups = this.#database
             .get('animation_bound_track_groups')
             .dispatch_group_count(ANIMATION_APPLY_WORKGROUP_SIZE);
 
         if (apply_groups > 0) {
             this.#encode_clip_passes(cmd_ctx, dt, apply_groups);
+        } else {
+            // CPU uploads seed global with the previous pose. Even without clips,
+            // compose current globals and advance prev_global before skinning/rendering.
+            const graph = new FrameGraph("GPUAnimationManager/TransformHierarchy");
+            graph_scene_update_transform_hierarchy({ graph, scene: this.#scene_context });
+            cmd_ctx.encodeGraph(graph);
         }
 
         // Skin matrix prep + skinning deformation. Both no-op when

package/src/shade/renderer/buffer/table/GPUTypedTable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUTypedTable.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/table/GPUTypedTable.js"],"names":[],"mappings":"AAuCA;;;GAGG;AACH;IAmDI;;;OAGG;IACH,iDAOC;IA5DD;;OAEG;IACH,oCAAW;IAEX;;;;OAIG;IACH,OAFU,IAAI,MAAM,EAAC,eAAe,CAAC,CAEnB;IAElB;;;;OAIG;IACH,uBAFU,YAAY,CAE6D;IAEnF;;;;;OAKG;IACH,iBAFU,MAAM,CAEe;IAE/B;;;;OAIG;IACH,WAFU,MAAM,CAES;IAEzB;;;;;;OAMG;IACH,oBAFU,MAAM,CAEkB;IAElC;;;OAGG;IACH,kBAFU,iBAAe,SAAS,CAEjB;IAejB;;;;;OAKG;IACH,WAHW,CAAC,GACC,MAAM,CAQlB;IAED;;;;;OAKG;IACH,sBAFW,MAAM,QAkChB;IAED;;;;;;;;;;OAUG;IACH,cAcC;IAoED;;;;;;OAMG;IACH,mBAJW,MAAM,GACJ,CAAC,GAAC,SAAS,CA4BvB;IAgDD;;;OAGG;IACH,cAsBC;IA+BD;;;;OAIG;IACH,mBAHW,MAAM,SACN,CAAC,QA4EX;IAED;;;OAGG;IACH,2BAIC;IAED;;OAEG;IACH,oBAEC;IAED;;;;;;;;;;OAUG;IACH,+BAEC;IAED;;;;;;;;;;OAUG;IACH,mCAJW,WAAW,UACX,MAAM,GACL,MAAM,CAoBjB;IAED;;;;;;;;;;;;OAYG;IACH,kCAMC;IAED;;;;;;;;;;;;;;OAcG;IACH,mCAHW,MAAM,GACL,MAAM,CAKjB;IAED,gBAEC;;CACJ;gCA3jB+B,sBAAsB;6BAPzB,yCAAyC;uBAC/C,mCAAmC"}
+{"version":3,"file":"GPUTypedTable.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/table/GPUTypedTable.js"],"names":[],"mappings":"AAuCA;;;GAGG;AACH;IAmDI;;;OAGG;IACH,iDAOC;IA5DD;;OAEG;IACH,oCAAW;IAEX;;;;OAIG;IACH,OAFU,IAAI,MAAM,EAAC,eAAe,CAAC,CAEnB;IAElB;;;;OAIG;IACH,uBAFU,YAAY,CAE6D;IAEnF;;;;;OAKG;IACH,iBAFU,MAAM,CAEe;IAE/B;;;;OAIG;IACH,WAFU,MAAM,CAES;IAEzB;;;;;;OAMG;IACH,oBAFU,MAAM,CAEkB;IAElC;;;OAGG;IACH,kBAFU,iBAAe,SAAS,CAEjB;IAejB;;;;;OAKG;IACH,WAHW,CAAC,GACC,MAAM,CAQlB;IAED;;;;;OAKG;IACH,sBAFW,MAAM,QAkChB;IAED;;;;;;;;;;OAUG;IACH,cAcC;IAoED;;;;;;OAMG;IACH,mBAJW,MAAM,GACJ,CAAC,GAAC,SAAS,CA4BvB;IAgDD;;;OAGG;IACH,cAsBC;IA+BD;;;;OAIG;IACH,mBAHW,MAAM,SACN,CAAC,QAkFX;IAED;;;OAGG;IACH,2BAIC;IAED;;OAEG;IACH,oBAEC;IAED;;;;;;;;;;OAUG;IACH,+BAEC;IAED;;;;;;;;;;OAUG;IACH,mCAJW,WAAW,UACX,MAAM,GACL,MAAM,CAoBjB;IAED;;;;;;;;;;;;OAYG;IACH,kCAMC;IAED;;;;;;;;;;;;;;OAcG;IACH,mCAHW,MAAM,GACL,MAAM,CAKjB;IAED,gBAEC;;CACJ;gCAjkB+B,sBAAsB;6BAPzB,yCAAyC;uBAC/C,mCAAmC"}

package/src/shade/renderer/buffer/table/GPUTypedTable.js

@@ -464,6 +464,12 @@ export class GPUTypedTable {
             write_wgsl_type_value(value, upload_buffer, type);
             upload_buffer.position = tail;
         } else {
+            // Reserve the whole stride up front. The writes below only reach the last
+            // field, so on a type with tail padding they would leave the buffer short of
+            // the tail we are about to move `position` to — and `position` is what
+            // GPUDatabase.update copies out to, past the end of `data`.
+            upload_buffer.ensureCapacity(tail + step_size);
+
             upload_buffer.writeUint32(element_index);
             write_wgsl_type_value(value, upload_buffer, type);
             upload_buffer.position = tail + step_size;

package/src/shade/renderer/buffer/table/single/GPUSingleTypeTable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUSingleTypeTable.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/buffer/table/single/GPUSingleTypeTable.js"],"names":[],"mappings":"AAsEA;;;GAGG;AACH;IAsCI;;;;;OAKG;IACH,uDAkBC;IA7DD;;;OAGG;IACH,0BAAK;IAEL;;;OAGG;IACH,2BAAM;IAEN;;;OAGG;IACH,sBAA2E;IAE3E;;;OAGG;IACH,kBAAyB;IAOzB;;;OAGG;IACH,+BAEC;IA4BD;;;OAGG;IACH,WAFW,MAAM,QAQhB;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,WAHW,MAAM,kBAsChB;IAED;;;;OAIG;IACH,aAHW,MAAM,OAiBhB;IAuCD;;;OAGG;IACH,kDAgDC;IAED,0BAQC;IAED,gBAEC;;CACJ"}
+{"version":3,"file":"GPUSingleTypeTable.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/buffer/table/single/GPUSingleTypeTable.js"],"names":[],"mappings":"AAsEA;;;GAGG;AACH;IAsCI;;;;;OAKG;IACH,uDAkBC;IA7DD;;;OAGG;IACH,0BAAK;IAEL;;;OAGG;IACH,2BAAM;IAEN;;;OAGG;IACH,sBAA2E;IAE3E;;;OAGG;IACH,kBAAyB;IAOzB;;;OAGG;IACH,+BAEC;IA4BD;;;OAGG;IACH,WAFW,MAAM,QAQhB;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,WAHW,MAAM,kBA6ChB;IAED;;;;OAIG;IACH,aAHW,MAAM,OAiBhB;IAuCD;;;OAGG;IACH,kDAgDC;IAED,0BAQC;IAED,gBAEC;;CACJ"}

package/src/shade/renderer/buffer/table/single/GPUSingleTypeTable.js

@@ -191,6 +191,13 @@ export class GPUSingleTypeTable {
         }
 
         upload_buffer.position = tail;
+
+        // Reserve the whole stride up front. The writes below only reach the last field,
+        // so on a type that pads out to `aligned_size` they would leave the buffer short
+        // of the tail rounded up to below — and that tail is what `update` copies out to,
+        // past the end of `data`.
+        upload_buffer.ensureCapacity(tail + stride);
+
         upload_buffer.writeUint32(id);
         write_wgsl_type_value(value, upload_buffer, this.type);
 

package/src/shade/renderer/global_illumination/brick4/gpu/draw/chunk_brick4_sample_specular.d.ts

@@ -0,0 +1,4 @@
+/** GGX-convolved radiance shared by standalone specular and SSR fallback. */
+export const chunk_brick4_sample_specular: CodeChunk;
+import { CodeChunk } from "../../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_brick4_sample_specular.d.ts.map

package/src/shade/renderer/global_illumination/brick4/gpu/draw/chunk_brick4_sample_specular.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_brick4_sample_specular.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/brick4/gpu/draw/chunk_brick4_sample_specular.js"],"names":[],"mappings":"AAMA,6EAA6E;AAC7E,qDA2CE;0BAjDwB,0CAA0C"}