@adobe/data-gpu 0.9.69

package/src/graphics/scene/model/shape/convex-hull.ts

@@ -0,0 +1,141 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+import type { ShapeMesh } from "./shape-mesh.js";
+
+/**
+ * Faceted render mesh of the convex hull of a point cloud (flat per-face normals,
+ * StandardVertex layout). A convex collider is *authored* as a point cloud — the
+ * physics engine builds the collision hull from the same points — but rendering
+ * needs a triangulated surface, which this computes. Phase-2 auto-hull (hull of a
+ * render mesh's vertices) reuses it.
+ *
+ * Incremental 3D hull: seed a tetrahedron, then fold each remaining point in by
+ * deleting the faces it can see and bridging the horizon to it. Every face's
+ * normal is oriented away from a fixed interior point (the seed centroid, always
+ * strictly inside a convex hull) — so orientation is robust without half-edge
+ * bookkeeping. Authored hulls are small (tens of points), so the simple O(n·f)
+ * form is plenty fast. Degenerate input (< 4 points or coplanar) → empty mesh.
+ */
+
+interface Face { a: number; b: number; c: number; nx: number; ny: number; nz: number }
+
+const EPS = 1e-7;
+
+export function convexHullMesh(points: Float32Array): ShapeMesh {
+    const faces = hullFaces(points);
+    if (!faces) return { vertices: new Float32Array(0), indices: new Uint16Array(0) };
+    const px = (i: number) => points[i * 3], py = (i: number) => points[i * 3 + 1], pz = (i: number) => points[i * 3 + 2];
+
+    // flat-shaded: three unique verts per face, all sharing the face normal.
+    const verts: number[] = [], indices: number[] = [];
+    for (const f of faces) {
+        const len = Math.hypot(f.nx, f.ny, f.nz) || 1;
+        const nx = f.nx / len, ny = f.ny / len, nz = f.nz / len;
+        // any in-plane unit vector for the tangent (flat shading ignores its sign)
+        let tx = px(f.b) - px(f.a), ty = py(f.b) - py(f.a), tz = pz(f.b) - pz(f.a);
+        const tl = Math.hypot(tx, ty, tz) || 1; tx /= tl; ty /= tl; tz /= tl;
+        const base = verts.length / 12;
+        const corners = [f.a, f.b, f.c], uv = [[0, 0], [1, 0], [0, 1]];
+        for (let i = 0; i < 3; i++) {
+            const v = corners[i];
+            verts.push(px(v), py(v), pz(v), nx, ny, nz, tx, ty, tz, 1, uv[i][0], uv[i][1]);
+        }
+        indices.push(base, base + 1, base + 2);
+    }
+    return { vertices: new Float32Array(verts), indices: new Uint16Array(indices) };
+}
+
+/**
+ * The deduplicated hull vertices (the extreme points) of a cloud — a minimal
+ * point set whose convex hull equals the cloud's. Used to feed a physics engine's
+ * convex-hull builder a *simplified* collider from a detailed mesh (thousands of
+ * verts → a few dozen). Empty for degenerate input.
+ */
+export function hullVertices(points: Float32Array): Float32Array {
+    const faces = hullFaces(points);
+    if (!faces) return new Float32Array(0);
+    const used = new Set<number>();
+    for (const f of faces) { used.add(f.a); used.add(f.b); used.add(f.c); }
+    const out = new Float32Array(used.size * 3);
+    let i = 0;
+    for (const idx of used) { out[i * 3] = points[idx * 3]; out[i * 3 + 1] = points[idx * 3 + 1]; out[i * 3 + 2] = points[idx * 3 + 2]; i++; }
+    return out;
+}
+
+/** The hull's triangular faces, each normal oriented outward, or null if the
+ *  point cloud is degenerate (fewer than 4 points, or all coplanar). Exported
+ *  for tests; rendering goes through {@link convexHullMesh}. */
+export function hullFaces(points: Float32Array): Face[] | null {
+    const n = points.length / 3;
+    if (n < 4) return null;
+    const px = (i: number) => points[i * 3], py = (i: number) => points[i * 3 + 1], pz = (i: number) => points[i * 3 + 2];
+
+    const seed = seedTetra(n, px, py, pz);
+    if (!seed) return null;
+    // centroid of the seed tetra — strictly inside the hull for its whole life, so
+    // "normal points away from this" is always the correct outward test.
+    const [i0, i1, i2, i3] = seed;
+    const cx = (px(i0) + px(i1) + px(i2) + px(i3)) / 4;
+    const cy = (py(i0) + py(i1) + py(i2) + py(i3)) / 4;
+    const cz = (pz(i0) + pz(i1) + pz(i2) + pz(i3)) / 4;
+
+    const makeFace = (a: number, b: number, c: number): Face => {
+        const ux = px(b) - px(a), uy = py(b) - py(a), uz = pz(b) - pz(a);
+        const vx = px(c) - px(a), vy = py(c) - py(a), vz = pz(c) - pz(a);
+        let nx = uy * vz - uz * vy, ny = uz * vx - ux * vz, nz = ux * vy - uy * vx;
+        if (nx * (px(a) - cx) + ny * (py(a) - cy) + nz * (pz(a) - cz) < 0) { // points inward → flip
+            return { a, b: c, c: b, nx: -nx, ny: -ny, nz: -nz };
+        }
+        return { a, b, c, nx, ny, nz };
+    };
+    const above = (f: Face, p: number): number =>
+        f.nx * (px(p) - px(f.a)) + f.ny * (py(p) - py(f.a)) + f.nz * (pz(p) - pz(f.a));
+
+    const faces: Face[] = [makeFace(i0, i1, i2), makeFace(i0, i1, i3), makeFace(i0, i2, i3), makeFace(i1, i2, i3)];
+    for (let p = 0; p < n; p++) {
+        if (faces.every(f => above(f, p) <= EPS)) continue; // inside the current hull
+
+        // horizon = edges on exactly one visible face (the toggle leaves only those).
+        const horizon = new Map<string, [number, number]>();
+        for (const f of faces) {
+            if (above(f, p) <= EPS) continue;
+            for (const [u, v] of [[f.a, f.b], [f.b, f.c], [f.c, f.a]] as const) {
+                const k = u < v ? `${u}_${v}` : `${v}_${u}`;
+                if (horizon.has(k)) horizon.delete(k); else horizon.set(k, [u, v]);
+            }
+        }
+        for (let i = faces.length - 1; i >= 0; i--) if (above(faces[i], p) > EPS) faces.splice(i, 1);
+        for (const [u, v] of horizon.values()) faces.push(makeFace(u, v, p));
+    }
+    return faces;
+}
+
+/** Indices of 4 non-coplanar seed points (max-spread pair, point farthest from
+ *  that line, point farthest from that plane), or null if all points are coplanar. */
+function seedTetra(n: number, px: (i: number) => number, py: (i: number) => number, pz: (i: number) => number): [number, number, number, number] | null {
+    let i0 = 0, i1 = 0, best = -1;
+    for (let i = 0; i < n; i++) for (let j = i + 1; j < n; j++) {
+        const d = (px(i) - px(j)) ** 2 + (py(i) - py(j)) ** 2 + (pz(i) - pz(j)) ** 2;
+        if (d > best) { best = d; i0 = i; i1 = j; }
+    }
+    if (best <= EPS) return null;
+    const ex = px(i1) - px(i0), ey = py(i1) - py(i0), ez = pz(i1) - pz(i0);
+    let i2 = -1; best = EPS;
+    for (let i = 0; i < n; i++) { // area² of triangle (i0,i1,i) ∝ |edge × (i0→i)|²
+        const wx = px(i) - px(i0), wy = py(i) - py(i0), wz = pz(i) - pz(i0);
+        const cx = ey * wz - ez * wy, cy = ez * wx - ex * wz, cz = ex * wy - ey * wx;
+        const a = cx * cx + cy * cy + cz * cz;
+        if (a > best) { best = a; i2 = i; }
+    }
+    if (i2 < 0) return null;
+    const ux = px(i1) - px(i0), uy = py(i1) - py(i0), uz = pz(i1) - pz(i0);
+    const vx = px(i2) - px(i0), vy = py(i2) - py(i0), vz = pz(i2) - pz(i0);
+    const pnx = uy * vz - uz * vy, pny = uz * vx - ux * vz, pnz = ux * vy - uy * vx;
+    let i3 = -1; best = EPS;
+    for (let i = 0; i < n; i++) {
+        const d = Math.abs(pnx * (px(i) - px(i0)) + pny * (py(i) - py(i0)) + pnz * (pz(i) - pz(i0)));
+        if (d > best) { best = d; i3 = i; }
+    }
+    if (i3 < 0) return null; // coplanar
+    return [i0, i1, i2, i3];
+}

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

