@adobe/data-gpu 0.9.75 → 0.9.77

package/src/physics/index.ts

@@ -0,0 +1,3 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+export * from "./public.js";

package/src/physics/is-voxel-shape-physics-pending.ts

@@ -0,0 +1,9 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+import type { Entity } from "@adobe/data/ecs";
+
+/** True while a body carries `voxelShapeName` but the mesh ref is not yet resolved. */
+export const isVoxelShapePhysicsPending = (store: unknown, id: Entity): boolean => {
+    const row = (store as { read(id: Entity): Record<string, unknown> | null }).read(id);
+    return row?.voxelShapeName != null && row?.voxelShape == null;
+};

package/src/physics/physics-clock/physics-clock.ts

@@ -0,0 +1,17 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+/**
+ * Fixed-timestep physics clock state — decouples simulation rate from render rate.
+ */
+export interface PhysicsClock {
+    /** Fixed simulation step length, seconds (default 1/60). */
+    readonly fixedDt: number;
+    /** Unsimulated time carried to the next frame, seconds (< fixedDt). */
+    readonly accumulator: number;
+    /** accumulator / fixedDt ∈ [0,1): render interpolation fraction prev→current. */
+    readonly alpha: number;
+    /** Whole steps the solver should run this frame (0..maxSubSteps). */
+    readonly steps: number;
+    /** Cap on steps/frame — prevents the "spiral of death" after a long stall. */
+    readonly maxSubSteps: number;
+}

package/src/physics/physics-clock-plugin.ts

@@ -2,28 +2,7 @@
 
 import { Database } from "@adobe/data/ecs";
 import { core } from "../core/core-plugin.js";
-
-/**
- * Fixed-timestep physics clock — decouples the simulation rate from the render
- * rate (Fiedler "fix your timestep"). Each render frame the accumulator absorbs
- * the variable `frameTime.dt`; the solver then runs a whole number of fixed
- * `fixedDt` steps (0, 1, or several), and `alpha` is the leftover fraction used
- * to interpolate the rendered pose between the last two simulated states.
- *
- * Default 60 Hz; set another rate at init with `setFixedTimestep(hz)`.
- */
-export interface PhysicsClock {
-    /** Fixed simulation step length, seconds (default 1/60). */
-    readonly fixedDt: number;
-    /** Unsimulated time carried to the next frame, seconds (< fixedDt). */
-    readonly accumulator: number;
-    /** accumulator / fixedDt ∈ [0,1): render interpolation fraction prev→current. */
-    readonly alpha: number;
-    /** Whole steps the solver should run this frame (0..maxSubSteps). */
-    readonly steps: number;
-    /** Cap on steps/frame — prevents the "spiral of death" after a long stall. */
-    readonly maxSubSteps: number;
-}
+import type { PhysicsClock } from "./physics-clock/physics-clock.js";
 
 const DEFAULT: PhysicsClock = { fixedDt: 1 / 60, accumulator: 0, alpha: 0, steps: 0, maxSubSteps: 8 };
 
