@vgai/engine 0.5.12 → 0.5.14

package/dist/setup/setup-particles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setup-particles.d.ts","sourceRoot":"","sources":["../../src/setup/setup-particles.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AACpC,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAE/C,MAAM,WAAW,gBAAgB;IAC/B,eAAe,EAAE,eAAe,CAAC;CAClC;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,GAAG,gBAAgB,CAKnE"}
+{"version":3,"file":"setup-particles.d.ts","sourceRoot":"","sources":["../../src/setup/setup-particles.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AACpC,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAG/C,MAAM,WAAW,gBAAgB;IAC/B,eAAe,EAAE,eAAe,CAAC;CAClC;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,GAAG,gBAAgB,CAanE"}

package/dist/setup/setup-particles.js

@@ -1,4 +1,5 @@
 import { BatchedRenderer } from 'three.quarks';
+import { farDepthTexture } from '../render/soft-particle-depth';
 /**
  * Creates the three.quarks BatchedRenderer for GPU particle systems.
  *
@@ -11,6 +12,14 @@ import { BatchedRenderer } from 'three.quarks';
  */
 export function setupParticles(scene) {
     const batchedRenderer = new BatchedRenderer();
+    // Seed the soft-particle depth sampler BEFORE any batch exists, so every
+    // batch this renderer later builds inherits it (`BatchedRenderer.addSystem`
+    // applies `this.depthTexture` to each new batch). A `softParticles` batch
+    // whose `depthTexture` uniform is still `null` samples black and multiplies
+    // every particle away; the far-depth default makes that same batch render
+    // exactly as an unfaded one until a real depth pass supplies the scene's own.
+    // See `render/soft-particle-depth.ts`.
+    batchedRenderer.setDepthTexture(farDepthTexture());
     scene.add(batchedRenderer);
     return { batchedRenderer };
 }

package/dist/world3d-react/r3f-adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"r3f-adapter.d.ts","sourceRoot":"","sources":["../../src/world3d-react/r3f-adapter.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AASH,OAAO,EAAiB,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AACtD,OAAO,KAAK,EAAoB,WAAW,EAAoB,MAAM,YAAY,CAAC;AAalF,OAAO,EAA4B,KAAK,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAYvF,sEAAsE;AACtE,MAAM,WAAW,uBAAuB;IACtC,qEAAqE;IACrE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB;;uBAEmB;IACnB,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC;IAC5B;;;;0CAIsC;IACtC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAClD;;;iDAG6C;IAC7C,QAAQ,CAAC,QAAQ,CAAC,EAAE,mBAAmB,GAAG,SAAS,CAAC;CACrD;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,GAAG,WAAW,CAge9E"}
+{"version":3,"file":"r3f-adapter.d.ts","sourceRoot":"","sources":["../../src/world3d-react/r3f-adapter.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAUH,OAAO,EAA2B,KAAK,SAAS,EAAsB,MAAM,OAAO,CAAC;AACpF,OAAO,KAAK,EAAoB,WAAW,EAAoB,MAAM,YAAY,CAAC;AAclF,OAAO,EAA4B,KAAK,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AA2CvF,sEAAsE;AACtE,MAAM,WAAW,uBAAuB;IACtC,qEAAqE;IACrE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB;;uBAEmB;IACnB,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC;IAC5B;;;;0CAIsC;IACtC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAClD;;;iDAG6C;IAC7C,QAAQ,CAAC,QAAQ,CAAC,EAAE,mBAAmB,GAAG,SAAS,CAAC;CACrD;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,GAAG,WAAW,CA6e9E"}

package/dist/world3d-react/r3f-adapter.js

@@ -18,18 +18,49 @@
  * project guarantees via its Vite `resolve.dedupe: ['three', 'react',
  * 'react-dom']` (see `examples/r3f-first-party/vite.config.ts`).
  */
-import { advance, createRoot, extend, events as pointerEvents, } from '@react-three/fiber';
-import { createElement } from 'react';
+import { advance, createRoot, extend, events as pointerEvents, useFrame, } from '@react-three/fiber';
+import { createElement, Fragment, useEffect, useMemo } from 'react';
 import { registerRenderVitals } from '../dev/register-render-vitals';
 import { createRenderDebugAdapter, frameCaptureContextFor, } from '../dev/render-debug-adapter';
 import { collectRenderMemory } from '../dev/render-memory';
 import { RENDER_SUBMIT_PHASE } from '../dev/render-vitals';
 import { createWebGLFrameCapture } from '../dev/webgl-frame-capture';
 import { WorldProvider } from '../react/world-state';
+import { createSoftParticleDepthPass } from '../render/soft-particle-depth';
 import { devLayersEnabled } from '../runtime/dev-layers';
 import { EngineBridge } from './engine-bridge';
 import { applyWorldRendererConfig } from './renderer-config';
 import { createR3FRootContext } from './world-context';
+/**
+ * Scene depth for any soft-particle system this world mounted, drawn between
+ * gameplay and the draw.
+ *
+ * `useFrame`'s priority is the whole reason this is a component rather than an
+ * engine phase: `systems.run(dt)` below finishes BEFORE `advance()`, and
+ * `advance()` is where every `useFrame` gameplay callback moves the frame's
+ * transforms — depth taken from an engine phase would be one frame stale.
+ * Priority `0` puts it after every negative-priority callback (fiber sorts
+ * subscribers by priority) and before both a positive-priority composer and
+ * fiber's own `state.gl.render` — and, unlike a positive priority, it does NOT
+ * flip fiber into manual-render mode (`internal.priority` only counts
+ * subscribers with `priority > 0`), so mounting it can never stop an ordinary
+ * world from drawing itself.
+ *
+ * Rendered as the LAST child of the adapter's tree so its subscription lands
+ * after the world's own (React completes children before siblings, and fiber's
+ * sort is stable) — the tie-break among priority-0 callbacks is insertion
+ * order.
+ *
+ * Costs nothing while no soft-particle system is armed — see
+ * `../render/soft-particle-depth.ts` for what "armed" means and what the pass
+ * spends when it is.
+ */
+function SoftParticleDepth() {
+    const pass = useMemo(() => createSoftParticleDepthPass(), []);
+    useEffect(() => () => pass.dispose(), [pass]);
+    useFrame(({ gl, scene, camera }) => pass.render(gl, scene, camera), 0);
+    return null;
+}
 /**
  * Build a `RootAdapter` that mounts `options.content` through
  * react-three-fiber, gated entirely by the host's own loop and rendering
@@ -214,7 +245,10 @@ export function createR3FAdapter(options) {
             // hosts, so the provider is conditional and those hooks stay the inert
             // no-ops they already document themselves to be.
             const game = runtime.ctx.game;
-            root.render(createElement(EngineBridge.Provider, { value: bridge }, game ? createElement(WorldProvider, { game }, content) : content));
+            // `SoftParticleDepth` trails the world's own tree deliberately — see its
+            // docblock for why the subscription must land last.
+            const world = createElement(Fragment, null, content, createElement(SoftParticleDepth, { key: 'vgai-soft-particle-depth' }));
+            root.render(createElement(EngineBridge.Provider, { value: bridge }, game ? createElement(WorldProvider, { game }, world) : world));
             // A reconcile-time crash (e.g. a missing `extend` catalogue entry)
             // surfaces as an uncaught window error and `onCreated` never fires —
             // without this guard, `mount()` would await `statePromise` FOREVER and
@@ -401,6 +435,11 @@ export function createR3FAdapter(options) {
                     return live().camera;
                 },
                 drivesOwnLoop: false,
+                // REPORTED for a host that draws this scene with a renderer other than
+                // the one it mounted us against — see `MountedThreeRoot.rendererConfig`.
+                // It is the same object already applied to `host.renderer` above; the
+                // report never applies anything itself.
+                rendererConfig: rendererConfig,
                 // Adapter surface: `debug` (the shared game registry) and, when a real
                 // WebGL2 context exists, `renderDebug` are engine-seeded. Game code
                 // adds its own capabilities via `ctx.registerSystemAdapter` exactly

package/dist/world3d-react/rapier-physics-bridge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rapier-physics-bridge.d.ts","sourceRoot":"","sources":["../../src/world3d-react/rapier-physics-bridge.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AAYH,MAAM,WAAW,wBAAwB;IACvC;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CAClD;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,aAAa,EAAE,EAAE,wBAAwB,GAAG,IAAI,CAkDrF"}
+{"version":3,"file":"rapier-physics-bridge.d.ts","sourceRoot":"","sources":["../../src/world3d-react/rapier-physics-bridge.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AAkBH,MAAM,WAAW,wBAAwB;IACvC;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CAClD;AAkCD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,aAAa,EAAE,EAAE,wBAAwB,GAAG,IAAI,CA0PrF"}

package/dist/world3d-react/rapier-physics-bridge.js

@@ -60,8 +60,32 @@
  */
 import { useRapier } from '@react-three/rapier';
 import { useEffect } from 'react';
+import * as THREE from 'three';
 import { createRapierBodyEditing, } from '../adapter/rapier-physics-adapter';
 import { useGameContext } from './engine-bridge';
+function lateEntityObject(states, nodeId) {
+    let found;
+    for (const state of states) {
+        state.object.traverse((candidate) => {
+            if (!found && candidate.userData['entityId'] === nodeId)
+                found = candidate;
+        });
+        if (found)
+            return found;
+    }
+    return undefined;
+}
+function owningBody(object, states) {
+    const byObject = new Map();
+    for (const state of states)
+        byObject.set(state.object, state.rigidBody);
+    for (let node = object; node; node = node.parent) {
+        const body = byObject.get(node);
+        if (body)
+            return body;
+    }
+    return undefined;
+}
 /**
  * Register this R3F world's `@react-three/rapier` physics as the game's
  * `SystemAdapters.physics`. Mount it once, INSIDE `<Physics>` (it reads
@@ -69,7 +93,7 @@ import { useGameContext } from './engine-bridge';
  */
 export function RapierPhysicsBridge({ onDebugChange }) {
     const ctx = useGameContext();
-    const { rigidBodyStates } = useRapier();
+    const { colliderStates, rapier, rigidBodyStates, world } = useRapier();
     const registerSystemAdapter = ctx.registerSystemAdapter;
     useEffect(() => {
         if (!registerSystemAdapter)
@@ -96,25 +120,191 @@ export function RapierPhysicsBridge({ onDebugChange }) {
          * `setSceneCamera`), so a destructured copy would be permanently absent.
          */
         const bodyFor = (nodeId) => {
-            const object = ctx.sceneIndex?.byEntityId(nodeId);
+            const indexed = ctx.sceneIndex?.byEntityId(nodeId);
+            const object = indexed ?? lateEntityObject(rigidBodyStates.values(), nodeId);
+            if (!indexed && object) {
+                // The editor assigns its stable authoring entity ids AFTER Fiber's
+                // first commit, while the root's SceneIndex is constructed during
+                // that commit. Resolve the one late id inside the library-owned body
+                // subtrees and immediately reindex it; subsequent gestures take the
+                // normal indexed path. This is the SceneIndex's documented escape
+                // hatch for a userData id written after construction, not a parallel
+                // scene mirror.
+                ctx.sceneIndex?.reindex(object);
+            }
             if (!object)
                 return undefined;
-            const byObject = new Map();
-            for (const state of rigidBodyStates.values())
-                byObject.set(state.object, state.rigidBody);
-            for (let node = object; node; node = node.parent) {
-                const body = byObject.get(node);
-                if (body)
-                    return body;
+            return owningBody(object, rigidBodyStates.values());
+        };
+        const colliderShape = (collider) => {
+            switch (collider.shapeType()) {
+                case rapier.ShapeType.Cuboid: {
+                    const halfExtents = collider.halfExtents();
+                    return { type: 'cuboid', halfExtents: [halfExtents.x, halfExtents.y, halfExtents.z] };
+                }
+                case rapier.ShapeType.Ball:
+                    return { type: 'ball', radius: collider.radius() };
+                case rapier.ShapeType.Capsule:
+                    return {
+                        type: 'capsule',
+                        halfHeight: collider.halfHeight(),
+                        radius: collider.radius(),
+                    };
+                default:
+                    return null;
+            }
+        };
+        const colliders = (nodeId) => {
+            const body = bodyFor(nodeId);
+            if (!body)
+                return [];
+            const result = [];
+            for (const state of colliderStates.values()) {
+                if (state.collider.parent()?.handle !== body.handle)
+                    continue;
+                const shape = colliderShape(state.collider);
+                if (!shape)
+                    continue;
+                state.object.updateWorldMatrix(true, false);
+                const position = state.collider.translation();
+                const rotation = state.collider.rotation();
+                const scale = state.object.getWorldScale(new THREE.Vector3());
+                result.push({
+                    id: String(state.collider.handle),
+                    shape,
+                    position: [position.x, position.y, position.z],
+                    rotation: [rotation.x, rotation.y, rotation.z, rotation.w],
+                    scale: [Math.abs(scale.x), Math.abs(scale.y), Math.abs(scale.z)],
+                    sensor: state.collider.isSensor(),
+                });
+            }
+            return result.sort((a, b) => Number(a.id) - Number(b.id));
+        };
+        const previewCollider = (colliderId, shape) => {
+            const collider = [...colliderStates.values()].find((state) => String(state.collider.handle) === colliderId)?.collider;
+            if (!collider || colliderShape(collider)?.type !== shape.type)
+                return;
+            switch (shape.type) {
+                case 'cuboid':
+                    collider.setHalfExtents({
+                        x: shape.halfExtents[0],
+                        y: shape.halfExtents[1],
+                        z: shape.halfExtents[2],
+                    });
+                    break;
+                case 'ball':
+                    collider.setRadius(shape.radius);
+                    break;
+                case 'capsule':
+                    collider.setHalfHeight(shape.halfHeight);
+                    collider.setRadius(shape.radius);
+                    break;
             }
-            return undefined;
+        };
+        const jointType = (type) => {
+            switch (type) {
+                case rapier.JointType.Revolute:
+                    return 'revolute';
+                case rapier.JointType.Fixed:
+                    return 'fixed';
+                case rapier.JointType.Prismatic:
+                    return 'prismatic';
+                case rapier.JointType.Rope:
+                    return 'rope';
+                case rapier.JointType.Spring:
+                    return 'spring';
+                case rapier.JointType.Spherical:
+                    return 'spherical';
+                default:
+                    return 'generic';
+            }
+        };
+        const tuple3 = (value) => [
+            value.x,
+            value.y,
+            value.z,
+        ];
+        const tuple4 = (value) => [value.x, value.y, value.z, value.w];
+        const worldAnchor = (body, anchor) => {
+            const point = new THREE.Vector3(anchor.x, anchor.y, anchor.z)
+                .applyQuaternion(new THREE.Quaternion(...tuple4(body.rotation())))
+                .add(new THREE.Vector3(...tuple3(body.translation())));
+            return tuple3(point);
+        };
+        const jointLimits = (joint, type) => {
+            if (type !== 'revolute' && type !== 'prismatic')
+                return {};
+            const unit = joint;
+            return unit.limitsEnabled()
+                ? { limits: { min: unit.limitsMin(), max: unit.limitsMax() } }
+                : {};
+        };
+        const jointAxis = (joint, type, body) => {
+            if (type !== 'revolute' && type !== 'prismatic')
+                return {};
+            const frame = joint.frameX1();
+            const axis = new THREE.Vector3(1, 0, 0).applyQuaternion(new THREE.Quaternion(frame.x, frame.y, frame.z, frame.w));
+            const worldAxis = axis
+                .clone()
+                .applyQuaternion(new THREE.Quaternion(...tuple4(body.rotation())));
+            return { axis: tuple3(axis), worldAxis: tuple3(worldAxis) };
+        };
+        const jointSnapshot = (joint) => {
+            const body1 = joint.body1();
+            const body2 = joint.body2();
+            const anchor1 = joint.anchor1();
+            const anchor2 = joint.anchor2();
+            const type = jointType(joint.type());
+            return {
+                id: String(joint.handle),
+                type,
+                body1: String(body1.handle),
+                body2: String(body2.handle),
+                anchor1: tuple3(anchor1),
+                anchor2: tuple3(anchor2),
+                worldAnchor1: worldAnchor(body1, anchor1),
+                worldAnchor2: worldAnchor(body2, anchor2),
+                body1Position: tuple3(body1.translation()),
+                body2Position: tuple3(body2.translation()),
+                body1Rotation: tuple4(body1.rotation()),
+                body2Rotation: tuple4(body2.rotation()),
+                ...jointAxis(joint, type, body1),
+                ...jointLimits(joint, type),
+                contactsEnabled: joint.contactsEnabled(),
+            };
+        };
+        const joints = (nodeId) => {
+            const body = bodyFor(nodeId);
+            if (!body)
+                return [];
+            const result = [];
+            world.impulseJoints.forEachJointHandleAttachedToRigidBody(body.handle, (handle) => {
+                const joint = world.impulseJoints.get(handle);
+                if (joint)
+                    result.push(jointSnapshot(joint));
+            });
+            return result.sort((a, b) => Number(a.id) - Number(b.id));
+        };
+        const previewJointAnchor = (jointId, endpoint, anchor) => {
+            const joint = world.impulseJoints.get(Number(jointId));
+            if (!joint)
+                return;
+            const value = { x: anchor[0], y: anchor[1], z: anchor[2] };
+            if (endpoint === 0)
+                joint.setAnchor1(value);
+            else
+                joint.setAnchor2(value);
         };
         const adapter = {
             ...createRapierBodyEditing(bodyFor),
             setDebugDrawEnabled: (enabled) => onDebugChange(enabled),
+            colliders,
+            previewCollider,
+            joints,
+            previewJointAnchor,
         };
         registerSystemAdapter('physics', adapter);
         return () => registerSystemAdapter('physics', undefined);
-    }, [ctx, registerSystemAdapter, rigidBodyStates, onDebugChange]);
+    }, [colliderStates, ctx, onDebugChange, rapier, registerSystemAdapter, rigidBodyStates, world]);
     return null;
 }