react-three-game 0.0.70 → 0.0.72

package/dist/index.d.ts

@@ -10,15 +10,19 @@ export { useEditorContext } from './tools/prefabeditor/PrefabEditor';
 export type { EditorContextType } from './tools/prefabeditor/PrefabEditor';
 export { createPrefabStore, prefabStoreToPrefab, usePrefabStoreApi } from './tools/prefabeditor/prefabStore';
 export type { PrefabStoreApi, PrefabStoreState } from './tools/prefabeditor/prefabStore';
-export { createScene } from './tools/prefabeditor/sceneApi';
+export { createScene } from './tools/prefabeditor/scene';
+export { denormalizePrefab } from './tools/prefabeditor/prefab';
 export { registerComponent } from './tools/prefabeditor/components/ComponentRegistry';
 export { FieldRenderer, FieldGroup, ListEditor, Label, Vector3Input, Vector3Field, NumberField, ColorInput, ColorField, StringInput, StringField, BooleanInput, BooleanField, SelectInput, SelectField, } from './tools/prefabeditor/components/Input';
-export { loadJson, saveJson, exportGLB, exportGLBData, regenerateIds, computeParentWorldMatrix, createModelNode, createImageNode, } from './tools/prefabeditor/utils';
+export { loadJson, saveJson, exportGLB, exportGLBData, regenerateIds, computeParentWorldMatrix, } from './tools/prefabeditor/utils';
 export type { ExportGLBOptions } from './tools/prefabeditor/utils';
+export { createModelNode, createImageNode, } from './tools/prefabeditor/prefab';
 export type { PrefabEditorProps, PrefabEditorRef, } from './tools/prefabeditor/PrefabEditor';
-export type { SpawnOptions, Scene, Entity, EntityComponent, EntityData, EntityUpdate, PropertyPath, SceneUpdates, } from './tools/prefabeditor/sceneApi';
-export type { PrefabRootProps, PrefabRootRef } from './tools/prefabeditor/PrefabRoot';
-export type { Component } from './tools/prefabeditor/components/ComponentRegistry';
+export type { SpawnOptions, Scene, Entity, EntityComponent, EntityData, EntityUpdate, PropertyPath, SceneUpdates, } from './tools/prefabeditor/scene';
+export type { PrefabRootProps, AssetRuntime } from './tools/prefabeditor/PrefabRoot';
+export type { EntityRuntime, LiveObjectRef, LiveRigidBodyRef } from './tools/prefabeditor/PrefabRoot';
+export { useAssetRuntime, useEntityRuntime, useEntityObjectRef, useEntityRigidBodyRef } from './tools/prefabeditor/PrefabRoot';
+export type { Component, ComponentViewProps } from './tools/prefabeditor/components/ComponentRegistry';
 export type { FieldDefinition, FieldType } from './tools/prefabeditor/components/Input';
 export type { Prefab, GameObject, ComponentData } from './tools/prefabeditor/types';
 export { findComponent, findComponentEntry, hasComponent } from './tools/prefabeditor/types';

package/dist/index.js

@@ -10,13 +10,16 @@ export { default as PrefabRoot } from './tools/prefabeditor/PrefabRoot';
 export { useEditorContext } from './tools/prefabeditor/PrefabEditor';
 // Prefab Editor - Store & Scene API
 export { createPrefabStore, prefabStoreToPrefab, usePrefabStoreApi } from './tools/prefabeditor/prefabStore';
-export { createScene } from './tools/prefabeditor/sceneApi';
+export { createScene } from './tools/prefabeditor/scene';
+export { denormalizePrefab } from './tools/prefabeditor/prefab';
 // Prefab Editor - Component Registry
 export { registerComponent } from './tools/prefabeditor/components/ComponentRegistry';
 // Prefab Editor - Input Components
 export { FieldRenderer, FieldGroup, ListEditor, Label, Vector3Input, Vector3Field, NumberField, ColorInput, ColorField, StringInput, StringField, BooleanInput, BooleanField, SelectInput, SelectField, } from './tools/prefabeditor/components/Input';
 // Prefab Editor - Utils
