react-three-game 0.0.100 → 0.0.102

package/README.md

@@ -16,6 +16,7 @@ Built on top of [three.js](https://github.com/mrdoob/three.js), [@react-three/fi
 
 * Website: https://prnth.com/react-three-game
 * Editor: https://prnth.com/react-three-game/editor
+* Starter template: https://github.com/prnthh/react-three-game-starter
 
 ## Install
 
@@ -294,4 +295,4 @@ npm run release
 
 ## License
 
-VPL
+PFYL / VPL

package/dist/index.d.ts

@@ -18,6 +18,8 @@ export { FieldRenderer, FieldGroup, ListEditor, Label, Vector3Input, Vector3Fiel
 export { loadJson, saveJson, exportGLB, exportGLBData, regenerateIds, computeParentWorldMatrix, } from './tools/prefabeditor/utils';
 export type { ExportGLBOptions } from './tools/prefabeditor/utils';
 export { createModelNode, createImageNode, } from './tools/prefabeditor/prefab';
+export { decomposeModelToPrefabNodes } from './tools/prefabeditor/modelPrefab';
+export type { DecomposeModelOptions } from './tools/prefabeditor/modelPrefab';
 export type { PrefabEditorProps, PrefabNode, PrefabEditorRef, } from './tools/prefabeditor/PrefabEditor';
 export type { PrefabRootProps } from './tools/prefabeditor/PrefabRoot';
 export type { AssetRuntime, NodeApi, LiveRef } from './tools/prefabeditor/assetRuntime';

package/dist/index.js

@@ -19,6 +19,7 @@ export { FieldRenderer, FieldGroup, ListEditor, Label, Vector3Input, Vector3Fiel
 // Prefab Editor - Utils
 export { loadJson, saveJson, exportGLB, exportGLBData, regenerateIds, computeParentWorldMatrix, } from './tools/prefabeditor/utils';
 export { createModelNode, createImageNode, } from './tools/prefabeditor/prefab';
+export { decomposeModelToPrefabNodes } from './tools/prefabeditor/modelPrefab';
 export { useAssetRuntime, useNode, useNodeHandle, useNodeObject } from './tools/prefabeditor/assetRuntime';
 export { useScene } from './tools/prefabeditor/PrefabRoot';
 export { MaterialOverridesProvider, useMaterialOverrides } from './tools/prefabeditor/components/MaterialComponent';

package/dist/plugins/crashcat/CrashcatPhysicsComponent.d.ts

@@ -0,0 +1,3 @@
+import { type Component } from "../../tools/prefabeditor/components/ComponentRegistry";
+declare const CrashcatPhysicsComponent: Component;
+export default CrashcatPhysicsComponent;

package/dist/plugins/crashcat/CrashcatPhysicsComponent.js

@@ -0,0 +1,352 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useFrame } from "@react-three/fiber";
+import { useEffect, useMemo, useRef } from "react";
+import { BooleanField, FieldRenderer, StringField, Vector3Field, } from "../../tools/prefabeditor/components/Input";
+import { useAssetRuntime, useNode } from "../../tools/prefabeditor/assetRuntime";
+import { usePrefabStoreApi } from "../../tools/prefabeditor/prefabStore";
+import { PrefabEditorMode, useScene } from "../../tools/prefabeditor/PrefabRoot";
+import { box, capsule, convexHull, MotionQuality, MotionType, rigidBody, sphere, triangleMesh, } from "crashcat";
+import { Matrix4, Quaternion, Vector3 } from "three";
+import { useCrashcat } from "./CrashcatRuntime";
+const MAX_PHYSICS_DELTA = 1 / 30;
+const crashcatPhysicsFields = [
+    {
+        name: "type",
+        type: "select",
+        label: "Motion Type",
+        options: [
+            { value: "fixed", label: "Fixed" },
+            { value: "dynamic", label: "Dynamic" },
+            { value: "kinematicPosition", label: "Kinematic Position" },
+            { value: "kinematicVelocity", label: "Kinematic Velocity" },
+        ],
+    },
+    {
+        name: "colliders",
+        type: "select",
+        label: "Collider",
+        options: [
+            { value: "cuboid", label: "Cuboid" },
+            { value: "ball", label: "Ball" },
+            { value: "capsule", label: "Capsule" },
+            { value: "hull", label: "Hull" },
+            { value: "trimesh", label: "Tri Mesh" },
+        ],
+    },
+    { name: "friction", type: "number", label: "Friction", step: 0.05 },
+    { name: "restitution", type: "number", label: "Restitution", step: 0.05 },
+    { name: "capsuleRadius", type: "number", label: "Capsule Radius", step: 0.05 },
+    { name: "capsuleHalfHeight", type: "number", label: "Capsule Half Height", step: 0.05 },
+];
+function CrashcatPhysicsEditor({ component, onUpdate }) {
+    return (_jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 10 }, children: [_jsx(FieldRenderer, { fields: crashcatPhysicsFields, values: component.properties, onChange: onUpdate }), _jsx(BooleanField, { name: "sensor", label: "Sensor", values: component.properties, onChange: onUpdate, fallback: false }), _jsx(Vector3Field, { name: "linearVelocity", label: "Linear Velocity", values: component.properties, onChange: onUpdate, fallback: [0, 0, 0] }), _jsx(Vector3Field, { name: "angularVelocity", label: "Angular Velocity", values: component.properties, onChange: onUpdate, fallback: [0, 0, 0] }), _jsx(StringField, { name: "collisionEnterEventName", label: "Collision Enter", values: component.properties, onChange: onUpdate, fallback: "" }), _jsx(StringField, { name: "collisionExitEventName", label: "Collision Exit", values: component.properties, onChange: onUpdate, fallback: "" }), _jsx(StringField, { name: "sensorEnterEventName", label: "Sensor Enter", values: component.properties, onChange: onUpdate, fallback: "" }), _jsx(StringField, { name: "sensorExitEventName", label: "Sensor Exit", values: component.properties, onChange: onUpdate, fallback: "" })] }));
+}
+const inverseWorldMatrix = new Matrix4();
+const childToLocalMatrix = new Matrix4();
+const scratchVertex = new Vector3();
+const scratchScale = new Vector3();
+const scratchPosition = new Vector3();
+const scratchBoundsSize = new Vector3();
+const worldQuaternion = new Quaternion();
+const parentWorldQuaternion = new Quaternion();
+const localQuaternion = new Quaternion();
+function collectGeometryData(object) {
+    const positions = [];
+    const indices = [];
+    let vertexOffset = 0;
+    inverseWorldMatrix.copy(object.matrixWorld).invert();
+    object.traverse((child) => {
+        var _a;
+        const geometry = child.geometry;
+        const positionAttribute = (_a = geometry === null || geometry === void 0 ? void 0 : geometry.attributes) === null || _a === void 0 ? void 0 : _a.position;
+        if (!positionAttribute)
+            return;
+        childToLocalMatrix.multiplyMatrices(inverseWorldMatrix, child.matrixWorld);
+        for (let i = 0; i < positionAttribute.count; i += 1) {
+            scratchVertex
+                .set(positionAttribute.getX(i), positionAttribute.getY(i), positionAttribute.getZ(i))
+                .applyMatrix4(childToLocalMatrix);
+            positions.push(scratchVertex.x, scratchVertex.y, scratchVertex.z);
+        }
+        if (geometry.index) {
+            for (let i = 0; i < geometry.index.count; i += 1) {
+                indices.push(vertexOffset + geometry.index.getX(i));
+            }
+        }
+        else {
+            for (let i = 0; i < positionAttribute.count; i += 1) {
+                indices.push(vertexOffset + i);
+            }
+        }
+        vertexOffset += positionAttribute.count;
+    });
+    if (positions.length === 0 || indices.length < 3)
+        return null;
+    return { positions, indices };
+}
+function createShapeForObject(object, physics) {
+    var _a, _b;
+    object.updateWorldMatrix(true, true);
+    if (physics.colliders === "trimesh") {
+        const geometry = collectGeometryData(object);
+        return geometry ? triangleMesh.create(geometry) : null;
+    }
+    if (physics.colliders === "hull") {
+        const geometry = collectGeometryData(object);
+        return geometry ? convexHull.create({ positions: geometry.positions }) : null;
+    }
+    if (physics.colliders === "capsule") {
+        return capsule.create({
+            radius: Math.max((_a = physics.capsuleRadius) !== null && _a !== void 0 ? _a : 0.35, 0.01),
+            halfHeightOfCylinder: Math.max((_b = physics.capsuleHalfHeight) !== null && _b !== void 0 ? _b : 0.45, 0.01),
+        });
+    }
+    object.getWorldScale(scratchScale);
+    const geometry = collectGeometryData(object);
+    if (!geometry)
+        return null;
+    if (physics.colliders === "ball") {
+        let maxRadiusSq = 0;
+        for (let i = 0; i < geometry.positions.length; i += 3) {
+            const x = geometry.positions[i] * scratchScale.x;
+            const y = geometry.positions[i + 1] * scratchScale.y;
+            const z = geometry.positions[i + 2] * scratchScale.z;
+            maxRadiusSq = Math.max(maxRadiusSq, x * x + y * y + z * z);
+        }
+        return sphere.create({ radius: Math.max(Math.sqrt(maxRadiusSq), 0.01) });
+    }
+    let minX = Infinity, minY = Infinity, minZ = Infinity;
+    let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
+    for (let i = 0; i < geometry.positions.length; i += 3) {
+        const x = geometry.positions[i] * scratchScale.x;
+        const y = geometry.positions[i + 1] * scratchScale.y;
+        const z = geometry.positions[i + 2] * scratchScale.z;
+        if (x < minX)
+            minX = x;
+        if (x > maxX)
+            maxX = x;
+        if (y < minY)
+            minY = y;
+        if (y > maxY)
+            maxY = y;
+        if (z < minZ)
+            minZ = z;
+        if (z > maxZ)
+            maxZ = z;
+    }
+    scratchBoundsSize.set(maxX - minX, maxY - minY, maxZ - minZ);
+    return box.create({
+        halfExtents: [
+            Math.max(scratchBoundsSize.x * 0.5, 0.01),
+            Math.max(scratchBoundsSize.y * 0.5, 0.01),
+            Math.max(scratchBoundsSize.z * 0.5, 0.01),
+        ],
+    });
+}
+function toMotionType(physics) {
+    if (physics.type === "dynamic")
+        return MotionType.DYNAMIC;
+    if (physics.type === "kinematicPosition" || physics.type === "kinematicVelocity")
+        return MotionType.KINEMATIC;
+    return MotionType.STATIC;
+}
+function toMotionQuality(physics) {
+    return physics.type === "kinematicPosition" ? MotionQuality.LINEAR_CAST : undefined;
+}
+function setObjectWorldTransform(object, position, quaternion) {
+    if (!object.parent) {
+        object.position.set(position[0], position[1], position[2]);
+        object.quaternion.set(quaternion[0], quaternion[1], quaternion[2], quaternion[3]);
+        object.updateMatrixWorld(true);
+        return;
+    }
+    scratchPosition.set(position[0], position[1], position[2]);
+    object.parent.worldToLocal(scratchPosition);
+    object.position.copy(scratchPosition);
+    object.parent.getWorldQuaternion(parentWorldQuaternion);
+    worldQuaternion.set(quaternion[0], quaternion[1], quaternion[2], quaternion[3]);
+    localQuaternion.copy(parentWorldQuaternion).invert().multiply(worldQuaternion);
+    object.quaternion.copy(localQuaternion);
+    object.updateMatrixWorld(true);
+}
+function syncObjectToBody(world, body, object, position, quaternion, delta) {
+    object.getWorldPosition(scratchPosition);
+    object.getWorldQuaternion(worldQuaternion);
+    position.splice(0, 3, scratchPosition.x, scratchPosition.y, scratchPosition.z);
+    quaternion.splice(0, 4, worldQuaternion.x, worldQuaternion.y, worldQuaternion.z, worldQuaternion.w);
+    if (delta === undefined) {
+        rigidBody.setPosition(world, body, position, false);
+        rigidBody.setQuaternion(world, body, quaternion, false);
+    }
+    else {
+        rigidBody.moveKinematic(body, position, quaternion, delta);
+    }
+}
+function bodyTransformChanged(body, lastPosition, lastQuaternion) {
+    const position = body.position;
+    const quaternion = body.quaternion;
+    return !lastPosition
+        || position[0] !== lastPosition[0]
+        || position[1] !== lastPosition[1]
+        || position[2] !== lastPosition[2]
+        || quaternion[0] !== (lastQuaternion === null || lastQuaternion === void 0 ? void 0 : lastQuaternion[0])
+        || quaternion[1] !== (lastQuaternion === null || lastQuaternion === void 0 ? void 0 : lastQuaternion[1])
+        || quaternion[2] !== (lastQuaternion === null || lastQuaternion === void 0 ? void 0 : lastQuaternion[2])
+        || quaternion[3] !== (lastQuaternion === null || lastQuaternion === void 0 ? void 0 : lastQuaternion[3]);
+}
+function getRegisteredBody(api, nodeId, body) {
+    return api && body && api.getBody(nodeId) === body ? body : null;
+}
+function CrashcatPhysicsView({ properties, children }) {
+    const { nodeId, getObject } = useNode();
+    const scene = useScene();
+    const store = usePrefabStoreApi();
+    const api = useCrashcat();
+    const { getAssetRevision } = useAssetRuntime();
+    const revision = getAssetRevision();
+    const bodyRef = useRef(null);
+    const motionTypeRef = useRef(MotionType.STATIC);
+    const syncPositionRef = useRef([0, 0, 0]);
+    const syncQuaternionRef = useRef([0, 0, 0, 1]);
+    const lastPositionRef = useRef(null);
+    const lastQuaternionRef = useRef(null);
+    const { angularVelocity, capsuleHalfHeight, capsuleRadius, colliders, collisionEnterEventName, collisionExitEventName, friction, linearVelocity, restitution, sensor, sensorEnterEventName, sensorExitEventName, type, } = properties;
+    const physics = useMemo(() => ({
+        angularVelocity,
+        capsuleHalfHeight,
+        capsuleRadius,
+        colliders,
+        collisionEnterEventName,
+        collisionExitEventName,
+        friction,
+        linearVelocity,
+        restitution,
+        sensor,
+        sensorEnterEventName,
+        sensorExitEventName,
+        type,
+    }), [
+        angularVelocity,
+        capsuleHalfHeight,
+        capsuleRadius,
+        colliders,
+        collisionEnterEventName,
+        collisionExitEventName,
+        friction,
+        linearVelocity,
+        restitution,
+        sensor,
+        sensorEnterEventName,
+        sensorExitEventName,
+        type,
+    ]);
+    useEffect(() => {
+        // Rebuild mesh-derived colliders when referenced assets finish loading.
+        void revision;
+        if (!api)
+            return;
+        const object = getObject();
+        if (!object)
+            return;
+        const shape = createShapeForObject(object, physics);
+        if (!shape)
+            return;
+        object.updateWorldMatrix(true, true);
+        object.getWorldPosition(scratchPosition);
+        const wq = new Quaternion();
+        object.getWorldQuaternion(wq);
+        const motionType = toMotionType(physics);
+        const motionQuality = toMotionQuality(physics);
+        const isKinematic = motionType === MotionType.KINEMATIC;
+        const isStatic = motionType === MotionType.STATIC;
+        const body = rigidBody.create(api.world, {
+            shape,
+            motionType,
+            motionQuality,
+            objectLayer: isStatic ? api.staticObjectLayer : api.movingObjectLayer,
+            position: [scratchPosition.x, scratchPosition.y, scratchPosition.z],
+            quaternion: [wq.x, wq.y, wq.z, wq.w],
+            sensor: Boolean(physics.sensor),
+            collideKinematicVsNonDynamic: isKinematic,
+            friction: physics.friction,
+            restitution: physics.restitution,
+            userData: { nodeId },
+        });
+        if (physics.linearVelocity) {
+            rigidBody.setLinearVelocity(api.world, body, physics.linearVelocity);
+        }
+        if (physics.angularVelocity) {
+            rigidBody.setAngularVelocity(api.world, body, physics.angularVelocity);
+        }
+        bodyRef.current = body;
+        motionTypeRef.current = motionType;
+        lastPositionRef.current = null;
+        lastQuaternionRef.current = null;
+        api.register(nodeId, body, {
+            motionType,
+            sensor: Boolean(physics.sensor),
+            events: {
+                collisionEnter: physics.collisionEnterEventName,
+                collisionExit: physics.collisionExitEventName,
+                sensorEnter: physics.sensorEnterEventName,
+                sensorExit: physics.sensorExitEventName,
+            },
+        });
+        return () => {
+            bodyRef.current = null;
+            api.unregister(nodeId);
+        };
+    }, [
+        api,
+        getObject,
+        nodeId,
+        physics,
+        revision,
+    ]);
+    useEffect(() => {
+        const syncEditBody = () => {
+            const body = getRegisteredBody(api, nodeId, bodyRef.current);
+            const object = getObject();
+            if (!api || !body || !object || scene.mode !== PrefabEditorMode.Edit)
+                return;
+            syncObjectToBody(api.world, body, object, syncPositionRef.current, syncQuaternionRef.current);
+        };
+        syncEditBody();
+        return store.subscribe(syncEditBody);
+    }, [api, getObject, nodeId, scene.mode, store]);
+    useFrame((_, delta) => {
+        const body = getRegisteredBody(api, nodeId, bodyRef.current);
+        const object = getObject();
+        if (!api || !body || !object || scene.mode !== PrefabEditorMode.Play || motionTypeRef.current !== MotionType.KINEMATIC)
+            return;
+        syncObjectToBody(api.world, body, object, syncPositionRef.current, syncQuaternionRef.current, Math.min(delta, MAX_PHYSICS_DELTA));
+    }, -2);
+    useFrame(() => {
+        const body = getRegisteredBody(api, nodeId, bodyRef.current);
+        const object = getObject();
+        if (!api || !body || !object || motionTypeRef.current !== MotionType.DYNAMIC || scene.mode !== PrefabEditorMode.Play)
+            return;
+        if (bodyTransformChanged(body, lastPositionRef.current, lastQuaternionRef.current)) {
+            setObjectWorldTransform(object, body.position, body.quaternion);
+            lastPositionRef.current = [body.position[0], body.position[1], body.position[2]];
+            lastQuaternionRef.current = [body.quaternion[0], body.quaternion[1], body.quaternion[2], body.quaternion[3]];
+        }
+        if (body.position[1] < -40) {
+            bodyRef.current = null;
+            api.unregister(nodeId);
+        }
+    });
+    return _jsx(_Fragment, { children: children });
+}
+const CrashcatPhysicsComponent = {
+    name: "CrashcatPhysics",
+    Editor: CrashcatPhysicsEditor,
+    View: CrashcatPhysicsView,
+    defaultProperties: {
+        type: "fixed",
+        colliders: "cuboid",
+        sensor: false,
+    },
+};
+export default CrashcatPhysicsComponent;

