org.outernet.cesium-unity 1.15.3-linux.1

package/Runtime/CesiumCameraController.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6b621ff6a9d4b8c4d85ac07de7f8b4b9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/CesiumCameraManager.cs

@@ -0,0 +1,105 @@
+using Reinterop;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using UnityEngine;
+
+namespace CesiumForUnity
+{
+    /// <summary>
+    /// Manages the set of cameras that are used for Cesium3DTileset culling and level-of-detail.
+    /// </summary>
+    [DisallowMultipleComponent]
+    [AddComponentMenu("Cesium/Cesium Camera Manager")]
+    [Icon("Packages/com.cesium.unity/Editor/Resources/Cesium-24x24.png")]
+    public class CesiumCameraManager : MonoBehaviour
+    {
+        /// <summary>
+        /// Gets the instance suitable for use with the given game object.
+        /// </summary>
+        /// <remarks>
+        /// This method looks for an existing instance using `GetComponentInParent`. If it fails to find one, then
+        /// it will create one. When one is created, it be added to the same `GameObject` that has the
+        /// `CesiumGeoreference` (found using `GetComponentInParent` again) if there is one. If there is no
+        /// `CesiumGeoreference`, the instance is added to the originally-provided `GameObject`.
+        /// </remarks>
+        /// <param name="gameObject">The game object.</param>
+        /// <returns></returns>
+        public static CesiumCameraManager GetOrCreate(GameObject gameObject)
+        {
+            if (gameObject == null) throw new ArgumentNullException("gameObject");
+
+            CesiumCameraManager result = gameObject.GetComponentInParent<CesiumCameraManager>();
+            if (result == null)
+                return CesiumCameraManager.Create(gameObject);
+            else
+                return result;
+        }
+
+        private static CesiumCameraManager Create(GameObject gameObject)
+        {
+            // Add it to the same game object that has the CesiumGeoreference, if any.
+            // Otherwise, add it to the current game object.
+            CesiumGeoreference georeference = gameObject.GetComponentInParent<CesiumGeoreference>();
+            GameObject owner = georeference == null ? gameObject : georeference.gameObject;
+            if (owner == null) return null;
+
+            return owner.AddComponent<CesiumCameraManager>();
+        }
+
+        #region User-editable properties
+
+        [SerializeField]
+        private bool _useMainCamera = true;
+
+        /// <summary>
+        /// Determines whether the camera tagged `MainCamera` should be used for Cesium3DTileset
+        /// culling and level-of-detail.
+        /// </summary>
+        public bool useMainCamera
+        {
+            get => this._useMainCamera;
+            set
+            {
+                this._useMainCamera = value;
+            }
+        }
+
+        [SerializeField]
+        private bool _useSceneViewCameraInEditor = true;
+
+        /// <summary>
+        /// Determines whether the camera associated with the Editor's active scene view should be
+        /// used for Cesium3DTileset culling and level-of-detail. In a game, this property has
+        /// no effect.
+        /// </summary>
+        public bool useSceneViewCameraInEditor
+        {
+            get => this._useSceneViewCameraInEditor;
+            set
+            {
+                this._useSceneViewCameraInEditor = value;
+            }
+        }
+
+        [SerializeField]
+        private List<Camera> _additionalCameras = new List<Camera>();
+
+        /// <summary>
+        /// Other cameras to use for Cesium3DTileset culling and level-of-detail, in addition
+        /// to the ones controlled by <see cref="useMainCamera"/> and
+        /// <see cref="useSceneViewCameraInEditor"/>.
+        /// </summary>
+        /// <remarks>
+        /// These additional cameras will be used even when they are disabled, which is useful for
+        /// creating a virtual camera that affects Cesium3DTileset loading without being used
+        /// for rendering.
+        /// </remarks>
+        public List<Camera> additionalCameras
+        {
+            get => this._additionalCameras;
+        }
+
+        #endregion
+    }
+}

package/Runtime/CesiumCameraManager.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: be1fb41cdd01d7649a082f1a8f2bd114
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/CesiumCartographicPolygon.cs

