@adobe/data-gpu 0.9.75 → 0.9.76

package/src/graphics/rendering/pbr-render/{pbr-render-plugin.ts → pbr-factor-render-plugin.ts}

@@ -2,79 +2,37 @@
 
 import { Database, type Entity } from "@adobe/data/ecs";
 import { pbrIblRender } from "../ibl-render/ibl-render-plugin.js";
-import { materialGpu } from "../material-gpu/material-gpu-plugin.js";
+import { materialPaletteGpu } from "../material-palette-gpu/material-palette-gpu-plugin.js";
 import { displayTransform } from "../display-transform-plugin.js";
 import { SceneUniforms } from "../../scene/scene-uniforms/scene-uniforms.js";
 import { StandardVertex } from "../standard-vertex/standard-vertex.js";
-import { createMaterialBindGroupLayout } from "../material-gpu/material-bind-group.js";
-import { buildPbrArrayShader } from "./pbr-array-shader.wgsl.js";
-
-// Must match pbrIblRender's bake so the array shader's prefiltered-mip math agrees.
-const PREFILTERED_MIP_COUNT = 7;
-
-/** Drawable: any visible entity with a geometry ref, a transform, and a material. */
-const DRAWABLE = ["geometry", "visible", "position", "rotation", "scale", "material"] as const;
-// Bodies carrying a derived display pose (interpolation-plugin) draw at it instead
-// of the canonical pose; everything else (statics, props, non-physics instances)
-// draws straight from position/rotation. Splitting the gather by archetype shape
-// avoids a per-row "has display pose?" branch.
-const DRAWABLE_INTERP = [...DRAWABLE, "_renderPosition", "_renderRotation"] as const;
-const DRAWABLE_DIRECT = { exclude: ["_renderPosition"] } as const;
-const PRIMITIVE = ["_vertexBuffer", "_indexBuffer", "_indexCount", "_indexFormat", "_geometry", "_nodeLocalMatrix"] as const;
-
-/** Minimal column shape the gather reads — satisfied by either query's columns. */
-interface Col<T> { get(i: number): T }
-
-function createIblBindGroupLayout(device: GPUDevice): GPUBindGroupLayout {
-    return device.createBindGroupLayout({
-        entries: [
-            { binding: 0, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "float", viewDimension: "cube" } },
-            { binding: 1, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "float", viewDimension: "cube" } },
-            { binding: 2, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "float", viewDimension: "2d" } },
-            { binding: 3, visibility: GPUShaderStage.FRAGMENT, sampler: { type: "filtering" } },
-        ],
-    });
-}
+import { createFactorPaletteBindGroupLayout } from "../material-palette-gpu/palette-bind-group.js";
+import { buildPbrFactorShader } from "./pbr-factor-shader.wgsl.js";
+import {
+    composeTrs,
+    createIblBindGroupLayout,
+    DRAWABLE,
+    DRAWABLE_DIRECT,
+    DRAWABLE_INTERP,
+    PREFILTERED_MIP_COUNT,
+    PRIMITIVE,
+    type ColumnReader,
+    type MeshBatch,
+} from "./primitive-render-shared.js";
+
+interface InstCache { buffer: GPUBuffer; indexBuffer: GPUBuffer; bindGroup: GPUBindGroup; capacity: number }
 
 /**
- * Compose a column-major TRS matrix directly into `out[o..o+15]` — no
- * allocation, reading position/rotation/scale straight from their column typed
- * arrays. Matches `translation · Quat.toMat4 · scaling`. Runs once per visible
- * drawable per frame, so the array churn of the math-helper form matters.
- */
-function composeTrs(
-    out: Float32Array, o: number,
-    p: ArrayLike<number>, pi: number, q: ArrayLike<number>, qi: number, s: ArrayLike<number>, si: number,
-): void {
-    const qx = q[qi], qy = q[qi + 1], qz = q[qi + 2], qw = q[qi + 3];
-    const sx = s[si], sy = s[si + 1], sz = s[si + 2];
-    const xx = qx * qx, yy = qy * qy, zz = qz * qz;
-    const xy = qx * qy, xz = qx * qz, yz = qy * qz;
-    const wx = qw * qx, wy = qw * qy, wz = qw * qz;
-    out[o] = (1 - 2 * (yy + zz)) * sx; out[o + 1] = (2 * (xy + wz)) * sx; out[o + 2] = (2 * (xz - wy)) * sx; out[o + 3] = 0;
-    out[o + 4] = (2 * (xy - wz)) * sy; out[o + 5] = (1 - 2 * (xx + zz)) * sy; out[o + 6] = (2 * (yz + wx)) * sy; out[o + 7] = 0;
-    out[o + 8] = (2 * (xz + wy)) * sz; out[o + 9] = (2 * (yz - wx)) * sz; out[o + 10] = (1 - 2 * (xx + yy)) * sz; out[o + 11] = 0;
-    out[o + 12] = p[pi]; out[o + 13] = p[pi + 1]; out[o + 14] = p[pi + 2]; out[o + 15] = 1;
-}
-
-/**
- * pbrRender — the single PBR + IBL renderer. It extends `pbrIblRender`, reusing
- * its IBL bake, skybox, scene/material bind groups and glTF draw path verbatim,
- * and adds one extra draw query for **instanced primitives** whose material
- * comes from the shared `materialGpu` arrays (selected per instance by the
- * material entity's `_layerIndex`). Two efficient queries, one render plugin:
- *
- *   - glTF models  → per-material bind group, native-resolution textures (pbrIblRender)
- *   - primitives   → shared texture_2d_array + per-instance layer (this system)
+ * pbrFactorRender — instanced primitive PBR from material factors only (no map
+ * sampling). Extends `pbrIblRender` for IBL + skybox + optional glTF draws.
+ * Pairs with `materialPaletteGpu` (`_paletteIndex` on factor materials).
  *
- * The primitive system runs after `pbrIblRenderSystem` so the skybox is drawn
- * first. World matrices are computed directly from `position`/`rotation`/`scale`
- * (primitives are flat — no hierarchy), so it's independent of `transform`.
+ * Pairs with `materialPaletteGpu` (`_paletteIndex`). Idle when no factor materials or drawables exist.
  */
