CesiumCartographicPolygon.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using Unity.Mathematics;
using UnityEngine;
 
#if SUPPORTS_SPLINES
using UnityEngine.Splines;
#endif
 
namespace CesiumForUnity
{
    public enum CesiumCartographicPolygonSource
    {
        Manual = 0,

        FromGeoJsonDocument = 1,

        FromCesiumIon = 2,

        FromUrl = 3
    }

    [ExecuteInEditMode]
#if SUPPORTS_SPLINES
    [RequireComponent(typeof(SplineContainer))]
    [RequireComponent(typeof(CesiumGlobeAnchor))]
    [AddComponentMenu("Cesium/Cesium Cartographic Polygon")]
#else
    [AddComponentMenu("")]
#endif
    [IconAttribute("Packages/com.cesium.unity/Editor/Resources/Cesium-24x24.png")]
    public partial class CesiumCartographicPolygon : MonoBehaviour
    {
        #region Events and Delegates

        public delegate void CartographicPolygonLoadFailureDelegate(
            CesiumCartographicPolygonLoadFailureDetails details);

        public static event CartographicPolygonLoadFailureDelegate
            OnCesiumCartographicPolygonLoadFailure;
 
        internal static void BroadcastCesiumCartographicPolygonLoadFailure(
            CesiumCartographicPolygonLoadFailureDetails details)
        {
            if (OnCesiumCartographicPolygonLoadFailure != null)
            {
                OnCesiumCartographicPolygonLoadFailure(details);
            }
        }
 
        #endregion
 
        internal static readonly List<double2> emptyList = new List<double2>();
 
#if SUPPORTS_SPLINES
        private SplineContainer _splineContainer;
        private CesiumGlobeAnchor _globeAnchor;
#endif
 
        [SerializeField]
        private CesiumCartographicPolygonSource _source = CesiumCartographicPolygonSource.Manual;

        public CesiumCartographicPolygonSource source
        {
            get => this._source;
            set
            {
                this._source = value;
                this.LoadFromSource();
            }
        }
 
        [SerializeField]
        private string _url = "";

        public string url
        {
            get => this._url;
            set
            {
                this._url = value;
                if (this._source == CesiumCartographicPolygonSource.FromUrl)
                {
                    this.LoadFromSource();
                }
            }
        }
 
        [SerializeField]
        private int _polygonIndex = 0;

        public int polygonIndex
        {
            get => this._polygonIndex;
            set
            {
                this._polygonIndex = value;
                this.LoadFromSource();
            }
        }
 
        [SerializeField]
        private int _featureIndex = 0;

        public int featureIndex
        {
            get => this._featureIndex;
            set
            {
                this._featureIndex = value;
                this.LoadFromSource();
            }
        }
 
        [SerializeField]
        private long _ionAssetID = 0;

        public long ionAssetID
        {
            get => this._ionAssetID;
            set
            {
                this._ionAssetID = value;
                if (this._source == CesiumCartographicPolygonSource.FromCesiumIon)
                {
                    this.LoadFromSource();
                }
            }
        }
 
        [SerializeField]
        private string _ionAccessToken = "";

        public string ionAccessToken
        {
            get => this._ionAccessToken;
            set
            {
                this._ionAccessToken = value;
                if (this._source == CesiumCartographicPolygonSource.FromCesiumIon)
                {
                    this.LoadFromSource();
                }
            }
        }
 
        [SerializeField]
        private CesiumIonServer _ionServer = null;

        public CesiumIonServer ionServer
        {
            get
            {
                if (this._ionServer == null)
                    this._ionServer = CesiumIonServer.serverForNewObjects;
                return this._ionServer;
            }
            set
            {
                if (value == null) value = CesiumIonServer.serverForNewObjects;
                this._ionServer = value;
                if (this._source == CesiumCartographicPolygonSource.FromCesiumIon)
                {
                    this.LoadFromSource();
                }
            }
        }
 
        [NonSerialized] private CesiumGeoJsonDocument _document = null;

        public CesiumGeoJsonDocument document
        {
            get => this._document;
            set
            {
                this._document = value;
                this._source = CesiumCartographicPolygonSource.FromGeoJsonDocument;
                this.ApplyDocument(value);
            }
        }
 
