@needle-tools/engine 4.1.0-beta.6 → 4.1.0-beta.8

package/src/engine/engine_context.ts

@@ -158,6 +158,8 @@ export class Context implements IContext {
 		// Note: this is due to a bug on OSX devices. See NE-5370
 		powerPreference: (DeviceUtilities.isiOS() || DeviceUtilities.isMacOS()) ? "default" : "high-performance",
 		stencil: true,
+		// logarithmicDepthBuffer: true,
+		// reverseDepthBuffer: true, // https://github.com/mrdoob/three.js/issues/29770
 	};
 	/** The default parameters that will be used when creating a new WebGLRenderer.  
 	 * Modify in global context to change the default parameters for all new contexts.

package/src/engine/engine_gameobject.ts

@@ -1,5 +1,6 @@
 import { Bone, Object3D, Quaternion, SkinnedMesh, Vector3 } from "three";
 
+import { type AssetReference } from "./engine_addressables.js";
 import { __internalNotifyObjectDestroyed as __internalRemoveReferences, disposeObjectResources } from "./engine_assetdatabase.js";
 import { ComponentLifecycleEvents } from "./engine_components_internal.js";
 import { activeInHierarchyFieldName } from "./engine_constants.js";
@@ -10,7 +11,7 @@ import { InstantiateIdProvider } from "./engine_networking_instantiate.js";
 import { assign } from "./engine_serialization_core.js";
 import { Context, registerComponent } from "./engine_setup.js";
 import { logHierarchy, setWorldPosition, setWorldQuaternion } from "./engine_three_utils.js";
-import { type Constructor, type GuidsMap, type IComponent as Component, type IComponent, IEventList,type IGameObject as GameObject, type UIDProvider } from "./engine_types.js";
+import { type Constructor, type GuidsMap, type IComponent as Component, type IComponent, IEventList, type IGameObject as GameObject, type UIDProvider } from "./engine_types.js";
 import { getParam, tryFindObject } from "./engine_utils.js";
 import { apply } from "./js-extensions/index.js";
 
@@ -307,9 +308,17 @@ declare type InstantiateReferenceMap = Record<string, ObjectCloneReference>;
  */
 export declare type InstantiateContext = Readonly<InstantiateReferenceMap>;
 
