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

package/Runtime/CesiumPropertyTableProperty.cs.meta

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

package/Runtime/CesiumRasterOverlay.cs

@@ -0,0 +1,239 @@
+using System;
+using UnityEngine;
+
+namespace CesiumForUnity
+{
+    /// <summary>
+    /// A pyramid of 2D images - sometimes terabytes or more in size - that can be draped over
+    /// a <see cref="Cesium3DTileset"/>.
+    /// </summary>
+    [ExecuteInEditMode]
+    public abstract class CesiumRasterOverlay : MonoBehaviour
+    {
+        /// <summary>
+        /// Encapsulates a method that receives details of a raster overlay load failure.
+        /// </summary>
+        /// <param name="details">The details of the load failure.</param>
+        public delegate void RasterOverlayLoadFailureDelegate(
+            CesiumRasterOverlayLoadFailureDetails details);
+
+        /// <summary>
+        /// An event that is raised when the raster overlay encounters an error that prevents it from loading.
+        /// </summary>
+        public static event
+            RasterOverlayLoadFailureDelegate OnCesiumRasterOverlayLoadFailure;
+
+        internal static void BroadcastCesiumRasterOverlayLoadFailure(
+            CesiumRasterOverlayLoadFailureDetails details)
+        {
+            if (OnCesiumRasterOverlayLoadFailure != null)
+            {
+                OnCesiumRasterOverlayLoadFailure(details);
+            }
+        }
+
+        [SerializeField]
+        private string _materialKey = "0";
+
+        /// <summary>
+        /// The key to use to match this overlay to the corresponding parameters in the tileset's material.
+        /// </summary>
+        /// <remarks>
+        /// In the tileset's materials, an overlay requires parameters for its texture, texture coordinate index,
+        /// and translation and scale. Overlays must specify a string key to match with the correct parameters.
+        /// The format of these parameters is as follows.
+        /// <list type="bullet">
+        /// <item><b>Overlay Texture</b>: _overlayTexture_KEY</item>
+        /// <item><b>Overlay Texture Coordinate Index</b>: _overlayTextureCoordinateIndex_KEY</item>
+        /// <item><b>Overlay Translation and Scale</b>: _overlayTranslationScale_KEY</item>
+        /// </list>
+        /// Material keys are useful for specifying the order of the raster overlays, or distinguishing them for
+        /// overlay-specific effects.
+        /// </remarks>
+        public string materialKey
+        {
+            get => this._materialKey;
+            set
+            {
+                this._materialKey = value;
+                this.Refresh();
+            }
+        }
+
+        [SerializeField]
+        private bool _showCreditsOnScreen = false;
+
+        /// <summary>
+        /// Whether or not to force this raster overlay's credits to be shown on the main screen. If false, the
+        /// credits are usually only shown on a "Data Attribution" popup.
+        /// </summary>
+        public bool showCreditsOnScreen
+        {
+            get => this._showCreditsOnScreen;
+            set
+            {
+                this._showCreditsOnScreen = value;
+                this.Refresh();
+            }
+        }
+
+        [SerializeField]
+        private float _maximumScreenSpaceError = 2.0f;
+
+        /// <summary>
+        /// The maximum number of pixels of error when rendering this overlay.
+        /// This is used to select an appropriate level-of-detail.
+        /// </summary>
+        /// <remarks>
+        /// When this property has its default value, 2.0, it means that raster overlay
+        /// images will be sized so that, when zoomed in closest, a single pixel in
+        /// the raster overlay maps to approximately 2x2 pixels on the screen.
+        /// </remarks>
+        public float maximumScreenSpaceError
+        {
+            get => this._maximumScreenSpaceError;
+            set
+            {
+                this._maximumScreenSpaceError = value;
+                this.Refresh();
+            }
+        }
+
+        [SerializeField]
+        private int _maximumTextureSize = 2048;
+
+        /// <summary>
+        /// The maximum texel size of raster overlay textures, in either direction.
+        /// </summary>
+        /// <remarks>
+        /// Images created by this overlay will be no more than this number of texels
+        /// in either direction.This may result in reduced raster overlay detail in
+        /// some cases.
+        /// </remarks>
+        public int maximumTextureSize
+        {
+            get => this._maximumTextureSize;
+            set
+            {
+                this._maximumTextureSize = value;
+                this.Refresh();
+            }
+        }
+
+        [SerializeField]
+        private int _maximumSimultaneousTileLoads = 20;
+
+        /// <summary>
+        /// The maximum number of overlay tiles that may simultaneously be in
+        /// the process of loading.
+        /// </summary>
+        public int maximumSimultaneousTileLoads
+        {
+            get => this._maximumSimultaneousTileLoads;
+            set
+            {
+                this._maximumSimultaneousTileLoads = value;
+                this.Refresh();
+            }
+        }
+
+        [SerializeField]
+        private long _subTileCacheBytes = 16 * 1024 * 1024;
+
+        /// <summary>
+        /// The maximum number of bytes to use to cache sub-tiles in memory.
+        /// </summary>
+        /// <remarks>
+        /// This is used by provider types that have an underlying tiling
+        /// scheme that may not align with the tiling scheme of the geometry tiles on
+        /// which the raster overlay tiles are draped. Because a single sub-tile may
+        /// overlap multiple geometry tiles, it is useful to cache loaded sub-tiles
+        /// in memory in case they're needed again soon. This property controls the
+        /// maximum size of that cache.
+        /// </remarks>
+        public long subTileCacheBytes
+        {
+            get => this._subTileCacheBytes;
+            set
+            {
+                this._subTileCacheBytes = value;
+                this.Refresh();
+            }
+        }
+
+        /// <summary>
+        /// Adds this raster overlay to the <see cref="Cesium3DTileset"/> on the same game object.
+        /// </summary>
+        /// <remarks>
+        /// If the overlay is already added or if the game object does not have a <see cref="Cesium3DTileset"/>,
+        /// this method does nothing.
+        /// </remarks>
+        public void AddToTileset()
+        {
+            Cesium3DTileset tileset = this.gameObject.GetComponent<Cesium3DTileset>();
+            if (tileset == null)
+                return;
+
+            // In case the material key changed, register the new key with the tileset.
+            tileset.UpdateOverlayMaterialKeys();
+
+            this.AddToTileset(tileset);
+        }
+
+        /// <summary>
+        /// Removes this raster overlay from the <see cref="Cesium3DTileset"/> on the same game object.
+        /// </summary>
+        /// <remarks>
+        /// If the overlay is not yet added or if the game object does not have a <see cref="Cesium3DTileset"/>,
+        /// this method does nothing.
+        /// </remarks>
+        public void RemoveFromTileset()
+        {
+            Cesium3DTileset tileset = this.gameObject.GetComponent<Cesium3DTileset>();
+            if (tileset == null)
+                return;
+
+            this.RemoveFromTileset(tileset);
+        }
+
+        /// <summary>
+        /// Refreshes this overlay by calling <see cref="RemoveFromTileset"/> followed by
+        /// <see cref="AddToTileset"/>. If the game object does not have a <see cref="Cesium3DTileset"/>,
+        /// this method does nothing.
+        /// </summary>
+        public void Refresh()
+        {
+            this.RemoveFromTileset();
+
+            if (this.enabled)
+                this.AddToTileset();
+        }
+
+        private void OnEnable()
+        {
+            this.AddToTileset();
+        }
+
+        private void OnDisable()
+        {
+            this.RemoveFromTileset();
+        }
+
+        private void OnValidate()
+        {
+            this.Refresh();
+        }
+
+        /// <summary>
+        /// When implemented in a derived class, adds the raster overlay to the given tileset.
+        /// </summary>
+        /// <param name="tileset">The tileset.</param>
+        protected abstract void AddToTileset(Cesium3DTileset tileset);
+
+        /// <summary>
+        /// When implemented in a derived class, removes the raster overlay from the given tileset.
+        /// </summary>
+        /// <param name="tileset">The tileset.</param>
+        protected abstract void RemoveFromTileset(Cesium3DTileset tileset);
+    }
+}

