@needle-tools/engine 4.8.7 → 4.8.8-next.4b53212

package/src/engine/engine_addressables.ts

@@ -8,7 +8,7 @@ import { BlobStorage } from "./engine_networking_blob.js";
 import { registerPrefabProvider, syncInstantiate, SyncInstantiateOptions } from "./engine_networking_instantiate.js";
 import { SerializationContext, TypeSerializer } from "./engine_serialization_core.js";
 import { Context } from "./engine_setup.js";
-import type { GLTF, IComponent, IGameObject, SourceIdentifier } from "./engine_types.js";
+import type { GLTF, IComponent, IGameObject, Model, SourceIdentifier } from "./engine_types.js";
 
 const debug = getParam("debugaddressables");
 
@@ -138,21 +138,35 @@ export class AssetReference {
         return ref;
     }
 
-    private static currentlyInstantiating: Map<string, number> = new Map<string, number>();
 
-    /** @returns true if this is an AssetReference instance */
-    get isAssetReference() { return true; }
 
-    /** The loaded asset */
+
+
+
+    readonly isAssetReference = true;
+
+    /**  
+     * This is the loaded asset root object. If the asset is a glb/gltf file this will be the {@link three#Scene} object.
+     */
+    get rawAsset(): any { return this._rawAsset; }
+
+    /** The loaded asset root
+     */
     get asset(): Object3D | null {
-        return this._glbRoot ?? this._asset;
+        return this._glbRoot ?? (this._rawAsset?.scene || null);
     }
 