        // Set to true while this component is writing to the spline itself, so that
        // the resulting Spline.Changed event isn't misinterpreted as a manual edit.
        // Exposed as internal so the editor can skip its own spline-modified handling
        // while a reload from the configured source is in progress.
        [NonSerialized] internal bool _isUpdatingSplineInternally = false;
 
#if SUPPORTS_SPLINES
        // Exposed for the editor so it can verify a modified spline belongs to this
        // polygon before reacting to the global AfterSplineWasModified callback.
        internal bool IsSplineOwned(Spline spline)
        {
            if (this._splineContainer == null)
            {
                return false;
            }
 
            IReadOnlyList<Spline> splines = this._splineContainer.Splines;
            for (int i = 0; i < splines.Count; i++)
            {
                if (splines[i] == spline)
                {
                    return true;
                }
            }
 
            return false;
        }
#endif
 
        void OnEnable()
        {
#if SUPPORTS_SPLINES
            this._splineContainer = this.GetComponent<SplineContainer>();
            this._globeAnchor = this.GetComponent<CesiumGlobeAnchor>();
 
            // If this component is created before the Splines package is added, the
            // "RequireComponent" attributes won't automatically apply. This extra check
            // should ensure the required components exist.
            if (this._splineContainer == null)
            {
                this._splineContainer = this.gameObject.AddComponent<SplineContainer>();
#if UNITY_EDITOR
                this.Reset();
#endif
            }
            if (this._globeAnchor == null)
            {
                this._globeAnchor = this.gameObject.AddComponent<CesiumGlobeAnchor>();
            }
 
            if (this._source != CesiumCartographicPolygonSource.Manual)
            {
                this.LoadFromSource();
            }
 
#elif UNITY_2022_2_OR_NEWER
            Debug.LogError("CesiumCartographicPolygon requires the Splines package, which is currently not installed " +
                "in the project. Install the Splines package using the Package Manager.");
#else
            Debug.LogError("CesiumCartographicPolygon requires the Splines package, which is not available " +
                "in this version of Unity.");
#endif
        }
 
#if SUPPORTS_SPLINES && UNITY_EDITOR
        void Reset()
        {
            IReadOnlyList<Spline> splines = this._splineContainer.Splines;
            for (int i = splines.Count - 1; i >= 0; i--)
            {
                this._splineContainer.RemoveSpline(splines[i]);
            }
 
            Spline defaultSpline = new Spline();
 
            BezierKnot[] knots = new BezierKnot[] {
                new BezierKnot(new float3(-100.0f, 0f, -100.0f)),
                new BezierKnot(new float3(100.0f, 0f, -100.0f)),
                new BezierKnot(new float3(100.0f, 0f, 100.0f)),
                new BezierKnot(new float3(-100.0f, 0f, 100.0f)),
            };
 
            defaultSpline.Knots = knots;
            defaultSpline.Closed = true;
            defaultSpline.SetTangentMode(TangentMode.Linear);
 
            this._splineContainer.AddSpline(defaultSpline);
        }
#endif

        public void Refresh()
        {
            if (this._source == CesiumCartographicPolygonSource.Manual)
            {
                this.RefreshDependentOverlays();
            }
            else
            {
                // For non-Manual sources, "LoadFromSource" reloads the spline asynchronously
                // and refreshes the dependent raster overlays itself once the load completes.
                LoadFromSource();
            }
        }
 