package/Runtime/CesiumRasterOverlay.cs.meta

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

package/Runtime/CesiumRasterOverlayLoadFailureDetails.cs

@@ -0,0 +1,65 @@
+namespace CesiumForUnity
+{
+    /// <summary>
+    /// The type of <see cref="CesiumRasterOverlay"/> load that encountered an error.
+    /// </summary>
+    public enum CesiumRasterOverlayLoadType
+    {
+        /// <summary>
+        /// An unknown load error.
+        /// </summary>
+        Unknown,
+
+        /// <summary>
+        /// A Cesium ion asset endpoint.
+        /// </summary>
+        CesiumIon,
+
+        /// <summary>
+        /// An initial load needed to create the overlay's tile provider.
+        /// </summary>
+        TileProvider
+    }
+
+    /// <summary>
+    /// Holds details of a <see cref="CesiumRasterOverlay"/> load failure.
+    /// </summary>
+    public struct CesiumRasterOverlayLoadFailureDetails
+    {
+        /// <summary>
+        /// The overlay that encountered the load failure.
+        /// </summary>
+        public CesiumRasterOverlay overlay;
+
+        /// <summary>
+        /// The type of request that failed to load.
+        /// </summary>
+        public CesiumRasterOverlayLoadType type;
+
+        /// <summary>
+        /// The HTTP status code of the response that led to the failure.
+        /// </summary>
+        /// <remarks>
+        /// If there was no response or the failure did not follow from a request, then
+        /// the value of this property will be 0.
+        /// </remarks>
+        public long httpStatusCode;
+
+        /// <summary>
+        /// A human-readable explanation of what failed.
+        /// </summary>
+        public string message;
+
+        public CesiumRasterOverlayLoadFailureDetails(
+            CesiumRasterOverlay overlay,
+            CesiumRasterOverlayLoadType type,
+            long httpStatusCode,
+            string message)
+        {
+            this.overlay = overlay;
+            this.type = type;
+            this.httpStatusCode = httpStatusCode;
+            this.message = message;
+        }
+    }
+}