@@ -0,0 +1,61 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+import { Database, type Entity } from "@adobe/data/ecs";
+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 { unitSphere, unitCube } from "./shape-mesh.js";
+import { uploadShapeMesh } from "./upload-shape-mesh.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.
+ */
+export const shapeGeometry = Database.Plugin.create({
+    extends: Database.Plugin.combine(pbrCore, model, core),
+    resources: {
+        _shapeGeometry: { default: null as { sphere: Entity; cube: Entity } | null, transient: true },
+    },
+    transactions: {
+        insertShapePrimitive(t, args: { vertexBuffer: GPUBuffer; indexBuffer: GPUBuffer; indexCount: number }): Entity {
+            const geometry = t.archetypes.Geometry.insert({ modelUrl: "" });
+            t.archetypes._PbrPrimitive.insert({
+                ephemeral: true,
+                _geometry: geometry,
+                _material: 0,                 // primitives carry material per-instance, not here
+                _vertexBuffer: args.vertexBuffer,
+                _skinVertexBuffer: null,
+                _indexBuffer: args.indexBuffer,
+                _indexCount: args.indexCount,
+                _indexFormat: "uint16",
+                _nodeLocalMatrix: Mat4x4.identity,
+            });
+            return geometry;
+        },
+    },
+    systems: {
+        shapeGeometryInit: {
+            schedule: { during: ["preUpdate"] },
+            create: db => {
+                let done = false;
+                return () => {
+                    if (done) return;
+                    const { device } = db.store.resources;
+                    if (!device) return;
+
+                    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 };
+                    done = true;
+                };
+            },
+        },
+    },
+});

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

