react-three-game 0.0.109 → 0.0.110

package/dist/tools/prefabeditor/PrefabRoot.js

@@ -19,22 +19,36 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { forwardRef, useCallback, useContext, useEffect, useImperativeHandle, useMemo, useRef, useState } from "react";
+import { forwardRef, useCallback, useEffect, useImperativeHandle, useMemo, useRef, useState } from "react";
 import { Euler, Matrix4 } from "three";
-import { useThree } from "@react-three/fiber";
 import { useStore } from "zustand";
 import { useClickValid } from "./useClickValid";
 import { findComponent, getNodeUserData } from "./types";
-import { getComponentDef } from "./components/ComponentRegistry";
+import { getComponentDef, registerComponent } from "./components/ComponentRegistry";
+import { builtinComponents } from "./components";
 import { loadModel, loadSound, loadTexture } from "../dragdrop";
 import { GameInstance, GameInstanceProvider, getRepeatAxesFromModelProperties } from "./InstanceProvider";
 import { composeTransform, decompose, withBasePath } from "./runtimeUtils";
-import { createPrefabStore, PrefabStoreProvider, usePrefabChildIds, usePrefabNode, usePrefabRootId } from "./prefabStore";
-import { AssetRuntimeContext, NodeScope } from "./assetRuntime";
+import { createPrefabStore, PrefabStoreProvider, usePrefabChildIds, usePrefabNode, usePrefabRootId, usePrefabStoreApi } from "./prefabStore";
+import { AssetRuntimeProvider, NodeScope, useAllModels, useAssetRuntime } from "./assetRuntime";
 import { gameEvents } from "./GameEvents";
-import { sound as soundManager } from "../../helpers/SoundManager";
-import { PrefabEditorMode, SceneContext } from "./SceneContext";
+import { useScene } from "./SceneContext";
+import { SceneProvider } from "./SceneProvider";
 const IDENTITY = new Matrix4();
