CesiumGeoreference.cs

Go to the documentation of this file.

using Reinterop;
using System;
using System.Collections.Generic;
using Unity.Mathematics;
using UnityEngine;
 
namespace CesiumForUnity
{
    public enum CesiumGeoreferenceOriginPlacement
    {
        TrueOrigin,
        CartographicOrigin
    }

    public enum CesiumGeoreferenceOriginAuthority
    {
        LongitudeLatitudeHeight,

        EarthCenteredEarthFixed
    }

    [ExecuteInEditMode]
    [ReinteropNativeImplementation("CesiumForUnityNative::CesiumGeoreferenceImpl", "CesiumGeoreferenceImpl.h")]
    [AddComponentMenu("Cesium/Cesium Georeference")]
    [IconAttribute("Packages/com.cesium.unity/Editor/Resources/Cesium-24x24.png")]
    public partial class CesiumGeoreference : MonoBehaviour
    {
        #region Fields
        [SerializeField]
        private CesiumEllipsoid _ellipsoidOverride = null;
 
        [SerializeField]
        private CesiumGeoreferenceOriginPlacement _originPlacement = CesiumGeoreferenceOriginPlacement.CartographicOrigin;
 
        [SerializeField]
        private CesiumGeoreferenceOriginAuthority _originAuthority = CesiumGeoreferenceOriginAuthority.LongitudeLatitudeHeight;
 
        [SerializeField]
        private double _latitude = 39.736401;
 
        [SerializeField]
        private double _longitude = -105.25737;
 
        [SerializeField]
        [Delayed]
        private double _height = 2250.0;
 
        [SerializeField]
        [Delayed]
        private double _ecefX = 6378137.0;
 
        [SerializeField]
        [Delayed]
        private double _ecefY = 0.0;
 
        [SerializeField]
        [Delayed]
        private double _ecefZ = 0.0;
 
        [SerializeField]
        private double _scale = 1.0;
 
        [NonSerialized]
        private double4x4 _localToEcef = double4x4.identity;
 
        [NonSerialized]
        private double4x4 _ecefToLocal = double4x4.identity;
 
        [NonSerialized]
        private bool _isInitialized = false;
 
        [NonSerialized]
        private HashSet<CesiumGlobeAnchor> _globeAnchors = new HashSet<CesiumGlobeAnchor>();
 
        [NonSerialized]
        private CesiumEllipsoid _ellipsoid = null;
 
        #endregion

        public CesiumGeoreferenceOriginPlacement originPlacement
        {
            get => this._originPlacement;
            set
            {
                this._originPlacement = value;
                this.MoveOrigin();
            }
        }

        public CesiumGeoreferenceOriginAuthority originAuthority
        {
            get => this._originAuthority;
            set
            {
                this._originAuthority = value;
                this.originPlacement = CesiumGeoreferenceOriginPlacement.CartographicOrigin;
            }
        }

        public double latitude
        {
            get => this._latitude;
            set
            {
                this._latitude = Math.Clamp(value, -90, 90);
                this.originAuthority = CesiumGeoreferenceOriginAuthority.LongitudeLatitudeHeight;
            }
        }

        public double longitude
        {
            get => this._longitude;
            set
            {
                this._longitude = Math.Clamp(value, -180, 180);
                this.originAuthority = CesiumGeoreferenceOriginAuthority.LongitudeLatitudeHeight;
            }
        }

        public double height
        {
            get => this._height;
            set
            {
                this._height = value;
                this.originAuthority = CesiumGeoreferenceOriginAuthority.LongitudeLatitudeHeight;
            }
        }

        public double ecefX
        {
            get => this._ecefX;
            set
            {
                this._ecefX = value;
                this.originAuthority = CesiumGeoreferenceOriginAuthority.EarthCenteredEarthFixed;
            }
        }

        public double ecefY
        {
            get => this._ecefY;
            set
            {
                this._ecefY = value;
                this.originAuthority = CesiumGeoreferenceOriginAuthority.EarthCenteredEarthFixed;
            }
        }

        public double ecefZ
        {
            get => this._ecefZ;
            set
            {
                this._ecefZ = value;
                this.originAuthority = CesiumGeoreferenceOriginAuthority.EarthCenteredEarthFixed;
            }
        }

        public double scale
        {
            get => this._scale;
            set
            {
                this._scale = value;
                this.MoveOrigin();
            }
        }
 
        public double4x4 localToEcefMatrix
        {
            get
            {
                this.Initialize();
                return this._localToEcef;
            }
        }
 
        public double4x4 ecefToLocalMatrix
        {
            get
            {
                this.Initialize();
                return this._ecefToLocal;
            }
        }

        public CesiumEllipsoid ellipsoid
        {
            get
            {
                if (this._ellipsoid == null)
                {
                    // Make a copy of the ellipsoid ScriptableObject
                    this._ellipsoid = ScriptableObject.CreateInstance<CesiumEllipsoid>();
                    this._ellipsoid.SetRadii((this._ellipsoidOverride ?? CesiumEllipsoid.WGS84).radii);
                }
 
                return this._ellipsoid;
            }
            set
            {
                // Don't set the _ellipsoid field directly; instead, set the ellipsoidOverride,
                // so that transforms are updated properly. _ellipsoid will be set through that
                // process.
                if (this._ellipsoidOverride != value)
                {
                    this._ellipsoidOverride = value;
                    this.ReloadEllipsoid();
                }
            }
        }