@@ -0,0 +1,150 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+/**
+ * Procedural unit-shape meshes in the StandardVertex packed layout
+ * (position vec3, normal vec3, tangent vec4, uv vec2 — 12 floats/vertex), so
+ * they feed the same PBR pipeline and `StandardVertex.layout` as glTF meshes.
+ * Unit-sized (radius / half-extent 1): a Node `scale` sets the real size, so a
+ * cuboid is the unit cube scaled by its half-extents and a sphere is the unit
+ * sphere scaled by its radius.
+ */
+export interface ShapeMesh {
+    vertices: Float32Array;
+    indices: Uint16Array;
+}
+
+function push(out: number[], px: number, py: number, pz: number, nx: number, ny: number, nz: number, tx: number, ty: number, tz: number, tw: number, u: number, v: number): void {
+    out.push(px, py, pz, nx, ny, nz, tx, ty, tz, tw, u, v);
+}
+
+/** UV sphere, radius 1, centred at origin. */
+export function unitSphere(rings = 24, segments = 48): ShapeMesh {
+    const verts: number[] = [];
+    for (let ring = 0; ring <= rings; ring++) {
+        const theta = (ring / rings) * Math.PI;
+        const st = Math.sin(theta), ct = Math.cos(theta);
+        for (let seg = 0; seg <= segments; seg++) {
+            const phi = (seg / segments) * Math.PI * 2;
+            const sp = Math.sin(phi), cp = Math.cos(phi);
+            const x = st * cp, y = ct, z = st * sp;
+            // tangent = d(pos)/dphi, normalized; degenerate at the poles.
+            let tx = -sp, ty = 0, tz = cp;
+            const tl = Math.hypot(tx, ty, tz);
+            if (tl < 1e-5) { tx = 1; ty = 0; tz = 0; } else { tx /= tl; tz /= tl; }
+            push(verts, x, y, z, x, y, z, tx, ty, tz, 1, seg / segments, ring / rings);
+        }
+    }
+    const indices: number[] = [];
+    const stride = segments + 1;
+    for (let ring = 0; ring < rings; ring++) {
+        for (let seg = 0; seg < segments; seg++) {
+            const a = ring * stride + seg, b = a + stride;
+            indices.push(a, b, a + 1, a + 1, b, b + 1);
+        }
+    }
+    return { vertices: new Float32Array(verts), indices: new Uint16Array(indices) };
+}
+
+interface Face { n: [number, number, number]; u: [number, number, number]; v: [number, number, number] }
+
+// u × v = n for every face, so [c0,c1,c2,c0,c2,c3] winds CCW outward (back-cull).
+const CUBE_FACES: Face[] = [
+    { n: [1, 0, 0],  u: [0, 0, -1], v: [0, 1, 0] },
+    { n: [-1, 0, 0], u: [0, 0, 1],  v: [0, 1, 0] },
+    { n: [0, 1, 0],  u: [1, 0, 0],  v: [0, 0, -1] },
+    { n: [0, -1, 0], u: [1, 0, 0],  v: [0, 0, 1] },
+    { n: [0, 0, 1],  u: [1, 0, 0],  v: [0, 1, 0] },
+    { n: [0, 0, -1], u: [-1, 0, 0], v: [0, 1, 0] },
+];
+
+/**
+ * Flat-shaded StandardVertex mesh from a triangle soup (positions + indices) —
+ * one face normal per triangle, three unique verts per triangle. Used to render
+ * an authored static-mesh collider. Indices are emitted as `uint16`, so this is
+ * for the modest authored meshes (ramps, props) of the current shape path, not
+ * dense terrain (which would need a `uint32`-indexed primitive).
+ */
+export function flatShadedMesh(positions: Float32Array, indices: ArrayLike<number>): ShapeMesh {
+    const verts: number[] = [], out: number[] = [];
+    for (let t = 0; t < indices.length; t += 3) {
+        const ia = indices[t] * 3, ib = indices[t + 1] * 3, ic = indices[t + 2] * 3;
+        const ax = positions[ia], ay = positions[ia + 1], az = positions[ia + 2];
+        const bx = positions[ib], by = positions[ib + 1], bz = positions[ib + 2];
+        const cx = positions[ic], cy = positions[ic + 1], cz = positions[ic + 2];
+        let nx = (by - ay) * (cz - az) - (bz - az) * (cy - ay);
+        let ny = (bz - az) * (cx - ax) - (bx - ax) * (cz - az);
+        let nz = (bx - ax) * (cy - ay) - (by - ay) * (cx - ax);
+        const nl = Math.hypot(nx, ny, nz) || 1; nx /= nl; ny /= nl; nz /= nl;
+        let tx = bx - ax, ty = by - ay, tz = bz - az;
+        const tl = Math.hypot(tx, ty, tz) || 1; tx /= tl; ty /= tl; tz /= tl;
+        const base = verts.length / 12;
+        push(verts, ax, ay, az, nx, ny, nz, tx, ty, tz, 1, 0, 0);
+        push(verts, bx, by, bz, nx, ny, nz, tx, ty, tz, 1, 1, 0);
+        push(verts, cx, cy, cz, nx, ny, nz, tx, ty, tz, 1, 0, 1);
+        out.push(base, base + 1, base + 2);
+    }
+    return { vertices: new Float32Array(verts), indices: new Uint16Array(out) };
+}
+
+/**
+ * Y-aligned capsule: a cylinder (radius `r`, half-height `halfHeight`) capped by
+ * two hemispheres of radius `r`, centred at the origin (total height
+ * 2·(halfHeight + r)). Unlike the sphere/cube, a capsule has two independent
+ * dimensions and spherical caps that must not distort under non-uniform scale —
+ * so it is built at its real size and rendered with unit scale (the bridge caches
+ * one mesh per distinct radius/half-height). Rings run top pole → bottom pole;
+ * the two equator rings (`ny = 0`, full radius) bound the straight cylinder wall.
+ */
+export function capsuleMesh(r: number, halfHeight: number, capRings = 8, segments = 24): ShapeMesh {
+    const rows: { y: number; rr: number; ny: number }[] = [];
+    for (let i = 0; i <= capRings; i++) {               // top cap: pole → equator
+        const a = (i / capRings) * (Math.PI / 2);
+        rows.push({ y: halfHeight + r * Math.cos(a), rr: r * Math.sin(a), ny: Math.cos(a) });
+    }
+    rows.push({ y: -halfHeight, rr: r, ny: 0 });          // cylinder bottom rim
+    for (let i = 1; i <= capRings; i++) {               // bottom cap: equator → pole
+        const b = (i / capRings) * (Math.PI / 2);
+        rows.push({ y: -halfHeight - r * Math.sin(b), rr: r * Math.cos(b), ny: -Math.sin(b) });
+    }
+    const verts: number[] = [];
+    const stride = segments + 1;
+    for (let row = 0; row < rows.length; row++) {
+        const { y, rr, ny } = rows[row];
+        const rad = Math.sqrt(Math.max(0, 1 - ny * ny)); // radial component of the unit normal
+        for (let seg = 0; seg <= segments; seg++) {
+            const phi = (seg / segments) * Math.PI * 2;
+            const cp = Math.cos(phi), sp = Math.sin(phi);
+            push(verts, rr * cp, y, rr * sp, rad * cp, ny, rad * sp, -sp, 0, cp, 1, seg / segments, row / (rows.length - 1));
+        }
+    }
+    const indices: number[] = [];
+    for (let row = 0; row < rows.length - 1; row++) {
+        for (let seg = 0; seg < segments; seg++) {
+            const a = row * stride + seg, b = a + stride;
+            indices.push(a, b, a + 1, a + 1, b, b + 1);
+        }
+    }
+    return { vertices: new Float32Array(verts), indices: new Uint16Array(indices) };
+}
+
+/** Cube spanning [-1, 1] on each axis, one material-space UV per face. */
+export function unitCube(): ShapeMesh {
+    const verts: number[] = [];
+    const indices: number[] = [];
+    let base = 0;
+    for (const f of CUBE_FACES) {
+        const [nx, ny, nz] = f.n, [ux, uy, uz] = f.u, [vx, vy, vz] = f.v;
+        const corner = (su: number, sv: number, tu: number, tv: number): void => {
+            push(verts,
+                nx + su * ux + sv * vx, ny + su * uy + sv * vy, nz + su * uz + sv * vz,
+                nx, ny, nz, ux, uy, uz, 1, tu, tv);
+        };
+        corner(-1, -1, 0, 0);
+        corner(1, -1, 1, 0);
+        corner(1, 1, 1, 1);
+        corner(-1, 1, 0, 1);
+        indices.push(base, base + 1, base + 2, base, base + 2, base + 3);
+        base += 4;
+    }
+    return { vertices: new Float32Array(verts), indices: new Uint16Array(indices) };
+}

