CesiumGlobeAnchor.cs

Go to the documentation of this file.

using Reinterop;
using System;
using System.Collections;
using UnityEngine;
using Unity.Mathematics;
 
#if UNITY_EDITOR
using UnityEditor;
#endif
 
namespace CesiumForUnity
{
    [ExecuteInEditMode]
    [ReinteropNativeImplementation("CesiumForUnityNative::CesiumGlobeAnchorImpl", "CesiumGlobeAnchorImpl.h", staticOnly: true)]
    [AddComponentMenu("Cesium/Cesium Globe Anchor")]
    [IconAttribute("Packages/com.cesium.unity/Editor/Resources/Cesium-24x24.png")]
    public partial class CesiumGlobeAnchor : MonoBehaviour, ICesiumRestartable
    {
        #region Fields
 
        // These fields are marked internal so that they can be accessed from C++.
        // See https://github.com/CesiumGS/cesium-unity/issues/210
 
        [SerializeField]
        internal bool _adjustOrientationForGlobeWhenMoving = true;
 
        [SerializeField]
        internal bool _detectTransformChanges = true;
 
        [SerializeField]
        internal double4x4 _localToGlobeFixedMatrix = double4x4.identity;
 
        // True if _localToGlobeFixedMatrix has a valid value.
        // False if it has not yet been initialized from the Transform.
        [SerializeField]
        internal bool _localToGlobeFixedMatrixIsValid = false;
 
        // The last known local Transform, used to detect changes in the Transform so that
        // the precise globe coordinates can be recomputed from it. These are invalid before OnEnable.
        [NonSerialized]
        internal bool _lastLocalsAreValid = false;
 
        [NonSerialized]
        internal Vector3 _lastLocalPosition;
 
        [NonSerialized]
        internal Quaternion _lastLocalRotation;
 
        [NonSerialized]
        internal Vector3 _lastLocalScale;
 
        // The resolved georeference containing this globe anchor. This is just a cache
        // of `GetComponentInParent<CesiumGeoreference>()`.
        [NonSerialized]
        internal CesiumGeoreference _georeference;
 
        [NonSerialized]
        internal double3? _lastEllipsoidRadii;
 
        #endregion
 
        #region User-editable properties
 
        public bool adjustOrientationForGlobeWhenMoving
        {
            get => this._adjustOrientationForGlobeWhenMoving;
            set => this._adjustOrientationForGlobeWhenMoving = value;
        }
 
        public bool detectTransformChanges
        {
            get => this._detectTransformChanges;
            set
            {
                this._detectTransformChanges = value;
                this.StartOrStopDetectingTransformChanges();
            }
        }
 
        public double4x4 localToGlobeFixedMatrix
        {
            get
            {
                this.InitializeEcefIfNeeded();
                return this._localToGlobeFixedMatrix;
            }
            set
            {
                this.InitializeEcefIfNeeded();
                this.UpdateEcef(value);
            }
        }
 
        public double3 longitudeLatitudeHeight
        {
            get
            {
                this.UpdateGeoreferenceIfNecessary();
 
                if (this._georeference == null || this._georeference.ellipsoid == null)
                {
                    // Cannot get property if there is no georeference, or the georeference has no ellipsoid.
                    return new double3(0.0, 0.0, 0.0);
                }
 
                return this._georeference.ellipsoid.CenteredFixedToLongitudeLatitudeHeight(this.positionGlobeFixed);
            }
            set
            {
                this.UpdateGeoreferenceIfNecessary();
 
                if (this._georeference == null || this._georeference.ellipsoid == null)
                {
                    // Cannot set property if there is no georeference, or the georeference has no ellipsoid.
                    return;
                }
 
                this.positionGlobeFixed = this._georeference.ellipsoid.LongitudeLatitudeHeightToCenteredFixed(value);
            }
        }
 
        public double3 positionGlobeFixed
        {
            get => this.localToGlobeFixedMatrix.c3.xyz;
            set
            {
                double4x4 newModelToEcef = this.localToGlobeFixedMatrix;
                newModelToEcef.c3 = new double4(value.x, value.y, value.z, 1.0);
                this.localToGlobeFixedMatrix = newModelToEcef;
            }
        }
 