        private void RefreshDependentOverlays()
        {
            CesiumPolygonRasterOverlay[] overlays = FindObjectsByType<CesiumPolygonRasterOverlay>(FindObjectsSortMode.None);
            for (int i = 0; i < overlays.Length; i++)
            {
                CesiumPolygonRasterOverlay overlay = overlays[i];
                if (overlay == null || overlay.polygons == null)
                    continue;
                if (overlay.polygons.Contains(this))
                {
                    overlay.Refresh();
                }
            }
        }
 
#if !SUPPORTS_SPLINES
        private void LoadFromSource(){} // Defined as no-op to supress CS1998, since Splines Package is not available during build.
#else
        private async void LoadFromSource()
        {
            CesiumGeoJsonDocument loaded = null;
            bool hasEmptySource = false;
            switch (this._source)
            {
                case CesiumCartographicPolygonSource.Manual:
                    return;
                case CesiumCartographicPolygonSource.FromGeoJsonDocument:
                    loaded = this._document;
                    break;
                case CesiumCartographicPolygonSource.FromUrl:
                    if (!string.IsNullOrEmpty(this._url))
                        loaded = await CesiumGeoJsonDocument.LoadFromUrlAsync(this._url);
                    else
                        hasEmptySource = true;
                    break;
                case CesiumCartographicPolygonSource.FromCesiumIon:
                    if (this._ionAssetID > 0)
                        loaded = await CesiumGeoJsonDocument.LoadFromCesiumIonAsync(
                            this._ionAssetID, this._ionAccessToken, this.ionServer);
                    else
                        hasEmptySource = true;
                    break;
            }
 
            if (loaded == null && this._source != CesiumCartographicPolygonSource.Manual && !hasEmptySource)
            {
                CesiumCartographicPolygonLoadType loadType =
                    this._source == CesiumCartographicPolygonSource.FromCesiumIon
                        ? CesiumCartographicPolygonLoadType.CesiumIon
                        : CesiumCartographicPolygonLoadType.Url;
 
                BroadcastCesiumCartographicPolygonLoadFailure(
                    new CesiumCartographicPolygonLoadFailureDetails(
                        this,
                        loadType,
                        "CesiumCartographicPolygon: failed to load the GeoJSON."));
            }
 
            // If this component was disabled or destroyed while the load was in flight, skip applying the result. 
            if (!this.isActiveAndEnabled) 
            {
                return;
            }
 
            this.ApplyDocument(loaded);
 
            // The spline has now been updated from the source, so rebuild any dependent
            // raster overlays to re-bake the cutout using the new shape.
            this.RefreshDependentOverlays();
        }
#endif

        private static List<double2> GetPolygonRingPoints(CesiumGeoJsonDocument geoJsonDocument, int featureIndex, int polygonIndex)
        {
#if SUPPORTS_SPLINES
            if (geoJsonDocument == null)
                return null;
 
            CesiumGeoJsonObject obj = geoJsonDocument.GetRootObject();
            if (obj == null)
                return null;
 
            CesiumGeoJsonObjectType objType = obj.GetObjectType();
 
            CesiumGeoJsonObject geometry = obj;
            if (objType == CesiumGeoJsonObjectType.Feature)
            {
                CesiumGeoJsonFeature feature = obj.GetObjectAsFeature();
                geometry = feature?.GetGeometry();
            }
            else if (objType == CesiumGeoJsonObjectType.FeatureCollection)
            {
                CesiumGeoJsonFeature[] features = obj.GetObjectAsFeatureCollection();
 
                // Bounds check: if featureIndex is out of range, return null (no cutout).
                if (features == null || features.Length == 0 || featureIndex < 0 || featureIndex >= features.Length)
                    return null;
 
                geometry = features[featureIndex].GetGeometry();
            }
 
            if (geometry == null)
                return null;
 
            CesiumGeoJsonLineString[] rings = null;
 
            CesiumGeoJsonObjectType geometryType = geometry.GetObjectType();
            if (geometryType == CesiumGeoJsonObjectType.Polygon)
            {
                rings = geometry.GetObjectAsPolygon()?.rings;
            }
            else if (geometryType == CesiumGeoJsonObjectType.MultiPolygon)
            {
                CesiumGeoJsonPolygon[] polys = geometry.GetObjectAsMultiPolygon();
 
                // Bounds check: if polygonIndex is out of range, return null (no cutout).
                if (polys == null || polys.Length == 0 || polygonIndex < 0 || polygonIndex >= polys.Length)
                    return null;
 
                rings = polys[polygonIndex]?.rings;
            }
 
            if (rings == null || rings.Length == 0 || rings[0] == null || rings[0].points.Length < 3)
                return null;
 
            List<double2> result = new List<double2>(rings[0].points.Length);
            foreach (double3 p in rings[0].points)
                result.Add(new double2(p.x, p.y));
            return result;
#else
            return null;
#endif
        }
 
