@needle-tools/engine 4.8.8 → 4.8.9-next.5967018

package/src/engine/xr/NeedleXRController.ts

@@ -398,8 +398,8 @@ export class NeedleXRController implements IPointerHitEventReceiver {
 C:${this.connected ? "x" : "-"} T:${this.isTracking ? "x" : "-"} Hand:${this.inputSource.hand ? "x" : "-"} Pen: ${this._isMxInk ? "x" : "-"}`;
         if (this.inputSource.hand) debugStr += `\nPinch: ${this.getGesture("pinch")?.value.toFixed(3)}`;
         debugStr += "\n" + profileStr;
-        debugStr += "\n" + (this.inputSource.targetRaySpace ? `Ray: x` : "Ray: -") + 
-            (this.inputSource.gripSpace ? " Grip: x" : " Grip: -") + 
+        debugStr += "\n" + (this.inputSource.targetRaySpace ? `Ray: x` : "Ray: -") +
+            (this.inputSource.gripSpace ? " Grip: x" : " Grip: -") +
             (this.inputSource.gamepad ? ` Gamepad: ${this.inputSource.gamepad.mapping}` : " Gamepad: -");
         if (this.inputSource.gamepad) {
             const gp = this.inputSource.gamepad;
@@ -415,7 +415,7 @@ C:${this.connected ? "x" : "-"} T:${this.isTracking ? "x" : "-"} Hand:${this.inp
         this._handJointPoses.clear();
         this._hand_wristDotUp = undefined;
 
-        if (!this.xr.referenceSpace) {
+        if (!this.xr.referenceSpace || !this.inputSource.gamepad?.connected) {
             this._isTracking = false;
             return;
         }
@@ -460,7 +460,7 @@ C:${this.connected ? "x" : "-"} T:${this.isTracking ? "x" : "-"} Hand:${this.inp
 
         // update controller object parent – needs to be parented to the rig, which
         // implicitly is the same object as the camera parent.
-        if (this.xr.context.mainCamera?.parent) { 
+        if (this.xr.context.mainCamera?.parent) {
             if (this._object.parent !== this.xr.context.mainCamera?.parent)
                 this.xr.context.mainCamera.parent.add(this._object);
             if (this._gripSpaceObject !== undefined && this._gripSpaceObject?.parent !== this.xr.context.mainCamera?.parent)
@@ -594,6 +594,24 @@ C:${this.connected ? "x" : "-"} T:${this.isTracking ? "x" : "-"} Hand:${this.inp
                     return this.getGesture("pinch");
                 }
                 return this.toNeedleGamepadButton(0, key);
+
+            case "xr-standard-trigger":
+                if (this.inputSource.gamepad) {
+                    return this.toNeedleGamepadButton(0, key);
+                }
+                break;
+
+            case "xr-standard-squeeze":
+                if (this.inputSource.gamepad) {
+                    return this.toNeedleGamepadButton(1, key);
+                }
+                break;
+
+            case "xr-standard-thumbstick":
+                if (this.inputSource.gamepad) {
+                    return this.toNeedleGamepadButton(3, key);
+                }
+                break;
         }
 
 
@@ -694,12 +712,18 @@ C:${this.connected ? "x" : "-"} T:${this.isTracking ? "x" : "-"} Hand:${this.inp
     getStick(key: StickName | "primary"): Vec3 {
         if (!this._layout) return { x: 0, y: 0, z: 0 };
 
+        // Hands dont have thumbsicks
+        if (this.isHand) {
+            return { x: 0, y: 0, z: 0 };
+        }
+
         if (key === "primary") {
-            const x = this.inputSource.gamepad?.axes[0] || 0;
-            const y = this.inputSource.gamepad?.axes[1] || 0;
-            // the primary thumbstick is button 3 (see gamepads module explainer)
-            const z = this.inputSource.gamepad?.buttons[3]?.value || 0;
-            return { x, y, z }
+            if (this._layout.components["xr-standard-thumbstick"]) key = "xr-standard-thumbstick";
+            // const x = this.inputSource.gamepad?.axes[0] || 0;
+            // const y = this.inputSource.gamepad?.axes[1] || 0;
+            // // the primary thumbstick is button 3 (see gamepads module explainer)
+            // const z = this.inputSource.gamepad?.buttons[3]?.value || 0;
+            // return { x, y, z }
         }
 
         const componentModel = this._layout?.components[key];
@@ -709,12 +733,12 @@ C:${this.connected ? "x" : "-"} T:${this.isTracking ? "x" : "-"} Hand:${this.inp
                     if (this.inputSource.gamepad) {
                         const xIndex = componentModel.gamepadIndices!.xAxis!;
                         const yIndex = componentModel.gamepadIndices!.yAxis!;
-                        let x = this.inputSource.gamepad?.axes[xIndex];
-                        let y = this.inputSource.gamepad?.axes[yIndex];
+                        let x = this.inputSource.gamepad.axes[xIndex] || 0;
+                        let y = this.inputSource.gamepad.axes[yIndex] || 0;
                         x *= -1;
                         y *= -1;
                         const buttonIndex = componentModel.gamepadIndices!.button!;
-                        const z = this.inputSource.gamepad?.buttons[buttonIndex]?.value;
+                        const z = this.inputSource.gamepad?.buttons[buttonIndex]?.value || 0;
                         return { x, y, z }
                     }
             }
@@ -731,13 +755,13 @@ C:${this.connected ? "x" : "-"} T:${this.isTracking ? "x" : "-"} Hand:${this.inp
     private initialize() {
         // WORKAROUND for hand controllers that don't have a select event
         this._hasSelectEvent = this.profiles.includes("generic-hand-select") || this.profiles.some(p => p.startsWith("generic-trigger"));
-       
+
         // Used to determine special layout for Quest controllers, e.g. last button is menu button
         this._isMetaQuestTouchController = this.profiles.includes("meta-quest-touch-plus") || this.profiles.includes("oculus-touch-v3");
 
         // Proper profile starting with v69 and browser 35.1
         this._isMxInk = this.profiles.includes("logitech-mx-ink")
-        
+
         if (!this._layout) {
             // Ignore transient-pointer since we likely don't want to spawn a controller visual just for a temporary pointer.
             // TODO we should check how this is actually handled on Quest Browser when the transient-pointer flag is on.
@@ -953,7 +977,7 @@ C:${this.connected ? "x" : "-"} T:${this.isTracking ? "x" : "-"} Hand:${this.inp
                 if (menuButtonState) {
                     if (menuButtonState.isDown) {
                         const menu = this.context.menu;
-                        if (menu.spatialMenuIsVisible) 
+                        if (menu.spatialMenuIsVisible)
                             menu.setSpatialMenuVisible(false);
                         else
                             this.context.menu.setSpatialMenuVisible(true);

package/src/engine/xr/NeedleXRSession.ts

@@ -530,7 +530,7 @@ export class NeedleXRSession implements INeedleXRSession {
             listener({ mode, init });
         }
         if (debug) showBalloonMessage("Requesting " + mode + " session (" + Date.now() + ")");
-        this._currentSessionRequest = navigator.xr?.requestSession(mode, init);
+        this._currentSessionRequest = navigator?.xr?.requestSession(mode, init);
         this._currentSessionRequestMode = mode;
         /**@type {XRSystem} */
         const newSession = await (this._currentSessionRequest)?.catch(e => {
@@ -1053,10 +1053,13 @@ export class NeedleXRSession implements INeedleXRSession {
 
     /** Disconnects the controller, invokes events and notifies previou controller (if any) */
     private disconnectInputSource(inputSource: XRInputSource) {
-        const handleRemove = (oldController: NeedleXRController, _array: Array<NeedleXRController>, i: number) => {
+        const handleRemove = (oldController: NeedleXRController, array: Array<NeedleXRController>) => {
             if (oldController.inputSource === inputSource) {
                 if (debug) console.log("Disconnecting controller", oldController.index);
-                this.controllers.splice(i, 1);
+
+                const index = array.indexOf(oldController);
+                if(index >= 0) array.splice(index, 1);
+
                 this.invokeControllerEvent(oldController, this._controllerRemoved, "removed");
                 const args: NeedleXRControllerEventArgs = {
                     xr: this,
@@ -1069,13 +1072,15 @@ export class NeedleXRSession implements INeedleXRSession {
                 oldController.onDisconnected();
             }
         }
-        for (let i = this.controllers.length - 1; i >= 0; i--) {
-            const oldController = this.controllers[i];
-            handleRemove(oldController, this.controllers, i);
+        const copy = [...this.controllers];
+        for (let i = copy.length - 1; i >= 0; i--) {
+            const oldController = copy[i];
+            handleRemove(oldController, this.controllers);
         }
-        for (let i = this._newControllers.length - 1; i >= 0; i--) {
-            const oldController = this._newControllers[i];
-            handleRemove(oldController, this._newControllers, i);
+        const copyNew = [...this._newControllers];
+        for (let i = copyNew.length - 1; i >= 0; i--) {
+            const oldController = copyNew[i];
+            handleRemove(oldController, this._newControllers);
         }
     }
 
@@ -1130,8 +1135,8 @@ export class NeedleXRSession implements INeedleXRSession {
         for (let i = 0; i < copy.length; i++) {
             this.disconnectInputSource(copy[i].inputSource);
         }
-        this._newControllers.length = 0;
         this.controllers.length = 0;
+        this._newControllers.length = 0;
 
         // we want to call leave XR for *all* scripts that are still registered
         // even if they might already be destroyed e.g. by the WebXR component (it destroys the default controller scripts)
@@ -1318,8 +1323,6 @@ export class NeedleXRSession implements INeedleXRSession {
                         continue;
                     }
                     this.invokeCallback_ControllerAdded(script, controller);
-                    // if (script.onXRControllerAdded) 
-                    //     script.onXRControllerAdded({ xr: this, controller, change: "added" });
                 }
             }
             this.controllers.sort((a, b) => a.index - b.index);
@@ -1558,9 +1561,10 @@ export class NeedleXRSession implements INeedleXRSession {
                 const rigWorldScale = getWorldScale(this.rig.gameObject);
                 minNearPlane *= rigWorldScale.x;
             }
-            if (this._camera instanceof PerspectiveCamera && this._camera.near > minNearPlane) {
+            if (this._camera instanceof PerspectiveCamera && Math.abs(this._camera.near - minNearPlane) > .0001) {
                 this.originalCameraNearPlane = this._camera.near;
                 this._camera.near = minNearPlane;
+                if(debug) console.debug(`Setting camera near plane to ${minNearPlane} (was ${this.originalCameraNearPlane}) to account for XR rendering scale`);
             }
         }
     }
@@ -1572,6 +1576,7 @@ export class NeedleXRSession implements INeedleXRSession {
 
         if (this._camera instanceof PerspectiveCamera && this.originalCameraNearPlane != undefined) {
             this._camera.near = this.originalCameraNearPlane;
+            this.originalCameraNearPlane = undefined;
         }
     }
 

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}\"`;

package/src/engine-components/ContactShadows.ts

@@ -1,4 +1,4 @@
-import { BackSide, CustomBlending, DoubleSide, FrontSide, Group, Material, Matrix4, MaxEquation, Mesh, MeshBasicMaterial, MeshDepthMaterial, MeshStandardMaterial, MinEquation, Object3D, OrthographicCamera, PlaneGeometry, RenderItem, ShaderMaterial, Vector3, WebGLRenderTarget } from "three";
+import { BackSide, CustomBlending, DoubleSide, FrontSide, Group, Material, Matrix4, MaxEquation, Mesh, MeshBasicMaterial, MeshDepthMaterial, MeshStandardMaterial, MinEquation, Object3D, OrthographicCamera, PlaneGeometry, RenderItem, ShaderMaterial, Vector3, Vector3Like, WebGLRenderTarget } from "three";
 import { HorizontalBlurShader } from 'three/examples/jsm/shaders/HorizontalBlurShader.js';
 import { VerticalBlurShader } from 'three/examples/jsm/shaders/VerticalBlurShader.js';
 
@@ -27,7 +27,14 @@ onStart(ctx => {
             shadows.darkness = intensity;
         }
     }
-})
+});
+
+
+type FitParameters = {
+    object?: Object3D | Object3D[];
+    positionOffset?: Partial<Vector3Like>;
+    scaleFactor?: Partial<Vector3Like>;
+}
 
 // Adapted from https://github.com/mrdoob/three.js/blob/master/examples/webgl_shadow_contact.html.
 
