@adobe/data-gpu 0.9.75 → 0.9.76

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

@@ -1,33 +1,45 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
 import { Database, type Entity } from "@adobe/data/ecs";
+import type { Aabb } from "@adobe/data/math";
 import { Mat4x4 } from "@adobe/data/math";
 import { pbrCore } from "../../../rendering/pbr-core-plugin.js";
 import { core } from "../../../../core/core-plugin.js";
-import { model } from "../model-plugin.js";
+import { mesh } from "../mesh-plugin.js";
 import { unitSphere, unitCube } from "./shape-mesh.js";
 import { uploadShapeMesh } from "./upload-shape-mesh.js";
+import { boundsFromShapeMesh } from "./bounds-from-shape-mesh.js";
+import { capsuleMesh, flatShadedMesh } from "./shape-mesh.js";
+import { convexHullMesh } from "./convex-hull.js";
+import type { ShapeSpec } from "./shape-spec.js";
 
 /**
- * shapeGeometry — registers procedural unit-sphere and unit-cube geometries as
- * `Geometry` + `_PbrPrimitive` entities (StandardVertex layout), exactly like
- * the model loader does for glTF, so primitives and loaded models share one
- * render path. The two geometry entity ids are published in `_shapeGeometry`
- * for the physics render bridge to reference (sphere / cuboid bodies). Built
- * once when the device is ready.
+ * shapeGeometry — bakes built-in procedural meshes into `StaticMesh` + `_PbrPrimitive`
+ * (StandardVertex layout). Registers shared unit sphere/cube at init; provides
+ * `insertStaticMeshPrimitive` for direct bakes (capsule/hull caches, extensions, etc.).
  */
 export const shapeGeometry = Database.Plugin.create({
-    extends: Database.Plugin.combine(pbrCore, model, core),
+    imports: Database.Plugin.combine(pbrCore, mesh),
+    extends: core,
     resources: {
-        _shapeGeometry: { default: null as { sphere: Entity; cube: Entity } | null, nonPersistent: true },
+        _shapeMeshes: { default: null as { sphere: Entity; cube: Entity } | null, nonPersistent: true },
     },
     transactions: {
-        insertShapePrimitive(t, args: { vertexBuffer: GPUBuffer; indexBuffer: GPUBuffer; indexCount: number }): Entity {
-            const geometry = t.archetypes.Geometry.insert({ modelUrl: "" });
+        insertStaticMeshPrimitive(t, args: {
+            mesh?: Entity;
+            vertexBuffer: GPUBuffer;
+            indexBuffer: GPUBuffer;
+            indexCount: number;
+            localBounds: Aabb;
+        }): Entity {
+            const meshId = args.mesh ?? t.archetypes.StaticMesh.insert({ localBounds: args.localBounds });
+            if (args.mesh !== undefined) {
+                t.update(args.mesh, { localBounds: args.localBounds });
+            }
             t.archetypes._PbrPrimitive.insert({
-                ephemeral: true,
-                _geometry: geometry,
-                _material: 0,                 // primitives carry material per-instance, not here
+                nonPersistent: true,
+                _mesh: meshId,
+                _material: 0,
                 _vertexBuffer: args.vertexBuffer,
                 _skinVertexBuffer: null,
                 _indexBuffer: args.indexBuffer,
@@ -35,7 +47,7 @@ export const shapeGeometry = Database.Plugin.create({
                 _indexFormat: "uint16",
                 _nodeLocalMatrix: Mat4x4.identity,
             });
-            return geometry;
+            return meshId;
         },
     },
     systems: {
@@ -50,12 +62,79 @@ export const shapeGeometry = Database.Plugin.create({
 
                     const s = uploadShapeMesh(device, unitSphere());
                     const c = uploadShapeMesh(device, unitCube());
-                    const sphere = db.transactions.insertShapePrimitive({ vertexBuffer: s.vb, indexBuffer: s.ib, indexCount: s.count });
-                    const cube = db.transactions.insertShapePrimitive({ vertexBuffer: c.vb, indexBuffer: c.ib, indexCount: c.count });
-                    db.store.resources._shapeGeometry = { sphere, cube };
+                    const sphere = db.transactions.insertStaticMeshPrimitive({
+                        vertexBuffer: s.vb, indexBuffer: s.ib, indexCount: s.count,
+                        localBounds: boundsFromShapeMesh(unitSphere()),
+                    });
+                    const cube = db.transactions.insertStaticMeshPrimitive({
+                        vertexBuffer: c.vb, indexBuffer: c.ib, indexCount: c.count,
+                        localBounds: boundsFromShapeMesh(unitCube()),
+                    });
+                    db.store.resources._shapeMeshes = { sphere, cube };
                     done = true;
                 };
             },
         },
+        shapeMeshBake: {
+            schedule: { during: ["preUpdate"], after: ["shapeGeometryInit"] },
+            create: db => {
+                const bake = (spec: ShapeSpec): {
+                    vb: GPUBuffer;
+                    ib: GPUBuffer;
+                    count: number;
+                    localBounds: Aabb;
+                } | null => {
+                    const { device } = db.store.resources;
+                    if (!device) return null;
+                    if (spec.kind === "unitSphere") {
+                        const data = unitSphere();
+                        const gpu = uploadShapeMesh(device, data);
+                        return { ...gpu, localBounds: boundsFromShapeMesh(data) };
+                    }
+                    if (spec.kind === "unitBox") {
+                        const data = unitCube();
+                        const gpu = uploadShapeMesh(device, data);
+                        return { ...gpu, localBounds: boundsFromShapeMesh(data) };
+                    }
+                    if (spec.kind === "capsule") {
+                        const data = capsuleMesh(spec.radius, spec.halfHeight);
+                        const gpu = uploadShapeMesh(device, data);
+                        return { ...gpu, localBounds: boundsFromShapeMesh(data) };
+                    }
+                    if (spec.kind === "convexHull") {
+                        const data = convexHullMesh(spec.points);
+                        const gpu = uploadShapeMesh(device, data);
+                        return { ...gpu, localBounds: boundsFromShapeMesh(data) };
+                    }
+                    if (spec.kind === "triMesh") {
+                        const data = flatShadedMesh(spec.positions, spec.indices);
+                        const gpu = uploadShapeMesh(device, data);
+                        return { ...gpu, localBounds: boundsFromShapeMesh(data) };
+                    }
+                    return null;
+                };
+                return () => {
+                    for (const arch of db.store.queryArchetypes(["shapeSpec"])) {
+                        const ids = arch.columns.id;
+                        const specs = arch.columns.shapeSpec;
+                        for (let i = arch.rowCount - 1; i >= 0; i--) {
+                            const spec = specs.get(i);
+                            if (!spec) continue;
+                            const meshId = ids.get(i);
+                            const baked = bake(spec);
+                            if (!baked) continue;
+                            db.transactions.insertStaticMeshPrimitive({
+                                mesh: meshId,
+                                vertexBuffer: baked.vb,
+                                indexBuffer: baked.ib,
+                                indexCount: baked.count,
+                                localBounds: baked.localBounds,
+                            });
+                            db.store.update(meshId, { shapeSpec: null });
+                        }
+                    }
+                };
+            },
+        },
     },
 });

package/src/graphics/scene/model/shape/shape-spec.ts

@@ -0,0 +1,9 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+/** Authored procedural mesh intent — consumed by the shape baker, not the renderer. */
+export type ShapeSpec =
+    | { kind: "unitSphere" }
+    | { kind: "unitBox" }
+    | { kind: "capsule"; radius: number; halfHeight: number }
+    | { kind: "convexHull"; points: Float32Array }
+    | { kind: "triMesh"; positions: Float32Array; indices: Uint32Array };

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

@@ -6,25 +6,8 @@ import { transform } from "../node/transform-plugin.js";
 import { modelLoader } from "./model-loader-plugin.js";
 
 /**
- * worldBoundsCreate
- *   query: Model-_worldBounds
- *   write: _worldBounds   (archetype migration; unit placeholder)
- *
- *   Adds the `_worldBounds` column to any Model that doesn't have it yet, so
- *   `worldBoundsSystem` can write directly without further migration.
- *
- * worldBoundsSystem
- *   query: Model+_worldMatrix+_worldBounds
- *   read:  geometry → _bounds, _worldMatrix
- *   write: _worldBounds
- *
- *   Transforms the asset-space AABB on each Model's `geometry` by the Model's
- *   `_worldMatrix` (all 8 corners, reduce to min/max) and writes the result.
- *   Geometries still loading have no `_bounds` yet — those Models are skipped
- *   until the asset finishes; their `_worldBounds` stays at its placeholder.
- *
- *   Cost: one matrix-vec multiply × 8 corners × N visible Models, per frame.
- *   At N=1000 that's ~8K vec3 ops; well under 0.1ms on modern CPUs.
+ * worldBounds — derives `_worldBounds` on `Model` rows from each instance's
+ * mesh `localBounds` and `_worldMatrix`.
  */
 export const worldBounds = Database.Plugin.create({
     extends: Database.Plugin.combine(modelLoader, transform),
@@ -33,11 +16,10 @@ export const worldBounds = Database.Plugin.create({
             schedule: { after: ["transformCreateWorldMatrix"] },
             create: db => () => {
                 for (const arch of db.store.queryArchetypes(
-                    ["geometry", "_worldMatrix"],
+                    ["mesh", "_worldMatrix"],
                     { exclude: ["_worldBounds"] },
                 )) {
                     const ids = arch.columns.id;
-                    // Iterate tail→head: every row migrates out of this archetype.
                     for (let i = arch.rowCount - 1; i >= 0; i--) {
                         db.store.update(ids.get(i), { _worldBounds: Aabb.unit });
                     }
@@ -48,13 +30,13 @@ export const worldBounds = Database.Plugin.create({
             schedule: { after: ["transformSystem", "worldBoundsCreate"] },
             create: db => () => {
                 for (const arch of db.store.queryArchetypes([
-                    "geometry", "_worldMatrix", "_worldBounds",
+                    "mesh", "_worldMatrix", "_worldBounds",
                 ])) {
-                    const geos = arch.columns.geometry;
+                    const meshRefs = arch.columns.mesh;
                     const worldMats = arch.columns._worldMatrix;
                     const worldBoundsCol = arch.columns._worldBounds;
                     for (let i = 0; i < arch.rowCount; i++) {
-                        const localBounds = db.store.get(geos.get(i), "_bounds");
+                        const localBounds = db.store.get(meshRefs.get(i), "localBounds") as Aabb | null;
                         if (!localBounds) continue;
                         worldBoundsCol.set(i, transformAabb(localBounds, worldMats.get(i)));
                     }
@@ -68,7 +50,6 @@ const transformAabb = (local: Aabb, m: Mat4x4): Aabb => {
     const { min, max } = local;
     let minX = Infinity, minY = Infinity, minZ = Infinity;
     let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
-    // The 8 box corners.
     for (let cx = 0; cx < 2; cx++) {
         for (let cy = 0; cy < 2; cy++) {
             for (let cz = 0; cz < 2; cz++) {

package/src/graphics/scene/node/node-data-plugin.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it } from "vitest";
+import { Database, Entity, type Store } from "@adobe/data/ecs";
+import { nodeData } from "./node-data-plugin.js";
+
+const createTestDb = () => Database.create(nodeData);
+
+const storeOf = (db: ReturnType<typeof createTestDb>) =>
+    (db as unknown as { store: Store<any, any, any> }).store;
+
+const identityNode = () => ({
+    position: [0, 0, 0] as const,
+    rotation: [0, 0, 0, 1] as const,
+    scale: [1, 1, 1] as const,
+    visible: true,
+    parent: 0 as Entity,
+});
+
+describe("nodeChildrenOf index", () => {
+    it("finds direct children of a parent node", () => {
+        const db = createTestDb();
+        const store = storeOf(db);
+        store.archetypes.Node.insert(identityNode()); // entity 0 — keeps parent id non-zero
+        const parent = store.archetypes.Node.insert(identityNode());
+        const childA = store.archetypes.Node.insert({ ...identityNode(), parent });
+        const childB = store.archetypes.Node.insert({ ...identityNode(), parent });
+        store.archetypes.Node.insert(identityNode()); // other root (parent === 0)
+
+        const children = db.indexes.nodeChildrenOf.find({ parent });
+        expect(children).toHaveLength(2);
+        expect(children).toContain(childA);
+        expect(children).toContain(childB);
+        expect(children).not.toContain(parent);
+    });
+
+    it("updates buckets when parent changes", () => {
+        const db = createTestDb();
+        const store = storeOf(db);
+        const parentA = store.archetypes.Node.insert(identityNode());
+        const parentB = store.archetypes.Node.insert(identityNode());
+        const child = store.archetypes.Node.insert({ ...identityNode(), parent: parentA });
+
+        expect(db.indexes.nodeChildrenOf.find({ parent: parentA })).toContain(child);
+        store.update(child, { parent: parentB });
+        expect(db.indexes.nodeChildrenOf.find({ parent: parentA })).not.toContain(child);
+        expect(db.indexes.nodeChildrenOf.find({ parent: parentB })).toContain(child);
+    });
+});

package/src/graphics/scene/node/node-data-plugin.ts

@@ -8,9 +8,13 @@ import { True } from "@adobe/data/schema";
  * The transform-hierarchy core model. Every entity with a position in the
  * world is a `Node` — see `node.ts` for the field bundle.
  *
- * `_worldMatrix` and `_worldBounds` are declared as components but NOT listed
- * on the authored Node archetype — systems write them via `db.store.update`,
- * migrating each entity once into a wider archetype.
+ * `_worldMatrix` and `_worldBounds` are derived components (`nonPersistent: true`)
+ * but NOT listed on the authored Node archetype — systems write them via
+ * `db.store.update`, migrating each entity once into a wider archetype.
+ *
+ * `indexes.nodeChildrenOf` lists direct children by parent entity id. Scoped
+ * to the Node archetype (and supersets such as Model) — not every column that
+ * happens to carry `parent`.
  */
 export const nodeData = Database.Plugin.create({
     components: {
@@ -19,10 +23,13 @@ export const nodeData = Database.Plugin.create({
         rotation:     Quat.schema,
         scale:        Vec3.schema,
         parent:       Entity.schema,
-        _worldMatrix: Mat4x4.schema,
-        _worldBounds: Aabb.schema,
+        _worldMatrix: { ...Mat4x4.schema, nonPersistent: true },
+        _worldBounds: { ...Aabb.schema, nonPersistent: true },
     },
     archetypes: {
         Node: ["position", "rotation", "scale", "parent", "visible"],
     },
+    indexes: {
+        nodeChildrenOf: { key: "parent", archetype: "Node" },
+    },
 });

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

@@ -2,7 +2,7 @@
 
 import { Database } from "@adobe/data/ecs";
 import { plugin as nodePlugin } from "./node/node-plugin.js";
-import { model } from "./model/model-plugin.js";
+import { mesh } from "./model/mesh-plugin.js";
 import { SceneUniforms } from "./scene-uniforms/scene-uniforms.js";
 
 /**
@@ -11,10 +11,10 @@ import { SceneUniforms } from "./scene-uniforms/scene-uniforms.js";
  *
  * Combines:
  *   - `Node.plugin`           (node data + transform system)
- *   - `model`                 (Geometry + Model archetypes)
+ *   - `mesh`                 (Mesh asset + Model/MeshInstance archetypes)
  *   - `SceneUniforms.plugin`  (camera resource + light resource + GPU uniform packing)
  *
  * Add a camera controller (e.g. `Orbit.plugin`), animation, and a renderer
  * (`pbrIblRender`) to get a working interactive scene.
  */
-export const scene = Database.Plugin.combine(nodePlugin, model, SceneUniforms.plugin);
+export const scene = Database.Plugin.combine(nodePlugin, mesh, SceneUniforms.plugin);

package/src/index.ts

@@ -1,72 +1,3 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
-// --- Scene model (declarative authored data, no camera, no systems) ----------
-export { scene } from "./graphics/scene/scene-plugin.js";
-
-// --- Authoring abstractions --------------------------------------------------
-export { animation } from "./graphics/animation/animation-plugin.js";
-export { AnimationTrack } from "./graphics/animation/animation-track/animation-track.js";
-export { InterpolationMode } from "./graphics/animation/interpolation-mode/interpolation-mode.js";
-
-// --- Infrastructure ----------------------------------------------------------
-export { core } from "./core/core-plugin.js";
-export { FrameTime } from "./core/frame-time/frame-time.js";
-export { graphics } from "./graphics/graphics-plugin.js";
-
-// --- Physics: shared rigid-body data model + pluggable solver seam -----------
-export { physicsData } from "./physics/physics-data-plugin.js";
-export { physicsClock } from "./physics/physics-clock-plugin.js";
-export type { PhysicsClock } from "./physics/physics-clock-plugin.js";
-export { jointData } from "./physics/joint/joint-plugin.js";
-export type { Joint } from "./physics/joint/joint.js";
-export { JointType } from "./physics/joint/joint-type/joint-type.js";
-export type { RigidBody } from "./physics/body/rigid-body.js";
-export type { StaticCollider } from "./physics/body/static-collider.js";
-export { BodyType } from "./physics/body/body-type/body-type.js";
-export { ColliderShape } from "./physics/body/collider-shape/collider-shape.js";
-export { rapierSolver } from "./physics/solvers/rapier-solver-plugin.js";
-export { joltSolver } from "./physics/solvers/jolt-solver-plugin.js";
-export { runSolverBenchmark } from "./physics/solvers/solver-benchmark.js";
-export type { SolverBenchmarkOptions, SolverBenchmarkResult } from "./physics/solvers/solver-benchmark.js";
-
-// --- Material registry (authored entities: physical + visible PBR props) ------
-export { Material } from "./material/material.js";
-
-// --- System plugins (consumed via aggregators) -------------------------------
-export { transform } from "./graphics/scene/node/transform-plugin.js";
-export { pbrCore } from "./graphics/rendering/pbr-core-plugin.js";
-export { modelLoader } from "./graphics/scene/model/model-loader-plugin.js";
-export { pbrSkinning } from "./graphics/rendering/skinning/skinning-plugin.js";
-export { picking } from "./graphics/picking/picking-plugin.js";
-export type { PickHit } from "./graphics/picking/pick-hit.js";
-
-// --- Rendering ---------------------------------------------------------------
-export { rendering } from "./graphics/rendering/rendering-plugin.js";
-export { pbrIblRender } from "./graphics/rendering/ibl-render/ibl-render-plugin.js";
-export { materialGpu } from "./graphics/rendering/material-gpu/material-gpu-plugin.js";
-export { pbrRender } from "./graphics/rendering/pbr-render/pbr-render-plugin.js";
-export { physicsRenderBridge } from "./graphics/rendering/pbr-render/physics-bridge-plugin.js";
-export { displayTransform } from "./graphics/rendering/display-transform-plugin.js";
-export { interpolation } from "./graphics/rendering/interpolation-plugin.js";
-export { modelCollider } from "./graphics/rendering/model-collider-plugin.js";
-export { boneColliders } from "./graphics/rendering/bone-collider-plugin.js";
-export { ragdollTrigger } from "./graphics/rendering/ragdoll-trigger-plugin.js";
-export { joltRagdoll } from "./graphics/rendering/jolt-ragdoll-plugin.js";
-export { fitBoneCapsules } from "./physics/ragdoll/fit-bone-capsules.js";
-export type { BoneCapsule } from "./physics/ragdoll/fit-bone-capsules.js";
-export { shapeGeometry } from "./graphics/scene/model/shape/shape-geometry-plugin.js";
-
-// --- Types (type + namespace, access .plugin for the ECS plugin) -------------
-export { Camera } from "./graphics/camera/camera.js";
-export { Light } from "./graphics/scene/light/light.js";
-export { Orbit } from "./graphics/camera/orbit/orbit.js";
-export { Node } from "./graphics/scene/node/node.js";
-export { Model } from "./graphics/scene/model/model.js";
-export { Geometry } from "./graphics/scene/model/geometry/geometry.js";
-export { SceneUniforms } from "./graphics/scene/scene-uniforms/scene-uniforms.js";
-export { StandardVertex } from "./graphics/rendering/standard-vertex/standard-vertex.js";
-export { VisibleMaterial } from "./graphics/rendering/visible-material/visible-material.js";
-
-// --- Utilities ---------------------------------------------------------------
-export { attachOrbitDrag } from "./graphics/camera/orbit/attach-orbit-drag.js";
-export type { OrbitDragService } from "./graphics/camera/orbit/attach-orbit-drag.js";
+export * from "./core/public.js";

package/src/material/assemble-material-row.ts

@@ -0,0 +1,26 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+import type { Material } from "./material.js";
+import type { MaterialDefinition } from "./material-definition.js";
+import { solidDefaults } from "./material-defaults.js";
+
+/** Fields that `solidDefaults` does not supply — must appear on every definition or full row. */
+const REQUIRED_KEYS = [
+    "density",
+    "restitution",
+    "heatCapacity",
+    "baseColorFactor",
+    "emissiveFactor",
+    "metallicFactor",
+    "roughnessFactor",
+] as const satisfies readonly (keyof Material)[];
+
+/** Merge defaults + definition into a full `Material` row; throw if required fields are missing. */
+export const assembleMaterialRow = (name: string, definition: MaterialDefinition): Material => {
+    const row = { name, ...solidDefaults, ...definition };
+    const missing = REQUIRED_KEYS.filter(key => row[key] === undefined);
+    if (missing.length > 0) {
+        throw new Error(`Material "${name}" is missing required fields: ${missing.join(", ")}`);
+    }
+    return row as Material;
+};