package/src/graphics/scene/model/shape/upload-shape-mesh.ts

@@ -0,0 +1,14 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+import type { ShapeMesh } from "./shape-mesh.js";
+
+/** Upload a procedural shape mesh into GPU vertex + index buffers (one-time,
+ *  when the device is ready). Shared by `shapeGeometry` (sphere/cube) and the
+ *  physics bridge (per-dimension capsules). */
+export function uploadShapeMesh(device: GPUDevice, mesh: ShapeMesh): { vb: GPUBuffer; ib: GPUBuffer; count: number } {
+    const vb = device.createBuffer({ size: mesh.vertices.byteLength, usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST });
+    device.queue.writeBuffer(vb, 0, mesh.vertices);
+    const ib = device.createBuffer({ size: mesh.indices.byteLength, usage: GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST });
+    device.queue.writeBuffer(ib, 0, mesh.indices);
+    return { vb, ib, count: mesh.indices.length };
+}

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

@@ -0,0 +1,88 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+import { Database } from "@adobe/data/ecs";
+import { Aabb, Mat4x4, type Vec3 } from "@adobe/data/math";
+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.
+ */
+export const worldBounds = Database.Plugin.create({
+    extends: Database.Plugin.combine(modelLoader, transform),
+    systems: {
+        worldBoundsCreate: {
+            schedule: { after: ["transformCreateWorldMatrix"] },
+            create: db => () => {
+                for (const arch of db.store.queryArchetypes(
+                    ["geometry", "_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 });
+                    }
+                }
+            },
+        },
+        worldBoundsSystem: {
+            schedule: { after: ["transformSystem", "worldBoundsCreate"] },
+            create: db => () => {
+                for (const arch of db.store.queryArchetypes([
+                    "geometry", "_worldMatrix", "_worldBounds",
+                ])) {
+                    const geos = arch.columns.geometry;
+                    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");
+                        if (!localBounds) continue;
+                        worldBoundsCol.set(i, transformAabb(localBounds, worldMats.get(i)));
+                    }
+                }
+            },
+        },
+    },
+});
+
+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++) {
+                const corner: Vec3 = [
+                    cx === 0 ? min[0] : max[0],
+                    cy === 0 ? min[1] : max[1],
+                    cz === 0 ? min[2] : max[2],
+                ];
+                const w = Mat4x4.multiplyVec3(m, corner);
+                if (w[0] < minX) minX = w[0]; if (w[0] > maxX) maxX = w[0];
+                if (w[1] < minY) minY = w[1]; if (w[1] > maxY) maxY = w[1];
+                if (w[2] < minZ) minZ = w[2]; if (w[2] > maxZ) maxZ = w[2];
+            }
+        }
+    }
+    return { min: [minX, minY, minZ], max: [maxX, maxY, maxZ] };
+};

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

