CesiumFlyToController.cs

Go to the documentation of this file.

using System;
using Unity.Mathematics;
using UnityEngine;
 
namespace CesiumForUnity
{
    [DisallowMultipleComponent]
    [AddComponentMenu("Cesium/Cesium Fly To Controller")]
    [IconAttribute("Packages/com.cesium.unity/Editor/Resources/Cesium-24x24.png")]
    public class CesiumFlyToController : MonoBehaviour
    {
        [SerializeField]
        private AnimationCurve _flyToAltitudeProfileCurve;
 
        public AnimationCurve flyToAltitudeProfileCurve
        {
            get => this._flyToAltitudeProfileCurve;
            set => this._flyToAltitudeProfileCurve = value;
        }
 
        [SerializeField]
        private AnimationCurve _flyToProgressCurve;
 
        public AnimationCurve flyToProgressCurve
        {
            get => this._flyToProgressCurve;
            set => this._flyToProgressCurve = value;
        }
 
        [SerializeField]
        private AnimationCurve _flyToMaximumAltitudeCurve;
 
        public AnimationCurve flyToMaximumAltitudeCurve
        {
            get => this._flyToMaximumAltitudeCurve;
            set => this._flyToMaximumAltitudeCurve = value;
        }
 
        [SerializeField]
        [Min(0.0f)]
        private double _flyToDuration = 5.0;
 
        public double flyToDuration
        {
            get => this._flyToDuration;
            set => this._flyToDuration = Math.Max(value, 0.0);
        }
 
        #region Deprecated Functionality
        [Min(0.0f)]
        private double _flyToGranularityDegrees = 0.01;
 
        [Obsolete("CesiumFlyToController no longer works using keypoints. This value has no effect.")]
        public double flyToGranularityDegrees
        {
            get => this._flyToGranularityDegrees;
            set
            {
                this._flyToGranularityDegrees = Math.Max(value, 0.0);
                if (this._flyToGranularityDegrees == 0.0)
                {
                    Debug.LogWarning(
                        "FlyToGranularityDegrees must be set to a non-zero value. " +
                        "Otherwise, CesiumFlyToController will not fly to any " +
                        "specified location.");
                }
            }
        }
        #endregion
 
        public delegate void CompletedFlightDelegate();
 
        public event CompletedFlightDelegate OnFlightComplete;
 
        public delegate void InterruptedFlightDelegate();
 
        public event InterruptedFlightDelegate OnFlightInterrupted;
 
        private CesiumGeoreference _georeference;
        private CesiumGlobeAnchor _globeAnchor;
        private CesiumSimplePlanarEllipsoidCurve _flightPath;
        private double _flightPathLength;
 
        private CesiumCameraController _cameraController;
 
        private Quaternion _sourceRotation;
        private Quaternion _destinationRotation;
 
        private double3 _destinationECEF;
        private double3 _previousPositionECEF;
 
        private double _maxHeight;
 
        private double _currentFlyToTime = 0.0;
 
        private bool _flyingToLocation = false;
        private bool _canInterruptFlight = true;
 
        void Awake()
        {
            this._georeference = this.gameObject.GetComponentInParent<CesiumGeoreference>();
            if (this._georeference == null)
            {
                Debug.LogError(
                    "CesiumFlyToController must be nested under a game object " +
                    "with a CesiumGeoreference.");
            }
 
            this._globeAnchor = this.gameObject.GetComponentInParent<CesiumGlobeAnchor>();
            if (this._globeAnchor == null)
            {
                Debug.LogError("CesiumFlyToController expects a CesiumGlobeAnchor to be attached to itself or to a parent");
            }
 
            CesiumOriginShift originShift = this._globeAnchor.GetComponent<CesiumOriginShift>();
            if (originShift == null)
            {
                Debug.LogError("CesiumFlyToController expects a CesiumOriginShift to be attached to the CesiumGlobeAnchor above it");
            }
 
            // If a CesiumCameraController is present, CesiumFlyToController will account for
            // its inputs and modify it during flights.
            this._cameraController = this.gameObject.GetComponent<CesiumCameraController>();
        }
 