@@ -50,7 +57,7 @@ export class ContactShadows extends Behaviour {
      * @param context The context to create the contact shadows in.
      * @returns The instance of the contact shadows.
      */
-    static auto(context?: Context): ContactShadows {
+    static auto(context?: Context, params?: FitParameters): ContactShadows {
         if (!context) context = Context.Current;
         if (!context) {
             throw new Error("No context provided and no current context set.");
@@ -65,12 +72,13 @@ export class ContactShadows extends Behaviour {
             this._instances.set(context, instance);
         }
         context.scene.add(instance.gameObject);
-        instance.fitShadows();
+        instance.fitShadows(params);
         return instance;
     }
 
     /**
      * When enabled the contact shadows component will be created to fit the whole scene.
+     * @default false
      */
     @serializable()
     autoFit: boolean = false;
@@ -107,12 +115,14 @@ export class ContactShadows extends Behaviour {
 
     /**
      * The minimum size of the shadows box
+     * @default undefined
      */
     minSize?: Partial<Vec3>;
 
     /**
      * When enabled the shadows will not be updated automatically. Use `needsUpdate()` to update the shadows manually.
      * This is useful when you want to update the shadows only when the scene changes.
+     * @default false
      */
     manualUpdate: boolean = false;
     /**
@@ -150,10 +160,11 @@ export class ContactShadows extends Behaviour {
     /**
      * Call to fit the shadows to the scene.
      */
-    fitShadows() {
+    fitShadows(params: FitParameters = {}) {
         if (debug) console.warn("Fitting shadows to scene");
         setAutoFitEnabled(this.shadowsRoot, false);
-        const box = getBoundingBox(this.context.scene.children, [this.shadowsRoot]);
+        const objectToFit = params.object || this.context.scene;
+        const box = getBoundingBox(objectToFit, [this.shadowsRoot]);
         // expand box in all directions (except below ground)
         // 0.75 expands by 75% in each direction
         // The "32" is pretty much heuristically determined – adjusting the value until we don't get a visible border anymore.
@@ -175,6 +186,16 @@ export class ContactShadows extends Behaviour {
         // We can't move GroundProjection down because of immersive-ar mesh/plane tracking where occlusion would otherwise hide GroundProjection
         this.shadowsRoot.position.set((min.x + box.max.x) / 2, min.y - offset, (min.z + box.max.z) / 2);
         this.shadowsRoot.scale.set(box.max.x - min.x, box.max.y - min.y, box.max.z - min.z);
+        if (params.positionOffset) {
+            if (params.positionOffset.x !== undefined) this.shadowsRoot.position.x += params.positionOffset.x;
+            if (params.positionOffset.y !== undefined) this.shadowsRoot.position.y += params.positionOffset.y;
+            if (params.positionOffset.z !== undefined) this.shadowsRoot.position.z += params.positionOffset.z;
+        }
+        if (params.scaleFactor) {
+            if (params.scaleFactor.x !== undefined) this.shadowsRoot.scale.x *= params.scaleFactor.x;
+            if (params.scaleFactor.y !== undefined) this.shadowsRoot.scale.y *= params.scaleFactor.y;
+            if (params.scaleFactor.z !== undefined) this.shadowsRoot.scale.z *= params.scaleFactor.z;
+        }
         this.applyMinSize();
         this.shadowsRoot.matrixWorldNeedsUpdate = true;
         if (debug) console.log("Fitted shadows to scene", this.shadowsRoot.scale.clone());

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,22 +986,22 @@ 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;
         }
 
         let objects: Object3D | Array<Object3D> | undefined = undefined;
-
         // If the user passed in an array as first argument
         if (Array.isArray(objectsOrOptions)) {
             objects = objectsOrOptions;
         }
         // If the user passed in an object as first argument
         else if (objectsOrOptions && "type" in objectsOrOptions) {
-            objects = objectsOrOptions.children;
+            objects = objectsOrOptions;
         }
         // If the user passed in an object as first argument and options as second argument
         else if (objectsOrOptions && typeof objectsOrOptions === "object") {
@@ -1008,12 +1010,10 @@ export class OrbitControls extends Behaviour implements ICameraController {
                 objects = options.objects;
             }
         }
-
         // Ensure objects are setup correctly
         if (objects && !Array.isArray(objects)) {
-            objects = objects.children;
+            objects = [objects];
         }
-
         if (!Array.isArray(objects) || objects && objects.length <= 0) {
             objects = this.context.scene.children;
         }
@@ -1032,7 +1032,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 +1041,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 +1076,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 +1099,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 +1112,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 +1127,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 +1173,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 +1185,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