@babylonjs/core 5.45.2 → 5.46.0

package/Cameras/arcRotateCamera.js

@@ -23,182 +23,6 @@ Node.AddNodeConstructor("ArcRotateCamera", (name, scene) => {
  * @see https://doc.babylonjs.com/features/featuresDeepDive/cameras/camera_introduction#arc-rotate-camera
  */
 export class ArcRotateCamera extends TargetCamera {
-    /**
-     * Instantiates a new ArcRotateCamera in a given scene
-     * @param name Defines the name of the camera
-     * @param alpha Defines the camera rotation along the longitudinal axis
-     * @param beta Defines the camera rotation along the latitudinal axis
-     * @param radius Defines the camera distance from its target
-     * @param target Defines the camera target
-     * @param scene Defines the scene the camera belongs to
-     * @param setActiveOnSceneIfNoneActive Defines whether the camera should be marked as active if not other active cameras have been defined
-     */
-    constructor(name, alpha, beta, radius, target, scene, setActiveOnSceneIfNoneActive = true) {
-        super(name, Vector3.Zero(), scene, setActiveOnSceneIfNoneActive);
-        /**
-         * Current inertia value on the longitudinal axis.
-         * The bigger this number the longer it will take for the camera to stop.
-         */
-        this.inertialAlphaOffset = 0;
-        /**
-         * Current inertia value on the latitudinal axis.
-         * The bigger this number the longer it will take for the camera to stop.
-         */
-        this.inertialBetaOffset = 0;
-        /**
-         * Current inertia value on the radius axis.
-         * The bigger this number the longer it will take for the camera to stop.
-         */
-        this.inertialRadiusOffset = 0;
-        /**
-         * Minimum allowed angle on the longitudinal axis.
-         * This can help limiting how the Camera is able to move in the scene.
-         */
-        this.lowerAlphaLimit = null;
-        /**
-         * Maximum allowed angle on the longitudinal axis.
-         * This can help limiting how the Camera is able to move in the scene.
-         */
-        this.upperAlphaLimit = null;
-        /**
-         * Minimum allowed angle on the latitudinal axis.
-         * This can help limiting how the Camera is able to move in the scene.
-         */
-        this.lowerBetaLimit = 0.01;
-        /**
-         * Maximum allowed angle on the latitudinal axis.
-         * This can help limiting how the Camera is able to move in the scene.
-         */
-        this.upperBetaLimit = Math.PI - 0.01;
-        /**
-         * Minimum allowed distance of the camera to the target (The camera can not get closer).
-         * This can help limiting how the Camera is able to move in the scene.
-         */
-        this.lowerRadiusLimit = null;
-        /**
-         * Maximum allowed distance of the camera to the target (The camera can not get further).
-         * This can help limiting how the Camera is able to move in the scene.
-         */
-        this.upperRadiusLimit = null;
-        /**
-         * Defines the current inertia value used during panning of the camera along the X axis.
-         */
-        this.inertialPanningX = 0;
-        /**
-         * Defines the current inertia value used during panning of the camera along the Y axis.
-         */
-        this.inertialPanningY = 0;
-        /**
-         * Defines the distance used to consider the camera in pan mode vs pinch/zoom.
-         * Basically if your fingers moves away from more than this distance you will be considered
-         * in pinch mode.
-         */
-        this.pinchToPanMaxDistance = 20;
-        /**
-         * Defines the maximum distance the camera can pan.
-         * This could help keeping the camera always in your scene.
-         */
-        this.panningDistanceLimit = null;
-        /**
-         * Defines the target of the camera before panning.
-         */
-        this.panningOriginTarget = Vector3.Zero();
-        /**
-         * Defines the value of the inertia used during panning.
-         * 0 would mean stop inertia and one would mean no deceleration at all.
-         */
-        this.panningInertia = 0.9;
-        //-- end properties for backward compatibility for inputs
-        /**
-         * Defines how much the radius should be scaled while zooming on a particular mesh (through the zoomOn function)
-         */
-        this.zoomOnFactor = 1;
-        /**
-         * Defines a screen offset for the camera position.
-         */
-        this.targetScreenOffset = Vector2.Zero();
-        /**
-         * Allows the camera to be completely reversed.
-         * If false the camera can not arrive upside down.
-         */
-        this.allowUpsideDown = true;
-        /**
-         * Define if double tap/click is used to restore the previously saved state of the camera.
-         */
-        this.useInputToRestoreState = true;
-        /** @internal */
-        this._viewMatrix = new Matrix();
-        /**
-         * Defines the allowed panning axis.
-         */
-        this.panningAxis = new Vector3(1, 1, 0);
-        this._transformedDirection = new Vector3();
-        /**
-         * Defines if camera will eliminate transform on y axis.
-         */
-        this.mapPanning = false;
-        /**
-         * Observable triggered when the mesh target has been changed on the camera.
-         */
-        this.onMeshTargetChangedObservable = new Observable();
-        /**
-         * Defines whether the camera should check collision with the objects oh the scene.
-         * @see https://doc.babylonjs.com/features/featuresDeepDive/cameras/camera_collisions#how-can-i-do-this-
-         */
-        this.checkCollisions = false;
-        /**
-         * Defines the collision radius of the camera.
-         * This simulates a sphere around the camera.
-         * @see https://doc.babylonjs.com/features/featuresDeepDive/cameras/camera_collisions#arcrotatecamera
-         */
-        this.collisionRadius = new Vector3(0.5, 0.5, 0.5);
-        this._previousPosition = Vector3.Zero();
-        this._collisionVelocity = Vector3.Zero();
-        this._newPosition = Vector3.Zero();
-        this._computationVector = Vector3.Zero();
-        this._onCollisionPositionChange = (collisionId, newPosition, collidedMesh = null) => {
-            if (!collidedMesh) {
-                this._previousPosition.copyFrom(this._position);
-            }
-            else {
-                this.setPosition(newPosition);
-                if (this.onCollide) {
-                    this.onCollide(collidedMesh);
-                }
-            }
-            // Recompute because of constraints
-            const cosa = Math.cos(this.alpha);
-            const sina = Math.sin(this.alpha);
-            const cosb = Math.cos(this.beta);
-            let sinb = Math.sin(this.beta);
-            if (sinb === 0) {
-                sinb = 0.0001;
-            }
-            const target = this._getTargetPosition();
-            this._computationVector.copyFromFloats(this.radius * cosa * sinb, this.radius * cosb, this.radius * sina * sinb);
-            target.addToRef(this._computationVector, this._newPosition);
-            this._position.copyFrom(this._newPosition);
-            let up = this.upVector;
-            if (this.allowUpsideDown && this.beta < 0) {
-                up = up.clone();
-                up = up.negate();
-            }
-            this._computeViewMatrix(this._position, target, up);
-            this._viewMatrix.addAtIndex(12, this.targetScreenOffset.x);
-            this._viewMatrix.addAtIndex(13, this.targetScreenOffset.y);
-            this._collisionTriggered = false;
-        };
-        this._target = Vector3.Zero();
-        if (target) {
-            this.setTarget(target);
-        }
-        this.alpha = alpha;
-        this.beta = beta;
-        this.radius = radius;
-        this.getViewMatrix();
-        this.inputs = new ArcRotateCameraInputsManager(this);
-        this.inputs.addKeyboard().addMouseWheel().addPointers();
-    }
     /**
      * Defines the target point of the camera.
      * The camera looks towards it from the radius distance.
@@ -564,6 +388,182 @@ export class ArcRotateCamera extends TargetCamera {
             this._autoRotationBehavior = null;
         }
     }
+    /**
+     * Instantiates a new ArcRotateCamera in a given scene
+     * @param name Defines the name of the camera
+     * @param alpha Defines the camera rotation along the longitudinal axis
+     * @param beta Defines the camera rotation along the latitudinal axis
+     * @param radius Defines the camera distance from its target
+     * @param target Defines the camera target
+     * @param scene Defines the scene the camera belongs to
+     * @param setActiveOnSceneIfNoneActive Defines whether the camera should be marked as active if not other active cameras have been defined
+     */
+    constructor(name, alpha, beta, radius, target, scene, setActiveOnSceneIfNoneActive = true) {
+        super(name, Vector3.Zero(), scene, setActiveOnSceneIfNoneActive);
+        /**
+         * Current inertia value on the longitudinal axis.
+         * The bigger this number the longer it will take for the camera to stop.
+         */
+        this.inertialAlphaOffset = 0;
+        /**
+         * Current inertia value on the latitudinal axis.
+         * The bigger this number the longer it will take for the camera to stop.
+         */
+        this.inertialBetaOffset = 0;
+        /**
+         * Current inertia value on the radius axis.
+         * The bigger this number the longer it will take for the camera to stop.
+         */
+        this.inertialRadiusOffset = 0;
+        /**
+         * Minimum allowed angle on the longitudinal axis.
+         * This can help limiting how the Camera is able to move in the scene.
+         */
+        this.lowerAlphaLimit = null;
+        /**
+         * Maximum allowed angle on the longitudinal axis.
+         * This can help limiting how the Camera is able to move in the scene.
+         */
+        this.upperAlphaLimit = null;
+        /**
+         * Minimum allowed angle on the latitudinal axis.
+         * This can help limiting how the Camera is able to move in the scene.
+         */
+        this.lowerBetaLimit = 0.01;
+        /**
+         * Maximum allowed angle on the latitudinal axis.
+         * This can help limiting how the Camera is able to move in the scene.
+         */
+        this.upperBetaLimit = Math.PI - 0.01;
+        /**
+         * Minimum allowed distance of the camera to the target (The camera can not get closer).
+         * This can help limiting how the Camera is able to move in the scene.
+         */
+        this.lowerRadiusLimit = null;
+        /**
+         * Maximum allowed distance of the camera to the target (The camera can not get further).
+         * This can help limiting how the Camera is able to move in the scene.
+         */
+        this.upperRadiusLimit = null;
+        /**
+         * Defines the current inertia value used during panning of the camera along the X axis.
+         */
+        this.inertialPanningX = 0;
+        /**
+         * Defines the current inertia value used during panning of the camera along the Y axis.
+         */
+        this.inertialPanningY = 0;
+        /**
+         * Defines the distance used to consider the camera in pan mode vs pinch/zoom.
+         * Basically if your fingers moves away from more than this distance you will be considered
+         * in pinch mode.
+         */
+        this.pinchToPanMaxDistance = 20;
+        /**
+         * Defines the maximum distance the camera can pan.
+         * This could help keeping the camera always in your scene.
+         */
+        this.panningDistanceLimit = null;
+        /**
+         * Defines the target of the camera before panning.
+         */
+        this.panningOriginTarget = Vector3.Zero();
+        /**
+         * Defines the value of the inertia used during panning.
+         * 0 would mean stop inertia and one would mean no deceleration at all.
+         */
+        this.panningInertia = 0.9;
+        //-- end properties for backward compatibility for inputs
+        /**
+         * Defines how much the radius should be scaled while zooming on a particular mesh (through the zoomOn function)
+         */
+        this.zoomOnFactor = 1;
+        /**
+         * Defines a screen offset for the camera position.
+         */
+        this.targetScreenOffset = Vector2.Zero();
+        /**
+         * Allows the camera to be completely reversed.
+         * If false the camera can not arrive upside down.
+         */
+        this.allowUpsideDown = true;
+        /**
+         * Define if double tap/click is used to restore the previously saved state of the camera.
+         */
+        this.useInputToRestoreState = true;
+        /** @internal */
+        this._viewMatrix = new Matrix();
+        /**
+         * Defines the allowed panning axis.
+         */
+        this.panningAxis = new Vector3(1, 1, 0);
+        this._transformedDirection = new Vector3();
+        /**
+         * Defines if camera will eliminate transform on y axis.
+         */
+        this.mapPanning = false;
+        /**
+         * Observable triggered when the mesh target has been changed on the camera.
+         */
+        this.onMeshTargetChangedObservable = new Observable();
+        /**
+         * Defines whether the camera should check collision with the objects oh the scene.
+         * @see https://doc.babylonjs.com/features/featuresDeepDive/cameras/camera_collisions#how-can-i-do-this-
+         */
+        this.checkCollisions = false;
+        /**
+         * Defines the collision radius of the camera.
+         * This simulates a sphere around the camera.
+         * @see https://doc.babylonjs.com/features/featuresDeepDive/cameras/camera_collisions#arcrotatecamera
+         */
+        this.collisionRadius = new Vector3(0.5, 0.5, 0.5);
+        this._previousPosition = Vector3.Zero();
+        this._collisionVelocity = Vector3.Zero();
+        this._newPosition = Vector3.Zero();
+        this._computationVector = Vector3.Zero();
+        this._onCollisionPositionChange = (collisionId, newPosition, collidedMesh = null) => {
+            if (!collidedMesh) {
+                this._previousPosition.copyFrom(this._position);
+            }
+            else {
+                this.setPosition(newPosition);
+                if (this.onCollide) {
+                    this.onCollide(collidedMesh);
+                }
+            }
+            // Recompute because of constraints
+            const cosa = Math.cos(this.alpha);
+            const sina = Math.sin(this.alpha);
+            const cosb = Math.cos(this.beta);
+            let sinb = Math.sin(this.beta);
+            if (sinb === 0) {
+                sinb = 0.0001;
+            }
+            const target = this._getTargetPosition();
+            this._computationVector.copyFromFloats(this.radius * cosa * sinb, this.radius * cosb, this.radius * sina * sinb);
+            target.addToRef(this._computationVector, this._newPosition);
+            this._position.copyFrom(this._newPosition);
+            let up = this.upVector;
+            if (this.allowUpsideDown && this.beta < 0) {
+                up = up.clone();
+                up = up.negate();
+            }
+            this._computeViewMatrix(this._position, target, up);
+            this._viewMatrix.addAtIndex(12, this.targetScreenOffset.x);
+            this._viewMatrix.addAtIndex(13, this.targetScreenOffset.y);
+            this._collisionTriggered = false;
+        };
+        this._target = Vector3.Zero();
+        if (target) {
+            this.setTarget(target);
+        }
+        this.alpha = alpha;
+        this.beta = beta;
+        this.radius = radius;
+        this.getViewMatrix();
+        this.inputs = new ArcRotateCameraInputsManager(this);
+        this.inputs.addKeyboard().addMouseWheel().addPointers();
+    }
     // Cache
     /** @internal */
     _initCache() {