package/Runtime/CesiumRasterOverlayLoadFailureDetails.cs.meta

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

package/Runtime/CesiumRuntime.asmdef

@@ -0,0 +1,32 @@
+{
+    "name": "CesiumRuntime",
+    "rootNamespace": "",
+    "references": [
+        "Unity.InputSystem",
+        "Unity.Mathematics",
+        "Unity.Splines"
+    ],
+    "includePlatforms": [
+        "Android",
+        "Editor",
+        "iOS",
+        "macOSStandalone",
+        "WSA",
+        "WindowsStandalone64",
+        "LinuxStandalone64"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": true,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [
+        {
+            "name": "com.unity.splines",
+            "expression": "1.0.0",
+            "define": "SUPPORTS_SPLINES"
+        }
+    ],
+    "noEngineReferences": false
+}

package/Runtime/CesiumRuntime.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 63cab5ddbd23cf34ca160a9b3d74438d
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/CesiumRuntime.cs

@@ -0,0 +1,3 @@
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("CesiumTests")]

package/Runtime/CesiumRuntime.cs.meta

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

package/Runtime/CesiumRuntimeSettings.cs

@@ -0,0 +1,188 @@
+using UnityEngine;
+using System;
+
+
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+
+namespace CesiumForUnity
+{
+    /// <summary>
+    /// Holds Cesium settings used at runtime.
+    /// </summary>
+    public sealed class CesiumRuntimeSettings : ScriptableObject
+    {
+        private static readonly string _settingsName = "CesiumSettings";
+        private static readonly string _filePath =
+            "Assets/" + _settingsName + "/Resources/CesiumRuntimeSettings.asset";
+
+        private static CesiumRuntimeSettings _instance;
+
+        /// <summary>
+        /// Gets the singleton instance of this class. If the project does not yet contain an instance,
+        /// one is created and added at the specified file path.
+        /// </summary>
+        public static CesiumRuntimeSettings instance
+        {
+            get
+            {
+                if (_instance != null)
+                {
+                    return _instance;
+                }
+
+                #if UNITY_EDITOR
+                _instance = AssetDatabase.LoadAssetAtPath(_filePath, typeof(CesiumRuntimeSettings))
+                        as CesiumRuntimeSettings;
+                #else
+                _instance =
+                    Resources.Load("CesiumRuntimeSettings") as CesiumRuntimeSettings;
+                #endif
+
+                #if UNITY_EDITOR
+                if (_instance == null)
+                {
+                    // Create the necessary folders if they don't already exist.
+                    if (!AssetDatabase.IsValidFolder("Assets/" + _settingsName))
+                    {
+                        AssetDatabase.CreateFolder("Assets", _settingsName);
+                    }
+
+                    if (!AssetDatabase.IsValidFolder("Assets/" + _settingsName + "/Resources"))
+                    {
+                        AssetDatabase.CreateFolder("Assets/" + _settingsName, "Resources");
+                    }
+
+                    string typeString = "t:"+ typeof(CesiumRuntimeSettings).Name;
+
+                    string[] instanceGUIDS = AssetDatabase.FindAssets(typeString);
+
+                    // If a CesiumRuntimeSettings asset is found outside of the preferred
+                    // file path, move it to the correct location.
+                    if (instanceGUIDS.Length > 0)
+                    {
+                        if (instanceGUIDS.Length > 1)
+                        {
+                            Debug.LogWarning("Found multiple CesiumRuntimeSettings assets " +
+                                "in the project folder. The first asset found will be used.");
+                        }
+                        
+                        string oldPath = AssetDatabase.GUIDToAssetPath(instanceGUIDS[0]);
+                        _instance =
+                                AssetDatabase.LoadAssetAtPath(oldPath, typeof(CesiumRuntimeSettings))
+                                    as CesiumRuntimeSettings;
+                        if(_instance != null)
+                        {
+                            string result = AssetDatabase.MoveAsset(oldPath, _filePath);
+                            AssetDatabase.Refresh();
+                            if (string.IsNullOrEmpty(result))
+                            {
+                                Debug.LogWarning("A CesiumRuntimeSettings asset was found outside " +
+                                    "the Assets/" + _settingsName + "/Resources folder and has been moved " +
+                                    "appropriately.");
+
+                                return _instance;
+                            }
+                            else
+                            {
+                                Debug.LogWarning("A CesiumRuntimeSettings asset was found outside " +
+                                    "the Assets/" + _settingsName + "/Resources folder, but could not " +
+                                    "be moved to the appropriate location. A new settings asset will be " +
+                                    "created instead.");
+                            }
+                        }
+                        else
+                        {
+                            Debug.LogWarning("An invalid CesiumRuntimeSettings asset was found " +
+                                "outside the Assets/" + _settingsName + "/Resources folder. " +
+                                "A new settings asset will be created instead.");
+                        }
+                    }
+                }
+                #endif
+
+                if (_instance == null)
+                {
+                    // Create an instance even if the game is not running in the editor
+                    // to prevent a crash.
+                    _instance = ScriptableObject.CreateInstance<CesiumRuntimeSettings>();
+                    #if UNITY_EDITOR
+                    AssetDatabase.CreateAsset(_instance, _filePath);
+                    AssetDatabase.Refresh();
+                    #else
+                    Debug.LogError("Cannot find a CesiumRuntimeSettings asset. " +
+                        "Any assets that use the project's default token will not load.");
+                    #endif
+                }
+
+                return _instance;
+            }
+        }
+
+        [SerializeField]
+        private string _defaultIonAccessTokenID = "";
+
+        /// <summary>
+        /// The ID of the default Cesium ion access token to use within the project.
+        /// </summary>
+        [Obsolete("Define a CesiumIonServer instead.")]
+        public static string defaultIonAccessTokenID
+        {
+            get => instance._defaultIonAccessTokenID;
+            #if UNITY_EDITOR
+            set
+            {
+                instance._defaultIonAccessTokenID = value;
+                EditorUtility.SetDirty(_instance);
+                AssetDatabase.SaveAssetIfDirty(_instance);
+                AssetDatabase.Refresh();
+            }
+            #endif
+        }
+
+        [SerializeField]
+        private string _defaultIonAccessToken = "";
+
+        /// <summary>
+        /// The default Cesium ion access token value to use within the project.
+        /// </summary>
+        [Obsolete("Define a CesiumIonServer instead.")]
+        public static string defaultIonAccessToken
+        {
+            get => instance._defaultIonAccessToken;
+            #if UNITY_EDITOR
+            set
+            {
+                instance._defaultIonAccessToken = value;
+                EditorUtility.SetDirty(_instance);
+                AssetDatabase.SaveAssetIfDirty(_instance);
+                AssetDatabase.Refresh();
+            }
+            #endif
+        }
+
+        [SerializeField]
+        [Tooltip("The number of requests to handle before each prune of old cached results from the database. Must restart Unity to apply changes.")]
+        private int _requestsPerCachePrune = 10000;
+
+        /// <summary>
+        ///  The number of requests to handle before each prune of old cached results from the database.
+        /// </summary>
+        public static int requestsPerCachePrune
+        {
+            get => instance._requestsPerCachePrune;
+        }
+
+        [SerializeField]
+        [Tooltip("The maximum number of items should be kept in the Sqlite database after pruning. Must restart Unity to apply changes.")]
+        private ulong  _maxItems = 4096;
+        /// <summary>
+        /// The maximum number of items should be kept in the Sqlite database after pruning.
+        /// </summary>
+        public static ulong maxItems
+        {
+            get => instance._maxItems;
+        }
+    }
+}

