@woosh/meep-engine 3.11.2 → 3.12.0

package/src/shade/renderer/material/standard/fragment_gbuffer_vt.js

@@ -1,169 +1,169 @@
-import { GPUShaderStage } from "../../../descriptor/GPUShaderStage.js";
-import { RenderPipelineDescriptor } from "../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
-import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
-import { G_BUFFER_COLOR_TARGETS } from "../../gbuffer/G_BUFFER_COLOR_TARGETS.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
-import { ShaderResourceGroupDescriptor } from "../../shader/resource/ShaderResourceGroupDescriptor.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-import { VT_STACK_INFO_STRUCT } from "../../texture/virtual/VT_STACK_INFO_STRUCT.js";
-import { MATERIAL_METADATA_STRUCT } from "../MATERIAL_METADATA_STRUCT.js";
-import {
-    build_gbuffer_fragment_body,
-    g_buffer_scene_resources,
-    g_buffer_viz_resources,
-} from "./fragment_gbuffer.js";
-import { material_gbuffer_vertex_shader_code } from "./material_gbuffer_vertex.js";
-
-/**
- * Group 0 of the virtual-texture material variant. Replaces the four
- * per-material texture bindings of the standard group with the VT globals:
- * the shared page table, the stack info buffer and the physical cache
- * layers — identical for every VT material, which is what lets hundreds of
- * them share one pipeline and the same feedback/table infrastructure.
- * Emissive stays a regular per-material texture (emissive maps are rarely
- * the memory problem VT solves).
- *
- * `material_info` must stay at binding 0 — the shared vertex stage
- * ({@link material_gbuffer_vertex_shader_code}) addresses it there.
- */
-export const SHADING_MATERIAL_VT_RESOURCE_GROUP = new ShaderResourceGroupDescriptor();
-
-SHADING_MATERIAL_VT_RESOURCE_GROUP.label = "Material VT";
-
-SHADING_MATERIAL_VT_RESOURCE_GROUP
-    .addUniform("material_info", MATERIAL_METADATA_STRUCT)
-    .addTexture("texture_emissive", "float")
-    .addSampler("texture_emissive_sampler")
-    .addTexture("vt_page_table", "uint")
-    .addStorageBuffer("vt_stacks", WebGPUArray.from(VT_STACK_INFO_STRUCT))
-    .addTexture("vt_cache_albedo", "float")
-    .addTexture("vt_cache_normal", "float")
-    .addTexture("vt_cache_orm", "float")
-    .addSampler("vt_cache_sampler");
-
-export const vt_gbuffer_shader_resources = new ShaderResourceSetDescriptor();
-
-// group order mirrors the standard material set — groups 1 and 2 are the
-// *same descriptor objects*, so the two pipelines are bind-group compatible
-// and the material pass can set viz/scene groups once for both
-vt_gbuffer_shader_resources.addGroup(SHADING_MATERIAL_VT_RESOURCE_GROUP);
-vt_gbuffer_shader_resources.addGroup(g_buffer_viz_resources);
-vt_gbuffer_shader_resources.addGroup(g_buffer_scene_resources);
-
-vt_gbuffer_shader_resources.addVisibility(GPUShaderStage.FRAGMENT);
-vt_gbuffer_shader_resources.getResourceByName("material_info").addVisibility(GPUShaderStage.VERTEX);
-
-const chunk_vt_sample_layer = new WeakMap();
-
-/**
- * Build the VT variant of the G-buffer material pipeline for a concrete
- * cache geometry. Called (and memoized) by the VirtualTextureManager once
- * its configuration is frozen.
- *
- * Sampling model (v1): one page-table fetch per pixel serves all three
- * layers — the stack's UV set, wrap mode and residency resolve once, then
- * albedo/normal/ORM are three bilinear fetches at the same physical
- * coordinate in their respective atlases. Missing layers and not-yet-
- * resident cells fall back to per-layer neutral values (albedo falls back
- * to the stack's average colour).
- *
- * @param {CodeChunk} chunk_vt_lookup from {@link build_chunk_vt_lookup}
- * @returns {RenderPipelineDescriptor}
- */
-export function build_vt_material_pipeline_descriptor(chunk_vt_lookup) {
-
-    let sample_chunk = chunk_vt_sample_layer.get(chunk_vt_lookup);
-
-    if (sample_chunk === undefined) {
-        sample_chunk = CodeChunk.from(
-            //language=WGSL
-            `
-fn vt_sample_layer(
-    cache: texture_2d<f32>,
-    cache_sampler: sampler,
-    phys: VTPhysical,
-    available: bool,
-    fallback: vec4<f32>,
-) -> vec4<f32> {
-    if (!available) {
-        return fallback;
-    }
-
-    // physical atlases are single-mip; virtual mip selection already
-    // happened through the page table
-    return textureSampleLevel(cache, cache_sampler, phys.uv, 0.0);
-}
-`,
-            [chunk_vt_lookup]
-        );
-
-        chunk_vt_sample_layer.set(chunk_vt_lookup, sample_chunk);
-    }
-
-    const body = build_gbuffer_fragment_body(
-        {
-            prelude: `
-    // ── virtual texture resolve, once per pixel for all layers ──────
-    let vt_info = vt_stacks[material_info.vt_stack];
-    let vt_layer_mask = vt_info.flags >> 8u;
-
-    if ((vt_info.flags & VT_STACK_FLAG_UV_SET_1) != 0u) {
-        // stack binds the second UV set — re-interpolate and re-bias
-        uv_info = barycentric_interpolate_uv(barycentric, vertex_0.uv1, vertex_1.uv1, vertex_2.uv1);
-        uv_info.ddx *= uv_derivative_bias.x;
-        uv_info.ddy *= uv_derivative_bias.y;
-    }
-
-    let vt_uv = vt_stack_wrap_uv(uv_info.uv, vt_info.flags);
-    let vt_mip = vt_mip_select(vt_info, uv_info.ddx, uv_info.ddy, 0.0);
-    let vt_entry = vt_page_table_load(vt_page_table, vt_info, vt_uv, vt_mip);
-
-    var vt_phys = VTPhysical(vec2<f32>(0.0), 0.0);
-
-    if (vt_entry.valid) {
-        vt_phys = vt_physical_uv(vt_entry, vt_info, vt_uv);
-    }
-`,
-            orm: `vt_sample_layer(vt_cache_orm, vt_cache_sampler, vt_phys, vt_entry.valid && (vt_layer_mask & 4u) != 0u, vec4<f32>(1.0, 1.0, 0.0, 1.0))`,
-            normal: `vt_sample_layer(vt_cache_normal, vt_cache_sampler, vt_phys, vt_entry.valid && (vt_layer_mask & 2u) != 0u, vec4<f32>(0.5, 0.5, 1.0, 1.0)).rgb * 2.0 - 1.0`,
-            diffuse: `vt_sample_layer(vt_cache_albedo, vt_cache_sampler, vt_phys, vt_entry.valid && (vt_layer_mask & 1u) != 0u, vt_info.average_color)`,
-            emissive: `textureSampleBarycentric(texture_emissive, texture_emissive_sampler, uv_info).rgb`,
-        },
-        [
-            sample_chunk,
-        ]
-    );
-
-    const shader = ShaderDescriptor.from({
-        label: "Material / GBuffer laydown (virtual texture)",
-        resources: vt_gbuffer_shader_resources,
-        body,
-    });
-
-    return RenderPipelineDescriptor.from({
-        label: "VT material / Viz-Buffer to G-Buffer laydown",
-        layout: vt_gbuffer_shader_resources.generatePipelineLayoutDescriptor(),
-        vertex: {
-            module: {
-                code: material_gbuffer_vertex_shader_code
-            }
-        },
-        fragment: {
-            module: {
-                code: shader.compile(),
-            },
-            targets: G_BUFFER_COLOR_TARGETS
-        },
-        depthStencil: {
-            // depth is a material mask — see the standard material pipeline
-            depthCompare: 'equal',
-            format: 'depth32float',
-            depthWriteEnabled: false
-        },
-        primitive: {
-            topology: 'triangle-list',
-            cullMode: 'none',
-        }
-    });
-}
+import { GPUShaderStage } from "../../../descriptor/GPUShaderStage.js";
+import { RenderPipelineDescriptor } from "../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { G_BUFFER_COLOR_TARGETS } from "../../gbuffer/G_BUFFER_COLOR_TARGETS.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
+import { ShaderResourceGroupDescriptor } from "../../shader/resource/ShaderResourceGroupDescriptor.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { VT_STACK_INFO_STRUCT } from "../../texture/virtual/VT_STACK_INFO_STRUCT.js";
+import { MATERIAL_METADATA_STRUCT } from "../MATERIAL_METADATA_STRUCT.js";
+import {
+    build_gbuffer_fragment_body,
+    g_buffer_scene_resources,
+    g_buffer_viz_resources,
+} from "./fragment_gbuffer.js";
+import { material_gbuffer_vertex_shader_code } from "./material_gbuffer_vertex.js";
+
+/**
+ * Group 0 of the virtual-texture material variant. Replaces the four
+ * per-material texture bindings of the standard group with the VT globals:
+ * the shared page table, the stack info buffer and the physical cache
+ * layers — identical for every VT material, which is what lets hundreds of
+ * them share one pipeline and the same feedback/table infrastructure.
+ * Emissive stays a regular per-material texture (emissive maps are rarely
+ * the memory problem VT solves).
+ *
+ * `material_info` must stay at binding 0 — the shared vertex stage
+ * ({@link material_gbuffer_vertex_shader_code}) addresses it there.
+ */
+export const SHADING_MATERIAL_VT_RESOURCE_GROUP = new ShaderResourceGroupDescriptor();
+
+SHADING_MATERIAL_VT_RESOURCE_GROUP.label = "Material VT";
+
+SHADING_MATERIAL_VT_RESOURCE_GROUP
+    .addUniform("material_info", MATERIAL_METADATA_STRUCT)
+    .addTexture("texture_emissive", "float")
+    .addSampler("texture_emissive_sampler")
+    .addTexture("vt_page_table", "uint")
+    .addStorageBuffer("vt_stacks", WebGPUArray.from(VT_STACK_INFO_STRUCT))
+    .addTexture("vt_cache_albedo", "float")
+    .addTexture("vt_cache_normal", "float")
+    .addTexture("vt_cache_orm", "float")
+    .addSampler("vt_cache_sampler");
+
+export const vt_gbuffer_shader_resources = new ShaderResourceSetDescriptor();
+
+// group order mirrors the standard material set — groups 1 and 2 are the
+// *same descriptor objects*, so the two pipelines are bind-group compatible
+// and the material pass can set viz/scene groups once for both
+vt_gbuffer_shader_resources.addGroup(SHADING_MATERIAL_VT_RESOURCE_GROUP);
+vt_gbuffer_shader_resources.addGroup(g_buffer_viz_resources);
+vt_gbuffer_shader_resources.addGroup(g_buffer_scene_resources);
+
+vt_gbuffer_shader_resources.addVisibility(GPUShaderStage.FRAGMENT);
+vt_gbuffer_shader_resources.getResourceByName("material_info").addVisibility(GPUShaderStage.VERTEX);
+
+const chunk_vt_sample_layer = new WeakMap();
+
+/**
+ * Build the VT variant of the G-buffer material pipeline for a concrete
+ * cache geometry. Called (and memoized) by the VirtualTextureManager once
+ * its configuration is frozen.
+ *
+ * Sampling model (v1): one page-table fetch per pixel serves all three
+ * layers — the stack's UV set, wrap mode and residency resolve once, then
+ * albedo/normal/ORM are three bilinear fetches at the same physical
+ * coordinate in their respective atlases. Missing layers and not-yet-
+ * resident cells fall back to per-layer neutral values (albedo falls back
+ * to the stack's average colour).
+ *
+ * @param {CodeChunk} chunk_vt_lookup from {@link build_chunk_vt_lookup}
+ * @returns {RenderPipelineDescriptor}
+ */
+export function build_vt_material_pipeline_descriptor(chunk_vt_lookup) {
+
+    let sample_chunk = chunk_vt_sample_layer.get(chunk_vt_lookup);
+
+    if (sample_chunk === undefined) {
+        sample_chunk = CodeChunk.from(
+            //language=WGSL
+            `
+fn vt_sample_layer(
+    cache: texture_2d<f32>,
+    cache_sampler: sampler,
+    phys: VTPhysical,
+    available: bool,
+    fallback: vec4<f32>,
+) -> vec4<f32> {
+    if (!available) {
+        return fallback;
+    }
+
+    // physical atlases are single-mip; virtual mip selection already
+    // happened through the page table
+    return textureSampleLevel(cache, cache_sampler, phys.uv, 0.0);
+}
+`,
+            [chunk_vt_lookup]
+        );
+
+        chunk_vt_sample_layer.set(chunk_vt_lookup, sample_chunk);
+    }
+
+    const body = build_gbuffer_fragment_body(
+        {
+            prelude: `
+    // ── virtual texture resolve, once per pixel for all layers ──────
+    let vt_info = vt_stacks[material_info.vt_stack];
+    let vt_layer_mask = vt_info.flags >> 8u;
+
+    if ((vt_info.flags & VT_STACK_FLAG_UV_SET_1) != 0u) {
+        // stack binds the second UV set — re-interpolate and re-bias
+        uv_info = barycentric_interpolate_uv(barycentric, vertex_0.uv1, vertex_1.uv1, vertex_2.uv1);
+        uv_info.ddx *= uv_derivative_bias.x;
+        uv_info.ddy *= uv_derivative_bias.y;
+    }
+
+    let vt_uv = vt_stack_wrap_uv(uv_info.uv, vt_info.flags);
+    let vt_mip = vt_mip_select(vt_info, uv_info.ddx, uv_info.ddy, 0.0);
+    let vt_entry = vt_page_table_load(vt_page_table, vt_info, vt_uv, vt_mip);
+
+    var vt_phys = VTPhysical(vec2<f32>(0.0), 0.0);
+
+    if (vt_entry.valid) {
+        vt_phys = vt_physical_uv(vt_entry, vt_info, vt_uv);
+    }
+`,
+            orm: `vt_sample_layer(vt_cache_orm, vt_cache_sampler, vt_phys, vt_entry.valid && (vt_layer_mask & 4u) != 0u, vec4<f32>(1.0, 1.0, 0.0, 1.0))`,
+            normal: `vt_sample_layer(vt_cache_normal, vt_cache_sampler, vt_phys, vt_entry.valid && (vt_layer_mask & 2u) != 0u, vec4<f32>(0.5, 0.5, 1.0, 1.0)).rgb * 2.0 - 1.0`,
+            diffuse: `vt_sample_layer(vt_cache_albedo, vt_cache_sampler, vt_phys, vt_entry.valid && (vt_layer_mask & 1u) != 0u, vt_info.average_color)`,
+            emissive: `textureSampleBarycentric(texture_emissive, texture_emissive_sampler, uv_info).rgb`,
+        },
+        [
+            sample_chunk,
+        ]
+    );
+
+    const shader = ShaderDescriptor.from({
+        label: "Material / GBuffer laydown (virtual texture)",
+        resources: vt_gbuffer_shader_resources,
+        body,
+    });
+
+    return RenderPipelineDescriptor.from({
+        label: "VT material / Viz-Buffer to G-Buffer laydown",
+        layout: vt_gbuffer_shader_resources.generatePipelineLayoutDescriptor(),
+        vertex: {
+            module: {
+                code: material_gbuffer_vertex_shader_code
+            }
+        },
+        fragment: {
+            module: {
+                code: shader.source,
+            },
+            targets: G_BUFFER_COLOR_TARGETS
+        },
+        depthStencil: {
+            // depth is a material mask — see the standard material pipeline
+            depthCompare: 'equal',
+            format: 'depth32float',
+            depthWriteEnabled: false
+        },
+        primitive: {
+            topology: 'triangle-list',
+            cullMode: 'none',
+        }
+    });
+}