@@ -50,8 +29,6 @@ export const physicsClock = Database.Plugin.create({
             create: db => () => {
                 const c = db.store.resources.physicsClock;
                 const h = c.fixedDt;
-                // clamp the absorbed time to the step budget so a long stall (tab
-                // backgrounded, GC) can't queue hundreds of steps (spiral of death)
                 const acc = c.accumulator + Math.min(db.store.resources.frameTime.dt, h * c.maxSubSteps);
                 const steps = Math.min(Math.floor(acc / h), c.maxSubSteps);
                 db.store.resources.physicsClock = { ...c, accumulator: acc - steps * h, alpha: (acc - steps * h) / h, steps };

package/src/physics/physics-clock.test.ts

@@ -2,7 +2,8 @@
 
 import { describe, it, expect } from "vitest";
 import { Database } from "@adobe/data/ecs";
-import { physicsClock, type PhysicsClock } from "./physics-clock-plugin.js";
+import { physicsClock } from "./physics-clock-plugin.js";
+import type { PhysicsClock } from "./physics-clock/physics-clock.js";
 
 /** The accumulator turns a variable render dt into a whole number of fixed steps
  *  plus a leftover interpolation `alpha`, capped against the spiral of death. */

package/src/physics/physics-data-plugin.ts

@@ -7,6 +7,8 @@ import { BodyType } from "./body/body-type/body-type.js";
 import { ColliderShape } from "./body/collider-shape/collider-shape.js";
 import type { ColliderMesh } from "./body/collider-mesh.js";
 import { Material } from "../material/material.js";
+import { RIGID_BODY_COMPONENTS } from "./rigid-body-components.js";
+import { STATIC_COLLIDER_COMPONENTS } from "./static-collider-components.js";
 
 /**
  * The shared, solver-agnostic rigid-body data model — the seam every physics
@@ -48,8 +50,8 @@ export const physicsData = Database.Plugin.create({
         rotation:        Quat.schema, // unified with Node.rotation so a body renders directly
         linearVelocity:  Vec3.schema,
         angularVelocity: Vec3.schema,
-        _prevPosition:   Vec3.schema, // derived: pose before the last fixed step (render interpolation)
-        _prevRotation:   Quat.schema,
+        _prevPosition:   { ...Vec3.schema, nonPersistent: true }, // derived: pose before the last fixed step (render interpolation)
+        _prevRotation:   { ...Quat.schema, nonPersistent: true },
         // Bodies sharing the same non-zero collisionGroup do not collide with each
         // other (they still collide with group 0 / the world) — e.g. a ragdoll's
         // bones. 0 = default (collide with everything). Honored by both solvers
@@ -63,11 +65,11 @@ export const physicsData = Database.Plugin.create({
         colliderMesh:    { default: null as ColliderMesh | null }, // colliderShape "mesh": static triangle soup
     },
     archetypes: {
-        RigidBody: ["bodyType", "colliderShape", "halfExtents", "material", "position", "rotation", "linearVelocity", "angularVelocity"],
-        StaticCollider: ["colliderShape", "halfExtents", "material", "position", "rotation"],
+        RigidBody: [...RIGID_BODY_COMPONENTS],
+        StaticCollider: [...STATIC_COLLIDER_COMPONENTS],
         // A convex-hull body (dynamic / kinematic): authored as a point cloud.
-        ConvexBody: ["bodyType", "colliderShape", "halfExtents", "material", "position", "rotation", "linearVelocity", "angularVelocity", "convexPoints"],
+        ConvexBody: [...RIGID_BODY_COMPONENTS, "convexPoints"],
         // A static triangle-mesh collider (terrain / level geometry).
-        MeshCollider: ["colliderShape", "halfExtents", "material", "position", "rotation", "colliderMesh"],
+        MeshCollider: [...STATIC_COLLIDER_COMPONENTS, "colliderMesh"],
     },
 });

package/src/physics/public.ts

@@ -0,0 +1,23 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+export * from "./physics-data-plugin.js";
+export * from "./rigid-body-components.js";
+export * from "./static-collider-components.js";
+export * from "./collider-primitive-render-archetypes.js";
+export * from "./collider-primitive-render-archetype.js";
+export * from "./physics-clock/physics-clock.js";
+export * from "./physics-clock-plugin.js";
+export * from "./joint/joint-plugin.js";
+export * from "./joint/joint.js";
+export * from "./joint/joint-type/joint-type.js";
+export * from "./body/rigid-body.js";
+export * from "./body/static-collider.js";
+export * from "./body/body-type/body-type.js";
+export * from "./body/collider-shape/collider-shape.js";
+export * from "./solvers/rapier-solver-plugin.js";
+export * from "./solvers/jolt-solver-plugin.js";
+export * from "./solvers/solver-benchmark.js";
+export * from "./solvers/solver-benchmark-options.js";
+export * from "./solvers/solver-benchmark-result.js";
+export * from "./ragdoll/fit-bone-capsules.js";
+export * from "./ragdoll/bone-capsule.js";

package/src/physics/ragdoll/bone-capsule.ts

@@ -0,0 +1,11 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+import type { Quat, Vec3 } from "@adobe/data/math";
+
+export interface BoneCapsule {
+    jointIndex: number;
+    offsetPosition: Vec3;
+    offsetRotation: Quat;
+    radius: number;
+    halfHeight: number;
+}

package/src/physics/ragdoll/fit-bone-capsules-input.ts

@@ -0,0 +1,14 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+import type { SkinVertices } from "./skin-vertices.js";
+
+export interface FitBoneCapsulesInput {
+    jointCount: number;
+    /** glTF inverse-bind matrices, column-major, `jointCount × 16`. */
+    inverseBindMatrices: Float32Array;
+    skin: SkinVertices;
+    /** A vertex joins a bone only if its dominant weight ≥ this (default 0.5). */
+    minWeight?: number;
+    /** Bones with fewer assigned vertices than this get no capsule (default 6). */
+    minVertices?: number;
+}

package/src/physics/ragdoll/fit-bone-capsules.test.ts

@@ -1,7 +1,8 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
 import { describe, it, expect } from "vitest";
-import { fitBoneCapsules, type SkinVertices } from "./fit-bone-capsules.js";
+import { fitBoneCapsules } from "./fit-bone-capsules.js";
+import type { SkinVertices } from "./skin-vertices.js";
 
 const IDENTITY_IBM = (n: number) => {
     const m = new Float32Array(n * 16);

package/src/physics/ragdoll/fit-bone-capsules.ts

@@ -1,6 +1,8 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
 import type { Vec3, Quat } from "@adobe/data/math";
+import type { BoneCapsule } from "./bone-capsule.js";
+import type { FitBoneCapsulesInput } from "./fit-bone-capsules-input.js";
 
 /**
  * Fits one capsule collider to each significant bone of a skinned mesh — the
@@ -16,33 +18,6 @@ import type { Vec3, Quat } from "@adobe/data/math";
  * `jointWorldMatrix · offset`, tracking the animated skeleton.
  */
 
-/** Skinned vertices in mesh (bind) space: `positions` (xyz triples), `joints`
- *  (4 joint indices/vertex), `weights` (4 weights/vertex). */
-export interface SkinVertices {
-    positions: Float32Array;
-    joints: Uint32Array;
-    weights: Float32Array;
-}
-
-export interface FitBoneCapsulesInput {
-    jointCount: number;
-    /** glTF inverse-bind matrices, column-major, `jointCount × 16`. */
-    inverseBindMatrices: Float32Array;
-    skin: SkinVertices;
-    /** A vertex joins a bone only if its dominant weight ≥ this (default 0.5). */
-    minWeight?: number;
-    /** Bones with fewer assigned vertices than this get no capsule (default 6). */
-    minVertices?: number;
-}
-
-export interface BoneCapsule {
-    jointIndex: number;
-    offsetPosition: Vec3; // capsule centre, bone-bind-local
-    offsetRotation: Quat; // orients the Y-aligned capsule onto the fitted axis, bone-bind-local
-    radius: number;
-    halfHeight: number;   // half-length of the cylindrical section
-}
-
 /** Transform a point by a column-major 4×4 matrix (slice `o..o+16`), into `out`. */
 function transformPoint(m: Float32Array, o: number, x: number, y: number, z: number, out: [number, number, number]): void {
     out[0] = m[o] * x + m[o + 4] * y + m[o + 8] * z + m[o + 12];

package/src/physics/ragdoll/skin-vertices.ts

@@ -0,0 +1,8 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+/** Skinned vertices in mesh (bind) space. */
+export interface SkinVertices {
+    positions: Float32Array;
+    joints: Uint32Array;
+    weights: Float32Array;
+}

package/src/physics/rigid-body-components.ts

@@ -0,0 +1,13 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+/** Column set shared by `RigidBody`, `ConvexBody`, and `VoxelRigidBody`. */
+export const RIGID_BODY_COMPONENTS = [
+    "bodyType",
+    "colliderShape",
+    "halfExtents",
+    "material",
+    "position",
+    "rotation",
+    "linearVelocity",
+    "angularVelocity",
+] as const;

package/src/physics/solvers/README.md

@@ -7,6 +7,10 @@ scene runs unchanged on any solver** (`Database.Plugin.combine(scene, solver)`).
 
 Two production-grade solvers ship, both compiled to WASM and wired identically:
 
+```ts
+import { joltSolver, rapierSolver } from "@adobe/data-gpu/physics";
+```
+
 | solver | engine | license |
 | --- | --- | --- |
 | `joltSolver` | Jolt Physics (Jorrit Rouwe) | MIT |

package/src/physics/solvers/jolt-solver-plugin.ts

@@ -2,6 +2,7 @@
 
 import initJolt from "jolt-physics";
 import { Database, type Entity } from "@adobe/data/ecs";
+import { isVoxelShapePhysicsPending } from "../is-voxel-shape-physics-pending.js";
 import { True } from "@adobe/data/schema";
 import { physicsClock } from "../physics-clock-plugin.js";
 import { physicsData } from "../physics-data-plugin.js";
@@ -9,6 +10,7 @@ import { jointData } from "../joint/joint-plugin.js";
 import { BodyType } from "../body/body-type/body-type.js";
 import { ColliderShape } from "../body/collider-shape/collider-shape.js";
 import type { ColliderMesh } from "../body/collider-mesh.js";
+import { massFromVolume } from "../body/collider-shape/mass-from-volume.js";
 
 /**
  * A third rigid-body solver behind the same `physicsData` seam — Jolt Physics
@@ -60,7 +62,7 @@ type JVec3 = InstanceType<JoltModule["Vec3"]>;
 type JShape = InstanceType<JoltModule["Shape"]>;
 type JPhysicsSystem = InstanceType<JoltModule["PhysicsSystem"]>;
 
-interface MatProps { restitution: number; friction: number }
+interface MatProps { density: number; restitution: number; friction: number }
 
 /** The live Jolt world, published once WASM init completes, so Jolt-native
  *  extensions (e.g. `joltRagdoll`) can add their own bodies/constraints into the
@@ -76,8 +78,8 @@ export interface JoltContext {
 export const joltSolver = Database.Plugin.create({
     extends: Database.Plugin.combine(physicsData, jointData, physicsClock),
     components: {
-        _joltBody: True.schema, // tag: this body has been mirrored into the Jolt world
-        _joltJoint: True.schema, // tag: this joint has been mirrored into the Jolt world
+        _joltBody: { ...True.schema, nonPersistent: true }, // tag: this body has been mirrored into the Jolt world
+        _joltJoint: { ...True.schema, nonPersistent: true }, // tag: this joint has been mirrored into the Jolt world
     },
     resources: {
         _joltContext: { default: null as JoltContext | null, nonPersistent: true },
@@ -95,8 +97,8 @@ export const joltSolver = Database.Plugin.create({
                 const bodies = new Map<Entity, JBody>(); // entity → Jolt body
 
                 const matPropsOf = (id: Entity): MatProps => {
-                    const m = db.store.read(id) as { restitution?: number; friction?: number } | null;
-                    return { restitution: m?.restitution ?? 0.2, friction: m?.friction ?? 0.5 };
+                    const m = db.store.read(id) as { density?: number; restitution?: number; friction?: number } | null;
+                    return { density: m?.density ?? 1, restitution: m?.restitution ?? 0.2, friction: m?.friction ?? 0.5 };
                 };
 
                 // hull/mesh colliders may be auto-generated from a model that's still
@@ -197,6 +199,16 @@ export const joltSolver = Database.Plugin.create({
                     const settings = new jolt.BodyCreationSettings(shp, pos, rot, motionType, layer);
                     settings.mRestitution = m.restitution;
                     settings.mFriction = m.friction;
+                    if (motion === "dynamic") {
+                        const volume = shp.GetVolume();
+                        if (volume > 0) {
+                            const mp = shp.GetMassProperties();
+                            mp.ScaleToMass(massFromVolume(volume, m.density));
+                            settings.mOverrideMassProperties = jolt.EOverrideMassProperties_MassAndInertiaProvided;
+                            settings.mMassPropertiesOverride = mp;
+                            jolt.destroy(mp);
+                        }
+                    }
                     const body = bi.CreateBody(settings);
                     bi.AddBody(body.GetID(), motion === "static" ? jolt.EActivation_DontActivate : jolt.EActivation_Activate);
                     if (motion === "dynamic" && (vx || vy || vz || wx || wy || wz)) {
@@ -233,6 +245,7 @@ export const joltSolver = Database.Plugin.create({
                         for (let r = arch.rowCount - 1; r >= 0; r--) {
                             const id = ids.get(r), bodyType = bt.get(r), shape = cs.get(r), h = he.get(r), p = pos.get(r), o = ori.get(r), v = lv.get(r), w = av.get(r);
                             if (!colliderReady(id, shape)) continue; // auto-collider not generated yet
+                            if (isVoxelShapePhysicsPending(db.store, id)) continue;
                             ensureBody(jolt, bi, id, bodyType, shape, h[0], h[1], h[2], mat.get(r), p[0], p[1], p[2], o, v[0], v[1], v[2], w[0], w[1], w[2]);
                             // Tag as mirrored. Dynamics also migrate onto the derived prev-pose
                             // snapshot (the interpolator reads it); kinematic bodies are authored
@@ -247,6 +260,7 @@ export const joltSolver = Database.Plugin.create({
                         for (let r = arch.rowCount - 1; r >= 0; r--) {
                             const id = ids.get(r), shape = cs.get(r), h = he.get(r), p = pos.get(r);
                             if (!colliderReady(id, shape)) continue; // auto-collider not generated yet
+                            if (isVoxelShapePhysicsPending(db.store, id)) continue;
                             ensureBody(jolt, bi, id, "static", shape, h[0], h[1], h[2], mat.get(r), p[0], p[1], p[2], ori.get(r), 0, 0, 0, 0, 0, 0);
                             db.store.update(id, { _joltBody: true });
                         }

package/src/physics/solvers/rapier-solver-plugin.ts

@@ -2,6 +2,7 @@
 
 import RAPIER from "@dimforge/rapier3d-compat";
 import { Database, type Entity } from "@adobe/data/ecs";
+import { isVoxelShapePhysicsPending } from "../is-voxel-shape-physics-pending.js";
 import { True } from "@adobe/data/schema";
 import { physicsClock } from "../physics-clock-plugin.js";
 import { physicsData } from "../physics-data-plugin.js";
@@ -47,8 +48,8 @@ interface MatProps { density: number; restitution: number; friction: number }
 export const rapierSolver = Database.Plugin.create({
     extends: Database.Plugin.combine(physicsData, jointData, physicsClock),
     components: {
-        _rapierBody: True.schema, // tag: this body has been mirrored into the Rapier world
-        _rapierJoint: True.schema, // tag: this joint has been mirrored into the Rapier world
+        _rapierBody: { ...True.schema, nonPersistent: true }, // tag: this body has been mirrored into the Rapier world
+        _rapierJoint: { ...True.schema, nonPersistent: true }, // tag: this joint has been mirrored into the Rapier world
     },
     systems: {
         rapierStep: {
@@ -125,6 +126,7 @@ export const rapierSolver = Database.Plugin.create({
                         for (let r = arch.rowCount - 1; r >= 0; r--) {
                             const id = ids.get(r), bodyType = bt.get(r), shape = cs.get(r), h = he.get(r), p = pos.get(r), o = ori.get(r), v = lv.get(r), w = av.get(r);
                             if (!colliderReady(id, shape)) continue; // auto-collider not generated yet
+                            if (isVoxelShapePhysicsPending(db.store, id)) continue;
                             ensureBody(id, bodyType, shape, h[0], h[1], h[2], mat.get(r), p[0], p[1], p[2], o, v[0], v[1], v[2], w[0], w[1], w[2]);
                             // Tag as mirrored. Dynamics also migrate onto the derived prev-pose
                             // snapshot (the interpolator reads it); kinematic bodies are authored
@@ -139,6 +141,7 @@ export const rapierSolver = Database.Plugin.create({
                         for (let r = arch.rowCount - 1; r >= 0; r--) {
                             const id = ids.get(r), shape = cs.get(r), h = he.get(r), p = pos.get(r);
                             if (!colliderReady(id, shape)) continue; // auto-collider not generated yet
+                            if (isVoxelShapePhysicsPending(db.store, id)) continue;
                             ensureBody(id, "static", shape, h[0], h[1], h[2], mat.get(r), p[0], p[1], p[2], ori.get(r), 0, 0, 0, 0, 0, 0);
                             db.store.update(id, { _rapierBody: true });
                         }

package/src/physics/solvers/solver-benchmark-options.ts

@@ -0,0 +1,16 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+export interface SolverBenchmarkOptions {
+    /** Dynamic bodies dropped into the scene (≈ workload size). Default 256. */
+    bodies?: number;
+    /** Timed frames. Default 300. */
+    frames?: number;
+    /** Warm-up frames before timing. Default 90. */
+    warmupFrames?: number;
+    /** Fixed timestep per frame (seconds). Default 1/60. */
+    dt?: number;
+    /** Fraction of `bodies` that are spheres (rest are boxes). Default 0.5. */
+    sphereFraction?: number;
+    /** Extra static collider boxes as resting scenery. Default 0. */
+    staticBodies?: number;
+}

package/src/physics/solvers/solver-benchmark-result.ts

@@ -0,0 +1,17 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+export interface SolverBenchmarkResult {
+    bodies: number;
+    frames: number;
+    /** Total wall-clock time of the timed frames (ms). */
+    totalMs: number;
+    /** Mean cost of one frame (ms). */
+    msPerFrame: number;
+    /** Simulation frames per real second. */
+    simFps: number;
+    /** Slowest single frame (ms). */
+    maxFrameMs: number;
+    avgY: number;
+    maxSpeed: number;
+    belowFloor: number;
+}

package/src/physics/solvers/solver-benchmark.ts

@@ -1,6 +1,8 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
 import { Database } from "@adobe/data/ecs";
+import type { SolverBenchmarkOptions } from "./solver-benchmark-options.js";
+import type { SolverBenchmarkResult } from "./solver-benchmark-result.js";
 
 /**
  * Headless benchmark harness for a physics **solver plugin** (anything built on
@@ -14,41 +16,6 @@ import { Database } from "@adobe/data/ecs";
  * yields to the event loop so that init + scene settling complete before timing.
  */
 
-export interface SolverBenchmarkOptions {
-    /** Dynamic bodies dropped into the scene (≈ workload size). Default 256. */
-    bodies?: number;
-    /** Timed frames. Default 300. */
-    frames?: number;
-    /** Warm-up frames before timing (lets async init finish + the pile settle). Default 90. */
-    warmupFrames?: number;
-    /** Fixed timestep per frame (seconds). Default 1/60. */
-    dt?: number;
-    /** Fraction of `bodies` that are spheres (rest are boxes). Default 0.5. */
-    sphereFraction?: number;
-    /** Extra *static* collider boxes laid out as resting scenery. They barely
-     *  cost the engine (nothing moves) but they ARE mirrored once and then scanned
-     *  by a naive per-frame sync — so this isolates the gather/sync overhead, which
-     *  is the realistic "many static, few dynamic" target workload. Default 0. */
-    staticBodies?: number;
-}
-
-export interface SolverBenchmarkResult {
-    bodies: number;
-    frames: number;
-    /** Total wall-clock time of the timed frames (ms). */
-    totalMs: number;
-    /** Mean cost of one frame (ms) — the headline number. */
-    msPerFrame: number;
-    /** Simulation frames per real second (1000 / msPerFrame). */
-    simFps: number;
-    /** Slowest single frame (ms) — surfaces hitches. */
-    maxFrameMs: number;
-    // --- coarse end-state, for cross-solver parity / sanity (not perf) ---
-    avgY: number;      // mean height of dynamic bodies (piled ≈ low, exploded ≈ wild)
-    maxSpeed: number;  // fastest dynamic body (a stable pile is near 0)
-    belowFloor: number; // dynamic bodies that sank below the floor top (should be 0)
-}
-
 interface LooseStore {
     archetypes: Record<string, { insert(v: unknown): number }>;
     queryArchetypes(include: readonly string[], opts?: { exclude?: readonly string[] }): Iterable<{

package/src/physics/static-collider-components.ts

@@ -0,0 +1,10 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+/** Column set shared by `StaticCollider`, `MeshCollider`, and `VoxelStaticCollider`. */
+export const STATIC_COLLIDER_COMPONENTS = [
+    "colliderShape",
+    "halfExtents",
+    "material",
+    "position",
+    "rotation",
+] as const;