-export { loadJson, saveJson, exportGLB, exportGLBData, regenerateIds, computeParentWorldMatrix, createModelNode, createImageNode, } from './tools/prefabeditor/utils';
+export { loadJson, saveJson, exportGLB, exportGLBData, regenerateIds, computeParentWorldMatrix, } from './tools/prefabeditor/utils';
+export { createModelNode, createImageNode, } from './tools/prefabeditor/prefab';
+export { useAssetRuntime, useEntityRuntime, useEntityObjectRef, useEntityRigidBodyRef } from './tools/prefabeditor/PrefabRoot';
 export { findComponent, findComponentEntry, hasComponent } from './tools/prefabeditor/types';
 // Game Events (physics + custom events)
 export { gameEvents, useGameEvent, getEntityIdFromRigidBody } from './tools/prefabeditor/GameEvents';

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 { getComponentDef } from './components/ComponentRegistry';
 import { base, colors, tree } from './styles';
 import { useEditorContext } from './PrefabEditor';
 import { Dropdown } from './Dropdown';
 import { FileMenu, TreeContextMenu, TreeNodeMenu } from './EditorTreeMenus';
+import { createEmptyNode } 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,17 +30,7 @@ export default function EditorTree({ selectedId, setSelectedId, getPrefab, onRep
         });
     };
     const handleAddChild = (parentId) => {
-        var _a;
-        const newNode = {
-            id: crypto.randomUUID(),
-            name: "New Node",
-            components: {
-                transform: {
-                    type: "Transform",
-                    properties: Object.assign({}, (_a = getComponentDef('Transform')) === null || _a === void 0 ? void 0 : _a.defaultProperties)
-                }
-            }
-        };
+        const newNode = createEmptyNode();
         addChild(parentId, newNode);
         setSelectedId(newNode.id);
     };

package/dist/tools/prefabeditor/EditorTreeMenus.js

@@ -10,28 +10,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useRef, useState } from 'react';
 import { createPortal } from 'react-dom';
+import { createEmptyPrefab } from './prefab';
 import { menu } from './styles';
 import { useEditorContext } from './PrefabEditor';
-import { getComponentDef } from './components/ComponentRegistry';
 import { loadJson, saveJson } from './utils';
-function createEmptyPrefab() {
-    var _a;
-    return {
-        id: crypto.randomUUID(),
-        name: 'New Prefab',
-        root: {
-            id: crypto.randomUUID(),
-            name: 'Root',
-            components: {
-                transform: {
-                    type: 'Transform',
-                    properties: Object.assign({}, (_a = getComponentDef('Transform')) === null || _a === void 0 ? void 0 : _a.defaultProperties)
-                }
-            },
-            children: []
-        }
-    };
-}
 function MenuPanel({ children, style, }) {
     return (_jsx("div", { style: Object.assign(Object.assign(Object.assign({}, menu.container), { position: 'static' }), style), onClick: (e) => e.stopPropagation(), children: children }));
 }

package/dist/tools/prefabeditor/EditorUI.js

@@ -14,6 +14,7 @@ import { useState } from 'react';
 import { hasComponent } from "./types";
 import EditorTree from './EditorTree';
 import { getAllComponentDefs } from './components/ComponentRegistry';
+import { createComponentData } from './prefab';
 import { base, colors, inspector, componentCard } from './styles';
 import { usePrefabStore } from './prefabStore';
 function EditorUI({ selectedId, setSelectedId, getPrefab, onReplacePrefab, onImportPrefab, basePath, onUndo, onRedo, canUndo, canRedo }) {
@@ -58,7 +59,7 @@ function NodeInspector({ node, updateNode, deleteNode, basePath }) {
                                     return;
                                 const def = ALL_COMPONENTS[addType];
                                 if (def) {
-                                    updateNode(n => (Object.assign(Object.assign({}, n), { components: Object.assign(Object.assign({}, n.components), { [addType.toLowerCase()]: { type: def.name, properties: def.defaultProperties } }) })));
+                                    updateNode(n => (Object.assign(Object.assign({}, n), { components: Object.assign(Object.assign({}, n.components), { [addType.toLowerCase()]: createComponentData(def.name) }) })));
                                 }
                             }, title: "Add Component", children: "+" })] }) }))] });
 }

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