-    protected set asset(val: any) {
-        this._asset = val;
+    protected set asset(val: Object3D | null) {
+        if (val) {
+            this._rawAsset = {
+                animations: val.animations,
+                scene: val,
+                scenes: [val],
+            }
+        }
+        else this._rawAsset = null;
     }
 
-    private _loading?: PromiseLike<any>;
 
     /** The url of the loaded asset (or the asset to be loaded) 
      * @deprecated use url */
@@ -177,12 +191,7 @@ export class AssetReference {
             (this._url.startsWith("http") || this._url.startsWith("blob:") || this._url.startsWith("www.") || this._url.includes("/"));
     }
 
-    /**  
-     * This is the loaded asset root object. If the asset is a glb/gltf file this will be the {@link three#Scene} object.
-     */
-    get rawAsset(): any { return this._asset; }
-
-    private _asset: any;
+    private _rawAsset: Model | null = null;
     private _glbRoot?: Object3D | null;
     private _url: string;
     private _urlName: string;
@@ -207,7 +216,7 @@ export class AssetReference {
         else {
             this._urlName = uri;
         }
-        
+
         if (asset !== null) this.asset = asset;
         registerPrefabProvider(this._url, this.onResolvePrefab.bind(this));
     }
@@ -226,6 +235,8 @@ export class AssetReference {
         return !this.asset || (this.asset as any).__destroyed === true || isDestroyed(this.asset) === true;
     }
 
+    private _loadingPromise: Promise<Model | null | undefined> | null = null;
+
     /**
      * @returns `true` if the asset has been loaded (via preload) or if it exists already (assigned to `asset`) */
     isLoaded() { return this._rawBinary || this.asset !== undefined }
@@ -242,7 +253,7 @@ export class AssetReference {
         this.asset = null;
         this._rawBinary = undefined;
         this._glbRoot = null;
-        this._loading = undefined;
+        this._loadingPromise = null;
         if (Context.Current) {
             Context.Current.addressables.unregisterAssetReference(this);
         }
@@ -267,16 +278,14 @@ export class AssetReference {
     /** Loads the asset and creates one instance (assigned to `asset`)
      * @returns the loaded asset
      */
-    async loadAssetAsync(prog?: ProgressCallback | null) {
-        if (debug)
-            console.log("loadAssetAsync", this.url);
+    async loadAssetAsync(prog?: ProgressCallback | null): Promise<Object3D | null> {
+        if (debug) console.log("[AssetReference] loadAssetAsync", this.url);
         if (!this.mustLoad) return this.asset;
 
         if (prog) this._progressListeners.push(prog);
-        
-        if (this._loading !== undefined) {
-            // console.warn("Wait for other loading thiny");
-            return this._loading.then(_ => this.asset);
+
+        if (this._loadingPromise !== null) {
+            return this._loadingPromise.then(_ => this.asset);
         }
         const context = Context.Current;
         // TODO: technically we shouldnt call awake only when the object is added to a scene
@@ -285,31 +294,30 @@ export class AssetReference {
         // console.log("START LOADING");
         if (this._rawBinary) {
             if (!(this._rawBinary instanceof ArrayBuffer)) {
-                console.error("Failed loading: Invalid raw binary data. Must be of type ArrayBuffer. " + (typeof this._rawBinary));
+                console.error("[AssetReference] Failed loading – Invalid data. Must be of type ArrayBuffer. " + (typeof this._rawBinary));
                 return null;
             }
-            this._loading = getLoader().parseSync(context, this._rawBinary, this.url, null);
+            this._loadingPromise = getLoader().parseSync(context, this._rawBinary, this.url, null);
             this.raiseProgressEvent(new ProgressEvent("progress", { loaded: this._rawBinary.byteLength, total: this._rawBinary.byteLength }));
         }
         else {
             if (debug) console.log("Load async", this.url);
-            this._loading = getLoader().loadSync(context, this.url, this.url, null, prog => {
+            this._loadingPromise = getLoader().loadSync(context, this.url, this.url, null, prog => {
                 this.raiseProgressEvent(prog);
             });
         }
-        const res = await this._loading;
+        this._loadingPromise.finally(() => this._loadingPromise = null);
+        const res = await this._loadingPromise;
         // clear all progress listeners after download has finished
         this._progressListeners.length = 0;
         this._glbRoot = this.tryGetActualGameObjectRoot(res);
-        this._loading = undefined;
         if (res) {
             // Make sure the loaded roots all have a reference to this AssetReference
             // that was originally loading it.
             // We need this when the loaded asset is being disposed
             // TODO: we have to prevent disposing resources that are still in use
             res[$assetReference] = this;
-            if (this._glbRoot)
-                this._glbRoot[$assetReference] = this;
+            if (this._glbRoot) this._glbRoot[$assetReference] = this;
             if (this.asset) this.asset[$assetReference] = this;
 
             // we need to handle the pre_setup callsbacks before instantiating
@@ -317,7 +325,7 @@ export class AssetReference {
             processNewScripts(context);
 
             if (res.scene !== undefined) {
-                this.asset = res;
+                this._rawAsset = res;
             }
             return this.asset;
         }
@@ -352,6 +360,9 @@ export class AssetReference {
         }
     }
 
+
+    private static readonly currentlyInstantiating: Map<string, number> = new Map<string, number>();
+
     private async onInstantiate(opts?: Object3D | IInstantiateOptions | SyncInstantiateOptions | null, networked: boolean = false, saveOnServer?: boolean): Promise<Object3D | null> {
         const context = Context.Current;
 
@@ -429,6 +440,8 @@ export class AssetReference {
             const scene = asset.scene as Group;
             if (scene.isGroup && scene.children.length === 1 && scene.children[0].name + "glb" === scene.name) {
                 const root = scene.children[0];
+                // HACK we want to keep the animations on the root object. Please keep in sync with engine_loader. This is so autoplay animations works (e.g. with AnimationUtils.autoplayAnimations where we get the animations from the root object). One case where an additioanl root exists is the SOC old mcdonald scene
+                root.animations = scene.animations;
                 return root;
             }
             // ok the scene is the scene, just use that then
@@ -544,7 +557,7 @@ export class ImageReference {
             console.error("Can not load texture without url");
             return failedTexturePromise;
         }
-        
+
         if (!this.loader) this.loader = new TextureLoader();
         this.loader.setCrossOrigin("anonymous");
         return this.loader.loadAsync(this.url).then(res => {

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,31 +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)
                 }
+                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));
                             }