react-three-game 0.0.70 → 0.0.71

package/dist/tools/prefabeditor/prefabStore.js

@@ -1,19 +1,8 @@
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 import { createContext, createElement, useContext } from "react";
 import { subscribeWithSelector } from "zustand/middleware";
 import { useStore } from "zustand";
 import { createStore } from "zustand/vanilla";
-import { getComponentAssetRefs } from "./components/ComponentRegistry";
+import { collectAssetRefsForIds, collectSubtreeAssetRefs, collectSubtreeIds, cloneSubtree, createPrefabPatch, denormalizePrefab, insertSubtree, isDescendant, normalizePrefab, updateAssetRefsForNodeChange, } from "./prefab";
 const PrefabStoreContext = createContext(null);
 const EMPTY_CHILD_IDS = [];
 export function PrefabStoreProvider({ store, children, }) {
@@ -42,8 +31,8 @@ export function usePrefabChildIds(nodeId) {
     return usePrefabStore(state => { var _a; return nodeId ? (_a = state.childIdsById[nodeId]) !== null && _a !== void 0 ? _a : EMPTY_CHILD_IDS : EMPTY_CHILD_IDS; });
 }
 export function createPrefabStore(prefab) {
-    return createStore()(subscribeWithSelector((set, get) => (Object.assign(Object.assign({}, createDocumentState(prefab)), { replacePrefab: (nextPrefab) => {
-            set(createDocumentState(nextPrefab, get().revision + 1));
+    return createStore()(subscribeWithSelector((set, get) => (Object.assign(Object.assign({}, normalizePrefab(prefab)), { replacePrefab: (nextPrefab) => {
+            set(normalizePrefab(nextPrefab, get().revision + 1));
         }, updateNode: (id, update) => {
             const state = get();
             const node = state.nodesById[id];
@@ -53,7 +42,7 @@ export function createPrefabStore(prefab) {
             if (nextNode === node)
                 return;
             const nextAssetRefCounts = updateAssetRefsForNodeChange(state.assetRefCounts, node, nextNode);
-            set(createMutationPatch(state, {
+            set(createPrefabPatch(state, {
                 nodesById: Object.assign(Object.assign({}, state.nodesById), { [id]: nextNode }),
             }, nextAssetRefCounts));
         }, updateNodes: (updates) => {
@@ -75,7 +64,7 @@ export function createPrefabStore(prefab) {
             }
             if (!nextNodesById)
                 return;
-            set(createMutationPatch(state, { nodesById: nextNodesById }, nextAssetRefCounts));
+            set(createPrefabPatch(state, { nodesById: nextNodesById }, nextAssetRefCounts));
         }, addChild: (parentId, node) => {
             var _a;
             const state = get();
@@ -87,8 +76,11 @@ export function createPrefabStore(prefab) {
             const nextAssetRefCounts = Object.assign({}, state.assetRefCounts);
             insertSubtree(node, parentId, nextNodesById, nextChildIdsById, nextParentIdById);
             nextChildIdsById[parentId] = [...((_a = nextChildIdsById[parentId]) !== null && _a !== void 0 ? _a : []), node.id];
-            addAssetRefs(nextAssetRefCounts, collectSubtreeAssetRefs(node));
-            set(createMutationPatch(state, {
+            collectSubtreeAssetRefs(node).forEach(ref => {
+                var _a;
+                nextAssetRefCounts[ref] = ((_a = nextAssetRefCounts[ref]) !== null && _a !== void 0 ? _a : 0) + 1;
+            });
+            set(createPrefabPatch(state, {
                 nodesById: nextNodesById,
                 childIdsById: nextChildIdsById,
                 parentIdById: nextParentIdById,
@@ -106,14 +98,22 @@ export function createPrefabStore(prefab) {
             const nextChildIdsById = Object.assign({}, state.childIdsById);
             const nextParentIdById = Object.assign({}, state.parentIdById);
             const nextAssetRefCounts = Object.assign({}, state.assetRefCounts);
-            removeAssetRefs(nextAssetRefCounts, collectAssetRefsForIds(idsToDelete, state.nodesById));
+            collectAssetRefsForIds(idsToDelete, state.nodesById).forEach(ref => {
+                var _a;
+                const nextCount = ((_a = nextAssetRefCounts[ref]) !== null && _a !== void 0 ? _a : 0) - 1;
+                if (nextCount > 0) {
+                    nextAssetRefCounts[ref] = nextCount;
+                    return;
+                }
+                delete nextAssetRefCounts[ref];
+            });
             idsToDelete.forEach(nodeId => {
                 delete nextNodesById[nodeId];
                 delete nextChildIdsById[nodeId];
                 delete nextParentIdById[nodeId];
             });
             nextChildIdsById[parentId] = ((_a = nextChildIdsById[parentId]) !== null && _a !== void 0 ? _a : []).filter(childId => childId !== id);
-            set(createMutationPatch(state, {
+            set(createPrefabPatch(state, {
                 nodesById: nextNodesById,
                 childIdsById: nextChildIdsById,
                 parentIdById: nextParentIdById,
@@ -129,7 +129,7 @@ export function createPrefabStore(prefab) {
             const nextNodesById = Object.assign({}, state.nodesById);
             const nextChildIdsById = Object.assign({}, state.childIdsById);
             const nextParentIdById = Object.assign({}, state.parentIdById);
-            const duplicatedRootId = cloneSubtreeIntoMaps(id, parentId, state, nextNodesById, nextChildIdsById, nextParentIdById);
+            const duplicatedRootId = cloneSubtree(id, parentId, state, nextNodesById, nextChildIdsById, nextParentIdById);
             if (!duplicatedRootId)
                 return null;
             const siblings = [...((_a = nextChildIdsById[parentId]) !== null && _a !== void 0 ? _a : [])];
@@ -142,8 +142,11 @@ export function createPrefabStore(prefab) {
             }
             nextChildIdsById[parentId] = siblings;
             const nextAssetRefCounts = Object.assign({}, state.assetRefCounts);
-            addAssetRefs(nextAssetRefCounts, collectAssetRefsForIds(collectSubtreeIds(id, state.childIdsById), state.nodesById));
-            set(createMutationPatch(state, {
+            collectAssetRefsForIds(collectSubtreeIds(id, state.childIdsById), state.nodesById).forEach(ref => {
+                var _a;
+                nextAssetRefCounts[ref] = ((_a = nextAssetRefCounts[ref]) !== null && _a !== void 0 ? _a : 0) + 1;
+            });
+            set(createPrefabPatch(state, {
                 nodesById: nextNodesById,
                 childIdsById: nextChildIdsById,
                 parentIdById: nextParentIdById,
@@ -155,7 +158,7 @@ export function createPrefabStore(prefab) {
             if (!node)
                 return;
             const nextNode = Object.assign(Object.assign({}, node), { [key]: !node[key] });
-            set(createMutationPatch(state, {
+            set(createPrefabPatch(state, {
                 nodesById: Object.assign(Object.assign({}, state.nodesById), { [id]: nextNode }),
             }));
         }, moveNode: (draggedId, targetId, position) => {
@@ -194,152 +197,10 @@ export function createPrefabStore(prefab) {
                 destinationChildren.splice(targetIndex, 0, draggedId);
                 nextChildIdsById[destinationParentId] = destinationChildren;
             }
-            set(createMutationPatch(state, {
+            set(createPrefabPatch(state, {
                 childIdsById: nextChildIdsById,
                 parentIdById: nextParentIdById,
             }));
         } }))));
 }
-export function prefabStoreToPrefab(state) {
-    return {
-        id: state.prefabId,
-        name: state.prefabName,
-        root: denormalizeNode(state.rootId, state.nodesById, state.childIdsById),
-    };
-}
-function createDocumentState(prefab, revision = 0) {
-    const nodesById = {};
-    const childIdsById = {};
-    const parentIdById = {};
-    insertSubtree(prefab.root, null, nodesById, childIdsById, parentIdById);
-    const assetRefCounts = createAssetRefCounts(nodesById);
-    return {
-        prefabId: prefab.id,
-        prefabName: prefab.name,
-        rootId: prefab.root.id,
-        nodesById,
-        childIdsById,
-        parentIdById,
-        revision,
-        assetManifestKey: getAssetManifestKey(assetRefCounts),
-        assetRefCounts,
-    };
-}
-function createMutationPatch(state, patch, nextAssetRefCounts = state.assetRefCounts) {
-    const assetRefsChanged = nextAssetRefCounts !== state.assetRefCounts;
-    return Object.assign(Object.assign(Object.assign({}, patch), { revision: state.revision + 1 }), (assetRefsChanged ? {
-        assetRefCounts: nextAssetRefCounts,
-        assetManifestKey: getAssetManifestKey(nextAssetRefCounts),
-    } : null));
-}
-function denormalizeNode(id, nodesById, childIdsById) {
-    var _a;
-    const node = nodesById[id];
-    return Object.assign(Object.assign({}, node), { children: ((_a = childIdsById[id]) !== null && _a !== void 0 ? _a : []).map(childId => denormalizeNode(childId, nodesById, childIdsById)) });
-}
-function collectSubtreeIds(id, childIdsById) {
-    var _a;
-    const ids = [id];
-    for (const childId of (_a = childIdsById[id]) !== null && _a !== void 0 ? _a : []) {
-        ids.push(...collectSubtreeIds(childId, childIdsById));
-    }
-    return ids;
-}
-function insertSubtree(node, parentId, nodesById, childIdsById, parentIdById) {
-    var _a;
-    const { children } = node, nodeRecord = __rest(node, ["children"]);
-    nodesById[node.id] = nodeRecord;
-    childIdsById[node.id] = (_a = children === null || children === void 0 ? void 0 : children.map(child => child.id)) !== null && _a !== void 0 ? _a : [];
-    parentIdById[node.id] = parentId;
-    children === null || children === void 0 ? void 0 : children.forEach(child => insertSubtree(child, node.id, nodesById, childIdsById, parentIdById));
-}
-function cloneSubtreeIntoMaps(id, parentId, source, nodesById, childIdsById, parentIdById) {
-    var _a, _b;
-    const originalNode = source.nodesById[id];
-    if (!originalNode)
-        return null;
-    const clonedId = crypto.randomUUID();
-    const clonedNode = Object.assign(Object.assign({}, originalNode), { id: clonedId, name: `${(_a = originalNode.name) !== null && _a !== void 0 ? _a : originalNode.id} Copy` });
-    nodesById[clonedId] = clonedNode;
-    parentIdById[clonedId] = parentId;
-    const clonedChildIds = ((_b = source.childIdsById[id]) !== null && _b !== void 0 ? _b : [])
-        .map(childId => cloneSubtreeIntoMaps(childId, clonedId, source, nodesById, childIdsById, parentIdById))
-        .filter((childId) => Boolean(childId));
-    childIdsById[clonedId] = clonedChildIds;
-    return clonedId;
-}
-function isDescendant(id, potentialAncestorId, parentIdById) {
-    let currentId = id;
-    while (currentId) {
-        if (currentId === potentialAncestorId)
-            return true;
-        currentId = parentIdById[currentId];
-    }
-    return false;
-}
-function createAssetRefCounts(nodesById) {
-    const assetRefCounts = {};
-    Object.values(nodesById).forEach(node => addAssetRefs(assetRefCounts, getAssetRefs(node)));
-    return assetRefCounts;
-}
-function updateAssetRefsForNodeChange(assetRefCounts, currentNode, nextNode) {
-    const currentRefs = getAssetRefs(currentNode);
-    const nextRefs = getAssetRefs(nextNode);
-    if (sameStringArrays(currentRefs, nextRefs)) {
-        return assetRefCounts;
-    }
-    const nextAssetRefCounts = Object.assign({}, assetRefCounts);
-    removeAssetRefs(nextAssetRefCounts, currentRefs);
-    addAssetRefs(nextAssetRefCounts, nextRefs);
-    return nextAssetRefCounts;
-}
-function collectSubtreeAssetRefs(node) {
-    var _a;
-    const refs = getAssetRefs(node);
-    (_a = node.children) === null || _a === void 0 ? void 0 : _a.forEach(child => refs.push(...collectSubtreeAssetRefs(child)));
-    return refs;
-}
-function collectAssetRefsForIds(ids, nodesById) {
-    return ids.reduce((refs, id) => {
-        refs.push(...getAssetRefs(nodesById[id]));
-        return refs;
-    }, []);
-}
-function getAssetRefs(node) {
-    var _a;
-    const refs = [];
-    Object.values((_a = node === null || node === void 0 ? void 0 : node.components) !== null && _a !== void 0 ? _a : {}).forEach(component => {
-        var _a;
-        if (!(component === null || component === void 0 ? void 0 : component.type))
-            return;
-        for (const ref of getComponentAssetRefs(component.type, (_a = component.properties) !== null && _a !== void 0 ? _a : {})) {
-            refs.push(`${ref.type}:${ref.path}`);
-        }
-    });
-    return refs.sort();
-}
-function addAssetRefs(assetRefCounts, refs) {
-    refs.forEach(ref => {
-        var _a;
-        assetRefCounts[ref] = ((_a = assetRefCounts[ref]) !== null && _a !== void 0 ? _a : 0) + 1;
-    });
-}
-function removeAssetRefs(assetRefCounts, refs) {
-    refs.forEach(ref => {
-        var _a;
-        const nextCount = ((_a = assetRefCounts[ref]) !== null && _a !== void 0 ? _a : 0) - 1;
-        if (nextCount > 0) {
-            assetRefCounts[ref] = nextCount;
-            return;
-        }
-        delete assetRefCounts[ref];
-    });
-}
-function getAssetManifestKey(assetRefCounts) {
-    return Object.keys(assetRefCounts).sort().join("|");
-}
-function sameStringArrays(left, right) {
-    if (left.length !== right.length)
-        return false;
-    return left.every((value, index) => value === right[index]);
-}
+export const prefabStoreToPrefab = denormalizePrefab;

package/dist/tools/prefabeditor/{sceneApi.js → scene.js}

@@ -10,7 +10,7 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 import { findComponentEntry } from "./types";
-import { getComponentDef } from "./components/ComponentRegistry";
+import { createComponentData, createNode as createPrefabNode } from "./prefab";
 function missingNode(id) {
     throw new Error(`Scene node not found: ${id}`);
 }
@@ -136,11 +136,8 @@ export function createScene(adapter) {
                 return createComponent(id, componentKey, component.type);
             },
             addComponent(type, properties) {
-                var _a;
-                const def = getComponentDef(type);
                 const key = type.toLowerCase();
-                const props = (_a = properties !== null && properties !== void 0 ? properties : def === null || def === void 0 ? void 0 : def.defaultProperties) !== null && _a !== void 0 ? _a : {};
-                adapter.updateNode(id, node => (Object.assign(Object.assign({}, node), { components: Object.assign(Object.assign({}, node.components), { [key]: { type, properties: props } }) })));
+                adapter.updateNode(id, node => (Object.assign(Object.assign({}, node), { components: Object.assign(Object.assign({}, node.components), { [key]: createComponentData(type, properties) }) })));
                 return createComponent(id, key, type);
             },
             removeComponent(name) {
@@ -177,7 +174,6 @@ export function createScene(adapter) {
             return adapter.getRootId();
         },
         find(nameOrId) {
-            // Try by ID first, then by name
             if (adapter.getNode(nameOrId))
                 return createNode(nameOrId);
             const foundId = adapter.findByName(nameOrId);
@@ -185,14 +181,7 @@ export function createScene(adapter) {
         },
         get: getNode,
         create(name, components, options) {
-            const node = {
-                id: crypto.randomUUID(),
-                name,
-                components: Object.assign({ transform: {
-                        type: "Transform",
-                        properties: { position: [0, 0, 0], rotation: [0, 0, 0], scale: [1, 1, 1] },
-                    } }, components),
-            };
+            const node = createPrefabNode(name, components);
             return createNode(adapter.addNode(node, options));
         },
         update,

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

@@ -34,7 +34,3 @@ export declare function computeParentWorldMatrix(state: {
 }, targetId: string): Matrix4;
 /** Recursively update all IDs in a node tree */
 export declare function regenerateIds(node: GameObject): GameObject;
-/** Create a GameObject node for a 3D model file */
-export declare function createModelNode(filename: string, name?: string): GameObject;
-/** Create a GameObject node for an image as a textured plane */
-export declare function createImageNode(texturePath: string, name?: string): GameObject;

package/dist/tools/prefabeditor/utils.js

@@ -155,40 +155,3 @@ export function regenerateIds(node) {
     var _a;
     return Object.assign(Object.assign({}, node), { id: crypto.randomUUID(), children: (_a = node.children) === null || _a === void 0 ? void 0 : _a.map(regenerateIds) });
 }
-function createNode(path, name, extraComponents) {
-    return {
-        id: crypto.randomUUID(),
-        name: name !== null && name !== void 0 ? name : path.replace(/^.*[\/]/, '').replace(/\.[^.]+$/, ''),
-        components: Object.assign({ transform: {
-                type: 'Transform',
-                properties: { position: [0, 0, 0], rotation: [0, 0, 0], scale: [1, 1, 1] }
-            } }, extraComponents)
-    };
-}
-/** Create a GameObject node for a 3D model file */
-export function createModelNode(filename, name) {
-    return createNode(filename, name, {
-        model: {
-            type: 'Model',
-            properties: {
-                filename,
-                instanced: false,
-                repeat: false,
-                repeatAxes: [{ axis: 'x', count: 1, offset: 1 }]
-            }
-        }
-    });
-}
-/** Create a GameObject node for an image as a textured plane */
-export function createImageNode(texturePath, name) {
-    return createNode(texturePath, name, {
-        geometry: {
-            type: 'Geometry',
-            properties: { geometryType: 'plane', args: [1, 1] }
-        },
-        material: {
-            type: 'Material',
-            properties: { color: '#ffffff', texture: texturePath }
-        }
-    });
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-three-game",
-  "version": "0.0.70",
+  "version": "0.0.71",
   "description": "high performance 3D game engine built in React",
   "main": "dist/index.js",
   "module": "dist/index.js",