@needle-tools/engine 3.30.0 → 3.31.1

package/src/engine/engine_addressables.ts

@@ -1,5 +1,5 @@
-import { getParam, resolveUrl } from "../engine/engine_utils.js";
-import { SerializationContext, TypeSerializer } from "./engine_serialization_core.js";
+import { deepClone, getParam, resolveUrl } from "../engine/engine_utils.js";
+import { SerializationContext, TypeSerializer, assign } from "./engine_serialization_core.js";
 import { Context } from "./engine_setup.js";
 import { Group, Object3D, Texture, TextureLoader } from "three";
 import { processNewScripts } from "./engine_mainloop_utils.js";
@@ -7,7 +7,7 @@ import { registerPrefabProvider, syncInstantiate } from "./engine_networking_ins
 import { download } from "./engine_web_api.js";
 import { getLoader } from "./engine_gltf.js";
 import type { IComponent, IGameObject, SourceIdentifier } from "./engine_types.js";
-import { destroy, instantiate, InstantiateOptions, isDestroyed } from "./engine_gameobject.js";
+import { destroy, IInstantiateOptions, instantiate, InstantiateOptions, isDestroyed } from "./engine_gameobject.js";
 
 const debug = getParam("debugaddressables");
 
@@ -245,12 +245,12 @@ export class AssetReference {
     }
 
     /** loads and returns a new instance of `asset` */