@@ -0,0 +1,28 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+import { Database, Entity } from "@adobe/data/ecs";
+import { Aabb, Mat4x4, Quat, Vec3 } from "@adobe/data/math";
+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.
+ */
+export const nodeData = Database.Plugin.create({
+    components: {
+        visible:      True.schema,
+        position:     Vec3.schema,
+        rotation:     Quat.schema,
+        scale:        Vec3.schema,
+        parent:       Entity.schema,
+        _worldMatrix: Mat4x4.schema,
+        _worldBounds: Aabb.schema,
+    },
+    archetypes: {
+        Node: ["position", "rotation", "scale", "parent", "visible"],
+    },
+});

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

@@ -0,0 +1,13 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+import { Database } from "@adobe/data/ecs";
+import { nodeData } from "./node-data-plugin.js";
+import { transform } from "./transform-plugin.js";
+
+/**
+ * Full node plugin — spatial hierarchy data plus the `transform` system that
+ * derives `_worldMatrix` each frame. Use `Node.plugin` (= this) to get both.
+ * Use `nodeData` directly if you only need the declared components and archetype
+ * without the per-frame TRS computation.
+ */
+export const plugin = Database.Plugin.combine(nodeData, transform);

package/src/graphics/scene/node/node.ts

@@ -0,0 +1,23 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+import type { Entity } from "@adobe/data/ecs";
+import type { Quat, Vec3 } from "@adobe/data/math";
+
+/**
+ * One entity in the Node archetype — a transform-hierarchy slot. Each field
+ * is its own ECS component (typed-buffer column), but the Node shape names
+ * the bundle so consumers can declare typed locals like
+ * `const node: Node = arch.read(i)`.
+ *
+ * `_worldMatrix` is *not* on the authored Node — the `transform` system
+ * adds it later, migrating each entity into a wider archetype.
+ */
+export interface Node {
+    position: Vec3;
+    rotation: Quat;
+    scale:    Vec3;
+    parent:   Entity;
+    visible:  boolean;
+}
+
+export * as Node from "./public.js";

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