-export const pbrRender = Database.Plugin.create({
-    extends: Database.Plugin.combine(pbrIblRender, materialGpu, displayTransform),
+export const pbrFactorRender = Database.Plugin.create({
+    extends: Database.Plugin.combine(pbrIblRender, materialPaletteGpu, displayTransform),
     systems: {
-        pbrPrimitiveRenderSystem: {
+        pbrFactorPrimitiveRenderSystem: {
             schedule: { during: ["render"], after: ["beginRenderPass", "pbrIblRenderSystem"], before: ["endRenderPass"] },
             create: db => {
                 let pipeline: GPURenderPipeline | null = null;
@@ -87,25 +45,21 @@ export const pbrRender = Database.Plugin.create({
                 let cachedSceneBuffer: GPUBuffer | null = null;
                 let cachedIrradiance: GPUTexture | null = null;
 
-                let matLayer = new Map<Entity, number>();
+                const matIndex = new Map<Entity, number>();
                 let matCount = -1;
 
-                interface Inst { buffer: GPUBuffer; layerBuffer: GPUBuffer; bindGroup: GPUBindGroup; capacity: number }
-                const instCache = new Map<Entity, Inst>();
+                const instCache = new Map<Entity, InstCache>();
                 let matScratch = new Float32Array(16);
-                let layerScratch = new Uint32Array(1);
-                // Per-frame matrix arena (composed TRS, one mat4 per drawable) + per-geometry
-                // draw lists (matrix offset + layer). All pooled and reused across frames —
-                // the gather runs over every visible body each frame, so zero allocation here.
+                let indexScratch = new Uint32Array(1);
                 let mats = new Float32Array(64 * 16);
-                const batches = new Map<Entity, { off: number[]; layer: number[] }>();
+                const batches = new Map<Entity, MeshBatch>();
 
                 return () => {
                     const {
                         device, renderPassEncoder, canvasFormat, depthFormat, _sceneUniformsBuffer,
-                        _materialBindGroup, _iblIrradiance, _iblPrefiltered, _iblBrdfLut,
+                        _factorPaletteBindGroup, _iblIrradiance, _iblPrefiltered, _iblBrdfLut,
                     } = db.store.resources;
-                    if (!device || !renderPassEncoder || !_sceneUniformsBuffer || !_materialBindGroup) return;
+                    if (!device || !renderPassEncoder || !_sceneUniformsBuffer || !_factorPaletteBindGroup) return;
                     if (!_iblIrradiance || !_iblPrefiltered || !_iblBrdfLut) return;
 
                     if (!sceneLayout) sceneLayout = SceneUniforms.createBindGroupLayout(device);
@@ -121,9 +75,11 @@ export const pbrRender = Database.Plugin.create({
                         addressModeU: "clamp-to-edge", addressModeV: "clamp-to-edge", addressModeW: "clamp-to-edge",
                     });
                     if (!pipeline) {
-                        const module = device.createShaderModule({ code: buildPbrArrayShader({ prefilteredMipCount: PREFILTERED_MIP_COUNT }) });
+                        const module = device.createShaderModule({ code: buildPbrFactorShader({ prefilteredMipCount: PREFILTERED_MIP_COUNT }) });
                         pipeline = device.createRenderPipeline({
-                            layout: device.createPipelineLayout({ bindGroupLayouts: [sceneLayout, createMaterialBindGroupLayout(device), iblLayout, instanceLayout] }),
+                            layout: device.createPipelineLayout({
+                                bindGroupLayouts: [sceneLayout, createFactorPaletteBindGroupLayout(device), iblLayout, instanceLayout],
+                            }),
                             vertex: { module, entryPoint: "vs_main", buffers: [StandardVertex.layout] },
                             fragment: { module, entryPoint: "fs_main", targets: [{ format: canvasFormat }] },
                             primitive: { topology: "triangle-list", cullMode: "back" },
@@ -148,62 +104,58 @@ export const pbrRender = Database.Plugin.create({
                         cachedIrradiance = _iblIrradiance;
                     }
 
-                    // material → layer, refreshed only when the material set grows
                     let mc = 0;
-                    for (const arch of db.store.queryArchetypes(["_layerIndex"])) mc += arch.rowCount;
+                    for (const arch of db.store.queryArchetypes(["_paletteIndex"])) mc += arch.rowCount;
                     if (mc !== matCount) {
-                        matLayer = new Map();
-                        for (const arch of db.store.queryArchetypes(["_layerIndex"])) {
-                            const id = arch.columns.id, li = arch.columns._layerIndex;
-                            for (let i = 0; i < arch.rowCount; i++) matLayer.set(id.get(i), li.get(i));
+                        matIndex.clear();
+                        for (const arch of db.store.queryArchetypes(["_paletteIndex"])) {
+                            const id = arch.columns.id, pi = arch.columns._paletteIndex;
+                            for (let i = 0; i < arch.rowCount; i++) matIndex.set(id.get(i), pi.get(i));
                         }
                         matCount = mc;
                     }
 
-                    // Gather visible primitive drawables grouped by geometry. Compose each
-                    // world matrix straight from the chosen pose/scale column typed arrays
-                    // into the pooled `mats` arena — no per-row array allocation. Two passes:
-                    // bodies with a display pose use it; everything else uses position/rotation.
-                    for (const b of batches.values()) { b.off.length = 0; b.layer.length = 0; }
+                    for (const b of batches.values()) { b.off.length = 0; b.materialIndex.length = 0; }
                     let drawCount = 0;
                     const gather = (
-                        rowCount: number, vis: Col<boolean>, geo: Col<Entity>, mat: Col<Entity>,
+                        rowCount: number, vis: ColumnReader<boolean>, meshCol: ColumnReader<Entity>, mat: ColumnReader<Entity>,
                         posArr: ArrayLike<number>, rotArr: ArrayLike<number>, sclArr: ArrayLike<number>,
                     ): void => {
                         for (let i = 0; i < rowCount; i++) {
                             if (!vis.get(i)) continue;
-                            const layer = matLayer.get(mat.get(i));
-                            if (layer === undefined) continue;
+                            const paletteIndex = matIndex.get(mat.get(i));
+                            if (paletteIndex === undefined) continue;
                             if ((drawCount + 1) * 16 > mats.length) { const grown = new Float32Array(mats.length * 2); grown.set(mats); mats = grown; }
                             composeTrs(mats, drawCount * 16, posArr, i * 3, rotArr, i * 4, sclArr, i * 3);
-                            const g = geo.get(i);
+                            const g = meshCol.get(i);
                             let b = batches.get(g);
-                            if (!b) { b = { off: [], layer: [] }; batches.set(g, b); }
-                            b.off.push(drawCount); b.layer.push(layer);
+                            if (!b) { b = { off: [], materialIndex: [] }; batches.set(g, b); }
+                            b.off.push(drawCount);
+                            b.materialIndex.push(paletteIndex);
                             drawCount++;
                         }
                     };
                     for (const arch of db.store.queryArchetypes(DRAWABLE_INTERP)) {
-                        gather(arch.rowCount, arch.columns.visible, arch.columns.geometry, arch.columns.material,
+                        gather(arch.rowCount, arch.columns.visible, arch.columns.mesh, arch.columns.material,
                             arch.columns._renderPosition.getTypedArray(), arch.columns._renderRotation.getTypedArray(), arch.columns.scale.getTypedArray());
                     }
                     for (const arch of db.store.queryArchetypes(DRAWABLE, DRAWABLE_DIRECT)) {
-                        gather(arch.rowCount, arch.columns.visible, arch.columns.geometry, arch.columns.material,
+                        gather(arch.rowCount, arch.columns.visible, arch.columns.mesh, arch.columns.material,
                             arch.columns.position.getTypedArray(), arch.columns.rotation.getTypedArray(), arch.columns.scale.getTypedArray());
                     }
                     if (drawCount === 0) return;
 
                     renderPassEncoder.setPipeline(pipeline);
                     renderPassEncoder.setBindGroup(0, sceneBindGroup);
-                    renderPassEncoder.setBindGroup(1, _materialBindGroup);
+                    renderPassEncoder.setBindGroup(1, _factorPaletteBindGroup);
                     renderPassEncoder.setBindGroup(2, iblBindGroup);
 
                     for (const arch of db.store.queryArchetypes(PRIMITIVE)) {
                         const vbs = arch.columns._vertexBuffer, ibs = arch.columns._indexBuffer;
                         const counts = arch.columns._indexCount, formats = arch.columns._indexFormat;
-                        const geoRefs = arch.columns._geometry, primIds = arch.columns.id;
+                        const meshRefs = arch.columns._mesh, primIds = arch.columns.id;
                         for (let i = 0; i < arch.rowCount; i++) {
-                            const b = batches.get(geoRefs.get(i));
+                            const b = batches.get(meshRefs.get(i));
                             if (!b || b.off.length === 0) continue;
                             const n = b.off.length;
                             const primId = primIds.get(i);
@@ -211,32 +163,29 @@ export const pbrRender = Database.Plugin.create({
                             let entry = instCache.get(primId);
                             if (!entry || entry.capacity < n) {
                                 entry?.buffer.destroy();
-                                entry?.layerBuffer.destroy();
+                                entry?.indexBuffer.destroy();
                                 const buffer = device.createBuffer({ size: Math.max(n * 64, 64), usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST });
-                                const layerBuffer = device.createBuffer({ size: Math.max(n * 4, 4), usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST });
+                                const indexBuffer = device.createBuffer({ size: Math.max(n * 4, 4), usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST });
                                 const bindGroup = device.createBindGroup({
                                     layout: instanceLayout,
-                                    entries: [{ binding: 0, resource: { buffer } }, { binding: 1, resource: { buffer: layerBuffer } }],
+                                    entries: [{ binding: 0, resource: { buffer } }, { binding: 1, resource: { buffer: indexBuffer } }],
                                 });
-                                entry = { buffer, layerBuffer, bindGroup, capacity: n };
+                                entry = { buffer, indexBuffer, bindGroup, capacity: n };
                                 instCache.set(primId, entry);
                             }
                             if (matScratch.length < n * 16) matScratch = new Float32Array(n * 16);
-                            if (layerScratch.length < n) layerScratch = new Uint32Array(n);
-                            // Copy this geometry's matrices out of the arena into a contiguous
-                            // upload buffer. Primitive node matrices are identity (flat shapes;
-                            // glTF hierarchy goes through pbrIblRender), so no extra multiply.
+                            if (indexScratch.length < n) indexScratch = new Uint32Array(n);
                             for (let j = 0; j < n; j++) {
                                 const src = b.off[j] * 16, dst = j * 16;
                                 for (let k = 0; k < 16; k++) matScratch[dst + k] = mats[src + k];
-                                layerScratch[j] = b.layer[j];
+                                indexScratch[j] = b.materialIndex[j];
                             }
                             device.queue.writeBuffer(entry.buffer, 0, matScratch, 0, n * 16);
-                            device.queue.writeBuffer(entry.layerBuffer, 0, layerScratch, 0, n);
+                            device.queue.writeBuffer(entry.indexBuffer, 0, indexScratch, 0, n);
 
                             renderPassEncoder.setBindGroup(3, entry.bindGroup);
-                            renderPassEncoder.setVertexBuffer(0, vbs.get(i)!); // _PbrPrimitive guarantees non-null
-                            renderPassEncoder.setIndexBuffer(ibs.get(i)!, formats.get(i)); // _PbrPrimitive guarantees non-null
+                            renderPassEncoder.setVertexBuffer(0, vbs.get(i)!);
+                            renderPassEncoder.setIndexBuffer(ibs.get(i)!, formats.get(i));
                             renderPassEncoder.drawIndexed(counts.get(i), n);
                         }
                     }

package/src/graphics/rendering/pbr-render/{pbr-array-shader.wgsl.ts → pbr-factor-shader.wgsl.ts}

@@ -5,13 +5,10 @@ import { schema as sceneUniformsSchema } from "../../scene/scene-uniforms/schema
 import brdf from "../ibl-render/brdf.wgsl.js";
 
 /**
- * Unified PBR shader for instanced primitives (and, after convergence, glTF).
- * Materials come from the shared `materialGpu` set — five `texture_2d_array`s +
- * a palette of per-layer factors (group 1) — selected by a per-instance layer
- * index (group 3, binding 1). Shading is identical Cook-Torrance + split-sum
- * IBL to the per-material `ibl-shader`; only the material *source* differs.
+ * Factor-only PBR for instanced primitives — palette factors + vertex normals,
+ * no material map sampling. Used by `pbrFactorRender`.
  */
-export function buildPbrArrayShader(options: { prefilteredMipCount: number }): string {
+export function buildPbrFactorShader(options: { prefilteredMipCount: number }): string {
     return /* wgsl */ `
 struct SceneUniforms {
 ${wgslStructFields(sceneUniformsSchema)}
@@ -20,18 +17,13 @@ ${wgslStructFields(sceneUniformsSchema)}
 struct MaterialFactors {
     baseColorFactor: vec4f,
     emissiveMetallic: vec4f,   // emissive.rgb, metallicFactor
-    roughNormalOcc: vec4f,     // roughnessFactor, normalScale, occlusionStrength, _
+    roughNormalIr: vec4f,      // roughnessFactor, normalScale, occlusionStrength, irEmission
+    emissionMeta: vec4f,       // emissionMode, _, _, _
 }
 
 @group(0) @binding(0) var<uniform> scene: SceneUniforms;
 
 @group(1) @binding(0) var<storage, read> palette: array<MaterialFactors>;
-@group(1) @binding(1) var baseColorArray: texture_2d_array<f32>;
-@group(1) @binding(2) var metallicRoughnessArray: texture_2d_array<f32>;
-@group(1) @binding(3) var normalArray: texture_2d_array<f32>;
-@group(1) @binding(4) var occlusionArray: texture_2d_array<f32>;
-@group(1) @binding(5) var emissiveArray: texture_2d_array<f32>;
-@group(1) @binding(6) var matSampler: sampler;
 
 @group(2) @binding(0) var iblIrradiance: texture_cube<f32>;
 @group(2) @binding(1) var iblPrefiltered: texture_cube<f32>;
@@ -39,7 +31,7 @@ struct MaterialFactors {
 @group(2) @binding(3) var iblSampler: sampler;
 
 @group(3) @binding(0) var<storage, read> instances: array<mat4x4<f32>>;
-@group(3) @binding(1) var<storage, read> layers: array<u32>;
+@group(3) @binding(1) var<storage, read> paletteIndices: array<u32>;
 
 const PREFILTERED_MIP_COUNT: f32 = ${options.prefilteredMipCount.toFixed(1)};
 
@@ -54,10 +46,7 @@ struct VertexOutput {
     @builtin(position) clipPosition: vec4f,
     @location(0) worldPosition: vec3f,
     @location(1) normal: vec3f,
-    @location(2) tangent: vec3f,
-    @location(3) bitangent: vec3f,
-    @location(4) uv: vec2f,
-    @location(5) @interpolate(flat) layer: u32,
+    @location(5) @interpolate(flat) paletteIndex: u32,
 }
 
 @vertex
@@ -74,10 +63,7 @@ fn vs_main(@builtin(instance_index) instanceIndex: u32, in: VertexInput) -> Vert
     out.clipPosition = scene.viewProjectionMatrix * worldPos;
     out.worldPosition = worldPos.xyz;
     out.normal = normalize(normalMat * in.normal);
-    out.tangent = normalize(m3 * in.tangent.xyz);
-    out.bitangent = normalize(cross(out.normal, out.tangent) * in.tangent.w);
-    out.uv = in.uv;
-    out.layer = layers[instanceIndex];
+    out.paletteIndex = paletteIndices[instanceIndex];
     return out;
 }
 
@@ -85,32 +71,26 @@ ${brdf}
 
 @fragment
 fn fs_main(in: VertexOutput) -> @location(0) vec4f {
-    let f = palette[in.layer];
-    let li = i32(in.layer);
+    let f = palette[in.paletteIndex];
 
-    let baseColor = textureSample(baseColorArray, matSampler, in.uv, li) * f.baseColorFactor;
-
-    let mr = textureSample(metallicRoughnessArray, matSampler, in.uv, li);
-    let metallic = mr.b * f.emissiveMetallic.w;
-    var roughness = mr.g * f.roughNormalOcc.x;
+    let baseColor = f.baseColorFactor;
+    let metallic = f.emissiveMetallic.w;
+    var roughness = f.roughNormalIr.x;
     roughness = max(roughness, MIN_ROUGHNESS);
     let alpha = roughness * roughness;
+    let occlusion = f.roughNormalIr.z;
+    let emissionMode = f.emissionMeta.x;
+    let irEmission = f.roughNormalIr.w;
+    // 0 = UV fluorescence (no visible add); 1 = visible luminescence (emissive + IR glow).
+    let emissive = select(vec3f(0.0), f.emissiveMetallic.xyz + vec3f(irEmission), emissionMode >= 0.5);
 
-    let occlusion = textureSample(occlusionArray, matSampler, in.uv, li).r;
-    let emissive = textureSample(emissiveArray, matSampler, in.uv, li).rgb * f.emissiveMetallic.xyz;
-
-    let nSampled = textureSample(normalArray, matSampler, in.uv, li).rgb * 2.0 - vec3f(1.0);
-    let nScaled = vec3f(nSampled.xy * f.roughNormalOcc.y, nSampled.z);
-    let tbn = mat3x3<f32>(in.tangent, in.bitangent, in.normal);
-    let N = normalize(tbn * nScaled);
-
+    let N = normalize(in.normal);
     let V = normalize(scene.cameraPosition - in.worldPosition);
     let nDotV = max(dot(N, V), 0.001);
     let R = reflect(-V, N);
 
     let f0 = mix(vec3f(0.04), baseColor.rgb, metallic);
 
-    // --- IBL contribution (split-sum) ---
     let F_ibl = f_schlick_roughness(nDotV, f0, roughness);
     let kD_ibl = (vec3f(1.0) - F_ibl) * (1.0 - metallic);
 
@@ -122,9 +102,8 @@ fn fs_main(in: VertexOutput) -> @location(0) vec4f {
     let envBrdf = textureSampleLevel(iblBrdfLut, iblSampler, vec2f(nDotV, roughness), 0.0).rg;
     let specularIbl = prefiltered * (F_ibl * envBrdf.x + envBrdf.y);
 
-    let ambient = (diffuseIbl + specularIbl) * mix(1.0, occlusion, f.roughNormalOcc.z);
+    let ambient = (diffuseIbl + specularIbl) * occlusion;
 
-    // --- Direct light (parity with the single scene light) ---
     let L = normalize(-scene.lightDirection);
     let H = normalize(V + L);
     let nDotL = max(dot(N, L), 0.0);

package/src/graphics/rendering/pbr-render/physics-bridge-plugin.ts

@@ -2,101 +2,127 @@
 
 import { Database, type Entity } from "@adobe/data/ecs";
 import { physicsData } from "../../../physics/physics-data-plugin.js";
-import { model } from "../../scene/model/model-plugin.js";
+import { RIGID_BODY_COMPONENTS } from "../../../physics/rigid-body-components.js";
+import { STATIC_COLLIDER_COMPONENTS } from "../../../physics/static-collider-components.js";
+import { mesh } from "../../scene/model/mesh-plugin.js";
 import { shapeGeometry } from "../../scene/model/shape/shape-geometry-plugin.js";
 import { capsuleMesh, flatShadedMesh } from "../../scene/model/shape/shape-mesh.js";
 import { convexHullMesh } from "../../scene/model/shape/convex-hull.js";
 import { uploadShapeMesh } from "../../scene/model/shape/upload-shape-mesh.js";
+import { boundsFromShapeMesh } from "../../scene/model/shape/bounds-from-shape-mesh.js";
 import type { ColliderMesh } from "../../../physics/body/collider-mesh.js";
 import { interpolation } from "../interpolation-plugin.js";
 
+/** Authored column sets for primitive collider rows (RigidBody, ConvexBody,
+ *  StaticCollider, MeshCollider). Query by these sets — not the named handle —
+ *  so solver-tagged variants are found after migration. Rows with
+ *  `voxelShapeName` are skipped at runtime (mechs voxel bodies). */
+const PRIMITIVE_COLLIDER_QUERIES: readonly {
+    include: readonly string[];
+    exclude?: readonly string[];
+}[] = [
+    { include: RIGID_BODY_COMPONENTS, exclude: ["convexPoints"] },
+    { include: [...RIGID_BODY_COMPONENTS, "convexPoints"] },
+    { include: STATIC_COLLIDER_COMPONENTS, exclude: ["colliderMesh"] },
+    { include: [...STATIC_COLLIDER_COMPONENTS, "colliderMesh"] },
+];
+
+const hasVoxelShapeName = (store: { read(id: Entity): Record<string, unknown> | null }, id: Entity): boolean =>
+    store.read(id)?.voxelShapeName != null;
+
 /**
- * physicsRenderBridge — makes colliders renderable by `pbrRender`. Once the
- * shape geometries exist, every body with a collider shape (dynamic RigidBody
- * or immovable StaticCollider alike) gains a `geometry` ref (sphere / cube by
- * collider shape), a `scale` (its half-extents — the unit shapes are size-1),
- * and `visible`. Because physics `rotation`/`position` are the same components
- * the renderer reads, there is no per-frame sync: this only migrates new bodies.
- *
- * It also folds in `interpolation`, so dynamic bodies render at the smooth,
- * render-rate display pose for free (the solver steps on a fixed clock that need
- * not match the render rate) — bridging physics to the renderer is exactly when
- * you want that. Use `interpolation` directly only with a custom (non-bridge) path.
- *
- * Also declares `Prop` — a render-only placed geometry with a material that is
- * not a physics body at all (decorative scenery with no collider).
+ * physicsRenderBridge — assigns default primitive render meshes for standard
+ * physics bodies whose visual is the collider primitive (RigidBody,
+ * StaticCollider, ConvexBody, MeshCollider — including solver-tagged variants).
+ * Collider shape
+ * drives the mesh; bodies on other archetypes (e.g. `VoxelRigidBody`) are not
+ * touched — their visual path owns `mesh` assignment separately.
  */
 export const physicsRenderBridge = Database.Plugin.create({
-    extends: Database.Plugin.combine(physicsData, model, shapeGeometry, interpolation),
-    archetypes: {
-        Prop: ["geometry", "position", "rotation", "scale", "visible", "material"],
-    },
+    imports: Database.Plugin.combine(mesh, shapeGeometry, interpolation),
+    extends: physicsData,
     systems: {
         physicsBridge: {
+            // Runs late in postUpdate so voxel-owned bodies can resolve first;
+            // name sorts after `voxelShapeVisualBridge` when both were postUpdate.
             schedule: { during: ["postUpdate"] },
             create: db => {
-                // Sphere/cube are unit meshes scaled by half-extents. A capsule can't
-                // be non-uniformly scaled (its caps would distort), so it's built at its
-                // real size and drawn at unit scale — one mesh per distinct (radius,
-                // half-height), cached here (scenes use very few capsule sizes).
-                const capsuleGeometry = new Map<string, Entity>();
+                const capsuleMeshes = new Map<string, Entity>();
                 const ensureCapsule = (device: GPUDevice, r: number, hy: number): Entity => {
                     const key = `${r}:${hy}`;
-                    let geo = capsuleGeometry.get(key);
-                    if (geo === undefined) {
-                        const m = uploadShapeMesh(device, capsuleMesh(r, hy));
-                        geo = db.transactions.insertShapePrimitive({ vertexBuffer: m.vb, indexBuffer: m.ib, indexCount: m.count });
-                        capsuleGeometry.set(key, geo);
+                    let id = capsuleMeshes.get(key);
+                    if (id === undefined) {
+                        const data = capsuleMesh(r, hy);
+                        const m = uploadShapeMesh(device, data);
+                        id = db.transactions.insertStaticMeshPrimitive({
+                            vertexBuffer: m.vb, indexBuffer: m.ib, indexCount: m.count,
+                            localBounds: boundsFromShapeMesh(data),
+                        });
+                        capsuleMeshes.set(key, id);
                     }
-                    return geo;
+                    return id;
                 };
-                // Hull render mesh = triangulated convex hull of the point cloud, cached
-                // by the point-array reference (bodies sharing a cloud share one mesh + draw).
-                const hullGeometry = new Map<Float32Array, Entity>();
+                const hullMeshes = new Map<Float32Array, Entity>();
                 const ensureHull = (device: GPUDevice, points: Float32Array): Entity => {
-                    let geo = hullGeometry.get(points);
-                    if (geo === undefined) {
-                        const m = uploadShapeMesh(device, convexHullMesh(points));
-                        geo = db.transactions.insertShapePrimitive({ vertexBuffer: m.vb, indexBuffer: m.ib, indexCount: m.count });
-                        hullGeometry.set(points, geo);
+                    let id = hullMeshes.get(points);
+                    if (id === undefined) {
+                        const data = convexHullMesh(points);
+                        const m = uploadShapeMesh(device, data);
+                        id = db.transactions.insertStaticMeshPrimitive({
+                            vertexBuffer: m.vb, indexBuffer: m.ib, indexCount: m.count,
+                            localBounds: boundsFromShapeMesh(data),
+                        });
+                        hullMeshes.set(points, id);
                     }
-                    return geo;
+                    return id;
                 };
-                // Static-mesh render = flat-shaded triangle soup, cached by the colliderMesh ref.
-                const meshGeometry = new Map<ColliderMesh, Entity>();
-                const ensureMesh = (device: GPUDevice, cm: ColliderMesh): Entity => {
-                    let geo = meshGeometry.get(cm);
-                    if (geo === undefined) {
-                        const m = uploadShapeMesh(device, flatShadedMesh(cm.positions, cm.indices));
-                        geo = db.transactions.insertShapePrimitive({ vertexBuffer: m.vb, indexBuffer: m.ib, indexCount: m.count });
-                        meshGeometry.set(cm, geo);
+                const triMeshes = new Map<ColliderMesh, Entity>();
+                const ensureTriMesh = (device: GPUDevice, cm: ColliderMesh): Entity => {
+                    let id = triMeshes.get(cm);
+                    if (id === undefined) {
+                        const data = flatShadedMesh(cm.positions, cm.indices);
+                        const m = uploadShapeMesh(device, data);
+                        id = db.transactions.insertStaticMeshPrimitive({
+                            vertexBuffer: m.vb, indexBuffer: m.ib, indexCount: m.count,
+                            localBounds: boundsFromShapeMesh(data),
+                        });
+                        triMeshes.set(cm, id);
                     }
-                    return geo;
+                    return id;
                 };
                 return () => {
-                    const shapes = db.store.resources._shapeGeometry;
+                    const shapes = db.store.resources._shapeMeshes;
                     const device = db.store.resources.device;
                     if (!shapes || !device) return;
-                    for (const arch of db.store.queryArchetypes(["colliderShape", "halfExtents"], { exclude: ["geometry"] })) {
-                        const ids = arch.columns.id, css = arch.columns.colliderShape, hes = arch.columns.halfExtents;
-                        // Tail→head: every visited body migrates out (gains geometry).
-                        for (let i = arch.rowCount - 1; i >= 0; i--) {
-                            const id = ids.get(i), shape = css.get(i), he = hes.get(i);
-                            // capsule + hull render at unit scale (their meshes are real-size);
-                            // sphere/cube are unit meshes scaled by half-extents.
-                            let geometry: Entity, scale: [number, number, number];
-                            if (shape === "box") { geometry = shapes.cube; scale = [he[0], he[1], he[2]]; }
-                            else if (shape === "capsule") { geometry = ensureCapsule(device, he[0], he[1]); scale = [1, 1, 1]; }
-                            else if (shape === "hull") {
-                                const pts = (db.store.read(id) as { convexPoints?: Float32Array | null }).convexPoints;
-                                geometry = pts ? ensureHull(device, pts) : shapes.sphere;
-                                scale = [1, 1, 1];
-                            } else if (shape === "mesh") {
-                                const cm = (db.store.read(id) as { colliderMesh?: ColliderMesh | null }).colliderMesh;
-                                geometry = cm ? ensureMesh(device, cm) : shapes.cube;
-                                scale = [1, 1, 1];
-                            } else { geometry = shapes.sphere; scale = [he[0], he[0], he[0]]; }
-                            db.store.update(id, { geometry, scale, visible: true });
+                    for (const { include, exclude } of PRIMITIVE_COLLIDER_QUERIES) {
+                        for (const arch of db.store.queryArchetypes(
+                            include as typeof RIGID_BODY_COMPONENTS,
+                            exclude ? { exclude: exclude as ["convexPoints"] | ["colliderMesh"] } : undefined,
+                        )) {
+                            const ids = arch.columns.id;
+                            const css = arch.columns.colliderShape;
+                            const hes = arch.columns.halfExtents;
+                            for (let i = arch.rowCount - 1; i >= 0; i--) {
+                                const id = ids.get(i);
+                                if (hasVoxelShapeName(db.store, id)) continue;
+                                if (db.store.get(id, "mesh") != null) continue;
+                                const shape = css.get(i);
+                                const he = hes.get(i);
+                                let meshId: Entity;
+                                let scale: [number, number, number];
+                                if (shape === "box") { meshId = shapes.cube; scale = [he[0], he[1], he[2]]; }
+                                else if (shape === "capsule") { meshId = ensureCapsule(device, he[0], he[1]); scale = [1, 1, 1]; }
+                                else if (shape === "hull") {
+                                    const pts = db.store.get(id, "convexPoints");
+                                    meshId = pts ? ensureHull(device, pts) : shapes.sphere;
+                                    scale = [1, 1, 1];
+                                } else if (shape === "mesh") {
+                                    const cm = db.store.get(id, "colliderMesh");
+                                    meshId = cm ? ensureTriMesh(device, cm) : shapes.cube;
+                                    scale = [1, 1, 1];
+                                } else { meshId = shapes.sphere; scale = [he[0], he[0], he[0]]; }
+                                db.store.update(id, { mesh: meshId, scale, visible: true });
+                            }
                         }
                     }
                 };