@@ -1,9 +1,8 @@
 import GameCanvas from "../../shared/GameCanvas";
 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>;
@@ -17,7 +16,6 @@ export interface PrefabEditorRef {
     }) => void;
     addModel: (path: string, model: Object3D, options?: SpawnOptions) => GameObject;
     addTexture: (path: string, texture: Texture, options?: SpawnOptions) => GameObject;
-    viewRef: React.RefObject<PrefabRootRef | null>;
 }
 export declare enum PrefabEditorMode {
     Edit = "edit",

package/dist/tools/prefabeditor/PrefabEditor.js

@@ -16,10 +16,11 @@ import PrefabRoot from "./PrefabRoot";
 import { Physics } from "@react-three/rapier";
 import EditorUI from "./EditorUI";
 import { base, toolbar } from "./styles";
-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";
@@ -38,15 +39,7 @@ 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, mode: initialMode = PrefabEditorMode.Edit, onChange, showUI = true, enableWindowDrop = true, canvasProps, uiPlugins, children }, ref) => {
     const [mode, setMode] = useState(initialMode);
@@ -66,10 +59,10 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, mode
     const canvasRef = useRef(null);
     const controlsRef = useRef(null);
     const onChangeRef = useRef(onChange);
-    const [injectedModels, setInjectedModels] = useState({});
-    const [injectedTextures, setInjectedTextures] = useState({});
     const isEditMode = mode === PrefabEditorMode.Edit;
-    const getPrefab = useCallback(() => prefabStoreToPrefab(prefabStore.getState()), [prefabStore]);
+    const getPrefab = useCallback(() => denormalizePrefab(prefabStore.getState()), [prefabStore]);
+    const getObject = useCallback((nodeId) => { var _a, _b; return (_b = (_a = prefabRootRef.current) === null || _a === void 0 ? void 0 : _a.getObject(nodeId)) !== null && _b !== void 0 ? _b : null; }, []);
+    const getRigidBody = useCallback((nodeId) => { var _a, _b; return (_b = (_a = prefabRootRef.current) === null || _a === void 0 ? void 0 : _a.getRigidBody(nodeId)) !== null && _b !== void 0 ? _b : null; }, []);
     onChangeRef.current = onChange;
     const setSelection = useCallback((nodeId) => {
         const nextNode = nodeId ? prefabStore.getState().nodesById[nodeId] : null;
@@ -101,8 +94,6 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, mode
         setSelectedObject(null);
         if (options === null || options === void 0 ? void 0 : options.resetHistory) {
             setSelectedId(null);
-            setInjectedModels({});
-            setInjectedTextures({});
             setHistory([prefab]);
             historyIndexRef.current = 0;
             setHistoryIndex(0);
@@ -124,7 +115,7 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, mode
                 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);
@@ -168,13 +159,12 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, mode
         return () => unsubscribe();
     }, [prefabStore, selectedId]);
     useEffect(() => {
-        var _a, _b;
         if (!selectedId) {
             setSelectedObject(null);
             return;
         }
-        setSelectedObject((_b = (_a = prefabRootRef.current) === null || _a === void 0 ? void 0 : _a.getObject(selectedId)) !== null && _b !== void 0 ? _b : null);
-    }, [selectedId]);
+        setSelectedObject(getObject(selectedId));
+    }, [getObject, selectedId]);
     const addNode = useCallback((node, options) => {
         var _a;
         const { addChild, rootId } = prefabStore.getState();
@@ -188,15 +178,17 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, mode
         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) => {
@@ -265,39 +257,29 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, mode
         return exportGLBData(rootObject);
     }), [clearSelection]);
     const handleFocusNode = useCallback((nodeId) => {
-        var _a;
-        const object = (_a = prefabRootRef.current) === null || _a === void 0 ? void 0 : _a.getObject(nodeId);
+        const object = getObject(nodeId);
         const controls = controlsRef.current;
         const camera = controls === null || controls === void 0 ? void 0 : controls.object;
         if (!object || !controls || !camera)
             return;
         focusCameraOnObject(object, camera, controls.target, () => { var _a; return (_a = controls.update) === null || _a === void 0 ? void 0 : _a.call(controls); });
-    }, []);
+    }, [getObject]);
     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,
         removeNode: (id) => prefabStore.getState().deleteNode(id),