@@ -0,0 +1 @@
+export { plugin } from "./node-plugin.js";

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

@@ -0,0 +1,72 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+import { Database } from "@adobe/data/ecs";
+import { Mat4x4, Quat } from "@adobe/data/math";
+import { nodeData } from "./node-data-plugin.js";
+
+/**
+ * transformCreateWorldMatrix
+ *   query: Node-_worldMatrix
+ *   write: _worldMatrix   (archetype migration; identity)
+ *
+ *   Adds the `_worldMatrix` column to any Node that doesn't have it yet, so
+ *   `transformSystem` can assume the column exists and write to it directly.
+ *
+ * transformSystem
+ *   query: Node+_worldMatrix
+ *   read:  position, rotation, scale, parent
+ *   write: _worldMatrix
+ *
+ *   Computes TRS for every Node and writes the result into the existing
+ *   `_worldMatrix` column. Parents are typically inserted before children
+ *   (glTF order, sample setup), so by the time we reach a child the parent's
+ *   matrix is already populated this frame.
+ */
+export const transform = Database.Plugin.create({
+    extends: nodeData,
+    systems: {
+        transformCreateWorldMatrix: {
+            create: db => () => {
+                for (const arch of db.store.queryArchetypes(
+                    ["position", "rotation", "scale", "parent"],
+                    { exclude: ["_worldMatrix"] },
+                )) {
+                    const ids = arch.columns.id;
+                    // Iterate tail→head: every row migrates out of this archetype,
+                    // and removing the last row first means no hole-fill shift.
+                    for (let i = arch.rowCount - 1; i >= 0; i--) {
+                        db.store.update(ids.get(i), { _worldMatrix: Mat4x4.identity });
+                    }
+                }
+            },
+        },
+        transformSystem: {
+            schedule: { after: ["transformCreateWorldMatrix"] },
+            create: db => () => {
+                for (const arch of db.store.queryArchetypes([
+                    "position", "rotation", "scale", "parent", "_worldMatrix",
+                ])) {
+                    const positions = arch.columns.position;
+                    const rotations = arch.columns.rotation;
+                    const scales = arch.columns.scale;
+                    const parents = arch.columns.parent;
+                    const worldMats = arch.columns._worldMatrix;
+                    for (let i = 0; i < arch.rowCount; i++) {
+                        const pos = positions.get(i);
+                        const rot = rotations.get(i);
+                        const scl = scales.get(i);
+                        const parentId = parents.get(i);
+                        const local = Mat4x4.multiply(
+                            Mat4x4.translation(pos[0], pos[1], pos[2]),
+                            Mat4x4.multiply(Quat.toMat4(rot), Mat4x4.scaling(scl[0], scl[1], scl[2])),
+                        );
+                        const parentWorld = parentId === 0
+                            ? Mat4x4.identity
+                            : db.store.get(parentId, "_worldMatrix") ?? Mat4x4.identity;
+                        worldMats.set(i, parentId === 0 ? local : Mat4x4.multiply(parentWorld, local));
+                    }
+                }
+            },
+        },
+    },
+});

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