        void Update()
        {
            if (this._flyingToLocation)
            {
                this.HandleFlightStep(Time.deltaTime);
            }
        }
 
#if UNITY_EDITOR
        // Ensures required components are present in the editor.
        private void Reset()
        {
            CesiumGlobeAnchor anchor = this.gameObject.GetComponentInParent<CesiumGlobeAnchor>();
            if(anchor == null)
            {
                anchor = this.gameObject.AddComponent<CesiumGlobeAnchor>();
                Debug.LogWarning("CesiumFlyToController missing a CesiumGlobeAnchor - adding");
            }
 
            CesiumOriginShift origin = anchor.GetComponent<CesiumOriginShift>();
            if(origin == null)
            {
                origin = anchor.gameObject.AddComponent<CesiumOriginShift>();
                Debug.LogWarning("CesiumFlyToController missing a CesiumOriginShift - adding");
            }
        }
#endif
 
        private bool DetectMovementInput()
        {
            double3 currentPositionECEF = this._globeAnchor.positionGlobeFixed;
            double distanceSquared = math.lengthsq(currentPositionECEF - this._previousPositionECEF);
            const double distanceConsideredMovement = 1e-6; // 1/1000 of a millimeter
            return distanceSquared >= (distanceConsideredMovement * distanceConsideredMovement);
        }
 
        private void HandleFlightStep(float deltaTime)
        {
            if (!this._flyingToLocation || this._flightPath == null)
            {
                return;
            }
 
            if (this._georeference == null)
            {
                this._flyingToLocation = false;
                return;
            }
 
            if (this._canInterruptFlight && this.DetectMovementInput())
            {
                this.InterruptFlight();
                return;
            }
 
            this._currentFlyToTime += deltaTime;
 
            double flyPercentage = 0.0;
            if (this._currentFlyToTime >= this._flyToDuration)
            {
                flyPercentage = 1.0;
            }
            else if (this._flyToProgressCurve != null && this._flyToProgressCurve.length > 0)
            {
                // Sample the progress curve if we have one
                flyPercentage = math.clamp(this._flyToProgressCurve.Evaluate((float)(this._currentFlyToTime / this._flyToDuration)), 0.0, 1.0);
            }
            else
            {
                flyPercentage = this._currentFlyToTime / this._flyToDuration;
            }
 
            // If we're have it to the end of the flight, or if the flight we're taking isn't actually moving or rotating us at all, we're done.
            if (flyPercentage == 1.0 || (this._flightPathLength == 0.0 && this._sourceRotation == this._destinationRotation))
            {
                this.CompleteFlight();
                return;
            }
 
            // Calculate the height above the surface. If we have a profile curve, use it as well.
            double altituteOffset = 0.0;
            if (this._maxHeight != 0.0 && this.flyToAltitudeProfileCurve != null && this.flyToAltitudeProfileCurve.length > 0)
            {
                double curveOffset = this._maxHeight * this.flyToAltitudeProfileCurve.Evaluate((float)flyPercentage);
                altituteOffset += curveOffset;
            }
 
            // Update position.
            double3 currentPosition = this._flightPath.GetPosition(flyPercentage, altituteOffset);
            this._previousPositionECEF = currentPosition;
            this._globeAnchor.positionGlobeFixed = currentPosition;
 
            Quaternion currentQuat = Quaternion.Slerp(this._sourceRotation, this._destinationRotation, (float)flyPercentage);
            this._globeAnchor.rotationEastUpNorth = currentQuat;
        }
 
        private void CompleteFlight()
        {
            this._globeAnchor.positionGlobeFixed = _destinationECEF;
            this._globeAnchor.rotationEastUpNorth = this._destinationRotation;
 
            this._flyingToLocation = false;
            this._currentFlyToTime = 0.0;
 
            this._globeAnchor.adjustOrientationForGlobeWhenMoving = true;
            this._globeAnchor.detectTransformChanges = true;
 
            if (this._cameraController != null)
            {
                this._cameraController.enableMovement = true;
                this._cameraController.enableRotation = true;
            }
 
            if (this.OnFlightComplete != null)
            {
                this.OnFlightComplete();
            }
        }
 
        private void InterruptFlight()
        {
            this._flyingToLocation = false;
 
            // Set the controller's roll to 0.0
            Vector3 angles = this.transform.eulerAngles;
            angles.z = 0.0f;
            this.transform.eulerAngles = angles;
 
            this._globeAnchor.adjustOrientationForGlobeWhenMoving = true;
            this._globeAnchor.detectTransformChanges = true;
 
            if (this._cameraController != null)
            {
                this._cameraController.enableMovement = true;
                this._cameraController.enableRotation = true;
            }
 
            if (this.OnFlightInterrupted != null)
            {
                this.OnFlightInterrupted();
            }
        }
 