-export function instantiate(instance: GameObject | Object3D, opts: IInstantiateOptions | null = null): GameObject {
+export function instantiate(instance: AssetReference, opts?: IInstantiateOptions | null): Promise<Object3D | null>
+export function instantiate(instance: GameObject | Object3D, opts?: IInstantiateOptions | null): GameObject
+export function instantiate(instance: AssetReference | GameObject | Object3D, opts?: IInstantiateOptions | null | undefined): GameObject | Promise<Object3D | null> {
+
+    if ("isAssetReference" in instance) {
+        return instance.instantiate(opts ?? undefined);
+    }
+
     let options: InstantiateOptions | null = null;
-    if (opts !== null) {
+
+    if (opts !== null && opts !== undefined) {
         // if x is defined assume this is a vec3 - this is just to not break everything at once and stay a little bit backwards compatible
         if (opts["x"] !== undefined) {
             options = new InstantiateOptions();

package/src/engine/engine_input.ts

@@ -36,8 +36,15 @@ export const enum InputEvents {
     KeyUp = "keyup",
     KeyPressed = "keypress"
 }
+
 /** e.g. `pointerdown` */
-export type InputEventNames = EnumToPrimitiveUnion<InputEvents>;
+type PointerEventNames = EnumToPrimitiveUnion<PointerEnumType>;
+type KeyboardEventNames = EnumToPrimitiveUnion<KeyboardEnumType>;
+export type InputEventNames = PointerEventNames | KeyboardEventNames;
+
+declare type PointerEventListener = (evt: NEPointerEvent) => void;
+declare type KeyboardEventListener = (evt: NEKeyboardEvent) => void;
+declare type InputEventListener = PointerEventListener | KeyboardEventListener;
 
 
 
@@ -217,10 +224,6 @@ export class KeyEventArgs {
 
 
 
-declare type PointerEventListener = (evt: NEPointerEvent) => void;
-declare type KeyboardEventListener = (evt: NEKeyboardEvent) => void;
-declare type InputEventListener = PointerEventListener | KeyboardEventListener;
-
 export enum InputEventQueue {
     Early = -100,
     Default = 0,
@@ -254,6 +257,8 @@ export class Input implements IInput {
      * @param callback The callback to call when the event is triggered
      * @param options The options for adding the event listener 
      */
+    addEventListener(type: PointerEventNames, callback: PointerEventListener, options?: EventListenerOptions);
+    addEventListener(type: KeyboardEventNames, callback: KeyboardEventListener, options?: EventListenerOptions);
     addEventListener(type: InputEvents | InputEventNames, callback: InputEventListener, options?: EventListenerOptions): void {
         if (!this._eventListeners[type]) this._eventListeners[type] = [];
 
@@ -284,6 +289,8 @@ export class Input implements IInput {
      * @param callback The callback to remove
      * @param options The options for removing the event listener 
      */
+    removeEventListener(type: PointerEventNames, callback: PointerEventListener, options?: EventListenerOptions);
+    removeEventListener(type: KeyboardEventNames, callback: KeyboardEventListener, options?: EventListenerOptions);
     removeEventListener(type: InputEvents | InputEventNames, callback: InputEventListener, options?: EventListenerOptions): void {
         if (!this._eventListeners[type]) return;
         if (!callback) return;

package/src/engine/engine_license.ts

@@ -6,6 +6,8 @@ import { getParam } from "./engine_utils.js";
 
 const debug = getParam("debuglicense");
 
+const _licenseCheckResultChangedCallbacks: ((result: boolean) => void)[] = [];
+
 // This is modified by a bundler (e.g. vite)
 // Do not edit manually
 let NEEDLE_ENGINE_LICENSE_TYPE: string = "basic";
@@ -36,7 +38,6 @@ export function hasCommercialLicense() {
     return hasProLicense() || hasIndieLicense();
 }
 
-const _licenseCheckResultChangedCallbacks: ((result: boolean) => void)[] = [];
 
 /** @internal */
 export function onLicenseCheckResultChanged(cb: (result: boolean) => void) {

package/src/engine/engine_networking_instantiate.ts

@@ -350,7 +350,7 @@ function instantiateSeeded(obj: GameObject, opts: IInstantiateOptions | null): {
     return { seed: seed, instance: instance };
 }
 
-export declare type PrefabProviderCallback = (guid: string) => Promise<GameObject | null>;
+export declare type PrefabProviderCallback = (guid: string) => Promise<Object3D | null>;
 
 const registeredPrefabProviders: { [key: string]: PrefabProviderCallback } = {};
 

package/src/engine/webcomponents/needle menu/needle-menu.ts

@@ -1,7 +1,7 @@
 import type { Context } from "../../engine_context.js";
 import { hasCommercialLicense, onLicenseCheckResultChanged } from "../../engine_license.js";
 import { isLocalNetwork } from "../../engine_networking_utils.js";
-import { DeviceUtilities,getParam } from "../../engine_utils.js";
+import { DeviceUtilities, getParam } from "../../engine_utils.js";
 import { onXRSessionStart, XRSessionEventArgs } from "../../xr/events.js";
 import { ButtonsFactory } from "../buttons.js";
 import { ensureFonts, iconFontUrl, loadFont } from "../fonts.js";
@@ -256,7 +256,12 @@ export class NeedleMenuElement extends HTMLElement {
         if (!element && domElement.shadowRoot) {
             element = domElement.shadowRoot.querySelector(elementName);
         }
+        // if no needle-menu was found in the domelement then we search the document body
         if (!element) {
+            element = window.document.body.querySelector(elementName) as NeedleMenuElement | null;
+        }
+        if (!element) {
+            // OK no menu element exists yet anywhere
             element = NeedleMenuElement.create() as NeedleMenuElement;
             if (domElement.shadowRoot)
                 domElement.shadowRoot.appendChild(element);
@@ -682,14 +687,15 @@ export class NeedleMenuElement extends HTMLElement {
         });
 
         try {
-        // if the user has a license then we CAN hide the needle logo
-        onLicenseCheckResultChanged(res => {
-            if (res == true && hasCommercialLicense() && !debugNonCommercial) {
-                let visible = this._userRequestedLogoVisible;
-                if(visible === undefined) visible = false;
-                this.#onSetLogoVisible(visible);
-            }
-        });
+            // if the user has a license then we CAN hide the needle logo
+            // calling this method immediately will cause an issue with vite bundling tho
+            window.requestAnimationFrame(() => onLicenseCheckResultChanged(res => {
+                if (res == true && hasCommercialLicense() && !debugNonCommercial) {
+                    let visible = this._userRequestedLogoVisible;
+                    if (visible === undefined) visible = false;
+                    this.#onSetLogoVisible(visible);
+                }
+            }));
         } catch (e) {
             console.error("[Needle Menu] License check failed.", e);
         }
@@ -824,7 +830,7 @@ export class NeedleMenuElement extends HTMLElement {
         this.logoContainer.style.display = "";
         this.logoContainer.style.opacity = "1";
         this.logoContainer.style.visibility = "visible";
-        if(visible) { 
+        if (visible) {
             this.root.classList.remove("logo-hidden");
             this.root.classList.add("logo-visible");
         }

package/src/engine-components/AvatarLoader.ts

@@ -52,7 +52,7 @@ export class AvatarLoader {
             if (!root) {
                 const opts = new InstantiateOptions();
                 // opts.parent = context.scene.uuid;
-                root = GameObject.instantiate(utils.tryFindObject(avatarId, context.scene), opts);
+                root = GameObject.instantiate(utils.tryFindObject(avatarId, context.scene) as Object3D, opts);
             }
         }
         else root = avatarId;

package/src/engine-components/Component.ts

@@ -1,6 +1,7 @@
 import { Euler, Object3D, Quaternion, Scene, Vector3 } from "three";
 
 import { isDevEnvironment } from "../engine/debug/index.js";
+import { type AssetReference } from "../engine/engine_addressables.js";
 import { addComponent, destroyComponentInstance, findObjectOfType, findObjectsOfType, getComponent, getComponentInChildren, getComponentInParent, getComponents, getComponentsInChildren, getComponentsInParent, getOrAddComponent, removeComponent } from "../engine/engine_components.js";
 import { activeInHierarchyFieldName } from "../engine/engine_constants.js";
 import { destroy, findByGuid, foreachComponent, HideFlags, type IInstantiateOptions, instantiate, isActiveInHierarchy, isActiveSelf, isDestroyed, isUsingInstancing, markAsInstancedRendered, setActive } from "../engine/engine_gameobject.js";
@@ -117,15 +118,20 @@ export abstract class GameObject extends Object3D implements Object3D, IGameObje
      */
     public static instantiateSynced(instance: GameObject | Object3D | null, opts: SyncInstantiateOptions): GameObject | null {
         if (!instance) return null;
-        return syncInstantiate(instance as any, opts) as GameObject | null;
+        return syncInstantiate(instance, opts) as GameObject | null;
     }
 
     /** Creates a new instance of the provided object (like cloning it including all components and children) 
      * @param instance object to instantiate
      * @param opts options for the instantiation (e.g. with what parent, position, etc.)
     */
-    public static instantiate(instance: GameObject | Object3D, opts: IInstantiateOptions | null = null): GameObject {
-        return instantiate(instance, opts) as GameObject;
+    public static instantiate(instance: AssetReference, opts?: IInstantiateOptions | null | undefined): Promise<Object3D | null>
+    public static instantiate(instance: GameObject | Object3D, opts?: IInstantiateOptions | null | undefined): GameObject
+    public static instantiate(instance: AssetReference | GameObject | Object3D, opts: IInstantiateOptions | null | undefined = null): GameObject | Promise<Object3D | null> {
+        if ('isAssetReference' in instance) {
+            return instantiate(instance as AssetReference, opts);
+        }
+        return instantiate(instance as GameObject | Object3D, opts) as GameObject;
     }
 
     /** Destroys a object on all connected clients (if you are in a networked session) 

package/src/engine-components/SceneSwitcher.ts

@@ -760,7 +760,7 @@ export class SceneSwitcher extends Behaviour {
             }
             this._lastLoadingScene = this.loadingScene;
             if (!this._loadingScenePromise) {
-                this._loadingScenePromise = this.loadingScene?.loadAssetAsync();
+                this._loadingScenePromise = this.loadingScene?.loadAssetAsync().then(res => res != null);
             }
             await this._loadingScenePromise;
             if (this._isCurrentlyLoading && this.loadingScene?.asset) {

package/src/engine-components/webxr/Avatar.ts

@@ -101,7 +101,7 @@ export class Avatar extends Behaviour {
             headObj.quaternion.x *= -1;
 
             // HACK: XRFlag limitation workaround to make sure first person user head is never rendered
-            if (this.context.time.frameCount % 10 === 0) {
+            if (this.context.time.frameCount % 10 === 0 && this.head.asset) {
                 const xrflags = GameObject.getComponentsInChildren(this.head.asset, XRFlag);
                 for (const flag of xrflags) {
                     flag.enabled = false;
@@ -242,9 +242,9 @@ export class Avatar extends Behaviour {
         await this.loadAvatarObjects(this.head, this.leftHand, this.rightHand);
 
         this._leftHandMeshes = [];
-        this.leftHand.asset.traverse((obj) => { if ((obj as Mesh)?.isMesh) this._leftHandMeshes!.push(obj); });
+        this.leftHand.asset?.traverse((obj) => { if ((obj as Mesh)?.isMesh) this._leftHandMeshes!.push(obj as Mesh); });
         this._rightHandMeshes = [];
-        this.rightHand.asset.traverse((obj) => { if ((obj as Mesh)?.isMesh) this._rightHandMeshes!.push(obj); });
+        this.rightHand.asset?.traverse((obj) => { if ((obj as Mesh)?.isMesh) this._rightHandMeshes!.push(obj as Mesh); });
 
         if (PlayerState.isLocalPlayer(this.gameObject)) {
             this._syncTransforms = GameObject.getComponentsInChildren(this.gameObject, SyncedTransform);

package/src/engine-components/webxr/WebXRImageTracking.ts

@@ -4,6 +4,7 @@ import { Object3DEventMap } from "three";
 import { isDevEnvironment, showBalloonWarning } from "../../engine/debug/index.js";
 import { AssetReference } from "../../engine/engine_addressables.js";
 import { serializable } from "../../engine/engine_serialization.js";
+import { IGameObject } from "../../engine/engine_types.js";
 import { CircularBuffer, DeviceUtilities, getParam } from "../../engine/engine_utils.js";
 import { type NeedleXREventArgs, NeedleXRSession } from "../../engine/xr/api.js";
 import { IUSDExporterExtension } from "../../engine-components/export/usdz/Extension.js";
@@ -355,7 +356,7 @@ export class WebXRImageTracking extends Behaviour {
         }
     }
 
-    private readonly imageToObjectMap = new Map<WebXRImageTrackingModel, { object: GameObject | null, frames: number, lastTrackingTime: number }>();
+    private readonly imageToObjectMap = new Map<WebXRImageTrackingModel, { object: Object3D | null, frames: number, lastTrackingTime: number }>();
     private readonly currentImages: WebXRTrackedImage[] = [];
 
     
@@ -456,7 +457,7 @@ export class WebXRImageTracking extends Behaviour {
                 trackedData = { object: null, frames: 0, lastTrackingTime: Date.now() };
                 this.imageToObjectMap.set(model, trackedData);
 
-                model.object.loadAssetAsync().then((asset: GameObject | null) => {
+                model.object.loadAssetAsync().then((asset: Object3D | null) => {
                     if (model.createObjectInstance && asset) {
                         asset = GameObject.instantiate(asset);
                     }
@@ -475,7 +476,7 @@ export class WebXRImageTracking extends Behaviour {
                         if (xr.rig) {
                             xr.rig.gameObject.add(asset);
                             image.applyToObject(asset);
-                            if (!asset.activeSelf)
+                            if (!(asset as IGameObject).activeSelf)
                                 GameObject.setActive(asset, true);
                             // InstancingUtil.markDirty(asset);
                         }
@@ -503,7 +504,7 @@ export class WebXRImageTracking extends Behaviour {
                     xr.rig.gameObject.add(trackedData.object);
 
                     image.applyToObject(trackedData.object, this.smooth ? this.context.time.deltaTimeUnscaled * 3 : undefined);
-                    if (!trackedData.object.activeSelf) {
+                    if (!(trackedData.object as IGameObject).activeSelf) {
                         GameObject.setActive(trackedData.object, true);
                     }
                     // InstancingUtil.markDirty(trackedData.object);

package/src/engine-components-experimental/networking/PlayerSync.ts

@@ -36,7 +36,7 @@ export class PlayerSync extends Behaviour {
         const assetReference = AssetReference.getOrCreateFromUrl(url);
         if (!assetReference.asset) {
             const i = await assetReference.loadAssetAsync();
-            GameObject.getOrAddComponent(i, PlayerState);
+            if(i) GameObject.getOrAddComponent(i, PlayerState);
         }
         const ps = new PlayerSync();
         ps._internalInit(init);