-    async instantiate(parent?: Object3D | InstantiateOptions) {
+    async instantiate(parent?: Object3D | IInstantiateOptions) {
         return this.onInstantiate(parent, false);
     }
 
     /** loads and returns a new instance of `asset` - this call is networked so an instance will be created on all connected users */
-    async instantiateSynced(parent?: Object3D | InstantiateOptions, saveOnServer: boolean = true) {
+    async instantiateSynced(parent?: Object3D | IInstantiateOptions, saveOnServer: boolean = true) {
         return this.onInstantiate(parent, true, saveOnServer);
     }
 
@@ -272,32 +272,30 @@ export class AssetReference {
         }
     }
 
-    private async onInstantiate(parent?: Object3D | InstantiateOptions, networked: boolean = false, saveOnServer?: boolean) {
+    private async onInstantiate(opts?: Object3D | IInstantiateOptions, networked: boolean = false, saveOnServer?: boolean) {
         const context = Context.Current;
+
+        // clone the instantiate options immediately
+        // in case the user is not awaiting this call and already modifying the options
+        const options = new InstantiateOptions();
+        if (opts instanceof Object3D) {
+            options.parent = opts;
+        }
+        else if (opts) {
+            options.cloneAssign(opts);
+        }
+        if (!options.parent) options.parent = context.scene;
+
+        // ensure the asset is loaded
         if (this.mustLoad) {
             await this.loadAssetAsync();
         }
         if (debug)
-            console.log("Instantiate", this.uri, "parent:", parent);
+            console.log("Instantiate", this.uri, "parent:", opts);
 
         if (this.asset) {
             if (debug) console.log("Add to scene", this.asset);
 
-            let options = parent instanceof InstantiateOptions ? parent : null;
-            if (!options) {
-                options = new InstantiateOptions();
-            }
-
-            if (typeof parent === "object") {
-                if (parent instanceof Object3D) {
-                    options.parent = parent;
-                }
-                else {
-                    Object.assign(options, parent);
-                }
-            }
-            if (!options.parent) options.parent = context.scene;
-
             let count = AssetReference.currentlyInstantiating.get(this.uri);
             // allow up to 10000 instantiations of the same prefab in the same frame
             if (count !== undefined && count >= 10000) {

package/src/engine/engine_gameobject.ts

@@ -28,21 +28,50 @@ export enum HideFlags {
     HideAndDontSave = DontSave | NotEditable | HideInHierarchy, // 0x0000003D
 }
 
+export type IInstantiateOptions = {
+    idProvider?: UIDProvider;
+    //** parent guid or object */
+    parent?: string | Object3D;
+    position?: Vector3;
+    /** for duplicatable parenting */
+    keepWorldPosition?: boolean;
+    rotation?: Quaternion;
+    scale?: Vector3;
+    /** if the instantiated object should be visible */
+    visible?: boolean;
+    context?: Context;
+}
 
-export class InstantiateOptions {
+export class InstantiateOptions implements IInstantiateOptions {
     idProvider?: UIDProvider | undefined;
-
-    //** parent guid */
     parent?: string | undefined | Object3D;
-    /** for duplicatable parenting */
     keepWorldPosition?: boolean
     position?: Vector3 | undefined;
     rotation?: Quaternion | undefined;
     scale?: Vector3 | undefined;
-
     visible?: boolean | undefined;
-
     context?: Context | undefined;
+
+    clone(){
+        const clone = new InstantiateOptions();
+        clone.idProvider = this.idProvider;
+        clone.parent = this.parent;
+        clone.keepWorldPosition = this.keepWorldPosition;
+        clone.position = this.position?.clone();
+        clone.rotation = this.rotation?.clone();
+        clone.scale = this.scale?.clone();
+        return clone;
+    }
+
+    /** Copy fields from another object, clone field references */
+    cloneAssign(other: InstantiateOptions | IInstantiateOptions){
+        this.idProvider = other.idProvider;
+        this.parent = other.parent;
+        this.keepWorldPosition = other.keepWorldPosition;
+        this.position = other.position?.clone();
+        this.rotation = other.rotation?.clone();
+        this.scale = other.scale?.clone();
+    }
 }
 
 
@@ -237,7 +266,7 @@ declare class NewGameObjectReferenceInfo {
     clone: Object3D;
 }
 
-export function instantiate(instance: GameObject | Object3D | null, opts: InstantiateOptions | null = null): GameObject | null {
+export function instantiate(instance: GameObject | Object3D | null, opts: IInstantiateOptions | null = null): GameObject | null {
     if (instance === null) return null;
 
     let options: InstantiateOptions | null = null;
@@ -256,6 +285,7 @@ export function instantiate(instance: GameObject | Object3D | null, opts: Instan
             // }
         }
     }
+    console.log(options?.position)
 
     let context = Context.Current;
     if (options?.context) context = options.context;
@@ -311,7 +341,7 @@ export function instantiate(instance: GameObject | Object3D | null, opts: Instan
 
 
 function internalInstantiate(
-    context: Context, instance: GameObject | Object3D, opts: InstantiateOptions | null,
+    context: Context, instance: GameObject | Object3D, opts: IInstantiateOptions | InstantiateOptions | null,
     componentsList: Array<Component>,
     newGameObjectsMap: { [key: string]: NewGameObjectReferenceInfo },
     skinnedMeshesMap: { [key: string]: NewGameObjectReferenceInfo }

package/src/engine/engine_networking_instantiate.ts

@@ -11,7 +11,7 @@ import { v5 } from 'uuid';
 import type { UIDProvider } from "./engine_types.js";
 import type { IModel } from "./engine_networking_types.js";
 import { SendQueue } from "./engine_networking_types.js";
-import { destroy, findByGuid, instantiate } from "./engine_gameobject.js";
+import { IInstantiateOptions, destroy, findByGuid, instantiate } from "./engine_gameobject.js";
 import { Object3D } from "three";
 import { InstantiateOptions } from "./engine_gameobject.js";
 import { ContextEvent, ContextRegistry } from "../engine/engine_context_registry.js";
@@ -182,7 +182,7 @@ class NewInstanceModel implements IModel {
     }
 }
 
-export function syncInstantiate(object: GameObject | Object3D, opts: InstantiateOptions, hostData?: HostData, save?: boolean): GameObject | null {
+export function syncInstantiate(object: GameObject | Object3D, opts: IInstantiateOptions, hostData?: HostData, save?: boolean): GameObject | null {
 
     const obj: GameObject = object as GameObject;
 
@@ -285,7 +285,7 @@ export function beginListenInstantiate(context: Context) {
 
 }
 
-function instantiateSeeded(obj: GameObject, opts: InstantiateOptions | null): { instance: GameObject | null, seed: number } {
+function instantiateSeeded(obj: GameObject, opts: IInstantiateOptions | null): { instance: GameObject | null, seed: number } {
     const seed = generateSeed();
     const options = opts ?? new InstantiateOptions();
     options.idProvider = new InstantiateIdProvider(seed);

package/src/engine/engine_utils.ts

@@ -440,9 +440,9 @@ export function unwatchWrite(vec: Vector, cb: Function) {
 /** Is MacOS or Windows (and not hololens) */
 export function isDesktop() {
     const ua = window.navigator.userAgent;
-    const standalone = /Windows|MacOS/.test(ua);
+    const standalone = /Windows|MacOS|Mac OS/.test(ua);
     const isHololens = /Windows NT/.test(ua) && /Edg/.test(ua) && !/Win64/.test(ua);
-    return standalone && !isHololens;
+    return standalone && !isHololens && !isiOS();
 }
 
 export function isMobileDevice() {

package/src/engine-components/Component.ts

@@ -6,7 +6,7 @@ import * as main from "../engine/engine_mainloop_utils.js";
 import { syncDestroy, syncInstantiate } from "../engine/engine_networking_instantiate.js";
 import type { ConstructorConcrete, SourceIdentifier, IComponent, IGameObject, Constructor, GuidsMap, Collision, ICollider } from "../engine/engine_types.js";
 import { addNewComponent, destroyComponentInstance, findObjectOfType, findObjectsOfType, getComponent, getComponentInChildren, getComponentInParent, getComponents, getComponentsInChildren, getComponentsInParent, getOrAddComponent, moveComponentInstance, removeComponent } from "../engine/engine_components.js";
-import { findByGuid, destroy, InstantiateOptions, instantiate, HideFlags, foreachComponent, markAsInstancedRendered, isActiveInHierarchy, isActiveSelf, isUsingInstancing, setActive, isDestroyed } from "../engine/engine_gameobject.js";
+import { findByGuid, destroy, InstantiateOptions, instantiate, HideFlags, foreachComponent, markAsInstancedRendered, isActiveInHierarchy, isActiveSelf, isUsingInstancing, setActive, isDestroyed, IInstantiateOptions } from "../engine/engine_gameobject.js";
 
 import { Euler, Object3D, Quaternion, Scene, Vector3 } from "three";
 import { showBalloonWarning, isDevEnvironment } from "../engine/debug/index.js";
@@ -72,7 +72,7 @@ export abstract class GameObject extends Object3D implements Object3D, IGameObje
      * @param instance object to instantiate
      * @param opts options for the instantiation
      */
-    public static instantiateSynced(instance: GameObject | Object3D | null, opts: InstantiateOptions): GameObject | null {
+    public static instantiateSynced(instance: GameObject | Object3D | null, opts: IInstantiateOptions): GameObject | null {
         if (!instance) return null;
         return syncInstantiate(instance as any, opts) as GameObject | null;
     }
@@ -81,7 +81,7 @@ export abstract class GameObject extends Object3D implements Object3D, IGameObje
      * @param instance object to instantiate
      * @param opts options for the instantiation (e.g. with what parent, position, etc.)
     */
-    public static instantiate(instance: GameObject | Object3D | null, opts: InstantiateOptions | null = null): GameObject | null {
+    public static instantiate(instance: GameObject | Object3D | null, opts: IInstantiateOptions | null = null): GameObject | null {
         return instantiate(instance, opts) as GameObject | null;
     }