Merge

dist/preview release/babylon.max.js

@@ -53046,6 +53046,486 @@ var BABYLON;
 //# sourceMappingURL=babylon.arcRotateCamera.js.map
 
 
+var BABYLON;
+(function (BABYLON) {
+    /**
+     * Manage the keyboard inputs to control the movement of an arc rotate camera.
+     * @see http://doc.babylonjs.com/how_to/customizing_camera_inputs
+     */
+    var FollowCameraKeyboardMoveInput = /** @class */ (function () {
+        function FollowCameraKeyboardMoveInput() {
+            /**
+             * Defines the list of key codes associated with the up action (increase heightOffset)
+             */
+            this.keysUp = [38];
+            /**
+             * Defines the list of key codes associated with the down action (decrease heightOffset)
+             */
+            this.keysDown = [40];
+            /**
+             * Defines the list of key codes associated with the left action (increase rotation)
+             */
+            this.keysLeft = [37];
+            /**
+             * Defines the list of key codes associated with the right action (decrease rotation)
+             */
+            this.keysRight = [39];
+            /**
+             * Defines the rate of change of heightOffset.
+             */
+            this.heightSensibility = 1;
+            /**
+             * Defines the rate of change of rotationOffset.
+             */
+            this.rotationSensibility = 1;
+            /**
+             * Defines the rate of change of radius.
+             */
+            this.radiusSensibility = 1;
+            /**
+             * Defines the minimum heightOffset value.
+             */
+            this.minHeightOffset = 0;
+            /**
+             * Defines the minimum radius value.
+             */
+            this.minRadius = 0;
+            this._keys = new Array();
+        }
+        /**
+         * Attach the input controls to a specific dom element to get the input from.
+         * @param element Defines the element the controls should be listened from
+         * @param noPreventDefault Defines whether event caught by the controls should call preventdefault() (https://developer.mozilla.org/en-US/docs/Web/API/Event/preventDefault)
+         */
+        FollowCameraKeyboardMoveInput.prototype.attachControl = function (element, noPreventDefault) {
+            var _this = this;
+            if (this._onCanvasBlurObserver) {
+                return;
+            }
+            this._scene = this.camera.getScene();
+            this._engine = this._scene.getEngine();
+            this._onCanvasBlurObserver = this._engine.onCanvasBlurObservable.add(function () {
+                _this._keys = [];
+            });
+            this._onKeyboardObserver = this._scene.onKeyboardObservable.add(function (info) {
+                var evt = info.event;
+                if (!evt.metaKey) {
+                    if (info.type === BABYLON.KeyboardEventTypes.KEYDOWN) {
+                        // this._ctrlPressed = evt.ctrlKey;
+                        _this._altPressed = evt.altKey;
+                        if (_this.keysUp.indexOf(evt.keyCode) !== -1 ||
+                            _this.keysDown.indexOf(evt.keyCode) !== -1 ||
+                            _this.keysLeft.indexOf(evt.keyCode) !== -1 ||
+                            _this.keysRight.indexOf(evt.keyCode) !== -1) {
+                            var index = _this._keys.indexOf(evt.keyCode);
+                            if (index === -1) {
+                                _this._keys.push(evt.keyCode);
+                            }
+                            if (evt.preventDefault) {
+                                if (!noPreventDefault) {
+                                    evt.preventDefault();
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        if (_this.keysUp.indexOf(evt.keyCode) !== -1 ||
+                            _this.keysDown.indexOf(evt.keyCode) !== -1 ||
+                            _this.keysLeft.indexOf(evt.keyCode) !== -1 ||
+                            _this.keysRight.indexOf(evt.keyCode) !== -1) {
+                            var index = _this._keys.indexOf(evt.keyCode);
+                            if (index >= 0) {
+                                _this._keys.splice(index, 1);
+                            }
+                            if (evt.preventDefault) {
+                                if (!noPreventDefault) {
+                                    evt.preventDefault();
+                                }
+                            }
+                        }
+                    }
+                }
+            });
+        };
+        /**
+         * Detach the current controls from the specified dom element.
+         * @param element Defines the element to stop listening the inputs from
+         */
+        FollowCameraKeyboardMoveInput.prototype.detachControl = function (element) {
+            if (this._scene) {
+                if (this._onKeyboardObserver) {
+                    this._scene.onKeyboardObservable.remove(this._onKeyboardObserver);
+                }
+                if (this._onCanvasBlurObserver) {
+                    this._engine.onCanvasBlurObservable.remove(this._onCanvasBlurObserver);
+                }
+                this._onKeyboardObserver = null;
+                this._onCanvasBlurObserver = null;
+            }
+            this._keys = [];
+        };
+        /**
+         * Update the current camera state depending on the inputs that have been used this frame.
+         * This is a dynamically created lambda to avoid the performance penalty of looping for inputs in the render loop.
+         */
+        FollowCameraKeyboardMoveInput.prototype.checkInputs = function () {
+            if (this._onKeyboardObserver) {
+                for (var index = 0; index < this._keys.length; index++) {
+                    var keyCode = this._keys[index];
+                    if (this.keysLeft.indexOf(keyCode) !== -1) {
+                        this.camera.rotationOffset += this.rotationSensibility;
+                        this.camera.rotationOffset %= 180;
+                    }
+                    else if (this.keysUp.indexOf(keyCode) !== -1) {
+                        if (this._altPressed) {
+                            this.camera.radius += this.radiusSensibility;
+                        }
+                        else {
+                            this.camera.heightOffset += this.heightSensibility;
+                        }
+                    }
+                    else if (this.keysRight.indexOf(keyCode) !== -1) {
+                        this.camera.rotationOffset -= this.rotationSensibility;
+                        this.camera.rotationOffset %= 180;
+                    }
+                    else if (this.keysDown.indexOf(keyCode) !== -1) {
+                        if (this._altPressed) {
+                            this.camera.radius -= this.radiusSensibility;
+                            this.camera.radius =
+                                Math.max(this.minRadius, this.camera.radius);
+                        }
+                        else {
+                            this.camera.heightOffset -= this.heightSensibility;
+                            this.camera.heightOffset =
+                                Math.max(this.minHeightOffset, this.camera.heightOffset);
+                        }
+                    }
+                }
+            }
+        };
+        /**
+         * Gets the class name of the current intput.
+         * @returns the class name
+         */
+        FollowCameraKeyboardMoveInput.prototype.getClassName = function () {
+            return "FollowCameraKeyboardMoveInput";
+        };
+        /**
+         * Get the friendly name associated with the input class.
+         * @returns the input friendly name
+         */
+        FollowCameraKeyboardMoveInput.prototype.getSimpleName = function () {
+            return "keyboard";
+        };
+        __decorate([
+            BABYLON.serialize()
+        ], FollowCameraKeyboardMoveInput.prototype, "keysUp", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], FollowCameraKeyboardMoveInput.prototype, "keysDown", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], FollowCameraKeyboardMoveInput.prototype, "keysLeft", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], FollowCameraKeyboardMoveInput.prototype, "keysRight", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], FollowCameraKeyboardMoveInput.prototype, "heightSensibility", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], FollowCameraKeyboardMoveInput.prototype, "rotationSensibility", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], FollowCameraKeyboardMoveInput.prototype, "radiusSensibility", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], FollowCameraKeyboardMoveInput.prototype, "minHeightOffset", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], FollowCameraKeyboardMoveInput.prototype, "minRadius", void 0);
+        return FollowCameraKeyboardMoveInput;
+    }());
+    BABYLON.FollowCameraKeyboardMoveInput = FollowCameraKeyboardMoveInput;
+    BABYLON.CameraInputTypes["FollowCameraKeyboardMoveInput"] = FollowCameraKeyboardMoveInput;
+})(BABYLON || (BABYLON = {}));
+
+//# sourceMappingURL=babylon.followCameraKeyboardMoveInput.js.map
+
+
+var BABYLON;
+(function (BABYLON) {
+    /**
+     * Default Inputs manager for the FollowCamera.
+     * It groups all the default supported inputs for ease of use.
+     * @see http://doc.babylonjs.com/how_to/customizing_camera_inputs
+     */
+    var FollowCameraInputsManager = /** @class */ (function (_super) {
+        __extends(FollowCameraInputsManager, _super);
+        /**
+         * Instantiates a new FollowCameraInputsManager.
+         * @param camera Defines the camera the inputs belong to
+         */
+        function FollowCameraInputsManager(camera) {
+            return _super.call(this, camera) || this;
+        }
+        /**
+         * Add keyboard input support to the input manager.
+         * @returns the current input manager
+         */
+        FollowCameraInputsManager.prototype.addKeyboard = function () {
+            this.add(new BABYLON.FollowCameraKeyboardMoveInput());
+            return this;
+        };
+        /**
+         * Add mouse wheel input support to the input manager.
+         * @returns the current input manager
+         */
+        FollowCameraInputsManager.prototype.addMouseWheel = function () {
+            console.warn("MouseWheel support not yet implemented for FollowCamera.");
+            return this;
+        };
+        /**
+         * Add pointers input support to the input manager.
+         * @returns the current input manager
+         */
+        FollowCameraInputsManager.prototype.addPointers = function () {
+            console.warn("Pointer support not yet implemented for FollowCamera.");
+            return this;
+        };
+        /**
+         * Add orientation input support to the input manager.
+         * @returns the current input manager
+         */
+        FollowCameraInputsManager.prototype.addVRDeviceOrientation = function () {
+            console.warn("DeviceOrientation support not yet implemented for FollowCamera.");
+            return this;
+        };
+        return FollowCameraInputsManager;
+    }(BABYLON.CameraInputsManager));
+    BABYLON.FollowCameraInputsManager = FollowCameraInputsManager;
+})(BABYLON || (BABYLON = {}));
+
+//# sourceMappingURL=babylon.followCameraInputsManager.js.map
+
+
+
+
+
+
+
+var BABYLON;
+(function (BABYLON) {
+    BABYLON.Node.AddNodeConstructor("FollowCamera", function (name, scene) {
+        return function () { return new FollowCamera(name, BABYLON.Vector3.Zero(), scene); };
+    });
+    BABYLON.Node.AddNodeConstructor("ArcFollowCamera", function (name, scene) {
+        return function () { return new ArcFollowCamera(name, 0, 0, 1.0, null, scene); };
+    });
+    /**
+     * A follow camera takes a mesh as a target and follows it as it moves. Both a free camera version followCamera and
+     * an arc rotate version arcFollowCamera are available.
+     * @see http://doc.babylonjs.com/features/cameras#follow-camera
+     */
+    var FollowCamera = /** @class */ (function (_super) {
+        __extends(FollowCamera, _super);
+        /**
+         * Instantiates the follow camera.
+         * @see http://doc.babylonjs.com/features/cameras#follow-camera
+         * @param name Define the name of the camera in the scene
+         * @param position Define the position of the camera
+         * @param scene Define the scene the camera belong to
+         * @param lockedTarget Define the target of the camera
+         */
+        function FollowCamera(name, position, scene, lockedTarget) {
+            if (lockedTarget === void 0) { lockedTarget = null; }
+            var _this = _super.call(this, name, position, scene) || this;
+            /**
+             * Distance the follow camera should follow an object at
+             */
+            _this.radius = 12;
+            /**
+             * Define a rotation offset between the camera and the object it follows
+             */
+            _this.rotationOffset = 0;
+            /**
+             * Define a height offset between the camera and the object it follows.
+             * It can help following an object from the top (like a car chaing a plane)
+             */
+            _this.heightOffset = 4;
+            /**
+             * Define how fast the camera can accelerate to follow it s target.
+             */
+            _this.cameraAcceleration = 0.05;
+            /**
+             * Define the speed limit of the camera following an object.
+             */
+            _this.maxCameraSpeed = 20;
+            _this.lockedTarget = lockedTarget;
+            _this.inputs = new BABYLON.FollowCameraInputsManager(_this);
+            _this.inputs.addKeyboard();
+            return _this;
+            // Uncomment the following line when the relevant handlers have been implemented.
+            // this.inputs.addKeyboard().addMouseWheel().addPointers().addVRDeviceOrientation();
+        }
+        FollowCamera.prototype._follow = function (cameraTarget) {
+            if (!cameraTarget) {
+                return;
+            }
+            var yRotation;
+            if (cameraTarget.rotationQuaternion) {
+                var rotMatrix = new BABYLON.Matrix();
+                cameraTarget.rotationQuaternion.toRotationMatrix(rotMatrix);
+                yRotation = Math.atan2(rotMatrix.m[8], rotMatrix.m[10]);
+            }
+            else {
+                yRotation = cameraTarget.rotation.y;
+            }
+            var radians = BABYLON.Tools.ToRadians(this.rotationOffset) + yRotation;
+            var targetPosition = cameraTarget.getAbsolutePosition();
+            var targetX = targetPosition.x + Math.sin(radians) * this.radius;
+            var targetZ = targetPosition.z + Math.cos(radians) * this.radius;
+            var dx = targetX - this.position.x;
+            var dy = (targetPosition.y + this.heightOffset) - this.position.y;
+            var dz = (targetZ) - this.position.z;
+            var vx = dx * this.cameraAcceleration * 2; //this is set to .05
+            var vy = dy * this.cameraAcceleration;
+            var vz = dz * this.cameraAcceleration * 2;
+            if (vx > this.maxCameraSpeed || vx < -this.maxCameraSpeed) {
+                vx = vx < 1 ? -this.maxCameraSpeed : this.maxCameraSpeed;
+            }
+            if (vy > this.maxCameraSpeed || vy < -this.maxCameraSpeed) {
+                vy = vy < 1 ? -this.maxCameraSpeed : this.maxCameraSpeed;
+            }
+            if (vz > this.maxCameraSpeed || vz < -this.maxCameraSpeed) {
+                vz = vz < 1 ? -this.maxCameraSpeed : this.maxCameraSpeed;
+            }
+            this.position = new BABYLON.Vector3(this.position.x + vx, this.position.y + vy, this.position.z + vz);
+            this.setTarget(targetPosition);
+        };
+        /**
+         * Attached controls to the current camera.
+         * @param element Defines the element the controls should be listened from
+         * @param noPreventDefault Defines whether event caught by the controls should call preventdefault() (https://developer.mozilla.org/en-US/docs/Web/API/Event/preventDefault)
+         */
+        FollowCamera.prototype.attachControl = function (element, noPreventDefault) {
+            this.inputs.attachElement(element, noPreventDefault);
+            this._reset = function () {
+            };
+        };
+        /**
+         * Detach the current controls from the camera.
+         * The camera will stop reacting to inputs.
+         * @param element Defines the element to stop listening the inputs from
+         */
+        FollowCamera.prototype.detachControl = function (element) {
+            this.inputs.detachElement(element);
+            if (this._reset) {
+                this._reset();
+            }
+        };
+        /** @hidden */
+        FollowCamera.prototype._checkInputs = function () {
+            this.inputs.checkInputs();
+            _super.prototype._checkInputs.call(this);
+            if (this.lockedTarget) {
+                this._follow(this.lockedTarget);
+            }
+        };
+        /**
+         * Gets the camera class name.
+         * @returns the class name
+         */
+        FollowCamera.prototype.getClassName = function () {
+            return "FollowCamera";
+        };
+        __decorate([
+            BABYLON.serialize()
+        ], FollowCamera.prototype, "radius", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], FollowCamera.prototype, "rotationOffset", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], FollowCamera.prototype, "heightOffset", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], FollowCamera.prototype, "cameraAcceleration", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], FollowCamera.prototype, "maxCameraSpeed", void 0);
+        __decorate([
+            BABYLON.serializeAsMeshReference("lockedTargetId")
+        ], FollowCamera.prototype, "lockedTarget", void 0);
+        return FollowCamera;
+    }(BABYLON.TargetCamera));
+    BABYLON.FollowCamera = FollowCamera;
+    /**
+     * Arc Rotate version of the follow camera.
+     * It still follows a Defined mesh but in an Arc Rotate Camera fashion.
+     * @see http://doc.babylonjs.com/features/cameras#follow-camera
+     */
+    var ArcFollowCamera = /** @class */ (function (_super) {
+        __extends(ArcFollowCamera, _super);
+        /**
+         * Instantiates a new ArcFollowCamera
+         * @see http://doc.babylonjs.com/features/cameras#follow-camera
+         * @param name Define the name of the camera
+         * @param alpha Define the rotation angle of the camera around the logitudinal axis
+         * @param beta Define the rotation angle of the camera around the elevation axis
+         * @param radius Define the radius of the camera from its target point
+         * @param target Define the target of the camera
+         * @param scene Define the scene the camera belongs to
+         */
+        function ArcFollowCamera(name, 
+        /** The longitudinal angle of the camera */
+        alpha, 
+        /** The latitudinal angle of the camera */
+        beta, 
+        /** The radius of the camera from its target */
+        radius, 
+        /** Define the camera target (the messh it should follow) */
+        target, scene) {
+            var _this = _super.call(this, name, BABYLON.Vector3.Zero(), scene) || this;
+            _this.alpha = alpha;
+            _this.beta = beta;
+            _this.radius = radius;
+            _this.target = target;
+            _this._cartesianCoordinates = BABYLON.Vector3.Zero();
+            _this._follow();
+            return _this;
+        }
+        ArcFollowCamera.prototype._follow = function () {
+            if (!this.target) {
+                return;
+            }
+            this._cartesianCoordinates.x = this.radius * Math.cos(this.alpha) * Math.cos(this.beta);
+            this._cartesianCoordinates.y = this.radius * Math.sin(this.beta);
+            this._cartesianCoordinates.z = this.radius * Math.sin(this.alpha) * Math.cos(this.beta);
+            var targetPosition = this.target.getAbsolutePosition();
+            this.position = targetPosition.add(this._cartesianCoordinates);
+            this.setTarget(targetPosition);
+        };
+        /** @hidden */
+        ArcFollowCamera.prototype._checkInputs = function () {
+            _super.prototype._checkInputs.call(this);
+            this._follow();
+        };
+        /**
+         * Returns the class name of the object.
+         * It is mostly used internally for serialization purposes.
+         */
+        ArcFollowCamera.prototype.getClassName = function () {
+            return "ArcFollowCamera";
+        };
+        return ArcFollowCamera;
+    }(BABYLON.TargetCamera));
+    BABYLON.ArcFollowCamera = ArcFollowCamera;
+})(BABYLON || (BABYLON = {}));
+
+//# sourceMappingURL=babylon.followCamera.js.map
+
+
 
 
 
