react-three-game 0.0.107 → 0.0.109

package/dist/plugins/crashcat/CrashcatRagdoll.js

@@ -0,0 +1,410 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { createPortal, useFrame, useThree } from "@react-three/fiber";
+import { mat3, mat4, quat, vec3 } from "mathcat";
+import { useCallback, useEffect, useMemo, useRef } from "react";
+import { box, ConstraintSpace, massProperties, motionProperties, MotionType, rigidBody, swingTwistConstraint, } from "crashcat";
+import { Quaternion, Vector3 } from "three";
+import { BooleanField, FieldRenderer, StringField, Vector3Field, } from "../../tools/prefabeditor/components/Input";
+import { useCrashcat } from "./CrashcatRuntime";
+export var RagdollBodyPart;
+(function (RagdollBodyPart) {
+    RagdollBodyPart[RagdollBodyPart["UpperBody"] = 0] = "UpperBody";
+    RagdollBodyPart[RagdollBodyPart["Head"] = 1] = "Head";
+    RagdollBodyPart[RagdollBodyPart["UpperLeftArm"] = 2] = "UpperLeftArm";
+    RagdollBodyPart[RagdollBodyPart["LowerLeftArm"] = 3] = "LowerLeftArm";
+    RagdollBodyPart[RagdollBodyPart["UpperRightArm"] = 4] = "UpperRightArm";
+    RagdollBodyPart[RagdollBodyPart["LowerRightArm"] = 5] = "LowerRightArm";
+    RagdollBodyPart[RagdollBodyPart["Pelvis"] = 6] = "Pelvis";
+    RagdollBodyPart[RagdollBodyPart["UpperLeftLeg"] = 7] = "UpperLeftLeg";
+    RagdollBodyPart[RagdollBodyPart["LowerLeftLeg"] = 8] = "LowerLeftLeg";
+    RagdollBodyPart[RagdollBodyPart["UpperRightLeg"] = 9] = "UpperRightLeg";
+    RagdollBodyPart[RagdollBodyPart["LowerRightLeg"] = 10] = "LowerRightLeg";
+})(RagdollBodyPart || (RagdollBodyPart = {}));
+let nextRagdollId = 0;
+const DEFAULT_POSITION = [0, 0, 0];
+const ZERO_VECTOR = [0, 0, 0];
+export function createRagdollSettings(scale = 1, angleA = Math.PI / 4, angleB = Math.PI / 4, twistAngle = 0) {
+    const shouldersDistance = 0.45 * scale;
+    const upperArmLength = 0.4 * scale;
+    const lowerArmLength = 0.4 * scale;
+    const upperArmSize = 0.15 * scale;
+    const lowerArmSize = 0.15 * scale;
+    const neckLength = 0.1 * scale;
+    const headRadius = 0.2 * scale;
+    const upperBodyLength = 0.6 * scale;
+    const pelvisLength = 0.2 * scale;
+    const pelvisSize = 0.25 * scale;
+    const upperLegLength = 0.5 * scale;
+    const upperLegSize = 0.15 * scale;
+    const lowerLegSize = 0.15 * scale;
+    const lowerLegLength = 0.5 * scale;
+    const lowerLeftLegPos = [-shouldersDistance / 3, lowerLegLength / 2, 0];
+    const lowerRightLegPos = [shouldersDistance / 3, lowerLegLength / 2, 0];
+    const upperLeftLegPos = [-shouldersDistance / 3, lowerLeftLegPos[1] + lowerLegLength / 2 + upperLegLength / 2, 0];
+    const upperRightLegPos = [shouldersDistance / 3, lowerRightLegPos[1] + lowerLegLength / 2 + upperLegLength / 2, 0];
+    const pelvisPos = [0, upperLeftLegPos[1] + upperLegLength / 2 + pelvisLength / 2, 0];
+    const upperBodyPos = [0, pelvisPos[1] + pelvisLength / 2 + upperBodyLength / 2, 0];
+    const headPos = [0, upperBodyPos[1] + upperBodyLength / 2 + headRadius / 2 + neckLength, 0];
+    const upperLeftArmPos = [-shouldersDistance / 2 - upperArmLength / 2, upperBodyPos[1] + upperBodyLength / 2, 0];
+    const upperRightArmPos = [shouldersDistance / 2 + upperArmLength / 2, upperBodyPos[1] + upperBodyLength / 2, 0];
+    const lowerLeftArmPos = [upperLeftArmPos[0] - lowerArmLength / 2 - upperArmLength / 2, upperLeftArmPos[1], 0];
+    const lowerRightArmPos = [upperRightArmPos[0] + lowerArmLength / 2 + upperArmLength / 2, upperRightArmPos[1], 0];
+    const shapes = new Map([
+        [RagdollBodyPart.LowerLeftLeg, { args: [lowerLegSize * 0.5, lowerLegLength * 0.5, lowerLegSize * 0.5], density: scale, position: lowerLeftLegPos }],
+        [RagdollBodyPart.LowerRightLeg, { args: [lowerLegSize * 0.5, lowerLegLength * 0.5, lowerLegSize * 0.5], density: scale, position: lowerRightLegPos }],
+        [RagdollBodyPart.UpperLeftLeg, { args: [upperLegSize * 0.5, upperLegLength * 0.5, upperLegSize * 0.5], density: scale, position: upperLeftLegPos }],
+        [RagdollBodyPart.UpperRightLeg, { args: [upperLegSize * 0.5, upperLegLength * 0.5, upperLegSize * 0.5], density: scale, position: upperRightLegPos }],
+        [RagdollBodyPart.Pelvis, { args: [shouldersDistance * 0.5, pelvisLength * 0.5, pelvisSize * 0.5], density: scale, position: pelvisPos }],
+        [RagdollBodyPart.UpperBody, { args: [shouldersDistance * 0.5, upperBodyLength * 0.5, lowerArmSize * 0.75], density: scale, position: upperBodyPos }],
+        [RagdollBodyPart.Head, { args: [headRadius * 0.6, headRadius * 0.7, headRadius * 0.6], density: scale, position: headPos }],
+        [RagdollBodyPart.UpperLeftArm, { args: [upperArmLength * 0.5, upperArmSize * 0.5, upperArmSize * 0.5], density: scale, position: upperLeftArmPos }],
+        [RagdollBodyPart.UpperRightArm, { args: [upperArmLength * 0.5, upperArmSize * 0.5, upperArmSize * 0.5], density: scale, position: upperRightArmPos }],
+        [RagdollBodyPart.LowerLeftArm, { args: [lowerArmLength * 0.5, lowerArmSize * 0.5, lowerArmSize * 0.5], density: scale, position: lowerLeftArmPos }],
+        [RagdollBodyPart.LowerRightArm, { args: [lowerArmLength * 0.5, lowerArmSize * 0.5, lowerArmSize * 0.5], density: scale, position: lowerRightArmPos }],
+    ]);
+    const joints = [
+        { bodyA: RagdollBodyPart.Head, bodyB: RagdollBodyPart.UpperBody, pivotA: [0, -headRadius - neckLength / 2, 0], pivotB: [0, upperBodyLength / 2, 0], axisA: [0, 1, 0], axisB: [0, 1, 0], angle: angleA, twistAngle },
+        { bodyA: RagdollBodyPart.LowerLeftLeg, bodyB: RagdollBodyPart.UpperLeftLeg, pivotA: [0, lowerLegLength / 2, 0], pivotB: [0, -upperLegLength / 2, 0], axisA: [0, 1, 0], axisB: [0, 1, 0], angle: angleA, twistAngle },
+        { bodyA: RagdollBodyPart.LowerRightLeg, bodyB: RagdollBodyPart.UpperRightLeg, pivotA: [0, lowerLegLength / 2, 0], pivotB: [0, -upperLegLength / 2, 0], axisA: [0, 1, 0], axisB: [0, 1, 0], angle: angleA, twistAngle },
+        { bodyA: RagdollBodyPart.UpperLeftLeg, bodyB: RagdollBodyPart.Pelvis, pivotA: [0, upperLegLength / 2, 0], pivotB: [-shouldersDistance / 3, -pelvisLength / 2, 0], axisA: [0, 1, 0], axisB: [0, 1, 0], angle: angleA, twistAngle },
+        { bodyA: RagdollBodyPart.UpperRightLeg, bodyB: RagdollBodyPart.Pelvis, pivotA: [0, upperLegLength / 2, 0], pivotB: [shouldersDistance / 3, -pelvisLength / 2, 0], axisA: [0, 1, 0], axisB: [0, 1, 0], angle: angleA, twistAngle },
+        { bodyA: RagdollBodyPart.Pelvis, bodyB: RagdollBodyPart.UpperBody, pivotA: [0, pelvisLength / 2, 0], pivotB: [0, -upperBodyLength / 2, 0], axisA: [0, 1, 0], axisB: [0, 1, 0], angle: angleA, twistAngle },
+        { bodyA: RagdollBodyPart.UpperBody, bodyB: RagdollBodyPart.UpperLeftArm, pivotA: [-shouldersDistance / 2, upperBodyLength / 2, 0], pivotB: [upperArmLength / 2, 0, 0], axisA: [1, 0, 0], axisB: [1, 0, 0], angle: angleB, twistAngle },
+        { bodyA: RagdollBodyPart.UpperBody, bodyB: RagdollBodyPart.UpperRightArm, pivotA: [shouldersDistance / 2, upperBodyLength / 2, 0], pivotB: [-upperArmLength / 2, 0, 0], axisA: [1, 0, 0], axisB: [1, 0, 0], angle: angleB, twistAngle },
+        { bodyA: RagdollBodyPart.LowerLeftArm, bodyB: RagdollBodyPart.UpperLeftArm, pivotA: [lowerArmLength / 2, 0, 0], pivotB: [-upperArmLength / 2, 0, 0], axisA: [1, 0, 0], axisB: [1, 0, 0], angle: angleA, twistAngle },
+        { bodyA: RagdollBodyPart.LowerRightArm, bodyB: RagdollBodyPart.UpperRightArm, pivotA: [-lowerArmLength / 2, 0, 0], pivotB: [upperArmLength / 2, 0, 0], axisA: [1, 0, 0], axisB: [1, 0, 0], angle: angleA, twistAngle },
+    ];
+    const skeleton = [
+        { bodyPart: RagdollBodyPart.Pelvis, parentBodyPart: null },
+        { bodyPart: RagdollBodyPart.UpperBody, parentBodyPart: RagdollBodyPart.Pelvis },
+        { bodyPart: RagdollBodyPart.Head, parentBodyPart: RagdollBodyPart.UpperBody },
+        { bodyPart: RagdollBodyPart.UpperLeftArm, parentBodyPart: RagdollBodyPart.UpperBody },
+        { bodyPart: RagdollBodyPart.LowerLeftArm, parentBodyPart: RagdollBodyPart.UpperLeftArm },
+        { bodyPart: RagdollBodyPart.UpperRightArm, parentBodyPart: RagdollBodyPart.UpperBody },
+        { bodyPart: RagdollBodyPart.LowerRightArm, parentBodyPart: RagdollBodyPart.UpperRightArm },
+        { bodyPart: RagdollBodyPart.UpperLeftLeg, parentBodyPart: RagdollBodyPart.Pelvis },
+        { bodyPart: RagdollBodyPart.LowerLeftLeg, parentBodyPart: RagdollBodyPart.UpperLeftLeg },
+        { bodyPart: RagdollBodyPart.UpperRightLeg, parentBodyPart: RagdollBodyPart.Pelvis },
+        { bodyPart: RagdollBodyPart.LowerRightLeg, parentBodyPart: RagdollBodyPart.UpperRightLeg },
+    ];
+    return { shapes, joints, skeleton };
+}
+function getTangent(out, axis) {
+    const ax = Math.abs(axis[0]);
+    const ay = Math.abs(axis[1]);
+    const az = Math.abs(axis[2]);
+    if (ax <= ay && ax <= az) {
+        vec3.set(out, 0, -axis[2], axis[1]);
+    }
+    else if (ay <= az) {
+        vec3.set(out, axis[2], 0, -axis[0]);
+    }
+    else {
+        vec3.set(out, -axis[1], axis[0], 0);
+    }
+    vec3.normalize(out, out);
+    return out;
+}
+function createRagdollBodies(api, instanceId, settings, offset, stabilize) {
+    const bodies = new Map();
+    const constraints = [];
+    const nodeIds = [];
+    for (const [part, config] of settings.shapes) {
+        const body = rigidBody.create(api.world, {
+            shape: box.create({
+                halfExtents: vec3.fromValues(config.args[0], config.args[1], config.args[2]),
+                convexRadius: Math.min(0.05, Math.min(config.args[0], config.args[1], config.args[2]) * 0.45),
+                density: config.density,
+            }),
+            objectLayer: api.movingObjectLayer,
+            motionType: MotionType.DYNAMIC,
+            position: vec3.fromValues(config.position[0] + offset[0], config.position[1] + offset[1], config.position[2] + offset[2]),
+            quaternion: quat.create(),
+            linearDamping: 0.05,
+            angularDamping: 0.05,
+            restitution: 0,
+            userData: { nodeId: `${instanceId}-${part}` },
+        });
+        const nodeId = `${instanceId}-${part}`;
+        api.register(nodeId, body, { motionType: MotionType.DYNAMIC, sensor: false });
+        bodies.set(part, body);
+        nodeIds.push(nodeId);
+    }
+    if (stabilize) {
+        stabilizeRagdoll(bodies, settings.skeleton);
+    }
+    for (const joint of settings.joints) {
+        const bodyA = bodies.get(joint.bodyA);
+        const bodyB = bodies.get(joint.bodyB);
+        if (!bodyA || !bodyB)
+            continue;
+        constraints.push(swingTwistConstraint.create(api.world, {
+            bodyIdA: bodyA.id,
+            bodyIdB: bodyB.id,
+            position1: vec3.fromValues(joint.pivotA[0], joint.pivotA[1], joint.pivotA[2]),
+            position2: vec3.fromValues(joint.pivotB[0], joint.pivotB[1], joint.pivotB[2]),
+            twistAxis1: vec3.fromValues(joint.axisA[0], joint.axisA[1], joint.axisA[2]),
+            planeAxis1: getTangent(vec3.create(), joint.axisA),
+            twistAxis2: vec3.fromValues(joint.axisB[0], joint.axisB[1], joint.axisB[2]),
+            planeAxis2: getTangent(vec3.create(), joint.axisB),
+            space: ConstraintSpace.LOCAL,
+            normalHalfConeAngle: joint.angle,
+            planeHalfConeAngle: joint.angle,
+            twistMinAngle: -joint.twistAngle,
+            twistMaxAngle: joint.twistAngle,
+        }));
+    }
+    return { bodies, constraints, nodeIds };
+}
+function stabilizeRagdoll(bodies, skeleton) {
+    var _a, _b, _c, _d, _e;
+    const minMassRatio = 0.8;
+    const maxMassRatio = 1.2;
+    const maxInertiaIncrease = 2;
+    const visited = new Set();
+    const massRatios = new Map();
+    const roots = skeleton.filter((joint) => joint.parentBodyPart === null);
+    for (const root of roots) {
+        const chain = [];
+        const toProcess = [root.bodyPart];
+        while (toProcess.length > 0) {
+            const current = toProcess.shift();
+            if (current === undefined || visited.has(current))
+                continue;
+            visited.add(current);
+            chain.push(current);
+            for (const joint of skeleton) {
+                if (joint.parentBodyPart === current && !visited.has(joint.bodyPart)) {
+                    toProcess.push(joint.bodyPart);
+                }
+            }
+        }
+        if (chain.length <= 1)
+            continue;
+        let totalMassRatio = 1;
+        massRatios.set(chain[0], 1);
+        for (let i = 1; i < chain.length; i += 1) {
+            const childPart = chain[i];
+            const parentPart = (_a = skeleton.find((joint) => joint.bodyPart === childPart)) === null || _a === void 0 ? void 0 : _a.parentBodyPart;
+            if (parentPart === undefined || parentPart === null)
+                continue;
+            const childBody = bodies.get(childPart);
+            const parentBody = bodies.get(parentPart);
+            if (!childBody || !parentBody)
+                continue;
+            const ratio = childBody.massProperties.mass / parentBody.massProperties.mass;
+            const clampedRatio = Math.max(minMassRatio, Math.min(maxMassRatio, ratio));
+            const parentRatio = (_b = massRatios.get(parentPart)) !== null && _b !== void 0 ? _b : 1;
+            const childRatio = parentRatio * clampedRatio;
+            massRatios.set(childPart, childRatio);
+            totalMassRatio += childRatio;
+        }
+        let totalMass = 0;
+        for (const part of chain) {
+            totalMass += (_d = (_c = bodies.get(part)) === null || _c === void 0 ? void 0 : _c.massProperties.mass) !== null && _d !== void 0 ? _d : 0;
+        }
+        const ratioToMass = totalMass / totalMassRatio;
+        for (const part of chain) {
+            const body = bodies.get(part);
+            const ratio = massRatios.get(part);
+            if (!body || ratio === undefined)
+                continue;
+            const oldMass = body.massProperties.mass;
+            const newMass = ratio * ratioToMass;
+            body.massProperties.mass = newMass;
+            const massScale = oldMass > 0 ? newMass / oldMass : 1;
+            for (let i = 0; i < 15; i += 1) {
+                body.massProperties.inertia[i] *= massScale;
+            }
+            body.massProperties.inertia[15] = 1;
+        }
+        const principals = new Map();
+        for (const part of chain) {
+            const body = bodies.get(part);
+            if (!body)
+                continue;
+            const rotation = mat3.create();
+            const diagonal = vec3.create();
+            if (motionProperties.decomposePrincipalMomentsOfInertia(body.massProperties.inertia, rotation, diagonal)) {
+                principals.set(part, { rotation, diagonal, childSum: 0 });
+            }
+        }
+        for (let i = chain.length - 1; i > 0; i -= 1) {
+            const childPart = chain[i];
+            const parentPart = (_e = skeleton.find((joint) => joint.bodyPart === childPart)) === null || _e === void 0 ? void 0 : _e.parentBodyPart;
+            if (parentPart === undefined || parentPart === null)
+                continue;
+            const childPrincipal = principals.get(childPart);
+            const parentPrincipal = principals.get(parentPart);
+            if (childPrincipal && parentPrincipal) {
+                parentPrincipal.childSum += childPrincipal.diagonal[0] + childPrincipal.childSum;
+            }
+        }
+        for (const part of chain) {
+            const principal = principals.get(part);
+            const body = bodies.get(part);
+            if (!principal || !body || principal.childSum === 0)
+                continue;
+            const minimum = Math.min(maxInertiaIncrease * principal.diagonal[0], principal.childSum);
+            principal.diagonal[0] = Math.max(principal.diagonal[0], minimum);
+            principal.diagonal[1] = Math.max(principal.diagonal[1], minimum);
+            principal.diagonal[2] = Math.max(principal.diagonal[2], minimum);
+            const scale = mat4.create();
+            mat4.fromScaling(scale, principal.diagonal);
+            const rot4x4 = mat4.create();
+            mat4.identity(rot4x4);
+            for (let i = 0; i < 3; i += 1) {
+                for (let j = 0; j < 3; j += 1) {
+                    rot4x4[i + j * 4] = principal.rotation[i + j * 3];
+                }
+            }
+            const temp1 = mat4.create();
+            const temp2 = mat4.create();
+            mat4.multiply(temp1, rot4x4, scale);
+            mat4.transpose(temp2, rot4x4);
+            mat4.multiply(body.massProperties.inertia, temp1, temp2);
+            body.massProperties.inertia[15] = 1;
+        }
+    }
+    for (const body of bodies.values()) {
+        if (body.motionType !== MotionType.DYNAMIC)
+            continue;
+        const mp = massProperties.create();
+        massProperties.copy(mp, body.massProperties);
+        body.massPropertiesOverride = rigidBody.MassPropertiesOverride.MASS_AND_INERTIA_PROVIDED;
+        body.motionProperties.invMass = mp.mass > 0 ? 1 / mp.mass : 0;
+        const rotation = mat3.create();
+        const diagonal = vec3.create();
+        if (motionProperties.decomposePrincipalMomentsOfInertia(mp.inertia, rotation, diagonal)) {
+            vec3.set(body.motionProperties.invInertiaDiagonal, diagonal[0] !== 0 ? 1 / diagonal[0] : 0, diagonal[1] !== 0 ? 1 / diagonal[1] : 0, diagonal[2] !== 0 ? 1 / diagonal[2] : 0);
+            quat.fromMat3(body.motionProperties.inertiaRotation, rotation);
+        }
+    }
+}
+const meshPosition = new Vector3();
+const meshQuaternion = new Quaternion();
+const ragdollFields = [
+    { name: "scale", type: "number", label: "Scale", step: 0.1 },
+    { name: "swingAngle", type: "number", label: "Swing Angle", step: 0.05 },
+    { name: "shoulderAngle", type: "number", label: "Shoulder Angle", step: 0.05 },
+    { name: "twistAngle", type: "number", label: "Twist Angle", step: 0.05 },
+    { name: "clickImpulse", type: "number", label: "Click Impulse", min: 0, step: 0.5 },
+];
+export function CrashcatRagdoll({ position = DEFAULT_POSITION, scale = 1.8, swingAngle = Math.PI / 4, shoulderAngle = Math.PI / 4, twistAngle = 0, stabilize = true, initialLinearVelocity = ZERO_VECTOR, initialAngularVelocity = ZERO_VECTOR, color = "#f97316", clickImpulse = 8, nodeInteractionHandlers, }) {
+    const api = useCrashcat();
+    const instanceId = useRef(`crashcat-ragdoll-${nextRagdollId++}`);
+    const stateRef = useRef(null);
+    const meshRefs = useRef(new Map());
+    const settings = useMemo(() => createRagdollSettings(scale, swingAngle, shoulderAngle, twistAngle), [scale, shoulderAngle, swingAngle, twistAngle]);
+    const shapeEntries = useMemo(() => [...settings.shapes], [settings]);
+    const [px, py, pz] = position;
+    const [lvx, lvy, lvz] = initialLinearVelocity;
+    const [avx, avy, avz] = initialAngularVelocity;
+    useEffect(() => {
+        if (!api)
+            return undefined;
+        const state = createRagdollBodies(api, instanceId.current, settings, [px, py, pz], stabilize);
+        stateRef.current = state;
+        for (const body of state.bodies.values()) {
+            rigidBody.addLinearVelocity(api.world, body, [lvx, lvy, lvz]);
+            rigidBody.addAngularVelocity(api.world, body, [avx, avy, avz]);
+        }
+        return () => {
+            for (const constraint of state.constraints) {
+                swingTwistConstraint.remove(api.world, constraint);
+            }
+            for (const nodeId of state.nodeIds) {
+                api.unregister(nodeId);
+            }
+            stateRef.current = null;
+        };
+    }, [api, avx, avy, avz, lvx, lvy, lvz, px, py, pz, settings, stabilize]);
+    useFrame(() => {
+        const state = stateRef.current;
+        if (!state)
+            return;
+        for (const [part, body] of state.bodies) {
+            const mesh = meshRefs.current.get(part);
+            if (!mesh)
+                continue;
+            meshPosition.set(body.position[0], body.position[1], body.position[2]);
+            meshQuaternion.set(body.quaternion[0], body.quaternion[1], body.quaternion[2], body.quaternion[3]);
+            mesh.position.copy(meshPosition);
+            mesh.quaternion.copy(meshQuaternion);
+        }
+    });
+    const handleClick = useCallback((event) => {
+        var _a;
+        (_a = nodeInteractionHandlers === null || nodeInteractionHandlers === void 0 ? void 0 : nodeInteractionHandlers.onClick) === null || _a === void 0 ? void 0 : _a.call(nodeInteractionHandlers, event);
+        const apiWorld = api === null || api === void 0 ? void 0 : api.world;
+        const state = stateRef.current;
+        if (!apiWorld || !state || clickImpulse <= 0)
+            return;
+        let hitBody = null;
+        let minDistanceSq = Infinity;
+        for (const body of state.bodies.values()) {
+            const dx = body.position[0] - event.point.x;
+            const dy = body.position[1] - event.point.y;
+            const dz = body.position[2] - event.point.z;
+            const distanceSq = dx * dx + dy * dy + dz * dz;
+            if (distanceSq < minDistanceSq) {
+                minDistanceSq = distanceSq;
+                hitBody = body;
+            }
+        }
+        if (!hitBody)
+            return;
+        rigidBody.addImpulseAtPosition(apiWorld, hitBody, [
+            event.ray.direction.x * clickImpulse,
+            event.ray.direction.y * clickImpulse + clickImpulse * 0.35,
+            event.ray.direction.z * clickImpulse,
+        ], [event.point.x, event.point.y, event.point.z]);
+    }, [api, clickImpulse, nodeInteractionHandlers]);
+    const interactionHandlers = Object.assign(Object.assign({}, nodeInteractionHandlers), { onClick: handleClick });
+    return (_jsx("group", Object.assign({}, interactionHandlers, { children: shapeEntries.map(([part, config]) => (_jsxs("mesh", { ref: (mesh) => {
+                if (mesh)
+                    meshRefs.current.set(part, mesh);
+                else
+                    meshRefs.current.delete(part);
+            }, castShadow: true, receiveShadow: true, position: [
+                config.position[0] + px,
+                config.position[1] + py,
+                config.position[2] + pz,
+            ], children: [_jsx("boxGeometry", { args: [config.args[0] * 2, config.args[1] * 2, config.args[2] * 2] }), _jsx("meshStandardMaterial", { color: color, roughness: 0.72, metalness: 0.05 })] }, part))) })));
+}
+function CrashcatRagdollEditor({ component, onUpdate, }) {
+    return (_jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 10 }, children: [_jsx(FieldRenderer, { fields: ragdollFields, values: component.properties, onChange: onUpdate }), _jsx(BooleanField, { name: "stabilize", label: "Stabilize", values: component.properties, onChange: onUpdate, fallback: true }), _jsx(StringField, { name: "color", label: "Color", values: component.properties, onChange: onUpdate, fallback: "#f97316" }), _jsx(Vector3Field, { name: "initialLinearVelocity", label: "Initial Linear Velocity", values: component.properties, onChange: onUpdate, fallback: [0, 0, 0] }), _jsx(Vector3Field, { name: "initialAngularVelocity", label: "Initial Angular Velocity", values: component.properties, onChange: onUpdate, fallback: [0, 0, 0] })] }));
+}
+function CrashcatRagdollView({ properties, children, editMode, nodeInteractionHandlers, worldPosition, }) {
+    var _a, _b, _c, _d, _e, _f;
+    const scene = useThree((state) => state.scene);
+    return (_jsxs(_Fragment, { children: [children, worldPosition
+                ? createPortal(_jsx(CrashcatRagdoll, { position: worldPosition, scale: (_a = properties.scale) !== null && _a !== void 0 ? _a : 1.8, swingAngle: (_b = properties.swingAngle) !== null && _b !== void 0 ? _b : Math.PI / 4, shoulderAngle: (_c = properties.shoulderAngle) !== null && _c !== void 0 ? _c : Math.PI / 4, twistAngle: (_d = properties.twistAngle) !== null && _d !== void 0 ? _d : 0, stabilize: properties.stabilize !== false, color: (_e = properties.color) !== null && _e !== void 0 ? _e : "#f97316", clickImpulse: editMode ? 0 : (_f = properties.clickImpulse) !== null && _f !== void 0 ? _f : 8, initialLinearVelocity: properties.initialLinearVelocity, initialAngularVelocity: properties.initialAngularVelocity, nodeInteractionHandlers: nodeInteractionHandlers }), scene)
+                : null] }));
+}
+const CrashcatRagdollComponent = {
+    name: "CrashcatRagdoll",
+    Editor: CrashcatRagdollEditor,
+    View: CrashcatRagdollView,
+    defaultProperties: {
+        scale: 1.8,
+        swingAngle: Math.PI / 4,
+        shoulderAngle: Math.PI / 4,
+        twistAngle: 0,
+        stabilize: true,
+        color: "#f97316",
+        clickImpulse: 8,
+        initialLinearVelocity: [0, 0, 0],
+        initialAngularVelocity: [0, 0, 0],
+    },
+};
+export default CrashcatRagdollComponent;
+export function createStaticBoxBody(world, objectLayer, halfExtents, position) {
+    return rigidBody.create(world, {
+        shape: box.create({ halfExtents }),
+        objectLayer,
+        motionType: MotionType.STATIC,
+        position,
+    });
+}