package/dist/plugins/crashcat/CrashcatRuntime.d.ts

@@ -0,0 +1,27 @@
+import { MotionType, type Filter, type RigidBody, type World } from "crashcat";
+export type CrashcatEventConfig = {
+    collisionEnter?: string;
+    collisionExit?: string;
+    sensorEnter?: string;
+    sensorExit?: string;
+};
+export type BodyMeta = {
+    nodeId: string;
+    motionType: MotionType;
+    sensor: boolean;
+    events?: CrashcatEventConfig;
+};
+export interface CrashcatApi {
+    world: World;
+    queryFilter: Filter;
+    staticObjectLayer: number;
+    movingObjectLayer: number;
+    register: (nodeId: string, body: RigidBody, meta: Omit<BodyMeta, "nodeId">) => void;
+    unregister: (nodeId: string) => void;
+    getBody: (nodeId: string) => RigidBody | null;
+}
+export declare function useCrashcat(): CrashcatApi | null;
+export declare function CrashcatRuntime({ debug, children }: {
+    debug?: boolean;
+    children?: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/plugins/crashcat/CrashcatRuntime.js

@@ -0,0 +1,154 @@
+"use client";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useFrame } from "@react-three/fiber";
+import { addBroadphaseLayer, addObjectLayer, createWorld, createWorldSettings, enableCollision, filter, registerAll, rigidBody, updateWorld, } from "crashcat";
+import { debugRenderer } from "crashcat/three";
+import { useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
+import { gameEvents } from "../../tools/prefabeditor/GameEvents";
+import { PrefabEditorMode, useScene } from "../../tools/prefabeditor/PrefabRoot";
+const SLEEP_TIME_BEFORE_REST = 0.1;
+const SLEEP_POINT_VELOCITY_THRESHOLD = 0.06;
+const MAX_PHYSICS_DELTA = 1 / 30;
+let didRegisterCrashcat = false;
+function ensureCrashcatRegistered() {
+    if (didRegisterCrashcat)
+        return;
+    registerAll();
+    didRegisterCrashcat = true;
+}
+const crashcatListeners = new Set();
+let crashcatApi = null;
+export function useCrashcat() {
+    return useSyncExternalStore((listener) => (crashcatListeners.add(listener), () => crashcatListeners.delete(listener)), () => crashcatApi, () => crashcatApi);
+}
+function setCrashcatApi(api) {
+    crashcatApi = api;
+    crashcatListeners.forEach((listener) => listener());
+}
+function emitConfiguredEvent(eventName, sourceNodeId, targetNodeId, collisionNormal) {
+    const trimmed = eventName === null || eventName === void 0 ? void 0 : eventName.trim();
+    if (!trimmed)
+        return;
+    gameEvents.emit(trimmed, Object.assign({ sourceEntityId: sourceNodeId, sourceNodeId, targetEntityId: targetNodeId, targetNodeId }, (collisionNormal ? { collisionNormal } : {})));
+}
+function createDebugState() {
+    const options = debugRenderer.createDefaultOptions();
+    options.bodies.wireframe = true;
+    options.bodies.color = debugRenderer.BodyColorMode.MOTION_TYPE;
+    options.bodies.showAngularVelocity = false;
+    options.bodies.showLinearVelocity = false;
+    options.contacts.enabled = false;
+    options.contactConstraints.enabled = false;
+    return debugRenderer.init(options);
+}
+function getBodyMeta(bodyById, body) {
+    var _a;
+    const registered = bodyById.get(Number(body.id));
+    if (registered)
+        return registered;
+    const nodeId = (_a = body.userData) === null || _a === void 0 ? void 0 : _a.nodeId;
+    if (typeof nodeId !== "string")
+        return null;
+    return {
+        nodeId,
+        motionType: body.motionType,
+        sensor: body.sensor,
+    };
+}
+export function CrashcatRuntime({ debug = false, children }) {
+    const { mode } = useScene();
+    const bodiesRef = useRef(new Map());
+    const bodyByIdRef = useRef(new Map());
+    const apiRef = useRef(null);
+    const [debugState] = useState(() => debug ? createDebugState() : null);
+    const listener = useMemo(() => ({
+        onContactAdded: (bodyA, bodyB, manifold) => {
+            var _a, _b;
+            const metaA = getBodyMeta(bodyByIdRef.current, bodyA);
+            const metaB = getBodyMeta(bodyByIdRef.current, bodyB);
+            const n = manifold === null || manifold === void 0 ? void 0 : manifold.worldSpaceNormal;
+            const nA = n ? [n[0], n[1], n[2]] : undefined;
+            const nB = n ? [-n[0], -n[1], -n[2]] : undefined;
+            if (metaA === null || metaA === void 0 ? void 0 : metaA.events)
+                emitConfiguredEvent(metaA.sensor ? metaA.events.sensorEnter : metaA.events.collisionEnter, metaA.nodeId, (_a = metaB === null || metaB === void 0 ? void 0 : metaB.nodeId) !== null && _a !== void 0 ? _a : null, nA);
+            if (metaB === null || metaB === void 0 ? void 0 : metaB.events)
+                emitConfiguredEvent(metaB.sensor ? metaB.events.sensorEnter : metaB.events.collisionEnter, metaB.nodeId, (_b = metaA === null || metaA === void 0 ? void 0 : metaA.nodeId) !== null && _b !== void 0 ? _b : null, nB);
+        },
+        onContactRemoved: (idA, idB) => {
+            var _a, _b;
+            const metaA = bodyByIdRef.current.get(Number(idA));
+            const metaB = bodyByIdRef.current.get(Number(idB));
+            if (metaA === null || metaA === void 0 ? void 0 : metaA.events)
+                emitConfiguredEvent(metaA.sensor ? metaA.events.sensorExit : metaA.events.collisionExit, metaA.nodeId, (_a = metaB === null || metaB === void 0 ? void 0 : metaB.nodeId) !== null && _a !== void 0 ? _a : null);
+            if (metaB === null || metaB === void 0 ? void 0 : metaB.events)
+                emitConfiguredEvent(metaB.sensor ? metaB.events.sensorExit : metaB.events.collisionExit, metaB.nodeId, (_b = metaA === null || metaA === void 0 ? void 0 : metaA.nodeId) !== null && _b !== void 0 ? _b : null);
+        },
+    }), []);
+    useEffect(() => {
+        ensureCrashcatRegistered();
+        const settings = createWorldSettings();
+        settings.narrowphase.collideWithBackfaces = true;
+        settings.sleeping.timeBeforeSleep = SLEEP_TIME_BEFORE_REST;
+        settings.sleeping.pointVelocitySleepThreshold = SLEEP_POINT_VELOCITY_THRESHOLD;
+        const movingBroadphase = addBroadphaseLayer(settings);
+        const staticBroadphase = addBroadphaseLayer(settings);
+        const movingObjectLayer = addObjectLayer(settings, movingBroadphase);
+        const staticObjectLayer = addObjectLayer(settings, staticBroadphase);
+        enableCollision(settings, movingObjectLayer, staticObjectLayer);
+        enableCollision(settings, movingObjectLayer, movingObjectLayer);
+        const world = createWorld(settings);
+        const queryFilter = filter.forWorld(world);
+        const bodies = bodiesRef.current;
+        const bodyById = bodyByIdRef.current;
+        const unregister = (nodeId) => {
+            const entry = bodies.get(nodeId);
+            if (!entry)
+                return;
+            bodyById.delete(Number(entry.body.id));
+            rigidBody.remove(world, entry.body);
+            bodies.delete(nodeId);
+        };
+        const runtimeApi = {
+            world,
+            queryFilter,
+            staticObjectLayer,
+            movingObjectLayer,
+            register: (nodeId, body, meta) => {
+                unregister(nodeId);
+                const full = Object.assign({ nodeId }, meta);
+                bodies.set(nodeId, { body, meta: full });
+                bodyById.set(Number(body.id), full);
+            },
+            unregister,
+            getBody: (nodeId) => { var _a, _b; return (_b = (_a = bodies.get(nodeId)) === null || _a === void 0 ? void 0 : _a.body) !== null && _b !== void 0 ? _b : null; },
+        };
+        apiRef.current = runtimeApi;
+        setCrashcatApi(runtimeApi);
+        return () => {
+            for (const entry of bodies.values()) {
+                rigidBody.remove(world, entry.body);
+            }
+            apiRef.current = null;
+            if (crashcatApi === runtimeApi)
+                setCrashcatApi(null);
+            bodies.clear();
+            bodyById.clear();
+            if (debugState)
+                debugRenderer.dispose(debugState);
+        };
+    }, [debugState]);
+    useFrame((_, delta) => {
+        const runtimeApi = apiRef.current;
+        if (!runtimeApi)
+            return;
+        const { world } = runtimeApi;
+        const stepDelta = Math.min(delta, MAX_PHYSICS_DELTA);
+        if (mode === PrefabEditorMode.Play)
+            updateWorld(world, listener, stepDelta);
+        if (debugState)
+            debugRenderer.update(debugState, world);
+    }, -1);
+    return (_jsxs(_Fragment, { children: [children, debugState && mode === PrefabEditorMode.Edit
+                ? _jsx("primitive", { object: debugState.object3d })
+                : null] }));
+}

package/dist/plugins/crashcat/index.d.ts

@@ -0,0 +1,2 @@
+export { CrashcatRuntime, useCrashcat, type BodyMeta, type CrashcatApi, type CrashcatEventConfig, } from "./CrashcatRuntime";
+export { default as CrashcatPhysicsComponent, default, } from "./CrashcatPhysicsComponent";

package/dist/plugins/crashcat/index.js

@@ -0,0 +1,2 @@
+export { CrashcatRuntime, useCrashcat, } from "./CrashcatRuntime";
+export { default as CrashcatPhysicsComponent, default, } from "./CrashcatPhysicsComponent";

package/dist/plugins/index.d.ts

@@ -0,0 +1 @@
+export * from "./crashcat";

package/dist/plugins/index.js

@@ -0,0 +1 @@
+export * from "./crashcat";