@adobe/data-gpu 0.9.75 → 0.9.76

package/src/graphics/rendering/pbr-render/primitive-render-shared.ts

@@ -0,0 +1,76 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+import type { Entity } from "@adobe/data/ecs";
+
+/** Must match `pbrIblRender` IBL bake mip count. */
+export const PREFILTERED_MIP_COUNT = 7;
+
+/** Drawable: visible entity with mesh ref, transform, and material. */
+export const DRAWABLE = ["mesh", "visible", "position", "rotation", "scale", "material"] as const;
+export const DRAWABLE_INTERP = [...DRAWABLE, "_renderPosition", "_renderRotation"] as const;
+export const DRAWABLE_DIRECT = { exclude: ["_renderPosition"] } as const;
+export const PRIMITIVE = ["_vertexBuffer", "_indexBuffer", "_indexCount", "_indexFormat", "_mesh", "_nodeLocalMatrix"] as const;
+
+/** Minimal column shape the gather reads — satisfied by either query's columns. */
+export interface ColumnReader<T> { get(i: number): T }
+
+export 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" } },
+        ],
+    });
+}
+
+/** Compose column-major TRS into `out[o..o+15]`. */
+export 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;
+}
+
+export interface MeshBatch {
+    off: number[];
+    materialIndex: number[];
+}
+
+/** @deprecated Use `MeshBatch`. */
+export type GeometryBatch = MeshBatch;
+
+export interface InstancedDrawCache {
+    buffer: GPUBuffer;
+    indexBuffer: GPUBuffer;
+    bindGroup: GPUBindGroup;
+    capacity: number;
+}
+
+/** Refresh material entity → GPU index map when the tagged material set grows. */
+export function refreshMaterialIndexMap(
+    db: { store: { queryArchetypes: (cols: string[]) => Iterable<{ rowCount: number; columns: { id: ColumnReader<Entity>; [k: string]: ColumnReader<number> } }> } },
+    indexColumn: string,
+    matCount: { value: number },
+    matIndex: Map<Entity, number>,
+): void {
+    let mc = 0;
+    for (const arch of db.store.queryArchetypes([indexColumn])) mc += arch.rowCount;
+    if (mc === matCount.value) return;
+    matIndex.clear();
+    for (const arch of db.store.queryArchetypes([indexColumn])) {
+        const id = arch.columns.id;
+        const col = arch.columns[indexColumn];
+        for (let i = 0; i < arch.rowCount; i++) matIndex.set(id.get(i), col.get(i));
+    }
+    matCount.value = mc;
+}

package/src/graphics/rendering/skinning/skinning-plugin.ts

