react-three-game 0.0.91 → 0.0.93

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

@@ -1,12 +1,13 @@
-import { Group, Matrix4, Object3D, Texture } from "three";
+import { type ForwardRefExoticComponent, type RefAttributes } from "react";
+import { Matrix4, Object3D, Texture } from "three";
 import { ThreeEvent } from "@react-three/fiber";
 import { GameObject as GameObjectType, Prefab } from "./types";
 import { LoadedModels } from "../dragdrop";
 import { PrefabStoreApi } from "./prefabStore";
 export interface PrefabRootRef {
-    root: Group | null;
-    getObject: (nodeId: string) => Object3D | null;
-    getRigidBody: (nodeId: string) => any;
+    root: Object3D | null;
+    getNodeObject: (nodeId: string) => Object3D | null;
+    getNodeHandle: <T = unknown>(nodeId: string, kind: string) => T | null;
     addModel: (path: string, model: Object3D) => void;
     addTexture: (path: string, texture: Texture) => void;
     addSound: (path: string, sound: AudioBuffer) => void;
@@ -14,23 +15,28 @@ export interface PrefabRootRef {
 export interface PrefabRootProps {
     editMode?: boolean;
     data?: Prefab;
-    store?: PrefabStoreApi;
     selectedId?: string | null;
     onSelect?: (id: string | null) => void;
-    onClick?: (event: ThreeEvent<PointerEvent>, entity: GameObjectType) => void;
-    onObjectRefChange?: (id: string, object: Object3D | null) => void;
+    onClick?: (event: ThreeEvent<PointerEvent>, node: GameObjectType) => void;
+    onEditNodeClick?: (event: ThreeEvent<PointerEvent>, node: GameObjectType) => void;
     basePath?: string;
 }
-export declare const PrefabRoot: import("react").ForwardRefExoticComponent<PrefabRootProps & import("react").RefAttributes<PrefabRootRef>>;
+interface PrefabRootInternalProps extends PrefabRootProps {
+    store?: PrefabStoreApi;
+}
+export declare const PrefabRootInternal: ForwardRefExoticComponent<PrefabRootInternalProps & RefAttributes<PrefabRootRef>>;
+export declare const PrefabRoot: ForwardRefExoticComponent<PrefabRootProps & RefAttributes<PrefabRootRef>>;
 export declare function GameObjectRenderer(props: RendererProps): import("react/jsx-runtime").JSX.Element | null;
 interface RendererProps {
     nodeId: string;
     selectedId?: string | null;
     onSelect?: (id: string) => void;
-    onClick?: (event: ThreeEvent<PointerEvent>, entity: GameObjectType) => void;
+    onClick?: (event: ThreeEvent<PointerEvent>, nodeId: string, object: Object3D | null) => void;
+    onEditNodeClick?: (event: ThreeEvent<PointerEvent>, node: GameObjectType) => void;
     registerRef: (id: string, obj: Object3D | null) => void;
     loadedModels: LoadedModels;
     editMode?: boolean;
     parentMatrix?: Matrix4;
+    isVisible?: boolean;
 }
 export default PrefabRoot;

package/dist/tools/prefabeditor/PrefabRoot.js

@@ -10,9 +10,8 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import { useHelper } from "@react-three/drei";
 import { forwardRef, useCallback, useEffect, useImperativeHandle, useMemo, useRef, useState } from "react";
-import { BoxHelper, Euler, Matrix4, } from "three";
+import { Euler, Matrix4, } from "three";
 import { useStore } from "zustand";
 import { useClickValid } from "./useClickValid";
 import { findComponent, getNodeUserData } from "./types";
@@ -21,9 +20,8 @@ import { builtinComponents } from "./components";
 import { loadModel, loadSound, loadTexture } from "../dragdrop";
 import { GameInstance, GameInstanceProvider, getRepeatAxesFromModelProperties, useInstanceCheck } from "./InstanceProvider";
 import { composeTransform, decompose } from "./utils";
-import { isPhysicsProps } from "./components/PhysicsComponent";
 import { createPrefabStore, PrefabStoreProvider, useOptionalPrefabStoreApi, usePrefabChildIds, usePrefabNode, usePrefabRootId } from "./prefabStore";
-import { AssetRuntimeContext, EntityRuntimeScope } from "./assetRuntime";
+import { AssetRuntimeContext, CurrentNodeScope } from "./assetRuntime";
 import { gameEvents } from "./GameEvents";
 import { sound as soundManager } from "../../helpers/SoundManager";
 builtinComponents.forEach(registerComponent);
@@ -37,30 +35,13 @@ function resolveAssetPath(basePath, file) {
         return file;
     return file.startsWith("/") ? `${basePath}${file}` : `${basePath}/${file}`;
 }
-/** Check if all model assets required by a node are loaded. */
-function isNodeReady(node, loadedModels) {
+/** Check if a model component's assets are loaded. */
+function isNodeReady(model, loadedModels) {
     var _a;
-    const model = findComponent(node, "Model");
     if (!((_a = model === null || model === void 0 ? void 0 : model.properties) === null || _a === void 0 ? void 0 : _a.filename))
         return true;
     return Boolean(loadedModels[model.properties.filename]);
 }
-function getNodeClickEventName(node) {
-    var _a;
-    const clickComponents = [
-        findComponent(node, 'BufferGeometry'),
-        findComponent(node, 'Geometry'),
-    ];
-    for (const component of clickComponents) {
-        if (!((_a = component === null || component === void 0 ? void 0 : component.properties) === null || _a === void 0 ? void 0 : _a.emitClickEvent))
-            continue;
-        const eventName = component.properties.clickEventName;
-        if (typeof eventName === 'string' && eventName.trim()) {
-            return eventName.trim();
-        }
-    }
-    return null;
-}
 function getNodeMetadataProps(node) {
     var _a, _b;
     const nodeName = (_b = (_a = node.name) === null || _a === void 0 ? void 0 : _a.trim()) !== null && _b !== void 0 ? _b : '';
@@ -69,7 +50,7 @@ function getNodeMetadataProps(node) {
         userData: Object.assign(Object.assign({ prefabNodeId: node.id }, (nodeName ? { prefabNodeName: nodeName } : {})), getNodeUserData(node)),
     };
 }
-export const PrefabRoot = forwardRef(({ editMode, data, store, selectedId, onSelect, onClick, onObjectRefChange, basePath = "" }, ref) => {
+export const PrefabRootInternal = forwardRef(({ editMode, data, store, selectedId, onSelect, onClick, onEditNodeClick, basePath = "" }, ref) => {
     var _a;
     const [models, setModels] = useState({});
     const [textures, setTextures] = useState({});
@@ -82,8 +63,7 @@ export const PrefabRoot = forwardRef(({ editMode, data, store, selectedId, onSel
     const failedTextures = useRef(new Set());
     const failedSounds = useRef(new Set());
     const objectRefs = useRef({});
-    const rigidBodyRefs = useRef(new Map());
-    const rootRef = useRef(null);
+    const nodeHandles = useRef(new Map());
     const parentStore = useOptionalPrefabStoreApi();
     const [ownedStore] = useState(() => {
         if (data)
@@ -95,35 +75,52 @@ export const PrefabRoot = forwardRef(({ editMode, data, store, selectedId, onSel
     const resolvedStore = (_a = store !== null && store !== void 0 ? store : parentStore) !== null && _a !== void 0 ? _a : ownedStore;
     const usesOwnedStore = resolvedStore === ownedStore;
     const shouldProvideStoreContext = !parentStore || parentStore !== resolvedStore;
+    const rootId = useStore(resolvedStore, state => state.rootId);
     const assetManifestKey = useStore(resolvedStore, state => state.assetManifestKey);
     const availableModels = useMemo(() => (Object.assign(Object.assign({}, models), injectedModels)), [models, injectedModels]);
     const availableTextures = useMemo(() => (Object.assign(Object.assign({}, textures), injectedTextures)), [textures, injectedTextures]);
     const availableSounds = useMemo(() => (Object.assign(Object.assign({}, sounds), injectedSounds)), [sounds, injectedSounds]);
-    const getObject = useCallback((id) => {
+    const getNodeObject = useCallback((id) => {
         var _a;
         return (_a = objectRefs.current[id]) !== null && _a !== void 0 ? _a : null;
     }, []);
-    const getRigidBody = useCallback((id) => {
-        var _a;
-        return (_a = rigidBodyRefs.current.get(id)) !== null && _a !== void 0 ? _a : null;
+    const getNodeHandle = useCallback((id, kind) => {
+        var _a, _b;
+        return (_b = (_a = nodeHandles.current.get(id)) === null || _a === void 0 ? void 0 : _a.get(kind)) !== null && _b !== void 0 ? _b : null;
+    }, []);
+    const registerNodeHandle = useCallback((id, kind, handle) => {
+        const current = nodeHandles.current.get(id);
+        if (handle == null) {
+            if (!current)
+                return;
+            current.delete(kind);
+            if (current.size === 0) {
+                nodeHandles.current.delete(id);
+            }
+            return;
+        }
+        if (current) {
+            current.set(kind, handle);
+            return;
+        }
+        nodeHandles.current.set(id, new Map([[kind, handle]]));
     }, []);
     useImperativeHandle(ref, () => ({
-        root: rootRef.current,
-        getObject,
-        getRigidBody: (nodeId) => { var _a; return (_a = rigidBodyRefs.current.get(nodeId)) !== null && _a !== void 0 ? _a : null; },
+        get root() {
+            var _a;
+            return (_a = objectRefs.current[rootId]) !== null && _a !== void 0 ? _a : null;
+        },
+        getNodeObject,
+        getNodeHandle,
         addModel: (path, model) => setInjectedModels(prev => (Object.assign(Object.assign({}, prev), { [path]: model }))),
         addTexture: (path, texture) => setInjectedTextures(prev => (Object.assign(Object.assign({}, prev), { [path]: texture }))),
         addSound: (path, sound) => {
             soundManager.setBuffer(path, sound);
             setInjectedSounds(prev => (Object.assign(Object.assign({}, prev), { [path]: sound })));
         },
-    }), [getObject]);
+    }), [getNodeHandle, getNodeObject, rootId]);
     const registerRef = useCallback((id, obj) => {
         objectRefs.current[id] = obj;
-        onObjectRefChange === null || onObjectRefChange === void 0 ? void 0 : onObjectRefChange(id, obj);
-    }, [onObjectRefChange]);
-    const registerRigidBodyRef = useCallback((id, rb) => {
-        rigidBodyRefs.current.set(id, rb);
     }, []);
     useEffect(() => {
         if (usesOwnedStore && data) {
@@ -188,25 +185,87 @@ export const PrefabRoot = forwardRef(({ editMode, data, store, selectedId, onSel
         syncAssets();
     }, [resolvedStore, assetManifestKey, basePath, injectedModels, injectedSounds, injectedTextures, models, sounds, textures]);
     const assetRuntime = useMemo(() => ({
-        getObject,
-        getRigidBody,
-        registerRigidBodyRef,
+        registerNodeHandle,
+        getNodeHandle,
+        getNodeObject,
         getModel: (path) => { var _a; return (_a = availableModels[path]) !== null && _a !== void 0 ? _a : null; },
         getTexture: (path) => { var _a; return (_a = availableTextures[path]) !== null && _a !== void 0 ? _a : null; },
         getSound: (path) => { var _a; return (_a = availableSounds[path]) !== null && _a !== void 0 ? _a : null; },
         getAssetRevision: () => `${Object.keys(availableTextures).sort().join('|')}::${Object.keys(availableModels).sort().join('|')}`,
-    }), [getObject, getRigidBody, registerRigidBodyRef, availableModels, availableTextures, availableSounds]);
-    const content = (_jsx("group", { ref: rootRef, children: _jsx(GameInstanceProvider, { models: availableModels, selectedId: selectedId, editMode: editMode, onSelect: editMode ? onSelect : undefined, registerRef: registerRef, children: _jsx(StoreRootNode, { selectedId: selectedId, onSelect: editMode ? onSelect : undefined, onClick: onClick, registerRef: registerRef, loadedModels: availableModels, editMode: editMode, parentMatrix: IDENTITY }) }) }));
+    }), [registerNodeHandle, getNodeHandle, getNodeObject, availableModels, availableTextures, availableSounds]);
+    const handleNodeClick = useCallback((event, nodeId, fallbackObject) => {
+        const node = resolvedStore.getState().nodesById[nodeId];
+        if (!node)
+            return;
+        const { clickEventName } = analyzeNodeComponents(node);
+        emitNodePointerEvent(clickEventName, event, nodeId, node, fallbackObject);
+        onClick === null || onClick === void 0 ? void 0 : onClick(event, node);
+    }, [onClick, resolvedStore]);
+    const content = (_jsx(GameInstanceProvider, { models: availableModels, selectedId: selectedId, editMode: editMode, onSelect: editMode ? onSelect : undefined, onClick: editMode ? undefined : handleNodeClick, registerRef: registerRef, children: _jsx(StoreRootNode, { selectedId: selectedId, onSelect: editMode ? onSelect : undefined, onClick: editMode ? undefined : handleNodeClick, onEditNodeClick: editMode ? onEditNodeClick : undefined, registerRef: registerRef, loadedModels: availableModels, editMode: editMode, parentMatrix: IDENTITY }) }));
     const runtimeContent = _jsx(AssetRuntimeContext.Provider, { value: assetRuntime, children: content });
     if (!shouldProvideStoreContext) {
         return runtimeContent;
     }
     return _jsx(PrefabStoreProvider, { store: resolvedStore, children: runtimeContent });
 });
+export const PrefabRoot = PrefabRootInternal;
 function StoreRootNode(props) {
     const rootId = usePrefabRootId();
     return _jsx(GameObjectRenderer, Object.assign({}, props, { nodeId: rootId }));
 }
+function getClickEventName(component) {
+    var _a;
+    if (!((_a = component === null || component === void 0 ? void 0 : component.properties) === null || _a === void 0 ? void 0 : _a.emitClickEvent))
+        return null;
+    const eventName = component.properties.clickEventName;
+    return typeof eventName === 'string' && eventName.trim() ? eventName.trim() : null;
+}
+function analyzeNodeComponents(node) {
+    var _a, _b, _c;
+    let bufferGeometry;
+    let geometry;
+    let material;
+    let model;
+    const composition = [];
+    for (const [key, component] of Object.entries((_a = node.components) !== null && _a !== void 0 ? _a : {})) {
+        if (!(component === null || component === void 0 ? void 0 : component.type))
+            continue;
+        switch (component.type) {
+            case "Transform":
+                break;
+            case "BufferGeometry":
+                bufferGeometry = component;
+                break;
+            case "Geometry":
+                geometry = component;
+                break;
+            case "Material":
+                material = component;
+                break;
+            case "Model":
+                model = component;
+                break;
+            default: {
+                const def = getComponentDef(component.type);
+                if (!(def === null || def === void 0 ? void 0 : def.View))
+                    break;
+                composition.push({
+                    key,
+                    View: def.View,
+                    properties: component.properties,
+                });
+                break;
+            }
+        }
+    }
+    return {
+        geometry: bufferGeometry !== null && bufferGeometry !== void 0 ? bufferGeometry : geometry,
+        material,
+        model,
+        clickEventName: (_c = (_b = getClickEventName(bufferGeometry)) !== null && _b !== void 0 ? _b : getClickEventName(geometry)) !== null && _c !== void 0 ? _c : getClickEventName(model),
+        composition,
+    };
+}
 function emitNodePointerEvent(eventName, event, nodeId, node, fallbackObject) {
     var _a;
     const trimmedEventName = eventName === null || eventName === void 0 ? void 0 : eventName.trim();
@@ -249,21 +308,19 @@ export function GameObjectRenderer(props) {
         ? _jsx(InstancedNode, Object.assign({}, props), key)
         : _jsx(StandardNode, Object.assign({}, props), key);
 }
-function InstancedNode({ nodeId, parentMatrix = IDENTITY, editMode, registerRef, onSelect, onClick }) {
+function InstancedNode({ nodeId, parentMatrix = IDENTITY, editMode, registerRef, onSelect, onEditNodeClick, onClick, isVisible = true }) {
     var _a, _b;
     const gameObject = usePrefabNode(nodeId);
     if (!gameObject)
         return null;
+    const analyzedComponents = useMemo(() => analyzeNodeComponents(gameObject), [gameObject]);
     const localTransform = getNodeTransformProps(gameObject);
     const isLocked = Boolean(gameObject.locked);
+    const nodeVisible = isVisible && !gameObject.hidden;
     const metadataProps = getNodeMetadataProps(gameObject);
-    const groupProps = Object.assign(Object.assign({}, metadataProps), { position: localTransform.position, rotation: localTransform.rotation, scale: localTransform.scale });
-    const physicsData = findComponent(gameObject, "Physics");
-    const physicsProps = isPhysicsProps(physicsData === null || physicsData === void 0 ? void 0 : physicsData.properties)
-        ? physicsData === null || physicsData === void 0 ? void 0 : physicsData.properties
-        : undefined;
-    const modelUrl = (_b = (_a = findComponent(gameObject, "Model")) === null || _a === void 0 ? void 0 : _a.properties) === null || _b === void 0 ? void 0 : _b.filename;
-    const instances = useMemo(() => buildRepeatedInstances(gameObject, parentMatrix, modelUrl, physicsProps), [gameObject, modelUrl, parentMatrix, physicsProps]);
+    const groupProps = Object.assign(Object.assign({}, metadataProps), { visible: nodeVisible, position: localTransform.position, rotation: localTransform.rotation, scale: localTransform.scale });
+    const modelUrl = (_b = (_a = analyzedComponents.model) === null || _a === void 0 ? void 0 : _a.properties) === null || _b === void 0 ? void 0 : _b.filename;
+    const instances = useMemo(() => buildRepeatedInstances(gameObject, parentMatrix, modelUrl), [gameObject, modelUrl, parentMatrix]);
     const groupRef = useRef(null);
     const handleGroupRef = useCallback((object) => {
         groupRef.current = object;
@@ -273,56 +330,44 @@ function InstancedNode({ nodeId, parentMatrix = IDENTITY, editMode, registerRef,
     }, [editMode, nodeId, registerRef]);
     const editClickHandlers = useClickValid(!!editMode && !isLocked, (event) => {
         onSelect === null || onSelect === void 0 ? void 0 : onSelect(nodeId);
-        onClick === null || onClick === void 0 ? void 0 : onClick(event, gameObject);
+        onEditNodeClick === null || onEditNodeClick === void 0 ? void 0 : onEditNodeClick(event, gameObject);
     });
-    const renderedInstances = instances.map(instance => (_jsx(GameInstance, { id: instance.id, sourceId: gameObject.id, modelUrl: instance.modelUrl, position: instance.position, rotation: instance.rotation, scale: instance.scale, locked: isLocked, physics: instance.physics }, instance.id)));
+    const renderedInstances = instances.map(instance => (_jsx(GameInstance, { id: instance.id, sourceId: gameObject.id, modelUrl: instance.modelUrl, position: instance.position, rotation: instance.rotation, scale: instance.scale, visible: nodeVisible, locked: isLocked, onClick: onClick }, instance.id)));
     if (editMode) {
         return (_jsxs(_Fragment, { children: [_jsx("group", Object.assign({ ref: handleGroupRef }, groupProps, editClickHandlers, { children: _jsx("mesh", { visible: false, children: _jsx("boxGeometry", { args: [0.01, 0.01, 0.01] }) }) })), renderedInstances] }));
     }
     return _jsx(_Fragment, { children: renderedInstances });
 }
-function StandardNode({ nodeId, selectedId, onSelect, onClick, registerRef, loadedModels, editMode, parentMatrix = IDENTITY, }) {
-    var _a, _b;
+function StandardNode({ nodeId, selectedId, onSelect, onClick, onEditNodeClick, registerRef, loadedModels, editMode, parentMatrix = IDENTITY, isVisible = true, }) {
     const gameObject = usePrefabNode(nodeId);
     const childIds = usePrefabChildIds(nodeId);
     if (!gameObject)
         return null;
+    const analyzedComponents = useMemo(() => analyzeNodeComponents(gameObject), [gameObject]);
     const isSelected = selectedId === nodeId;
     const isLocked = Boolean(gameObject.locked);
+    const nodeVisible = isVisible && !gameObject.hidden;
     const stillInstanced = useInstanceCheck(nodeId);
-    const clickEventName = getNodeClickEventName(gameObject);
     const metadataProps = getNodeMetadataProps(gameObject);
     const groupRef = useRef(null);
-    const helperRef = useRef(null);
     const handleGroupRef = useCallback((object) => {
         groupRef.current = object;
         registerRef(nodeId, object);
     }, [nodeId, registerRef]);
-    const handleHelperRef = useCallback((object) => {
-        helperRef.current = object;
-    }, []);
-    const handleEditGroupRef = useCallback((object) => {
-        handleGroupRef(object);
-        handleHelperRef(object);
-    }, [handleGroupRef, handleHelperRef]);
     const editClickHandlers = useClickValid(!!editMode && !isLocked, (event) => {
         onSelect === null || onSelect === void 0 ? void 0 : onSelect(nodeId);
-        onClick === null || onClick === void 0 ? void 0 : onClick(event, gameObject);
+        onEditNodeClick === null || onEditNodeClick === void 0 ? void 0 : onEditNodeClick(event, gameObject);
     });
-    const primaryClickHandlers = !editMode && (clickEventName || onClick)
+    const primaryClickHandlers = !editMode && onClick
         ? {
             onClick: (event) => {
                 event.stopPropagation();
-                emitNodePointerEvent(clickEventName, event, nodeId, gameObject, groupRef.current);
-                onClick === null || onClick === void 0 ? void 0 : onClick(event, gameObject);
+                onClick(event, nodeId, groupRef.current);
             },
         }
         : undefined;
-    useHelper(editMode && isSelected ? helperRef : null, BoxHelper, "cyan");
     const world = parentMatrix.clone().multiply(compose(gameObject));
-    const physics = findComponent(gameObject, "Physics");
-    const ready = isNodeReady(gameObject, loadedModels);
-    const hasPhysics = physics && ready && !stillInstanced;
+    const ready = isNodeReady(analyzedComponents.model, loadedModels);
     const transform = getNodeTransformProps(gameObject);
     const transformProps = {
         position: transform.position,
@@ -330,40 +375,11 @@ function StandardNode({ nodeId, selectedId, onSelect, onClick, registerRef, load
         scale: transform.scale,
     };
     const groupProps = Object.assign(Object.assign({}, metadataProps), transformProps);
-    const physicsDef = hasPhysics ? getComponentDef(physics.type) : null;
-    const isInstanced = (_b = (_a = findComponent(gameObject, "Model")) === null || _a === void 0 ? void 0 : _a.properties) === null || _b === void 0 ? void 0 : _b.instanced;
-    const physicsKey = `physics_${nodeId}_${isInstanced ? 'instanced' : 'standard'}`;
-    const renderCtx = { loadedModels, editMode, registerRef };
-    const childNodes = _jsx(ChildNodes, { childIds: childIds, parentMatrix: world, selectedId: selectedId, onSelect: onSelect, onClick: onClick, registerRef: registerRef, loadedModels: loadedModels, editMode: editMode });
-    const inner = renderCompositionNode(gameObject, renderCtx, primaryClickHandlers, childNodes);
+    const childNodes = _jsx(ChildNodes, { childIds: childIds, parentMatrix: world, selectedId: selectedId, onSelect: onSelect, onClick: onClick, onEditNodeClick: onEditNodeClick, registerRef: registerRef, loadedModels: loadedModels, editMode: editMode, isVisible: nodeVisible });
+    const inner = renderNodeContent(analyzedComponents, loadedModels, primaryClickHandlers, childNodes);
     const editAnchor = editMode ? (_jsx("mesh", { visible: false, children: _jsx("boxGeometry", { args: [0.01, 0.01, 0.01] }) })) : null;
-    const standardNode = (_jsxs("group", Object.assign({ ref: editMode ? handleEditGroupRef : handleGroupRef }, groupProps, (editMode ? editClickHandlers : undefined), { children: [editAnchor, inner] })));
-    const physicsNode = hasPhysics && (physicsDef === null || physicsDef === void 0 ? void 0 : physicsDef.View) ? (_jsx(physicsDef.View, Object.assign({ properties: physics.properties }, transformProps, { children: _jsxs("group", Object.assign({ ref: editMode ? handleEditGroupRef : handleGroupRef }, metadataProps, (editMode ? editClickHandlers : undefined), { children: [editAnchor, inner] })) }), physicsKey)) : null;
-    return (_jsx(EntityRuntimeScope, { nodeId: nodeId, editMode: editMode, isSelected: isSelected, children: physicsNode !== null && physicsNode !== void 0 ? physicsNode : standardNode }));
-}
-function isRendererHandledComponent(componentType) {
-    return componentType === "Transform"
-        || componentType === "BufferGeometry"
-        || componentType === "Geometry"
-        || componentType === "Material"
-        || componentType === "Physics"
-        || componentType === "Model";
-}
-function getCompositionComponents(gameObject) {
-    var _a;
-    return Object.entries((_a = gameObject.components) !== null && _a !== void 0 ? _a : {}).reduce((result, [key, comp]) => {
-        if (!(comp === null || comp === void 0 ? void 0 : comp.type) || isRendererHandledComponent(comp.type))
-            return result;
-        const def = getComponentDef(comp.type);
-        if (!(def === null || def === void 0 ? void 0 : def.View))
-            return result;
-        result.push({
-            key,
-            View: def.View,
-            properties: comp.properties,
-        });
-        return result;
-    }, []);
+    const standardNode = (_jsxs("group", Object.assign({ ref: handleGroupRef }, groupProps, { visible: nodeVisible }, (editMode ? editClickHandlers : undefined), { children: [editAnchor, inner] })));
+    return (_jsx(CurrentNodeScope, { nodeId: nodeId, editMode: editMode, isSelected: isSelected, children: standardNode }));
 }
 function ChildNodes(_a) {
     var { childIds, parentMatrix } = _a, props = __rest(_a, ["childIds", "parentMatrix"]);
@@ -381,7 +397,7 @@ function getModelRepeatSettings(node) {
         repeatAxes: getRepeatAxesFromModelProperties(properties),
     };
 }
-function buildRepeatedInstances(gameObject, parentMatrix, modelUrl, physics) {
+function buildRepeatedInstances(gameObject, parentMatrix, modelUrl) {
     if (!modelUrl)
         return [];
     const transform = getNodeTransformProps(gameObject);
@@ -418,7 +434,6 @@ function buildRepeatedInstances(gameObject, parentMatrix, modelUrl, physics) {
                     position,
                     rotation,
                     scale,
-                    physics,
                 });
             }
         }
@@ -434,32 +449,30 @@ function getNodeTransformProps(node) {
         scale: (_d = t === null || t === void 0 ? void 0 : t.scale) !== null && _d !== void 0 ? _d : [1, 1, 1],
     };
 }
-function renderCompositionNode(gameObject, ctx, primaryClickHandlers, childNodes) {
-    const primaryContent = renderNodePrimaryContent(gameObject, ctx, primaryClickHandlers);
-    return applyNodeComposition(gameObject, _jsxs(_Fragment, { children: [primaryContent, childNodes] }));
-}
-function renderNodePrimaryContent(gameObject, ctx, primaryClickHandlers) {
-    var _a, _b, _c;
-    const geometry = (_a = findComponent(gameObject, "BufferGeometry")) !== null && _a !== void 0 ? _a : findComponent(gameObject, "Geometry");
-    const material = findComponent(gameObject, "Material");
-    const model = findComponent(gameObject, "Model");
-    const geometryDef = geometry && getComponentDef(geometry.type);
-    const materialDef = material && getComponentDef(material.type);
-    const modelDef = model && getComponentDef(model.type);
-    const geometryProperties = (_b = geometry === null || geometry === void 0 ? void 0 : geometry.properties) !== null && _b !== void 0 ? _b : {};
+function renderNodeContent(analyzedComponents, loadedModels, primaryClickHandlers, childNodes) {
+    var _a, _b, _c, _d;
+    const geometry = analyzedComponents.geometry;
+    const geometryDef = analyzedComponents.geometry && getComponentDef(analyzedComponents.geometry.type);
+    const materialDef = analyzedComponents.material && getComponentDef(analyzedComponents.material.type);
+    const modelDef = analyzedComponents.model && getComponentDef(analyzedComponents.model.type);
+    const geometryProperties = (_a = geometry === null || geometry === void 0 ? void 0 : geometry.properties) !== null && _a !== void 0 ? _a : {};
     const meshVisible = geometryProperties.visible !== false;
     const meshCastShadow = meshVisible && geometryProperties.castShadow !== false;
     const meshReceiveShadow = meshVisible && geometryProperties.receiveShadow !== false;
-    if ((geometry === null || geometry === void 0 ? void 0 : geometry.type) && (geometryDef === null || geometryDef === void 0 ? void 0 : geometryDef.View)) {
-        return (_jsxs("mesh", Object.assign({ visible: meshVisible, castShadow: meshCastShadow, receiveShadow: meshReceiveShadow }, primaryClickHandlers, { children: [_jsx(geometryDef.View, { properties: geometry.properties }), material && (materialDef === null || materialDef === void 0 ? void 0 : materialDef.View) && (_jsx(materialDef.View, { properties: material.properties }, "material"))] })));
+    let primaryContent = null;
+    if (((_b = analyzedComponents.geometry) === null || _b === void 0 ? void 0 : _b.type) && (geometryDef === null || geometryDef === void 0 ? void 0 : geometryDef.View)) {
+        primaryContent = (_jsxs("mesh", Object.assign({ visible: meshVisible, castShadow: meshCastShadow, receiveShadow: meshReceiveShadow }, primaryClickHandlers, { children: [_jsx(geometryDef.View, { properties: analyzedComponents.geometry.properties }), analyzedComponents.material && (materialDef === null || materialDef === void 0 ? void 0 : materialDef.View) && (_jsx(materialDef.View, { properties: analyzedComponents.material.properties }, "material"))] })));
     }
-    if ((model === null || model === void 0 ? void 0 : model.type) && (modelDef === null || modelDef === void 0 ? void 0 : modelDef.View) && !((_c = model.properties) === null || _c === void 0 ? void 0 : _c.instanced) && isNodeReady(gameObject, ctx.loadedModels)) {
-        return _jsx(modelDef.View, { properties: model.properties });
+    else if (((_c = analyzedComponents.model) === null || _c === void 0 ? void 0 : _c.type)
+        && (modelDef === null || modelDef === void 0 ? void 0 : modelDef.View)
+        && !((_d = analyzedComponents.model.properties) === null || _d === void 0 ? void 0 : _d.instanced)
+        && isNodeReady(analyzedComponents.model, loadedModels)) {
+        primaryContent = primaryClickHandlers ? (_jsx("group", Object.assign({}, primaryClickHandlers, { children: _jsx(modelDef.View, { properties: analyzedComponents.model.properties }) }))) : (_jsx(modelDef.View, { properties: analyzedComponents.model.properties }));
     }
-    return null;
-}
-function applyNodeComposition(gameObject, subtree) {
-    const components = getCompositionComponents(gameObject);
-    return components.reduce((acc, { key, View, properties }) => (_jsx(View, { properties: properties, children: acc }, key)), subtree);
+    let content = _jsxs(_Fragment, { children: [primaryContent, childNodes] });
+    for (const { key, View, properties } of analyzedComponents.composition) {
+        content = (_jsx(View, { properties: properties, children: content }, key));
+    }
+    return content;
 }
 export default PrefabRoot;

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

@@ -1,34 +1,36 @@
 import { type ReactNode } from "react";
 import type { Object3D, Texture } from "three";
 export interface AssetRuntime {
-    registerRigidBodyRef: (id: string, rb: any) => void;
+    registerNodeHandle: (id: string, kind: string, handle: unknown) => void;
+    getNodeHandle: <T = unknown>(id: string, kind: string) => T | null;
     getModel: (path: string) => Object3D | null;
     getTexture: (path: string) => Texture | null;
     getSound: (path: string) => AudioBuffer | null;
     getAssetRevision: () => string;
-    getObject: (id: string) => Object3D | null;
-    getRigidBody: (id: string) => any;
+    getNodeObject: (id: string) => Object3D | null;
 }
 export interface AssetRuntimeContextValue extends AssetRuntime {
 }
-export interface EntityRuntime {
+export interface CurrentNodeRuntime {
     nodeId: string;
     editMode?: boolean;
     isSelected?: boolean;
-    getObject: <T extends Object3D = Object3D>() => T | null;
-    getRigidBody: <T = any>() => T | null;
+    getCurrentNodeObject: <T extends Object3D = Object3D>() => T | null;
+    getCurrentNodeHandle: <T = unknown>(kind: string) => T | null;
 }
 export interface LiveRef<T> {
     readonly current: T | null;
 }
 export type LiveObjectRef<T extends Object3D = Object3D> = LiveRef<T>;
-export type LiveRigidBodyRef<T = any> = LiveRef<T>;
+export type LiveHandleRef<T = unknown> = LiveRef<T>;
+export type CurrentNodeObjectRef<T extends Object3D = Object3D> = LiveObjectRef<T>;
+export type CurrentNodeHandleRef<T = unknown> = LiveHandleRef<T>;
 export declare const AssetRuntimeContext: import("react").Context<AssetRuntimeContextValue | null>;
 export declare function useAssetRuntime(): AssetRuntime;
-export declare function useEntityRuntime(): EntityRuntime;
-export declare function useEntityObjectRef<T extends Object3D = Object3D>(): LiveRef<T>;
-export declare function useEntityRigidBodyRef<T = any>(): LiveRef<T>;
-export declare function EntityRuntimeScope({ nodeId, editMode, isSelected, children, }: {
+export declare function useCurrentNode(): CurrentNodeRuntime;
+export declare function useCurrentNodeObject<T extends Object3D = Object3D>(): LiveRef<T>;
+export declare function useCurrentNodeHandle<T = unknown>(kind: string): LiveRef<T>;
+export declare function CurrentNodeScope({ nodeId, editMode, isSelected, children, }: {
     nodeId: string;
     editMode?: boolean;
     isSelected?: boolean;

package/dist/tools/prefabeditor/assetRuntime.js

@@ -1,37 +1,37 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { createContext, useContext, useMemo } from "react";
 export const AssetRuntimeContext = createContext(null);
-const EntityRuntimeContext = createContext(null);
+const CurrentNodeRuntimeContext = createContext(null);
 export function useAssetRuntime() {
     const ctx = useContext(AssetRuntimeContext);
     if (!ctx)
         throw new Error("useAssetRuntime must be used inside <PrefabRoot>");
     return ctx;
 }
-export function useEntityRuntime() {
-    const ctx = useContext(EntityRuntimeContext);
+export function useCurrentNode() {
+    const ctx = useContext(CurrentNodeRuntimeContext);
     if (!ctx)
-        throw new Error("useEntityRuntime must be used inside a component View rendered by <PrefabRoot>");
+        throw new Error("useCurrentNode must be used inside a component View rendered by <PrefabRoot>");
     return ctx;
 }
-export function useEntityObjectRef() {
-    const { getObject } = useEntityRuntime();
-    return useMemo(() => ({ get current() { return getObject(); } }), [getObject]);
+export function useCurrentNodeObject() {
+    const { getCurrentNodeObject } = useCurrentNode();
+    return useMemo(() => ({ get current() { return getCurrentNodeObject(); } }), [getCurrentNodeObject]);
 }
-export function useEntityRigidBodyRef() {
-    const { getRigidBody } = useEntityRuntime();
-    return useMemo(() => ({ get current() { return getRigidBody(); } }), [getRigidBody]);
+export function useCurrentNodeHandle(kind) {
+    const { getCurrentNodeHandle } = useCurrentNode();
+    return useMemo(() => ({ get current() { return getCurrentNodeHandle(kind); } }), [getCurrentNodeHandle, kind]);
 }
-export function EntityRuntimeScope({ nodeId, editMode, isSelected, children, }) {
+export function CurrentNodeScope({ nodeId, editMode, isSelected, children, }) {
     const asset = useContext(AssetRuntimeContext);
     if (!asset)
-        throw new Error("EntityRuntimeScope must be used inside <PrefabRoot>");
+        throw new Error("CurrentNodeScope must be used inside <PrefabRoot>");
     const value = useMemo(() => ({
         nodeId,
         editMode,
         isSelected,
-        getObject: () => asset.getObject(nodeId),
-        getRigidBody: () => asset.getRigidBody(nodeId),
+        getCurrentNodeObject: () => asset.getNodeObject(nodeId),
+        getCurrentNodeHandle: (kind) => asset.getNodeHandle(nodeId, kind),
     }), [asset, editMode, isSelected, nodeId]);
-    return _jsx(EntityRuntimeContext.Provider, { value: value, children: children });
+    return _jsx(CurrentNodeRuntimeContext.Provider, { value: value, children: children });
 }

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

@@ -52,7 +52,7 @@ function BufferArrayField({ label, value, fallback, onChange, rows = 4, }) {
 function BufferGeometryComponentEditor({ component, onUpdate, }) {
     var _a;
     const properties = (_a = component.properties) !== null && _a !== void 0 ? _a : {};
-    return (_jsxs(FieldGroup, { children: [_jsx(BufferArrayField, { label: "Positions", value: properties.positions, fallback: DEFAULT_TRIANGLE_POSITIONS, rows: 5, onChange: (positions) => onUpdate({ positions }) }), _jsx(BufferArrayField, { label: "Indices", value: properties.indices, fallback: DEFAULT_TRIANGLE_INDICES, onChange: (indices) => onUpdate({ indices }) }), _jsx(BufferArrayField, { label: "Normals", value: properties.normals, fallback: [], onChange: (normals) => onUpdate({ normals }) }), _jsx(BufferArrayField, { label: "UVs", value: properties.uvs, fallback: DEFAULT_TRIANGLE_UVS, onChange: (uvs) => onUpdate({ uvs }) }), _jsx(BooleanField, { name: "computeVertexNormals", label: "Compute Normals", values: properties, onChange: onUpdate, fallback: true }), _jsx(BooleanField, { name: "visible", label: "Visible", values: properties, onChange: onUpdate, fallback: true }), _jsx(BooleanField, { name: "castShadow", label: "Cast Shadow", values: properties, onChange: onUpdate, fallback: true }), _jsx(BooleanField, { name: "receiveShadow", label: "Receive Shadow", values: properties, onChange: onUpdate, fallback: true }), _jsx(BooleanField, { name: "emitClickEvent", label: "Emit Click Event", values: properties, onChange: onUpdate, fallback: false }), properties.emitClickEvent ? (_jsx(StringField, { name: "clickEventName", label: "Click Event Name", values: properties, onChange: onUpdate, placeholder: "entity:click" })) : null] }));
+    return (_jsxs(FieldGroup, { children: [_jsx(BufferArrayField, { label: "Positions", value: properties.positions, fallback: DEFAULT_TRIANGLE_POSITIONS, rows: 5, onChange: (positions) => onUpdate({ positions }) }), _jsx(BufferArrayField, { label: "Indices", value: properties.indices, fallback: DEFAULT_TRIANGLE_INDICES, onChange: (indices) => onUpdate({ indices }) }), _jsx(BufferArrayField, { label: "Normals", value: properties.normals, fallback: [], onChange: (normals) => onUpdate({ normals }) }), _jsx(BufferArrayField, { label: "UVs", value: properties.uvs, fallback: DEFAULT_TRIANGLE_UVS, onChange: (uvs) => onUpdate({ uvs }) }), _jsx(BooleanField, { name: "computeVertexNormals", label: "Compute Normals", values: properties, onChange: onUpdate, fallback: true }), _jsx(BooleanField, { name: "visible", label: "Visible", values: properties, onChange: onUpdate, fallback: true }), _jsx(BooleanField, { name: "castShadow", label: "Cast Shadow", values: properties, onChange: onUpdate, fallback: true }), _jsx(BooleanField, { name: "receiveShadow", label: "Receive Shadow", values: properties, onChange: onUpdate, fallback: true }), _jsx(BooleanField, { name: "emitClickEvent", label: "Emit Click Event", values: properties, onChange: onUpdate, fallback: false }), properties.emitClickEvent ? (_jsx(StringField, { name: "clickEventName", label: "Click Event Name", values: properties, onChange: onUpdate, placeholder: "node:click" })) : null] }));
 }
 function BufferGeometryComponentView({ properties }) {
     const positions = normalizeNumberArray(properties.positions, DEFAULT_TRIANGLE_POSITIONS);

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

@@ -3,7 +3,7 @@ import { OrthographicCamera, PerspectiveCamera, useHelper } from '@react-three/d
 import { useRef } from 'react';
 import { CameraHelper } from 'three';
 import { useFrame, useThree } from '@react-three/fiber';
-import { useEntityRuntime } from '../assetRuntime';
+import { useCurrentNode } from '../assetRuntime';
 import { FieldGroup, NumberField, SelectField } from './Input';
 const CAMERA_PROJECTION_OPTIONS = [
     { value: 'perspective', label: 'Perspective' },
@@ -25,7 +25,7 @@ function CameraComponentEditor({ component, onUpdate }) {
 }
 function CameraComponentView({ properties, children }) {
     var _a;
-    const { editMode, isSelected } = useEntityRuntime();
+    const { editMode, isSelected } = useCurrentNode();
     const { size } = useThree();
     const merged = Object.assign(Object.assign({}, cameraDefaults), properties);
     const projection = (_a = merged.projection) !== null && _a !== void 0 ? _a : cameraDefaults.projection;