        public quaternion rotationGlobeFixed
        {
            get
            {
                double3 translation;
                quaternion rotation;
                double3 scale;
 
                Helpers.MatrixToTranslationRotationAndScale(this.localToGlobeFixedMatrix, out translation, out rotation, out scale);
 
                return rotation;
            }
            set
            {
                double3 translation;
                quaternion rotation;
                double3 scale;
 
                Helpers.MatrixToTranslationRotationAndScale(this.localToGlobeFixedMatrix, out translation, out rotation, out scale);
                this.localToGlobeFixedMatrix = Helpers.TranslationRotationAndScaleToMatrix(translation, value, scale);
            }
        }
 
        public quaternion rotationEastUpNorth
        {
            get
            {
                this.InitializeEcefIfNeeded();
                return this.GetLocalToEastUpNorthRotation();
            }
            set
            {
                this.InitializeEcefIfNeeded();
                this.SetLocalToEastUpNorthRotation(value);
            }
        }
 
        public double3 scaleGlobeFixed
        {
            get
            {
                double3 translation;
                quaternion rotation;
                double3 scale;
 
                Helpers.MatrixToTranslationRotationAndScale(this.localToGlobeFixedMatrix, out translation, out rotation, out scale);
 
                return scale;
            }
            set
            {
                double3 translation;
                quaternion rotation;
                double3 scale;
 
                Helpers.MatrixToTranslationRotationAndScale(this.localToGlobeFixedMatrix, out translation, out rotation, out scale);
                this.localToGlobeFixedMatrix = Helpers.TranslationRotationAndScaleToMatrix(translation, rotation, value);
            }
        }
 
        public double3 scaleEastUpNorth
        {
            get => -this.scaleGlobeFixed;
            set => this.scaleGlobeFixed = -value;
        }
 
        #endregion
 
        #region Deprecated Functionality
 
        [Obsolete("Use positionGlobeFixed.x instead.")]
        public double ecefX
        {
            get => this.positionGlobeFixed.x;
            set
            {
                double3 position = this.positionGlobeFixed;
                position.x = value;
                this.positionGlobeFixed = position;
            }
        }
 
        [Obsolete("Use positionGlobeFixed.y instead.")]
        public double ecefY
        {
            get => this.positionGlobeFixed.y;
            set
            {
                double3 position = this.positionGlobeFixed;
                position.y = value;
                this.positionGlobeFixed = position;
            }
        }
 
        [Obsolete("Use positionGlobeFixed.z instead.")]
        public double ecefZ
        {
            get => this.positionGlobeFixed.z;
            set
            {
                double3 position = this.positionGlobeFixed;
                position.z = value;
                this.positionGlobeFixed = position;
            }
        }
 
        [Obsolete("Use longitudeLatitudeHeight.x instead.")]
        public double longitude
        {
            get => this.longitudeLatitudeHeight.x;
            set
            {
                double3 position = this.longitudeLatitudeHeight;
                position.x = value;
                this.longitudeLatitudeHeight = position;
            }
        }
 
        [Obsolete("Use longitudeLatitudeHeight.y instead.")]
        public double latitude
        {
            get => this.longitudeLatitudeHeight.y;
            set
            {
                double3 position = this.longitudeLatitudeHeight;
                position.y = value;
                this.longitudeLatitudeHeight = position;
            }
        }
 
        [Obsolete("Use longitudeLatitudeHeight.z instead.")]
        public double height
        {
            get => this.longitudeLatitudeHeight.z;
            set
            {
                double3 position = this.longitudeLatitudeHeight;
                position.z = value;
                this.longitudeLatitudeHeight = position;
            }
        }
 
        [Obsolete("Set the longitudeLatitudeHeight property instead.")]
        public void SetPositionLongitudeLatitudeHeight(double longitude, double latitude, double height)
        {
            this.longitudeLatitudeHeight = new double3(longitude, latitude, height);
        }
 
 
        [Obsolete("Set the positionGlobeFixed property instead.")]
        public void SetPositionEarthCenteredEarthFixed(double x, double y, double z)
        {
            this.positionGlobeFixed = new double3(x, y, z);
        }
 
        #endregion
 
        #region Public Methods
 