+// Reusable scratch objects for buildRepeatedInstances. The matrices are pure
+// intermediates (their results are read out into plain arrays per instance),
+// so they can be shared across calls instead of allocating fresh Matrix4s in
+// nested loops for every repeated instance.
+const _scratchTranslation = new Matrix4();
+const _scratchRotation = new Matrix4();
+const _scratchScale = new Matrix4();
+const _scratchOffset = new Matrix4();
+const _scratchWorld = new Matrix4();
+const _scratchEuler = new Euler();
+builtinComponents.forEach((component) => {
+    if (!getComponentDef(component.name))
+        registerComponent(component);
+});
 const EMPTY_NODE_COMPONENTS = {
     geometry: undefined,
     materials: [],
@@ -43,20 +57,6 @@ const EMPTY_NODE_COMPONENTS = {
     clickEventName: null,
     composition: [],
 };
-function precompileModel(model, renderer, camera) {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            if (typeof renderer.compileAsync === "function") {
-                yield renderer.compileAsync(model, camera);
-                return;
-            }
-            renderer.compile(model, camera);
-        }
-        catch (error) {
-            console.warn("Failed to precompile model before adding it to the scene", error);
-        }
-    });
-}
 /** Check if a model component's assets are loaded. */
 function isNodeReady(model, loadedModels) {
     var _a;
@@ -72,21 +72,8 @@ 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, onEditNodeClick, basePath = "", children }, ref) => {
-    const parentScene = useContext(SceneContext);
-    const parentAssetRuntime = useContext(AssetRuntimeContext);
-    const renderer = useThree(state => state.gl);
-    const camera = useThree(state => state.camera);
-    const [models, setModels] = useState({});
-    const [textures, setTextures] = useState({});
-    const [sounds, setSounds] = useState({});
-    const loading = useRef(new Set());
-    const failedModels = useRef(new Set());
-    const failedTextures = useRef(new Set());
-    const failedSounds = useRef(new Set());
-    const injectedModelVersions = useRef({});
-    const objectRefs = useRef({});
-    const nodeHandles = useRef(new Map());
+export const PrefabRoot = forwardRef((props, ref) => {
+    const { data, store } = props;
     const [ownedStore] = useState(() => {
         if (store)
             return null;
@@ -95,198 +82,76 @@ export const PrefabRoot = forwardRef(({ editMode, data, store, selectedId, onSel
         throw new Error("PrefabRoot requires either a `data` or `store` prop");
     });
     const resolvedStore = store !== null && store !== void 0 ? store : ownedStore;
-    if (!resolvedStore) {
+    if (!resolvedStore)
         throw new Error("PrefabRoot requires either a `data` or `store` prop");
-    }
-    const usesOwnedStore = resolvedStore === ownedStore;
-    const rootId = useStore(resolvedStore, state => state.rootId);
-    const assetRefCounts = useStore(resolvedStore, state => state.assetRefCounts);
-    const getModel = useCallback((path) => { var _a, _b; return (_b = (_a = models[path]) !== null && _a !== void 0 ? _a : parentAssetRuntime === null || parentAssetRuntime === void 0 ? void 0 : parentAssetRuntime.getModel(path)) !== null && _b !== void 0 ? _b : null; }, [models, parentAssetRuntime]);
-    const getTexture = useCallback((path) => { var _a, _b; return (_b = (_a = textures[path]) !== null && _a !== void 0 ? _a : parentAssetRuntime === null || parentAssetRuntime === void 0 ? void 0 : parentAssetRuntime.getTexture(path)) !== null && _b !== void 0 ? _b : null; }, [parentAssetRuntime, textures]);
-    const getSound = useCallback((path) => { var _a, _b; return (_b = (_a = sounds[path]) !== null && _a !== void 0 ? _a : parentAssetRuntime === null || parentAssetRuntime === void 0 ? void 0 : parentAssetRuntime.getSound(path)) !== null && _b !== void 0 ? _b : null; }, [parentAssetRuntime, sounds]);
-    const assetRevision = useMemo(() => { var _a; return `${(_a = parentAssetRuntime === null || parentAssetRuntime === void 0 ? void 0 : parentAssetRuntime.getAssetRevision()) !== null && _a !== void 0 ? _a : ""}::${Object.keys(textures).sort().join('|')}::${Object.keys(models).sort().join('|')}`; }, [models, parentAssetRuntime, textures]);
-    const getObject = useCallback((id) => {
-        var _a, _b;
-        return (_b = (_a = objectRefs.current[id]) !== null && _a !== void 0 ? _a : parentAssetRuntime === null || parentAssetRuntime === void 0 ? void 0 : parentAssetRuntime.getObject(id)) !== null && _b !== void 0 ? _b : null;
-    }, [parentAssetRuntime]);
-    const getHandle = useCallback((id, kind) => {
-        var _a, _b, _c;
-        return (_c = (_b = (_a = nodeHandles.current.get(id)) === null || _a === void 0 ? void 0 : _a.get(kind)) !== null && _b !== void 0 ? _b : parentAssetRuntime === null || parentAssetRuntime === void 0 ? void 0 : parentAssetRuntime.getHandle(id, kind)) !== null && _c !== void 0 ? _c : null;
-    }, [parentAssetRuntime]);
-    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) {
-            parentAssetRuntime === null || parentAssetRuntime === void 0 ? void 0 : parentAssetRuntime.registerHandle(id, kind, null);
-            if (!current)
-                return;
-            current.delete(kind);
-            if (current.size === 0) {
-                nodeHandles.current.delete(id);
-            }
-            return;
-        }
-        if (current) {
-            current.set(kind, handle);
-            parentAssetRuntime === null || parentAssetRuntime === void 0 ? void 0 : parentAssetRuntime.registerHandle(id, kind, handle);
-            return;
-        }
-        nodeHandles.current.set(id, new Map([[kind, handle]]));
-        parentAssetRuntime === null || parentAssetRuntime === void 0 ? void 0 : parentAssetRuntime.registerHandle(id, kind, handle);
-    }, [parentAssetRuntime]);
-    const registerObject = useCallback((id, obj) => {
-        if (obj) {
-            objectRefs.current[id] = obj;
-        }
-        else {
-            delete objectRefs.current[id];
-        }
-        parentAssetRuntime === null || parentAssetRuntime === void 0 ? void 0 : parentAssetRuntime.registerObject(id, obj);
-    }, [parentAssetRuntime]);
-    const registerModel = useCallback((path, model) => {
-        parentAssetRuntime === null || parentAssetRuntime === void 0 ? void 0 : parentAssetRuntime.registerModel(path, model);
-        setModels(prev => prev[path] === model ? prev : Object.assign(Object.assign({}, prev), { [path]: model }));
-    }, [parentAssetRuntime]);
-    const registerTexture = useCallback((path, texture) => {
-        parentAssetRuntime === null || parentAssetRuntime === void 0 ? void 0 : parentAssetRuntime.registerTexture(path, texture);
-        setTextures(prev => prev[path] === texture ? prev : Object.assign(Object.assign({}, prev), { [path]: texture }));
-    }, [parentAssetRuntime]);
-    const registerSound = useCallback((path, sound) => {
-        parentAssetRuntime === null || parentAssetRuntime === void 0 ? void 0 : parentAssetRuntime.registerSound(path, sound);
-        soundManager.setBuffer(path, sound);
-        setSounds(prev => prev[path] === sound ? prev : Object.assign(Object.assign({}, prev), { [path]: sound }));
-    }, [parentAssetRuntime]);
-    const sceneValue = useMemo(() => ({
-        get root() {
-            var _a;
-            return (_a = objectRefs.current[rootId]) !== null && _a !== void 0 ? _a : null;
-        },
-        mode: editMode ? PrefabEditorMode.Edit : PrefabEditorMode.Play,
-        basePath,
-        get: getNode,
-        getObject,
-        getHandle,
-        getModel,
-        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),
-        replaceNode: (id, node) => resolvedStore.getState().replaceNode(id, node),
-        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) => {
-            var _a;
-            const version = ((_a = injectedModelVersions.current[path]) !== null && _a !== void 0 ? _a : 0) + 1;
-            injectedModelVersions.current[path] = version;
-            void precompileModel(model, renderer, camera).then(() => {
-                if (injectedModelVersions.current[path] !== version)
-                    return;
-                registerModel(path, model);
-            });
-        },
-        addTexture: registerTexture,
-        addSound: registerSound,
-    }), [basePath, camera, editMode, getHandle, getModel, getNode, getObject, registerModel, registerSound, registerTexture, renderer, resolvedStore, rootId]);
-    useImperativeHandle(ref, () => sceneValue, [sceneValue]);
     useEffect(() => {
-        if (usesOwnedStore && data) {
+        if (!store && data)
             resolvedStore.getState().replacePrefab(data);
-        }
-    }, [data, resolvedStore, usesOwnedStore]);
+    }, [data, resolvedStore, store]);
+    return (_jsx(PrefabStoreProvider, { store: resolvedStore, children: _jsx(AssetRuntimeProvider, { children: _jsx(SceneProvider, { store: resolvedStore, editMode: props.editMode, basePath: props.basePath, children: _jsx(PrefabRootBody, Object.assign({ ref: ref }, props)) }) }) }));
+});
+const PrefabRootBody = forwardRef(({ editMode, selectedId, onSelect, onClick, onEditNodeClick, basePath = "", children }, ref) => {
+    const scene = useScene();
+    const runtime = useAssetRuntime();
+    const models = useAllModels();
+    const storeApi = usePrefabStoreApi();
+    const assetRefCounts = useStore(storeApi, state => state.assetRefCounts);
+    useImperativeHandle(ref, () => scene, [scene]);
+    const loading = useRef(new Set());
+    const failed = useRef(new Set());
     useEffect(() => {
-        const loadAsset = (file, loaded, failed, loader) => {
-            if (loaded[file] || loading.current.has(file) || failed.has(file))
+        const tryLoad = (key, hasLoaded, run) => {
+            if (hasLoaded || loading.current.has(key) || failed.current.has(key))
                 return;
-            loading.current.add(file);
-            void loader(withBasePath(basePath, file)).then(result => {
-                loading.current.delete(file);
+            loading.current.add(key);
+            void run().then(result => {
+                loading.current.delete(key);
                 if (!result.success) {
-                    console.warn(`Failed to load asset: ${file}`, result.error);
-                    failed.add(file);
+                    console.warn(`Failed to load asset: ${key}`, result.error);
+                    failed.current.add(key);
                 }
             });
         };
         Object.keys(assetRefCounts).forEach(entry => {
-            const separator = entry.indexOf(':');
-            const type = entry.slice(0, separator);
-            const file = entry.slice(separator + 1);
+            const sep = entry.indexOf(':');
+            const type = entry.slice(0, sep);
+            const file = entry.slice(sep + 1);
+            const path = withBasePath(basePath, file);
             if (type === 'model') {
-                const inheritedModel = models[file] ? null : parentAssetRuntime === null || parentAssetRuntime === void 0 ? void 0 : parentAssetRuntime.getModel(file);
-                if (inheritedModel) {
-                    registerModel(file, inheritedModel);
-                    return;
-                }
-                loadAsset(file, models, failedModels.current, path => loadModel(path).then((result) => __awaiter(void 0, void 0, void 0, function* () {
-                    const loadedModel = result.model;
-                    if (result.success && loadedModel) {
-                        yield precompileModel(loadedModel, renderer, camera);
-                        registerModel(file, loadedModel);
-                    }
-                    return result;
-                })));
+                tryLoad(entry, !!runtime.getModel(file), () => __awaiter(void 0, void 0, void 0, function* () {
+                    const r = yield loadModel(path);
+                    if (r.success && r.model)
+                        runtime.registerModel(file, r.model);
+                    return r;
+                }));
             }
             else if (type === 'texture') {
-                const inheritedTexture = textures[file] ? null : parentAssetRuntime === null || parentAssetRuntime === void 0 ? void 0 : parentAssetRuntime.getTexture(file);
-                if (inheritedTexture) {
-                    registerTexture(file, inheritedTexture);
-                    return;
-                }
-                loadAsset(file, textures, failedTextures.current, path => loadTexture(path).then(result => {
-                    const loadedTexture = result.texture;
-                    if (result.success && loadedTexture) {
-                        registerTexture(file, loadedTexture);
-                    }
-                    return result;
+                tryLoad(entry, !!runtime.getTexture(file), () => __awaiter(void 0, void 0, void 0, function* () {
+                    const r = yield loadTexture(path);
+                    if (r.success && r.texture)
+                        runtime.registerTexture(file, r.texture);
+                    return r;
                 }));
             }
             else if (type === 'sound') {
-                const inheritedSound = sounds[file] ? null : parentAssetRuntime === null || parentAssetRuntime === void 0 ? void 0 : parentAssetRuntime.getSound(file);
-                if (inheritedSound) {
-                    registerSound(file, inheritedSound);
-                    return;
-                }
-                loadAsset(file, sounds, failedSounds.current, path => loadSound(path).then(result => {
-                    const loadedSound = result.sound;
-                    if (result.success && loadedSound) {
-                        registerSound(file, loadedSound);
-                    }
-                    return result;
+                tryLoad(entry, !!runtime.getSound(file), () => __awaiter(void 0, void 0, void 0, function* () {
+                    const r = yield loadSound(path);
+                    if (r.success && r.sound)
+                        runtime.registerSound(file, r.sound);
+                    return r;
                 }));
             }
         });
-    }, [assetRefCounts, basePath, camera, models, parentAssetRuntime, registerModel, registerSound, registerTexture, renderer, sounds, textures]);
-    const assetRuntime = useMemo(() => ({
-        registerObject,
-        registerHandle,
-        registerModel,
-        registerTexture,
-        registerSound,
-        getHandle,
-        getObject,
-        getModel,
-        getTexture,
-        getSound,
-        getAssetRevision: () => assetRevision,
-    }), [registerObject, registerHandle, registerModel, registerTexture, registerSound, getHandle, getObject, getModel, getTexture, getSound, assetRevision]);
+    }, [assetRefCounts, basePath, runtime]);
     const handleNodeClick = useCallback((event, nodeId, fallbackObject) => {
-        const node = resolvedStore.getState().nodesById[nodeId];
+        const node = storeApi.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 = (_jsxs(GameInstanceProvider, { models: models, selectedId: selectedId, editMode: editMode, onSelect: editMode ? onSelect : undefined, onClick: editMode ? undefined : handleNodeClick, registerRef: registerObject, children: [_jsx(StoreRootNode, { selectedId: selectedId, onSelect: editMode ? onSelect : undefined, onClick: editMode ? undefined : handleNodeClick, onEditNodeClick: editMode ? onEditNodeClick : undefined, registerRef: registerObject, loadedModels: models, editMode: editMode, parentMatrix: IDENTITY, basePath: basePath }), children] }));
-    const runtimeContent = parentAssetRuntime ? content : (_jsx(AssetRuntimeContext.Provider, { value: assetRuntime, children: content }));
-    const sceneContent = parentScene ? runtimeContent : (_jsx(SceneContext.Provider, { value: sceneValue, children: runtimeContent }));
-    return _jsx(PrefabStoreProvider, { store: resolvedStore, children: sceneContent });
+    }, [onClick, storeApi]);
+    return (_jsxs(GameInstanceProvider, { models: models, selectedId: selectedId, editMode: editMode, onSelect: editMode ? onSelect : undefined, onClick: editMode ? undefined : handleNodeClick, registerRef: runtime.registerObject, children: [_jsx(StoreRootNode, { selectedId: selectedId, onSelect: editMode ? onSelect : undefined, onClick: editMode ? undefined : handleNodeClick, onEditNodeClick: editMode ? onEditNodeClick : undefined, registerRef: runtime.registerObject, loadedModels: models, editMode: editMode, parentMatrix: IDENTITY, basePath: basePath }), children] }));
 });
 function StoreRootNode(props) {
     const rootId = usePrefabRootId();
@@ -502,11 +367,11 @@ function buildRepeatedInstances(gameObject, parentMatrix, modelUrl) {
             offsets[axisIndex] = entry.offset;
         }
     }
-    const baseTranslation = new Matrix4().makeTranslation(transform.position[0], transform.position[1], transform.position[2]);
-    const baseRotation = new Matrix4().makeRotationFromEuler(new Euler(...transform.rotation));
-    const baseScale = new Matrix4().makeScale(transform.scale[0], transform.scale[1], transform.scale[2]);
-    const offsetMatrix = new Matrix4();
-    const worldMatrix = new Matrix4();
+    const baseTranslation = _scratchTranslation.makeTranslation(transform.position[0], transform.position[1], transform.position[2]);
+    const baseRotation = _scratchRotation.makeRotationFromEuler(_scratchEuler.set(transform.rotation[0], transform.rotation[1], transform.rotation[2]));
+    const baseScale = _scratchScale.makeScale(transform.scale[0], transform.scale[1], transform.scale[2]);
+    const offsetMatrix = _scratchOffset;
+    const worldMatrix = _scratchWorld;
     const instances = [];
     for (let x = 0; x < counts[0]; x++) {
         for (let y = 0; y < counts[1]; y++) {

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

@@ -0,0 +1,14 @@
+import { type ReactNode } from "react";
+import type { PrefabStoreApi } from "./prefabStore";
+export interface SceneProviderProps {
+    store: PrefabStoreApi;
+    editMode?: boolean;
+    basePath?: string;
+    children: ReactNode;
+}
+/**
+ * Recursive provider: if a Scene is already present above, this is a
+ * pass-through. Otherwise this layer becomes the owner and builds a default
+ * Scene bound to the given store + asset runtime.
+ */
+export declare function SceneProvider({ store, editMode, basePath, children }: SceneProviderProps): import("react").JSX.Element;

package/dist/tools/prefabeditor/SceneProvider.js

@@ -0,0 +1,68 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { useContext, useMemo } from "react";
+import { useThree } from "@react-three/fiber";
+import { useStore } from "zustand";
+import { PrefabEditorMode, SceneContext } from "./SceneContext";
+import { useAssetRuntime } from "./assetRuntime";
+/**
+ * Recursive provider: if a Scene is already present above, this is a
+ * pass-through. Otherwise this layer becomes the owner and builds a default
+ * Scene bound to the given store + asset runtime.
+ */
+export function SceneProvider({ store, editMode, basePath = "", children }) {
+    const inherited = useContext(SceneContext);
+    if (inherited !== null)
+        return _jsx(_Fragment, { children: children });
+    return (_jsx(SceneOwner, { store: store, editMode: editMode, basePath: basePath, children: children }));
+}
+function SceneOwner({ store, editMode, basePath, children }) {
+    const runtime = useAssetRuntime();
+    const renderer = useThree(s => s.gl);
+    const camera = useThree(s => s.camera);
+    const rootId = useStore(store, s => s.rootId);
+    const scene = useMemo(() => ({
+        get root() { return runtime.getObject(rootId); },
+        mode: editMode ? PrefabEditorMode.Edit : PrefabEditorMode.Play,
+        basePath,
+        get: (id) => { var _a; return (_a = store.getState().nodesById[id]) !== null && _a !== void 0 ? _a : null; },
+        getObject: runtime.getObject,
+        getHandle: runtime.getHandle,
+        getModel: runtime.getModel,
+        add: (node, parentId) => {
+            const s = store.getState();
+            s.addChild(parentId !== null && parentId !== void 0 ? parentId : s.rootId, node);
+            return node;
+        },
+        update: (id, fn) => store.getState().updateNode(id, fn),
+        replaceNode: (id, node) => store.getState().replaceNode(id, node),
+        remove: (id) => store.getState().deleteNode(id),
+        duplicate: (id) => store.getState().duplicateNode(id),
+        move: (a, b, p) => store.getState().moveNode(a, b, p),
+        replace: (p) => store.getState().replacePrefab(p),
+        addModel: (path, model) => {
+            void precompile(model, renderer, camera).then(() => runtime.registerModel(path, model));
+        },
+        addTexture: runtime.registerTexture,
+        addSound: runtime.registerSound,
+    }), [store, editMode, basePath, runtime, rootId, renderer, camera]);
+    return _jsx(SceneContext.Provider, { value: scene, children: children });
+}
+function precompile(model, renderer, camera) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield renderer.compileAsync(model, camera);
+        }
+        catch (error) {
+            console.warn("Failed to precompile model before adding it to the scene", error);
+        }
+    });
+}

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

@@ -1,6 +1,10 @@
 import { type ReactNode } from "react";
 import type { Object3D, Texture } from "three";
+import type { LoadedModels, LoadedSounds, LoadedTextures } from "../dragdrop";
 export interface AssetRuntime {
+    models: LoadedModels;
+    textures: LoadedTextures;
+    sounds: LoadedSounds;
     registerObject: (id: string, object: Object3D | null) => void;
     registerHandle: (id: string, kind: string, handle: unknown) => void;
     registerModel: (path: string, model: Object3D) => void;
@@ -10,7 +14,7 @@ export interface AssetRuntime {
     getModel: (path: string) => Object3D | null;
     getTexture: (path: string) => Texture | null;
     getSound: (path: string) => AudioBuffer | null;
-    getAssetRevision: () => string;
+    getAssetRevision: () => number;
     getObject: (id: string) => Object3D | null;
 }
 export interface NodeApi {
@@ -23,7 +27,21 @@ export interface NodeApi {
 export interface LiveRef<T> {
     readonly current: T | null;
 }
+export interface AssetRuntimeProviderProps {
+    children: ReactNode;
+    runtimeRef?: React.MutableRefObject<AssetRuntime | null>;
+}
 export declare const AssetRuntimeContext: import("react").Context<AssetRuntime | null>;
+/** Subscribe to a single loaded model; re-renders only when that model changes. */
+export declare function useModelAsset(path?: string | null): Object3D | null;
+/** Subscribe to a single loaded texture; re-renders only when that texture changes. */
+export declare function useTextureAsset(path?: string | null): Texture | null;
+/** Subscribe to a single loaded sound; re-renders only when that sound changes. */
+export declare function useSoundAsset(path?: string | null): AudioBuffer | null;
+/** Subscribe to the full model map (only needed by the instancing root). */
+export declare function useAllModels(): LoadedModels;
+/** Coarse "an asset was (un)registered" signal. */
+export declare function useAssetRevision(): number;
 export declare function useAssetRuntime(): AssetRuntime;
 export declare function useNode(): NodeApi;
 export declare function useNodeObject<T extends Object3D = Object3D>(): LiveRef<T>;
@@ -33,4 +51,9 @@ export declare function NodeScope({ nodeId, editMode, isSelected, children, }: {
     editMode?: boolean;
     isSelected?: boolean;
     children: ReactNode;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react").JSX.Element;
+/**
+ * Recursive provider: if an AssetRuntime is already present above, this is a
+ * pass-through. Otherwise this layer becomes the owner and allocates state.
+ */
+export declare function AssetRuntimeProvider({ children, runtimeRef }: AssetRuntimeProviderProps): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react").JSX.Element | null | undefined;

package/dist/tools/prefabeditor/assetRuntime.js

@@ -1,7 +1,40 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useContext, useMemo } from "react";
+import { createContext, useCallback, useContext, useMemo, useRef, useState } from "react";
+import { useStore } from "zustand";
+import { createStore } from "zustand/vanilla";
+import { sound as soundManager } from "../../helpers/SoundManager";
 export const AssetRuntimeContext = createContext(null);
 const NodeContext = createContext(null);
+function createAssetStore() {
+    return createStore(() => ({ models: {}, textures: {}, sounds: {}, version: 0 }));
+}
+const AssetStoreContext = createContext(null);
+function useAssetStore() {
+    const store = useContext(AssetStoreContext);
+    if (!store)
+        throw new Error("Asset hooks must be used inside <PrefabRoot>");
+    return store;
+}
+/** Subscribe to a single loaded model; re-renders only when that model changes. */
+export function useModelAsset(path) {
+    return useStore(useAssetStore(), s => { var _a; return (path ? (_a = s.models[path]) !== null && _a !== void 0 ? _a : null : null); });
+}
+/** Subscribe to a single loaded texture; re-renders only when that texture changes. */
+export function useTextureAsset(path) {
+    return useStore(useAssetStore(), s => { var _a; return (path ? (_a = s.textures[path]) !== null && _a !== void 0 ? _a : null : null); });
+}
+/** Subscribe to a single loaded sound; re-renders only when that sound changes. */
+export function useSoundAsset(path) {
+    return useStore(useAssetStore(), s => { var _a; return (path ? (_a = s.sounds[path]) !== null && _a !== void 0 ? _a : null : null); });
+}
+/** Subscribe to the full model map (only needed by the instancing root). */
+export function useAllModels() {
+    return useStore(useAssetStore(), s => s.models);
+}
+/** Coarse "an asset was (un)registered" signal. */
+export function useAssetRevision() {
+    return useStore(useAssetStore(), s => s.version);
+}
 export function useAssetRuntime() {
     const ctx = useContext(AssetRuntimeContext);
     if (!ctx)
@@ -35,3 +68,84 @@ export function NodeScope({ nodeId, editMode, isSelected, children, }) {
     }), [asset, editMode, isSelected, nodeId]);
     return _jsx(NodeContext.Provider, { value: value, children: children });
 }
+/**
+ * Recursive provider: if an AssetRuntime is already present above, this is a
+ * pass-through. Otherwise this layer becomes the owner and allocates state.
+ */
+export function AssetRuntimeProvider({ children, runtimeRef }) {
+    const inherited = useContext(AssetRuntimeContext);
+    if (inherited !== null) {
+        if (runtimeRef)
+            runtimeRef.current = inherited;
+        return children;
+    }
+    return _jsx(AssetRuntimeOwner, { runtimeRef: runtimeRef, children: children });
+}
+function AssetRuntimeOwner({ children, runtimeRef }) {
+    const [assetStore] = useState(createAssetStore);
+    const objectRefs = useRef({});
+    const nodeHandles = useRef(new Map());
+    const registerObject = useCallback((id, obj) => {
+        if (obj)
+            objectRefs.current[id] = obj;
+        else
+            delete objectRefs.current[id];
+    }, []);
+    const registerHandle = 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]]));
+    }, []);
+    const registerModel = useCallback((path, model) => {
+        if (assetStore.getState().models[path] === model)
+            return;
+        assetStore.setState(s => ({ models: Object.assign(Object.assign({}, s.models), { [path]: model }), version: s.version + 1 }));
+    }, [assetStore]);
+    const registerTexture = useCallback((path, texture) => {
+        if (assetStore.getState().textures[path] === texture)
+            return;
+        assetStore.setState(s => ({ textures: Object.assign(Object.assign({}, s.textures), { [path]: texture }), version: s.version + 1 }));
+    }, [assetStore]);
+    const registerSound = useCallback((path, sound) => {
+        soundManager.setBuffer(path, sound);
+        if (assetStore.getState().sounds[path] === sound)
+            return;
+        assetStore.setState(s => ({ sounds: Object.assign(Object.assign({}, s.sounds), { [path]: sound }), version: s.version + 1 }));
+    }, [assetStore]);
+    const getObject = useCallback((id) => { var _a; return (_a = objectRefs.current[id]) !== null && _a !== void 0 ? _a : null; }, []);
+    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 getModel = useCallback((path) => { var _a; return (_a = assetStore.getState().models[path]) !== null && _a !== void 0 ? _a : null; }, [assetStore]);
+    const getTexture = useCallback((path) => { var _a; return (_a = assetStore.getState().textures[path]) !== null && _a !== void 0 ? _a : null; }, [assetStore]);
+    const getSound = useCallback((path) => { var _a; return (_a = assetStore.getState().sounds[path]) !== null && _a !== void 0 ? _a : null; }, [assetStore]);
+    const getAssetRevision = useCallback(() => assetStore.getState().version, [assetStore]);
+    // Stable runtime: all members have stable identity, so consumers that only
+    // use imperative getters/registrars never re-render on asset loads. The
+    // live maps are exposed as snapshot getters for imperative readers; reactive
+    // consumers use the selector hooks (useModelAsset, useAllModels, ...).
+    const runtime = useMemo(() => ({
+        get models() { return assetStore.getState().models; },
+        get textures() { return assetStore.getState().textures; },
+        get sounds() { return assetStore.getState().sounds; },
+        registerObject, registerHandle,
+        registerModel, registerTexture, registerSound,
+        getObject, getHandle, getModel, getTexture, getSound,
+        getAssetRevision,
+    }), [assetStore, registerObject, registerHandle, registerModel, registerTexture, registerSound, getObject, getHandle, getModel, getTexture, getSound, getAssetRevision]);
+    if (runtimeRef)
+        runtimeRef.current = runtime;
+    return (_jsx(AssetStoreContext.Provider, { value: assetStore, children: _jsx(AssetRuntimeContext.Provider, { value: runtime, children: children }) }));
+}

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

@@ -1,11 +1,11 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Environment } from '@react-three/drei';
 import { FieldGroup, NumberField } from './Input';
-import { useAssetRuntime } from '../assetRuntime';
+import { useAssetRevision } from '../assetRuntime';
 function EnvironmentView({ properties, children, }) {
-    const { getAssetRevision } = useAssetRuntime();
+    const assetRevision = useAssetRevision();
     const { intensity = 1, resolution = 256 } = properties;
-    const environmentRevision = `${getAssetRevision()}::${intensity}::${resolution}`;
+    const environmentRevision = `${assetRevision}::${intensity}::${resolution}`;
     return (_jsx(Environment, { background: true, environmentIntensity: intensity, resolution: resolution, frames: 1, children: children }, environmentRevision));
 }
 const EnvironmentComponent = {