@@ -9,36 +9,21 @@ import { animation } from "../../animation/animation-plugin.js";
 import type { JointTemplate } from "../../scene/model/gltf/parse-skin.js";
 
 /**
- * pbrSkinning
- *   query: Model+geometry, _Skeleton
- *   read:
- *     geometry
- *     _skinJointTemplate          (from Geometry)
- *     _skinInverseBindMatrices    (from Geometry)
- *     _animationClipRefs          (from Geometry)
- *     _worldMatrix                (from Model + joint Nodes)
- *   write:
- *     _Skeleton                   // new ephemeral entity, one per skinned Model
- *     Node                        // joint entities (TRS hierarchy)
- *     Animation                   // optional, when geometry has clips
- *     _skeletonInstanceBuffer
- *     _skeletonJointMatrixBuffer
- *     _skeletonJointMatrixBindGroup
+ * pbrSkinning — builds a `_Skeleton` for each `Model` whose `mesh` is a
+ * `SkinnedMesh` (non-empty `skinJointTemplate`).
  */
 export const pbrSkinning = Database.Plugin.create({
     extends: Database.Plugin.combine(modelLoader, pbrCore, transform, animation),
     components: {
-        _skeletonJoints:                  { default: [] as number[] },
-        _skeletonGeometry:                Entity.schema,
-        /** 64 bytes — the Model's world matrix, refreshed each frame. */
-        _skeletonInstanceBuffer:          { default: null as GPUBuffer | null },
-        /** N × 64 bytes — joint skinning matrices, refreshed each frame. */
-        _skeletonJointMatrixBuffer:       { default: null as GPUBuffer | null },
+        _skeletonJoints:                  { default: [] as number[], nonPersistent: true },
+        _skeletonMesh:                    { ...Entity.schema, nonPersistent: true },
+        _skeletonInstanceBuffer:          { default: null as GPUBuffer | null, nonPersistent: true },
+        _skeletonJointMatrixBuffer:       { default: null as GPUBuffer | null, nonPersistent: true },
     },
     archetypes: {
         _Skeleton: [
             "_skeletonJoints",
-            "_skeletonGeometry",
+            "_skeletonMesh",
             "_skeletonModelRef",
             "_skeletonInstanceBuffer",
             "_skeletonJointMatrixBuffer",
@@ -48,7 +33,7 @@ export const pbrSkinning = Database.Plugin.create({
     transactions: {
         initSkeleton(t, args: {
             modelRef: number;
-            geometryRef: number;
+            meshRef: number;
             jointTemplate: readonly JointTemplate[];
             instanceBuffer: GPUBuffer;
             jointMatrixBuffer: GPUBuffer;
@@ -56,9 +41,6 @@ export const pbrSkinning = Database.Plugin.create({
             clipRef: number | null;
         }) {
             const jointIds: number[] = new Array(args.jointTemplate.length);
-            // jointTemplate is in glTF skin.joints[] order. Parents can come
-            // after children in glTF, so resolve parent entity ids in two passes:
-            // first insert with parent=0, then update each joint's parent.
             for (let i = 0; i < args.jointTemplate.length; i++) {
                 const j = args.jointTemplate[i];
                 jointIds[i] = t.archetypes.Node.insert({
@@ -76,7 +58,7 @@ export const pbrSkinning = Database.Plugin.create({
             }
             t.archetypes._Skeleton.insert({
                 _skeletonJoints: jointIds,
-                _skeletonGeometry: args.geometryRef,
+                _skeletonMesh: args.meshRef,
                 _skeletonModelRef: args.modelRef,
                 _skeletonInstanceBuffer: args.instanceBuffer,
                 _skeletonJointMatrixBuffer: args.jointMatrixBuffer,
@@ -110,15 +92,18 @@ export const pbrSkinning = Database.Plugin.create({
                             ],
                         });
                     }
-                    for (const arch of db.store.queryArchetypes(["geometry"])) {
+                    for (const arch of db.store.queryArchetypes(["mesh"])) {
                         const ids = arch.columns.id;
-                        const geoRefs = arch.columns.geometry;
+                        const meshRefs = arch.columns.mesh;
                         for (let i = 0; i < arch.rowCount; i++) {
                             const modelId = ids.get(i);
                             if (initialized.has(modelId)) continue;
-                            const geoId = geoRefs.get(i);
-                            const geo = db.store.read(geoId);
-                            const template = geo?._skinJointTemplate;
+                            const meshId = meshRefs.get(i);
+                            const asset = db.store.read(meshId) as {
+                                skinJointTemplate?: JointTemplate[];
+                                animationClipRefs?: number[];
+                            } | null;
+                            const template = asset?.skinJointTemplate;
                             if (!template || template.length === 0) continue;
                             initialized.add(modelId);
 
@@ -139,12 +124,12 @@ export const pbrSkinning = Database.Plugin.create({
                             });
                             db.transactions.initSkeleton({
                                 modelRef: modelId,
-                                geometryRef: geoId,
+                                meshRef: meshId,
                                 jointTemplate: template,
                                 instanceBuffer,
                                 jointMatrixBuffer: matrixBuffer,
                                 jointMatrixBindGroup: matrixBindGroup,
-                                clipRef: geo?._animationClipRefs?.[0] ?? null,
+                                clipRef: asset?.animationClipRefs?.[0] ?? null,
                             });
                         }
                     }
@@ -160,29 +145,28 @@ export const pbrSkinning = Database.Plugin.create({
                     if (!device) return;
                     for (const arch of db.store.queryArchetypes([
                         "_skeletonJoints",
-                        "_skeletonGeometry",
+                        "_skeletonMesh",
                         "_skeletonModelRef",
                         "_skeletonInstanceBuffer",
                         "_skeletonJointMatrixBuffer",
                     ])) {
                         const jointsCol = arch.columns._skeletonJoints;
-                        const geoCol = arch.columns._skeletonGeometry;
+                        const meshCol = arch.columns._skeletonMesh;
                         const modelCol = arch.columns._skeletonModelRef;
                         const instBufCol = arch.columns._skeletonInstanceBuffer;
                         const bufCol = arch.columns._skeletonJointMatrixBuffer;
                         for (let i = 0; i < arch.rowCount; i++) {
                             const joints = jointsCol.get(i);
-                            const geoId = geoCol.get(i);
+                            const meshId = meshCol.get(i);
                             const modelId = modelCol.get(i);
                             const instanceBuffer = instBufCol.get(i);
                             const buffer = bufCol.get(i);
                             if (!buffer || !instanceBuffer) continue;
-                            const ibm = db.store.get(geoId, "_skinInverseBindMatrices");
+                            const ibm = db.store.get(meshId, "skinInverseBindMatrices") as Float32Array | null;
                             if (!ibm) continue;
                             const modelWorld = db.store.get(modelId, "_worldMatrix");
                             if (!modelWorld) continue;
 
-                            // The vertex shader's `instances[0]` slot.
                             device.queue.writeBuffer(instanceBuffer, 0, new Float32Array(modelWorld));
 
                             const invModelWorld = Mat4x4.inverse(modelWorld);
@@ -191,8 +175,6 @@ export const pbrSkinning = Database.Plugin.create({
                             }
                             for (let j = 0; j < joints.length; j++) {
                                 const jw = db.store.get(joints[j], "_worldMatrix") ?? Mat4x4.identity;
-                                // inverse(modelWorld) × jointWorld × IBM — leaves vertices in
-                                // model-local space; vertex shader applies modelWorld separately.
                                 const ibmJoint: Mat4x4 = [
                                     ibm[j * 16 + 0],  ibm[j * 16 + 1],  ibm[j * 16 + 2],  ibm[j * 16 + 3],
                                     ibm[j * 16 + 4],  ibm[j * 16 + 5],  ibm[j * 16 + 6],  ibm[j * 16 + 7],

package/src/graphics/scene/model/geometry/public.ts

@@ -1,4 +1,4 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
-// Reserved for future Geometry helpers (e.g. bounds queries).
+/** @deprecated Use `mesh/mesh.ts`. */
 export {};

package/src/graphics/scene/model/mesh/mesh.ts

@@ -0,0 +1,18 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+import type { Aabb } from "@adobe/data/math";
+import type { JointTemplate } from "../gltf/parse-skin.js";
+
+/** Baked static mesh asset — local-space bounds only. */
+export interface StaticMesh {
+    localBounds: Aabb;
+}
+
+/** Baked skinned mesh asset — static capabilities plus skeleton/animation data. */
+export interface SkinnedMesh extends StaticMesh {
+    skinJointTemplate: JointTemplate[];
+    skinInverseBindMatrices: Float32Array | null;
+    animationClipRefs: number[];
+}
+
+export * as Mesh from "./public.js";

package/src/graphics/scene/model/mesh/public.ts

@@ -0,0 +1,3 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+export { mesh as plugin } from "../mesh-plugin.js";

package/src/graphics/scene/model/mesh-plugin.ts

@@ -0,0 +1,102 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+import { Database, Entity } from "@adobe/data/ecs";
+import { Aabb, Quat, type Vec3 } from "@adobe/data/math";
+import { Node } from "../node/node.js";
+import { plugin as Material } from "../../../material/material-plugin.js";
+import type { ShapeSpec } from "./shape/shape-spec.js";
+import type { JointTemplate } from "./gltf/parse-skin.js";
+
+/**
+ * Mesh asset model — separates mesh **intent** (pending import), **asset**
+ * (static or skinned capabilities), and **instance** (placed drawables).
+ *
+ * - `GltfMeshPending` / `ShapeMeshPending` — work queue; the entity id is the
+ *   stable mesh handle instances can reference before GPU data exists.
+ * - `StaticMesh` / `SkinnedMesh` — baked assets with capability components.
+ * - `Model` — hierarchical instance (glTF / scene graph).
+ * - `MeshInstance` — render-only instance with a material (factor path).
+ */
+export const mesh = Database.Plugin.create({
+    extends: Database.Plugin.combine(Node.plugin, Material),
+    components: {
+        /** Instance → baked mesh asset entity. */
+        mesh: Entity.schema,
+        /** Pending glTF import — cleared when the row migrates to Static/SkinnedMesh. */
+        gltfUrl: { type: "string" },
+        /** Pending procedural import — cleared when baked to StaticMesh. */
+        shapeSpec: { default: null as ShapeSpec | null },
+        /** Optional grid dimensions on baked mesh assets (used by extensions for scale). */
+        voxelVolumeSize: { default: null as Vec3 | null },
+        /** Asset-space axis-aligned bounds (all baked meshes). */
+        localBounds: { default: null as Aabb | null },
+        /** Skinned-mesh capabilities (SkinnedMesh archetype). */
+        skinJointTemplate: { default: [] as JointTemplate[] },
+        skinInverseBindMatrices: { default: null as Float32Array | null },
+        animationClipRefs: { default: [] as number[] },
+        /** CPU-retained collision source for auto-collider generation. */
+        cpuCollisionPositions: { default: null as Float32Array | null },
+        cpuCollisionIndices: { default: null as Uint32Array | null },
+        /** CPU-retained skin bind data for ragdoll capsule fitting. */
+        cpuSkin: { default: null as { positions: Float32Array; joints: Uint32Array; weights: Float32Array } | null },
+    },
+    resources: {
+        _gltfMeshByUrl: { default: null as Map<string, Entity> | null, nonPersistent: true },
+    },
+    archetypes: {
+        GltfMeshPending:  ["gltfUrl"],
+        ShapeMeshPending: ["shapeSpec"],
+        StaticMesh:       ["localBounds"],
+        SkinnedMesh:      ["localBounds", "skinJointTemplate", "skinInverseBindMatrices", "animationClipRefs"],
+        MeshInstance:     ["mesh", "position", "rotation", "scale", "visible", "material"],
+        Model:            ["mesh", "position", "rotation", "scale", "visible", "parent"],
+    },
+    transactions: {
+        insertGltfMesh(t, args: { url: string }): Entity {
+            const map = t.resources._gltfMeshByUrl ??= new Map();
+            const existing = map.get(args.url);
+            if (existing != null) return existing;
+            const id = t.archetypes.GltfMeshPending.insert({ gltfUrl: args.url });
+            map.set(args.url, id);
+            return id;
+        },
+        insertShapeMesh(t, args: { shapeSpec: ShapeSpec }): Entity {
+            return t.archetypes.ShapeMeshPending.insert({ shapeSpec: args.shapeSpec });
+        },
+        insertMeshInstance(t, args: {
+            mesh: Entity;
+            material: Entity;
+            position?: Vec3;
+            rotation?: Quat;
+            scale?: Vec3;
+        }): Entity {
+            return t.archetypes.MeshInstance.insert({
+                mesh:     args.mesh,
+                material: args.material,
+                position: args.position ?? [0, 0, 0],
+                rotation: args.rotation ?? Quat.identity,
+                scale:    args.scale    ?? [1, 1, 1],
+                visible:  true,
+            });
+        },
+        insertModel(t, args: {
+            mesh: Entity;
+            position?: Vec3;
+            rotation?: Quat;
+            scale?: Vec3;
+            parent?: Entity;
+        }): Entity {
+            return t.archetypes.Model.insert({
+                mesh:     args.mesh,
+                position: args.position ?? [0, 0, 0],
+                rotation: args.rotation ?? Quat.identity,
+                scale:    args.scale    ?? [1, 1, 1],
+                visible:  true,
+                parent:   args.parent   ?? 0,
+            });
+        },
+    },
+});
+
+/** @deprecated Use `mesh` — kept for scene combiner import path. */
+export const model = mesh;

package/src/graphics/scene/model/model-loader-plugin.ts

@@ -5,13 +5,13 @@ import type { Aabb } from "@adobe/data/math";
 import { pbrCore } from "../../rendering/pbr-core-plugin.js";
 import { animation } from "../../animation/animation-plugin.js";
 import { core } from "../../../core/core-plugin.js";
-import { Model } from "./model.js";
+import { mesh } from "./mesh-plugin.js";
 import { loadGltfPrimitives, type GpuPrimitiveData } from "./gltf/load-gltf-model.js";
 import type { LoadedAnimation } from "./gltf/parse-animations.js";
 import type { JointTemplate } from "./gltf/parse-skin.js";
 
 export interface LoadedArgs {
-    geometry: number;
+    mesh: number;
     bounds: Aabb;
     primitives: GpuPrimitiveData[];
     skinJointTemplate: JointTemplate[];
@@ -22,44 +22,23 @@ export interface LoadedArgs {
 }
 
 /**
- * modelLoader
- *   query: Geometry-_bounds
- *   read:
- *     modelUrl
- *   write:
- *     _bounds: Aabb
- *     _skinJointTemplate: JointTemplate[]
- *     _skinInverseBindMatrices: Float32Array | null
- *     _animationClipRefs: EntityId[]
- *     _VisibleMaterial
- *     _PbrPrimitive
- *     AnimationClip                       // when the glTF carries animations
+ * modelLoader — queries `GltfMeshPending`, fetches each `gltfUrl`, inserts
+ * `_PbrPrimitive` rows, and migrates the mesh entity to `StaticMesh` or
+ * `SkinnedMesh` with capability components.
  */
 export const modelLoader = Database.Plugin.create({
-    extends: Database.Plugin.combine(pbrCore, Model.plugin, core, animation),
-    components: {
-        _bounds: { default: null as Aabb | null },
-        _skinJointTemplate: { default: [] as JointTemplate[] },
-        _skinInverseBindMatrices: { default: null as Float32Array | null },
-        _animationClipRefs: { default: [] as number[] },
-        // CPU-retained model-space collision geometry (auto-collider source).
-        _cpuPositions: { default: null as Float32Array | null },
-        _cpuIndices: { default: null as Uint32Array | null },
-        // CPU-retained skin (mesh-bind positions + 4 joints + 4 weights per vertex),
-        // for fitting per-bone ragdoll capsules.
-        _cpuSkin: { default: null as { positions: Float32Array; joints: Uint32Array; weights: Float32Array } | null },
-    },
+    extends: Database.Plugin.combine(pbrCore, mesh, core, animation),
     transactions: {
         insertLoadedPrimitives(t, args: LoadedArgs) {
             for (const p of args.primitives) {
                 const materialId = t.archetypes._VisibleMaterial.insert({
-                    ephemeral: true,
+                    nonPersistent: true,
                     _materialBindGroup: p.pbrMaterialBindGroup,
-                    _geometry: args.geometry,
+                    _mesh: args.mesh,
                 });
                 t.archetypes._PbrPrimitive.insert({
-                    ephemeral: true,
-                    _geometry: args.geometry,
+                    nonPersistent: true,
+                    _mesh: args.mesh,
                     _material: materialId,
                     _vertexBuffer: p.pbrVertexBuffer,
                     _skinVertexBuffer: p.pbrSkinVertexBuffer,
@@ -78,14 +57,17 @@ export const modelLoader = Database.Plugin.create({
                 });
                 clipRefs.push(clipId);
             }
-            t.update(args.geometry, {
-                _bounds: args.bounds,
-                _skinJointTemplate: args.skinJointTemplate,
-                _skinInverseBindMatrices: args.skinInverseBindMatrices,
-                _animationClipRefs: clipRefs,
-                _cpuPositions: args.collision?.positions ?? null,
-                _cpuIndices: args.collision?.indices ?? null,
-                _cpuSkin: args.skinVertices,
+            const skinned = args.skinJointTemplate.length > 0;
+            t.update(args.mesh, {
+                localBounds: args.bounds,
+                cpuCollisionPositions: args.collision?.positions ?? null,
+                cpuCollisionIndices: args.collision?.indices ?? null,
+                cpuSkin: args.skinVertices,
+                ...(skinned ? {
+                    skinJointTemplate: args.skinJointTemplate,
+                    skinInverseBindMatrices: args.skinInverseBindMatrices,
+                    animationClipRefs: clipRefs,
+                } : {}),
             });
         },
     },
@@ -96,19 +78,19 @@ export const modelLoader = Database.Plugin.create({
                 return () => {
                     const { device } = db.store.resources;
                     if (!device) return;
-                    for (const arch of db.store.queryArchetypes(["modelUrl"])) {
+                    for (const arch of db.store.queryArchetypes(["gltfUrl"])) {
                         const ids = arch.columns.id;
-                        const urls = arch.columns.modelUrl;
+                        const urls = arch.columns.gltfUrl;
                         for (let i = 0; i < arch.rowCount; i++) {
                             const id = ids.get(i);
                             if (inFlight.has(id)) continue;
                             const url = urls.get(i);
-                            if (!url) continue;   // procedural geometries (shapes) carry no URL
+                            if (!url) continue;
                             inFlight.add(id);
                             loadGltfPrimitives(device, url)
                                 .then(loaded => {
                                     db.transactions.insertLoadedPrimitives({
-                                        geometry: id,
+                                        mesh: id,
                                         bounds: loaded.bounds,
                                         primitives: loaded.primitives,
                                         skinJointTemplate: loaded.skin?.jointTemplate ?? [],

package/src/graphics/scene/model/model-plugin.ts

@@ -1,46 +1,3 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
-import { Database, Entity } from "@adobe/data/ecs";
-import { Quat, type Vec3 } from "@adobe/data/math";
-import { Node } from "../node/node.js";
-
-/**
- * Authored renderable scene. A `Geometry` is an asset identified by URL; a
- * `Model` is a placed instance of a Geometry — a Node plus a reference to
- * the Geometry it draws.
- *
- * Loading is performed by `modelLoader`, which reads the `modelUrl` and
- * produces the GPU primitives the renderers consume.
- */
-export const model = Database.Plugin.create({
-    extends: Node.plugin,
-    components: {
-        modelUrl: { type: "string" },
-        geometry: Entity.schema,
-    },
-    archetypes: {
-        Geometry: ["modelUrl"],
-        Model:    ["geometry", "position", "rotation", "scale", "visible", "parent"],
-    },
-    transactions: {
-        insertGeometry(t, args: { modelUrl: string }): number {
-            return t.archetypes.Geometry.insert({ modelUrl: args.modelUrl });
-        },
-        insertModel(t, args: {
-            geometry: number;
-            position?: Vec3;
-            rotation?: Quat;
-            scale?: Vec3;
-            parent?: number;
-        }): number {
-            return t.archetypes.Model.insert({
-                geometry: args.geometry,
-                position: args.position ?? [0, 0, 0],
-                rotation: args.rotation ?? Quat.identity,
-                scale:    args.scale    ?? [1, 1, 1],
-                visible:  true,
-                parent:   args.parent   ?? 0,
-            });
-        },
-    },
-});
+export { mesh as model } from "./mesh-plugin.js";

package/src/graphics/scene/model/model.ts

@@ -3,13 +3,9 @@
 import type { Entity } from "@adobe/data/ecs";
 import type { Node } from "../node/node.js";
 
-/**
- * One row of the `Model` archetype — a placed instance of a Geometry. A
- * Node (transform + visibility + parent) plus a reference to the Geometry
- * the renderer should draw.
- */
+/** One row of the `Model` archetype — a placed instance of a mesh asset. */
 export interface Model extends Node {
-    geometry: Entity;
+    mesh: Entity;
 }
 
 export * as Model from "./public.js";

package/src/graphics/scene/model/public.ts

@@ -1 +1,3 @@
-export { model as plugin } from "./model-plugin.js";
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+export { mesh as plugin } from "./mesh-plugin.js";

package/src/graphics/scene/model/shape/bounds-from-shape-mesh.ts

@@ -0,0 +1,20 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+import type { Aabb } from "@adobe/data/math";
+import type { ShapeMesh } from "./shape-mesh.js";
+
+const FLOATS_PER_VERTEX = 12;
+
+/** Axis-aligned bounds of packed StandardVertex positions in a shape mesh. */
+export const boundsFromShapeMesh = (mesh: ShapeMesh): Aabb => {
+    const v = mesh.vertices;
+    let minX = Infinity, minY = Infinity, minZ = Infinity;
+    let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
+    for (let i = 0; i < v.length; i += FLOATS_PER_VERTEX) {
+        const x = v[i], y = v[i + 1], z = v[i + 2];
+        if (x < minX) minX = x; if (x > maxX) maxX = x;
+        if (y < minY) minY = y; if (y > maxY) maxY = y;
+        if (z < minZ) minZ = z; if (z > maxZ) maxZ = z;
+    }
+    return { min: [minX, minY, minZ], max: [maxX, maxY, maxZ] };
+};