package/src/shade/renderer/object_property/shader_object_property_process.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_object_property_process.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/object_property/shader_object_property_process.js"],"names":[],"mappings":"AAoEA;;;;;;;;;GASG;AACH,2DAKG;8BA/E2B,4BAA4B"}
+{"version":3,"file":"shader_object_property_process.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/object_property/shader_object_property_process.js"],"names":[],"mappings":"AAoEA;;;;;;;;;GASG;AACH,2DAIG;8BA9E2B,4BAA4B"}

package/src/shade/renderer/object_property/shader_object_property_process.js

@@ -1,84 +1,83 @@
-import { u32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../shader/type/WebGPUArray.js";
-import { GEOMETRY_METADATA_STRUCT } from "../geometry/GEOMETRY_METADATA_STRUCT.js";
-import { CodeChunk } from "../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
-import {
-    chunk_update_object_property_mesh_instance_bounds
-} from "./chunk_update_object_property_mesh_instance_bounds.js";
-import { MeshInstanceProperty } from "./MeshInstanceProperty.js";
-import { OBJECT_PROPERTY_REFERENCE_COLLECTION_READ_STRUCT } from "./OBJECT_PROPERTY_REFERENCE_COLLECTION_STRUCTS.js";
-import { ObjectType } from "./ObjectType.js";
-
-const WORKGROUP_SIZE = 64;
-
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    .addStorageBuffer('object_property_writes', OBJECT_PROPERTY_REFERENCE_COLLECTION_READ_STRUCT, false)
-    .addStorageBuffer('scene_database', WebGPUArray.from(u32), true)
-    .addStorageBuffer('geometries', WebGPUArray.from(GEOMETRY_METADATA_STRUCT), false);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-@compute @workgroup_size(${WORKGROUP_SIZE},1,1)
-fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let index = gid.x;
-    if(index >= object_property_writes.count){
-        return;
-    }
-
-    // Producer's atomic count keeps incrementing past arrayLength when
-    // a frame's writes outrun the buffer; the actual record stores
-    // get dropped, but \`count\` doesn't. Without this clamp, threads
-    // past the array tail read OOB garbage from \`elements[index]\` and
-    // dispatch it as if it were a real (instance, property) ref —
-    // which then RMW-corrupts random meshes_table rows downstream.
-    if(index >= arrayLength(&object_property_writes.elements)){
-        return;
-    }
-
-    let _ref = object_property_writes.elements[index];
-    let object_type = _ref.instance >> 24u;
-    let object_index = _ref.instance & 0x00FFFFFFu;
-
-    // Outer dispatch: object type. Only mesh instances are wired up so far.
-    switch(object_type){
-        case ${ObjectType.MeshInstance}u: {
-            // Inner dispatch: which property of the mesh instance needs to
-            // be refreshed. Box and sphere are computed by a single helper
-            // that updates both — both cases route to it. We're not
-            // deduplicating yet, so emitting both refs costs two dispatch
-            // threads per dirty mesh.
-            switch(_ref.property){
-                case ${MeshInstanceProperty.BoundingBox}u,
-                     ${MeshInstanceProperty.BoundingSphere}u: {
-                    update_object_property_mesh_instance_bounds(object_index);
-                }
-                default: {}
-            }
-        }
-        default: {}
-    }
-}
-`, [
-        chunk_update_object_property_mesh_instance_bounds,
-    ]);
-
-/**
- * Consumes the `object_property_writes` stream and dispatches the
- * appropriate update function per `(object_type, property)`. Currently the
- * only fleshed-out path is mesh-instance bounds refresh — anything else is
- * a no-op until we wire it up.
- *
- * Dispatch sized to fit the producer's worst-case output for the frame
- * (`limits.get_limit(ObjectPropertyReference)`); each thread early-outs if
- * its index is past the actual count.
- */
-export const shader_object_property_process = ComputeShader.from({
-    label: "ObjectProperty/Process",
-    body,
-    resources,
-    group_size: [WORKGROUP_SIZE, 1, 1],
-});
+import { u32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../shader/type/WebGPUArray.js";
+import { GEOMETRY_METADATA_STRUCT } from "../geometry/GEOMETRY_METADATA_STRUCT.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
+import {
+    chunk_update_object_property_mesh_instance_bounds
+} from "./chunk_update_object_property_mesh_instance_bounds.js";
+import { MeshInstanceProperty } from "./MeshInstanceProperty.js";
+import { OBJECT_PROPERTY_REFERENCE_COLLECTION_READ_STRUCT } from "./OBJECT_PROPERTY_REFERENCE_COLLECTION_STRUCTS.js";
+import { ObjectType } from "./ObjectType.js";
+
+const WORKGROUP_SIZE = 64;
+
+const resources = new ShaderResourceSetDescriptor();
+resources.createGroup()
+    .addStorageBuffer('object_property_writes', OBJECT_PROPERTY_REFERENCE_COLLECTION_READ_STRUCT, false)
+    .addStorageBuffer('scene_database', WebGPUArray.from(u32), true)
+    .addStorageBuffer('geometries', WebGPUArray.from(GEOMETRY_METADATA_STRUCT), false);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@compute @workgroup_size(${WORKGROUP_SIZE},1,1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let index = gid.x;
+    if(index >= object_property_writes.count){
+        return;
+    }
+
+    // Producer's atomic count keeps incrementing past arrayLength when
+    // a frame's writes outrun the buffer; the actual record stores
+    // get dropped, but \`count\` doesn't. Without this clamp, threads
+    // past the array tail read OOB garbage from \`elements[index]\` and
+    // dispatch it as if it were a real (instance, property) ref —
+    // which then RMW-corrupts random meshes_table rows downstream.
+    if(index >= arrayLength(&object_property_writes.elements)){
+        return;
+    }
+
+    let _ref = object_property_writes.elements[index];
+    let object_type = _ref.instance >> 24u;
+    let object_index = _ref.instance & 0x00FFFFFFu;
+
+    // Outer dispatch: object type. Only mesh instances are wired up so far.
+    switch(object_type){
+        case ${ObjectType.MeshInstance}u: {
+            // Inner dispatch: which property of the mesh instance needs to
+            // be refreshed. Box and sphere are computed by a single helper
+            // that updates both — both cases route to it. We're not
+            // deduplicating yet, so emitting both refs costs two dispatch
+            // threads per dirty mesh.
+            switch(_ref.property){
+                case ${MeshInstanceProperty.BoundingBox}u,
+                     ${MeshInstanceProperty.BoundingSphere}u: {
+                    update_object_property_mesh_instance_bounds(object_index);
+                }
+                default: {}
+            }
+        }
+        default: {}
+    }
+}
+`, [
+        chunk_update_object_property_mesh_instance_bounds,
+    ]);
+
+/**
+ * Consumes the `object_property_writes` stream and dispatches the
+ * appropriate update function per `(object_type, property)`. Currently the
+ * only fleshed-out path is mesh-instance bounds refresh — anything else is
+ * a no-op until we wire it up.
+ *
+ * Dispatch sized to fit the producer's worst-case output for the frame
+ * (`limits.get_limit(ObjectPropertyReference)`); each thread early-outs if
+ * its index is past the actual count.
+ */
+export const shader_object_property_process = ComputeShader.from({
+    label: "ObjectProperty/Process",
+    body,
+    resources,
+});

