react-three-game 0.0.104 → 0.0.106

package/dist/plugins/crashcat/CrashcatRuntime.js

@@ -8,8 +8,9 @@ import { gameEvents } from "../../tools/prefabeditor/GameEvents";
 import { PrefabEditorMode, useScene } from "../../tools/prefabeditor/PrefabRoot";
 const SLEEP_TIME_BEFORE_REST = 0.1;
 const SLEEP_POINT_VELOCITY_THRESHOLD = 0.06;
-const MAX_PHYSICS_STEP_DELTA = 1 / 60;
+const FIXED_PHYSICS_STEP_DELTA = 1 / 60;
 const MAX_PHYSICS_CATCH_UP_DELTA = 1 / 10;
+const MAX_PHYSICS_STEPS_PER_FRAME = 4;
 let didRegisterCrashcat = false;
 function ensureCrashcatRegistered() {
     if (didRegisterCrashcat)
@@ -68,6 +69,7 @@ export function CrashcatRuntime({ debug = false, children }) {
     const bodiesRef = useRef(new Map());
     const bodyByIdRef = useRef(new Map());
     const apiRef = useRef(null);
+    const accumulatedDeltaRef = useRef(0);
     const [debugState] = useState(() => debug ? createDebugState() : null);
     const listener = useMemo(() => ({
         onContactAdded: (bodyA, bodyB, manifold) => {
@@ -131,8 +133,10 @@ export function CrashcatRuntime({ debug = false, children }) {
             getBody: (nodeId) => { var _a, _b; return (_b = (_a = bodies.get(nodeId)) === null || _a === void 0 ? void 0 : _a.body) !== null && _b !== void 0 ? _b : null; },
         };
         apiRef.current = runtimeApi;
+        accumulatedDeltaRef.current = 0;
         setCrashcatApi(runtimeApi);
         return () => {
+            accumulatedDeltaRef.current = 0;
             for (const entry of bodies.values()) {
                 rigidBody.remove(world, entry.body);
             }
@@ -152,11 +156,20 @@ export function CrashcatRuntime({ debug = false, children }) {
         const { world } = runtimeApi;
         const frameDelta = Math.min(delta, MAX_PHYSICS_CATCH_UP_DELTA);
         if (mode === PrefabEditorMode.Play) {
-            const stepCount = Math.max(1, Math.ceil(frameDelta / MAX_PHYSICS_STEP_DELTA));
-            const stepDelta = frameDelta / stepCount;
-            for (let stepIndex = 0; stepIndex < stepCount; stepIndex += 1) {
-                updateWorld(world, listener, stepDelta);
+            accumulatedDeltaRef.current += frameDelta;
+            let stepCount = 0;
+            while (accumulatedDeltaRef.current >= FIXED_PHYSICS_STEP_DELTA &&
+                stepCount < MAX_PHYSICS_STEPS_PER_FRAME) {
+                updateWorld(world, listener, FIXED_PHYSICS_STEP_DELTA);
+                accumulatedDeltaRef.current -= FIXED_PHYSICS_STEP_DELTA;
+                stepCount += 1;
             }
+            if (stepCount === MAX_PHYSICS_STEPS_PER_FRAME) {
+                accumulatedDeltaRef.current = Math.min(accumulatedDeltaRef.current, FIXED_PHYSICS_STEP_DELTA);
+            }
+        }
+        else {
+            accumulatedDeltaRef.current = 0;
         }
         if (debugState)
             debugRenderer.update(debugState, world);

package/dist/tools/prefabeditor/PrefabRoot.js

@@ -15,7 +15,7 @@ import { Euler, Matrix4 } from "three";
 import { useStore } from "zustand";
 import { useClickValid } from "./useClickValid";
 import { findComponent, getNodeUserData } from "./types";
-import { getComponentDef, getComponentAssetRefs, registerComponent } 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";
@@ -99,13 +99,12 @@ export const PrefabRoot = forwardRef(({ editMode, data, store, selectedId, onSel
     }
     const usesOwnedStore = resolvedStore === ownedStore;
     const rootId = useStore(resolvedStore, state => state.rootId);
-    const assetManifestKey = useStore(resolvedStore, state => state.assetManifestKey);
+    const assetRefCounts = useStore(resolvedStore, state => state.assetRefCounts);
     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 getModel = useCallback((path) => { var _a; return (_a = availableModels[path]) !== null && _a !== void 0 ? _a : null; }, [availableModels]);
-    const getTexture = useCallback((path) => { var _a; return (_a = availableTextures[path]) !== null && _a !== void 0 ? _a : null; }, [availableTextures]);
-    const getSound = useCallback((path) => { var _a; return (_a = availableSounds[path]) !== null && _a !== void 0 ? _a : null; }, [availableSounds]);
+    const getTexture = useCallback((path) => { var _a, _b; return (_b = (_a = injectedTextures[path]) !== null && _a !== void 0 ? _a : textures[path]) !== null && _b !== void 0 ? _b : null; }, [injectedTextures, textures]);
+    const getSound = useCallback((path) => { var _a, _b; return (_b = (_a = injectedSounds[path]) !== null && _a !== void 0 ? _a : sounds[path]) !== null && _b !== void 0 ? _b : null; }, [injectedSounds, sounds]);
+    const assetRevision = useMemo(() => `${Object.keys(textures).concat(Object.keys(injectedTextures)).sort().join('|')}::${Object.keys(availableModels).sort().join('|')}`, [availableModels, injectedTextures, textures]);
     const getObject = useCallback((id) => {
         var _a;
         return (_a = objectRefs.current[id]) !== null && _a !== void 0 ? _a : null;
@@ -173,40 +172,23 @@ export const PrefabRoot = forwardRef(({ editMode, data, store, selectedId, onSel
         }
     }, [data, resolvedStore, usesOwnedStore]);
     useEffect(() => {
-        void assetManifestKey;
-        const syncAssets = (snapshot = resolvedStore.getState()) => {
-            const modelsToLoad = new Set();
-            const texturesToLoad = new Set();
-            const soundsToLoad = new Set();
-            Object.values(snapshot.nodesById).forEach(node => {
-                var _a;
-                Object.values((_a = 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 : {})) {
-                        if (ref.type === 'model')
-                            modelsToLoad.add(ref.path);
-                        else if (ref.type === 'texture')
-                            texturesToLoad.add(ref.path);
-                        else if (ref.type === 'sound')
-                            soundsToLoad.add(ref.path);
-                    }
-                });
+        const loadAsset = (file, loaded, injected, failed, loader) => {
+            if (loaded[file] || injected[file] || loading.current.has(file) || failed.has(file))
+                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);
+                    failed.add(file);
+                }
             });
-            const loadAsset = (file, loaded, injected, failed, loader) => {
-                if (loaded[file] || injected[file] || loading.current.has(file) || failed.has(file))
-                    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);
-                        failed.add(file);
-                    }
-                });
-            };
-            modelsToLoad.forEach(file => {
+        };
+        Object.keys(assetRefCounts).forEach(entry => {
+            const separator = entry.indexOf(':');
+            const type = entry.slice(0, separator);
+            const file = entry.slice(separator + 1);
+            if (type === 'model') {
                 loadAsset(file, models, injectedModels, failedModels.current, path => loadModel(path).then(result => {
                     const loadedModel = result.model;
                     if (result.success && loadedModel) {
@@ -214,8 +196,8 @@ export const PrefabRoot = forwardRef(({ editMode, data, store, selectedId, onSel
                     }
                     return result;
                 }));
-            });
-            texturesToLoad.forEach(file => {
+            }
+            else if (type === 'texture') {
                 loadAsset(file, textures, injectedTextures, failedTextures.current, path => loadTexture(path).then(result => {
                     const loadedTexture = result.texture;
                     if (result.success && loadedTexture) {
@@ -223,8 +205,8 @@ export const PrefabRoot = forwardRef(({ editMode, data, store, selectedId, onSel
                     }
                     return result;
                 }));
-            });
-            soundsToLoad.forEach(file => {
+            }
+            else if (type === 'sound') {
                 loadAsset(file, sounds, injectedSounds, failedSounds.current, path => loadSound(path).then(result => {
                     const loadedSound = result.sound;
                     if (result.success && loadedSound) {
@@ -233,10 +215,9 @@ export const PrefabRoot = forwardRef(({ editMode, data, store, selectedId, onSel
                     }
                     return result;
                 }));
-            });
-        };
-        syncAssets();
-    }, [resolvedStore, assetManifestKey, basePath, injectedModels, injectedSounds, injectedTextures, models, sounds, textures]);
+            }
+        });
+    }, [assetRefCounts, basePath, injectedModels, injectedSounds, injectedTextures, models, sounds, textures]);
     const assetRuntime = useMemo(() => ({
         registerHandle,
         getHandle,
@@ -244,8 +225,8 @@ export const PrefabRoot = forwardRef(({ editMode, data, store, selectedId, onSel
         getModel,
         getTexture,
         getSound,
-        getAssetRevision: () => `${Object.keys(availableTextures).sort().join('|')}::${Object.keys(availableModels).sort().join('|')}`,
-    }), [registerHandle, getHandle, getObject, getModel, getTexture, getSound, availableModels, availableTextures]);
+        getAssetRevision: () => assetRevision,
+    }), [registerHandle, getHandle, getObject, getModel, getTexture, getSound, assetRevision]);
     const handleNodeClick = useCallback((event, nodeId, fallbackObject) => {
         const node = resolvedStore.getState().nodesById[nodeId];
         if (!node)

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

@@ -66,18 +66,19 @@ function GeometryComponentEditor({ component, onUpdate, }) {
 // View for Geometry component
 function GeometryComponentView({ properties, children }) {
     const { geometryType, args = [] } = properties;
+    const geometryKey = `${geometryType !== null && geometryType !== void 0 ? geometryType : 'box'}:${JSON.stringify(args)}`;
     // Only return the geometry node, do not wrap in mesh or group
     switch (geometryType) {
         case "box":
-            return _jsx("boxGeometry", { args: args });
+            return _jsx("boxGeometry", { args: args }, geometryKey);
         case "sphere":
-            return _jsx("sphereGeometry", { args: args });
+            return _jsx("sphereGeometry", { args: args }, geometryKey);
         case "plane":
-            return _jsx("planeGeometry", { args: args });
+            return _jsx("planeGeometry", { args: args }, geometryKey);
         case "cylinder":
-            return _jsx("cylinderGeometry", { args: args });
+            return _jsx("cylinderGeometry", { args: args }, geometryKey);
         default:
-            return _jsx("boxGeometry", { args: [1, 1, 1] });
+            return _jsx("boxGeometry", { args: [1, 1, 1] }, "box:[1,1,1]");
     }
 }
 const GeometryComponent = {

package/dist/tools/prefabeditor/prefab.js

@@ -185,7 +185,7 @@ export function cloneSubtree(id, parentId, source, nodesById, childIdsById, pare
     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` });
+    const clonedNode = Object.assign(Object.assign({}, originalNode), { components: clonePrefabValue(originalNode.components), 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 : [])

package/package.json

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