@@ -85354,197 +85834,6 @@ var BABYLON;
 //# sourceMappingURL=babylon.gamepadSceneComponent.js.map
 
 
-
-
-
-
-
-var BABYLON;
-(function (BABYLON) {
-    BABYLON.Node.AddNodeConstructor("FollowCamera", function (name, scene) {
-        return function () { return new FollowCamera(name, BABYLON.Vector3.Zero(), scene); };
-    });
-    BABYLON.Node.AddNodeConstructor("ArcFollowCamera", function (name, scene) {
-        return function () { return new ArcFollowCamera(name, 0, 0, 1.0, null, scene); };
-    });
-    /**
-     * A follow camera takes a mesh as a target and follows it as it moves. Both a free camera version followCamera and
-     * an arc rotate version arcFollowCamera are available.
-     * @see http://doc.babylonjs.com/features/cameras#follow-camera
-     */
-    var FollowCamera = /** @class */ (function (_super) {
-        __extends(FollowCamera, _super);
-        /**
-         * Instantiates the follow camera.
-         * @see http://doc.babylonjs.com/features/cameras#follow-camera
-         * @param name Define the name of the camera in the scene
-         * @param position Define the position of the camera
-         * @param scene Define the scene the camera belong to
-         * @param lockedTarget Define the target of the camera
-         */
-        function FollowCamera(name, position, scene, lockedTarget) {
-            if (lockedTarget === void 0) { lockedTarget = null; }
-            var _this = _super.call(this, name, position, scene) || this;
-            /**
-             * Distance the follow camera should follow an object at
-             */
-            _this.radius = 12;
-            /**
-             * Define a rotation offset between the camera and the object it follows
-             */
-            _this.rotationOffset = 0;
-            /**
-             * Define a height offset between the camera and the object it follows.
-             * It can help following an object from the top (like a car chaing a plane)
-             */
-            _this.heightOffset = 4;
-            /**
-             * Define how fast the camera can accelerate to follow it s target.
-             */
-            _this.cameraAcceleration = 0.05;
-            /**
-             * Define the speed limit of the camera following an object.
-             */
-            _this.maxCameraSpeed = 20;
-            _this.lockedTarget = lockedTarget;
-            return _this;
-        }
-        FollowCamera.prototype._follow = function (cameraTarget) {
-            if (!cameraTarget) {
-                return;
-            }
-            var yRotation;
-            if (cameraTarget.rotationQuaternion) {
-                var rotMatrix = new BABYLON.Matrix();
-                cameraTarget.rotationQuaternion.toRotationMatrix(rotMatrix);
-                yRotation = Math.atan2(rotMatrix.m[8], rotMatrix.m[10]);
-            }
-            else {
-                yRotation = cameraTarget.rotation.y;
-            }
-            var radians = BABYLON.Tools.ToRadians(this.rotationOffset) + yRotation;
-            var targetPosition = cameraTarget.getAbsolutePosition();
-            var targetX = targetPosition.x + Math.sin(radians) * this.radius;
-            var targetZ = targetPosition.z + Math.cos(radians) * this.radius;
-            var dx = targetX - this.position.x;
-            var dy = (targetPosition.y + this.heightOffset) - this.position.y;
-            var dz = (targetZ) - this.position.z;
-            var vx = dx * this.cameraAcceleration * 2; //this is set to .05
-            var vy = dy * this.cameraAcceleration;
-            var vz = dz * this.cameraAcceleration * 2;
-            if (vx > this.maxCameraSpeed || vx < -this.maxCameraSpeed) {
-                vx = vx < 1 ? -this.maxCameraSpeed : this.maxCameraSpeed;
-            }
-            if (vy > this.maxCameraSpeed || vy < -this.maxCameraSpeed) {
-                vy = vy < 1 ? -this.maxCameraSpeed : this.maxCameraSpeed;
-            }
-            if (vz > this.maxCameraSpeed || vz < -this.maxCameraSpeed) {
-                vz = vz < 1 ? -this.maxCameraSpeed : this.maxCameraSpeed;
-            }
-            this.position = new BABYLON.Vector3(this.position.x + vx, this.position.y + vy, this.position.z + vz);
-            this.setTarget(targetPosition);
-        };
-        /** @hidden */
-        FollowCamera.prototype._checkInputs = function () {
-            _super.prototype._checkInputs.call(this);
-            if (this.lockedTarget) {
-                this._follow(this.lockedTarget);
-            }
-        };
-        /**
-         * Gets the camera class name.
-         * @returns the class name
-         */
-        FollowCamera.prototype.getClassName = function () {
-            return "FollowCamera";
-        };
-        __decorate([
-            BABYLON.serialize()
-        ], FollowCamera.prototype, "radius", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], FollowCamera.prototype, "rotationOffset", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], FollowCamera.prototype, "heightOffset", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], FollowCamera.prototype, "cameraAcceleration", void 0);
-        __decorate([
-            BABYLON.serialize()
-        ], FollowCamera.prototype, "maxCameraSpeed", void 0);
-        __decorate([
-            BABYLON.serializeAsMeshReference("lockedTargetId")
-        ], FollowCamera.prototype, "lockedTarget", void 0);
-        return FollowCamera;
-    }(BABYLON.TargetCamera));
-    BABYLON.FollowCamera = FollowCamera;
-    /**
-     * Arc Rotate version of the follow camera.
-     * It still follows a Defined mesh but in an Arc Rotate Camera fashion.
-     * @see http://doc.babylonjs.com/features/cameras#follow-camera
-     */
-    var ArcFollowCamera = /** @class */ (function (_super) {
-        __extends(ArcFollowCamera, _super);
-        /**
-         * Instantiates a new ArcFollowCamera
-         * @see http://doc.babylonjs.com/features/cameras#follow-camera
-         * @param name Define the name of the camera
-         * @param alpha Define the rotation angle of the camera around the logitudinal axis
-         * @param beta Define the rotation angle of the camera around the elevation axis
-         * @param radius Define the radius of the camera from its target point
-         * @param target Define the target of the camera
-         * @param scene Define the scene the camera belongs to
-         */
-        function ArcFollowCamera(name, 
-        /** The longitudinal angle of the camera */
-        alpha, 
-        /** The latitudinal angle of the camera */
-        beta, 
-        /** The radius of the camera from its target */
-        radius, 
-        /** Define the camera target (the messh it should follow) */
-        target, scene) {
-            var _this = _super.call(this, name, BABYLON.Vector3.Zero(), scene) || this;
-            _this.alpha = alpha;
-            _this.beta = beta;
-            _this.radius = radius;
-            _this.target = target;
-            _this._cartesianCoordinates = BABYLON.Vector3.Zero();
-            _this._follow();
-            return _this;
-        }
-        ArcFollowCamera.prototype._follow = function () {
-            if (!this.target) {
-                return;
-            }
-            this._cartesianCoordinates.x = this.radius * Math.cos(this.alpha) * Math.cos(this.beta);
-            this._cartesianCoordinates.y = this.radius * Math.sin(this.beta);
-            this._cartesianCoordinates.z = this.radius * Math.sin(this.alpha) * Math.cos(this.beta);
-            var targetPosition = this.target.getAbsolutePosition();
-            this.position = targetPosition.add(this._cartesianCoordinates);
-            this.setTarget(targetPosition);
-        };
-        /** @hidden */
-        ArcFollowCamera.prototype._checkInputs = function () {
-            _super.prototype._checkInputs.call(this);
-            this._follow();
-        };
-        /**
-         * Returns the class name of the object.
-         * It is mostly used internally for serialization purposes.
-         */
-        ArcFollowCamera.prototype.getClassName = function () {
-            return "ArcFollowCamera";
-        };
-        return ArcFollowCamera;
-    }(BABYLON.TargetCamera));
-    BABYLON.ArcFollowCamera = ArcFollowCamera;
-})(BABYLON || (BABYLON = {}));
-
-//# sourceMappingURL=babylon.followCamera.js.map
-
-
 var BABYLON;
 (function (BABYLON) {
     /**