@needle-tools/engine 4.8.8-next.857d744 → 4.8.8-next.8add297

package/src/engine-components/DropListener.ts

@@ -399,10 +399,11 @@ export class DropListener extends Behaviour {
     private _abort: AbortController | null = null;
 
     /**
-     * Processes dropped files, loads them as 3D models, and handles networking if enabled
-     * Creates an abort controller to cancel previous uploads if new files are dropped
+     * Processes dropped files and loads them as 3D models.
+     * When enabled, it also handles network drops (sending files between clients).
+     * Automatically handles cancelling previous uploads if new files are dropped.
      * @param fileList Array of dropped files
-     * @param ctx Context information about where the drop occurred
+     * @param ctx Context information about where on the screen or in 3D space the drop occurred
      */
     private async addFromFiles(fileList: Array<File>, ctx: DropContext) {
         if (debug) console.log("Add files", fileList)

package/src/engine-components/NestedGltf.ts

@@ -4,6 +4,7 @@ import { InstantiateIdProvider } from "../engine/engine_networking_instantiate.j
 import { serializable } from "../engine/engine_serialization_decorator.js";
 import { getParam } from "../engine/engine_utils.js";
 import { Behaviour } from "../engine-components/Component.js";
+import { EventList } from "./EventList.js";
 
 const debug = getParam("debugnestedgltf");
 
@@ -11,17 +12,21 @@ const debug = getParam("debugnestedgltf");
  * It will load the gltf file and instantiate it as a child of the parent of the GameObject that has this component
  */
 export class NestedGltf extends Behaviour {
-    /**
-     * A reference to the gltf file that should be loaded
-     */
+
+    /**  A reference to the gltf file that should be loaded */
     @serializable(AssetReference)
     filePath?: AssetReference;
 
+    /** Invoked when the nested glTF file has been instantiated */
+    @serializable(EventList)
+    loaded: EventList<{ component: NestedGltf, instance: any, asset: AssetReference }> = new EventList();
+
     /**
      * EXPERIMENTAL for cloud asset loading
      */
     loadAssetInParent = true;
 
+
     private _isLoadingOrDoneLoading: boolean = false;
 
     /** Register a callback that will be called when the progress of the loading changes */
@@ -31,7 +36,7 @@ export class NestedGltf extends Behaviour {
 
     /** Begin loading the referenced gltf file in filePath */
     preload() {
-        this.filePath?.preload();
+        return this.filePath?.preload() || null;
     }
 
     /** @internal */
@@ -41,27 +46,31 @@ export class NestedGltf extends Behaviour {
 
         const parent = this.gameObject.parent;
         if (parent) {
-            this._isLoadingOrDoneLoading = true;
-            const opts = new InstantiateOptions();
-            // we need to provide stable guids for creating nested gltfs
-            opts.idProvider = new InstantiateIdProvider(this.hash(this.guid));
-            opts.parent = this.loadAssetInParent !== false ? parent : this.gameObject;
-            this.gameObject.updateMatrix();
-            const matrix = this.gameObject.matrix;
-            if (debug) console.log("Load nested:", this.filePath?.url ?? this.filePath, this.gameObject.position);
-            const res = await this.filePath?.instantiate?.call(this.filePath, opts);
-            if (debug) console.log("Nested loaded:", this.filePath?.url ?? this.filePath, res);
-            if (res && this.loadAssetInParent !== false) {
-                res.matrixAutoUpdate = false;
-                res.matrix.identity();
-                res.applyMatrix4(matrix);
-                res.matrixAutoUpdate = true;
-                res.layers.disableAll();
-                res.layers.set(this.layer);
-
-                this.dispatchEvent(new CustomEvent("loaded", { detail: { instance: res, assetReference: this.filePath } }));
+
+            if (this.filePath) {
+
+                this._isLoadingOrDoneLoading = true;
+                const opts = new InstantiateOptions();
+                // we need to provide stable guids for creating nested gltfs
+                opts.idProvider = new InstantiateIdProvider(this.hash(this.guid));
+                opts.parent = this.loadAssetInParent !== false ? parent : this.gameObject;
+                this.gameObject.updateMatrix();
+                const matrix = this.gameObject.matrix;
+                if (debug) console.log("Load nested:", this.filePath?.url ?? this.filePath, this.gameObject.position);
+                const res = await this.filePath?.instantiate?.call(this.filePath, opts);
+                if (debug) console.log("Nested loaded:", this.filePath?.url ?? this.filePath, res);
+                if (res && this.loadAssetInParent !== false) {
+                    res.matrixAutoUpdate = false;
+                    res.matrix.identity();
+                    res.applyMatrix4(matrix);
+                    res.matrixAutoUpdate = true;
+                    res.layers.disableAll();
+                    res.layers.set(this.layer);
+                    this.loaded.invoke({ component: this, instance: res, asset: this.filePath });
+                }
+                if (debug) console.log("Nested loading done:", this.filePath?.url ?? this.filePath, res);
             }
-            if (debug) console.log("Nested loading done:", this.filePath?.url ?? this.filePath, res);
+
         }
     }
 

package/src/engine-components/OrbitControls.ts

@@ -889,6 +889,8 @@ export class OrbitControls extends Behaviour implements ICameraController {
             }
             else this._fovLerpDuration = this.targetLerpDuration;
         }
+
+        // if (this.context.mainCameraComponent) this.context.mainCameraComponent.fieldOfView = fov;
     }
 
     /** Moves the camera look-at target to a position smoothly. 
@@ -984,10 +986,11 @@ export class OrbitControls extends Behaviour implements ICameraController {
     */
     fitCamera(options?: FitCameraOptions);
     fitCamera(objects?: Object3D | Array<Object3D>, options?: Omit<FitCameraOptions, "objects">);
-    fitCamera(objectsOrOptions?: Object3D | Array<Object3D> | FitCameraOptions, options?: FitCameraOptions) {
+    fitCamera(objectsOrOptions?: Object3D | Array<Object3D> | FitCameraOptions, options?: FitCameraOptions): void {
 
         if (this.context.isInXR) {
             // camera fitting in XR is not supported
+            console.warn('[OrbitControls] Can not fit camera while XR session is active');
             return;
         }
 
@@ -1032,7 +1035,7 @@ export class OrbitControls extends Behaviour implements ICameraController {
             return;
         }
         if (!options) options = {}
-        const { immediate = false, centerCamera = "y", cameraNearFar = "auto", fitOffset = 1.1, fov = camera?.fov } = options;
+        const { immediate = false, centerCamera, cameraNearFar = "auto", fitOffset = 1.1, fov = camera?.fov } = options;
         const size = new Vector3();
         const center = new Vector3();
         // TODO would be much better to calculate the bounds in camera space instead of world space - 
@@ -1041,15 +1044,13 @@ export class OrbitControls extends Behaviour implements ICameraController {
         // and thus we're just getting some maximum that will work for sure.
         const box = getBoundingBox(objects, undefined, this._camera?.threeCamera?.layers);
         const boxCopy = box.clone();
-
-        camera.updateMatrixWorld();
-        camera.updateProjectionMatrix();
         box.getCenter(center);
 
         const box_size = new Vector3();
         box.getSize(box_size);
 
         // project this box into camera space
+        camera.updateMatrixWorld();
         box.applyMatrix4(camera.matrixWorldInverse);
 
         box.getSize(size);
@@ -1078,9 +1079,18 @@ export class OrbitControls extends Behaviour implements ICameraController {
         this.minZoom = distance * 0.01;
 
         const verticalOffset = 0.05;
-
         const lookAt = center.clone();
         lookAt.y -= size.y * verticalOffset;
+        if (options.targetOffset) {
+            if (options.targetOffset.x !== undefined) lookAt.x += options.targetOffset.x;
+            if (options.targetOffset.y !== undefined) lookAt.y += options.targetOffset.y;
+            if (options.targetOffset.z !== undefined) lookAt.z += options.targetOffset.z;
+        }
+        if (options.relativeTargetOffset) {
+            if (options.relativeTargetOffset.x !== undefined) lookAt.x += options.relativeTargetOffset.x * size.x;
+            if (options.relativeTargetOffset.y !== undefined) lookAt.y += options.relativeTargetOffset.y * size.y;
+            if (options.relativeTargetOffset.z !== undefined) lookAt.z += options.relativeTargetOffset.z * size.z;
+        }
         this.setLookTargetPosition(lookAt, immediate);
         this.setFieldOfView(options.fov, immediate);
 
@@ -1092,6 +1102,7 @@ export class OrbitControls extends Behaviour implements ICameraController {
             // TODO: this doesnt take the Camera component nearClipPlane into account
             camera.near = (distance / 100);
             camera.far = boundsMax + distance * 10;
+            camera.updateProjectionMatrix();
 
             // adjust maxZoom so that the ground projection radius is always inside
             if (groundprojection) {
@@ -1104,12 +1115,13 @@ export class OrbitControls extends Behaviour implements ICameraController {
         if (currentZoom < this.minZoom) this.minZoom = currentZoom * 0.9;
         if (currentZoom > this.maxZoom) this.maxZoom = currentZoom * 1.1;
 
-        camera.updateMatrixWorld();
-        camera.updateProjectionMatrix();
-
-        const cameraWp = getWorldPosition(camera);
         const direction = center.clone();
-        direction.sub(cameraWp);
+        if (options.fitDirection) {
+            direction.sub(new Vector3().copy(options.fitDirection).multiplyScalar(1_000_000));
+        }
+        else {
+            direction.sub(camera.worldPosition);
+        }
         if (centerCamera === "y")
             direction.y = 0;
         direction.normalize();
@@ -1118,6 +1130,16 @@ export class OrbitControls extends Behaviour implements ICameraController {
             direction.y += -verticalOffset * 4 * distance;
 
         let cameraLocalPosition = center.clone().sub(direction);
+        if (options.cameraOffset) {
+            if (options.cameraOffset.x !== undefined) cameraLocalPosition.x += options.cameraOffset.x;
+            if (options.cameraOffset.y !== undefined) cameraLocalPosition.y += options.cameraOffset.y;
+            if (options.cameraOffset.z !== undefined) cameraLocalPosition.z += options.cameraOffset.z;
+        }
+        if (options.relativeCameraOffset) {
+            if (options.relativeCameraOffset.x !== undefined) cameraLocalPosition.x += options.relativeCameraOffset.x * size.x;
+            if (options.relativeCameraOffset.y !== undefined) cameraLocalPosition.y += options.relativeCameraOffset.y * size.y;
+            if (options.relativeCameraOffset.z !== undefined) cameraLocalPosition.z += options.relativeCameraOffset.z * size.z;
+        }
         if (camera.parent) {
             cameraLocalPosition = camera.parent.worldToLocal(cameraLocalPosition);
         }
@@ -1154,7 +1176,7 @@ export class OrbitControls extends Behaviour implements ICameraController {
 /**
  * Options for fitting the camera to the scene. Used in {@link OrbitControls.fitCamera}
  */
-declare type FitCameraOptions = {
+export type FitCameraOptions = {
     /** When enabled debug rendering will be shown */
     debug?: boolean,
     /**
@@ -1166,14 +1188,41 @@ declare type FitCameraOptions = {
      */
     immediate?: boolean,
 
+    /** Fit offset: A factor to multiply the distance to the objects by
+     * @default 1.1
+     */
+    fitOffset?: number,
+
+    /** The direction from which the camera should be fitted in worldspace. If not defined the current camera's position will be used */
+    fitDirection?: Vector3Like,
+
     /** If set to "y" the camera will be centered in the y axis */
     centerCamera?: "none" | "y",
+    /** Set to 'auto' to update the camera near or far plane based on the fitted-objects bounds */
     cameraNearFar?: "keep" | "auto",
 
-    fov?: number,
+    /**
+     * Offset the camera position in world space
+     */
+    cameraOffset?: Partial<Vector3Like>,
+    /**
+     * Offset the camera position relative to the size of the objects being focused on (e.g. x: 0.5).  
+     * Value range: -1 to 1
+     */
+    relativeCameraOffset?: Partial<Vector3Like>,
 
-    /** Fit offset: A factor to multiply the distance to the objects by
-     * @default 1.1
+    /**
+     * Offset the camera target position in world space
      */
-    fitOffset?: number,
+    targetOffset?: Partial<Vector3Like>,
+    /**
+     * Offset the camera target position relative to the size of the objects being focused on.  
+     * Value range: -1 to 1
+     */
+    relativeTargetOffset?: Partial<Vector3Like>,
+
+    /**
+     * Field of view (FOV) for the camera
+     */
+    fov?: number,
 }

package/src/engine-components/Renderer.ts

@@ -706,7 +706,8 @@ export class Renderer extends Behaviour implements IRenderer {
         }
 
         if (this.reflectionProbeUsage !== ReflectionProbeUsage.Off && this._reflectionProbe) {
-            this._reflectionProbe.onSet(this);
+            if (!this._lightmaps?.length) // Currently reflectionprobes cant be used with lightmaps
+                this._reflectionProbe.onSet(this);
         }
         // since three 163 we need to set the envMap to the scene envMap if it is not set
         // otherwise the envmapIntensity has no effect: https://github.com/mrdoob/three.js/pull/27903

package/src/engine-components/Skybox.ts

@@ -48,21 +48,20 @@ function createRemoteSkyboxComponent(context: IContext, url: string, skybox: boo
 const promises = new Array<Promise<any>>();
 ContextRegistry.registerCallback(ContextEvent.ContextCreationStart, (args) => {
     const context = args.context;
-    const skyboxImage = context.domElement.getAttribute("background-image");
+    const backgroundImage = context.domElement.getAttribute("background-image");
     const environmentImage = context.domElement.getAttribute("environment-image");
-    const envAndSkyboxAreSame = skyboxImage === environmentImage;
-
-    if (skyboxImage && !envAndSkyboxAreSame) {
-        if (debug) console.log("Creating remote skybox to load " + skyboxImage);
+    
+    if (backgroundImage) {
+        if (debug) console.log("Creating RemoteSkybox to load background " + backgroundImage);
         // if the user is loading a GLB without a camera then the CameraUtils (which creates the default camera)
         // checks if we have this attribute set and then sets the skybox clearflags accordingly
         // if the user has a GLB with a camera but set to solid color then the skybox image is not visible -> we will just warn then and not override the camera settings
-        const promise = createRemoteSkyboxComponent(context, skyboxImage, true, false, "background-image");
+        const promise = createRemoteSkyboxComponent(context, backgroundImage, true, false, "background-image");
         if (promise) promises.push(promise);
     }
     if (environmentImage) {
-        if (debug) console.log("Creating remote environment to load " + environmentImage);
-        const promise = createRemoteSkyboxComponent(context, environmentImage, envAndSkyboxAreSame, true, "environment-image");
+        if (debug) console.log("Creating RemoteSkybox to load environment " + environmentImage);
+        const promise = createRemoteSkyboxComponent(context, environmentImage, false, true, "environment-image");
         if (promise) promises.push(promise);
     }
 });
@@ -200,7 +199,7 @@ export class RemoteSkybox extends Behaviour {
             console.warn("Potentially invalid skybox URL: \"" + name + "\" on " + (this.name || this.gameObject?.name || "context"));
         }
 
-        if (debug) console.log("Set remote skybox url: " + url);
+        if (debug) console.log("Set RemoteSkybox url: " + url);
 
         if (this._prevUrl === url && this._prevLoadedEnvironment) {
             this.apply();
@@ -258,7 +257,7 @@ export class RemoteSkybox extends Behaviour {
             this._prevBackground = this.context.scene.background;
         if (this.context.scene.environment !== envMap)
             this._prevEnvironment = this.context.scene.environment;
-        if (debug) console.log("Set remote skybox", this.url, !Camera.backgroundShouldBeTransparent(this.context));
+        if (debug) console.log("Set RemoteSkybox (" + ((this.environment && this.background) ? "environment and background" : this.environment ? "environment" : this.background ? "background" : "none") + ")", this.url, !Camera.backgroundShouldBeTransparent(this.context));
         if (this.environment)
             this.context.scene.environment = envMap;
         if (this.background && !Camera.backgroundShouldBeTransparent(this.context))

package/src/engine-components/api.ts

@@ -51,7 +51,8 @@ import "./CameraUtils.js"
 import "./AnimationUtils.js"
 import "./AnimationUtilsAutoplay.js"
 
-export { DragMode } from "./DragControls.js"
+export { DragMode } from "./DragControls.js";
+export { type FitCameraOptions } from "./OrbitControls.js";
 export type { DropListenerNetworkEventArguments, DropListenerOnDropArguments } from "./DropListener.js";
 export * from "./particlesystem/api.js"
 

package/src/engine-components/export/usdz/USDZExporter.ts

@@ -12,6 +12,7 @@ import { InstancingHandler } from "../../../engine-components/RendererInstancing
 import { Collider } from "../../Collider.js";
 import { Behaviour, GameObject } from "../../Component.js";
 import { ContactShadows } from "../../ContactShadows.js";
+import { EventList } from "../../EventList.js";
 import { GroundProjectedEnv } from "../../GroundProjection.js";
 import { Renderer } from "../../Renderer.js"
 import { Rigidbody } from "../../RigidBody.js";
@@ -29,7 +30,6 @@ import { USDZUIExtension } from "./extensions/USDZUI.js";
 import { USDZExporter as ThreeUSDZExporter } from "./ThreeUSDZExporter.js";
 import { disableObjectsAtStart, registerAnimatorsImplictly, registerAudioSourcesImplictly } from "./utils/animationutils.js";
 import { ensureQuicklookLinkIsCreated } from "./utils/quicklook.js";
-import { EventList } from "../../EventList.js";
 
 const debug = getParam("debugusdz");
 const debugUsdzPruning = getParam("debugusdzpruning");

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

@@ -3,6 +3,7 @@ import { Object3DEventMap } from "three";
 
 import { isDevEnvironment, showBalloonWarning } from "../../engine/debug/index.js";
 import { AssetReference } from "../../engine/engine_addressables.js";
+import { Context } from "../../engine/engine_context.js";
 import { serializable } from "../../engine/engine_serialization.js";
 import { IGameObject } from "../../engine/engine_types.js";
 import { CircularBuffer, delay, DeviceUtilities, getParam } from "../../engine/engine_utils.js";
@@ -12,7 +13,6 @@ import { imageToCanvas, USDObject, USDWriter, USDZExporterContext } from "../../
 import { USDZExporter } from "../../engine-components/export/usdz/USDZExporter.js";
 import { Behaviour, GameObject } from "../Component.js";
 import { Renderer } from "../Renderer.js";
-import { Context } from "../../engine/engine_context.js";
 
 // https://github.com/immersive-web/marker-tracking/blob/main/explainer.md