@@ -0,0 +1,20 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+import { Database } from "@adobe/data/ecs";
+import { plugin as nodePlugin } from "./node/node-plugin.js";
+import { model } from "./model/model-plugin.js";
+import { SceneUniforms } from "./scene-uniforms/scene-uniforms.js";
+
+/**
+ * The complete authored scene — spatial hierarchy, models, camera, lighting,
+ * and the GPU uniform buffer that ties them together for rendering.
+ *
+ * Combines:
+ *   - `Node.plugin`           (node data + transform system)
+ *   - `model`                 (Geometry + Model 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);

package/src/graphics/scene/scene-uniforms/create-bind-group-layout.ts

@@ -0,0 +1,19 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+/**
+ * Bind group layout for the SceneUniforms uniform buffer. Stable across the
+ * renderer pipeline (consumer) and `_sceneUniforms` system (producer).
+ * WebGPU compares layouts structurally, so creating two layout objects from
+ * this descriptor is safe.
+ */
+export function createBindGroupLayout(device: GPUDevice): GPUBindGroupLayout {
+    return device.createBindGroupLayout({
+        entries: [
+            {
+                binding: 0,
+                visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT,
+                buffer: { type: "uniform" },
+            },
+        ],
+    });
+}

package/src/graphics/scene/scene-uniforms/public.ts

@@ -0,0 +1,5 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+export * from "./schema.js";
+export { createBindGroupLayout } from "./create-bind-group-layout.js";
+export { plugin } from "./scene-uniforms-plugin.js";