package/dist/plugins/crashcat/CrashcatRuntime.js

@@ -5,7 +5,7 @@ import { addBroadphaseLayer, addObjectLayer, createWorld, createWorldSettings, e
 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";
+import { PrefabEditorMode, useScene } from "../../tools/prefabeditor/SceneContext";
 const SLEEP_TIME_BEFORE_REST = 0.1;
 const SLEEP_POINT_VELOCITY_THRESHOLD = 0.06;
 const MAX_PHYSICS_STEP_DELTA = 1 / 60;
@@ -33,11 +33,14 @@ function setCrashcatApi(api) {
         listener();
     });
 }
-function emitConfiguredEvent(eventName, sourceNodeId, targetNodeId, collisionNormal) {
-    const trimmed = eventName === null || eventName === void 0 ? void 0 : eventName.trim();
-    if (!trimmed)
+function emitPhysicsEvent(eventType, eventName, sourceNodeId, targetNodeId, collisionNormal) {
+    const alias = eventName === null || eventName === void 0 ? void 0 : eventName.trim();
+    if (!gameEvents.hasListeners(eventType) && (!alias || !gameEvents.hasListeners(alias)))
         return;
-    gameEvents.emit(trimmed, Object.assign({ sourceEntityId: sourceNodeId, sourceNodeId, targetEntityId: targetNodeId, targetNodeId }, (collisionNormal ? { collisionNormal } : {})));
+    const payload = Object.assign({ sourceEntityId: sourceNodeId, sourceNodeId, targetEntityId: targetNodeId, targetNodeId }, (collisionNormal ? { collisionNormal } : {}));
+    gameEvents.emit(eventType, payload);
+    if (alias)
+        gameEvents.emit(alias, payload);
 }
 function createDebugState() {
     const options = debugRenderer.createDefaultOptions();
@@ -71,26 +74,27 @@ export function CrashcatRuntime({ debug = false, children }) {
     const [debugState] = useState(() => debug ? createDebugState() : null);
     const listener = useMemo(() => ({
         onContactAdded: (bodyA, bodyB, manifold) => {
-            var _a, _b;
+            var _a, _b, _c, _d, _e, _f;
             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);
+            if (metaA)
+                emitPhysicsEvent(metaA.sensor ? "sensor:enter" : "collision:enter", metaA.sensor ? (_a = metaA.events) === null || _a === void 0 ? void 0 : _a.sensorEnter : (_b = metaA.events) === null || _b === void 0 ? void 0 : _b.collisionEnter, metaA.nodeId, (_c = metaB === null || metaB === void 0 ? void 0 : metaB.nodeId) !== null && _c !== void 0 ? _c : null, nA);
+            if (metaB)
+                emitPhysicsEvent(metaB.sensor ? "sensor:enter" : "collision:enter", metaB.sensor ? (_d = metaB.events) === null || _d === void 0 ? void 0 : _d.sensorEnter : (_e = metaB.events) === null || _e === void 0 ? void 0 : _e.collisionEnter, metaB.nodeId, (_f = metaA === null || metaA === void 0 ? void 0 : metaA.nodeId) !== null && _f !== void 0 ? _f : null, nB);
         },
         onContactRemoved: (idA, idB) => {
-            var _a, _b;
+            var _a, _b, _c, _d, _e, _f;
             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);
+            if (metaA)
+                emitPhysicsEvent(metaA.sensor ? "sensor:exit" : "collision:exit", metaA.sensor ? (_a = metaA.events) === null || _a === void 0 ? void 0 : _a.sensorExit : (_b = metaA.events) === null || _b === void 0 ? void 0 : _b.collisionExit, metaA.nodeId, (_c = metaB === null || metaB === void 0 ? void 0 : metaB.nodeId) !== null && _c !== void 0 ? _c : null);
+            if (metaB)
+                emitPhysicsEvent(metaB.sensor ? "sensor:exit" : "collision:exit", metaB.sensor ? (_d = metaB.events) === null || _d === void 0 ? void 0 : _d.sensorExit : (_e = metaB.events) === null || _e === void 0 ? void 0 : _e.collisionExit, metaB.nodeId, (_f = metaA === null || metaA === void 0 ? void 0 : metaA.nodeId) !== null && _f !== void 0 ? _f : null);
         },
+        onBodyPairValidate: (bodyA, bodyB) => !rigidBody.bodiesShareConstraint(bodyA, bodyB),
     }), []);
     useEffect(() => {
         ensureCrashcatRegistered();

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

@@ -1,2 +1,3 @@
 export { CrashcatRuntime, useCrashcat, type BodyMeta, type CrashcatApi, type CrashcatEventConfig, } from "./CrashcatRuntime";
 export { default as CrashcatPhysicsComponent, default, } from "./CrashcatPhysicsComponent";
+export { CrashcatRagdoll, default as CrashcatRagdollComponent, RagdollBodyPart, createRagdollSettings, createStaticBoxBody, type CrashcatRagdollProps, type RagdollSettings, } from "./CrashcatRagdoll";

package/dist/plugins/crashcat/index.js

@@ -1,2 +1,3 @@
 export { CrashcatRuntime, useCrashcat, } from "./CrashcatRuntime";
 export { default as CrashcatPhysicsComponent, default, } from "./CrashcatPhysicsComponent";
+export { CrashcatRagdoll, default as CrashcatRagdollComponent, RagdollBodyPart, createRagdollSettings, createStaticBoxBody, } from "./CrashcatRagdoll";

package/dist/tools/assetviewer/page.js

@@ -5,7 +5,7 @@ import { Suspense, useEffect, useLayoutEffect, useState, useRef } from "react";
 import { createPortal } from 'react-dom';
 import { Mesh, TextureLoader } from "three";
 import { loadModel } from "../dragdrop/modelLoader";
-import { resolvePrefabAssetPath } from "../prefabeditor/PrefabEditor";
+import { withBasePath } from "../prefabeditor/utils";
 import { base, colors, fonts } from "../prefabeditor/styles";
 const styles = {
     errorIcon: { color: colors.danger, fontSize: 12 },
@@ -126,7 +126,7 @@ function TextureCard({ file, onSelect, basePath = "" }) {
     const [isHovered, setIsHovered] = useState(false);
     const [error, setError] = useState(false);
     const { ref, isInView } = useInView();
-    const fullPath = resolvePrefabAssetPath(basePath, file);
+    const fullPath = withBasePath(basePath, file);
     const fileName = file.split('/').pop();
     if (error) {
         return (_jsxs("div", { ref: ref, style: Object.assign(Object.assign({ maxWidth: 60, aspectRatio: '1 / 1' }, assetTileStyle), { backgroundColor: assetViewerColors.errorBg }), onClick: () => onSelect(file), title: `Could not load ${file}`, children: [_jsx("div", { style: { flex: 1, display: 'flex', alignItems: 'center', justifyContent: 'center' }, children: _jsx("div", { style: styles.errorIcon, children: "\u2717" }) }), _jsx("div", { style: styles.bottomLabel, children: fileName })] }));
@@ -170,7 +170,7 @@ export function ModelListViewer({ files, selected, onSelect, basePath = "" }) {
 function ModelCard({ file, onSelect, basePath = "", size = 60, }) {
     const [error, setError] = useState(false);
     const { ref, isInView } = useInView();
-    const fullPath = resolvePrefabAssetPath(basePath, file);
+    const fullPath = withBasePath(basePath, file);
     if (error) {
         return (_jsx("div", { ref: ref, style: { aspectRatio: '1 / 1', backgroundColor: assetViewerColors.errorBg, cursor: 'pointer', display: 'flex', alignItems: 'center', justifyContent: 'center', border: `1px solid ${colors.dangerBorder}` }, onClick: () => onSelect(file), children: _jsx("div", { style: styles.errorIcon, children: "\u2717" }) }));
     }
@@ -215,7 +215,7 @@ export function SoundListViewer({ files, selected, onSelect, basePath = "" }) {
 }
 function SoundCard({ file, onSelect, basePath = "" }) {
     const fileName = file.split('/').pop() || '';
-    const fullPath = resolvePrefabAssetPath(basePath, file);
+    const fullPath = withBasePath(basePath, file);
     return (_jsxs("div", { onClick: () => onSelect(file), style: Object.assign(Object.assign({ aspectRatio: '1 / 1' }, assetTileStyle), { alignItems: 'center', justifyContent: 'center' }), children: [_jsx("div", { style: styles.iconLarge, children: "\uD83D\uDD0A" }), _jsx("div", { style: { color: colors.text, fontSize: fonts.size, padding: '0 4px', marginTop: 4, overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap', textAlign: 'center', width: '100%' }, children: fileName })] }));
 }
 const PICKER_POPUP_WIDTH = 260;

package/dist/tools/prefabeditor/EditorContext.d.ts

@@ -0,0 +1,36 @@
+import type { PrefabEditorMode, Scene } from "./SceneContext";
+import type { Prefab } from "./types";
+import type { ExportGLBOptions } from "./utils";
+export interface PrefabEditorRef extends Scene {
+    save: () => Prefab;
+    load: (prefab: Prefab, options?: {
+        resetHistory?: boolean;
+        notifyChange?: boolean;
+    }) => void;
+    undo: () => void;
+    redo: () => void;
+    screenshot: () => void;
+    exportGLB: (options?: ExportGLBOptions) => Promise<ArrayBuffer | undefined>;
+    exportGLBData: () => Promise<ArrayBuffer | undefined>;
+    clearSelection: () => Promise<void>;
+}
+export interface EditorContextType {
+    mode: PrefabEditorMode;
+    basePath: string;
+    setMode: (mode: PrefabEditorMode) => void;
+    transformMode: "translate" | "rotate" | "scale";
+    setTransformMode: (mode: "translate" | "rotate" | "scale") => void;
+    scaleSnap: number;
+    setScaleSnap: (resolution: number) => void;
+    positionSnap: number;
+    setPositionSnap: (resolution: number) => void;
+    rotationSnap: number;
+    setRotationSnap: (resolution: number) => void;
+    onFocusNode?: (nodeId: string) => void;
+    onScreenshot?: () => void;
+    onExportGLB?: () => void;
+}
+export declare const EditorContext: import("react").Context<EditorContextType | null>;
+export declare const EditorRefContext: import("react").Context<PrefabEditorRef | null>;
+export declare function useEditorContext(): EditorContextType;
+export declare function useEditorRef(): PrefabEditorRef;

package/dist/tools/prefabeditor/EditorContext.js

@@ -0,0 +1,17 @@
+import { createContext, useContext } from "react";
+export const EditorContext = createContext(null);
+export const EditorRefContext = createContext(null);
+export function useEditorContext() {
+    const context = useContext(EditorContext);
+    if (!context) {
+        throw new Error("useEditorContext must be used within EditorContext.Provider");
+    }
+    return context;
+}
+export function useEditorRef() {
+    const editorRef = useContext(EditorRefContext);
+    if (!editorRef) {
+        throw new Error("useEditorRef must be used within PrefabEditor");
+    }
+    return editorRef;
+}

package/dist/tools/prefabeditor/EditorTree.js

@@ -1,10 +1,10 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { memo, useCallback, useState } from 'react';
 import { base, colors, tree } from './styles';
-import { useEditorContext, useEditorRef } from './PrefabEditor';
+import { useEditorContext, useEditorRef } from './EditorContext';
 import { Dropdown } from './Dropdown';
 import { FileMenu, TreeContextMenu, TreeNodeMenu } from './EditorTreeMenus';
-import { createEmptyNode } from './prefab';
+import { createEmptyNode, createPackedPrefabNode } from './prefab';
 import { usePrefabChildIds, usePrefabNode, usePrefabRootId, usePrefabStore, usePrefabStoreApi } from './prefabStore';
 export default function EditorTree({ selectedId, setSelectedId, getPrefab, onReplacePrefab, onImportPrefab, onUndo, onRedo, canUndo, canRedo }) {
     const { onFocusNode } = useEditorContext();
@@ -30,6 +30,9 @@ export default function EditorTree({ selectedId, setSelectedId, getPrefab, onRep
         editor.add(newNode, parentId);
         setSelectedId(newNode.id);
     };
+    const handleImportPackedPrefab = (url) => {
+        editor.add(createPackedPrefabNode(url), rootId);
+    };
     const handleDuplicate = (nodeId) => {
         if (nodeId === rootId)
             return;
@@ -103,7 +106,7 @@ export default function EditorTree({ selectedId, setSelectedId, getPrefab, onRep
     return (_jsxs(_Fragment, { children: [_jsxs("div", { style: Object.assign(Object.assign({}, tree.panel), { width: collapsed ? 'auto' : 224 }), children: [_jsxs("div", { style: base.header, children: [_jsxs("div", { style: { display: 'flex', alignItems: 'center', gap: 6, cursor: 'pointer' }, onClick: () => setCollapsed(!collapsed), children: [_jsx("span", { children: collapsed ? '▶' : '▼' }), _jsx("span", { children: "Prefab" })] }), !collapsed && (_jsxs("div", { style: { display: 'flex', alignItems: 'center', gap: 4 }, children: [_jsx("button", { style: Object.assign(Object.assign({}, base.btn), { padding: '2px 6px', fontSize: 10, opacity: canUndo ? 1 : 0.4 }), onClick: (e) => { e.stopPropagation(); onUndo === null || onUndo === void 0 ? void 0 : onUndo(); }, disabled: !canUndo, title: "Undo", children: "\u21B6" }), _jsx("button", { style: Object.assign(Object.assign({}, base.btn), { padding: '2px 6px', fontSize: 10, opacity: canRedo ? 1 : 0.4 }), onClick: (e) => { e.stopPropagation(); onRedo === null || onRedo === void 0 ? void 0 : onRedo(); }, disabled: !canRedo, title: "Redo", children: "\u21B7" }), _jsx(Dropdown, { placement: "bottom-end", trigger: ({ ref, toggle }) => (_jsx("button", { ref: ref, title: "Menu", style: Object.assign(Object.assign({}, base.btn), { padding: '2px 6px', fontSize: 10 }), onClick: (e) => {
                                                 e.stopPropagation();
                                                 toggle();
-                                            }, children: "\u22EE" })), children: (close) => (_jsx(FileMenu, { getPrefab: getPrefab, onReplacePrefab: onReplacePrefab, onImportPrefab: onImportPrefab, onClose: close })) })] }))] }), !collapsed && (_jsxs(_Fragment, { children: [_jsx("div", { style: { padding: '4px 4px', borderBottom: `1px solid ${colors.borderLight}` }, children: _jsx("input", { type: "text", placeholder: "Search nodes...", value: searchQuery, onChange: (e) => setSearchQuery(e.target.value), onClick: (e) => e.stopPropagation(), style: Object.assign(Object.assign({}, base.input), { padding: '4px 8px' }) }) }), _jsx("div", { style: tree.scroll, children: _jsx(TreeNode, { nodeId: rootId, depth: 0, rootId: rootId, visibleIds: visibleIds, collapsedIds: collapsedIds, dropTarget: dropTarget, selectedNodeId: selectedId, onToggleCollapse: toggleCollapse, onOpenContextMenu: openContextMenu, onDragStart: handleDragStart, onDragOver: handleDragOver, onDragLeave: handleDragLeave, onDrop: handleDrop, onDragEnd: () => { setDraggedId(null); setDropTarget(null); }, renderTreeNodeMenu: renderTreeNodeMenu, onToggleDisabled: handleToggleDisabled, setSelectedId: setSelectedId }) })] }))] }), _jsx(TreeContextMenu, { contextMenu: contextMenu, onClose: closeContextMenu, children: (nodeId, close) => renderTreeNodeMenu(nodeId, nodeId === rootId, close) })] }));
+                                            }, children: "\u22EE" })), children: (close) => (_jsx(FileMenu, { getPrefab: getPrefab, onReplacePrefab: onReplacePrefab, onImportPrefab: onImportPrefab, onImportPackedPrefab: handleImportPackedPrefab, onClose: close })) })] }))] }), !collapsed && (_jsxs(_Fragment, { children: [_jsx("div", { style: { padding: '4px 4px', borderBottom: `1px solid ${colors.borderLight}` }, children: _jsx("input", { type: "text", placeholder: "Search nodes...", value: searchQuery, onChange: (e) => setSearchQuery(e.target.value), onClick: (e) => e.stopPropagation(), style: Object.assign(Object.assign({}, base.input), { padding: '4px 8px' }) }) }), _jsx("div", { style: tree.scroll, children: _jsx(TreeNode, { nodeId: rootId, depth: 0, rootId: rootId, visibleIds: visibleIds, collapsedIds: collapsedIds, dropTarget: dropTarget, selectedNodeId: selectedId, onToggleCollapse: toggleCollapse, onOpenContextMenu: openContextMenu, onDragStart: handleDragStart, onDragOver: handleDragOver, onDragLeave: handleDragLeave, onDrop: handleDrop, onDragEnd: () => { setDraggedId(null); setDropTarget(null); }, renderTreeNodeMenu: renderTreeNodeMenu, onToggleDisabled: handleToggleDisabled, setSelectedId: setSelectedId }) })] }))] }), _jsx(TreeContextMenu, { contextMenu: contextMenu, onClose: closeContextMenu, children: (nodeId, close) => renderTreeNodeMenu(nodeId, nodeId === rootId, close) })] }));
 }
 const TreeNode = memo(function TreeNode({ nodeId, depth, rootId, visibleIds, collapsedIds, dropTarget, selectedNodeId, onToggleCollapse, onOpenContextMenu, onDragStart, onDragOver, onDragLeave, onDrop, onDragEnd, renderTreeNodeMenu, onToggleDisabled, setSelectedId, }) {
     var _a;

package/dist/tools/prefabeditor/EditorTreeMenus.d.ts

@@ -20,9 +20,10 @@ export declare function TreeContextMenu({ contextMenu, onClose, children, }: {
     onClose: () => void;
     children: (nodeId: string, onClose: () => void) => React.ReactNode;
 }): import("react").ReactPortal | null;
-export declare function FileMenu({ getPrefab, onReplacePrefab, onImportPrefab, onClose }: {
+export declare function FileMenu({ getPrefab, onReplacePrefab, onImportPrefab, onImportPackedPrefab, onClose }: {
     getPrefab: () => Prefab;
     onReplacePrefab: (prefab: Prefab) => void;
     onImportPrefab: (prefab: Prefab) => void;
+    onImportPackedPrefab: (url: string) => void;
     onClose: () => void;
 }): import("react/jsx-runtime").JSX.Element;