react-three-game 0.0.69 → 0.0.71

package/dist/tools/prefabeditor/InstanceProvider.js

@@ -16,29 +16,31 @@ import { InstancedRigidBodies } from "@react-three/rapier";
 import { ActiveCollisionTypes } from "@dimforge/rapier3d-compat";
 import { Mesh, Matrix4, Vector3, Quaternion, Euler, BoxHelper } from "three";
 import { gameEvents, getEntityIdFromRigidBody } from "./GameEvents";
+import { useClickValid } from "./useClickValid";
 export const DEFAULT_REPEAT_AXES = [{ axis: 'x', count: 1, offset: 1 }];
 export function normalizeRepeatAxes(value) {
     if (!Array.isArray(value)) {
         return DEFAULT_REPEAT_AXES;
     }
     const seen = new Set();
-    const normalized = value.flatMap((entry) => {
+    const normalized = value.reduce((result, entry) => {
         if (!entry || typeof entry !== 'object')
-            return [];
+            return result;
         const axisValue = entry.axis;
         if (axisValue !== 'x' && axisValue !== 'y' && axisValue !== 'z')
-            return [];
+            return result;
         if (seen.has(axisValue))
-            return [];
+            return result;
         seen.add(axisValue);
         const countValue = Number(entry.count);
         const offsetValue = Number(entry.offset);
-        return [{
-                axis: axisValue,
-                count: Number.isFinite(countValue) ? Math.max(1, Math.floor(countValue)) : 1,
-                offset: Number.isFinite(offsetValue) ? offsetValue : 1,
-            }];
-    });
+        result.push({
+            axis: axisValue,
+            count: Number.isFinite(countValue) ? Math.max(1, Math.floor(countValue)) : 1,
+            offset: Number.isFinite(offsetValue) ? offsetValue : 1,
+        });
+        return result;
+    }, []);
     return normalized.length > 0 ? normalized : DEFAULT_REPEAT_AXES;
 }
 function toVector3Tuple(value, fallback) {
@@ -101,36 +103,17 @@ function hasPhysics(instance) {
 function getColliderType(physics) {
     return physics.colliders || (physics.type === 'fixed' ? 'trimesh' : 'hull');
 }
-function emitSensorEnter(sourceId, payload) {
-    gameEvents.emit('sensor:enter', {
-        sourceEntityId: sourceId,
-        targetEntityId: getEntityIdFromRigidBody(payload.other.rigidBody),
-        targetRigidBody: payload.other.rigidBody,
-    });
-}
-function emitSensorExit(sourceId, payload) {
-    gameEvents.emit('sensor:exit', {
-        sourceEntityId: sourceId,
-        targetEntityId: getEntityIdFromRigidBody(payload.other.rigidBody),
-        targetRigidBody: payload.other.rigidBody,
-    });
-}
-function emitCollisionEnter(sourceId, payload) {
-    gameEvents.emit('collision:enter', {
-        sourceEntityId: sourceId,
-        targetEntityId: getEntityIdFromRigidBody(payload.other.rigidBody),
-        targetRigidBody: payload.other.rigidBody,
-    });
-}
-function emitCollisionExit(sourceId, payload) {
-    gameEvents.emit('collision:exit', {
+function emitPhysicsEvent(sourceId, eventName, payload) {
+    if (!eventName)
+        return;
+    gameEvents.emit(eventName, {
         sourceEntityId: sourceId,
         targetEntityId: getEntityIdFromRigidBody(payload.other.rigidBody),
         targetRigidBody: payload.other.rigidBody,
     });
 }
-function emitClick(sourceId, instanceId, event) {
-    gameEvents.emit('click', {
+function emitClick(sourceId, instanceId, eventName, event) {
+    gameEvents.emit(eventName, {
         sourceEntityId: sourceId,
         instanceEntityId: instanceId && instanceId !== sourceId ? instanceId : undefined,
         point: [event.point.x, event.point.y, event.point.z],
@@ -145,6 +128,7 @@ function instanceEquals(a, b) {
     return a.id === b.id &&
         a.sourceId === b.sourceId &&
         a.clickable === b.clickable &&
+        a.clickEventName === b.clickEventName &&
         a.locked === b.locked &&
         a.meshPath === b.meshPath &&
         arrayEquals(a.position, b.position) &&
@@ -261,7 +245,7 @@ function InstancedRigidGroup({ group, modelKey, partCount, flatMeshes, onSelect,
     const rigidBodiesRef = useRef(null);
     const instances = useMemo(() => group.instances.filter(hasPhysics).map(inst => {
         const _a = inst.physics, { activeCollisionTypes: _activeCollisionTypes, colliders: _colliders, userData } = _a, rigidBodyProps = __rest(_a, ["activeCollisionTypes", "colliders", "userData"]);
-        return Object.assign(Object.assign({ key: inst.id, position: inst.position, rotation: inst.rotation, scale: inst.scale }, rigidBodyProps), { colliders: getColliderType(inst.physics), userData: Object.assign(Object.assign({}, userData), { entityId: inst.sourceId }), onIntersectionEnter: (payload) => emitSensorEnter(inst.sourceId, payload), onIntersectionExit: (payload) => emitSensorExit(inst.sourceId, payload), onCollisionEnter: (payload) => emitCollisionEnter(inst.sourceId, payload), onCollisionExit: (payload) => emitCollisionExit(inst.sourceId, payload) });
+        return Object.assign(Object.assign({ key: inst.id, position: inst.position, rotation: inst.rotation, scale: inst.scale }, rigidBodyProps), { colliders: getColliderType(inst.physics), userData: Object.assign(Object.assign({}, userData), { entityId: inst.sourceId }), onIntersectionEnter: (payload) => emitPhysicsEvent(inst.sourceId, inst.physics.sensorEnterEventName, payload), onIntersectionExit: (payload) => emitPhysicsEvent(inst.sourceId, inst.physics.sensorExitEventName, payload), onCollisionEnter: (payload) => emitPhysicsEvent(inst.sourceId, inst.physics.collisionEnterEventName, payload), onCollisionExit: (payload) => emitPhysicsEvent(inst.sourceId, inst.physics.collisionExitEventName, payload) });
     }), [group.instances]);
     // Apply scale to visual meshes (InstancedRigidBodies only scales colliders, not visuals)
     useEffect(() => {
@@ -336,7 +320,7 @@ function InstancedRigidGroup({ group, modelKey, partCount, flatMeshes, onSelect,
         if (!instance.clickable)
             return;
         e.stopPropagation();
-        emitClick(instance.sourceId, instance.id, e);
+        emitClick(instance.sourceId, instance.id, instance.clickEventName || 'click', e);
     };
     const shouldHandleClick = editMode || group.instances.some(inst => inst.clickable);
     // Add key to force remount when instance count changes significantly (helps with cleanup)
@@ -356,12 +340,19 @@ function NonPhysicsInstancedGroup({ modelKey, group, partCount, instancesMap, on
 }
 // Individual instance item with its own click state
 function InstanceGroupItem({ instance, InstanceComponents, onSelect, registerRef, selectedId, editMode }) {
-    const clickValid = useRef(false);
     const groupRef = useRef(null);
     const isLocked = Boolean(instance.locked);
     const isSelected = selectedId === instance.id || selectedId === instance.sourceId;
     const canSelect = editMode && !isLocked;
     const canClick = !editMode && Boolean(instance.clickable);
+    const pointerHandlers = useClickValid(canSelect || canClick, (e) => {
+        if (editMode) {
+            onSelect === null || onSelect === void 0 ? void 0 : onSelect(instance.sourceId);
+        }
+        else if (instance.clickable) {
+            emitClick(instance.sourceId, instance.id, instance.clickEventName || 'click', e);
+        }
+    });
     // Use BoxHelper when object is selected in edit mode
     useHelper(editMode && isSelected ? groupRef : null, BoxHelper, 'cyan');
     useEffect(() => {
@@ -370,18 +361,7 @@ function InstanceGroupItem({ instance, InstanceComponents, onSelect, registerRef
         registerRef === null || registerRef === void 0 ? void 0 : registerRef(instance.id, groupRef.current);
         return () => registerRef === null || registerRef === void 0 ? void 0 : registerRef(instance.id, null);
     }, [editMode, instance.id, registerRef]);
-    return (_jsx("group", { ref: groupRef, position: instance.position, rotation: instance.rotation, scale: instance.scale, onPointerDown: canSelect || canClick ? (e) => { e.stopPropagation(); clickValid.current = true; } : undefined, onPointerMove: canSelect || canClick ? () => { clickValid.current = false; } : undefined, onPointerUp: canSelect || canClick ? (e) => {
-            if (clickValid.current) {
-                e.stopPropagation();
-                if (editMode) {
-                    onSelect === null || onSelect === void 0 ? void 0 : onSelect(instance.sourceId);
-                }
-                else if (instance.clickable) {
-                    emitClick(instance.sourceId, instance.id, e);
-                }
-            }
-            clickValid.current = false;
-        } : undefined, children: InstanceComponents.map((Instance, i) => _jsx(Instance, {}, i)) }));
+    return (_jsx("group", Object.assign({ ref: groupRef, position: instance.position, rotation: instance.rotation, scale: instance.scale }, pointerHandlers, { children: InstanceComponents.map((Instance, i) => _jsx(Instance, {}, i)) })));
 }
 // Hook to check if an instance exists
 export function useInstanceCheck(id) {
@@ -390,21 +370,43 @@ export function useInstanceCheck(id) {
     return (_a = ctx === null || ctx === void 0 ? void 0 : ctx.hasInstance(id)) !== null && _a !== void 0 ? _a : false;
 }
 // GameInstance component: registers an instance for batch rendering (renders nothing itself)
-export const GameInstance = React.forwardRef(({ id, sourceId, clickable = false, modelUrl, locked = false, position, rotation, scale, physics = undefined, }, ref) => {
+export const GameInstance = React.forwardRef(({ id, sourceId, clickable = false, clickEventName, modelUrl, locked = false, position, rotation, scale, physics = undefined, }, ref) => {
     const ctx = useContext(GameInstanceContext);
     const addInstance = ctx === null || ctx === void 0 ? void 0 : ctx.addInstance;
     const removeInstance = ctx === null || ctx === void 0 ? void 0 : ctx.removeInstance;
+    const [positionX, positionY, positionZ] = position;
+    const [rotationX, rotationY, rotationZ] = rotation;
+    const [scaleX, scaleY, scaleZ] = scale;
+    const physicsSignature = getPhysicsSignature(physics);
     const instance = useMemo(() => ({
         id,
         sourceId: sourceId !== null && sourceId !== void 0 ? sourceId : id,
         clickable,
+        clickEventName,
         locked,
         meshPath: modelUrl,
         position,
         rotation,
         scale,
         physics,
-    }), [id, sourceId, clickable, locked, modelUrl, JSON.stringify(position), JSON.stringify(rotation), JSON.stringify(scale), getPhysicsSignature(physics)]);
+    }), [
+        id,
+        sourceId,
+        clickable,
+        clickEventName,
+        locked,
+        modelUrl,
+        positionX,
+        positionY,
+        positionZ,
+        rotationX,
+        rotationY,
+        rotationZ,
+        scaleX,
+        scaleY,
+        scaleZ,
+        physicsSignature,
+    ]);
     useEffect(() => {
         if (!addInstance || !removeInstance)
             return;

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

@@ -3,7 +3,7 @@ import { Object3D, Texture } from "three";
 import { GameObject, Prefab } from "./types";
 import { PrefabRootRef } from "./PrefabRoot";
 import type { ExportGLBOptions } from "./utils";
-import { type Scene, type SpawnOptions } from "./sceneApi";
+import { type Scene, type SpawnOptions } from "./scene";
 export interface PrefabEditorRef {
     screenshot: () => void;
     exportGLB: (options?: ExportGLBOptions) => Promise<ArrayBuffer | undefined>;
@@ -19,10 +19,32 @@ export interface PrefabEditorRef {
     addTexture: (path: string, texture: Texture, options?: SpawnOptions) => GameObject;
     viewRef: React.RefObject<PrefabRootRef | null>;
 }
+export declare enum PrefabEditorMode {
+    Edit = "edit",
+    Play = "play"
+}
+export interface EditorContextType {
+    mode: PrefabEditorMode;
+    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 function useEditorContext(): EditorContextType;
 export interface PrefabEditorProps {
     basePath?: string;
     initialPrefab?: Prefab;
     physics?: boolean;
+    mode?: PrefabEditorMode;
     onChange?: (prefab: Prefab) => void;
     showUI?: boolean;
     enableWindowDrop?: boolean;

package/dist/tools/prefabeditor/PrefabEditor.js

@@ -10,31 +10,39 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { MapControls, TransformControls } from "@react-three/drei";
 import GameCanvas from "../../shared/GameCanvas";
-import { useCallback, useEffect, useMemo, useRef, useState, forwardRef, useImperativeHandle } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState, forwardRef, useImperativeHandle, createContext, useContext } from "react";
+import { findComponentEntry } from "./types";
 import PrefabRoot from "./PrefabRoot";
 import { Physics } from "@react-three/rapier";
 import EditorUI from "./EditorUI";
 import { base, toolbar } from "./styles";
-import { EditorContext } from "./EditorContext";
-import { createImageNode, createModelNode, computeParentWorldMatrix, decompose, exportGLB as exportGLBFile, exportGLBData, focusCameraOnObject, regenerateIds } from "./utils";
+import { computeParentWorldMatrix, decompose, exportGLB as exportGLBFile, exportGLBData, focusCameraOnObject, regenerateIds } from "./utils";
 import { loadFiles } from "../dragdrop";
-import { createPrefabStore, PrefabStoreProvider, prefabStoreToPrefab } from "./prefabStore";
-import { createScene } from "./sceneApi";
+import { denormalizePrefab, createImageNode, createModelNode, createNode } from './prefab';
+import { createPrefabStore, PrefabStoreProvider } from "./prefabStore";
+import { createScene } from "./scene";
+export var PrefabEditorMode;
+(function (PrefabEditorMode) {
+    PrefabEditorMode["Edit"] = "edit";
+    PrefabEditorMode["Play"] = "play";
+})(PrefabEditorMode || (PrefabEditorMode = {}));
+export const EditorContext = createContext(null);
+export function useEditorContext() {
+    const context = useContext(EditorContext);
+    if (!context) {
+        throw new Error("useEditorContext must be used within EditorContext.Provider");
+    }
+    return context;
+}
+const MAX_HISTORY_LENGTH = 50;
+const HISTORY_DEBOUNCE_MS = 500;
 const DEFAULT_PREFAB = {
     id: "prefab-default",
     name: "New Prefab",
-    root: {
-        id: "root",
-        components: {
-            transform: {
-                type: "Transform",
-                properties: { position: [0, 0, 0], rotation: [0, 0, 0], scale: [1, 1, 1] }
-            }
-        }
-    }
+    root: createNode('Root', {}, { id: 'root' })
 };
-const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, onChange, showUI = true, enableWindowDrop = true, canvasProps, uiPlugins, children }, ref) => {
-    const [editMode, setEditMode] = useState(true);
+const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, mode: initialMode = PrefabEditorMode.Edit, onChange, showUI = true, enableWindowDrop = true, canvasProps, uiPlugins, children }, ref) => {
+    const [mode, setMode] = useState(initialMode);
     const [selectedId, setSelectedId] = useState(null);
     const [transformMode, setTransformMode] = useState("translate");
     const [scaleSnap, setScaleSnap] = useState(0);
@@ -51,9 +59,8 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, onCh
     const canvasRef = useRef(null);
     const controlsRef = useRef(null);
     const onChangeRef = useRef(onChange);
-    const [injectedModels, setInjectedModels] = useState({});
-    const [injectedTextures, setInjectedTextures] = useState({});
-    const getPrefab = useCallback(() => prefabStoreToPrefab(prefabStore.getState()), [prefabStore]);
+    const isEditMode = mode === PrefabEditorMode.Edit;
+    const getPrefab = useCallback(() => denormalizePrefab(prefabStore.getState()), [prefabStore]);
     onChangeRef.current = onChange;
     const setSelection = useCallback((nodeId) => {
         const nextNode = nodeId ? prefabStore.getState().nodesById[nodeId] : null;
@@ -62,24 +69,29 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, onCh
         }
         setSelectedId(nodeId);
     }, [prefabStore]);
-    const toggleEditMode = () => {
-        setEditMode(prev => {
-            const next = !prev;
-            if (!next) {
+    const updateMode = useCallback((nextMode) => {
+        setMode(prev => {
+            if (prev === nextMode)
+                return prev;
+            if (nextMode === PrefabEditorMode.Play) {
                 setSelectedId(null);
                 setSelectedObject(null);
             }
-            return next;
+            return nextMode;
         });
+    }, []);
+    const toggleMode = () => {
+        updateMode(isEditMode ? PrefabEditorMode.Play : PrefabEditorMode.Edit);
     };
+    useEffect(() => {
+        updateMode(initialMode);
+    }, [initialMode, updateMode]);
     const loadPrefab = useCallback((prefab, options) => {
         changeOriginRef.current = (options === null || options === void 0 ? void 0 : options.notifyChange) === false ? "replace-silent" : "replace";
         prefabStore.getState().replacePrefab(prefab);
         setSelectedObject(null);
         if (options === null || options === void 0 ? void 0 : options.resetHistory) {
             setSelectedId(null);
-            setInjectedModels({});
-            setInjectedTextures({});
             setHistory([prefab]);
             historyIndexRef.current = 0;
             setHistoryIndex(0);
@@ -101,7 +113,7 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, onCh
                 return;
             }
             lastRevision = state.revision;
-            const nextPrefab = prefabStoreToPrefab(state);
+            const nextPrefab = denormalizePrefab(state);
             const changeOrigin = changeOriginRef.current;
             if (changeOrigin !== "replace-silent") {
                 (_a = onChangeRef.current) === null || _a === void 0 ? void 0 : _a.call(onChangeRef, nextPrefab);
@@ -110,7 +122,7 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, onCh
                 clearTimeout(historyTimeout);
                 historyTimeout = null;
             }
-            if (changeOrigin || !editMode) {
+            if (changeOrigin || !isEditMode) {
                 changeOriginRef.current = null;
                 return;
             }
@@ -118,13 +130,13 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, onCh
                 const currentHistoryIndex = historyIndexRef.current;
                 setHistory(prev => {
                     const nextHistory = [...prev.slice(0, currentHistoryIndex + 1), nextPrefab];
-                    return nextHistory.length > 50 ? nextHistory.slice(1) : nextHistory;
+                    return nextHistory.length > MAX_HISTORY_LENGTH ? nextHistory.slice(1) : nextHistory;
                 });
-                const nextHistoryIndex = Math.min(currentHistoryIndex + 1, 49);
+                const nextHistoryIndex = Math.min(currentHistoryIndex + 1, MAX_HISTORY_LENGTH - 1);
                 historyIndexRef.current = nextHistoryIndex;
                 setHistoryIndex(nextHistoryIndex);
                 historyTimeout = null;
-            }, 500);
+            }, HISTORY_DEBOUNCE_MS);
         });
         return () => {
             if (historyTimeout) {
@@ -132,7 +144,7 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, onCh
             }
             unsubscribe();
         };
-    }, [editMode, prefabStore]);
+    }, [isEditMode, prefabStore]);
     useEffect(() => {
         if (!selectedId)
             return;
@@ -165,15 +177,17 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, onCh
         addNode(regenerateIds(prefab.root), { select: false });
     }, [addNode]);
     const addModel = useCallback((path, model, options) => {
+        var _a;
         const node = createModelNode(path, options === null || options === void 0 ? void 0 : options.name);
         addNode(node, options);
-        setInjectedModels(prev => (Object.assign(Object.assign({}, prev), { [path]: model })));
+        (_a = prefabRootRef.current) === null || _a === void 0 ? void 0 : _a.addModel(path, model);
         return node;
     }, [addNode]);
     const addTexture = useCallback((path, texture, options) => {
+        var _a;
         const node = createImageNode(path, options === null || options === void 0 ? void 0 : options.name);
         addNode(node, options);
-        setInjectedTextures(prev => (Object.assign(Object.assign({}, prev), { [path]: texture })));
+        (_a = prefabRootRef.current) === null || _a === void 0 ? void 0 : _a.addTexture(path, texture);
         return node;
     }, [addNode]);
     const applyHistory = (index) => {
@@ -187,7 +201,7 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, onCh
     const undo = () => historyIndex > 0 && applyHistory(historyIndex - 1);
     const redo = () => historyIndex < history.length - 1 && applyHistory(historyIndex + 1);
     useEffect(() => {
-        if (!editMode)
+        if (!isEditMode)
             return;
         const handleKeyDown = (e) => {
             if (!(e.ctrlKey || e.metaKey))
@@ -203,7 +217,7 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, onCh
         };
         window.addEventListener('keydown', handleKeyDown);
         return () => window.removeEventListener('keydown', handleKeyDown);
-    }, [editMode, historyIndex, history]);
+    }, [isEditMode, historyIndex, history]);
     const handleScreenshot = useCallback(() => {
         const canvas = canvasRef.current;
         if (!canvas)
@@ -253,6 +267,18 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, onCh
     const scene = useMemo(() => createScene({
         getRootId: () => prefabStore.getState().rootId,
         getNode: (id) => { var _a; return (_a = prefabStore.getState().nodesById[id]) !== null && _a !== void 0 ? _a : null; },
+        getChildIds: (id) => { var _a; return (_a = prefabStore.getState().childIdsById[id]) !== null && _a !== void 0 ? _a : []; },
+        getParentId: (id) => { var _a; return (_a = prefabStore.getState().parentIdById[id]) !== null && _a !== void 0 ? _a : null; },
+        findByName: (name) => {
+            var _a;
+            const state = prefabStore.getState();
+            const normalized = name.toLowerCase();
+            for (const [id, node] of Object.entries(state.nodesById)) {
+                if (((_a = node.name) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === normalized)
+                    return id;
+            }
+            return null;
+        },
         updateNode: (id, update) => prefabStore.getState().updateNode(id, update),
         updateNodes: (updates) => prefabStore.getState().updateNodes(Object.entries(updates).map(([id, update]) => ({ id, update }))),
         addNode: (node, options) => addNode(node, options).id,
@@ -268,14 +294,19 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, onCh
         const parentWorld = computeParentWorldMatrix(prefabStore.getState(), selectedId);
         const local = parentWorld.clone().invert().multiply(object.matrixWorld);
         const { position, rotation, scale } = decompose(local);
-        prefabStore.getState().updateNode(selectedId, node => (Object.assign(Object.assign({}, node), { components: Object.assign(Object.assign({}, node.components), { transform: {
-                    type: "Transform",
-                    properties: { position, rotation, scale },
-                } }) })));
+        prefabStore.getState().updateNode(selectedId, node => {
+            var _a;
+            const entry = findComponentEntry(node, "Transform");
+            const key = (_a = entry === null || entry === void 0 ? void 0 : entry[0]) !== null && _a !== void 0 ? _a : "transform";
+            return Object.assign(Object.assign({}, node), { components: Object.assign(Object.assign({}, node.components), { [key]: {
+                        type: "Transform",
+                        properties: { position, rotation, scale },
+                    } }) });
+        });
     };
     // --- Drag & drop files to add nodes ---
     useEffect(() => {
-        if (!enableWindowDrop || !editMode)
+        if (!enableWindowDrop || !isEditMode)
             return;
         function handleDragOver(e) {
             e.preventDefault();
@@ -308,7 +339,7 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, onCh
             window.removeEventListener('dragover', handleDragOver);
             window.removeEventListener('drop', handleDrop);
         };
-    }, [addModel, addTexture, editMode, enableWindowDrop]);
+    }, [addModel, addTexture, isEditMode, enableWindowDrop]);
     useImperativeHandle(ref, () => ({
         screenshot: handleScreenshot,
         exportGLB: handleExportGLB,
@@ -321,9 +352,10 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, onCh
         addTexture,
         viewRef: prefabRootRef
     }), [addModel, addTexture, clearSelection, getPrefab, handleExportGLB, handleExportGLBData, handleScreenshot, loadPrefab, scene]);
-    const content = (_jsxs(_Fragment, { children: [_jsx("ambientLight", { intensity: 1.5 }), _jsx("gridHelper", { args: [10, 10], position: [0, -1, 0] }), _jsx(PrefabRoot, { ref: prefabRootRef, store: prefabStore, editMode: editMode, selectedId: selectedId, onSelect: setSelection, onSelectedObjectChange: editMode ? setSelectedObject : undefined, onFocusNode: editMode ? handleFocusNode : undefined, basePath: basePath, injectedModels: injectedModels, injectedTextures: injectedTextures }), children] }));
+    const content = (_jsxs(_Fragment, { children: [_jsx("gridHelper", { args: [10, 10], position: [0, -1, 0] }), _jsx(PrefabRoot, { ref: prefabRootRef, store: prefabStore, editMode: isEditMode, selectedId: selectedId, onSelect: setSelection, basePath: basePath }), children] }));
     return _jsx(PrefabStoreProvider, { store: prefabStore, children: _jsxs(EditorContext.Provider, { value: {
-                editMode,
+                mode,
+                setMode: updateMode,
                 transformMode,
                 setTransformMode,
                 scaleSnap,
@@ -332,10 +364,10 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, onCh
                 setPositionSnap,
                 rotationSnap,
                 setRotationSnap,
-                onFocusNode: editMode ? handleFocusNode : undefined,
+                onFocusNode: isEditMode ? handleFocusNode : undefined,
                 onScreenshot: handleScreenshot,
                 onExportGLB: handleExportGLB
-            }, children: [_jsxs(GameCanvas, Object.assign({ camera: { position: [0, 5, 15] }, canvasRef: canvasRef }, canvasProps, { onPointerMissed: editMode
+            }, children: [_jsxs(GameCanvas, Object.assign({ camera: { position: [0, 5, 15] }, canvasRef: canvasRef }, canvasProps, { onPointerMissed: isEditMode
                         ? (event) => {
                             var _a, _b, _c, _d;
                             const button = (_c = (_a = event.button) !== null && _a !== void 0 ? _a : (_b = event.sourceEvent) === null || _b === void 0 ? void 0 : _b.button) !== null && _c !== void 0 ? _c : 0;
@@ -344,7 +376,7 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, onCh
                             }
                             (_d = canvasProps === null || canvasProps === void 0 ? void 0 : canvasProps.onPointerMissed) === null || _d === void 0 ? void 0 : _d.call(canvasProps, event);
                         }
-                        : canvasProps === null || canvasProps === void 0 ? void 0 : canvasProps.onPointerMissed, children: [physics ? (_jsx(Physics, { debug: editMode, paused: editMode, children: content })) : content, editMode && (_jsxs(_Fragment, { children: [_jsx(MapControls, { ref: controlsRef, makeDefault: true }), selectedObject && (_jsx(TransformControls, { object: selectedObject, mode: transformMode, space: "local", onObjectChange: handleTransformChange, translationSnap: positionSnap > 0 ? positionSnap : undefined, rotationSnap: rotationSnap > 0 ? rotationSnap : undefined, scaleSnap: scaleSnap > 0 ? scaleSnap : undefined }, `transform-${transformMode}-${positionSnap}-${rotationSnap}-${scaleSnap}`))] }))] })), showUI && (_jsxs(_Fragment, { children: [_jsxs("div", { style: toolbar.panel, children: [_jsx("button", { style: base.btn, onClick: toggleEditMode, children: editMode ? "▶" : "⏸" }), uiPlugins] }), editMode && (_jsx(EditorUI, { selectedId: selectedId, setSelectedId: setSelection, getPrefab: getPrefab, onReplacePrefab: (prefab) => loadPrefab(prefab, { resetHistory: true }), onImportPrefab: importPrefab, basePath: basePath, onUndo: undo, onRedo: redo, canUndo: historyIndex > 0, canRedo: historyIndex < history.length - 1 }))] }))] }) });
+                        : canvasProps === null || canvasProps === void 0 ? void 0 : canvasProps.onPointerMissed, children: [physics ? (_jsx(Physics, { debug: isEditMode, paused: isEditMode, children: content })) : content, isEditMode && (_jsxs(_Fragment, { children: [_jsx(MapControls, { ref: controlsRef, makeDefault: true }), selectedObject && (_jsx(TransformControls, { object: selectedObject, mode: transformMode, space: "local", onObjectChange: handleTransformChange, translationSnap: positionSnap > 0 ? positionSnap : undefined, rotationSnap: rotationSnap > 0 ? rotationSnap : undefined, scaleSnap: scaleSnap > 0 ? scaleSnap : undefined }, `transform-${transformMode}-${positionSnap}-${rotationSnap}-${scaleSnap}`))] }))] })), showUI && (_jsxs(_Fragment, { children: [_jsxs("div", { style: toolbar.panel, children: [_jsx("button", { style: base.btn, onClick: toggleMode, children: isEditMode ? "▶" : "⏸" }), uiPlugins] }), isEditMode && (_jsx(EditorUI, { selectedId: selectedId, setSelectedId: setSelection, getPrefab: getPrefab, onReplacePrefab: (prefab) => loadPrefab(prefab, { resetHistory: true }), onImportPrefab: importPrefab, basePath: basePath, onUndo: undo, onRedo: redo, canUndo: historyIndex > 0, canRedo: historyIndex < history.length - 1 }))] }))] }) });
 });
 PrefabEditor.displayName = "PrefabEditor";
 export default PrefabEditor;

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

@@ -1,13 +1,36 @@
-import { Group, Matrix4, Object3D } from "three";
+import { Group, Matrix4, Object3D, Texture } from "three";
 import { ThreeEvent } from "@react-three/fiber";
 import { GameObject as GameObjectType, Prefab } from "./types";
-import { LoadedModels, LoadedTextures } from "../dragdrop";
+import { LoadedModels } from "../dragdrop";
 import { PrefabStoreApi } from "./prefabStore";
+import { type RefBridge } from "./RefBridge";
+/** Runtime context available to all component Views inside a PrefabRoot. */
+export interface SceneRuntime {
+    refBridge: RefBridge;
+    getRigidBody: (id: string) => any;
+    /** @internal Used by PhysicsComponent. */
+    registerRigidBodyRef: (id: string, rb: any) => void;
+    editMode?: boolean;
+    /** Get a loaded model by asset path. */
+    getModel: (path: string) => Object3D | null;
+    /** Get a loaded texture by asset path. */
+    getTexture: (path: string) => Texture | null;
+    /** Get a loaded sound buffer by asset path. */
+    getSound: (path: string) => AudioBuffer | null;
+    /** Get a revision string that changes when loaded assets change (for cache-busting keys). */
+    getAssetRevision: () => string;
+}
+/** Access the scene runtime (refBridge, getRigidBody, editMode) from within a component View. */
+export declare function useSceneRuntime(): SceneRuntime;
 export interface PrefabRootRef {
     root: Group | null;
+    refBridge: RefBridge;
     rigidBodyRefs: Map<string, any>;
     getObject: (nodeId: string) => Object3D | null;
-    focusNode: (nodeId: string) => void;
+    getRigidBody: (nodeId: string) => any;
+    addModel: (path: string, model: Object3D) => void;
+    addTexture: (path: string, texture: Texture) => void;
+    addSound: (path: string, sound: AudioBuffer) => void;
 }
 export interface PrefabRootProps {
     editMode?: boolean;
@@ -16,11 +39,7 @@ export interface PrefabRootProps {
     selectedId?: string | null;
     onSelect?: (id: string | null) => void;
     onClick?: (event: ThreeEvent<PointerEvent>, entity: GameObjectType) => void;
-    onSelectedObjectChange?: (object: Object3D | null) => void;
-    onFocusNode?: (nodeId: string) => void;
     basePath?: string;
-    injectedModels?: LoadedModels;
-    injectedTextures?: LoadedTextures;
 }
 export declare const PrefabRoot: import("react").ForwardRefExoticComponent<PrefabRootProps & import("react").RefAttributes<PrefabRootRef>>;
 export declare function GameObjectRenderer(props: RendererProps): import("react/jsx-runtime").JSX.Element | null;
@@ -30,9 +49,7 @@ interface RendererProps {
     onSelect?: (id: string) => void;
     onClick?: (event: ThreeEvent<PointerEvent>, entity: GameObjectType) => void;
     registerRef: (id: string, obj: Object3D | null) => void;
-    registerRigidBodyRef: (id: string, rb: any) => void;
     loadedModels: LoadedModels;
-    loadedTextures: LoadedTextures;
     editMode?: boolean;
     parentMatrix?: Matrix4;
 }