-    }), [addNode, prefabStore]);
+        getObject,
+        getRigidBody,
+    }), [addNode, getObject, getRigidBody, prefabStore]);
     const handleTransformChange = () => {
-        var _a;
         if (!selectedId)
             return;
-        const object = (_a = prefabRootRef.current) === null || _a === void 0 ? void 0 : _a.getObject(selectedId);
+        const object = getObject(selectedId);
         if (!object)
             return;
         const parentWorld = computeParentWorldMatrix(prefabStore.getState(), selectedId);
@@ -358,10 +340,9 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, mode
         scene,
         load: loadPrefab,
         addModel,
-        addTexture,
-        viewRef: prefabRootRef
+        addTexture
     }), [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: isEditMode, selectedId: selectedId, onSelect: setSelection, onSelectedObjectChange: isEditMode ? setSelectedObject : undefined, onFocusNode: isEditMode ? handleFocusNode : undefined, basePath: basePath, injectedModels: injectedModels, injectedTextures: injectedTextures }), children] }));
+    const content = (_jsxs(_Fragment, { children: [isEditMode ? _jsx("gridHelper", { args: [10, 10], position: [0, -1, 0] }) : null, _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: {
                 mode,
                 setMode: updateMode,

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

@@ -1,14 +1,49 @@
-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, LoadedSounds, LoadedTextures } from "../dragdrop";
+import { LoadedModels } from "../dragdrop";
 import { PrefabStoreApi } from "./prefabStore";
+/** Scene-wide shared services available to component Views inside a PrefabRoot. */
+export interface AssetRuntime {
+    /** @internal Used by PhysicsComponent. */
+    registerRigidBodyRef: (id: string, rb: any) => void;
+    /** 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;
+}
+export interface EntityRuntime {
+    nodeId: string;
+    editMode?: boolean;
+    isSelected?: boolean;
+    getObject: <T extends Object3D = Object3D>() => T | null;
+    getRigidBody: <T = any>() => T | null;
+}
+export interface LiveObjectRef<T extends Object3D = Object3D> {
+    readonly current: T | null;
+}
+export interface LiveRigidBodyRef<T = any> {
+    readonly current: T | null;
+}
+/** Access scene-wide shared services from within a component View. */
+export declare function useAssetRuntime(): AssetRuntime;
+/** Access the current node's runtime from within a component View. */
+export declare function useEntityRuntime(): EntityRuntime;
+/** Read the current component's Object3D through a live ref-like accessor. */
+export declare function useEntityObjectRef<T extends Object3D = Object3D>(): LiveObjectRef<T>;
+/** Read the current component's rigid body through a live ref-like accessor. */
+export declare function useEntityRigidBodyRef<T = any>(): LiveRigidBodyRef<T>;
 export interface PrefabRootRef {
     root: Group | null;
-    rigidBodyRefs: Map<string, any>;
     getObject: (nodeId: string) => Object3D | null;
     getRigidBody: (nodeId: string) => any;
-    focusNode: (nodeId: string) => void;
+    addModel: (path: string, model: Object3D) => void;
+    addTexture: (path: string, texture: Texture) => void;
+    addSound: (path: string, sound: AudioBuffer) => void;
 }
 export interface PrefabRootProps {
     editMode?: boolean;
@@ -17,12 +52,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;
-    injectedSounds?: LoadedSounds;
 }
 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;
@@ -32,11 +62,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;
-    getRigidBody: (id: string) => any;
     loadedModels: LoadedModels;
-    loadedSounds: LoadedSounds;
-    loadedTextures: LoadedTextures;
     editMode?: boolean;
     parentMatrix?: Matrix4;
 }