@adobe/data-gpu 0.9.75 → 0.9.76

package/src/graphics/rendering/ibl-render/ibl-render-plugin.ts

@@ -264,18 +264,18 @@ export const pbrIblRender = Database.Plugin.create({
                     // from each Model's `_worldMatrix` component (written by _transform).
                     interface ModelEntry { id: number; matrix: Mat4x4 }
                     const modelsByGeo = new Map<number, ModelEntry[]>();
-                    for (const arch of db.store.queryArchetypes(["geometry", "visible", "_worldMatrix"])) {
+                    for (const arch of db.store.queryArchetypes(["mesh", "visible", "_worldMatrix"])) {
                         const ids = arch.columns.id;
-                        const geoRefs = arch.columns.geometry;
+                        const meshRefs = arch.columns.mesh;
                         const vis = arch.columns.visible;
                         const worldMats = arch.columns._worldMatrix;
                         for (let i = 0; i < arch.rowCount; i++) {
                             if (!vis.get(i)) continue;
                             const id = ids.get(i);
                             const m = worldMats.get(i);
-                            const geoId = geoRefs.get(i);
-                            let arr = modelsByGeo.get(geoId);
-                            if (!arr) { arr = []; modelsByGeo.set(geoId, arr); }
+                            const meshId = meshRefs.get(i);
+                            let arr = modelsByGeo.get(meshId);
+                            if (!arr) { arr = []; modelsByGeo.set(meshId, arr); }
                             arr.push({ id, matrix: m });
                         }
                     }
@@ -315,7 +315,7 @@ export const pbrIblRender = Database.Plugin.create({
                         "_indexCount",
                         "_indexFormat",
                         "_material",
-                        "_geometry",
+                        "_mesh",
                         "_nodeLocalMatrix",
                     ])) {
                         const vbs = archetype.columns._vertexBuffer;
@@ -324,12 +324,12 @@ export const pbrIblRender = Database.Plugin.create({
                         const counts = archetype.columns._indexCount;
                         const formats = archetype.columns._indexFormat;
                         const matRefs = archetype.columns._material;
-                        const geoRefs = archetype.columns._geometry;
+                        const meshRefs = archetype.columns._mesh;
                         const nodeMats = archetype.columns._nodeLocalMatrix;
                         const primIds = archetype.columns.id;
                         for (let i = 0; i < archetype.rowCount; i++) {
-                            const geoId = geoRefs.get(i);
-                            const models = modelsByGeo.get(geoId);
+                            const meshId = meshRefs.get(i);
+                            const models = modelsByGeo.get(meshId);
                             if (!models) continue;
 
                             const skinBuf = skinVbs.get(i);

package/src/graphics/rendering/interpolation.test.ts

@@ -3,7 +3,7 @@
 import { describe, it, expect } from "vitest";
 import { Database } from "@adobe/data/ecs";
 import { interpolation } from "./interpolation-plugin.js";
-import type { PhysicsClock } from "../../physics/physics-clock-plugin.js";
+import type { PhysicsClock } from "../../physics/physics-clock/physics-clock.js";
 
 /**
  * The interpolation pass turns the fixed-step sim state into a smooth render pose.

package/src/graphics/rendering/jolt-ragdoll-plugin.ts

@@ -26,7 +26,11 @@ import type { JointTemplate } from "../scene/model/gltf/parse-skin.js";
  */
 
 type Jolt = JoltContext["jolt"];
-interface SkinGeo { _cpuSkin?: { positions: Float32Array; joints: Uint32Array; weights: Float32Array } | null; _skinInverseBindMatrices?: Float32Array | null; _skinJointTemplate?: JointTemplate[] }
+interface SkinGeo {
+    cpuSkin?: { positions: Float32Array; joints: Uint32Array; weights: Float32Array } | null;
+    skinInverseBindMatrices?: Float32Array | null;
+    skinJointTemplate?: JointTemplate[];
+}
 
 /** Column-major rigid transform from a position + unit quaternion. */
 const compose = (px: number, py: number, pz: number, q: ArrayLike<number>): Mat4x4 =>
@@ -63,9 +67,9 @@ export const joltRagdoll = Database.Plugin.create({
                 const jointWorld = (j: Entity): Mat4x4 => (db.store.get(j, "_worldMatrix") as Mat4x4 | undefined) ?? Mat4x4.identity;
 
                 const build = (ctx: JoltContext, jointIds: readonly Entity[], g: SkinGeo): void => {
-                    const jolt = ctx.jolt, template = g._skinJointTemplate!;
+                    const jolt = ctx.jolt, template = g.skinJointTemplate!;
                     const caps = new Map<number, { radius: number; halfHeight: number; offPos: readonly number[]; offRot: readonly number[] }>();
-                    for (const c of fitBoneCapsules({ jointCount: jointIds.length, inverseBindMatrices: g._skinInverseBindMatrices!, skin: g._cpuSkin! }))
+                    for (const c of fitBoneCapsules({ jointCount: jointIds.length, inverseBindMatrices: g.skinInverseBindMatrices!, skin: g.cpuSkin! }))
                         caps.set(c.jointIndex, { radius: c.radius, halfHeight: c.halfHeight, offPos: c.offsetPosition, offRot: c.offsetRotation });
 
                     const skel = new jolt.Skeleton();
@@ -123,11 +127,11 @@ export const joltRagdoll = Database.Plugin.create({
                     const ctx = db.store.resources._joltContext;
                     if (!ctx) return;
                     if (!built) {
-                        for (const arch of db.store.queryArchetypes(["_skeletonJoints", "_skeletonGeometry"])) {
-                            const jc = arch.columns._skeletonJoints, gc = arch.columns._skeletonGeometry;
+                        for (const arch of db.store.queryArchetypes(["_skeletonJoints", "_skeletonMesh"])) {
+                            const jc = arch.columns._skeletonJoints, mc = arch.columns._skeletonMesh;
                             for (let i = 0; i < arch.rowCount; i++) {
-                                const g = db.store.read(gc.get(i)) as SkinGeo | null;
-                                if (!g?._cpuSkin || !g._skinInverseBindMatrices || !g._skinJointTemplate?.length) continue;
+                                const g = db.store.read(mc.get(i)) as SkinGeo | null;
+                                if (!g?.cpuSkin || !g.skinInverseBindMatrices || !g.skinJointTemplate?.length) continue;
                                 build(ctx, jc.get(i), g); built = true; break;
                             }
                             if (built) break;

package/src/graphics/rendering/material-palette-gpu/material-palette-gpu-plugin.ts

@@ -0,0 +1,86 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+import { Database } from "@adobe/data/ecs";
+import { U32 } from "@adobe/data/math";
+import { core } from "../../../core/core-plugin.js";
+import { Material } from "../../../material/material.js";
+import {
+    MAX_FACTOR_PALETTE_ENTRIES,
+    PALETTE_STRIDE,
+    materialHasMaps,
+    writePaletteLayer,
+} from "./material-palette.js";
+import { createFactorPaletteBindGroup } from "./palette-bind-group.js";
+
+/** Material rows the factor builder reads (PBR factors only — no map URLs). */
+const FACTOR_MATERIAL_COMPONENTS = [
+    "baseColorFactor", "emissiveFactor", "metallicFactor", "roughnessFactor", "normalScale", "occlusionStrength",
+    "irEmission", "emissionMode",
+    "baseColorUrl", "metallicRoughnessUrl", "normalUrl", "occlusionUrl", "emissiveUrl",
+] as const;
+
+/**
+ * materialPaletteGpu — uploads factor-only materials into a shared palette buffer.
+ * Materials with any map URL are skipped (no map upload path — use factor rows or glTF).
+ * Each factor material gets `_paletteIndex`; no texture arrays are allocated.
+ */
+export const materialPaletteGpu = Database.Plugin.create({
+    extends: Database.Plugin.combine(Material.plugin, core),
+    components: {
+        _paletteIndex: { ...U32.schema, nonPersistent: true },
+    },
+    resources: {
+        _factorPalette: { default: null as GPUBuffer | null, nonPersistent: true },
+        _factorPaletteBindGroup: { default: null as GPUBindGroup | null, nonPersistent: true },
+    },
+    systems: {
+        materialPaletteGpuBuilder: {
+            schedule: { during: ["preRender"] },
+            create: db => {
+                let palette: GPUBuffer | null = null;
+                let nextIndex = 0;
+                return () => {
+                    const { device } = db.store.resources;
+                    if (!device) return;
+
+                    for (const arch of db.store.queryArchetypes(["name", ...FACTOR_MATERIAL_COMPONENTS], { exclude: ["_paletteIndex"] })) {
+                        const c = arch.columns;
+                        for (let i = arch.rowCount - 1; i >= 0; i--) {
+                            const urls = {
+                                baseColorUrl: c.baseColorUrl.get(i),
+                                metallicRoughnessUrl: c.metallicRoughnessUrl.get(i),
+                                normalUrl: c.normalUrl.get(i),
+                                occlusionUrl: c.occlusionUrl.get(i),
+                                emissiveUrl: c.emissiveUrl.get(i),
+                            };
+                            if (materialHasMaps(urls)) continue;
+                            if (nextIndex >= MAX_FACTOR_PALETTE_ENTRIES) break;
+
+                            if (!palette) {
+                                palette = device.createBuffer({
+                                    size: MAX_FACTOR_PALETTE_ENTRIES * PALETTE_STRIDE,
+                                    usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+                                });
+                                db.store.resources._factorPalette = palette;
+                                db.store.resources._factorPaletteBindGroup = createFactorPaletteBindGroup(device, palette);
+                            }
+
+                            const index = nextIndex++;
+                            writePaletteLayer(device, palette, index, {
+                                baseColorFactor: c.baseColorFactor.get(i),
+                                emissiveFactor: c.emissiveFactor.get(i),
+                                metallicFactor: c.metallicFactor.get(i),
+                                roughnessFactor: c.roughnessFactor.get(i),
+                                normalScale: c.normalScale.get(i),
+                                occlusionStrength: c.occlusionStrength.get(i),
+                                irEmission: c.irEmission.get(i),
+                                emissionMode: c.emissionMode.get(i),
+                            });
+                            db.store.update(c.id.get(i), { _paletteIndex: index });
+                        }
+                    }
+                };
+            },
+        },
+    },
+});

package/src/graphics/rendering/material-palette-gpu/material-palette-gpu.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it } from "vitest";
+import { materialHasMaps } from "./material-palette.js";
+
+const emptyUrls = {
+    baseColorUrl: "",
+    metallicRoughnessUrl: "",
+    normalUrl: "",
+    occlusionUrl: "",
+    emissiveUrl: "",
+};
+
+describe("materialHasMaps", () => {
+    it("is false when all URLs are empty", () => {
+        expect(materialHasMaps(emptyUrls)).toBe(false);
+    });
+
+    it("is true when any URL is set", () => {
+        expect(materialHasMaps({ ...emptyUrls, baseColorUrl: "https://example.com/a.jpg" })).toBe(true);
+    });
+});

package/src/graphics/rendering/material-palette-gpu/material-palette.ts

@@ -0,0 +1,41 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+/** Bytes per palette entry: 4 × vec4 (base, emissive/metal, rough/normal/occlusion/ir, emission meta). */
+export const PALETTE_STRIDE = 64;
+
+/** Factor-only materials — palette rows only, no map memory. */
+export const MAX_FACTOR_PALETTE_ENTRIES = 256;
+
+/** Per-material visible factors written into one palette row. */
+export interface MaterialFactors {
+    baseColorFactor: readonly number[];
+    emissiveFactor: readonly number[];
+    metallicFactor: number;
+    roughnessFactor: number;
+    normalScale: number;
+    occlusionStrength: number;
+    irEmission: number;
+    emissionMode: number;
+}
+
+const _palette = new Float32Array(PALETTE_STRIDE / 4);
+
+export function writePaletteLayer(device: GPUDevice, palette: GPUBuffer, index: number, f: MaterialFactors): void {
+    _palette[0] = f.baseColorFactor[0]; _palette[1] = f.baseColorFactor[1]; _palette[2] = f.baseColorFactor[2]; _palette[3] = f.baseColorFactor[3];
+    _palette[4] = f.emissiveFactor[0]; _palette[5] = f.emissiveFactor[1]; _palette[6] = f.emissiveFactor[2]; _palette[7] = f.metallicFactor;
+    _palette[8] = f.roughnessFactor; _palette[9] = f.normalScale; _palette[10] = f.occlusionStrength; _palette[11] = f.irEmission;
+    _palette[12] = f.emissionMode; _palette[13] = 0; _palette[14] = 0; _palette[15] = 0;
+    device.queue.writeBuffer(palette, index * PALETTE_STRIDE, _palette);
+}
+
+/** The five map source URLs for one material ("" = factor-only). */
+export interface MaterialMapUrls {
+    baseColorUrl: string;
+    metallicRoughnessUrl: string;
+    normalUrl: string;
+    occlusionUrl: string;
+    emissiveUrl: string;
+}
+
+export const materialHasMaps = (urls: MaterialMapUrls): boolean =>
+    !!(urls.baseColorUrl || urls.metallicRoughnessUrl || urls.normalUrl || urls.occlusionUrl || urls.emissiveUrl);

package/src/graphics/rendering/material-palette-gpu/palette-bind-group.ts

@@ -0,0 +1,24 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+const layoutByDevice = new WeakMap<GPUDevice, GPUBindGroupLayout>();
+
+/** Bind-group layout for factor PBR: palette storage buffer only (group 1). */
+export function createFactorPaletteBindGroupLayout(device: GPUDevice): GPUBindGroupLayout {
+    let layout = layoutByDevice.get(device);
+    if (!layout) {
+        layout = device.createBindGroupLayout({
+            entries: [
+                { binding: 0, visibility: GPUShaderStage.FRAGMENT, buffer: { type: "read-only-storage" } },
+            ],
+        });
+        layoutByDevice.set(device, layout);
+    }
+    return layout;
+}
+
+export function createFactorPaletteBindGroup(device: GPUDevice, palette: GPUBuffer): GPUBindGroup {
+    return device.createBindGroup({
+        layout: createFactorPaletteBindGroupLayout(device),
+        entries: [{ binding: 0, resource: { buffer: palette } }],
+    });
+}

package/src/graphics/rendering/model-collider-plugin.ts

@@ -7,64 +7,48 @@ import { modelLoader } from "../scene/model/model-loader-plugin.js";
 import { hullVertices } from "../scene/model/shape/convex-hull.js";
 
 /**
- * modelCollider — lets a rendered model double as a physics body whose collider is
- * **auto-generated from its mesh**. A `ModelBody` (or `StaticModelCollider`) carries
- * a `geometry` + a `colliderShape` of `"hull"` or `"mesh"` but *no* collision data;
- * this fills it once the mesh has loaded:
- *
- *   hull → `convexPoints` = the simplified hull vertices of the mesh (the engine
- *          rebuilds the hull) — a coarse, convex stand-in for a detailed model.
- *   mesh → `colliderMesh` = the mesh triangles verbatim (static trimesh).
- *
- * The source defaults to the body's own `geometry` but can be overridden with
- * `collisionGeometry` (point it at a low-poly mesh for a cheaper collider). The
- * model's `scale` is baked into the collision geometry so it matches the render.
- * Generated data is cached per (source geometry, shape, scale), so many instances
- * of one model share it. Authoring the collider by hand (supplying `convexPoints`
- * / `colliderMesh` directly, as `ConvexBody` / `MeshCollider` do) still works and
- * simply skips generation.
- *
- * Because the body already has a `geometry`, the physics render bridge leaves it
- * alone — it renders as the detailed model and collides as the generated shape.
+ * modelCollider — auto-generates physics colliders from loaded mesh CPU data.
  */
 export const modelCollider = Database.Plugin.create({
     extends: Database.Plugin.combine(physicsData, modelLoader),
     components: {
-        collisionGeometry: Entity.schema, // optional override: generate the collider from this Geometry instead of `geometry`
+        collisionMesh: Entity.schema,
     },
     archetypes: {
-        // A model that is also a dynamic/kinematic body; collider auto-generated.
-        ModelBody: ["geometry", "scale", "visible", "parent", "bodyType", "colliderShape", "halfExtents", "material", "position", "rotation", "linearVelocity", "angularVelocity"],
-        // A static model collider (immovable level geometry that renders as a model).
-        StaticModelCollider: ["geometry", "scale", "visible", "parent", "colliderShape", "halfExtents", "material", "position", "rotation"],
+        ModelBody: ["mesh", "scale", "visible", "parent", "bodyType", "colliderShape", "halfExtents", "material", "position", "rotation", "linearVelocity", "angularVelocity"],
+        StaticModelCollider: ["mesh", "scale", "visible", "parent", "colliderShape", "halfExtents", "material", "position", "rotation"],
     },
     systems: {
         generateModelColliders: {
             schedule: { during: ["postUpdate"] },
             create: db => {
-                // generated collider data, shared across instances of the same (source mesh, shape, scale)
                 const cache = new Map<string, { convexPoints: Float32Array } | { colliderMesh: ColliderMesh }>();
                 return () => {
-                    // model-bodies (geometry + scale) whose collider data isn't generated yet
-                    for (const arch of db.store.queryArchetypes(["colliderShape", "geometry", "scale"], { exclude: ["convexPoints", "colliderMesh"] })) {
+                    for (const arch of db.store.queryArchetypes(["colliderShape", "mesh", "scale"], { exclude: ["convexPoints", "colliderMesh"] })) {
                         const ids = arch.columns.id, css = arch.columns.colliderShape, scl = arch.columns.scale;
-                        // tail→head: filling the data migrates the row out of this archetype
                         for (let i = arch.rowCount - 1; i >= 0; i--) {
                             const shape = css.get(i);
-                            if (shape !== "hull" && shape !== "mesh") continue; // primitive-shaped model-bodies need no generation
+                            if (shape !== "hull" && shape !== "mesh") continue;
                             const id = ids.get(i);
-                            const src = (db.store.read(id) as { collisionGeometry?: Entity }).collisionGeometry || arch.columns.geometry.get(i);
-                            const mesh = db.store.read(src) as { _cpuPositions?: Float32Array | null; _cpuIndices?: Uint32Array | null } | null;
-                            const positions = mesh?._cpuPositions;
-                            if (!positions) continue; // source mesh not loaded yet — retry next frame
+                            const src = (db.store.read(id) as { collisionMesh?: Entity }).collisionMesh ?? arch.columns.mesh.get(i);
+                            const asset = db.store.read(src) as {
+                                cpuCollisionPositions?: Float32Array | null;
+                                cpuCollisionIndices?: Uint32Array | null;
+                            } | null;
+                            const positions = asset?.cpuCollisionPositions;
+                            if (!positions) continue;
                             const s = scl.get(i), key = `${src}:${shape}:${s[0]}:${s[1]}:${s[2]}`;
                             let data = cache.get(key);
                             if (!data) {
                                 const scaled = new Float32Array(positions.length);
-                                for (let k = 0; k < positions.length; k += 3) { scaled[k] = positions[k] * s[0]; scaled[k + 1] = positions[k + 1] * s[1]; scaled[k + 2] = positions[k + 2] * s[2]; }
+                                for (let k = 0; k < positions.length; k += 3) {
+                                    scaled[k] = positions[k] * s[0];
+                                    scaled[k + 1] = positions[k + 1] * s[1];
+                                    scaled[k + 2] = positions[k + 2] * s[2];
+                                }
                                 data = shape === "hull"
                                     ? { convexPoints: hullVertices(scaled) }
-                                    : { colliderMesh: { positions: scaled, indices: mesh!._cpuIndices ?? new Uint32Array(0) } };
+                                    : { colliderMesh: { positions: scaled, indices: asset!.cpuCollisionIndices ?? new Uint32Array(0) } };
                                 cache.set(key, data);
                             }
                             db.store.update(id, data);

package/src/graphics/rendering/pbr-core-plugin.ts

@@ -5,36 +5,33 @@ import { Mat4x4 } from "@adobe/data/math";
 import { U32 } from "@adobe/data/math";
 
 /**
- * Shape declarations shared between asset producers (model loader, shape
- * generators) and consumers (renderers). Every component and archetype is
- * ephemeral — not part of the user's data model. Pair with an asset
- * producer plus a renderer aggregator (`pbrIblRender`)
- * to get drawable scenes.
+ * Ephemeral GPU mesh payloads shared between asset producers (glTF loader,
+ * shape baker) and renderers. Not part of the authored asset model.
  */
 export const pbrCore = Database.Plugin.create({
     components: {
-        _vertexBuffer:                  { default: null as GPUBuffer | null },
+        _vertexBuffer:                  { default: null as GPUBuffer | null, nonPersistent: true },
         /** Secondary VBO with skinning attributes (joints u32×4, weights f32×4),
          *  null for static primitives. Drives skinned-pipeline dispatch. */
-        _skinVertexBuffer:              { default: null as GPUBuffer | null },
-        _indexBuffer:                   { default: null as GPUBuffer | null },
-        _indexCount:                    U32.schema,
-        _indexFormat:                   { default: "uint16" as GPUIndexFormat },
-        _materialBindGroup:             { default: null as GPUBindGroup | null },
+        _skinVertexBuffer:              { default: null as GPUBuffer | null, nonPersistent: true },
+        _indexBuffer:                   { default: null as GPUBuffer | null, nonPersistent: true },
+        _indexCount:                    { ...U32.schema, nonPersistent: true },
+        _indexFormat:                   { default: "uint16" as GPUIndexFormat, nonPersistent: true },
+        _materialBindGroup:             { default: null as GPUBindGroup | null, nonPersistent: true },
         /** Back-reference from a _PbrPrimitive / _VisibleMaterial to the
-         *  authored Geometry that owns it. */
-        _geometry:                      Entity.schema,
-        _material:                      Entity.schema,
+         *  baked mesh asset that owns it. */
+        _mesh:                          { ...Entity.schema, nonPersistent: true },
+        _material:                      { ...Entity.schema, nonPersistent: true },
         /** Node-local-to-model-root matrix baked at load time. The renderer
          *  pre-multiplies it with the per-instance model-root world matrix. */
-        _nodeLocalMatrix:               Mat4x4.schema,
+        _nodeLocalMatrix:               { ...Mat4x4.schema, nonPersistent: true },
         /** Skeleton-side back-references the renderer reads when dispatching
          *  the skinned pipeline. Populated by `pbrSkinning`. */
-        _skeletonModelRef:              Entity.schema,
-        _skeletonJointMatrixBindGroup:  { default: null as GPUBindGroup | null },
+        _skeletonModelRef:              { ...Entity.schema, nonPersistent: true },
+        _skeletonJointMatrixBindGroup:  { default: null as GPUBindGroup | null, nonPersistent: true },
     },
     archetypes: {
-        _VisibleMaterial: ["ephemeral", "_materialBindGroup", "_geometry"],
-        _PbrPrimitive: ["ephemeral", "_vertexBuffer", "_skinVertexBuffer", "_indexBuffer", "_indexCount", "_indexFormat", "_material", "_geometry", "_nodeLocalMatrix"],
+        _VisibleMaterial: ["nonPersistent", "_materialBindGroup", "_mesh"],
+        _PbrPrimitive: ["nonPersistent", "_vertexBuffer", "_skinVertexBuffer", "_indexBuffer", "_indexCount", "_indexFormat", "_material", "_mesh", "_nodeLocalMatrix"],
     },
 });