react-three-game 0.0.69 → 0.0.71

package/dist/tools/prefabeditor/components/ModelComponent.js

@@ -1,8 +1,9 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { ModelPicker } from '../../assetviewer/page';
 import { useContext, useMemo } from 'react';
-import { BooleanField, FieldGroup, Label, NumberInput, SelectInput } from './Input';
-import { EditorContext } from '../EditorContext';
+import { BooleanField, FieldGroup, Label, ListEditor, NumberInput, SelectInput } from './Input';
+import { useSceneRuntime } from '../PrefabRoot';
+import { EditorContext } from '../PrefabEditor';
 import { DEFAULT_REPEAT_AXES, getRepeatAxesFromModelProperties, normalizeRepeatAxes } from '../InstanceProvider';
 import { colors } from '../styles';
 const AXIS_OPTIONS = [
@@ -18,12 +19,10 @@ function quantize(value, step) {
     return Math.round(value / step) * step;
 }
 function RepeatAxisEditor({ axes, onChange, positionSnap, }) {
-    const addAxis = () => {
-        const used = new Set(axes.map(axis => axis.axis));
-        const nextAxis = AXIS_OPTIONS.find(option => !used.has(option.value));
-        if (!nextAxis)
+    const addAxis = (axisValue) => {
+        if (!axisValue)
             return;
-        onChange([...axes, { axis: nextAxis.value, count: 1, offset: 1 }]);
+        onChange([...axes, { axis: axisValue, count: 1, offset: 1 }]);
     };
     const updateAxis = (index, patch) => {
         const nextAxes = axes.map((axis, axisIndex) => axisIndex === index ? Object.assign(Object.assign({}, axis), patch) : axis);
@@ -32,41 +31,30 @@ function RepeatAxisEditor({ axes, onChange, positionSnap, }) {
     const removeAxis = (index) => {
         onChange(axes.filter((_, axisIndex) => axisIndex !== index));
     };
-    const canAddAxis = axes.length < AXIS_OPTIONS.length;
-    return (_jsxs("div", { style: { display: 'flex', flexDirection: 'column', gap: 8 }, children: [_jsxs("div", { style: { display: 'flex', alignItems: 'center', justifyContent: 'space-between' }, children: [_jsx(Label, { children: "Repeat Axes" }), _jsx("button", { type: "button", onClick: addAxis, disabled: !canAddAxis, style: {
-                            width: 22,
-                            height: 22,
-                            borderRadius: 3,
-                            border: `1px solid ${canAddAxis ? colors.accentBorder : colors.border}`,
-                            background: canAddAxis ? colors.accentBg : colors.bgSurface,
-                            color: canAddAxis ? colors.accent : colors.textMuted,
-                            cursor: canAddAxis ? 'pointer' : 'not-allowed',
-                            fontSize: 14,
-                            lineHeight: 1,
-                            padding: 0,
-                        }, title: canAddAxis ? 'Add repeat axis' : 'All axes already in use', children: "+" })] }), axes.map((axisConfig, index) => {
-                const usedByOthers = new Set(axes.filter((_, axisIndex) => axisIndex !== index).map(axis => axis.axis));
-                const axisOptions = AXIS_OPTIONS.filter(option => option.value === axisConfig.axis || !usedByOthers.has(option.value));
-                return (_jsxs("div", { style: {
-                        display: 'flex',
-                        flexDirection: 'column',
-                        gap: 6,
-                        padding: 8,
-                        border: `1px solid ${colors.border}`,
-                        borderRadius: 4,
-                        background: colors.bgSurface,
-                    }, children: [_jsxs("div", { style: { display: 'flex', gap: 6, alignItems: 'end' }, children: [_jsx("div", { style: { flex: 1, minWidth: 0 }, children: _jsx(SelectInput, { label: "Axis", value: axisConfig.axis, onChange: (axis) => updateAxis(index, { axis: axis }), options: axisOptions }) }), index > 0 ? (_jsx("button", { type: "button", onClick: () => removeAxis(index), style: {
-                                        height: 24,
-                                        width: 28,
-                                        borderRadius: 3,
-                                        border: `1px solid ${colors.border}`,
-                                        background: colors.bgInput,
-                                        color: colors.text,
-                                        cursor: 'pointer',
-                                        padding: 0,
-                                        flexShrink: 0,
-                                    }, title: "Remove repeat axis", children: "\u00D7" })) : null] }), _jsxs("div", { style: { display: 'flex', flexDirection: 'column', gap: 6 }, children: [_jsxs("div", { children: [_jsx(Label, { children: "Count" }), _jsx(NumberInput, { value: axisConfig.count, onChange: (count) => updateAxis(index, { count: Math.max(1, Math.floor(count)) }), step: 1, min: 1, style: { width: '100%', minWidth: 0, boxSizing: 'border-box' } })] }), _jsxs("div", { children: [_jsx(Label, { children: "Offset" }), _jsx(NumberInput, { value: axisConfig.offset, onChange: (offset) => updateAxis(index, { offset: quantize(offset, positionSnap) }), step: positionSnap > 0 ? positionSnap : 0.1, style: { width: '100%', minWidth: 0, boxSizing: 'border-box' } })] })] })] }, `${axisConfig.axis}-${index}`));
-            })] }));
+    const availableAxisOptions = AXIS_OPTIONS.filter(option => !axes.some(axis => axis.axis === option.value));
+    return (_jsx(ListEditor, { label: "Repeat Axes", items: axes, onAdd: addAxis, addOptions: availableAxisOptions, canAdd: availableAxisOptions.length > 0, emptyMessage: "No repeat axes added.", addButtonTitle: "Add repeat axis", addDisabledTitle: "All axes already in use", renderItem: (axisConfig, index) => {
+            const usedByOthers = new Set(axes.filter((_, axisIndex) => axisIndex !== index).map(axis => axis.axis));
+            const axisOptions = AXIS_OPTIONS.filter(option => option.value === axisConfig.axis || !usedByOthers.has(option.value));
+            return (_jsxs("div", { style: {
+                    display: 'flex',
+                    flexDirection: 'column',
+                    gap: 6,
+                    padding: 8,
+                    border: `1px solid ${colors.border}`,
+                    borderRadius: 4,
+                    background: colors.bgSurface,
+                }, children: [_jsxs("div", { style: { display: 'flex', gap: 6, alignItems: 'end' }, children: [_jsx("div", { style: { flex: 1, minWidth: 0 }, children: _jsx(SelectInput, { label: "Axis", value: axisConfig.axis, onChange: (axis) => updateAxis(index, { axis: axis }), options: axisOptions }) }), _jsx("button", { type: "button", onClick: () => removeAxis(index), style: {
+                                    height: 24,
+                                    width: 28,
+                                    borderRadius: 3,
+                                    border: `1px solid ${colors.border}`,
+                                    background: colors.bgInput,
+                                    color: colors.text,
+                                    cursor: 'pointer',
+                                    padding: 0,
+                                    flexShrink: 0,
+                                }, title: "Remove repeat axis", children: "\u00D7" })] }), _jsxs("div", { style: { display: 'flex', flexDirection: 'column', gap: 6 }, children: [_jsxs("div", { children: [_jsx(Label, { children: "Count" }), _jsx(NumberInput, { value: axisConfig.count, onChange: (count) => updateAxis(index, { count: Math.max(1, Math.floor(count)) }), step: 1, min: 1, style: { width: '100%', minWidth: 0, boxSizing: 'border-box' } })] }), _jsxs("div", { children: [_jsx(Label, { children: "Offset" }), _jsx(NumberInput, { value: axisConfig.offset, onChange: (offset) => updateAxis(index, { offset: quantize(offset, positionSnap) }), step: positionSnap > 0 ? positionSnap : 0.1, style: { width: '100%', minWidth: 0, boxSizing: 'border-box' } })] })] })] }, `${axisConfig.axis}-${index}`));
+        } }));
 }
 function ModelComponentEditor({ component, node, onUpdate, basePath = "" }) {
     var _a;
@@ -76,11 +64,12 @@ function ModelComponentEditor({ component, node, onUpdate, basePath = "" }) {
     return (_jsxs(FieldGroup, { children: [_jsx(ModelPicker, { value: component.properties.filename, onChange: (filename) => onUpdate({ filename }), basePath: basePath, pickerKey: node === null || node === void 0 ? void 0 : node.id }), _jsx(BooleanField, { name: "instanced", label: "Instanced", values: component.properties, onChange: onUpdate, fallback: false }), component.properties.instanced && (_jsxs(_Fragment, { children: [_jsx(BooleanField, { name: "repeat", label: "Repeat", values: component.properties, onChange: onUpdate, fallback: false }), component.properties.repeat && (_jsx(RepeatAxisEditor, { axes: repeatAxes, onChange: (nextAxes) => onUpdate({ repeatAxes: nextAxes }), positionSnap: positionSnap }))] }))] }));
 }
 // View for Model component
-function ModelComponentView({ properties, loadedModels, children }) {
+function ModelComponentView({ properties, children }) {
+    const { getModel } = useSceneRuntime();
     // Instanced models are handled elsewhere (GameInstance), so only render non-instanced here
     if (!properties.filename || properties.instanced)
         return _jsx(_Fragment, { children: children });
-    const sourceModel = loadedModels === null || loadedModels === void 0 ? void 0 : loadedModels[properties.filename];
+    const sourceModel = getModel(properties.filename);
     // Clone model once and set up shadows - memoized to avoid cloning on every render
     const clonedModel = useMemo(() => {
         if (!sourceModel)
@@ -107,6 +96,11 @@ const ModelComponent = {
         instanced: false,
         repeat: false,
         repeatAxes: DEFAULT_REPEAT_AXES
-    }
+    },
+    getAssetRefs: (properties) => {
+        if (properties.filename)
+            return [{ type: 'model', path: properties.filename }];
+        return [];
+    },
 };
 export default ModelComponent;

package/dist/tools/prefabeditor/components/PhysicsComponent.d.ts

@@ -1,9 +1,18 @@
 import type { RigidBodyOptions } from "@react-three/rapier";
 import { Component } from "./ComponentRegistry";
-export type PhysicsProps = RigidBodyOptions & {
+type PhysicsColliderType = NonNullable<RigidBodyOptions['colliders']> | 'capsule';
+export type PhysicsProps = Omit<RigidBodyOptions, 'colliders'> & {
+    colliders?: PhysicsColliderType;
     activeCollisionTypes?: 'all' | undefined;
     linearVelocity?: [number, number, number];
     angularVelocity?: [number, number, number];
+    capsuleRadius?: number;
+    capsuleHalfHeight?: number;
+    sensorEnterEventName?: string;
+    sensorExitEventName?: string;
+    collisionEnterEventName?: string;
+    collisionExitEventName?: string;
 };
+export declare function isPhysicsProps(v: any): v is PhysicsProps;
 declare const PhysicsComponent: Component;
 export default PhysicsComponent;

package/dist/tools/prefabeditor/components/PhysicsComponent.js

@@ -9,22 +9,112 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { RigidBody, useRapier } from "@react-three/rapier";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { CapsuleCollider, RigidBody, useRapier } from "@react-three/rapier";
 import { useRef, useEffect, useCallback } from 'react';
-import { BooleanField, FieldGroup, NumberField, SelectField, Vector3Field } from "./Input";
+import { useSceneRuntime } from "../PrefabRoot";
+import { BooleanField, FieldGroup, ListEditor, NumberField, SelectField, SelectInput, StringInput, Vector3Field } from "./Input";
 import { gameEvents, getEntityIdFromRigidBody } from "../GameEvents";
 import { colors } from "../styles";
+export function isPhysicsProps(v) {
+    return (v === null || v === void 0 ? void 0 : v.type) === "fixed" || (v === null || v === void 0 ? void 0 : v.type) === "dynamic" || (v === null || v === void 0 ? void 0 : v.type) === "kinematicPosition" || (v === null || v === void 0 ? void 0 : v.type) === "kinematicVelocity";
+}
 const enabledAxesFallback = [true, true, true];
-function LockedAxisField({ label, values, onChange, }) {
-    const enabledTranslations = Array.isArray(values.enabledTranslations)
-        ? values.enabledTranslations
+const capsuleRadiusFallback = 0.35;
+const capsuleHalfHeightFallback = 0.45;
+const PHYSICS_EVENT_OPTIONS = [
+    {
+        key: 'sensorEnterEventName',
+        label: 'Sensor Enter',
+        defaultName: 'sensor:enter',
+        requiresSensor: true,
+    },
+    {
+        key: 'sensorExitEventName',
+        label: 'Sensor Exit',
+        defaultName: 'sensor:exit',
+        requiresSensor: true,
+    },
+    {
+        key: 'collisionEnterEventName',
+        label: 'Collision Enter',
+        defaultName: 'collision:enter',
+        requiresSensor: false,
+    },
+    {
+        key: 'collisionExitEventName',
+        label: 'Collision Exit',
+        defaultName: 'collision:exit',
+        requiresSensor: false,
+    },
+];
+function getPhysicsEventOption(key) {
+    return PHYSICS_EVENT_OPTIONS.find(option => option.key === key);
+}
+function getConfiguredPhysicsEvents(values) {
+    return PHYSICS_EVENT_OPTIONS.filter(option => typeof values[option.key] === 'string' && values[option.key].trim().length > 0);
+}
+function getAvailablePhysicsEvents(values, currentKey) {
+    const configuredKeys = new Set(getConfiguredPhysicsEvents(values).map(option => option.key));
+    return PHYSICS_EVENT_OPTIONS
+        .filter(option => option.key === currentKey || !configuredKeys.has(option.key))
+        .map(option => ({ value: option.key, label: option.label }));
+}
+function PhysicsEventBindingsEditor({ values, onChange, }) {
+    const configuredEvents = getConfiguredPhysicsEvents(values);
+    const nextEventOptions = getAvailablePhysicsEvents(values);
+    const addEvent = (eventKey) => {
+        if (!eventKey)
+            return;
+        const option = getPhysicsEventOption(eventKey);
+        if (!option)
+            return;
+        onChange(Object.assign({ [option.key]: option.defaultName }, (option.requiresSensor ? { sensor: true } : null)));
+    };
+    const updateEventKey = (currentKey, nextKey) => {
+        const nextOption = getPhysicsEventOption(nextKey);
+        if (!nextOption)
+            return;
+        onChange(Object.assign({ [currentKey]: undefined, [nextOption.key]: values[currentKey] || nextOption.defaultName }, (nextOption.requiresSensor ? { sensor: true } : null)));
+    };
+    const updateEventName = (key, eventName) => {
+        onChange({ [key]: eventName });
+    };
+    const removeEvent = (key) => {
+        onChange({ [key]: undefined });
+    };
+    return (_jsx(ListEditor, { label: "Events", items: configuredEvents, onAdd: addEvent, addOptions: nextEventOptions, canAdd: nextEventOptions.length > 0, emptyMessage: "No physics events configured.", addButtonTitle: "Add physics event", addDisabledTitle: "All physics events already added", renderItem: (option) => {
+            var _a;
+            return (_jsxs("div", { style: {
+                    display: 'flex',
+                    flexDirection: 'column',
+                    gap: 6,
+                    padding: 8,
+                    border: `1px solid ${colors.border}`,
+                    borderRadius: 4,
+                    background: colors.bgSurface,
+                }, children: [_jsxs("div", { style: { display: 'flex', gap: 6, alignItems: 'end' }, children: [_jsx("div", { style: { flex: 1, minWidth: 0 }, children: _jsx(SelectInput, { label: "Type", value: option.key, onChange: (nextKey) => updateEventKey(option.key, nextKey), options: getAvailablePhysicsEvents(values, option.key) }) }), _jsx("button", { type: "button", onClick: () => removeEvent(option.key), style: {
+                                    height: 24,
+                                    width: 28,
+                                    borderRadius: 3,
+                                    border: `1px solid ${colors.border}`,
+                                    background: colors.bgInput,
+                                    color: colors.text,
+                                    cursor: 'pointer',
+                                    padding: 0,
+                                    flexShrink: 0,
+                                }, title: "Remove physics event", children: "\u00D7" })] }), _jsx(StringInput, { label: "Event Name", value: (_a = values[option.key]) !== null && _a !== void 0 ? _a : option.defaultName, onChange: (eventName) => updateEventName(option.key, eventName), placeholder: option.defaultName })] }, option.key));
+        } }));
+}
+function LockedAxisField({ label, name, values, onChange, }) {
+    const enabledAxes = Array.isArray(values[name])
+        ? values[name]
         : enabledAxesFallback;
     const axisLabels = ['X', 'Y', 'Z'];
     const toggleAxisLock = (index) => {
-        const nextEnabledTranslations = [...enabledTranslations];
-        nextEnabledTranslations[index] = !nextEnabledTranslations[index];
-        onChange({ enabledTranslations: nextEnabledTranslations });
+        const nextEnabledAxes = [...enabledAxes];
+        nextEnabledAxes[index] = !nextEnabledAxes[index];
+        onChange({ [name]: nextEnabledAxes });
     };
     return (_jsxs("div", { children: [_jsxs("div", { style: {
                     display: 'flex',
@@ -42,7 +132,7 @@ function LockedAxisField({ label, values, onChange, }) {
                             fontSize: '10px',
                             color: colors.textDim,
                         }, children: "Active means locked" })] }), _jsx("div", { style: { display: 'flex', gap: 4 }, children: axisLabels.map((axisLabel, index) => {
-                    const isLocked = !enabledTranslations[index];
+                    const isLocked = !enabledAxes[index];
                     return (_jsx("button", { type: "button", onClick: () => toggleAxisLock(index), style: {
                             flex: 1,
                             backgroundColor: isLocked ? colors.dangerBg : colors.bgInput,
@@ -67,20 +157,23 @@ function PhysicsComponentEditor({ component, onUpdate }) {
                     { value: 'trimesh', label: 'Trimesh (exact)' },
                     { value: 'cuboid', label: 'Cuboid (box)' },
                     { value: 'ball', label: 'Ball (sphere)' },
-                ] }), _jsx(NumberField, { name: "mass", label: "Mass", values: component.properties, onChange: onUpdate, fallback: 1, step: 0.1, min: 0 }), _jsx(NumberField, { name: "restitution", label: "Restitution (Bounciness)", values: component.properties, onChange: onUpdate, fallback: 0, min: 0, max: 1, step: 0.1 }), _jsx(NumberField, { name: "friction", label: "Friction", values: component.properties, onChange: onUpdate, fallback: 0.5, min: 0, step: 0.1 }), _jsx(NumberField, { name: "linearDamping", label: "Linear Damping", values: component.properties, onChange: onUpdate, fallback: 0, min: 0, step: 0.1 }), _jsx(NumberField, { name: "angularDamping", label: "Angular Damping", values: component.properties, onChange: onUpdate, fallback: 0, min: 0, step: 0.1 }), _jsx(NumberField, { name: "gravityScale", label: "Gravity Scale", values: component.properties, onChange: onUpdate, fallback: 1, step: 0.1 }), _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(LockedAxisField, { label: "Lock Movement", values: component.properties, onChange: onUpdate }), _jsx(BooleanField, { name: "sensor", label: "Sensor (Trigger Only)", values: component.properties, onChange: onUpdate, fallback: false }), _jsx(SelectField, { name: "activeCollisionTypes", label: "Collision Detection", values: component.properties, onChange: onUpdate, options: [
+                    { value: 'capsule', label: 'Capsule' },
+                ] }), component.properties.colliders === 'capsule' ? (_jsxs(_Fragment, { children: [_jsx(NumberField, { name: "capsuleRadius", label: "Capsule Radius", values: component.properties, onChange: onUpdate, fallback: capsuleRadiusFallback, min: 0.01, step: 0.01 }), _jsx(NumberField, { name: "capsuleHalfHeight", label: "Capsule Half Height", values: component.properties, onChange: onUpdate, fallback: capsuleHalfHeightFallback, min: 0.01, step: 0.01 })] })) : null, _jsx(NumberField, { name: "mass", label: "Mass", values: component.properties, onChange: onUpdate, fallback: 1, step: 0.1, min: 0 }), _jsx(NumberField, { name: "restitution", label: "Restitution (Bounciness)", values: component.properties, onChange: onUpdate, fallback: 0, min: 0, max: 1, step: 0.1 }), _jsx(NumberField, { name: "friction", label: "Friction", values: component.properties, onChange: onUpdate, fallback: 0.5, min: 0, step: 0.1 }), _jsx(NumberField, { name: "linearDamping", label: "Linear Damping", values: component.properties, onChange: onUpdate, fallback: 0, min: 0, step: 0.1 }), _jsx(NumberField, { name: "angularDamping", label: "Angular Damping", values: component.properties, onChange: onUpdate, fallback: 0, min: 0, step: 0.1 }), _jsx(NumberField, { name: "gravityScale", label: "Gravity Scale", values: component.properties, onChange: onUpdate, fallback: 1, step: 0.1 }), _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(LockedAxisField, { label: "Lock Movement", name: "enabledTranslations", values: component.properties, onChange: onUpdate }), _jsx(LockedAxisField, { label: "Lock Rotations", name: "enabledRotations", values: component.properties, onChange: onUpdate }), _jsx(BooleanField, { name: "sensor", label: "Sensor (Trigger Only)", values: component.properties, onChange: onUpdate, fallback: false }), _jsx(PhysicsEventBindingsEditor, { values: component.properties, onChange: onUpdate }), _jsx(SelectField, { name: "activeCollisionTypes", label: "Collision Detection", values: component.properties, onChange: onUpdate, options: [
                     { value: '', label: 'Default (Dynamic only)' },
                     { value: 'all', label: 'All (includes kinematic & fixed)' },
                 ] })] }));
 }
-function PhysicsComponentView({ properties, children, position, rotation, scale, editMode, nodeId, registerRigidBodyRef }) {
-    const { type, colliders, sensor, activeCollisionTypes, linearVelocity = [0, 0, 0], angularVelocity = [0, 0, 0], enabledTranslations = enabledAxesFallback } = properties, otherProps = __rest(properties, ["type", "colliders", "sensor", "activeCollisionTypes", "linearVelocity", "angularVelocity", "enabledTranslations"]);
+function PhysicsComponentView({ properties, children, position, rotation, scale, editMode, nodeId }) {
+    const { registerRigidBodyRef } = useSceneRuntime();
+    const { type, colliders, sensor, activeCollisionTypes, linearVelocity = [0, 0, 0], angularVelocity = [0, 0, 0], capsuleRadius = capsuleRadiusFallback, capsuleHalfHeight = capsuleHalfHeightFallback, sensorEnterEventName, sensorExitEventName, collisionEnterEventName, collisionExitEventName, enabledTranslations = enabledAxesFallback, enabledRotations = enabledAxesFallback } = properties, otherProps = __rest(properties, ["type", "colliders", "sensor", "activeCollisionTypes", "linearVelocity", "angularVelocity", "capsuleRadius", "capsuleHalfHeight", "sensorEnterEventName", "sensorExitEventName", "collisionEnterEventName", "collisionExitEventName", "enabledTranslations", "enabledRotations"]);
     const colliderType = colliders || (type === 'fixed' ? 'trimesh' : 'hull');
+    const usesManualCapsuleCollider = colliderType === 'capsule';
     const rigidBodyRef = useRef(null);
     const linearVelocityKey = linearVelocity.join(',');
     const angularVelocityKey = angularVelocity.join(',');
     const rbKey = editMode
-        ? `${type || 'dynamic'}_${colliderType}_${position === null || position === void 0 ? void 0 : position.join(',')}_${rotation === null || rotation === void 0 ? void 0 : rotation.join(',')}`
-        : `${type || 'dynamic'}_${colliderType}`;
+        ? `${type || 'dynamic'}_${colliderType}_${capsuleRadius}_${capsuleHalfHeight}_${position === null || position === void 0 ? void 0 : position.join(',')}_${rotation === null || rotation === void 0 ? void 0 : rotation.join(',')}`
+        : `${type || 'dynamic'}_${colliderType}_${capsuleRadius}_${capsuleHalfHeight}`;
     // Try to get rapier context - will be null if not inside <Physics>
     let rapier = null;
     try {
@@ -92,11 +185,11 @@ function PhysicsComponentView({ properties, children, position, rotation, scale,
     }
     // Register RigidBody ref when it's available
     useEffect(() => {
-        if (nodeId && registerRigidBodyRef && rigidBodyRef.current) {
+        if (nodeId && rigidBodyRef.current) {
             registerRigidBodyRef(nodeId, rigidBodyRef.current);
         }
         return () => {
-            if (nodeId && registerRigidBodyRef) {
+            if (nodeId) {
                 registerRigidBodyRef(nodeId, null);
             }
         };
@@ -135,54 +228,57 @@ function PhysicsComponentView({ properties, children, position, rotation, scale,
     }, [rbKey, angularVelocityKey]);
     // Event handlers for physics interactions
     const handleIntersectionEnter = useCallback((payload) => {
-        if (!nodeId)
+        if (!nodeId || !sensorEnterEventName)
             return;
-        gameEvents.emit('sensor:enter', {
+        gameEvents.emit(sensorEnterEventName, {
             sourceEntityId: nodeId,
             targetEntityId: getEntityIdFromRigidBody(payload.other.rigidBody),
             targetRigidBody: payload.other.rigidBody,
         });
-    }, [nodeId]);
+    }, [nodeId, sensorEnterEventName]);
     const handleIntersectionExit = useCallback((payload) => {
-        if (!nodeId)
+        if (!nodeId || !sensorExitEventName)
             return;
-        gameEvents.emit('sensor:exit', {
+        gameEvents.emit(sensorExitEventName, {
             sourceEntityId: nodeId,
             targetEntityId: getEntityIdFromRigidBody(payload.other.rigidBody),
             targetRigidBody: payload.other.rigidBody,
         });
-    }, [nodeId]);
+    }, [nodeId, sensorExitEventName]);
     const handleCollisionEnter = useCallback((payload) => {
-        if (!nodeId)
+        if (!nodeId || !collisionEnterEventName)
             return;
-        gameEvents.emit('collision:enter', {
+        gameEvents.emit(collisionEnterEventName, {
             sourceEntityId: nodeId,
             targetEntityId: getEntityIdFromRigidBody(payload.other.rigidBody),
             targetRigidBody: payload.other.rigidBody,
         });
-    }, [nodeId]);
+    }, [collisionEnterEventName, nodeId]);
     const handleCollisionExit = useCallback((payload) => {
-        if (!nodeId)
+        if (!nodeId || !collisionExitEventName)
             return;
-        gameEvents.emit('collision:exit', {
+        gameEvents.emit(collisionExitEventName, {
             sourceEntityId: nodeId,
             targetEntityId: getEntityIdFromRigidBody(payload.other.rigidBody),
             targetRigidBody: payload.other.rigidBody,
         });
-    }, [nodeId]);
-    return (_jsx(RigidBody, Object.assign({ ref: rigidBodyRef, type: type, colliders: colliderType, position: position, rotation: rotation, scale: scale, sensor: sensor, enabledTranslations: enabledTranslations, userData: { entityId: nodeId }, onIntersectionEnter: handleIntersectionEnter, onIntersectionExit: handleIntersectionExit, onCollisionEnter: handleCollisionEnter, onCollisionExit: handleCollisionExit }, otherProps, { children: children }), rbKey));
+    }, [collisionExitEventName, nodeId]);
+    return (_jsxs(RigidBody, Object.assign({ ref: rigidBodyRef, type: type, colliders: usesManualCapsuleCollider ? false : colliderType, position: position, rotation: rotation, scale: scale, sensor: sensor, enabledTranslations: enabledTranslations, enabledRotations: enabledRotations, userData: { entityId: nodeId }, onIntersectionEnter: handleIntersectionEnter, onIntersectionExit: handleIntersectionExit, onCollisionEnter: handleCollisionEnter, onCollisionExit: handleCollisionExit }, otherProps, { children: [usesManualCapsuleCollider ? _jsx(CapsuleCollider, { args: [capsuleHalfHeight, capsuleRadius], sensor: sensor }) : null, children] }), rbKey));
 }
 const PhysicsComponent = {
     name: 'Physics',
     Editor: PhysicsComponentEditor,
     View: PhysicsComponentView,
-    nonComposable: true,
+    isWrapper: true,
     defaultProperties: {
         type: 'dynamic',
         colliders: 'hull',
+        capsuleRadius: capsuleRadiusFallback,
+        capsuleHalfHeight: capsuleHalfHeightFallback,
         linearVelocity: [0, 0, 0],
         angularVelocity: [0, 0, 0],
         enabledTranslations: [true, true, true],
+        enabledRotations: [true, true, true],
     }
 };
 export default PhysicsComponent;

package/dist/tools/prefabeditor/components/PointLightComponent.d.ts

@@ -0,0 +1,3 @@
+import { Component } from './ComponentRegistry';
+declare const PointLightComponent: Component;
+export default PointLightComponent;

package/dist/tools/prefabeditor/components/PointLightComponent.js

@@ -0,0 +1,55 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, useRef } from 'react';
+import { useHelper } from '@react-three/drei';
+import { PointLightHelper } from 'three';
+import { BooleanField, ColorField, NumberField } from './Input';
+import { LightSection, ShadowBiasField, mergeWithDefaults } from './lightUtils';
+const pointLightDefaults = {
+    color: '#ffffff',
+    intensity: 1,
+    distance: 0,
+    decay: 2,
+    castShadow: false,
+    shadowMapSize: 512,
+    shadowBias: 0,
+    shadowNormalBias: 0,
+    shadowAutoUpdate: true,
+    shadowCameraNear: 0.5,
+    shadowCameraFar: 500,
+};
+function PointLightComponentEditor({ component, onUpdate }) {
+    const values = mergeWithDefaults(pointLightDefaults, component.properties);
+    return (_jsxs("div", { style: { display: 'flex', flexDirection: 'column', gap: 8 }, children: [_jsxs(LightSection, { title: "Light", children: [_jsx(ColorField, { name: "color", label: "Color", values: values, onChange: onUpdate }), _jsx(NumberField, { name: "intensity", label: "Intensity", values: values, onChange: onUpdate, min: 0, step: 0.1, fallback: 1 }), _jsx(NumberField, { name: "distance", label: "Distance", values: values, onChange: onUpdate, min: 0, step: 1, fallback: 0 }), _jsx(NumberField, { name: "decay", label: "Decay", values: values, onChange: onUpdate, min: 0, step: 0.1, fallback: 2 })] }), _jsxs(LightSection, { title: "Shadow", children: [_jsx(BooleanField, { name: "castShadow", label: "Cast Shadow", values: values, onChange: onUpdate, fallback: false }), values.castShadow ? (_jsxs(_Fragment, { children: [_jsx(BooleanField, { name: "shadowAutoUpdate", label: "Auto Update", values: values, onChange: onUpdate, fallback: true }), _jsx(NumberField, { name: "shadowMapSize", label: "Map Size", values: values, onChange: onUpdate, min: 128, step: 128, fallback: 512 }), _jsx(ShadowBiasField, { name: "shadowBias", label: "Bias", values: values, onChange: onUpdate, fallback: 0 }), _jsx(ShadowBiasField, { name: "shadowNormalBias", label: "Normal Bias", values: values, onChange: onUpdate, fallback: 0 }), _jsx(NumberField, { name: "shadowCameraNear", label: "Near", values: values, onChange: onUpdate, min: 0.001, step: 0.1, fallback: 0.5 }), _jsx(NumberField, { name: "shadowCameraFar", label: "Far", values: values, onChange: onUpdate, min: 0.1, step: 1, fallback: 500 })] })) : null] })] }));
+}
+function PointLightView({ properties, children, editMode, isSelected }) {
+    const merged = mergeWithDefaults(pointLightDefaults, properties);
+    const color = merged.color;
+    const intensity = merged.intensity;
+    const distance = merged.distance;
+    const decay = merged.decay;
+    const castShadow = merged.castShadow;
+    const shadowMapSize = merged.shadowMapSize;
+    const shadowBias = merged.shadowBias;
+    const shadowNormalBias = merged.shadowNormalBias;
+    const shadowAutoUpdate = merged.shadowAutoUpdate;
+    const shadowCameraNear = merged.shadowCameraNear;
+    const shadowCameraFar = merged.shadowCameraFar;
+    const lightRef = useRef(null);
+    useHelper(editMode && isSelected ? lightRef : null, PointLightHelper, 0.5, color);
+    useEffect(() => {
+        var _a;
+        const shadow = (_a = lightRef.current) === null || _a === void 0 ? void 0 : _a.shadow;
+        if (!shadow)
+            return;
+        shadow.needsUpdate = true;
+        shadow.camera.updateProjectionMatrix();
+    }, [castShadow, shadowMapSize, shadowBias, shadowNormalBias, shadowAutoUpdate, shadowCameraNear, shadowCameraFar]);
+    return (_jsxs(_Fragment, { children: [_jsx("pointLight", { ref: lightRef, color: color, intensity: intensity, distance: distance, decay: decay, castShadow: castShadow, "shadow-mapSize-width": shadowMapSize, "shadow-mapSize-height": shadowMapSize, "shadow-bias": shadowBias, "shadow-normalBias": shadowNormalBias, "shadow-autoUpdate": shadowAutoUpdate, "shadow-camera-near": shadowCameraNear, "shadow-camera-far": shadowCameraFar }), editMode && isSelected ? (_jsxs("mesh", { children: [_jsx("sphereGeometry", { args: [0.2, 10, 8] }), _jsx("meshBasicMaterial", { color: color, wireframe: true })] })) : null, children] }));
+}
+const PointLightComponent = {
+    name: 'PointLight',
+    Editor: PointLightComponentEditor,
+    View: PointLightView,
+    defaultProperties: {},
+};
+export default PointLightComponent;

package/dist/tools/prefabeditor/components/SoundComponent.d.ts

@@ -0,0 +1,3 @@
+import { Component } from './ComponentRegistry';
+declare const SoundComponent: Component;
+export default SoundComponent;