@woosh/meep-engine 3.30.0 → 3.31.0

package/src/shade/renderer/rasterize/native/viz/viz_rasterization_alpha_tested_pass_descriptor.js

@@ -1,204 +1,242 @@
-import { RenderPipelineDescriptor } from "../../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
-import { DEPTH_BACKGROUND_VALUE } from "../../../depth/DEPTH_BACKGROUND_VALUE.js";
-import { chunk_triangle_winding_is_reversed } from "../../chunk_triangle_winding_is_reversed.js";
-import { chunk_scene_database_access } from "../../../scene/chunk_scene_database_access.js";
-import {
-    chunk_triangle_list_reverse_winding
-} from "../../../shader/chunk/geometry/triangle/chunk_triangle_list_reverse_winding.js";
-import { RENDER_GLOBAL_MIP_BIAS } from "../../../postprocess/taa/RENDER_GLOBAL_MIP_BIAS.js";
-import {
-    chunk_encode_meshlet_element
-} from "../../../shader/chunk/geometry/meshlet/chunk_encode_meshlet_element.js";
-import {
-    chunk_read_meshlet_attribute_u32
-} from "../../../shader/chunk/geometry/meshlet/chunk_read_meshlet_attribute_u32.js";
-import { chunk_read_meshlet_vertex } from "../../../shader/chunk/geometry/meshlet/chunk_read_meshlet_vertex.js";
-import {
-    chunk_read_meshlet_vertex_by_draw_index
-} from "../../../shader/chunk/geometry/meshlet/chunk_read_meshlet_vertex_by_draw_index.js";
-import {
-    chunk_spatio_temporal_noise_r2_64
-} from "../../../shader/chunk/noise/chunk_spatio_temporal_noise_r2_64.js";
-import {
-    chunk_transparency_hashed_alpha_threshold
-} from "../../../shader/chunk/transparency/chunk_transparency_hashed_alpha_threshold.js";
-import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
-import { RenderPassColorAttachmentDescriptor } from "../../../shader/pass/RenderPassColorAttachmentDescriptor.js";
-import { RenderPassDescriptor } from "../../../shader/pass/RenderPassDescriptor.js";
-import { ShaderDescriptor } from "../../../shader/ShaderDescriptor.js";
-import { DEPTH_STENCIL_STATE_STANDARD } from "../../DEPTH_STENCIL_STATE_STANDARD.js";
-import { alpha_tested_pass_resources } from "../alpha_tested_pass_resources.js";
-import { rasterization_primitive_state } from "../rasterization_primitive_state.js";
-import { VIZ_BUFFER_INVALID_MESH_VALUE } from "./VIZ_BUFFER_INVALID_MESH_VALUE.js";
-
-const shader_fragment = ShaderDescriptor.from({
-    resources: alpha_tested_pass_resources,
-    body: CodeChunk.from(
-//language=WGSL
-        `
-struct VizBufferOutput{
-    @location(0) m_triangle : u32,
-    @location(1) m_mesh : u32,
-}
-
-@fragment
-fn main(
-    @builtin(position) coord : vec4<f32>,
-    @location(0) @interpolate(flat) m_mesh:u32,
-    @location(1) @interpolate(flat) m_triangle:u32,
-    @location(2) uv_jittered:vec2<f32>,
-    @location(3) position_world: vec3<f32>,
-) -> VizBufferOutput {
-
-    // Note that we use jittered UVs directly, the compensation happens inside TAAU itself.
-    let uv = uv_jittered;
-    
-    // Calculate mip bias based on upscale ratio. 
-    // We take the average or the min of the vec2 upscale_ratio.
-    // log2(2.0) = 1.0, so we subtract that to get sharper mips.
-    let mip_bias = -log2(max(view.upscale_ratio.x, view.upscale_ratio.y)) + ${RENDER_GLOBAL_MIP_BIAS};
-    
-    let alpha_sample = textureSampleBias(t_color, t_color_sampler, uv, mip_bias).a * material.albedo_color.a;
-    
-    let coord_i = vec2<u32>(coord.xy);
-    
-    // TODO move to STBN (vec1)
-    let noise = spatio_temporal_noise_r2_64(coord_i, view.frame_index, t_noise);
-    let threshold = transparency_hashed_alpha_threshold(1.0, noise.x, position_world);
-    
-    if(alpha_sample < threshold){
-        discard;
-    }
-
-    var result:VizBufferOutput;
-
-    //decode meshlet payload
-    result.m_triangle = m_triangle ;
-    result.m_mesh = m_mesh ;
-
-    return result;
-}
-    `, [
-            chunk_transparency_hashed_alpha_threshold,
-            chunk_spatio_temporal_noise_r2_64,
-        ]
-    )
-});
-
-const shader_vertex = ShaderDescriptor.from({
-    resources: alpha_tested_pass_resources,
-    body: CodeChunk.from(
-//language=WGSL
-        `
-struct VertexOutput{
-    @builtin(position) position: vec4f,
-    @location(0) @interpolate(flat) m_mesh: u32,
-    @location(1) @interpolate(flat) m_triangle: u32,
-    @location(2) uv: vec2f,
-    @location(3) position_world: vec3f,
-}
-
-@vertex
-fn main(
-    @builtin(vertex_index) vertex_draw_index : u32,
-    @builtin(instance_index) input_index : u32,
-) -> VertexOutput{
-    let meshlet_def = meshlets[input_index];
-    
-    let mesh_id = meshlet_def.mesh;
-    
-    let meshlet_id = meshlet_def.index;
-    
-    let meshlet_header = meshlet_metadata[meshlet_id];
-    
-    let last_draw_index = meshlet_header.primitive_count * 3u - 1u;
-    
-    if(vertex_draw_index > last_draw_index){
-        return VertexOutput(); // discard vertex outside of meshlet bounds
-    }
-    
-    let triangle_index = encode_meshlet_element(meshlet_id, vertex_draw_index / 3u);
-
-    let mesh = scene_read_mesh(&scene_database, mesh_id);
-    let node = scene_read_node(&scene_database, mesh.node);
-
-    let meshlet_vertex = read_meshlet_vertex_by_draw_index(
-        meshlet_header,
-        triangle_list_reverse_winding(
-            vertex_draw_index,
-            triangle_winding_is_reversed(node, material.draw_side)
-        ),
-    );
-
-    var output: VertexOutput;
-
-    let instance_matrix = node.global;
-    
-    let position_world = instance_matrix * vec4(meshlet_vertex.position, 1.0);
-
-    output.position_world = position_world.xyz / position_world.w;
-    output.position = camera.view_projection_matrix * position_world;
-
-    output.m_mesh = mesh_id;
-    output.m_triangle = triangle_index;
-    output.uv = meshlet_vertex.uv;
-    
-    return output;
-}
-    `, [
-            chunk_read_meshlet_vertex,
-            chunk_read_meshlet_attribute_u32,
-            chunk_encode_meshlet_element,
-            chunk_read_meshlet_vertex_by_draw_index,
-            chunk_scene_database_access,
-            chunk_triangle_winding_is_reversed,
-            chunk_triangle_list_reverse_winding,
-        ]
-    )
-});
-
-const pipeline = RenderPipelineDescriptor.from({
-    label: "Rasterize to Visibility Buffer / alpha-tested",
-    layout: alpha_tested_pass_resources.generatePipelineLayout(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
-    vertex: {
-        module: {
-            code: shader_vertex.source
-        }
-    },
-    fragment: {
-        module: {
-            code: shader_fragment.source
-        },
-        targets: [
-            {
-                // triangle ID
-                format: "r32uint",
-            }, {
-                // Mesh ID
-                format: "r32uint",
-            }
-        ]
-    },
-    depthStencil: DEPTH_STENCIL_STATE_STANDARD,
-    primitive: rasterization_primitive_state
-});
-
-export const viz_rasterization_alpha_tested_pass_descriptor = new RenderPassDescriptor();
-
-viz_rasterization_alpha_tested_pass_descriptor.pipeline = pipeline;
-viz_rasterization_alpha_tested_pass_descriptor.resources = alpha_tested_pass_resources;
-viz_rasterization_alpha_tested_pass_descriptor.colorAttachments = [
-    // TRIANGLE ID
-    RenderPassColorAttachmentDescriptor.from({
-        clearValue: [0, 0, 0, 0],
-    }),
-    // MESH ID
-    RenderPassColorAttachmentDescriptor.from({
-        clearValue: [VIZ_BUFFER_INVALID_MESH_VALUE, 1, 1, 1],
-    })
-];
-
-/**
- * Clear depth to 0 for reverse Z technique
- */
-viz_rasterization_alpha_tested_pass_descriptor.depthStencilAttachment.depthClearValue = DEPTH_BACKGROUND_VALUE;
+import { RenderPipelineDescriptor } from "../../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
+import { DEPTH_BACKGROUND_VALUE } from "../../../depth/DEPTH_BACKGROUND_VALUE.js";
+import {
+    chunk_material_opacity_contract,
+    chunk_material_opacity_opaque
+} from "../../../material/template/chunk_material_surface.js";
+import { GRADIENT_SAMPLING_INFO_STRUCT } from "../../../shader/chunk/texture/GRADIENT_SAMPLING_INFO_STRUCT.js";
+import { chunk_triangle_winding_is_reversed } from "../../chunk_triangle_winding_is_reversed.js";
+import { chunk_scene_database_access } from "../../../scene/chunk_scene_database_access.js";
+import {
+    chunk_triangle_list_reverse_winding
+} from "../../../shader/chunk/geometry/triangle/chunk_triangle_list_reverse_winding.js";
+import { RENDER_GLOBAL_MIP_BIAS } from "../../../postprocess/taa/RENDER_GLOBAL_MIP_BIAS.js";
+import {
+    chunk_encode_meshlet_element
+} from "../../../shader/chunk/geometry/meshlet/chunk_encode_meshlet_element.js";
+import {
+    chunk_read_meshlet_attribute_u32
+} from "../../../shader/chunk/geometry/meshlet/chunk_read_meshlet_attribute_u32.js";
+import { chunk_read_meshlet_vertex } from "../../../shader/chunk/geometry/meshlet/chunk_read_meshlet_vertex.js";
+import {
+    chunk_read_meshlet_vertex_by_draw_index
+} from "../../../shader/chunk/geometry/meshlet/chunk_read_meshlet_vertex_by_draw_index.js";
+import {
+    chunk_spatio_temporal_noise_r2_64
+} from "../../../shader/chunk/noise/chunk_spatio_temporal_noise_r2_64.js";
+import {
+    chunk_transparency_hashed_alpha_threshold
+} from "../../../shader/chunk/transparency/chunk_transparency_hashed_alpha_threshold.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { RenderPassColorAttachmentDescriptor } from "../../../shader/pass/RenderPassColorAttachmentDescriptor.js";
+import { ShaderDescriptor } from "../../../shader/ShaderDescriptor.js";
+import { DEPTH_STENCIL_STATE_STANDARD } from "../../DEPTH_STENCIL_STATE_STANDARD.js";
+import {
+    alpha_tested_fragment_resources,
+    alpha_tested_pipeline_layout,
+    alpha_tested_vertex_resources
+} from "../alpha_tested_pass_resources.js";
+import { TemplatePassDescriptor } from "../../TemplatePassDescriptor.js";
+import { rasterization_primitive_state } from "../rasterization_primitive_state.js";
+import { VIZ_BUFFER_INVALID_MESH_VALUE } from "./VIZ_BUFFER_INVALID_MESH_VALUE.js";
+
+/**
+ * The harness around a template's `material_opacity`: the hashed threshold and the noise that feeds
+ * it are this pass's, the coverage is the template's.
+ *
+ * The template is handed the bias this pass has always sampled with, and is called at the top of
+ * `main`, in uniform control flow, so it can sample with it exactly as the pass did — see
+ * {@link chunk_material_opacity_contract}. The gradients are there for a template that cannot:
+ * `dpdx`/`dpdy` of the interpolated UV scaled by `exp2` of the bias, which selects the same level.
+ */
+const fragment_body = CodeChunk.from(
+//language=WGSL
+    `
+struct VizBufferOutput{
+    @location(0) m_triangle : u32,
+    @location(1) m_mesh : u32,
+}
+
+@fragment
+fn main(
+    @builtin(position) coord : vec4<f32>,
+    @location(0) @interpolate(flat) m_mesh:u32,
+    @location(1) @interpolate(flat) m_triangle:u32,
+    @location(2) uv_jittered:vec2<f32>,
+    @location(3) position_world: vec3<f32>,
+) -> VizBufferOutput {
+
+    // Note that we use jittered UVs directly, the compensation happens inside TAAU itself.
+    let uv = uv_jittered;
+    
+    // Calculate mip bias based on upscale ratio. 
+    // We take the average or the min of the vec2 upscale_ratio.
+    // log2(2.0) = 1.0, so we subtract that to get sharper mips.
+    let mip_bias = -log2(max(view.upscale_ratio.x, view.upscale_ratio.y)) + ${RENDER_GLOBAL_MIP_BIAS};
+    
+    let gradient_scale = exp2(mip_bias);
+    
+    var opacity_input: MaterialOpacityInput;
+    
+    opacity_input.uv = ${GRADIENT_SAMPLING_INFO_STRUCT.wgsl_ref}(uv, dpdx(uv) * gradient_scale, dpdy(uv) * gradient_scale);
+    opacity_input.mip_bias = mip_bias;
+    opacity_input.position_ws = position_world;
+    
+    let alpha_sample = material_opacity(opacity_input);
+    
+    let coord_i = vec2<u32>(coord.xy);
+    
+    // TODO move to STBN (vec1)
+    let noise = spatio_temporal_noise_r2_64(coord_i, view.frame_index, t_noise);
+    let threshold = transparency_hashed_alpha_threshold(1.0, noise.x, position_world);
+    
+    if(alpha_sample < threshold){
+        discard;
+    }
+
+    var result:VizBufferOutput;
+
+    //decode meshlet payload
+    result.m_triangle = m_triangle ;
+    result.m_mesh = m_mesh ;
+
+    return result;
+}
+    `, [
+        chunk_material_opacity_contract,
+        chunk_transparency_hashed_alpha_threshold,
+        chunk_spatio_temporal_noise_r2_64,
+    ]
+);
+
+const shader_vertex = ShaderDescriptor.from({
+    resources: alpha_tested_vertex_resources,
+    body: CodeChunk.from(
+//language=WGSL
+        `
+struct VertexOutput{
+    @builtin(position) position: vec4f,
+    @location(0) @interpolate(flat) m_mesh: u32,
+    @location(1) @interpolate(flat) m_triangle: u32,
+    @location(2) uv: vec2f,
+    @location(3) position_world: vec3f,
+}
+
+@vertex
+fn main(
+    @builtin(vertex_index) vertex_draw_index : u32,
+    @builtin(instance_index) input_index : u32,
+) -> VertexOutput{
+    let meshlet_def = meshlets[input_index];
+    
+    let mesh_id = meshlet_def.mesh;
+    
+    let meshlet_id = meshlet_def.index;
+    
+    let meshlet_header = meshlet_metadata[meshlet_id];
+    
+    let last_draw_index = meshlet_header.primitive_count * 3u - 1u;
+    
+    if(vertex_draw_index > last_draw_index){
+        return VertexOutput(); // discard vertex outside of meshlet bounds
+    }
+    
+    let triangle_index = encode_meshlet_element(meshlet_id, vertex_draw_index / 3u);
+
+    let mesh = scene_read_mesh(&scene_database, mesh_id);
+    let node = scene_read_node(&scene_database, mesh.node);
+
+    let meshlet_vertex = read_meshlet_vertex_by_draw_index(
+        meshlet_header,
+        triangle_list_reverse_winding(
+            vertex_draw_index,
+            triangle_winding_is_reversed(node, materials[mesh.material].draw_side)
+        ),
+    );
+
+    var output: VertexOutput;
+
+    let instance_matrix = node.global;
+    
+    let position_world = instance_matrix * vec4(meshlet_vertex.position, 1.0);
+
+    output.position_world = position_world.xyz / position_world.w;
+    output.position = camera.view_projection_matrix * position_world;
+
+    output.m_mesh = mesh_id;
+    output.m_triangle = triangle_index;
+    output.uv = meshlet_vertex.uv;
+    
+    return output;
+}
+    `, [
+            chunk_read_meshlet_vertex,
+            chunk_read_meshlet_attribute_u32,
+            chunk_encode_meshlet_element,
+            chunk_read_meshlet_vertex_by_draw_index,
+            chunk_scene_database_access,
+            chunk_triangle_winding_is_reversed,
+            chunk_triangle_list_reverse_winding,
+        ]
+    )
+});
+
+const vertex_code = shader_vertex.source;
+
+/**
+ * The visibility pass for alpha-tested materials, one pipeline per template.
+ *
+ * @type {TemplatePassDescriptor}
+ */
+export const viz_rasterization_alpha_tested_pass_descriptor = new TemplatePassDescriptor("Rasterize to Visibility Buffer / alpha-tested", template => {
+    const shader_fragment = ShaderDescriptor.from({
+        label: `Rasterize to Visibility Buffer / alpha-tested / ${template.name}`,
+        resources: alpha_tested_fragment_resources(template),
+        body: CodeChunk.from('', [
+            template.opacity ?? chunk_material_opacity_opaque,
+            fragment_body,
+        ])
+    });
+
+    return RenderPipelineDescriptor.from({
+        label: `Rasterize to Visibility Buffer / alpha-tested / ${template.name}`,
+        layout: alpha_tested_pipeline_layout(template),
+        vertex: {
+            module: {
+                code: vertex_code
+            }
+        },
+        fragment: {
+            module: {
+                code: shader_fragment.source
+            },
+            targets: [
+                {
+                    // triangle ID
+                    format: "r32uint",
+                }, {
+                    // Mesh ID
+                    format: "r32uint",
+                }
+            ]
+        },
+        depthStencil: DEPTH_STENCIL_STATE_STANDARD,
+        primitive: rasterization_primitive_state
+    });
+});
+
+viz_rasterization_alpha_tested_pass_descriptor.colorAttachments = [
+    // TRIANGLE ID
+    RenderPassColorAttachmentDescriptor.from({
+        clearValue: [0, 0, 0, 0],
+    }),
+    // MESH ID
+    RenderPassColorAttachmentDescriptor.from({
+        clearValue: [VIZ_BUFFER_INVALID_MESH_VALUE, 1, 1, 1],
+    })
+];
+
+/**
+ * Clear depth to 0 for reverse Z technique
+ */
+viz_rasterization_alpha_tested_pass_descriptor.depthStencilAttachment.depthClearValue = DEPTH_BACKGROUND_VALUE;

package/src/shade/renderer/restir/reservoir/shader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/restir/reservoir/shader.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,6CAFU,SAAS,CAwBjB;AAEF;;;;GAIG;AACH,8CAFU,SAAS,CAiBjB;0BAxDwB,oCAAoC"}
+{"version":3,"file":"shader.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/restir/reservoir/shader.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,6CAFU,SAAS,CAwBjB;AAEF;;;;GAIG;AACH,8CAFU,SAAS,CA2CjB;0BAlFwB,oCAAoC"}

package/src/shade/renderer/restir/reservoir/shader.js

@@ -47,9 +47,35 @@ fn RTXDI_FinalizeResampling(
     normalizationNumerator: f32,
     normalizationDenominator: f32
 ){
+    // largest finite f32; both an infinity and a NaN fail the comparison against it
+    const WEIGHT_LIMIT = 3.4028235e38;
+
     let denominator = reservoir.targetPdf * normalizationDenominator;
 
-    reservoir.weightSum = select( (reservoir.weightSum * normalizationNumerator) / denominator, 0.0, denominator == 0.0);
+    let weight = (reservoir.weightSum * normalizationNumerator) / denominator;
+
+    /*
+     A reservoir weight that is not a positive finite number is PERMANENT, so it is refused here
+     rather than where it would be noticed.
+
+     This used to answer 0 for the exact denominator == 0 case alone, and pass everything else
+     through. A survivor whose target function is tiny but not zero divides to an infinity, which
+     the next frame reads back as history: rtxdi_combine_reservoirs multiplies it by M and
+     multiplies that by the target function re-evaluated at this surface, and a surface that has
+     since turned away from the light makes that 0 * inf, a NaN. The NaN comes back through this
+     function, fails denominator == 0, and is stored again; restir_resolve rejects a reservoir on
+     weightSum <= 0.0, which is false for a NaN, so the pixel returns radiance * NaN for as long as
+     reprojection keeps finding it, and the a-trous denoiser spreads it to the neighbours. Camera
+     motion does not clear it, because the history test only asks whether the light reference is
+     valid and M is positive.
+
+     Every reservoir that reaches the reservoir buffer passes through this function first, so this
+     is the whole write side.
+
+     Zero is the right answer for all of them: it is what an empty reservoir carries, and it is the
+     one value restir_resolve already rejects.
+    */
+    reservoir.weightSum = select(0.0, weight, weight > 0.0 && weight < WEIGHT_LIMIT);
 }
     `, [
         RTXDI_Reservoir.declaration_chunk,

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

@@ -148,7 +148,8 @@ export class GPUSceneContext {
     /**
      * Bring the GPU scene database in line with the scene, writing only the rows that changed:
      * the scene root's, once; a light's, as it arrives; and every entity's row that a system
-     * marked since the last build. Nothing is walked — the rows keep what was marked.
+     * marked since the last build — and taking back the rows of entities that let go of theirs.
+     * Nothing is walked — the rows keep what was marked.
      */
     build(): void;
     /**

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":"AAqEA;;;;;;;;;GASG;AACH;IA0II;;;;OAIG;IACH,sBAHW,eAAe,SACf,KAAK,EAiCf;IA5KD;;;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;IAQD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,8CAEC;IAOD;;;OAGG;IACH,8CAEC;IAoHD;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,gDAEC;IAED;;OAEG;IACH,kDAEC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH;QAH0C,SAAS,GAAxC,oBAAoB;QAClB,yBAAyB,CAmCrC;IAED;;OAEG;IACH,6CAEC;IAYD;;;OAGG;IACH,kCAEC;IAED;;;;;OAKG;IACH,uCAEC;IAED;;;;;;;;;;;OAWG;IACH,uCAUC;IAED,+BAUC;IAED;;;;;;;;;;OAUG;IACH,yBAEC;IAED;;;;;OAKG;IACH,sCAMC;IAOD;;;;;;;OAOG;IACH,8EAEC;IA0BD;;;;OAIG;IACH,cAqEC;IAED;;;OAGG;IACH,YAFW,eAAe,QA0BzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAHW,sBAAsB,cACtB,MAAM,QAuBhB;IAoCD,gBAYC;IAIL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;8BA5pBY,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;+BAtBvD,iDAAiD;sBAI1D,YAAY;oCADE,uCAAuC;mCADxC,gCAAgC;oCAD/B,mDAAmD;kDAIrC,wCAAwC;0CAfhD,0DAA0D;8BAItE,8CAA8C;iCAF3C,iDAAiD;qCAG7C,qDAAqD;oCAGtD,qCAAqC;4BAC7C,gCAAgC;uCAOrB,iDAAiD;6BAM3D,wBAAwB;wCADb,mCAAmC;uCAdpC,wCAAwC"}
+{"version":3,"file":"GPUSceneContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUSceneContext.js"],"names":[],"mappings":"AAqEA;;;;;;;;;GASG;AACH;IA0II;;;;OAIG;IACH,sBAHW,eAAe,SACf,KAAK,EAiCf;IA5KD;;;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;IAQD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,8CAEC;IAOD;;;OAGG;IACH,8CAEC;IAoHD;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,gDAEC;IAED;;OAEG;IACH,kDAEC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH;QAH0C,SAAS,GAAxC,oBAAoB;QAClB,yBAAyB,CAmCrC;IAED;;OAEG;IACH,6CAEC;IAYD;;;OAGG;IACH,kCAEC;IAED;;;;;OAKG;IACH,uCAEC;IAED;;;;;;;;;;;OAWG;IACH,uCAUC;IAED,+BAUC;IAED;;;;;;;;;;OAUG;IACH,yBAEC;IAED;;;;;OAKG;IACH,sCAMC;IAOD;;;;;;;OAOG;IACH,8EAEC;IA0BD;;;;;OAKG;IACH,cAsEC;IAED;;;OAGG;IACH,YAFW,eAAe,QA0BzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAHW,sBAAsB,cACtB,MAAM,QAuBhB;IAoCD,gBAYC;IAIL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;8BA9pBY,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;+BAtBvD,iDAAiD;sBAI1D,YAAY;oCADE,uCAAuC;mCADxC,gCAAgC;oCAD/B,mDAAmD;kDAIrC,wCAAwC;0CAfhD,0DAA0D;8BAItE,8CAA8C;iCAF3C,iDAAiD;qCAG7C,qDAAqD;oCAGtD,qCAAqC;4BAC7C,gCAAgC;uCAOrB,iDAAiD;6BAM3D,wBAAwB;wCADb,mCAAmC;uCAdpC,wCAAwC"}

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

@@ -498,16 +498,14 @@ export class GPUSceneContext {
     /**
      * Bring the GPU scene database in line with the scene, writing only the rows that changed:
      * the scene root's, once; a light's, as it arrives; and every entity's row that a system
-     * marked since the last build. Nothing is walked — the rows keep what was marked.
+     * marked since the last build — and taking back the rows of entities that let go of theirs.
+     * Nothing is walked — the rows keep what was marked.
      */
     build() {
-        let written = 0;
-
         if (!this.#root_written) {
             this.#scene_database.get('transforms').set_record(NODE3D_SCENE_ID, ROOT_RECORD, ROOT_RECORD_WRITER);
 
             this.#root_written = true;
-            written++;
         }
 
         // Entities are rows — marked by the systems that place them, written here. Built on demand
@@ -521,12 +519,16 @@ export class GPUSceneContext {
             // flush, so a light that arrived this frame is written this frame.
             this.#lights.sync_rows(this.#rows);
 
-            written += this.#rows.flush();
+            this.#rows.flush();
         } else {
             assert.equal(this.#scene.lights.elements.length, 0, 'the scene has lights and names no dataset; a light is an entity of one');
         }
 
-        if (written === 0) {
+        // Asked of the database rather than counted here. A row given back — an entity deleted
+        // in a frame where nothing else changed — is written by nobody, and until its zeroed
+        // record and its page's occupancy go up, every page iterator still finds it: the cull
+        // draws it where it last stood.
+        if (!this.#scene_database.has_pending_upload) {
             return;
         }
 
@@ -641,9 +643,9 @@ export class GPUSceneContext {
         this.#tlas.update(this.scene_database_buffer, cmd_ctx);
 
         // What was asked of the scene database this frame is copied out at the tail of the
-        // database's own update when rows were written this frame, and here — after the bounds
-        // pass — when none were; either way what lands, at the head of a later frame's update, is
-        // the box the GPU held when the copy ran.
+        // database's own update when the build had anything to send this frame, and here — after
+        // the bounds pass — when it had nothing; either way what lands, at the head of a later
+        // frame's update, is the box the GPU held when the copy ran.
         this.#scene_database.readback.encode(cmd_ctx);
     }
 

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

@@ -12,3 +12,25 @@ export const SCENE_DATABASE_SPEC = GPUDatabaseDefinition.from({
     meshes: MESH_INSTANCE_METADATA_STRUCT,
     transforms: NODE3D_STRUCT,
 });
+
+// A mesh's transform. A mesh row and its transforms row are the same row — the entity's, one on —
+// so this word always names its own index, and it is declared as the link it is.
+SCENE_DATABASE_SPEC.add_link({
+    table: 'meshes',
+    field: 'node',
+    target_database: SCENE_DATABASE_SPEC,
+    target_table: 'transforms',
+    nullable: false,
+    owning: false,
+});
+
+// A row with no parent row names the scene root, row 0 — a real row, occupied from the first build,
+// its own parent. Required, because 0 here is a row and never a null.
+SCENE_DATABASE_SPEC.add_link({
+    table: 'transforms',
+    field: 'parent',
+    target_database: SCENE_DATABASE_SPEC,
+    target_table: 'transforms',
+    nullable: false,
+    owning: false,
+});

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

@@ -19,6 +19,16 @@ export class SceneManager {
      * @returns {GPUSceneContext}
      */
     obtain(scene: Scene): GPUSceneContext;
+    /**
+     * Release every scene context this handed out.
+     *
+     * Each one owns a GPU database, a meshlet pool, a light collection and the shadow views'
+     * camera buffers, and nothing used to release any of it: `Renderer.destroy()` never reached
+     * here, which is also why `GPUSceneContext.destroy()` had never been exercised.
+     *
+     * @returns {void}
+     */
+    destroy(): void;
     #private;
 }
 export type GraphicsContext = import("../GraphicsContext.js").GraphicsContext;

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

@@ -1 +1 @@
-{"version":3,"file":"SceneManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/SceneManager.js"],"names":[],"mappings":"AAEA;;;GAGG;AAEH;IAaI;;;OAGG;IACH,sBAFW,eAAe,EAIzB;IAjBD;;;OAGG;IACH,gBAFU,IAAI,KAAK,EAAC,eAAe,CAAC,CAET;IA6B3B;;;;OAIG;IACH,cAHW,KAAK,GACH,eAAe,CAY3B;;CAEJ;8BAxDY,OAAO,uBAAuB,EAAE,eAAe;oBAC/C,OAAO,YAAY,EAAE,KAAK;gCAJP,sBAAsB"}
+{"version":3,"file":"SceneManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/SceneManager.js"],"names":[],"mappings":"AAEA;;;GAGG;AAEH;IAaI;;;OAGG;IACH,sBAFW,eAAe,EAIzB;IAjBD;;;OAGG;IACH,gBAFU,IAAI,KAAK,EAAC,eAAe,CAAC,CAET;IA6B3B;;;;OAIG;IACH,cAHW,KAAK,GACH,eAAe,CAY3B;IAED;;;;;;;;OAQG;IACH,WAFa,IAAI,CAQhB;;CAEJ;8BAzEY,OAAO,uBAAuB,EAAE,eAAe;oBAC/C,OAAO,YAAY,EAAE,KAAK;gCAJP,sBAAsB"}

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

@@ -57,4 +57,21 @@ export class SceneManager {
         return ctx;
     }
 
+    /**
+     * Release every scene context this handed out.
+     *
+     * Each one owns a GPU database, a meshlet pool, a light collection and the shadow views'
+     * camera buffers, and nothing used to release any of it: `Renderer.destroy()` never reached
+     * here, which is also why `GPUSceneContext.destroy()` had never been exercised.
+     *
+     * @returns {void}
+     */
+    destroy() {
+        for (const ctx of this.scene_contexts.values()) {
+            ctx.destroy();
+        }
+
+        this.scene_contexts.clear();
+    }
+
 }

package/src/shade/renderer/scene/rows/GPUEntityBoundsReadback.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUEntityBoundsReadback.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/scene/rows/GPUEntityBoundsReadback.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;GAcG;AACH;IA8BI;;;;OAIG;IACH,sBAJW,OAAO,2CAA2C,EAAE,mBAAmB,QAEvE,OAAO,mBAAmB,EAAE,YAAY,EAUlD;IAED;;;;OAIG;IACH,4BAEC;IAED;;;;;;OAMG;IACH,gBAHW,MAAM,GACJ,OAAO,CAyBnB;IAED;;;;;;OAMG;IACH,YAJW,MAAM,UACN,UAAU,MAAM,CAAC,GAAC,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,GAClD,OAAO,CAgBnB;IAED;;;;OAIG;IACH,eAFW,MAAM,QAIhB;;CACJ"}
+{"version":3,"file":"GPUEntityBoundsReadback.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/scene/rows/GPUEntityBoundsReadback.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;GAcG;AACH;IA8BI;;;;OAIG;IACH,sBAJW,OAAO,2CAA2C,EAAE,mBAAmB,QAEvE,OAAO,mBAAmB,EAAE,YAAY,EAelD;IAED;;;;OAIG;IACH,4BAEC;IAED;;;;;;OAMG;IACH,gBAHW,MAAM,GACJ,OAAO,CA2BnB;IAED;;;;;;OAMG;IACH,YAJW,MAAM,UACN,UAAU,MAAM,CAAC,GAAC,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,GAClD,OAAO,CA6BnB;IAED;;;;OAIG;IACH,eAFW,MAAM,QAIhB;;CACJ"}