react-three-game 0.0.93 → 0.0.95

package/dist/tools/prefabeditor/PrefabRoot.js

@@ -9,8 +9,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 { forwardRef, useCallback, useEffect, useImperativeHandle, useMemo, useRef, useState } from "react";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { createContext, forwardRef, useCallback, useContext, useEffect, useImperativeHandle, useMemo, useRef, useState } from "react";
 import { Euler, Matrix4, } from "three";
 import { useStore } from "zustand";
 import { useClickValid } from "./useClickValid";
@@ -20,8 +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 { createPrefabStore, PrefabStoreProvider, useOptionalPrefabStoreApi, usePrefabChildIds, usePrefabNode, usePrefabRootId } from "./prefabStore";
-import { AssetRuntimeContext, CurrentNodeScope } from "./assetRuntime";
+import { createPrefabStore, PrefabStoreProvider, usePrefabChildIds, usePrefabNode, usePrefabRootId } from "./prefabStore";
+import { AssetRuntimeContext, NodeScope } from "./assetRuntime";
 import { gameEvents } from "./GameEvents";
 import { sound as soundManager } from "../../helpers/SoundManager";
 builtinComponents.forEach(registerComponent);
@@ -50,8 +50,20 @@ function getNodeMetadataProps(node) {
         userData: Object.assign(Object.assign({ prefabNodeId: node.id }, (nodeName ? { prefabNodeName: nodeName } : {})), getNodeUserData(node)),
     };
 }
