react-three-game 0.0.85 → 0.0.87

package/dist/tools/prefabeditor/InstanceProvider.js

@@ -15,8 +15,7 @@ import { Merged, useHelper } from '@react-three/drei';
 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";
+import { usePointerEvents } from "./usePointerEvents";
 export const DEFAULT_REPEAT_AXES = [{ axis: 'x', count: 1, offset: 1 }];
 export function normalizeRepeatAxes(value) {
     if (!Array.isArray(value)) {
@@ -103,32 +102,9 @@ function hasPhysics(instance) {
 function getColliderType(physics) {
     return physics.colliders || (physics.type === 'fixed' ? 'trimesh' : 'hull');
 }
-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, eventName, event) {
-    gameEvents.emit(eventName, {
-        sourceEntityId: sourceId,
-        instanceEntityId: instanceId && instanceId !== sourceId ? instanceId : undefined,
-        point: [event.point.x, event.point.y, event.point.z],
-        button: event.button,
-        altKey: event.nativeEvent.altKey,
-        ctrlKey: event.nativeEvent.ctrlKey,
-        metaKey: event.nativeEvent.metaKey,
-        shiftKey: event.nativeEvent.shiftKey,
-    });
-}
 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) &&
@@ -245,7 +221,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) => 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) });
+        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 }) });
     }), [group.instances]);
     // Apply scale to visual meshes (InstancedRigidBodies only scales colliders, not visuals)
     useEffect(() => {
@@ -317,12 +293,8 @@ function InstancedRigidGroup({ group, modelKey, partCount, flatMeshes, onSelect,
             onSelect(instance.sourceId);
             return;
         }
-        if (!instance.clickable)
-            return;
-        e.stopPropagation();
-        emitClick(instance.sourceId, instance.id, instance.clickEventName || 'click', e);
     };
-    const shouldHandleClick = editMode || group.instances.some(inst => inst.clickable);
+    const shouldHandleClick = editMode;
     // Add key to force remount when instance count changes significantly (helps with cleanup)
     const rigidBodyKey = `rb_${modelKey}_${group.instances.map(inst => `${inst.id}:${getPhysicsSignature(inst.physics)}`).join('|')}`;
     return (_jsx(InstancedRigidBodies, { ref: rigidBodiesRef, instances: instances, children: Array.from({ length: partCount }).map((_, i) => {
@@ -344,14 +316,15 @@ function InstanceGroupItem({ instance, InstanceComponents, onSelect, registerRef
     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);
-        }
+    const canClick = false;
+    const pointerHandlers = usePointerEvents({
+        enabled: canSelect || canClick,
+        entity: instance,
+        onClick: () => {
+            if (editMode) {
+                onSelect === null || onSelect === void 0 ? void 0 : onSelect(instance.sourceId);
+            }
+        },
     });
     // Use BoxHelper when object is selected in edit mode
     useHelper(editMode && isSelected ? groupRef : null, BoxHelper, 'cyan');
@@ -370,7 +343,7 @@ 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, clickEventName, modelUrl, locked = false, position, rotation, scale, physics = undefined, }, ref) => {
+export const GameInstance = React.forwardRef(({ id, sourceId, 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;
@@ -381,8 +354,6 @@ export const GameInstance = React.forwardRef(({ id, sourceId, clickable = false,
     const instance = useMemo(() => ({
         id,
         sourceId: sourceId !== null && sourceId !== void 0 ? sourceId : id,
-        clickable,
-        clickEventName,
         locked,
         meshPath: modelUrl,
         position,
@@ -392,8 +363,6 @@ export const GameInstance = React.forwardRef(({ id, sourceId, clickable = false,
     }), [
         id,
         sourceId,
-        clickable,
-        clickEventName,
         locked,
         modelUrl,
         positionX,

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

@@ -2,18 +2,23 @@ import GameCanvas from "../../shared/GameCanvas";
 import { Object3D, Texture } from "three";
 import { GameObject, Prefab } from "./types";
 import type { ExportGLBOptions } from "./utils";
-import { type Scene, type SpawnOptions } from "./scene";
+import { type PrefabStoreApi } from "./prefabStore";
+import type { SpawnOptions } from "./scene";
 export interface PrefabEditorRef {
+    root: Object3D | null;
+    store: PrefabStoreApi;
+    getObject: (nodeId: string) => Object3D | null;
+    getRigidBody: (nodeId: string) => any;
     screenshot: () => void;
     exportGLB: (options?: ExportGLBOptions) => Promise<ArrayBuffer | undefined>;
     exportGLBData: () => Promise<ArrayBuffer | undefined>;
     clearSelection: () => Promise<void>;
     save: () => Prefab;
-    scene: Scene;
     load: (prefab: Prefab, options?: {
         resetHistory?: boolean;
         notifyChange?: boolean;
     }) => void;
+    addNode: (node: GameObject, options?: SpawnOptions) => GameObject;
     addModel: (path: string, model: Object3D, options?: SpawnOptions) => GameObject;
     addTexture: (path: string, texture: Texture, options?: SpawnOptions) => GameObject;
 }

package/dist/tools/prefabeditor/PrefabEditor.js

@@ -10,7 +10,7 @@ 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, useReducer, useRef, useState, forwardRef, useImperativeHandle, createContext, useContext } from "react";
+import { useCallback, useEffect, useReducer, useRef, useState, forwardRef, useImperativeHandle, createContext, useContext } from "react";
 import { findComponentEntry } from "./types";
 import PrefabRoot from "./PrefabRoot";
 import { Physics } from "@react-three/rapier";
@@ -20,7 +20,6 @@ import { computeParentWorldMatrix, decompose, exportGLB as exportGLBFile, export
 import { loadFiles } from "../dragdrop";
 import { denormalizePrefab, createImageNode, createModelNode, createNode } from './prefab';
 import { createPrefabStore, PrefabStoreProvider } from "./prefabStore";
-import { createScene } from "./scene";
 function isObjectAttachedToRoot(root, object) {
     if (!root || !object)
         return false;
@@ -53,7 +52,6 @@ const DEFAULT_PREFAB = {
     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) => {
-    var _a, _b;
     const [mode, setMode] = useState(initialMode);
     const [selectedId, setSelectedId] = useState(null);
     const [transformMode, setTransformMode] = useState("translate");
@@ -73,6 +71,7 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, mode
     const onChangeRef = useRef(onChange);
     const isEditMode = mode === PrefabEditorMode.Edit;
     const getPrefab = useCallback(() => denormalizePrefab(prefabStore.getState()), [prefabStore]);
+    const getRootObject = useCallback(() => { var _a, _b; return (_b = (_a = prefabRootRef.current) === null || _a === void 0 ? void 0 : _a.root) !== null && _b !== void 0 ? _b : null; }, []);
     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; }, []);
     const handleObjectRefChange = useCallback((nodeId) => {
@@ -173,7 +172,7 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, mode
         return () => unsubscribe();
     }, [prefabStore, selectedId]);
     const selectedObject = selectedId ? getObject(selectedId) : null;
-    const transformObject = isObjectAttachedToRoot((_b = (_a = prefabRootRef.current) === null || _a === void 0 ? void 0 : _a.root) !== null && _b !== void 0 ? _b : null, selectedObject)
+    const transformObject = isObjectAttachedToRoot(getRootObject(), selectedObject)
         ? selectedObject
         : null;
     const addNode = useCallback((node, options) => {
@@ -251,21 +250,19 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, mode
         });
     }), [setSelection]);
     const handleExportGLB = useCallback((...args_1) => __awaiter(void 0, [...args_1], void 0, function* (options = {}) {
-        var _a;
         yield clearSelection();
-        const rootObject = (_a = prefabRootRef.current) === null || _a === void 0 ? void 0 : _a.root;
+        const rootObject = getRootObject();
         if (!rootObject)
             return;
         return exportGLBFile(rootObject, Object.assign({ filename: `${prefabStore.getState().prefabName || 'prefab'}.glb` }, options));
-    }), [clearSelection, prefabStore]);
+    }), [clearSelection, getRootObject, prefabStore]);
     const handleExportGLBData = useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
-        var _a;
         yield clearSelection();
-        const rootObject = (_a = prefabRootRef.current) === null || _a === void 0 ? void 0 : _a.root;
+        const rootObject = getRootObject();
         if (!rootObject)
             return;
         return exportGLBData(rootObject);
-    }), [clearSelection]);
+    }), [clearSelection, getRootObject]);
     const handleFocusNode = useCallback((nodeId) => {
         const object = getObject(nodeId);
         const controls = controlsRef.current;
@@ -274,18 +271,6 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, mode
             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; },
-        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),
-        getObject,
-        getRigidBody,
-    }), [addNode, getObject, getRigidBody, prefabStore]);
     const handleTransformChange = () => {
         if (!selectedId)
             return;
@@ -342,16 +327,20 @@ const PrefabEditor = forwardRef(({ basePath, initialPrefab, physics = true, mode
         };
     }, [addModel, addTexture, isEditMode, enableWindowDrop]);
     useImperativeHandle(ref, () => ({
+        root: getRootObject(),
+        store: prefabStore,
+        getObject,
+        getRigidBody,
         screenshot: handleScreenshot,
         exportGLB: handleExportGLB,
         exportGLBData: handleExportGLBData,
         clearSelection,
         save: getPrefab,
-        scene,
         load: loadPrefab,
+        addNode,
         addModel,
         addTexture
-    }), [addModel, addTexture, clearSelection, getPrefab, handleExportGLB, handleExportGLBData, handleScreenshot, loadPrefab, scene]);
+    }), [addModel, addNode, addTexture, clearSelection, getObject, getPrefab, getRigidBody, getRootObject, handleExportGLB, handleExportGLBData, handleScreenshot, loadPrefab, prefabStore]);
     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, onObjectRefChange: handleObjectRefChange, basePath: basePath }), children] }));
     const handleCanvasCreated = useCallback((state) => {
         var _a;

package/dist/tools/prefabeditor/PrefabRoot.js

@@ -13,10 +13,9 @@ import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-run
 import { useHelper } from "@react-three/drei";
 import { forwardRef, useCallback, useEffect, useImperativeHandle, useMemo, useRef, useState } from "react";
 import { BoxHelper, Euler, Matrix4, } from "three";
-import { useFrame } from "@react-three/fiber";
 import { useStore } from "zustand";
 import { useClickValid } from "./useClickValid";
-import { findComponent } from "./types";
+import { findComponent, getNodeUserData } from "./types";
 import { getComponentDef, getComponentAssetRefs, registerComponent } from "./components/ComponentRegistry";
 import { builtinComponents } from "./components";
 import { loadModel, loadSound, loadTexture } from "../dragdrop";
@@ -24,7 +23,8 @@ import { GameInstance, GameInstanceProvider, getRepeatAxesFromModelProperties, u
 import { composeTransform, decompose } from "./utils";
 import { isPhysicsProps } from "./components/PhysicsComponent";
 import { createPrefabStore, PrefabStoreProvider, useOptionalPrefabStoreApi, usePrefabChildIds, usePrefabNode, usePrefabRootId } from "./prefabStore";
-import { AssetRuntimeContext, EntityRuntimeScope, createRuntimeEngine } from "./runtime";
+import { AssetRuntimeContext, EntityRuntimeScope } from "./assetRuntime";
+import { gameEvents } from "./GameEvents";
 import { sound as soundManager } from "../../helpers/SoundManager";
 builtinComponents.forEach(registerComponent);
 const IDENTITY = new Matrix4();
@@ -45,6 +45,30 @@ function isNodeReady(node, loadedModels) {
         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 : '';
+    return {
+        name: nodeName,
+        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) => {
     var _a;
     const [models, setModels] = useState({});
@@ -94,29 +118,13 @@ export const PrefabRoot = forwardRef(({ editMode, data, store, selectedId, onSel
             setInjectedSounds(prev => (Object.assign(Object.assign({}, prev), { [path]: sound })));
         },
     }), [getObject]);
-    const runtimeEngine = useMemo(() => createRuntimeEngine({
-        store: resolvedStore,
-        getObject,
-        getRigidBody,
-    }), [resolvedStore, getObject, getRigidBody]);
     const registerRef = useCallback((id, obj) => {
         objectRefs.current[id] = obj;
-        runtimeEngine.invalidate();
         onObjectRefChange === null || onObjectRefChange === void 0 ? void 0 : onObjectRefChange(id, obj);
-    }, [onObjectRefChange, runtimeEngine]);
+    }, [onObjectRefChange]);
     const registerRigidBodyRef = useCallback((id, rb) => {
         rigidBodyRefs.current.set(id, rb);
-        runtimeEngine.invalidate();
-    }, [runtimeEngine]);
-    useEffect(() => {
-        runtimeEngine.setActive(!editMode);
-    }, [editMode, runtimeEngine]);
-    useEffect(() => {
-        return () => runtimeEngine.dispose();
-    }, [runtimeEngine]);
-    useFrame((_, dt) => {
-        runtimeEngine.tick(dt);
-    });
+    }, []);
     useEffect(() => {
         if (usesOwnedStore && data) {
             resolvedStore.getState().replacePrefab(data);
@@ -189,15 +197,36 @@ export const PrefabRoot = forwardRef(({ editMode, data, store, selectedId, onSel
         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 }) }) }));