package/src/shade/renderer/object_property/shader_refresh_all_mesh_bounds.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_refresh_all_mesh_bounds.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/object_property/shader_refresh_all_mesh_bounds.js"],"names":[],"mappings":"AAaA,mEAEmC;AAQnC;;;;;;;;;;;;;;GAcG;AACH,2DAmBG;6BAvD0B,gCAAgC;8BAG/B,4BAA4B"}
+{"version":3,"file":"shader_refresh_all_mesh_bounds.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/object_property/shader_refresh_all_mesh_bounds.js"],"names":[],"mappings":"AAaA,mEAEmC;AAQnC;;;;;;;;;;;;;;GAcG;AACH,2DAkBG;6BAtD0B,gCAAgC;8BAG/B,4BAA4B"}

package/src/shade/renderer/object_property/shader_refresh_all_mesh_bounds.js

@@ -1,58 +1,57 @@
-import { u32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../shader/type/WebGPUArray.js";
-import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
-import { GEOMETRY_METADATA_STRUCT } from "../geometry/GEOMETRY_METADATA_STRUCT.js";
-import { CodeChunk } from "../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
-import {
-    chunk_update_object_property_mesh_instance_bounds
-} from "./chunk_update_object_property_mesh_instance_bounds.js";
-
-const WORKGROUP_SIZE = 64;
-
-export const REFRESH_ALL_MESH_BOUNDS_SETTINGS_STRUCT = WebGPUStruct.from({
-    instance_count: u32,
-}, "RefreshAllMeshBoundsSettings");
-
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    .addUniform('settings', REFRESH_ALL_MESH_BOUNDS_SETTINGS_STRUCT)
-    .addStorageBuffer('scene_database', WebGPUArray.from(u32), true)
-    .addStorageBuffer('geometries', WebGPUArray.from(GEOMETRY_METADATA_STRUCT), false);
-
-/**
- * Recompute bounding box + bounding sphere for every mesh in the scene.
- *
- * Coarser than the OPR-stream-driven `shader_object_property_process` —
- * that one only refreshes meshes whose own transform was animated. When a
- * non-mesh ancestor (joint, anchor) is animated, its descendant meshes'
- * world transforms change too, but they have no animation binding and
- * never make it into the OPR stream. Walking descendants on the GPU to
- * find them is the right answer eventually; for now this pass just
- * refreshes everyone, paying O(instance_count) per frame to dodge the
- * stale-bounds → frustum-culling drop-out the targeted refresh would
- * otherwise leave behind.
- *
- * Dispatch one thread per mesh row in `[0, instance_count)`.
- */
-export const shader_refresh_all_mesh_bounds = ComputeShader.from({
-    label: "ObjectProperty/RefreshAllMeshBounds",
-    body: CodeChunk.from(
-        //language=WGSL
-        `
-@compute @workgroup_size(${WORKGROUP_SIZE},1,1)
-fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let mesh_row = gid.x;
-    if(mesh_row >= settings.instance_count){
-        return;
-    }
-
-    update_object_property_mesh_instance_bounds(mesh_row);
-}
-`, [
-            chunk_update_object_property_mesh_instance_bounds,
-        ]),
-    resources,
-    group_size: [WORKGROUP_SIZE, 1, 1],
-});
+import { u32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+import { GEOMETRY_METADATA_STRUCT } from "../geometry/GEOMETRY_METADATA_STRUCT.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
+import {
+    chunk_update_object_property_mesh_instance_bounds
+} from "./chunk_update_object_property_mesh_instance_bounds.js";
+
+const WORKGROUP_SIZE = 64;
+
+export const REFRESH_ALL_MESH_BOUNDS_SETTINGS_STRUCT = WebGPUStruct.from({
+    instance_count: u32,
+}, "RefreshAllMeshBoundsSettings");
+
+const resources = new ShaderResourceSetDescriptor();
+resources.createGroup()
+    .addUniform('settings', REFRESH_ALL_MESH_BOUNDS_SETTINGS_STRUCT)
+    .addStorageBuffer('scene_database', WebGPUArray.from(u32), true)
+    .addStorageBuffer('geometries', WebGPUArray.from(GEOMETRY_METADATA_STRUCT), false);
+
+/**
+ * Recompute bounding box + bounding sphere for every mesh in the scene.
+ *
+ * Coarser than the OPR-stream-driven `shader_object_property_process` —
+ * that one only refreshes meshes whose own transform was animated. When a
+ * non-mesh ancestor (joint, anchor) is animated, its descendant meshes'
+ * world transforms change too, but they have no animation binding and
+ * never make it into the OPR stream. Walking descendants on the GPU to
+ * find them is the right answer eventually; for now this pass just
+ * refreshes everyone, paying O(instance_count) per frame to dodge the
+ * stale-bounds → frustum-culling drop-out the targeted refresh would
+ * otherwise leave behind.
+ *
+ * Dispatch one thread per mesh row in `[0, instance_count)`.
+ */
+export const shader_refresh_all_mesh_bounds = ComputeShader.from({
+    label: "ObjectProperty/RefreshAllMeshBounds",
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(${WORKGROUP_SIZE},1,1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let mesh_row = gid.x;
+    if(mesh_row >= settings.instance_count){
+        return;
+    }
+
+    update_object_property_mesh_instance_bounds(mesh_row);
+}
+`, [
+            chunk_update_object_property_mesh_instance_bounds,
+        ]),
+    resources,
+});