package/Runtime/CesiumRuntimeSettings.cs.meta

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

package/Runtime/CesiumSampleHeightResult.cs

@@ -0,0 +1,47 @@
+using Unity.Mathematics;
+
+namespace CesiumForUnity
+{
+    /// <summary>
+    /// The asynchronous result of a call to <see cref="Cesium3DTileset.SampleHeightMostDetailed"/>.
+    /// </summary>
+    public class CesiumSampleHeightResult
+    {
+        /// <summary>
+        /// The positions and their sampled heights. The X component is Longitude (degrees),
+        /// the Y component is Latitude (degrees), and the Z component is Height (meters) 
+        /// above the ellipsoid (usually WGS84).
+        /// </summary>
+        /// <remarks>
+        /// <para>
+        /// For each resulting position, its longitude and latitude values will match
+        /// values from its input. Its height will either be the height sampled from
+        /// the tileset at that position, or the original input height if the sample
+        /// was unsuccessful. To determine which, look at the value of
+        /// <see cref="CesiumSampleHeightResult.sampleSuccess"/> at the same index.
+        /// </para>
+        /// <para>
+        /// The returned height is measured from the ellipsoid (usually WGS84) and
+        /// should not be confused with a height above Mean Sea Level.
+        /// </para>
+        /// </remarks>
+        public double3[] longitudeLatitudeHeightPositions { get; set; }
+
+        /// <summary>
+        /// Indicates whether the height for the position at the corresponding index was sampled
+        /// successfully.
+        /// </summary>
+        /// <remarks>
+        /// If true, then the corresponding position in
+        /// <see cref="CesiumSampleHeightResult.longitudeLatitudeHeightPositions"/> uses
+        /// the height sampled from the tileset. If false, the height could not be sampled for 
+        /// the position, so its height is the same as the original input height.
+        /// </remarks>
+        public bool[] sampleSuccess { get; set; }
+
+        /// <summary>
+        /// Any warnings that occurred while sampling heights.
+        /// </summary>
+        public string[] warnings { get; set; }
+    }
+}

package/Runtime/CesiumSampleHeightResult.cs.meta

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