        public void Sync()
        {
            // If the ellipsoid changed since last sync, we need to update from transform since our ECEF mapping
            // is going to be invalid.
            bool isEllipsoidChanged = this._lastEllipsoidRadii.HasValue && this._georeference != null ?
                (this._lastEllipsoidRadii.Value.x != this._georeference.ellipsoid.radii.x ||
                this._lastEllipsoidRadii.Value.y != this._georeference.ellipsoid.radii.y ||
                this._lastEllipsoidRadii.Value.z != this._georeference.ellipsoid.radii.z) : true;
 
            // If we don't have a local -> globe fixed matrix yet, we must update from the Transform
            bool updateFromTransform = !this._localToGlobeFixedMatrixIsValid;
            if (!isEllipsoidChanged && !updateFromTransform && this._lastLocalsAreValid)
            {
                // We may also need to update from the Transform if it has changed
                // since the last time we computed the local -> globe fixed matrix.
                updateFromTransform =
                    this._lastLocalPosition != this.transform.localPosition ||
                    this._lastLocalRotation != this.transform.localRotation ||
                    this._lastLocalScale != this.transform.localScale;
            }
 
            if (isEllipsoidChanged || updateFromTransform)
                this.UpdateEcefFromTransform();
            else
                this.UpdateEcef(this._localToGlobeFixedMatrix);
        }
 
        public void Restart()
        {
            this.UpdateGeoreference();
 
            if (this._georeference == null)
                Debug.LogWarning($"{this.gameObject.name} is not nested inside a game object with a CesiumGeoreference. Most of its CesiumGlobeAnchor functionality will not work.");
 
            this.Sync();
            this.StartOrStopDetectingTransformChanges();
        }
 
        #endregion
 
        #region Unity Messages
 
        private void UpdateGeoreference()
        {
            if (this._georeference != null)
                this._georeference.RemoveGlobeAnchor(this);
 
            this._georeference = this.gameObject.GetComponentInParent<CesiumGeoreference>();
 
            if (this._georeference != null)
            {
                this._georeference.Initialize();
                if (this.isActiveAndEnabled)
                    this._georeference.AddGlobeAnchor(this);
            }
        }
 
        internal void UpdateGeoreferenceIfNecessary()
        {
            if (this._georeference == null)
                this.UpdateGeoreference();
        }
 
        private void OnEnable()
        {
            this.Restart();
        }
 
        private void Reset()
        {
            this.Restart();
        }
 
        private void OnDisable()
        {
            if (this._georeference != null)
                this._georeference.RemoveGlobeAnchor(this);
            this._georeference = null;
        }
 
        private void OnTransformParentChanged()
        {
            this.UpdateGeoreference();
            this.Sync();
        }
 
        #endregion
 
        #region Coroutines
 
        private void StartOrStopDetectingTransformChanges()
        {
            this.StopCoroutine("DetectTransformChanges");
 
            bool start = this._detectTransformChanges;
 
#if UNITY_EDITOR
            // Always detect changes in Edit mode.
            if (!EditorApplication.isPlaying)
                start = true;
#endif
 
            // Can't start a coroutine on an inactive game object
            if (!this.isActiveAndEnabled)
                start = false;
 
            if (start)
                this.StartCoroutine("DetectTransformChanges");
        }
 
        private IEnumerator DetectTransformChanges()
        {
            // Detect changes in the Transform component.
            // We don't use Transform.hasChanged because we can't control when it is reset to false.
            WaitUntil waitForChanges = new WaitUntil(() => this._lastLocalsAreValid && (
                this.transform.localPosition != this._lastLocalPosition ||
                this.transform.localRotation != this._lastLocalRotation ||
                this.transform.localScale != this._lastLocalScale));
 
            while (true)
            {
                yield return waitForChanges;
                this.UpdateEcefFromTransform();
            }
        }
 
        #endregion
 
        #region Updaters
 
        private void InitializeEcefIfNeeded()
        {
            if (!this._localToGlobeFixedMatrixIsValid)
                this.UpdateEcefFromTransform();
        }
 
        private void UpdateEcef(double4x4 newModelToEcef)
        {
            this.UpdateGeoreferenceIfNecessary();
            this.SetNewLocalToGlobeFixedMatrix(newModelToEcef);
        }
 
        private void UpdateEcefFromTransform()
        {
            this.UpdateGeoreferenceIfNecessary();
            if (this._georeference != null)
                this.SetNewLocalToGlobeFixedMatrixFromTransform();
#if UNITY_EDITOR
            PrefabUtility.RecordPrefabInstancePropertyModifications(this);
#endif
        }
 
        private partial void SetNewLocalToGlobeFixedMatrix(double4x4 newLocalToGlobeFixedMatrix);
 
        private partial void SetNewLocalToGlobeFixedMatrixFromTransform();
 
        private partial quaternion GetLocalToEastUpNorthRotation();
 
        private partial void SetLocalToEastUpNorthRotation(quaternion newRotation);
 
        #endregion
    }
}