        [Tooltip("An event raised when the georeference origin changes.")]
        public event Action changed;

        public void SetOriginEarthCenteredEarthFixed(double x, double y, double z)
        {
            this._ecefX = x;
            this._ecefY = y;
            this._ecefZ = z;
            this.originAuthority = CesiumGeoreferenceOriginAuthority.EarthCenteredEarthFixed;
        }

        public void SetOriginLongitudeLatitudeHeight(double longitude, double latitude, double height)
        {
            this._longitude = longitude;
            this._latitude = latitude;
            this._height = height;
            this.originAuthority = CesiumGeoreferenceOriginAuthority.LongitudeLatitudeHeight;
        }

        public void AddGlobeAnchor(CesiumGlobeAnchor globeAnchor)
        {
            this._globeAnchors.Add(globeAnchor);
        }

        public void RemoveGlobeAnchor(CesiumGlobeAnchor globeAnchor)
        {
            this._globeAnchors.Remove(globeAnchor);
        }

        public void Initialize()
        {
            if (!this._isInitialized)
            {
                this._isInitialized = true;
                this.UpdateOtherCoordinates();
                this.UpdateTransformations();
            }
        }

        public void ReloadEllipsoid()
        {
            // clear cached ellipsoid so it has to be rebuilt
            this._ellipsoid = null;
            this.UpdateTransformations();
            this.UpdateOtherCoordinates();
 
            Cesium3DTileset[] tilesets = GetComponentsInChildren<Cesium3DTileset>();
            foreach (var tileset in tilesets)
            {
                tileset.RecreateTileset();
            }
        }
 
        private void UpdateTransformations()
        {
            this._localToEcef = this.ComputeLocalToEarthCenteredEarthFixedTransformation();
            this._ecefToLocal = math.inverse(this._localToEcef);
        }

        public void MoveOrigin()
        {
            if (!this._isInitialized)
                throw new InvalidOperationException("The origin of a CesiumGeoreference must not be set before its Initialize method is called, either explicitly or via OnEnable.");
 
            // Scale must be greater than 0
            if (this._scale < 1e-8)
                this._scale = 1e-8;
 
            this.UpdateOtherCoordinates();
 
            double4x4 oldLocalToEcef = this._localToEcef;
 
            this.UpdateTransformations();
 
            if (oldLocalToEcef.Equals(this._localToEcef))
            {
                // Origin didn't change meaningfully.
                return;
            }
 
            foreach (CesiumGlobeAnchor anchor in this._globeAnchors)
            {
                if (anchor == null)
                    continue;
 
                anchor.Sync();
            }
 
            if (this.changed != null)
            {
                this.changed();
            }
        }
 
        private void OnValidate()
        {
            if (this._isInitialized)
            {
                this.MoveOrigin();
            }
        }
 
        private void OnEnable()
        {
            this.Initialize();
        }
 
        private void OnDisable()
        {
            this._isInitialized = false;
        }
 
        private void UpdateOtherCoordinates()
        {
            if (this._originAuthority == CesiumGeoreferenceOriginAuthority.LongitudeLatitudeHeight)
            {
                double3 ecef =
                    this.ellipsoid.LongitudeLatitudeHeightToCenteredFixed(
                        new double3(this._longitude, this._latitude, this._height));
                this._ecefX = ecef.x;
                this._ecefY = ecef.y;
                this._ecefZ = ecef.z;
            }
            else if (this._originAuthority == CesiumGeoreferenceOriginAuthority.EarthCenteredEarthFixed)
            {
                double3 llh =
                    this.ellipsoid.CenteredFixedToLongitudeLatitudeHeight(
                        new double3(this._ecefX, this._ecefY, this._ecefZ));
                this._longitude = llh.x;
                this._latitude = llh.y;
                this._height = llh.z;
            }
        }

        public double3
            TransformUnityPositionToEarthCenteredEarthFixed(double3 unityPosition)
        {
            this.Initialize();
            return math.mul(this._localToEcef, new double4(unityPosition, 1.0)).xyz;
        }

        public double3
            TransformEarthCenteredEarthFixedPositionToUnity(double3 earthCenteredEarthFixed)
        {
            this.Initialize();
            return math.mul(this._ecefToLocal, new double4(earthCenteredEarthFixed, 1.0)).xyz;
        }

        public double3
            TransformUnityDirectionToEarthCenteredEarthFixed(double3 unityDirection)
        {
            this.Initialize();
            return math.mul(this._localToEcef, new double4(unityDirection, 0.0)).xyz;
        }

        public double3
            TransformEarthCenteredEarthFixedDirectionToUnity(double3 earthCenteredEarthFixedDirection)
        {
            this.Initialize();
            return math.mul(this._ecefToLocal, new double4(earthCenteredEarthFixedDirection, 0.0)).xyz;
        }
 
        private partial double4x4 ComputeLocalToEarthCenteredEarthFixedTransformation();
    }
}