Changed to just MOVE Lazy Picking

packages/dev/core/src/Cameras/Inputs/BaseCameraMouseWheelInput.ts

@@ -80,7 +80,7 @@ export abstract class BaseCameraMouseWheelInput implements ICameraInput<Camera>
             }
         };
 
-        this._observer = this.camera._addPointerObserver(this._wheel, PointerEventTypes.POINTERWHEEL);
+        this._observer = this.camera.getScene().onPointerObservable.add(this._wheel, PointerEventTypes.POINTERWHEEL);
     }
 
     /**

packages/dev/core/src/Cameras/Inputs/BaseCameraPointersInput.ts

@@ -214,10 +214,12 @@ export abstract class BaseCameraPointersInput implements ICameraInput<Camera> {
             }
         };
 
-        this._observer = this.camera._addPointerObserver(
-            this._pointerInput,
-            PointerEventTypes.POINTERDOWN | PointerEventTypes.POINTERUP | PointerEventTypes.POINTERMOVE | PointerEventTypes.POINTERDOUBLETAP
-        );
+        this._observer = this.camera
+            .getScene()
+            .onPointerObservable.add(
+                this._pointerInput,
+                PointerEventTypes.POINTERDOWN | PointerEventTypes.POINTERUP | PointerEventTypes.POINTERMOVE | PointerEventTypes.POINTERDOUBLETAP
+            );
 
         this._onLostFocus = () => {
             this._pointA = this._pointB = null;

packages/dev/core/src/Cameras/Inputs/arcRotateCameraMouseWheelInput.ts

@@ -128,7 +128,7 @@ export class ArcRotateCameraMouseWheelInput implements ICameraInput<ArcRotateCam
             }
         };
 
-        this._observer = this.camera._addPointerObserver(this._wheel, PointerEventTypes.POINTERWHEEL);
+        this._observer = this.camera.getScene().onPointerObservable.add(this._wheel, PointerEventTypes.POINTERWHEEL)
 
         if (this.zoomToMouseLocation) {
             this._inertialPanning.setAll(0);

packages/dev/core/src/Cameras/Inputs/flyCameraMouseInput.ts

@@ -84,7 +84,7 @@ export class FlyCameraMouseInput implements ICameraInput<FlyCamera> {
         noPreventDefault = Tools.BackCompatCameraNoPreventDefault(arguments);
         this._noPreventDefault = noPreventDefault;
 
-        this._observer = this.camera._addPointerObserver((p: any) => {
+        this._observer = this.camera.getScene().onPointerObservable.add((p: any) => {
             this._pointerInput(p);
         }, PointerEventTypes.POINTERDOWN | PointerEventTypes.POINTERUP | PointerEventTypes.POINTERMOVE);
 

packages/dev/core/src/Cameras/Inputs/followCameraMouseWheelInput.ts

@@ -111,7 +111,7 @@ export class FollowCameraMouseWheelInput implements ICameraInput<FollowCamera> {
             }
         };
 
-        this._observer = this.camera._addPointerObserver(this._wheel, PointerEventTypes.POINTERWHEEL);
+        this._observer = this.camera.getScene().onPointerObservable.add(this._wheel, PointerEventTypes.POINTERWHEEL);
     }
 
     /**

packages/dev/core/src/Cameras/Inputs/freeCameraMouseInput.ts

@@ -188,7 +188,9 @@ export class FreeCameraMouseInput implements ICameraInput<FreeCamera> {
             }
         };
 
-        this._observer = this.camera._addPointerObserver(this._pointerInput, PointerEventTypes.POINTERDOWN | PointerEventTypes.POINTERUP | PointerEventTypes.POINTERMOVE);
+        this._observer = this.camera
+            .getScene()
+            .onPointerObservable.add(this._pointerInput, PointerEventTypes.POINTERDOWN | PointerEventTypes.POINTERUP | PointerEventTypes.POINTERMOVE);
 
         if (element) {
             this._contextMenuBind = this.onContextMenu.bind(this);

packages/dev/core/src/Cameras/Inputs/freeCameraTouchInput.ts

@@ -139,7 +139,9 @@ export class FreeCameraTouchInput implements ICameraInput<FreeCamera> {
             };
         }
 
-        this._observer = this.camera._addPointerObserver(this._pointerInput, PointerEventTypes.POINTERDOWN | PointerEventTypes.POINTERUP | PointerEventTypes.POINTERMOVE);
+        this._observer = this.camera
+            .getScene()
+            .onPointerObservable.add(this._pointerInput, PointerEventTypes.POINTERDOWN | PointerEventTypes.POINTERUP | PointerEventTypes.POINTERMOVE);
 
         if (this._onLostFocus) {
             const engine = this.camera.getEngine();

packages/dev/core/src/Cameras/camera.ts

@@ -1,7 +1,6 @@
 import { serialize, SerializationHelper, serializeAsVector3 } from "../Misc/decorators";
 import { SmartArray } from "../Misc/smartArray";
 import { Tools } from "../Misc/tools";
-import type { Observer } from "../Misc/observable";
 import { Observable } from "../Misc/observable";
 import type { Nullable } from "../types";
 import type { CameraInputsManager } from "./cameraInputsManager";
@@ -18,18 +17,13 @@ import { Viewport } from "../Maths/math.viewport";
 import { Frustum } from "../Maths/math.frustum";
 import type { Plane } from "../Maths/math.plane";
 import { Constants } from "../Engines/constants";
-import type { PointerInfo } from "../Events/pointerEvents";
 
 declare type PostProcess = import("../PostProcesses/postProcess").PostProcess;
 declare type RenderTargetTexture = import("../Materials/Textures/renderTargetTexture").RenderTargetTexture;
 declare type FreeCamera = import("./freeCamera").FreeCamera;
 declare type TargetCamera = import("./targetCamera").TargetCamera;
 declare type Ray = import("../Culling/ray").Ray;
 
-const forCameraState = {
-    forCamera: true,
-};
-
 /**
  * This is the base class of all the camera used in the application.
  * @see https://doc.babylonjs.com/features/cameras
@@ -638,11 +632,6 @@ export class Camera extends Node {
         return check;
     }
 
-    /** @internal */
-    public _addPointerObserver(callback: any, mask?: number): Nullable<Observer<PointerInfo>> {
-        return this._scene.onPointerObservable.add(callback, mask, false, null, false, forCameraState);
-    }
-
     /**
      * Attach the input controls to a specific dom element to get the input from.
      * @param noPreventDefault Defines whether event caught by the controls should call preventdefault() (https://developer.mozilla.org/en-US/docs/Web/API/Event/preventDefault)

packages/dev/core/src/Cameras/flyCamera.ts

@@ -295,6 +295,7 @@ export class FlyCamera extends TargetCamera {
      */
     public detachControl(): void {
         this.inputs.detachElement();
+
         this.cameraDirection = new Vector3(0, 0, 0);
     }
 