+    const runtimeContent = _jsx(AssetRuntimeContext.Provider, { value: assetRuntime, children: content });
     if (!shouldProvideStoreContext) {
-        return _jsx(AssetRuntimeContext.Provider, { value: assetRuntime, children: content });
+        return runtimeContent;
     }
-    return _jsx(PrefabStoreProvider, { store: resolvedStore, children: _jsx(AssetRuntimeContext.Provider, { value: assetRuntime, children: content }) });
+    return _jsx(PrefabStoreProvider, { store: resolvedStore, children: runtimeContent });
 });
 function StoreRootNode(props) {
     const rootId = usePrefabRootId();
     return _jsx(GameObjectRenderer, Object.assign({}, props, { nodeId: rootId }));
 }
+function emitNodePointerEvent(eventName, event, nodeId, node, fallbackObject) {
+    var _a;
+    const trimmedEventName = eventName === null || eventName === void 0 ? void 0 : eventName.trim();
+    if (!trimmedEventName)
+        return;
+    gameEvents.emit(trimmedEventName, {
+        sourceEntityId: nodeId,
+        sourceNodeId: nodeId,
+        nodeId,
+        node,
+        object: (_a = event.object) !== null && _a !== void 0 ? _a : fallbackObject,
+        point: [event.point.x, event.point.y, event.point.z],
+        button: event.button,
+        altKey: event.nativeEvent.altKey,
+        ctrlKey: event.nativeEvent.ctrlKey,
+        metaKey: event.nativeEvent.metaKey,
+        shiftKey: event.nativeEvent.shiftKey,
+        r3fEvent: event,
+    });
+}
 export function GameObjectRenderer(props) {
     var _a, _b;
     const node = usePrefabNode(props.nodeId);
@@ -221,20 +250,19 @@ export function GameObjectRenderer(props) {
         : _jsx(StandardNode, Object.assign({}, props), key);
 }
 function InstancedNode({ nodeId, parentMatrix = IDENTITY, editMode, registerRef, onSelect, onClick }) {
-    var _a, _b, _c;
+    var _a, _b;
     const gameObject = usePrefabNode(nodeId);
     if (!gameObject)
         return null;
     const localTransform = getNodeTransformProps(gameObject);
     const isLocked = Boolean(gameObject.locked);
-    const clickComponent = findComponent(gameObject, "Click");
-    const clickable = Boolean(clickComponent);
-    const clickEventName = (_a = clickComponent === null || clickComponent === void 0 ? void 0 : clickComponent.properties) === null || _a === void 0 ? void 0 : _a.eventName;
+    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 = (_c = (_b = findComponent(gameObject, "Model")) === null || _b === void 0 ? void 0 : _b.properties) === null || _c === void 0 ? void 0 : _c.filename;
+    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 groupRef = useRef(null);
     const handleGroupRef = useCallback((object) => {
@@ -243,22 +271,27 @@ function InstancedNode({ nodeId, parentMatrix = IDENTITY, editMode, registerRef,
             registerRef(nodeId, object);
         }
     }, [editMode, nodeId, registerRef]);
-    const editClickHandlers = useClickValid(!!editMode && !isLocked, (e) => {
+    const editClickHandlers = useClickValid(!!editMode && !isLocked, (event) => {
         onSelect === null || onSelect === void 0 ? void 0 : onSelect(nodeId);
-        onClick === null || onClick === void 0 ? void 0 : onClick(e, gameObject);
+        onClick === null || onClick === void 0 ? void 0 : onClick(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)));
     if (editMode) {
-        return (_jsxs(_Fragment, { children: [_jsx("group", Object.assign({ ref: handleGroupRef, position: localTransform.position, rotation: localTransform.rotation, scale: localTransform.scale }, editClickHandlers, { children: _jsx("mesh", { visible: false, children: _jsx("boxGeometry", { args: [0.01, 0.01, 0.01] }) }) })), instances.map(instance => (_jsx(GameInstance, { id: instance.id, sourceId: gameObject.id, clickable: clickable, clickEventName: clickEventName, modelUrl: instance.modelUrl, position: instance.position, rotation: instance.rotation, scale: instance.scale, locked: isLocked, physics: instance.physics }, instance.id)))] }));
+        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: instances.map(instance => (_jsx(GameInstance, { id: instance.id, sourceId: gameObject.id, clickable: clickable, clickEventName: clickEventName, modelUrl: instance.modelUrl, position: instance.position, rotation: instance.rotation, scale: instance.scale, locked: isLocked, physics: instance.physics }, instance.id))) }));
+    return _jsx(_Fragment, { children: renderedInstances });
 }
 function StandardNode({ nodeId, selectedId, onSelect, onClick, registerRef, loadedModels, editMode, parentMatrix = IDENTITY, }) {
     var _a, _b;
     const gameObject = usePrefabNode(nodeId);
     const childIds = usePrefabChildIds(nodeId);
+    if (!gameObject)
+        return null;
     const isSelected = selectedId === nodeId;
-    const isLocked = Boolean(gameObject === null || gameObject === void 0 ? void 0 : gameObject.locked);
+    const isLocked = Boolean(gameObject.locked);
     const stillInstanced = useInstanceCheck(nodeId);
+    const clickEventName = getNodeClickEventName(gameObject);
+    const metadataProps = getNodeMetadataProps(gameObject);
     const groupRef = useRef(null);
     const helperRef = useRef(null);
     const handleGroupRef = useCallback((object) => {
@@ -268,27 +301,43 @@ function StandardNode({ nodeId, selectedId, onSelect, onClick, registerRef, load
     const handleHelperRef = useCallback((object) => {
         helperRef.current = object;
     }, []);
-    const clickHandlers = useClickValid(!!editMode && !isLocked, (e) => {
+    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);
-        if (gameObject)
-            onClick === null || onClick === void 0 ? void 0 : onClick(e, gameObject);
+        onClick === null || onClick === void 0 ? void 0 : onClick(event, gameObject);
     });
+    const primaryClickHandlers = !editMode && (clickEventName || onClick)
+        ? {
+            onClick: (event) => {
+                event.stopPropagation();
+                emitNodePointerEvent(clickEventName, event, nodeId, gameObject, groupRef.current);
+                onClick === null || onClick === void 0 ? void 0 : onClick(event, gameObject);
+            },
+        }
+        : undefined;
     useHelper(editMode && isSelected ? helperRef : null, BoxHelper, "cyan");
-    if (!gameObject)
-        return null;
     const world = parentMatrix.clone().multiply(compose(gameObject));
     const physics = findComponent(gameObject, "Physics");
     const ready = isNodeReady(gameObject, loadedModels);
     const hasPhysics = physics && ready && !stillInstanced;
     const transform = getNodeTransformProps(gameObject);
+    const transformProps = {
+        position: transform.position,
+        rotation: transform.rotation,
+        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 = (_jsx("group", Object.assign({}, clickHandlers, { children: renderCompositionNode(gameObject, renderCtx, childNodes) })));
+    const inner = renderCompositionNode(gameObject, renderCtx, primaryClickHandlers, childNodes);
     const physicsInner = editMode ? _jsx("group", { visible: false, children: inner }) : inner;
-    return (_jsx(EntityRuntimeScope, { nodeId: nodeId, editMode: editMode, isSelected: isSelected, children: editMode ? (_jsxs(_Fragment, { children: [_jsx("group", { ref: handleGroupRef, position: transform.position, rotation: transform.rotation, scale: transform.scale, children: _jsx("mesh", { visible: false, children: _jsx("boxGeometry", { args: [0.01, 0.01, 0.01] }) }) }), _jsx("group", { ref: handleHelperRef, position: transform.position, rotation: transform.rotation, scale: transform.scale, children: inner }), hasPhysics && (physicsDef === null || physicsDef === void 0 ? void 0 : physicsDef.View) ? (_jsx(physicsDef.View, { properties: physics.properties, position: transform.position, rotation: transform.rotation, scale: transform.scale, children: physicsInner }, physicsKey)) : null] })) : hasPhysics && (physicsDef === null || physicsDef === void 0 ? void 0 : physicsDef.View) ? (_jsx(physicsDef.View, { properties: physics.properties, position: transform.position, rotation: transform.rotation, scale: transform.scale, children: inner }, physicsKey)) : (_jsx("group", { ref: handleGroupRef, position: transform.position, rotation: transform.rotation, scale: transform.scale, children: inner })) }));
+    return (_jsx(EntityRuntimeScope, { nodeId: nodeId, editMode: editMode, isSelected: isSelected, children: editMode ? (_jsxs(_Fragment, { children: [_jsxs("group", Object.assign({ ref: handleEditGroupRef }, groupProps, editClickHandlers, { children: [_jsx("mesh", { visible: false, children: _jsx("boxGeometry", { args: [0.01, 0.01, 0.01] }) }), inner] })), hasPhysics && (physicsDef === null || physicsDef === void 0 ? void 0 : physicsDef.View) ? (_jsx(physicsDef.View, Object.assign({ properties: physics.properties }, transformProps, { children: physicsInner }), physicsKey)) : null] })) : hasPhysics && (physicsDef === null || physicsDef === void 0 ? void 0 : physicsDef.View) ? (_jsx(physicsDef.View, Object.assign({ properties: physics.properties }, transformProps, { children: _jsx("group", Object.assign({ ref: handleGroupRef }, metadataProps, { children: inner })) }), physicsKey)) : (_jsx("group", Object.assign({ ref: handleGroupRef }, groupProps, { children: inner }))) }));
 }
 function isRendererHandledComponent(componentType) {
     return componentType === "Transform"
@@ -383,11 +432,11 @@ 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, childNodes) {
-    const primaryContent = renderNodePrimaryContent(gameObject, ctx);
+function renderCompositionNode(gameObject, ctx, primaryClickHandlers, childNodes) {
+    const primaryContent = renderNodePrimaryContent(gameObject, ctx, primaryClickHandlers);
     return applyNodeComposition(gameObject, _jsxs(_Fragment, { children: [primaryContent, childNodes] }));
 }
-function renderNodePrimaryContent(gameObject, ctx) {
+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");
@@ -400,7 +449,7 @@ function renderNodePrimaryContent(gameObject, ctx) {
     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", { visible: meshVisible, castShadow: meshCastShadow, receiveShadow: meshReceiveShadow, children: [_jsx(geometryDef.View, { properties: geometry.properties }), material && (materialDef === null || materialDef === void 0 ? void 0 : materialDef.View) && (_jsx(materialDef.View, { properties: material.properties }, "material"))] }));
+        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"))] })));
     }
     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 });

package/dist/tools/prefabeditor/{runtime.d.ts → assetRuntime.d.ts}

@@ -1,7 +1,5 @@
 import { type ReactNode } from "react";
 import type { Object3D, Texture } from "three";
-import type { PrefabStoreApi } from "./prefabStore";
-import { type EntityComponent, type Scene } from "./scene";
 export interface AssetRuntime {
     registerRigidBodyRef: (id: string, rb: any) => void;
     getModel: (path: string) => Object3D | null;
@@ -36,26 +34,3 @@ export declare function EntityRuntimeScope({ nodeId, editMode, isSelected, child
     isSelected?: boolean;
     children: ReactNode;
 }): import("react/jsx-runtime").JSX.Element;
-/** Runtime behaviour produced by `Component.create(ctx)`. All methods optional. */
-export interface ComponentInstance {
-    start?(): void;
-    update?(dt: number): void;
-    destroy?(): void;
-}
-export interface ComponentRuntimeContext<TProperties = Record<string, any>> {
-    scene: Scene;
-    component: EntityComponent<TProperties>;
-    object: Object3D;
-    rigidBody: any;
-}
-export interface RuntimeEngine {
-    tick: (dt: number) => void;
-    setActive: (active: boolean) => void;
-    invalidate: () => void;
-    dispose: () => void;
-}
-export declare function createRuntimeEngine({ store, getObject, getRigidBody, }: {
-    store: PrefabStoreApi;
-    getObject: (id: string) => Object3D | null;
-    getRigidBody: (id: string) => any;
-}): RuntimeEngine;

package/dist/tools/prefabeditor/assetRuntime.js

@@ -0,0 +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);
+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);
+    if (!ctx)
+        throw new Error("useEntityRuntime 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 useEntityRigidBodyRef() {
+    const { getRigidBody } = useEntityRuntime();
+    return useMemo(() => ({ get current() { return getRigidBody(); } }), [getRigidBody]);
+}
+export function EntityRuntimeScope({ nodeId, editMode, isSelected, children, }) {
+    const asset = useContext(AssetRuntimeContext);
+    if (!asset)
+        throw new Error("EntityRuntimeScope must be used inside <PrefabRoot>");
+    const value = useMemo(() => ({
+        nodeId,
+        editMode,
+        isSelected,
+        getObject: () => asset.getObject(nodeId),
+        getRigidBody: () => asset.getRigidBody(nodeId),
+    }), [asset, editMode, isSelected, nodeId]);
+    return _jsx(EntityRuntimeContext.Provider, { value: value, children: children });
+}

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

@@ -1,5 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { BooleanField, FieldGroup } from "./Input";
+import { BooleanField, FieldGroup, StringField } from "./Input";
 const DEFAULT_TRIANGLE_POSITIONS = [
     0, 0, 0,
     1, 0, 0,
@@ -63,7 +63,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 })] }));
+    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] }));
 }
 function BufferGeometryComponentView({ properties }) {
     const positions = normalizeNumberArray(properties.positions, DEFAULT_TRIANGLE_POSITIONS);
@@ -91,6 +91,8 @@ const BufferGeometryComponent = {
         normals: [],
         uvs: DEFAULT_TRIANGLE_UVS,
         computeVertexNormals: true,
+        emitClickEvent: false,
+        clickEventName: '',
     },
 };
 export default BufferGeometryComponent;

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 '../runtime';
+import { useEntityRuntime } from '../assetRuntime';
 import { FieldGroup, NumberField, SelectField } from './Input';
 const CAMERA_PROJECTION_OPTIONS = [
     { value: 'perspective', label: 'Perspective' },

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

@@ -1,6 +1,5 @@
 import { FC } from "react";
 import { ComponentData, GameObject } from "../types";
-import type { ComponentInstance, ComponentRuntimeContext } from "../runtime";
 export type AssetRef = {
     type: "model" | "texture" | "sound";
     path: string;
@@ -28,8 +27,6 @@ export interface Component {
     }>;
     defaultProperties: any;
     View?: FC<ComponentViewProps>;
-    /** Optional runtime factory for the non-React game loop. */
-    create?: (ctx: ComponentRuntimeContext) => ComponentInstance | void;
     /** Declare which asset paths this component references (for asset loading). */
     getAssetRefs?: (properties: Record<string, any>) => AssetRef[];
 }