@needle-tools/engine 4.8.7-next.e134730 → 4.8.8-next.12b5946

package/src/engine/engine_animation.ts

@@ -2,6 +2,7 @@ import { AnimationAction, AnimationClip, AnimationMixer, Object3D, PropertyBindi
 
 import type { Context } from "./engine_context.js";
 import { GLTF, IAnimationComponent, Model } from "./engine_types.js";
+import { TypeStore } from "./engine_typestore.js";
 
 /**
  * Registry for animation related data. Use {@link registerAnimationMixer} to register an animation mixer instance.  
@@ -88,12 +89,15 @@ export class AnimationUtils {
      * This method will look for objects in the scene that have animations and assign them to the correct objects.  
      * @param file The GLTF file to assign the animations from
      */
-    static assignAnimationsFromFile(file: Pick<Model, "animations" | "scene">, opts?: { createAnimationComponent(obj: Object3D, animation: AnimationClip): IAnimationComponent }) {
+    static autoplayAnimations(file: Object3D | Pick<Model, "animations" | "scene">): Array<IAnimationComponent> | null {
         if (!file || !file.animations) {
             console.debug("No animations found in file");
-            return;
+            return null;
         }
 
+        const scene = "scene" in file ? file.scene : file as Object3D;
+        const animationComponents = new Array<IAnimationComponent>();
+
         for (let i = 0; i < file.animations.length; i++) {
             const animation = file.animations[i];
             if (!animation.tracks || animation.tracks.length <= 0) {
@@ -103,12 +107,12 @@ export class AnimationUtils {
             for (const t in animation.tracks) {
                 const track = animation.tracks[t];
                 const parsedPath = PropertyBinding.parseTrackName(track.name);
-                let obj = PropertyBinding.findNode(file.scene, parsedPath.nodeName);
+                let obj = PropertyBinding.findNode(scene, parsedPath.nodeName);
                 if (!obj) {
                     const objectName = track["__objectName"] ?? track.name.substring(0, track.name.indexOf("."));
                     // let obj = gltf.scene.getObjectByName(objectName);
                     // this finds unnamed objects that still have tracks targeting them
-                    obj = file.scene.getObjectByProperty('uuid', objectName);
+                    obj = scene.getObjectByProperty('uuid', objectName);
 
                     if (!obj) {
                         // console.warn("could not find " + objectName, animation, gltf.scene);
@@ -116,32 +120,35 @@ export class AnimationUtils {
                     }
                 }
 
-                let animationComponent = findAnimationGameObjectInParent(obj);
+                let animationComponent = findAnimationComponentInParent(obj) || findAnimationComponentInParent(scene);
                 if (!animationComponent) {
-                    if (!opts?.createAnimationComponent) {
-                        console.warn("No AnimationComponent found in parent hierarchy of object and no 'createAnimationComponent' callback was provided in options.")
-                        continue;
+                    const anim = TypeStore.get("Animation");
+                    animationComponent = scene.addComponent(anim);
+                    if (!animationComponent) {
+                        console.error("Failed creating Animation component: No 'Animation' component found in TypeStore");
+                        break;
                     }
-                    animationComponent = opts.createAnimationComponent(file.scene, animation);
-                    obj.addComponent(animationComponent);
                 }
+                animationComponents.push(animationComponent);
                 if (animationComponent.addClip) {
                     animationComponent.addClip(animation);
                 }
             }
         }
-        function findAnimationGameObjectInParent(obj): IAnimationComponent | null {
+        return animationComponents;
+
+        function findAnimationComponentInParent(obj): IAnimationComponent | null {
             if (!obj) return null;
             const components = obj.userData?.components;
             if (components && components.length > 0) {
                 for (let i = 0; i < components.length; i++) {
                     const component = components[i] as IAnimationComponent;
                     if (component.isAnimationComponent === true) {
-                        return obj;
+                        return component;
                     }
                 }
             }
-            return findAnimationGameObjectInParent(obj.parent);
+            return findAnimationComponentInParent(obj.parent);
         }
     }
 }

package/src/engine/engine_assetdatabase.ts

@@ -61,7 +61,7 @@ export function disposeObjectResources(obj: object | null | undefined) {
         return;
     }
 
-    if(typeof obj === "object") {
+    if (typeof obj === "object") {
         obj[$disposed] = true;
     }
 
@@ -79,8 +79,8 @@ export function disposeObjectResources(obj: object | null | undefined) {
         disposeObjectResources(obj.bindMatrixInverse);
         disposeObjectResources(obj.customDepthMaterial);
         disposeObjectResources(obj.customDistanceMaterial);
-        obj.geometry = null;
-        obj.material = null;
+        obj.geometry = {};
+        obj.material = {};
         obj.visible = false;
     }
     else if (obj instanceof Mesh) {
@@ -88,8 +88,8 @@ export function disposeObjectResources(obj: object | null | undefined) {
         disposeObjectResources(obj.material);
         disposeObjectResources(obj.customDepthMaterial);
         disposeObjectResources(obj.customDistanceMaterial);
-        obj.geometry = null;
-        obj.material = null;
+        obj.geometry = {};
+        obj.material = {};
         obj.visible = false;
     }
     else if (obj instanceof BufferGeometry) {
@@ -175,8 +175,8 @@ function free(obj: any) {
 
 export function __internalNotifyObjectDestroyed(obj: Object3D) {
     if (obj instanceof Mesh || obj instanceof SkinnedMesh) {
-        obj.material = null;
-        obj.geometry = null;
+        obj.material = {};
+        obj.geometry = {};
     }
 }
 

package/src/engine/engine_camera.ts

@@ -1,5 +1,6 @@
-import { Camera, Object3D } from "three";
+import { Camera, HemisphereLightHelper, Object3D, PerspectiveCamera, Vector2, WebGLRenderer } from "three";
 
+import { Mathf } from "./engine_math.js";
 import type { ICameraController } from "./engine_types.js";
 
 
@@ -24,7 +25,11 @@ export function setCameraController(cam: Camera, cameraController: ICameraContro
 
 const autofit = "needle:autofit";
 
-/** @internal */
+/** 
+ * Used by e.g. getBoundingBox via ContactShadows or OrbitControls when fitting the camera or shadow planes. Objects can be marked to be excluded from bounding box calculations via `setAutoFitEnabled(obj, <bool>)`
+ * @see setAutoFitEnabled
+ * @internal 
+ */
 export function useForAutoFit(obj: Object3D): boolean {
     // if autofit is not defined we assume it may be included
     if (obj[autofit] === undefined) return true;
@@ -33,8 +38,54 @@ export function useForAutoFit(obj: Object3D): boolean {
 }
 
 /**
- * Enable or disable autofitting for the given object
+ * Enable or disable autofitting for the given object. Objects that are 'disabled' will be excluded in getBoundingBox calculations.   
+ * This is used by ContactShadows or OrbitControls when fitting the shadow plane or camera to the given objects or scene.
+ * @see useForAutoFit
  */
 export function setAutoFitEnabled(obj: Object3D, enabled: boolean): void {
     obj[autofit] = enabled;
+}
+
+
+
+export type FocusRectSettings = {
+    /** Lower values will result in faster alignment with the rect (value ~= seconds to reach target) 
+     * Minimum value is 0.
+     */
+    damping: number
+}
+export type FocusRect = DOMRect | Element | { x: number, y: number, width: number, height: number };
+
+let rendererRect: DOMRect | undefined = undefined;
+const overlapRect = { x: 0, y: 0, width: 0, height: 0 };
+
+/** Used internally by the Needle Engine context via 'setFocusRect(<rect>)'  */
+export function updateCameraFocusRect(focusRect: FocusRect, dt: number, camera: PerspectiveCamera, renderer: WebGLRenderer) {
+
+    if (focusRect instanceof Element) {
+        focusRect = focusRect.getBoundingClientRect();
+    }
+    rendererRect = renderer.domElement.getBoundingClientRect();
+
+    const rect = overlapRect;
+    rect.x = focusRect.x;
+    rect.y = focusRect.y;
+    rect.width = focusRect.width;
+    rect.height = focusRect.height;
+
+    rect.x -= rendererRect.x;
+    rect.y -= rendererRect.y;
+
+    const targetX = rect.width / -2 - (rect.x - (rendererRect.width / 2));
+    const targetY = rect.height / -2 - (rect.y - (rendererRect.height / 2));
+
+    const view = camera.view;
+
+    let offsetX = view?.offsetX || 0;
+    let offsetY = view?.offsetY || 0;
+    offsetX = Mathf.lerp(offsetX, targetX, dt);
+    offsetY = Mathf.lerp(offsetY, targetY, dt);
+
+    camera.setViewOffset(rendererRect.width, rendererRect.height, offsetX, offsetY, rendererRect.width, rendererRect.height);
+    camera.updateProjectionMatrix();
 }

package/src/engine/engine_context.ts

@@ -18,6 +18,7 @@ import { Addressables } from './engine_addressables.js';
 import { AnimationsRegistry } from './engine_animation.js';
 import { Application } from './engine_application.js';
 import { AssetDatabase } from './engine_assetdatabase.js';
+import { FocusRect, FocusRectSettings, updateCameraFocusRect } from './engine_camera.js';
 import { VERSION } from './engine_constants.js';
 import { ContextEvent, ContextRegistry } from './engine_context_registry.js';
 import { WaitForPromise } from './engine_coroutine.js';
@@ -1371,6 +1372,35 @@ export class Context implements IContext {
 		this.internalUpdatePhysics(steps);
 	}
 
+
+
+	/**
+	 * Set a rect or dom element. The camera center will be moved to the center of the rect.  
+	 * This is useful if you have Needle Engine embedded in a HTML layout and while you want the webgl background to fill e.g. the whole screen you want to move the camera center to free space.  
+	 * For that you can simply pass in the rect or HMTL div that you want the camera to center on.
+	 * @param rect The focus rect or null to disable
+	 * @param settings Optional settings for the focus rect. These will override the `focusRectSettings` property
+	 */
+	public setCameraFocusRect(rect: FocusRect | null, settings?: Partial<FocusRectSettings>) {
+		this._focusRect = rect;
+		if (settings) {
+			Object.assign(this.focusRectSettings, settings);
+		}
+	}
+	get focusRect() { return this._focusRect; }
+	/** Settings when a focus rect is set. Use `setCameraFocusRect(...)` to do so.  
+	 * This can be used to offset the renderer center e.g. to a specific DOM element.
+	 */
+	readonly focusRectSettings: FocusRectSettings = {
+		/** Controls how fast the rect is centered. Smaller values mean the rect is centered faster.   
+		 * A minimum value of 0 means the rect is centered instantly.
+		 * @default .05
+		*/
+		damping: .05
+	};
+	private _focusRect: FocusRect | null = null;
+
+
 	private _lastTimestamp = 0;
 	private _accumulatedTime = 0;
 	private _dispatchReadyAfterFrame = false;
@@ -1421,7 +1451,7 @@ export class Context implements IContext {
 
 		Context.Current = this;
 		this.time.update();
-		
+
 		if (debugframerate) console.log("FPS", (this.time.smoothedFps).toFixed(0));
 
 
@@ -1498,6 +1528,14 @@ export class Context implements IContext {
 
 		if (this.isVisibleToUser || this.runInBackground) {
 
+			if (this._focusRect) {
+				if (this.mainCamera instanceof PerspectiveCamera) {
+					const settings = this.focusRectSettings;
+					const dt = settings.damping > 0 ? this.time.deltaTime / settings.damping : 1;
+					updateCameraFocusRect(this._focusRect, dt, this.mainCamera, this.renderer);
+				}
+			}
+
 			this._currentFrameEvent = FrameEvent.OnBeforeRender;
 
 			// should we move these callbacks in the regular three onBeforeRender events?

package/src/engine/engine_create_objects.ts

@@ -42,13 +42,13 @@ export type ObjectOptions = {
     /**
      * The position of the object in local space
      */
-    position?: Vec3 | [number, number, number],
+    position?: Partial<Vec3> | [number, number, number],
     /** The rotation of the object in local space */
-    rotation?: Vec3 | [number, number, number],
+    rotation?: Partial<Vec3> | [number, number, number],
     /**
      * The scale of the object in local space
      */
-    scale?: Vec3 | number | [number, number, number],
+    scale?: Partial<Vec3> | number | [number, number, number],
     /**
      * If the object should receive shadows
      * @default true
@@ -251,14 +251,15 @@ export class ObjectUtils {
         if (opts?.position) {
             if (Array.isArray(opts.position))
                 obj.position.set(opts.position[0], opts.position[1], opts.position[2]);
-            else
-                obj.position.set(opts.position.x, opts.position.y, opts.position.z);
+            else {
+                obj.position.set(opts.position.x || 0, opts.position.y || 0, opts.position.z || 0);
+            }
         }
         if (opts?.rotation) {
             if (Array.isArray(opts.rotation))
                 obj.rotation.set(opts.rotation[0], opts.rotation[1], opts.rotation[2]);
             else
-                obj.rotation.set(opts.rotation.x, opts.rotation.y, opts.rotation.z);
+                obj.rotation.set(opts.rotation.x || 0, opts.rotation.y || 0, opts.rotation.z || 0);
         }
         if (opts?.scale) {
             if (typeof opts.scale === "number")
@@ -267,7 +268,7 @@ export class ObjectUtils {
                 obj.scale.set(opts.scale[0], opts.scale[1], opts.scale[2]);
             }
             else {
-                obj.scale.set(opts.scale.x, opts.scale.y, opts.scale.z);
+                obj.scale.set(opts.scale.x || 1, opts.scale.y || 1, opts.scale.z || 1);
 
             }
         }

package/src/engine/engine_gameobject.ts

@@ -166,9 +166,9 @@ export function destroy(instance: Object3D | Component, recursive: boolean = tru
         setDestroyed(obj, true);
         if (dispose) {
             disposeObjectResources(obj);
+            // This needs to be called after disposing because it removes the references to resources
+            __internalRemoveReferences(obj);
         }
-        // This needs to be called after disposing because it removes the references to resources
-        __internalRemoveReferences(obj);
     }
     destroyed_objects.length = 0;
     destroyed_components.length = 0;

package/src/engine/engine_gltf_builtin_components.ts

@@ -72,13 +72,13 @@ export async function createBuiltinComponents(context: Context, gltfId: SourceId
 
     if (gltf.scenes) {
         for (const scene of gltf.scenes) {
-            await onCreateBuiltinComponents(serializationContext, scene, deserializeQueue, lateResolve);
+            await onCreateBuiltinComponents(serializationContext, scene, deserializeQueue, lateResolve, 0);
         }
     }
     // TODO: when is the gltf here an object3d?
     if (gltf.children) {
         for (const ch of gltf.children) {
-            await onCreateBuiltinComponents(serializationContext, ch, deserializeQueue, lateResolve);
+            await onCreateBuiltinComponents(serializationContext, ch, deserializeQueue, lateResolve, 0);
         }
     }
 
@@ -202,7 +202,7 @@ const unknownComponentsBuffer: Array<string> = [];
 
 
 async function onCreateBuiltinComponents(context: SerializationContext, obj: Object3D,
-    deserialize: DeserializeData[], lateResolve: LateResolveCallback[]) {
+    deserialize: DeserializeData[], lateResolve: LateResolveCallback[], level: number) {
     if (!obj) return;
 
     // iterate injected data
@@ -267,20 +267,21 @@ async function onCreateBuiltinComponents(context: SerializationContext, obj: Obj
             }
             // console.debug("finished adding gltf builtin components", obj);
         }
-        if (unknownComponentsBuffer.length > 0) {
-            const unknown = unknownComponentsBuffer.join(", ");
-            console.warn("unknown components: " + unknown);
-            unknownComponentsBuffer.length = 0;
-            if (isLocalNetwork())
-                showBalloonMessage(`<strong>Unknown components in scene</strong>:\n\n${unknown}\n\nThis could mean you forgot to add a npmdef to your ExportInfo\n<a href="https://engine.needle.tools/docs/project_structure.html#creating-and-installing-a-npmdef" target="_blank">documentation</a>`, LogType.Warn);
-        }
     }
 
     if (obj.children) {
         for (const ch of obj.children) {
-            await onCreateBuiltinComponents(context, ch, deserialize, lateResolve);
+            await onCreateBuiltinComponents(context, ch, deserialize, lateResolve, level + 1);
         }
     }
+
+    if (unknownComponentsBuffer.length > 0 && level === 0) {
+        const unknown = unknownComponentsBuffer.join(", ");
+        console.warn(`Unknown components in scene: ${unknown}`);
+        unknownComponentsBuffer.length = 0;
+        if (isLocalNetwork())
+            showBalloonMessage(`<strong>Unknown components in scene</strong>:\n\n${unknown}\n\nThis could mean you forgot to add a npmdef to your ExportInfo\n<a href="https://engine.needle.tools/docs/project_structure.html#creating-and-installing-a-npmdef" target="_blank">documentation</a>`, LogType.Warn);
+    }
 }
 
 function handleDeserialization(data: DeserializeData, context: SerializationContext) {

package/src/engine/engine_loaders.callbacks.ts

@@ -98,6 +98,7 @@ export namespace NeedleEngineModelLoader {
      *     }
      *     return null;
      * });
+     * ```
      */
     export function onCreateCustomModelLoader(callback: CustomLoaderCallback, opts?: CustomLoaderOptions) {
         const entry = { name: opts?.name, priority: opts?.priority ?? 0, callback };

package/src/engine/engine_loaders.ts

@@ -61,7 +61,7 @@ export async function onCreateLoader(url: string, context: Context): Promise<Cus
     switch (type) {
         case "unsupported":
             return null;
-            
+
         default:
         case "unknown":
             {
@@ -287,15 +287,6 @@ async function onAfterLoaded(loader: Loader | CustomLoader, context: Context, gl
         gltfId = gltfId.split("?")[0];
     }
 
-    // assign animations of loaded glTF to all scenes
-    if ("scenes" in model) {
-        for (const scene of model.scenes) {
-            if (scene && !scene.animations?.length) {
-                scene.animations = [...model.animations];
-            }
-        }
-    }
-
     // E.g. fbx material cleanup
     postprocessLoadedFile(loader, model);
 
@@ -357,13 +348,27 @@ function checkIfUserAttemptedToLoadALocalFile(url: string) {
 /**
  * Postprocess the loaded file. This is used to apply any custom postprocessing to the loaded file.
  */
-function postprocessLoadedFile(loader: object, result: Model) {
+function postprocessLoadedFile(loader: object, model: Model) {
+
+
+    // assign animations of loaded glTF to all scenes
+    if ("scenes" in model) {
+        for (const scene of model.scenes) {
+            if (scene && !scene.animations?.length) {
+                for (const anim of model.animations) {
+                    if (!scene.animations.includes(anim)) {
+                        scene.animations.push(anim);
+                    }
+                }
+            }
+        }
+    }
 
     if (loader instanceof FBXLoader || loader instanceof OBJLoader) {
 
-        let obj: Object3D | Model = result;
+        let obj: Object3D | Model = model;
         if (!(obj instanceof Object3D)) {
-            obj = (result as GLTF).scene;
+            obj = (model as GLTF).scene || model.scenes.find(s => s);
         }
 
         obj.traverse((child) => {

package/src/engine/extensions/NEEDLE_lighting_settings.ts

@@ -169,8 +169,11 @@ export class SceneLightSettings extends Behaviour {
                 this._hemisphereLightObj.removeFromParent();
         }
 
-        if (this.sourceId)
-            this.context.sceneLighting.internalEnableReflection(this.sourceId);
+        if (this.sourceId) {
+            if (!this.context.domElement.getAttribute("environment-image")) {
+                this.context.sceneLighting.internalEnableReflection(this.sourceId);
+            }
+        }
     }
 
     onDisable() {

package/src/engine/extensions/NEEDLE_lightmaps.ts

@@ -70,7 +70,7 @@ export class NEEDLE_lightmaps implements GLTFLoaderPlugin {
                                 console.log(entry);
                             let res: Promise<any> | null = null;
                             // Check if the pointer is a json pointer:
-                            if (entry.pointer.startsWith("/textures/")) {
+                            if (entry.pointer.startsWith("/textures/") || /** legacy support e.g. SOC */entry.pointer.startsWith("textures/")) {
                                 if (debug) console.log("Load texture from gltf", entry.pointer);
                                 res = resolveReferences(this.parser, entry.pointer).then(res => this.resolveTexture(entry, res));
                             }

package/src/engine/js-extensions/Vector.ts

@@ -10,6 +10,12 @@ export function apply(object: Vector3) {
     }
 }
 
+// NOTE: keep in sync with method declarations below
+declare module 'three' {
+    export interface Vector3 {
+        slerp(end: Vector3, t: number): Vector3;
+    }
+}
 
 Vector3.prototype["slerp"] = function (end: Vector3, t: number) {
     return slerp(this, end, t);

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

@@ -60,6 +60,8 @@ type SkyboxAttributes = {
     "background-color"?: string,
     /** URL to .exr, .hdr, .png, .jpg to be used for lighting */
     "environment-image"?: string,
+
+    "environment-intensity"?: number,
 }
 
 export type TonemappingAttributeOptions = "none" | "linear" | "neutral" | "agx";

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

@@ -45,6 +45,7 @@ const observedAttributes = [
     "tone-mapping-exposure",
     "background-blurriness",
     "background-color",
+    "environment-intensity",
 ]
 
 // https://developers.google.com/web/fundamentals/web-components/customelements
@@ -54,8 +55,8 @@ const observedAttributes = [
  * The needle engine web component creates and manages a needle engine context which is responsible for rendering a 3D scene using threejs.   
  * The needle engine context is created when the src attribute is set and disposed when the needle engine is removed from the document (you can prevent this by setting the keep-alive attribute to true).  
  * The needle engine context is accessible via the context property on the needle engine element (e.g. document.querySelector("needle-engine").context).
- * @link https://engine.needle.tools/docs/reference/needle-engine-attributes
- * 
+ * See {@link https://engine.needle.tools/docs/reference/needle-engine-attributes}
+ *
  * @example
  * <needle-engine src="https://example.com/scene.glb"></needle-engine>
  * @example
@@ -64,7 +65,7 @@ const observedAttributes = [
 export class NeedleEngineWebComponent extends HTMLElement implements INeedleEngineComponent {
 
     static get observedAttributes() {
-        return observedAttributes
+        return observedAttributes;
     }
 
     public get loadingProgress01(): number { return this._loadingProgress01; }
@@ -94,7 +95,7 @@ export class NeedleEngineWebComponent extends HTMLElement implements INeedleEngi
     /**
      * Get the current context for this web component instance. The context is created when the src attribute is set and the loading has finished.  
      * The context is disposed when the needle engine is removed from the document (you can prevent this by setting the keep-alive attribute to true).  
-     * @returns {Promise<Context>} a promise that resolves to the context when the loading has finished
+     * @returns a promise that resolves to the context when the loading has finished
      */
     public getContext(): Promise<Context> {
         return new Promise((res, _rej) => {
@@ -325,22 +326,14 @@ export class NeedleEngineWebComponent extends HTMLElement implements INeedleEngi
                 if (debug) console.log("ktx2DecoderPath", newValue);
                 setKtx2TranscoderPath(newValue);
                 break;
-            case "tone-mapping": {
-                this.applyAttributes();
-                break;
-            }
-            case "tone-mapping-exposure": {
-                this.applyAttributes();
-                break;
-            }
-            case "background-blurriness": {
-                const value = parseFloat(newValue);
-                if (value != undefined && this._context) {
-                    this._context.scene.backgroundBlurriness = value;
-                }
-                break;
-            }
-            case "background-color": {
+                
+            case "tonemapping":
+            case "tone-mapping":
+            case "tone-mapping-exposure":
+            case "background-blurriness":
+            case "background-color":
+            case "environment-intensity":
+            {
                 this.applyAttributes();
                 break;
             }
@@ -552,11 +545,18 @@ export class NeedleEngineWebComponent extends HTMLElement implements INeedleEngi
         const backgroundBlurriness = this.getAttribute("background-blurriness");
         if (backgroundBlurriness !== null && backgroundBlurriness !== undefined) {
             const value = parseFloat(backgroundBlurriness);
-            if (value !== undefined && this._context) {
+            if (!isNaN(value) && this._context) {
                 this._context.scene.backgroundBlurriness = value;
             }
         }
 
+        const environmentIntensity = this.getAttribute("environment-intensity");
+        if (environmentIntensity != undefined && this._context) {
+            const value = parseFloat(environmentIntensity);
+            if (!isNaN(value) && this._context)
+                this._context.scene.environmentIntensity = value;
+        }
+
         const backgroundColor = this.getAttribute("background-color");
         if (this._context?.renderer) {
             if (typeof backgroundColor === "string" && backgroundColor.length > 0) {

package/src/engine-components/Animation.ts

@@ -67,7 +67,7 @@ export class Animation extends Behaviour implements IAnimationComponent {
     get isAnimationComponent(): boolean { return true; }
     addClip(clip: AnimationClip) {
         if (!this.animations) this.animations = [];
-        this.animations.push(clip);
+        if (!this.animations.includes(clip)) this.animations.push(clip);
     }
 
     /**

package/src/engine-components/AnimationUtilsAutoplay.ts

@@ -1,7 +1,6 @@
 import type { GLTF } from "three/examples/jsm/loaders/GLTFLoader.js";
 
 import { AnimationUtils } from "../engine/engine_animation.js";
-import { addComponent } from "../engine/engine_components.js";
 import { ContextEvent, ContextRegistry } from "../engine/engine_context_registry.js";
 import { Animation } from "./Animation.js";
 import { Animator } from "./Animator.js";
@@ -29,11 +28,7 @@ ContextRegistry.registerCallback(ContextEvent.ContextCreated, args => {
                     return undefined;
                 }, true);
                 if (hasAnimation !== true) {
-                    AnimationUtils.assignAnimationsFromFile(file.file as GLTF, {
-                        createAnimationComponent: (obj, _clip) => {
-                            return addComponent(obj, Animation);
-                        },
-                    });
+                    AnimationUtils.autoplayAnimations(file.file as GLTF);
                 }
             }
         }

package/src/engine-components/Camera.ts

@@ -9,6 +9,7 @@ import { RenderTexture } from "../engine/engine_texture.js";
 import { getTempColor, getWorldPosition } from "../engine/engine_three_utils.js";
 import type { ICamera } from "../engine/engine_types.js"
 import { getParam } from "../engine/engine_utils.js";
+import { NeedleXREventArgs } from "../engine/engine_xr.js";
 import { RGBAColor } from "../engine/js-extensions/index.js";
 import { Behaviour, GameObject } from "./Component.js";
 import { OrbitControls } from "./OrbitControls.js";
@@ -446,6 +447,11 @@ export class Camera extends Behaviour implements ICamera {
         this.context.removeCamera(this);
     }
 
+    onLeaveXR(_args: NeedleXREventArgs): void {
+        // Restore previous FOV
+        this.fieldOfView = this._fov;
+    }
+
 
     /** @internal */
     onBeforeRender() {
@@ -553,7 +559,7 @@ export class Camera extends Behaviour implements ICamera {
         }
 
         // restore previous fov (e.g. when user was in VR or AR and the camera's fov has changed)
-        this.fieldOfView = this._fov;
+        this.fieldOfView = this.fieldOfView;
 
         if (debug) {
             const msg = `[Camera] Apply ClearFlags: ${ClearFlags[this._clearFlags]} - \"${this.name}\"`;