-export const PrefabRootInternal = forwardRef(({ editMode, data, store, selectedId, onSelect, onClick, onEditNodeClick, basePath = "" }, ref) => {
-    var _a;
+export var PrefabEditorMode;
+(function (PrefabEditorMode) {
+    PrefabEditorMode["Edit"] = "edit";
+    PrefabEditorMode["Play"] = "play";
+})(PrefabEditorMode || (PrefabEditorMode = {}));
+export const SceneContext = createContext(null);
+export function useScene() {
+    const scene = useContext(SceneContext);
+    if (!scene) {
+        throw new Error("useScene must be used within a PrefabRoot or PrefabEditor scene provider");
+    }
+    return scene;
+}
+export const PrefabRoot = forwardRef(({ editMode, data, store, selectedId, onSelect, onClick, onEditNodeClick, basePath = "", children }, ref) => {
     const [models, setModels] = useState({});
     const [textures, setTextures] = useState({});
     const [sounds, setSounds] = useState({});
@@ -64,31 +76,33 @@ export const PrefabRootInternal = forwardRef(({ editMode, data, store, selectedI
     const failedSounds = useRef(new Set());
     const objectRefs = useRef({});
     const nodeHandles = useRef(new Map());
-    const parentStore = useOptionalPrefabStoreApi();
     const [ownedStore] = useState(() => {
+        if (store)
+            return null;
         if (data)
             return createPrefabStore(data);
-        if (store || parentStore)
-            return null;
         throw new Error("PrefabRoot requires either a `data` or `store` prop");
     });
-    const resolvedStore = (_a = store !== null && store !== void 0 ? store : parentStore) !== null && _a !== void 0 ? _a : ownedStore;
+    const resolvedStore = store !== null && store !== void 0 ? store : 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 getNodeObject = useCallback((id) => {
+    const getObject = useCallback((id) => {
         var _a;
         return (_a = objectRefs.current[id]) !== null && _a !== void 0 ? _a : null;
     }, []);
-    const getNodeHandle = useCallback((id, kind) => {
+    const getHandle = 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 getNode = useCallback((nodeId) => {
+        var _a;
+        return (_a = resolvedStore.getState().nodesById[nodeId]) !== null && _a !== void 0 ? _a : null;
+    }, [resolvedStore]);
+    const registerHandle = useCallback((id, kind, handle) => {
         const current = nodeHandles.current.get(id);
         if (handle == null) {
             if (!current)
@@ -105,20 +119,33 @@ export const PrefabRootInternal = forwardRef(({ editMode, data, store, selectedI
         }
         nodeHandles.current.set(id, new Map([[kind, handle]]));
     }, []);
-    useImperativeHandle(ref, () => ({
+    const sceneValue = useMemo(() => ({
         get root() {
             var _a;
             return (_a = objectRefs.current[rootId]) !== null && _a !== void 0 ? _a : null;
         },
-        getNodeObject,
-        getNodeHandle,
+        mode: editMode ? PrefabEditorMode.Edit : PrefabEditorMode.Play,
+        get: getNode,
+        getObject,
+        getHandle,
+        add: (node, parentId) => {
+            const state = resolvedStore.getState();
+            state.addChild(parentId !== null && parentId !== void 0 ? parentId : state.rootId, node);
+            return node;
+        },
+        update: (id, fn) => resolvedStore.getState().updateNode(id, fn),
+        remove: (id) => resolvedStore.getState().deleteNode(id),
+        duplicate: (id) => resolvedStore.getState().duplicateNode(id),
+        move: (draggedId, targetId, position) => resolvedStore.getState().moveNode(draggedId, targetId, position),
+        replace: (prefab) => resolvedStore.getState().replacePrefab(prefab),
         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 })));
         },
-    }), [getNodeHandle, getNodeObject, rootId]);
+    }), [editMode, getHandle, getNode, getObject, resolvedStore, rootId]);
+    useImperativeHandle(ref, () => sceneValue, [sceneValue]);
     const registerRef = useCallback((id, obj) => {
         objectRefs.current[id] = obj;
     }, []);
@@ -153,31 +180,27 @@ export const PrefabRootInternal = forwardRef(({ editMode, data, store, selectedI
                     return;
                 loading.current.add(file);
                 void loader(resolveAssetPath(basePath, file)).then(result => {
+                    loading.current.delete(file);
                     if (!result.success) {
                         console.warn(`Failed to load asset: ${file}`, result.error);
-                        loading.current.delete(file);
                         failed.add(file);
                     }
                 });
             };
-            modelsToLoad.forEach(file => loadAsset(file, models, injectedModels, failedModels.current, (path) => loadModel(path).then(result => {
-                const model = result.model;
-                if (result.success && model) {
-                    setModels(m => (Object.assign(Object.assign({}, m), { [file]: model })));
-                }
+            modelsToLoad.forEach(file => loadAsset(file, models, injectedModels, failedModels.current, path => loadModel(path).then(result => {
+                if (result.success && result.model)
+                    setModels(m => (Object.assign(Object.assign({}, m), { [file]: result.model })));
                 return result;
             })));
-            texturesToLoad.forEach(file => loadAsset(file, textures, injectedTextures, failedTextures.current, (path) => loadTexture(path).then(result => {
-                if (result.success && result.texture) {
+            texturesToLoad.forEach(file => loadAsset(file, textures, injectedTextures, failedTextures.current, path => loadTexture(path).then(result => {
+                if (result.success && result.texture)
                     setTextures(t => (Object.assign(Object.assign({}, t), { [file]: result.texture })));
-                }
                 return result;
             })));
-            soundsToLoad.forEach(file => loadAsset(file, sounds, injectedSounds, failedSounds.current, (path) => loadSound(path).then(result => {
+            soundsToLoad.forEach(file => loadAsset(file, sounds, injectedSounds, failedSounds.current, path => loadSound(path).then(result => {
                 if (result.success && result.sound) {
                     soundManager.setBuffer(file, result.sound);
-                    setSounds(current => (Object.assign(Object.assign({}, current), { [file]: result.sound })));
-                    loading.current.delete(file);
+                    setSounds(s => (Object.assign(Object.assign({}, s), { [file]: result.sound })));
                 }
                 return result;
             })));
@@ -185,14 +208,14 @@ export const PrefabRootInternal = forwardRef(({ editMode, data, store, selectedI
         syncAssets();
     }, [resolvedStore, assetManifestKey, basePath, injectedModels, injectedSounds, injectedTextures, models, sounds, textures]);
     const assetRuntime = useMemo(() => ({
-        registerNodeHandle,
-        getNodeHandle,
-        getNodeObject,
+        registerHandle,
+        getHandle,
+        getObject,
         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('|')}`,
-    }), [registerNodeHandle, getNodeHandle, getNodeObject, availableModels, availableTextures, availableSounds]);
+    }), [registerHandle, getHandle, getObject, availableModels, availableTextures, availableSounds]);
     const handleNodeClick = useCallback((event, nodeId, fallbackObject) => {
         const node = resolvedStore.getState().nodesById[nodeId];
         if (!node)
@@ -201,14 +224,10 @@ export const PrefabRootInternal = forwardRef(({ editMode, data, store, selectedI
         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;
-    }
+    const content = (_jsxs(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 }), children] }));
+    const runtimeContent = (_jsx(SceneContext.Provider, { value: sceneValue, children: _jsx(AssetRuntimeContext.Provider, { value: assetRuntime, children: content }) }));
     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 }));
@@ -221,11 +240,12 @@ function getClickEventName(component) {
     return typeof eventName === 'string' && eventName.trim() ? eventName.trim() : null;
 }
 function analyzeNodeComponents(node) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     let bufferGeometry;
     let geometry;
     let material;
     let model;
+    let sprite;
     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))
@@ -245,6 +265,9 @@ function analyzeNodeComponents(node) {
             case "Model":
                 model = component;
                 break;
+            case "Sprite":
+                sprite = component;
+                break;
             default: {
                 const def = getComponentDef(component.type);
                 if (!(def === null || def === void 0 ? void 0 : def.View))
@@ -262,7 +285,8 @@ function analyzeNodeComponents(node) {
         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),
+        sprite,
+        clickEventName: (_d = (_c = (_b = getClickEventName(bufferGeometry)) !== null && _b !== void 0 ? _b : getClickEventName(geometry)) !== null && _c !== void 0 ? _c : getClickEventName(model)) !== null && _d !== void 0 ? _d : getClickEventName(sprite),
         composition,
     };
 }
@@ -379,7 +403,7 @@ function StandardNode({ nodeId, selectedId, onSelect, onClick, onEditNodeClick,
     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: handleGroupRef }, groupProps, { visible: nodeVisible }, (editMode ? editClickHandlers : undefined), { children: [editAnchor, inner] })));
-    return (_jsx(CurrentNodeScope, { nodeId: nodeId, editMode: editMode, isSelected: isSelected, children: standardNode }));
+    return (_jsx(NodeScope, { nodeId: nodeId, editMode: editMode, isSelected: isSelected, children: standardNode }));
 }
 function ChildNodes(_a) {
     var { childIds, parentMatrix } = _a, props = __rest(_a, ["childIds", "parentMatrix"]);
@@ -452,24 +476,58 @@ function getNodeTransformProps(node) {
 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;
-    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"))] })));
+    const model = analyzedComponents.model;
+    const material = analyzedComponents.material;
+    const sprite = analyzedComponents.sprite;
+    const shapeKind = (sprite === null || sprite === void 0 ? void 0 : sprite.type) ? 'sprite' : (geometry === null || geometry === void 0 ? void 0 : geometry.type) ? 'mesh' : (model === null || model === void 0 ? void 0 : model.type) ? 'model' : 'none';
+    let materialContent = null;
+    switch (shapeKind) {
+        case 'sprite': {
+            const materialDef = (material === null || material === void 0 ? void 0 : material.type) ? getComponentDef(material.type) : undefined;
+            if ((material === null || material === void 0 ? void 0 : material.properties) && (materialDef === null || materialDef === void 0 ? void 0 : materialDef.View)) {
+                const materialIsSprite = material.properties.materialType === 'sprite';
+                materialContent = (_jsx(materialDef.View, { properties: Object.assign(Object.assign({}, material.properties), { materialType: 'sprite', transparent: materialIsSprite ? material.properties.transparent : true, depthTest: materialIsSprite ? material.properties.depthTest : false, depthWrite: materialIsSprite ? material.properties.depthWrite : false }) }, "material"));
+            }
+            break;
+        }
+        case 'mesh': {
+            const materialDef = (material === null || material === void 0 ? void 0 : material.type) ? getComponentDef(material.type) : undefined;
+            if ((material === null || material === void 0 ? void 0 : material.properties) && (materialDef === null || materialDef === void 0 ? void 0 : materialDef.View)) {
+                materialContent = _jsx(materialDef.View, { properties: material.properties }, "material");
+            }
+            break;
+        }
     }
-    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 }));
+    let primaryContent = null;
+    let contentChildren = childNodes;
+    switch (shapeKind) {
+        case 'sprite': {
+            primaryContent = (_jsxs("sprite", Object.assign({ center: (_b = (_a = sprite === null || sprite === void 0 ? void 0 : sprite.properties) === null || _a === void 0 ? void 0 : _a.center) !== null && _b !== void 0 ? _b : [0.5, 0.5] }, primaryClickHandlers, { children: [materialContent, childNodes] })));
+            contentChildren = null;
+            break;
+        }
+        case 'mesh': {
+            const geometryDef = (geometry === null || geometry === void 0 ? void 0 : geometry.type) ? getComponentDef(geometry.type) : undefined;
+            if (!(geometry === null || geometry === void 0 ? void 0 : geometry.properties) || !(geometryDef === null || geometryDef === void 0 ? void 0 : geometryDef.View))
+                break;
+            const GeometryView = geometryDef.View;
+            const geometryProperties = (_c = geometry.properties) !== null && _c !== void 0 ? _c : {};
+            const visible = geometryProperties.visible !== false;
+            primaryContent = (_jsxs("mesh", Object.assign({ visible: visible, castShadow: visible && geometryProperties.castShadow !== false, receiveShadow: visible && geometryProperties.receiveShadow !== false }, primaryClickHandlers, { children: [_jsx(GeometryView, { properties: geometry.properties }), materialContent] })));
+            break;
+        }
+        case 'model': {
+            if (!(model === null || model === void 0 ? void 0 : model.type) || ((_d = model.properties) === null || _d === void 0 ? void 0 : _d.instanced) || !isNodeReady(model, loadedModels))
+                break;
+            const modelDef = getComponentDef(model.type);
+            if (!(modelDef === null || modelDef === void 0 ? void 0 : modelDef.View))
+                break;
+            const modelContent = _jsx(modelDef.View, { properties: model.properties });
+            primaryContent = primaryClickHandlers ? _jsx("group", Object.assign({}, primaryClickHandlers, { children: modelContent })) : modelContent;
+            break;
+        }
     }
-    let content = _jsxs(_Fragment, { children: [primaryContent, childNodes] });
+    let content = _jsxs(_Fragment, { children: [primaryContent, contentChildren] });
     for (const { key, View, properties } of analyzedComponents.composition) {
         content = (_jsx(View, { properties: properties, children: content }, key));
     }

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

@@ -1,36 +1,30 @@
 import { type ReactNode } from "react";
 import type { Object3D, Texture } from "three";
 export interface AssetRuntime {
-    registerNodeHandle: (id: string, kind: string, handle: unknown) => void;
-    getNodeHandle: <T = unknown>(id: string, kind: string) => T | null;
+    registerHandle: (id: string, kind: string, handle: unknown) => void;
+    getHandle: <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;
-    getNodeObject: (id: string) => Object3D | null;
+    getObject: (id: string) => Object3D | null;
 }
-export interface AssetRuntimeContextValue extends AssetRuntime {
-}
-export interface CurrentNodeRuntime {
+export interface NodeApi {
     nodeId: string;
     editMode?: boolean;
     isSelected?: boolean;
-    getCurrentNodeObject: <T extends Object3D = Object3D>() => T | null;
-    getCurrentNodeHandle: <T = unknown>(kind: string) => T | null;
+    getObject: <T extends Object3D = Object3D>() => T | null;
+    getHandle: <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 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 const AssetRuntimeContext: import("react").Context<AssetRuntime | null>;
 export declare function useAssetRuntime(): AssetRuntime;
-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, }: {
+export declare function useNode(): NodeApi;
+export declare function useNodeObject<T extends Object3D = Object3D>(): LiveRef<T>;
+export declare function useNodeHandle<T = unknown>(kind: string): LiveRef<T>;
+export declare function NodeScope({ 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 CurrentNodeRuntimeContext = createContext(null);
+const NodeContext = createContext(null);
 export function useAssetRuntime() {
     const ctx = useContext(AssetRuntimeContext);
     if (!ctx)
         throw new Error("useAssetRuntime must be used inside <PrefabRoot>");
     return ctx;
 }
-export function useCurrentNode() {
-    const ctx = useContext(CurrentNodeRuntimeContext);
+export function useNode() {
+    const ctx = useContext(NodeContext);
     if (!ctx)
-        throw new Error("useCurrentNode must be used inside a component View rendered by <PrefabRoot>");
+        throw new Error("useNode must be used inside a component View rendered by <PrefabRoot>");
     return ctx;
 }
-export function useCurrentNodeObject() {
-    const { getCurrentNodeObject } = useCurrentNode();
-    return useMemo(() => ({ get current() { return getCurrentNodeObject(); } }), [getCurrentNodeObject]);
+export function useNodeObject() {
+    const { getObject } = useNode();
+    return useMemo(() => ({ get current() { return getObject(); } }), [getObject]);
 }
-export function useCurrentNodeHandle(kind) {
-    const { getCurrentNodeHandle } = useCurrentNode();
-    return useMemo(() => ({ get current() { return getCurrentNodeHandle(kind); } }), [getCurrentNodeHandle, kind]);
+export function useNodeHandle(kind) {
+    const { getHandle } = useNode();
+    return useMemo(() => ({ get current() { return getHandle(kind); } }), [getHandle, kind]);
 }
-export function CurrentNodeScope({ nodeId, editMode, isSelected, children, }) {
+export function NodeScope({ nodeId, editMode, isSelected, children, }) {
     const asset = useContext(AssetRuntimeContext);
     if (!asset)
-        throw new Error("CurrentNodeScope must be used inside <PrefabRoot>");
+        throw new Error("NodeScope must be used inside <PrefabRoot>");
     const value = useMemo(() => ({
         nodeId,
         editMode,
         isSelected,
-        getCurrentNodeObject: () => asset.getNodeObject(nodeId),
-        getCurrentNodeHandle: (kind) => asset.getNodeHandle(nodeId, kind),
+        getObject: () => asset.getObject(nodeId),
+        getHandle: (kind) => asset.getHandle(nodeId, kind),
     }), [asset, editMode, isSelected, nodeId]);
-    return _jsx(CurrentNodeRuntimeContext.Provider, { value: value, children: children });
+    return _jsx(NodeContext.Provider, { value: value, children: children });
 }

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 { useCurrentNode } from '../assetRuntime';
+import { useNode } 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 } = useCurrentNode();
+    const { editMode, isSelected } = useNode();
     const { size } = useThree();
     const merged = Object.assign(Object.assign({}, cameraDefaults), properties);
     const projection = (_a = merged.projection) !== null && _a !== void 0 ? _a : cameraDefaults.projection;

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

@@ -3,7 +3,7 @@ import { useHelper } from "@react-three/drei";
 import { useRef, useEffect, useState } from "react";
 import { useFrame } from "@react-three/fiber";
 import { CameraHelper } from "three";
-import { useCurrentNode } from "../assetRuntime";
+import { useNode } from "../assetRuntime";
 import { BooleanField, ColorField, NumberField, NumberInput, Vector3Input } from "./Input";
 import { LightSection, ShadowBiasField, mergeWithDefaults } from "./lightUtils";
 import { colors } from "../styles";
@@ -102,7 +102,7 @@ function DirectionalLightComponentEditor({ component, onUpdate }) {
     return (_jsxs("div", { style: { display: 'flex', flexDirection: 'column', gap: 8 }, children: [_jsxs(LightSection, { title: "Light", children: [_jsx(ColorField, { name: "color", label: "Color", values: values, onChange: onUpdate }), _jsx(NumberField, { name: "intensity", label: "Intensity", values: values, onChange: onUpdate, min: 0, step: 0.1, fallback: 1 }), _jsx(Vector3Input, { label: "Target Offset", value: values.targetOffset, onChange: targetOffset => onUpdate({ targetOffset }), snap: 0.5 })] }), _jsxs(LightSection, { title: "Shadow", children: [_jsx(BooleanField, { name: "castShadow", label: "Cast Shadow", values: values, onChange: onUpdate, fallback: false }), values.castShadow ? (_jsxs(_Fragment, { children: [_jsx(BooleanField, { name: "shadowAutoUpdate", label: "Auto Update", values: values, onChange: onUpdate, fallback: true }), _jsx(NumberField, { name: "shadowMapSize", label: "Map Size", values: values, onChange: onUpdate, min: 128, step: 128, fallback: 512 }), _jsx(ShadowBiasField, { name: "shadowBias", label: "Bias", values: values, onChange: onUpdate, fallback: 0 }), _jsx(ShadowBiasField, { name: "shadowNormalBias", label: "Normal Bias", values: values, onChange: onUpdate, fallback: 0 }), _jsx(NumberField, { name: "shadowCameraNear", label: "Near", values: values, onChange: onUpdate, min: 0.001, step: 0.1, fallback: 0.5 }), _jsx(NumberField, { name: "shadowCameraFar", label: "Far", values: values, onChange: onUpdate, min: 0.1, step: 1, fallback: 500 }), _jsx(ShadowFrustumField, { values: values, onChange: onUpdate })] })) : null] })] }));
 }
 function DirectionalLightView({ properties, children }) {
-    const { editMode, isSelected } = useCurrentNode();
+    const { editMode, isSelected } = useNode();
     const merged = mergeWithDefaults(directionalLightDefaults, properties);
     const color = merged.color;
     const intensity = merged.intensity;

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

@@ -1,7 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useMemo, useRef, useState } from 'react';
 import { colors, ui } from '../styles';
-import { useOptionalPrefabStoreApi } from '../prefabStore';
+import { usePrefabStoreApi } from '../prefabStore';
 // ============================================================================
 // Shared Styles (derived from shared color tokens)
 // ============================================================================
@@ -278,14 +278,10 @@ export function ColorInput({ label, value, onChange }) {
 export function StringInput({ label, value, onChange, placeholder }) {
     return (_jsxs("div", { children: [label && _jsx(Label, { children: label }), _jsx("input", { type: "text", style: styles.input, value: value, onChange: e => onChange(e.target.value), placeholder: placeholder })] }));
 }
-function useOptionalPrefabSnapshot() {
-    const store = useOptionalPrefabStoreApi();
-    const [state, setState] = useState(() => { var _a; return (_a = store === null || store === void 0 ? void 0 : store.getState()) !== null && _a !== void 0 ? _a : null; });
+function usePrefabSnapshot() {
+    const store = usePrefabStoreApi();
+    const [state, setState] = useState(() => store.getState());
     useEffect(() => {
-        if (!store) {
-            setState(null);
-            return;
-        }
         setState(store.getState());
         return store.subscribe(nextState => setState(nextState));
     }, [store]);
@@ -323,7 +319,7 @@ function SearchSuggestionList({ query, options, onSelect, emptyMessage, }) {
                     }, children: [_jsx("span", { style: { fontSize: 11, fontWeight: 500 }, children: option.label }), option.description ? (_jsx("span", { style: { fontSize: 10, color: colors.textMuted, fontFamily: 'monospace' }, children: option.description })) : null] }, option.value))) })] }));
 }
 export function NodeInput({ label, value, onChange, placeholder, includeRoot = true, }) {
-    const prefabState = useOptionalPrefabSnapshot();
+    const prefabState = usePrefabSnapshot();
     const [query, setQuery] = useState('');
     const options = useMemo(() => {
         var _a;

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

@@ -1,19 +1,22 @@
 import { type ReactNode } from 'react';
 import type { ThreeElement } from '@react-three/fiber';
 import { Component } from './ComponentRegistry';
-import { MeshBasicNodeMaterial, MeshStandardNodeMaterial } from 'three/webgpu';
+import { MeshBasicNodeMaterial, MeshStandardNodeMaterial, SpriteNodeMaterial } from 'three/webgpu';
 import { MeshBasicMaterialProperties, MeshStandardMaterialProperties } from 'three';
 declare module '@react-three/fiber' {
     interface ThreeElements {
         meshBasicNodeMaterial: ThreeElement<typeof MeshBasicNodeMaterial>;
         meshStandardNodeMaterial: ThreeElement<typeof MeshStandardNodeMaterial>;
+        spriteNodeMaterial: ThreeElement<typeof SpriteNodeMaterial>;
     }
 }
 export interface MaterialProps extends Omit<MeshStandardMaterialProperties & MeshBasicMaterialProperties, 'args' | 'normalScale'> {
-    materialType?: 'standard' | 'basic';
+    materialType?: 'standard' | 'basic' | 'sprite';
     transmission?: number;
     thickness?: number;
     ior?: number;
+    rotation?: number;
+    sizeAttenuation?: boolean;
     texture?: string;
     offset?: [number, number];
     repeat?: boolean;