packages/dev/core/src/Cameras/freeCamera.ts

@@ -287,6 +287,7 @@ export class FreeCamera extends TargetCamera {
      */
     public detachControl(): void {
         this.inputs.detachElement();
+
         this.cameraDirection = new Vector3(0, 0, 0);
         this.cameraRotation = new Vector2(0, 0);
     }

packages/dev/core/src/Events/pointerEvents.ts

@@ -118,8 +118,11 @@ export class PointerInfo extends PointerInfoBase {
      */
     public get pickInfo(): Nullable<PickingInfo> {
         if (this._inputManager) {
-            this._pickInfo = this._inputManager._pickMove((this.event as IPointerEvent).pointerId);
+            // Store InputManager locally so that we can null out the object ref and avoid circular reference
+            const inputManager = this._inputManager;
             this._inputManager = null;
+            this._pickInfo = inputManager._pickMove((this.event as IPointerEvent).pointerId);
+            inputManager._setRayOnPointerInfo(this);
         }
 
         return this._pickInfo;

packages/dev/core/src/Inputs/scene.inputManager.ts

@@ -120,7 +120,6 @@ export class InputManager {
     private _meshUnderPointerId: { [pointerId: number]: Nullable<AbstractMesh> } = {};
     private _movePointerInfo: Nullable<PointerInfo> = null;
     private _clearCachedPickInfo: Nullable<Observer<Scene>> = null;
-    private _shouldPick = false;
 
     // Keyboard
     private _onKeyDown: (evt: IKeyboardEvent) => void;
@@ -197,14 +196,6 @@ export class InputManager {
         this._pointerY = value;
     }
 
-    private _computeShouldPick() {
-        const observers = this._scene.onPointerObservable.observers;
-
-        this._shouldPick = observers.some((observer) => {
-            return !observer.customState?.forCamera;
-        });
-    }
-
     private _updatePointerPosition(evt: IPointerEvent): void {
         const canvasRect = this._scene.getEngine().getInputElementClientRect();
 
@@ -251,14 +242,18 @@ export class InputManager {
         if (!pickResult) {
             this._movePointerInfo = pi;
         }
-        if (this._shouldPick) {
+        else {
             this._setRayOnPointerInfo(pi);
         }
-        scene.onPointerObservable.notifyObservers(pi, type);
+        if (scene.onPointerObservable.hasObservers()) {
+            //this._setRayOnPointerInfo(pi);
+            scene.onPointerObservable.notifyObservers(pi, type);
+        }
     }
 
     // Pointers handling
-    private _setRayOnPointerInfo(pointerInfo: PointerInfo) {
+    /** @internal */
+    public _setRayOnPointerInfo(pointerInfo: PointerInfo) {
         const scene = this._scene;
         if (pointerInfo.pickInfo && scene._pickingAvailable) {
             if (!pointerInfo.pickInfo.ray) {
@@ -302,6 +297,7 @@ export class InputManager {
         );
 
         this._setCursorAndPointerOverMesh(pickResult, pointerId, scene);
+
         return pickResult;
     }
 
@@ -417,12 +413,11 @@ export class InputManager {
                 scene.onPointerDown(evt, pickResult, type);
             }
 
-            const pi = new PointerInfo(type, evt, pickResult);
-            if (this._shouldPick) {
+            if (scene.onPointerObservable.hasObservers()) {
+                const pi = new PointerInfo(type, evt, pickResult);
                 this._setRayOnPointerInfo(pi);
+                scene.onPointerObservable.notifyObservers(pi, type);
             }
-
-            scene.onPointerObservable.notifyObservers(pi, type);
         }
     }
 
@@ -470,7 +465,7 @@ export class InputManager {
                 if (scene.onPointerPick) {
                     scene.onPointerPick(evt, pickResult);
                 }
-                if (clickInfo.singleClick && !clickInfo.ignore && this._shouldPick) {
+                if (clickInfo.singleClick && !clickInfo.ignore && scene.onPointerObservable.hasObservers()) {
                     const type = PointerEventTypes.POINTERPICK;
                     const pi = new PointerInfo(type, evt, pickResult);
                     this._setRayOnPointerInfo(pi);
@@ -506,28 +501,28 @@ export class InputManager {
         }
 
         let type = 0;
-        if (!clickInfo.ignore && !clickInfo.hasSwiped) {
-            if (clickInfo.singleClick && scene.onPointerObservable.hasSpecificMask(PointerEventTypes.POINTERTAP)) {
-                type = PointerEventTypes.POINTERTAP;
-            } else if (clickInfo.doubleClick && scene.onPointerObservable.hasSpecificMask(PointerEventTypes.POINTERDOUBLETAP)) {
-                type = PointerEventTypes.POINTERDOUBLETAP;
+        if (scene.onPointerObservable.hasObservers()) {
+            if (!clickInfo.ignore && !clickInfo.hasSwiped) {
+                if (clickInfo.singleClick && scene.onPointerObservable.hasSpecificMask(PointerEventTypes.POINTERTAP)) {
+                    type = PointerEventTypes.POINTERTAP;
+                } else if (clickInfo.doubleClick && scene.onPointerObservable.hasSpecificMask(PointerEventTypes.POINTERDOUBLETAP)) {
+                    type = PointerEventTypes.POINTERDOUBLETAP;
+                }
+                if (type) {
+                    const pi = new PointerInfo(type, evt, pickResult);
+                    this._setRayOnPointerInfo(pi);
+                    scene.onPointerObservable.notifyObservers(pi, type);
+                }
             }
-            if (type) {
+
+            if (!clickInfo.ignore) {
+                type = PointerEventTypes.POINTERUP;
                 const pi = new PointerInfo(type, evt, pickResult);
                 this._setRayOnPointerInfo(pi);
                 scene.onPointerObservable.notifyObservers(pi, type);
             }
         }
 
-        if (!clickInfo.ignore) {
-            type = PointerEventTypes.POINTERUP;
-            const pi = new PointerInfo(type, evt, pickResult);
-            if (this._shouldPick) {
-                this._setRayOnPointerInfo(pi);
-            }
-            scene.onPointerObservable.notifyObservers(pi, type);
-        }
-
         if (scene.onPointerUp && !clickInfo.ignore) {
             scene.onPointerUp(evt, pickResult, type);
         }
@@ -553,13 +548,6 @@ export class InputManager {
         const scene = this._scene;
         const engine = scene.getEngine();
 
-        scene.onPointerObservable.onObserverAdded = () => {
-            this._computeShouldPick();
-        };
-        scene.onPointerObservable.onObserverRemoved = () => {
-            this._computeShouldPick();
-        };
-
         if (!elementToAttachTo) {
             elementToAttachTo = engine.getInputElement();
         }
@@ -577,7 +565,7 @@ export class InputManager {
         this._initActionManager = (act: Nullable<AbstractActionManager>): Nullable<AbstractActionManager> => {
             if (!this._meshPickProceed) {
                 const pickResult =
-                    scene.skipPointerUpPicking || (scene._registeredActions === 0 && !this._shouldPick)
+                    scene.skipPointerUpPicking || (scene._registeredActions === 0 && !scene.onPointerObservable.hasObservers())
                         ? null
                         : scene.pick(this._unTranslatedPointerX, this._unTranslatedPointerY, scene.pointerUpPredicate, false, scene.cameraToUseForPointers);
                 this._currentPickResult = pickResult;
@@ -806,7 +794,7 @@ export class InputManager {
             // Meshes
             this._pickedDownMesh = null;
             let pickResult;
-            if (scene.skipPointerDownPicking || (scene._registeredActions === 0 && !this._shouldPick)) {
+            if (scene.skipPointerDownPicking || (scene._registeredActions === 0 && !scene.onPointerObservable.hasObservers())) {
                 pickResult = new PickingInfo();
             } else {
                 pickResult = scene.pick(this._unTranslatedPointerX, this._unTranslatedPointerY, scene.pointerDownPredicate, false, scene.cameraToUseForPointers);
@@ -839,7 +827,7 @@ export class InputManager {
 
             this._initClickEvent(scene.onPrePointerObservable, scene.onPointerObservable, evt, (clickInfo: _ClickInfo, pickResult: Nullable<PickingInfo>) => {
                 // PreObservable support
-                if (this._shouldPick) {
+                if (scene.onPrePointerObservable.hasObservers()) {
                     if (!clickInfo.ignore) {
                         if (!clickInfo.hasSwiped) {
                             if (clickInfo.singleClick && scene.onPrePointerObservable.hasSpecificMask(PointerEventTypes.POINTERTAP)) {
@@ -877,7 +865,7 @@ export class InputManager {
                 }
 
                 // Meshes
-                if (!this._meshPickProceed && ((AbstractActionManager && AbstractActionManager.HasTriggers) || this._shouldPick)) {
+                if (!this._meshPickProceed && ((AbstractActionManager && AbstractActionManager.HasTriggers) || scene.onPointerObservable.hasObservers())) {
                     this._initActionManager(null, clickInfo);
                 }
                 if (!pickResult) {
@@ -892,7 +880,7 @@ export class InputManager {
 
         this._onKeyDown = (evt: IKeyboardEvent) => {
             const type = KeyboardEventTypes.KEYDOWN;
-            if (scene.onKeyboardObservable.hasObservers()) {
+            if (scene.onPreKeyboardObservable.hasObservers()) {
                 const pi = new KeyboardInfoPre(type, evt);
                 scene.onPreKeyboardObservable.notifyObservers(pi, type);
                 if (pi.skipOnKeyboardObservable) {
@@ -912,7 +900,7 @@ export class InputManager {
 
         this._onKeyUp = (evt: IKeyboardEvent) => {
             const type = KeyboardEventTypes.KEYUP;
-            if (this._shouldPick) {
+            if (scene.onPreKeyboardObservable.hasObservers()) {
                 const pi = new KeyboardInfoPre(type, evt);
                 scene.onPreKeyboardObservable.notifyObservers(pi, type);
                 if (pi.skipOnKeyboardObservable) {