@@ -0,0 +1,152 @@
+using System.Collections.Generic;
+using Unity.Mathematics;
+using UnityEngine;
+
+#if SUPPORTS_SPLINES
+using UnityEngine.Splines;
+#endif
+
+namespace CesiumForUnity
+{
+    /// <summary>
+    /// A spline-based polygon used to rasterize 2D polygons on top of <see cref="Cesium3DTileset"/>s.
+    /// Cartographic polygons are only supported for Unity 2022.2 or later.
+    /// </summary>
+    [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
+    {
+#if SUPPORTS_SPLINES
+        private SplineContainer _splineContainer;
+        private CesiumGlobeAnchor _globeAnchor;
+#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>();
+            }
+
+#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
+
+        static List<double2> emptyList = new List<double2>();
+
+        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
+        }
+    }
+}

package/Runtime/CesiumCartographicPolygon.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 01cfd193d3e63e7458cad0835cc96e84
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/CesiumCreditSystem.cs

@@ -0,0 +1,343 @@
+using Reinterop;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+using UnityEngine.Networking;
+
+#if UNITY_EDITOR
+using UnityEditor.SceneManagement;
+#endif
+
+namespace CesiumForUnity
+{
+    /// <summary>
+    /// Represents an HTML element, either text or an image, that may also be hyperlinked.
+    /// This abstraction allows HTML parts of a credit to be converted to the desired UI elements
+    /// by a UI implementation.
+    /// </summary>
+    internal class CesiumCreditComponent
+    {
+        private string _text;
+        private string _link;
+        private int _imageId = -1;
+
+        /// <summary>
+        /// The text of this credit component. May be empty.
+        /// </summary>
+        public string text
+        {
+            get => this._text;
+        }
+
+        /// <summary>
+        /// The link used by this credit component. May be empty. 
+        /// If the UI representation of this component is clicked, it should open this link.
+        /// </summary>
+        public string link
+        {
+            get => this._link;
+        }
+
+        /// <summary>
+        /// The ID of the image represented by this credit component.
+        /// </summary>
+        /// <remarks>
+        /// This ID corresponds to the index of the image in <see cref="CesiumCreditSystem.images"/>.
+        /// If it is -1, this component does not contain an image.
+        /// </remarks>
+        public int imageId
+        {
+            get => this._imageId;
+        }
+
+        public CesiumCreditComponent(string text, string link, int imageId)
+        {
+            this._text = text;
+            this._link = link;
+            this._imageId = imageId;
+        }
+    }
+
+    /// <summary>
+    /// Represents an HTML credit from a tileset or raster overlay. This abstracts an HTML string
+    /// into multiple <see cref="CesiumCreditComponent"/>s for UI rendering.
+    /// </summary>
+    internal class CesiumCredit
+    {
+        private List<CesiumCreditComponent> _components;
+
+        /// <summary>
+        /// The <see cref="CesiumCreditComponent"/>s that make up this credit.
+        /// </summary>
+        public List<CesiumCreditComponent> components
+        {
+            get => this._components;
+        }
+
+        public CesiumCredit() : this(new List<CesiumCreditComponent>())
+        { }
+
+        public CesiumCredit(List<CesiumCreditComponent> components)
+        {
+            this._components = components;
+        }
+    }
+
+    /// <summary>
+    /// Manages credits / attribution for <see cref="Cesium3DTileset"/> and <see cref="CesiumRasterOverlay"/>.
+    /// </summary>
+    [ExecuteInEditMode]
+    [ReinteropNativeImplementation("CesiumForUnityNative::CesiumCreditSystemImpl", "CesiumCreditSystemImpl.h")]
+    [AddComponentMenu("Cesium/Cesium Credit System")]
+    [IconAttribute("Packages/com.cesium.unity/Editor/Resources/Cesium-24x24.png")]
+    public partial class CesiumCreditSystem : MonoBehaviour
+    {
+        private static CesiumCreditSystem _defaultCreditSystem;
+
+        private List<CesiumCredit> _onScreenCredits;
+        private List<CesiumCredit> _popupCredits;
+        private List<Texture2D> _images;
+        private int _numLoadingImages = 0;
+
+        const string base64Prefix = "data:image/png;base64,";
+        const string defaultName = "CesiumCreditSystemDefault";
+        const string creditSystemPrefabName = "CesiumCreditSystem";
+
+        #region Fields and Events
+        /// <summary>
+        /// The current on-screen credits, represented as <see cref="CesiumCredit"/>s.
+        /// </summary>
+        internal List<CesiumCredit> onScreenCredits
+        {
+            get => this._onScreenCredits;
+        }
+
+        /// <summary>
+        /// The credits to be displayed in the "Data Attribution" panel,
+        /// represented as <see cref="CesiumCredit"/>s.
+        /// </summary>
+        internal List<CesiumCredit> popupCredits
+        {
+            get => this._popupCredits;
+        }
+
+        /// <summary>
+        /// The images loaded by this credit system.
+        /// </summary>
+        internal List<Texture2D> images
+        {
+            get => this._images;
+        }
+
+        /// <summary>
+        /// Encapsulates a method that receives the on-screen and popup credits in <see cref="CesiumCredit"/>
+        /// form. This can be used to create UI components for the credits after they have been updated.
+        /// </summary>
+        /// <param name="onScreenCredits">The on-screen credits.</param>
+        /// <param name="onPopupCredits">The popup credits.</param>
+        internal delegate void CreditsUpdateDelegate(List<CesiumCredit> onScreenCredits, List<CesiumCredit> onPopupCredits);
+
+        /// <summary>
+        /// An event that is raised when credits have been updated by the credit system. This is
+        /// only raised when the credits in view have actually changed.
+        /// </summary>
+        /// <remarks>
+        /// If the credit system is loading any images for its credits, the update will not be broadcasted
+        /// until all image loads are complete.
+        /// </remarks>
+        internal event CreditsUpdateDelegate OnCreditsUpdate;
+        #endregion
+
+        #region Unity Messages
+
+        private void OnEnable()
+        {
+            this._onScreenCredits = new List<CesiumCredit>();
+            this._popupCredits = new List<CesiumCredit>();
+            this._images = new List<Texture2D>();
+
+            Cesium3DTileset.OnSetShowCreditsOnScreen += this.ForceUpdateCredits;
+#if UNITY_EDITOR
+            EditorSceneManager.sceneClosing += HandleClosingSceneView;
+#endif
+        }
+
+        private void Update()
+        {
+            this.UpdateCredits(false);
+        }
+
+        private void OnDestroy()
+        {
+            Cesium3DTileset.OnSetShowCreditsOnScreen -= this.ForceUpdateCredits;
+
+            for (int i = 0, count = this._images.Count; i < count; i++)
+            {
+                if (this._images != null)
+                {
+                    UnityLifetime.Destroy(this._images[i]);
+                }
+            }
+
+            this._images.Clear();
+
+            if (_defaultCreditSystem == this)
+            {
+                _defaultCreditSystem = null;
+            }
+        }
+
+        /// <summary>
+        /// This handles the destruction of the credit system whenever the application is quit
+        /// from a built executable or from play mode.
+        /// </summary>
+        private void OnApplicationQuit()
+        {
+            UnityLifetime.Destroy(this.gameObject);
+        }
+        #endregion
+
+        /// <summary>
+        /// Forces the credits to update, bypassing any performance optimizations in play.
+        /// This ensures the credit system accounts for changes to the credits, e.g. if 
+        /// <see cref="Cesium3DTileset.showCreditsOnScreen"/> is changed on a tileset.</param>
+        /// </summary>
+        private void ForceUpdateCredits()
+        {
+            this.UpdateCredits(true);
+        }
+
+        /// <summary>
+        /// Updates the underlying native credit system.
+        /// </summary>
+        /// <param name="forceUpdate">Whether to force the credit system to update.</param>
+        private partial void UpdateCredits(bool forceUpdate);
+
+        internal void BroadcastCreditsUpdate()
+        {
+            if (this.OnCreditsUpdate != null)
+            {
+                this.OnCreditsUpdate(this._onScreenCredits, this._popupCredits);
+            }
+        }
+
+        /// <summary>
+        /// Creates an instance of the default credit system prefab.
+        /// </summary>
+        /// <remarks>
+        /// This prefab comes with a <see cref="CesiumCreditSystemUI"/> component so that 
+        /// the credits UI is automatically added to the editor and scene. However, 
+        /// the CesiumCreditSystem class is uncoupled from any UI implementation itself.
+        /// </remarks>
+        /// <returns>The new CesiumCreditSystem instance.</returns>
+        private static CesiumCreditSystem CreateDefaultCreditSystem()
+        {
+            GameObject creditSystemPrefab = Resources.Load<GameObject>(creditSystemPrefabName);
+            GameObject creditSystemGameObject = UnityEngine.Object.Instantiate(creditSystemPrefab);
+            creditSystemGameObject.name = defaultName;
+            creditSystemGameObject.hideFlags = HideFlags.HideAndDontSave;
+
+            return creditSystemGameObject.GetComponent<CesiumCreditSystem>();
+        }
+
+        /// <summary>
+        /// Gets the default credit system, or creates a new default credit system instance if none exist.
+        /// </summary>
+        /// <returns>The default CesiumCreditSystem instance.</returns>
+        internal static CesiumCreditSystem GetDefaultCreditSystem()
+        {
+            if (_defaultCreditSystem == null)
+            {
+                CesiumCreditSystem[] creditSystems = Resources.FindObjectsOfTypeAll<CesiumCreditSystem>();
+                for (int i = 0; i < creditSystems.Length; i++)
+                {
+                    if (creditSystems[i].gameObject.name == defaultName)
+                    {
+                        _defaultCreditSystem = creditSystems[i];
+                        break;
+                    }
+                }
+            }
+
+            if (_defaultCreditSystem == null)
+            {
+                _defaultCreditSystem = CreateDefaultCreditSystem();
+            }
+
+            return _defaultCreditSystem;
+        }
+
+        internal bool HasLoadingImages()
+        {
+            return this._numLoadingImages > 0;
+        }
+
+        internal IEnumerator LoadImage(string url)
+        {
+            int index = this._images.Count;
+
+            // Initialize a texture of arbitrary size as a placeholder,
+            // so that when other images are loaded, their IDs align properly
+            // with the current list of images.
+            Texture2D texture = new Texture2D(1, 1);
+            this._images.Add(texture);
+
+            if (url.LastIndexOf(base64Prefix, base64Prefix.Length) == 0)
+            {
+                // Load an image from a string that contains the
+                // "data:image/png;base64," prefix
+                string byteString = url.Substring(base64Prefix.Length);
+                byte[] bytes = Convert.FromBase64String(byteString);
+                if (!texture.LoadImage(bytes))
+                {
+                    Debug.Log("Could not parse image from base64 string.");
+                }
+            }
+            else
+            {
+                // Load an image from a URL.
+                UnityWebRequest request = UnityWebRequestTexture.GetTexture(url);
+                this._numLoadingImages++;
+                yield return request.SendWebRequest();
+
+                if (request.result == UnityWebRequest.Result.ConnectionError ||
+                    request.result == UnityWebRequest.Result.ProtocolError)
+                {
+                    Debug.Log(request.error);
+                }
+                else
+                {
+                    texture = ((DownloadHandlerTexture)request.downloadHandler).texture;
+
+                    Texture2D placeholderTexture = this._images[index];
+                    this._images[index] = texture;
+                    UnityLifetime.Destroy(placeholderTexture);
+                }
+
+                this._numLoadingImages--;
+            }
+
+            texture.wrapMode = TextureWrapMode.Clamp;
+        }
+
+
+#if UNITY_EDITOR
+        /// <summary>
+        /// This handles the destruction of the credit system between scene switches in the Unity Editor.
+        /// Without this, the credit system will live between instances and won't properly render the 
+        /// current scene's credits.
+        /// </summary>
+        /// <param name="scene">The scene.</param>
+        /// <param name="removingScene">Whether or not the closing scene is also being removed.</param>
+        private static void HandleClosingSceneView(Scene scene, bool removingScene)
+        {
+            if (_defaultCreditSystem != null && _defaultCreditSystem.gameObject.scene == scene)
+            {
+                UnityLifetime.Destroy(_defaultCreditSystem.gameObject);
+            }
+        }
+#endif
+    }
+}

package/Runtime/CesiumCreditSystem.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6ad7d034075e67d4d8e4442eee83f1bd
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: