react-three-game 0.0.84 → 0.0.86

package/dist/tools/prefabeditor/runtime.js

@@ -1,184 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useContext, useMemo } from "react";
-import { getComponentDef } from "./components/ComponentRegistry";
-import { createScene } from "./scene";
-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 });
-}
-export function createRuntimeEngine({ store, getObject, getRigidBody, }) {
-    const scene = createScene({
-        getRootId: () => store.getState().rootId,
-        getNode: (id) => { var _a; return (_a = store.getState().nodesById[id]) !== null && _a !== void 0 ? _a : null; },
-        getChildIds: (id) => { var _a; return (_a = store.getState().childIdsById[id]) !== null && _a !== void 0 ? _a : []; },
-        getParentId: (id) => { var _a; return (_a = store.getState().parentIdById[id]) !== null && _a !== void 0 ? _a : null; },
-        updateNode: (id, update) => store.getState().updateNode(id, update),
-        updateNodes: (updates) => {
-            store.getState().updateNodes(Object.entries(updates).map(([id, update]) => ({ id, update })));
-        },
-        addNode: (node, options) => {
-            var _a;
-            const parentId = (_a = options === null || options === void 0 ? void 0 : options.parentId) !== null && _a !== void 0 ? _a : store.getState().rootId;
-            store.getState().addChild(parentId, node);
-            return node.id;
-        },
-        removeNode: (id) => store.getState().deleteNode(id),
-        getObject,
-        getRigidBody,
-    });
-    // key = `${nodeId}:${componentKey}:${componentType}`
-    const instances = new Map();
-    let active = false;
-    let dirty = true;
-    let lastRevision = store.getState().revision;
-    const unsubscribe = store.subscribe((state) => {
-        if (state.revision === lastRevision)
-            return;
-        lastRevision = state.revision;
-        dirty = true;
-    });
-    function destroy(key) {
-        var _a, _b;
-        const record = instances.get(key);
-        if (!record)
-            return;
-        try {
-            (_b = (_a = record.instance).destroy) === null || _b === void 0 ? void 0 : _b.call(_a);
-        }
-        catch (error) {
-            console.error(`[runtime] destroy ${key}`, error);
-        }
-        instances.delete(key);
-    }
-    function sync() {
-        const state = store.getState();
-        const live = new Set();
-        let hasPendingMount = false;
-        const visit = (nodeId) => {
-            var _a, _b, _c;
-            const node = state.nodesById[nodeId];
-            if (!node)
-                return;
-            if (!node.disabled && node.components) {
-                for (const componentKey in node.components) {
-                    const data = node.components[componentKey];
-                    if (!(data === null || data === void 0 ? void 0 : data.type))
-                        continue;
-                    const def = getComponentDef(data.type);
-                    if (!(def === null || def === void 0 ? void 0 : def.create))
-                        continue;
-                    const key = `${nodeId}:${componentKey}:${data.type}`;
-                    live.add(key);
-                    const object = getObject(nodeId);
-                    if (!object) {
-                        hasPendingMount = true;
-                        continue;
-                    }
-                    const rigidBody = getRigidBody(nodeId);
-                    const existing = instances.get(key);
-                    if (existing && existing.object === object && existing.rigidBody === rigidBody) {
-                        continue;
-                    }
-                    if (existing) {
-                        destroy(key);
-                    }
-                    const entity = scene.find(nodeId);
-                    const component = entity === null || entity === void 0 ? void 0 : entity.getComponent(componentKey);
-                    if (!entity || !component)
-                        continue;
-                    let instance;
-                    try {
-                        instance = (_a = def.create({ scene, component, object, rigidBody })) !== null && _a !== void 0 ? _a : {};
-                    }
-                    catch (error) {
-                        console.error(`[runtime] create ${key}`, error);
-                        continue;
-                    }
-                    instances.set(key, { instance, object, rigidBody });
-                    try {
-                        (_b = instance.start) === null || _b === void 0 ? void 0 : _b.call(instance);
-                    }
-                    catch (error) {
-                        console.error(`[runtime] start ${key}`, error);
-                    }
-                }
-            }
-            for (const childId of (_c = state.childIdsById[nodeId]) !== null && _c !== void 0 ? _c : [])
-                visit(childId);
-        };
-        visit(state.rootId);
-        for (const key of Array.from(instances.keys())) {
-            if (!live.has(key))
-                destroy(key);
-        }
-        dirty = hasPendingMount;
-    }
-    return {
-        tick(dt) {
-            if (!active)
-                return;
-            if (dirty)
-                sync();
-            for (const [key, record] of instances) {
-                if (!record.instance.update)
-                    continue;
-                try {
-                    record.instance.update(dt);
-                }
-                catch (error) {
-                    console.error(`[runtime] update ${key}`, error);
-                }
-            }
-        },
-        setActive(nextActive) {
-            if (active === nextActive)
-                return;
-            active = nextActive;
-            dirty = true;
-            if (!active) {
-                for (const key of Array.from(instances.keys()))
-                    destroy(key);
-            }
-        },
-        invalidate() {
-            dirty = true;
-        },
-        dispose() {
-            active = false;
-            for (const key of Array.from(instances.keys()))
-                destroy(key);
-            unsubscribe();
-        },
-    };
-}