        private void ComputeFlightPath(
            double3 sourceECEF,
            double3 destinationECEF,
            float yawAtDestination,
            float pitchAtDestination)
        {
            // The source and destination rotations are expressed in East-Up-North coordinates.
            pitchAtDestination = Mathf.Clamp(pitchAtDestination, -89.99f, 89.99f);
            this._sourceRotation = this._globeAnchor.transform.rotation;
            this._destinationRotation = Quaternion.Euler(pitchAtDestination, yawAtDestination, 0.0f);
            this._destinationECEF = destinationECEF;
 
            this._flightPath = CesiumSimplePlanarEllipsoidCurve.FromCenteredFixedCoordinates(
                this._georeference.ellipsoid,
                sourceECEF, 
                destinationECEF);
            this._flightPathLength = math.length(sourceECEF - destinationECEF);
 
            this._maxHeight = 0.0;
            if (this._flyToAltitudeProfileCurve != null && this._flyToMaximumAltitudeCurve.length > 0)
            {
                this._maxHeight = 30000.0;
                if (this._flyToMaximumAltitudeCurve != null && this._flyToMaximumAltitudeCurve.length > 0)
                {
                    this._maxHeight = this._flyToMaximumAltitudeCurve.Evaluate((float)this._flightPathLength);
                }
            }
 
            this._previousPositionECEF = sourceECEF;
            this._flyingToLocation = true;
        }
 
        public void FlyToLocationEarthCenteredEarthFixed(
            double3 destination,
            float yawAtDestination,
            float pitchAtDestination,
            bool canInterruptByMoving)
        {
            if (this._flyingToLocation)
            {
                return;
            }
 
            pitchAtDestination = Mathf.Clamp(pitchAtDestination, -89.99f, 89.99f);
 
            // Compute source location in ECEF
            double3 source = this._globeAnchor.positionGlobeFixed;
 
            this.ComputeFlightPath(source, destination, yawAtDestination, pitchAtDestination);
 
            // Indicate that the controller will be flying from now
            this._flyingToLocation = true;
            this._canInterruptFlight = canInterruptByMoving;
            this._globeAnchor.adjustOrientationForGlobeWhenMoving = false;
            this._globeAnchor.detectTransformChanges = false;
 
            if (this._cameraController != null)
            {
                this._cameraController.enableMovement = canInterruptByMoving;
                this._cameraController.enableRotation = false;
            }
        }
 
        public void FlyToLocationEarthCenteredEarthFixed(
            Vector3 destination,
            float yawAtDestination,
            float pitchAtDestination,
            bool canInterruptByMoving)
        {
            this.FlyToLocationEarthCenteredEarthFixed(
                new double3()
                {
                    x = destination.x,
                    y = destination.y,
                    z = destination.z,
                },
                yawAtDestination,
                pitchAtDestination,
                canInterruptByMoving);
        }
 
        public void FlyToLocationLongitudeLatitudeHeight(
            double3 destination,
            float yawAtDestination,
            float pitchAtDestination,
            bool canInterruptByMoving)
        {
            double3 destinationECEF =
                this._georeference.ellipsoid.LongitudeLatitudeHeightToCenteredFixed(destination);
 
            this.FlyToLocationEarthCenteredEarthFixed(
                destinationECEF,
                yawAtDestination,
                pitchAtDestination,
                canInterruptByMoving);
        }
 
        public void FlyToLocationLongitudeLatitudeHeight(
            Vector3 destination,
            float yawAtDestination,
            float pitchAtDestination,
            bool canInterruptByMoving)
        {
            double3 destinationCoordinates = new double3()
            {
                x = destination.x,
                y = destination.y,
                z = destination.z
            };
            double3 destinationECEF =
                this._georeference.ellipsoid.LongitudeLatitudeHeightToCenteredFixed(
                    destinationCoordinates);
 
            this.FlyToLocationEarthCenteredEarthFixed(
                destinationECEF,
                yawAtDestination,
                pitchAtDestination,
                canInterruptByMoving);
        }
    }
}