        private void ApplyDocument(CesiumGeoJsonDocument geoJsonDocument)
        {
#if SUPPORTS_SPLINES
            List<double2> points = GetPolygonRingPoints(geoJsonDocument, this._featureIndex, this._polygonIndex);
            if (points == null || points.Count < 3)
            {
                // Clear any existing spline so that no cutout is applied.
                this._isUpdatingSplineInternally = true;
                try
                {
                    IReadOnlyList<Spline> splines = this._splineContainer.Splines;
                    for (int i = splines.Count - 1; i >= 0; i--)
                    {
                        this._splineContainer.RemoveSpline(splines[i]);
                    }
                }
                finally
                {
                    this._isUpdatingSplineInternally = false;
                }
 
                return;
            }
 
            CesiumGeoreference georeference = this._globeAnchor.GetComponentInParent<CesiumGeoreference>();
            if (georeference == null)
            {
                Debug.LogError("CesiumCartographicPolygon could not find a CesiumGeoreference in its " +
                    "parent hierarchy, so the GeoJSON source could not be applied.");
                return;
            }
 
            georeference.Initialize();
 
            // Remove the last point if it duplicates the first (GeoJson Spec.)
            if (points.Count > 3)
            {
                double2 first = points[0];
                double2 last = points[points.Count - 1];
                if (math.abs(first.x - last.x) < 1e-9 && math.abs(first.y - last.y) < 1e-9)
                {
                    points.RemoveAt(points.Count - 1);
                }
            }
 
            Matrix4x4 worldToLocal = this.transform.worldToLocalMatrix;
 
            BezierKnot[] knots = new BezierKnot[points.Count];
            for (int i = 0; i < points.Count; i++)
            {
                double3 cartographic = new double3(points[i].x, points[i].y, 0.0);
                double3 ecef = georeference.ellipsoid.LongitudeLatitudeHeightToCenteredFixed(cartographic);
                double3 unityPosition = georeference.TransformEarthCenteredEarthFixedPositionToUnity(ecef);
                Vector3 localPosition = worldToLocal.MultiplyPoint3x4(
                    new Vector3((float)unityPosition.x, (float)unityPosition.y, (float)unityPosition.z));
                knots[i] = new BezierKnot(new float3(localPosition.x, localPosition.y, localPosition.z));
            }
 
            Spline newSpline = new Spline();
            newSpline.Knots = knots;
            newSpline.Closed = true;
            newSpline.SetTangentMode(TangentMode.Linear);
 
            this._isUpdatingSplineInternally = true;
            try
            {
                IReadOnlyList<Spline> splines = this._splineContainer.Splines;
                for (int i = splines.Count - 1; i >= 0; i--)
                {
                    this._splineContainer.RemoveSpline(splines[i]);
                }
 
                this._splineContainer.AddSpline(newSpline);
            }
            finally
            {
                this._isUpdatingSplineInternally = false;
            }
#endif
        }
 
        internal List<double2> GetCartographicPoints(Matrix4x4 worldToTileset)
        {
#if SUPPORTS_SPLINES
            CesiumGeoreference georeference = this._globeAnchor.GetComponentInParent<CesiumGeoreference>();
            if (georeference == null)
            {
                return emptyList;
            }
 
            IReadOnlyList<Spline> splines = this._splineContainer.Splines;
            if (splines.Count == 0)
            {
                return emptyList;
            }
 
            if (splines.Count > 1)
            {
                Debug.LogWarning("CesiumCartographicPolygon has multiple splines in its Spline component, " +
                    "but can only support one at a time. Only the first spline will be rasterized.");
            }
 
            Spline spline = splines[0];
            if (!spline.Closed)
            {
                Debug.LogError("Spline must be closed to be used as a cartographic polygon.");
                return emptyList;
            }
 
            BezierKnot[] knots = spline.ToArray();
            List<double2> cartographicPoints = new List<double2>(knots.Length);
 
            float4x4 localToWorld = this.transform.localToWorldMatrix;
 
            for (int i = 0; i < knots.Length; i++)
            {
                if (spline.GetTangentMode(i) != TangentMode.Linear)
                {
                    Debug.LogError("CesiumCartographicPolygon only supports linear splines.");
                    return emptyList;
                }
 
                BezierKnot knot = knots[i];
 
                // The spline points should be located in the tileset *exactly where they
                // appear to be*. The way we do that is by getting their world position, and
                // then transforming that world position to a Cesium3DTileset local position.
                // That way if the tileset is transformed relative to the globe, the polygon
                // will still affect the tileset where the user thinks it should.
 
                float3 worldPosition = knot.Transform(localToWorld).Position;
                float3 unityPosition = worldToTileset.MultiplyPoint3x4(worldPosition);
                double3 ecefPosition = georeference.TransformUnityPositionToEarthCenteredEarthFixed(unityPosition);
                double3 cartographicPosition = georeference.ellipsoid.CenteredFixedToLongitudeLatitudeHeight(ecefPosition);
 
                cartographicPoints.Add(cartographicPosition.xy);
            }
 
            return cartographicPoints;
#else
            return emptyList;
#endif
        }
    }
}