react-three-game 0.0.92 → 0.0.94

package/dist/tools/prefabeditor/InstanceProvider.js

@@ -1,20 +1,9 @@
-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 { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import React, { createContext, useContext, useMemo, useRef, useState, useEffect, useCallback } from "react";
+import React, { createContext, useContext, useMemo, useRef, useState, useEffect } from "react";
 import { Merged, useHelper } from '@react-three/drei';
-import { InstancedRigidBodies } from "@react-three/rapier";
-import { ActiveCollisionTypes } from "@dimforge/rapier3d-compat";
-import { Mesh, Matrix4, Vector3, Quaternion, Euler, BoxHelper } from "three";
+import { Mesh, Matrix4, BoxHelper } from "three";
+import { useStore } from "zustand";
+import { createStore } from "zustand/vanilla";
 import { usePointerEvents } from "./usePointerEvents";
 export const DEFAULT_REPEAT_AXES = [{ axis: 'x', count: 1, offset: 1 }];
 export function normalizeRepeatAxes(value) {
@@ -81,66 +70,67 @@ function arrayEquals(a, b) {
     }
     return true;
 }
-function stableSerialize(value) {
-    if (Array.isArray(value)) {
-        return `[${value.map(stableSerialize).join(',')}]`;
-    }
-    if (value && typeof value === 'object') {
-        const entries = Object.entries(value)
-            .sort(([a], [b]) => a.localeCompare(b))
-            .map(([key, entry]) => `${key}:${stableSerialize(entry)}`);
-        return `{${entries.join(',')}}`;
-    }
-    return JSON.stringify(value);
-}
-function getPhysicsSignature(physics) {
-    return physics ? stableSerialize(physics) : 'none';
-}
-function hasPhysics(instance) {
-    return Boolean(instance.physics);
-}
-function getColliderType(physics) {
-    return physics.colliders || (physics.type === 'fixed' ? 'trimesh' : 'hull');
-}
 function instanceEquals(a, b) {
     return a.id === b.id &&
         a.sourceId === b.sourceId &&
         a.locked === b.locked &&
+        a.visible === b.visible &&
         a.meshPath === b.meshPath &&
         arrayEquals(a.position, b.position) &&
         arrayEquals(a.rotation, b.rotation) &&
-        arrayEquals(a.scale, b.scale) &&
-        getPhysicsSignature(a.physics) === getPhysicsSignature(b.physics);
+        arrayEquals(a.scale, b.scale);
 }
-const GameInstanceContext = createContext(null);
-export function GameInstanceProvider({ children, models, onSelect, registerRef, selectedId, editMode }) {
-    const [instances, setInstances] = useState([]);
-    const addInstance = useCallback((instance) => {
-        setInstances(prev => {
-            const idx = prev.findIndex(i => i.id === instance.id);
-            if (idx !== -1) {
-                // Update existing if changed
-                if (instanceEquals(prev[idx], instance)) {
-                    return prev;
-                }
-                const copy = [...prev];
-                copy[idx] = instance;
-                return copy;
+function createInstanceRegistryStore() {
+    return createStore()((set, get) => ({
+        instancesById: {},
+        sourceInstanceIdsById: {},
+        addInstance: (instance) => {
+            const previous = get().instancesById[instance.id];
+            if (previous && instanceEquals(previous, instance)) {
+                return;
             }
-            // Add new
-            return [...prev, instance];
-        });
-    }, []);
-    const removeInstance = useCallback((id) => {
-        setInstances(prev => {
-            if (!prev.find(i => i.id === id))
-                return prev;
-            return prev.filter(i => i.id !== id);
-        });
-    }, []);
-    const hasInstance = useCallback((id) => {
-        return instances.some(i => i.id === id || i.sourceId === id);
-    }, [instances]);
+            set(state => {
+                var _a, _b;
+                const instancesById = Object.assign(Object.assign({}, state.instancesById), { [instance.id]: instance });
+                const sourceInstanceIdsById = Object.assign({}, state.sourceInstanceIdsById);
+                if (previous && previous.sourceId !== previous.id) {
+                    const previousSourceInstances = Object.assign({}, ((_a = sourceInstanceIdsById[previous.sourceId]) !== null && _a !== void 0 ? _a : {}));
+                    delete previousSourceInstances[previous.id];
+                    sourceInstanceIdsById[previous.sourceId] = Object.keys(previousSourceInstances).length > 0
+                        ? previousSourceInstances
+                        : undefined;
+                }
+                if (instance.sourceId !== instance.id) {
+                    sourceInstanceIdsById[instance.sourceId] = Object.assign(Object.assign({}, ((_b = sourceInstanceIdsById[instance.sourceId]) !== null && _b !== void 0 ? _b : {})), { [instance.id]: true });
+                }
+                return { instancesById, sourceInstanceIdsById };
+            });
+        },
+        removeInstance: (id) => {
+            const previous = get().instancesById[id];
+            if (!previous)
+                return;
+            set(state => {
+                var _a;
+                const instancesById = Object.assign({}, state.instancesById);
+                const sourceInstanceIdsById = Object.assign({}, state.sourceInstanceIdsById);
+                delete instancesById[id];
+                if (previous.sourceId !== previous.id) {
+                    const sourceInstances = Object.assign({}, ((_a = sourceInstanceIdsById[previous.sourceId]) !== null && _a !== void 0 ? _a : {}));
+                    delete sourceInstances[id];
+                    sourceInstanceIdsById[previous.sourceId] = Object.keys(sourceInstances).length > 0
+                        ? sourceInstances
+                        : undefined;
+                }
+                return { instancesById, sourceInstanceIdsById };
+            });
+        },
+    }));
+}
+const GameInstanceContext = createContext(null);
+export function GameInstanceProvider({ children, models, onSelect, onClick, registerRef, selectedId, editMode }) {
+    const [instanceStore] = useState(createInstanceRegistryStore);
+    const instancesById = useStore(instanceStore, state => state.instancesById);
     // Flatten all model meshes once (models → flat mesh parts)
     // Note: Geometry is cloned with baked transforms for instancing
     const { flatMeshes, modelParts } = useMemo(() => {
@@ -170,13 +160,14 @@ export function GameInstanceProvider({ children, models, onSelect, registerRef,
             Object.values(flatMeshes).forEach(mesh => mesh.geometry.dispose());
         };
     }, [flatMeshes]);
-    // Group instances by meshPath and physics presence for batch rendering.
+    const instances = useMemo(() => Object.values(instancesById), [instancesById]);
+    // Group instances by meshPath for batched rendering.
     const grouped = useMemo(() => {
         const groups = {};
         for (const inst of instances) {
-            const key = `${inst.meshPath}__${inst.physics ? 'physics' : 'visual'}`;
+            const key = inst.meshPath;
             if (!groups[key])
-                groups[key] = { hasPhysics: Boolean(inst.physics), instances: [] };
+                groups[key] = { instances: [] };
             groups[key].instances.push(inst);
         }
         Object.values(groups).forEach(group => {
@@ -184,146 +175,45 @@ export function GameInstanceProvider({ children, models, onSelect, registerRef,
         });
         return groups;
     }, [instances]);
-    return (_jsxs(GameInstanceContext.Provider, { value: {
-            addInstance,
-            removeInstance,
-            instances,
-            meshes: flatMeshes,
-            modelParts,
-            hasInstance
-        }, children: [children, Object.entries(grouped).map(([key, group]) => {
-                if (!group.hasPhysics)
-                    return null;
+    const contextValue = useMemo(() => ({
+        store: instanceStore,
+        meshes: flatMeshes,
+        modelParts,
+    }), [instanceStore, flatMeshes, modelParts]);
+    return (_jsxs(GameInstanceContext.Provider, { value: contextValue, children: [children, Object.entries(grouped).map(([key, group]) => {
                 const modelKey = group.instances[0].meshPath;
                 const partCount = modelParts[modelKey] || 0;
                 if (partCount === 0)
                     return null;
-                return (_jsx(InstancedRigidGroup, { group: group, modelKey: modelKey, partCount: partCount, flatMeshes: flatMeshes, onSelect: onSelect, editMode: editMode }, key));
-            }), Object.entries(grouped).map(([key, group]) => {
-                if (group.hasPhysics)
-                    return null;
-                const modelKey = group.instances[0].meshPath;
-                const partCount = modelParts[modelKey] || 0;
-                if (partCount === 0)
-                    return null;
-                // Create mesh subset for this specific model
                 const meshesForModel = {};
                 for (let i = 0; i < partCount; i++) {
                     const partKey = `${modelKey}__${i}`;
                     meshesForModel[partKey] = flatMeshes[partKey];
                 }
-                return (_jsx(Merged, { meshes: meshesForModel, castShadow: true, receiveShadow: true, children: (instancesMap) => (_jsx(NonPhysicsInstancedGroup, { modelKey: modelKey, group: group, partCount: partCount, instancesMap: instancesMap, onSelect: onSelect, registerRef: registerRef, selectedId: selectedId, editMode: editMode })) }, key));
+                return (_jsx(Merged, { meshes: meshesForModel, castShadow: true, receiveShadow: true, children: (instancesMap) => (_jsx(InstancedGroup, { modelKey: modelKey, group: group, partCount: partCount, instancesMap: instancesMap, onSelect: onSelect, onClick: onClick, registerRef: registerRef, selectedId: selectedId, editMode: editMode })) }, key));
             })] }));
 }
-// Render physics-enabled instances using InstancedRigidBodies
-function InstancedRigidGroup({ group, modelKey, partCount, flatMeshes, onSelect, editMode }) {
-    const meshRefs = useRef([]);
-    const rigidBodiesRef = useRef(null);
-    const instances = useMemo(() => group.instances.filter(hasPhysics).map(inst => {
-        const _a = inst.physics, { activeCollisionTypes: _activeCollisionTypes, colliders: _colliders, userData } = _a, rigidBodyProps = __rest(_a, ["activeCollisionTypes", "colliders", "userData"]);
-        return Object.assign(Object.assign({ key: inst.id, position: inst.position, rotation: inst.rotation, scale: inst.scale }, rigidBodyProps), { colliders: getColliderType(inst.physics), userData: Object.assign(Object.assign({}, userData), { entityId: inst.sourceId }) });
-    }), [group.instances]);
-    // Apply scale to visual meshes (InstancedRigidBodies only scales colliders, not visuals)
-    useEffect(() => {
-        const matrix = new Matrix4();
-        const pos = new Vector3();
-        const quat = new Quaternion();
-        const euler = new Euler();
-        const scl = new Vector3();
-        meshRefs.current.forEach(mesh => {
-            if (!mesh)
-                return;
-            group.instances.forEach((inst, i) => {
-                pos.set(...inst.position);
-                euler.set(...inst.rotation);
-                quat.setFromEuler(euler);
-                scl.set(...inst.scale);
-                matrix.compose(pos, quat, scl);
-                mesh.setMatrixAt(i, matrix);
-            });
-            mesh.instanceMatrix.needsUpdate = true;
-        });
-        // Update rigid body positions when instances change
-        if (rigidBodiesRef.current) {
-            try {
-                group.instances.forEach((inst, i) => {
-                    var _a;
-                    const body = (_a = rigidBodiesRef.current) === null || _a === void 0 ? void 0 : _a[i];
-                    if (body && body.setTranslation && body.setRotation) {
-                        pos.set(...inst.position);
-                        euler.set(...inst.rotation);
-                        quat.setFromEuler(euler);
-                        body.setTranslation(pos, false);
-                        body.setRotation(quat, false);
-                    }
-                });
-            }
-            catch (error) {
-                // Ignore errors when switching between instanced/non-instanced states
-                console.warn('Failed to update rigidbody positions:', error);
-            }
-        }
-    }, [group.instances]);
-    useEffect(() => {
-        group.instances.forEach((inst, i) => {
-            var _a, _b;
-            if (!inst.physics || inst.physics.activeCollisionTypes !== 'all')
-                return;
-            const body = (_a = rigidBodiesRef.current) === null || _a === void 0 ? void 0 : _a[i];
-            if (!body || !body.numColliders || !body.collider)
-                return;
-            for (let colliderIndex = 0; colliderIndex < body.numColliders(); colliderIndex++) {
-                const collider = body.collider(colliderIndex);
-                (_b = collider.setActiveCollisionTypes) === null || _b === void 0 ? void 0 : _b.call(collider, ActiveCollisionTypes.DEFAULT |
-                    ActiveCollisionTypes.KINEMATIC_FIXED |
-                    ActiveCollisionTypes.KINEMATIC_KINEMATIC);
-            }
-        });
-    }, [group.instances]);
-    // Handle click on instanced mesh in edit mode
-    const handleClick = (e) => {
-        const instanceId = e.instanceId;
-        const instance = instanceId !== undefined ? group.instances[instanceId] : undefined;
-        if (!instance)
-            return;
-        if (editMode) {
-            if (!onSelect || instance.locked)
-                return;
-            e.stopPropagation();
-            onSelect(instance.sourceId);
-            return;
-        }
-    };
-    const shouldHandleClick = editMode;
-    // Add key to force remount when instance count changes significantly (helps with cleanup)
-    const rigidBodyKey = `rb_${modelKey}_${group.instances.map(inst => `${inst.id}:${getPhysicsSignature(inst.physics)}`).join('|')}`;
-    return (_jsx(InstancedRigidBodies, { ref: rigidBodiesRef, instances: instances, children: Array.from({ length: partCount }).map((_, i) => {
-            const mesh = flatMeshes[`${modelKey}__${i}`];
-            if (!mesh)
-                return null;
-            return (_jsx("instancedMesh", { ref: el => { meshRefs.current[i] = el; }, args: [mesh.geometry, mesh.material, group.instances.length], castShadow: true, receiveShadow: true, frustumCulled: false, onClick: shouldHandleClick ? handleClick : undefined }, i));
-        }) }, rigidBodyKey));
-}
-// Render non-physics instances using Merged (instancing without rigid bodies)
-function NonPhysicsInstancedGroup({ modelKey, group, partCount, instancesMap, onSelect, registerRef, selectedId, editMode }) {
-    // Pre-compute which Instance components exist for this model
+function InstancedGroup({ modelKey, group, partCount, instancesMap, onSelect, onClick, registerRef, selectedId, editMode }) {
     const InstanceComponents = useMemo(() => Array.from({ length: partCount }, (_, i) => instancesMap[`${modelKey}__${i}`]).filter(Boolean), [instancesMap, modelKey, partCount]);
-    return (_jsx(_Fragment, { children: group.instances.map(inst => (_jsx(InstanceGroupItem, { instance: inst, InstanceComponents: InstanceComponents, onSelect: onSelect, registerRef: registerRef, selectedId: selectedId, editMode: editMode }, inst.id))) }));
+    const visibleInstances = useMemo(() => group.instances.filter(instance => instance.visible !== false), [group.instances]);
+    return (_jsx(_Fragment, { children: visibleInstances.map(inst => (_jsx(InstanceGroupItem, { instance: inst, InstanceComponents: InstanceComponents, onSelect: onSelect, onClick: onClick, registerRef: registerRef, selectedId: selectedId, editMode: editMode }, inst.id))) }));
 }
 // Individual instance item with its own click state
-function InstanceGroupItem({ instance, InstanceComponents, onSelect, registerRef, selectedId, editMode }) {
+function InstanceGroupItem({ instance, InstanceComponents, onSelect, onClick, registerRef, selectedId, editMode }) {
     const groupRef = useRef(null);
     const isLocked = Boolean(instance.locked);
     const isSelected = selectedId === instance.id || selectedId === instance.sourceId;
     const canSelect = editMode && !isLocked;
-    const canClick = false;
+    const canClick = !editMode && Boolean(onClick);
     const pointerHandlers = usePointerEvents({
         enabled: canSelect || canClick,
-        entity: instance,
-        onClick: () => {
+        node: instance,
+        onClick: (event) => {
             if (editMode) {
                 onSelect === null || onSelect === void 0 ? void 0 : onSelect(instance.sourceId);
+                return;
             }
+            onClick === null || onClick === void 0 ? void 0 : onClick(event, instance.sourceId, groupRef.current);
         },
     });
     // Use BoxHelper when object is selected in edit mode
@@ -336,34 +226,29 @@ function InstanceGroupItem({ instance, InstanceComponents, onSelect, registerRef
     }, [editMode, instance.id, registerRef]);
     return (_jsx("group", Object.assign({ ref: groupRef, position: instance.position, rotation: instance.rotation, scale: instance.scale }, pointerHandlers, { children: InstanceComponents.map((Instance, i) => _jsx(Instance, {}, i)) })));
 }
-// Hook to check if an instance exists
 export function useInstanceCheck(id) {
-    var _a;
     const ctx = useContext(GameInstanceContext);
-    return (_a = ctx === null || ctx === void 0 ? void 0 : ctx.hasInstance(id)) !== null && _a !== void 0 ? _a : false;
+    return ctx ? useStore(ctx.store, state => Boolean(state.instancesById[id] || state.sourceInstanceIdsById[id])) : false;
 }
-// GameInstance component: registers an instance for batch rendering (renders nothing itself)
-export const GameInstance = React.forwardRef(({ id, sourceId, modelUrl, locked = false, position, rotation, scale, physics = undefined, }, ref) => {
+export const GameInstance = React.forwardRef(({ id, sourceId, modelUrl, locked = false, position, rotation, scale, visible = true, onClick: _onClick, }, ref) => {
     const ctx = useContext(GameInstanceContext);
-    const addInstance = ctx === null || ctx === void 0 ? void 0 : ctx.addInstance;
-    const removeInstance = ctx === null || ctx === void 0 ? void 0 : ctx.removeInstance;
     const [positionX, positionY, positionZ] = position;
     const [rotationX, rotationY, rotationZ] = rotation;
     const [scaleX, scaleY, scaleZ] = scale;
-    const physicsSignature = getPhysicsSignature(physics);
     const instance = useMemo(() => ({
         id,
         sourceId: sourceId !== null && sourceId !== void 0 ? sourceId : id,
         locked,
+        visible,
         meshPath: modelUrl,
         position,
         rotation,
         scale,
-        physics,
     }), [
         id,
         sourceId,
         locked,
+        visible,
         modelUrl,
         positionX,
         positionY,
@@ -374,16 +259,16 @@ export const GameInstance = React.forwardRef(({ id, sourceId, modelUrl, locked =
         scaleX,
         scaleY,
         scaleZ,
-        physicsSignature,
     ]);
     useEffect(() => {
-        if (!addInstance || !removeInstance)
+        if (!ctx)
             return;
+        const store = ctx.store;
+        const { addInstance, removeInstance } = store.getState();
         addInstance(instance);
         return () => {
             removeInstance(instance.id);
         };
-    }, [addInstance, removeInstance, instance]);
-    // No visual rendering - provider handles all instanced visuals
+    }, [ctx === null || ctx === void 0 ? void 0 : ctx.store, instance]);
     return null;
 });

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

@@ -1,31 +1,21 @@
 import GameCanvas from "../../shared/GameCanvas";
-import { Object3D, Texture } from "three";
-import { GameObject, Prefab } from "./types";
+import { Prefab } from "./types";
+import { PrefabEditorMode, type Scene } from "./PrefabRoot";
 import type { ExportGLBOptions } from "./utils";
-import { type PrefabStoreApi } from "./prefabStore";
-import type { SpawnOptions } from "./scene";
-export interface PrefabEditorRef {
-    root: Object3D | null;
-    store: PrefabStoreApi;
-    getObject: (nodeId: string) => Object3D | null;
-    getRigidBody: (nodeId: string) => any;
-    screenshot: () => void;
-    exportGLB: (options?: ExportGLBOptions) => Promise<ArrayBuffer | undefined>;
-    exportGLBData: () => Promise<ArrayBuffer | undefined>;
-    clearSelection: () => Promise<void>;
+export interface PrefabEditorRef extends Scene {
     save: () => Prefab;
     load: (prefab: Prefab, options?: {
         resetHistory?: boolean;
         notifyChange?: boolean;
     }) => void;
-    addNode: (node: GameObject, options?: SpawnOptions) => GameObject;
-    addModel: (path: string, model: Object3D, options?: SpawnOptions) => GameObject;
-    addTexture: (path: string, texture: Texture, options?: SpawnOptions) => GameObject;
-}
-export declare enum PrefabEditorMode {
-    Edit = "edit",
-    Play = "play"
+    undo: () => void;
+    redo: () => void;
+    screenshot: () => void;
+    exportGLB: (options?: ExportGLBOptions) => Promise<ArrayBuffer | undefined>;
+    exportGLBData: () => Promise<ArrayBuffer | undefined>;
+    clearSelection: () => Promise<void>;
 }
+export type { PrefabNode } from "./PrefabRoot";
 export interface EditorContextType {
     mode: PrefabEditorMode;
     setMode: (mode: PrefabEditorMode) => void;
@@ -42,11 +32,12 @@ export interface EditorContextType {
     onExportGLB?: () => void;
 }
 export declare const EditorContext: import("react").Context<EditorContextType | null>;
+export declare const EditorRefContext: import("react").Context<PrefabEditorRef | null>;
 export declare function useEditorContext(): EditorContextType;
+export declare function useEditorRef(): PrefabEditorRef;
 export interface PrefabEditorProps {
     basePath?: string;
     initialPrefab?: Prefab;
-    physics?: boolean;
     mode?: PrefabEditorMode;
     onChange?: (prefab: Prefab) => void;
     showUI?: boolean;