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

package/Editor/ConfigureReinterop.cs

@@ -0,0 +1,255 @@
+using Reinterop;
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Unity.Collections;
+using Unity.Collections.LowLevel.Unsafe;
+using UnityEditor;
+using UnityEditor.IMGUI.Controls;
+using UnityEngine;
+using UnityEngine.Networking;
+
+namespace CesiumForUnity
+{
+    [Reinterop]
+    internal partial class ConfigureReinterop
+    {
+        // The output path for generated C++ files.
+        // If this is relative, it is relative to the this file.
+#if UNITY_EDITOR
+        public const string CppOutputPath = "../native~/Editor/generated-Editor";
+#elif UNITY_ANDROID
+        public const string CppOutputPath = "../native~/Editor/generated-Android";
+#elif UNITY_IOS
+        public const string CppOutputPath = "../native~/Editor/generated-iOS";
+#elif UNITY_WSA
+        public const string CppOutputPath = "../native~/Runtime/generated-WSA";
+#elif UNITY_64
+        public const string CppOutputPath = "../native~/Editor/generated-Standalone";
+#else
+        public const string CppOutputPath = "../native~/Editor/generated-Unknown";
+#endif
+
+        // The namespace with which to prefix all C# namespaces. For example, if this
+        // property is set to "DotNet", then anything in the "System" namespace in C#
+        // will be found in the "DotNet::System" namespace in C++.
+        public const string BaseNamespace = "DotNet";
+
+        // The name of the DLL or SO containing the C++ code.
+        public const string NativeLibraryName = "CesiumForUnityNative-Editor";
+
+        // Comma-separated types to treat as non-blittable, even if their fields would
+        // otherwise cause Reinterop to treat them as blittable.
+        public const string NonBlittableTypes = "Unity.Collections.LowLevel.Unsafe.AtomicSafetyHandle,Unity.Collections.NativeArray,UnityEngine.MeshData,UnityEngine.MeshDataArray";
+
+        public void ExposeToCPP()
+        {
+            Debug.Log("log");
+
+            UnityWebRequest request = UnityWebRequest.Get("url");
+
+            var uploadHandler = new UploadHandlerRaw(new byte[0]);
+
+            var rawBytes = new NativeArray<byte>(1, Allocator.Persistent, NativeArrayOptions.UninitializedMemory);
+            unsafe
+            {
+                NativeArrayUnsafeUtility.GetUnsafeBufferPointerWithoutChecks(rawBytes);
+            }
+            uploadHandler = new UploadHandlerRaw(rawBytes, true);
+            request = new UnityWebRequest("url", "method", new NativeDownloadHandler(), uploadHandler);
+
+            bool isDone = request.isDone;
+            string e = request.error;
+            string method = request.method;
+            string url = request.url;
+            if (request.result == UnityWebRequest.Result.Success) { };
+            request.downloadHandler = new NativeDownloadHandler();
+            request.SetRequestHeader("name", "value");
+            request.GetResponseHeader("name");
+            Dictionary<string,string>.Enumerator enumerator = request.GetResponseHeaders().GetEnumerator();
+            while(enumerator.MoveNext())
+            {
+                string key = enumerator.Current.Key;
+                string value = enumerator.Current.Value;
+            }
+            request.downloadHandler.Dispose();
+            long responseCode = request.responseCode;
+            UnityWebRequestAsyncOperation op = request.SendWebRequest();
+            op.completed += o => { };
+
+            Task.Run(() => { });
+
+            CesiumIonSession session = CesiumIonServerManager.instance.GetSession(null);
+            CesiumIonServer server = CesiumIonServerManager.instance.current;
+            session = CesiumIonServerManager.instance.currentSession;
+            session.IsConnected();
+            server = session.server;
+            session.server = server;
+
+            List<QuickAddItem> items = new List<QuickAddItem>();
+            items = session.GetQuickAddItems();
+
+            QuickAddItem item = new QuickAddItem();
+            item.type = QuickAddItemType.BlankTileset;
+            item.name = "name";
+            item.tooltip = "tooltip";
+            item.tilesetName = "tilesetName";
+            item.tilesetId = 1;
+            item.overlayName = "overlayName";
+            item.overlayId = 2;
+
+            item = new QuickAddItem(QuickAddItemType.IonTileset, "name", "tooltip", "tilesetName", 1, "overlayName", 2);
+            items.Add(item);
+            
+            server.defaultIonAccessToken = "";
+            server.defaultIonAccessTokenId = "";
+            server.apiUrl = "";
+            server.serverUrl = "";
+            server.oauth2ApplicationID = 1;
+
+            CesiumIonServerManager.instance.GetUserAccessToken(null);
+            CesiumIonServerManager.instance.SetUserAccessToken(null, null);
+
+            EditorPrefs.HasKey("Key");
+            EditorPrefs.GetString("Key");
+            EditorPrefs.SetString("Key", "Value");
+            EditorPrefs.DeleteKey("Key");
+
+            Application.OpenURL("URL");
+            string temporaryCachePath = Application.temporaryCachePath;
+            string applicationVersion = Application.version;
+            string unityVersion = Application.unityVersion;
+            string applicationPlatform = Helpers.ToString(Application.platform);
+            string productName = Application.productName;
+            string osVersion = System.Environment.OSVersion.VersionString;
+
+            TreeViewItem root = new TreeViewItem(0, -1, "root");
+            int id = root.id;
+
+            TreeViewState treeState = new TreeViewState();
+            IonAssetsTreeView treeView = new IonAssetsTreeView(treeState);
+            treeView.Reload();
+
+            MultiColumnHeader header = treeView.multiColumnHeader;
+            int sorted = header.sortedColumnIndex;
+            bool ascending = header.IsSortedAscending(sorted);
+
+            string searchString = treeView.searchString;
+            int length = searchString.Length;
+            searchString.Contains("string", StringComparison.CurrentCultureIgnoreCase);
+            string.Equals("stringA", "stringB");
+            string.IsNullOrEmpty("value");
+
+            Rect r = new Rect(0, 0, 50, 50);
+            GUI.Label(r, "Label");
+
+            session.BroadcastConnectionUpdate();
+            session.BroadcastAssetsUpdate();
+            session.BroadcastProfileUpdate();
+            session.BroadcastTokensUpdate();
+            session.BroadcastDefaultsUpdate();
+
+            CesiumEditorWindow editorWindow = CesiumEditorWindow.currentWindow;
+
+            IonAssetDetails.FormatType("type");
+            IonAssetDetails.FormatDate("date");
+
+            SelectIonTokenWindow.GetDefaultNewTokenName();
+            SelectIonTokenWindow.ShowWindow(null);
+            SelectIonTokenWindow tokenWindow = SelectIonTokenWindow.currentWindow;
+            tokenWindow.server = null;
+            tokenWindow.tokenSource = IonTokenSource.Create;
+            string name = tokenWindow.createdTokenName;
+            int tokenIndex = tokenWindow.selectedExistingTokenIndex;
+            tokenIndex = 0;
+            string token = tokenWindow.specifiedToken;
+            List<string> tokens = tokenWindow.GetExistingTokenList();
+            tokens.Clear();
+            tokens.Add(token);
+            tokenWindow.RefreshExistingTokenList();
+            tokenWindow.Close();
+
+            int requestsPerCachePrune = CesiumRuntimeSettings.requestsPerCachePrune;
+            ulong maxItems = CesiumRuntimeSettings.maxItems;
+
+            Cesium3DTileset[] tilesets = UnityEngine.Object.FindObjectsOfType<Cesium3DTileset>();
+            Cesium3DTileset tileset = tilesets[0];
+            for (int i = 0; i < tilesets.Length; i++)
+            {
+                tileset = tilesets[i];
+                tileset.tilesetSource = CesiumDataSource.FromCesiumIon;
+                token = tileset.ionAccessToken;
+                tileset.RecreateTileset();
+            }
+
+            tileset = tileset.gameObject.GetComponent<Cesium3DTileset>();
+
+            CesiumIonRasterOverlay ionOverlay = tileset.gameObject.GetComponent<CesiumIonRasterOverlay>();
+            token = ionOverlay.ionAccessToken;
+            ionOverlay.Refresh();
+            GameObject gameObject = new GameObject("Name");
+            tileset = gameObject.AddComponent<Cesium3DTileset>();
+            ionOverlay = gameObject.AddComponent<CesiumIonRasterOverlay>();
+            tileset.ionAssetID = 0;
+            ionOverlay.ionAssetID = 0;
+
+            CesiumRasterOverlay[] rasterOverlays = tileset.gameObject.GetComponents<CesiumRasterOverlay>();
+            CesiumRasterOverlay overlay = rasterOverlays[0];
+            UnityEngine.Object.DestroyImmediate(overlay, true);
+            UnityEngine.Object.DestroyImmediate(overlay);
+
+            CesiumIonRasterOverlay[] ionRasterOverlays =
+                tileset.gameObject.GetComponents<CesiumIonRasterOverlay>();
+            ionOverlay = ionRasterOverlays[0];
+
+            string substring = "string";
+            substring = string.Concat(substring, new long[] { 100 });
+            string message = string.Concat(substring, "string");
+            Debug.Log(message);
+            Debug.LogWarning(message);
+            Debug.LogError(message);
+
+            Selection.activeGameObject = gameObject;
+
+            CesiumEditorUtility.FindFirstTileset();
+            CesiumEditorUtility.FindFirstTilesetWithAssetID(0);
+            CesiumEditorUtility.CreateTileset("name", 0);
+            CesiumEditorUtility.AddBaseOverlayToTileset(tileset, 0);
+
+            IonMissingAssetWindow.ShowWindow("Asset Name", 0);
+
+            IonTokenTroubleshootingWindow troubleshootingWindow = null!;
+            IonTokenTroubleshootingWindow.UseDefaultToken(troubleshootingWindow.ionAsset);
+            TokenTroubleshootingDetails tokenDetails = troubleshootingWindow.assetTokenDetails;
+            tokenDetails = troubleshootingWindow.defaultTokenDetails;
+            token = tokenDetails.token;
+            tokenDetails.isValid = true;
+            tokenDetails.allowsAccessToAsset = true;
+            tokenDetails.associatedWithUserAccount = true;
+            tokenDetails.loaded = true;
+
+            CesiumIonAsset asset = troubleshootingWindow.ionAsset;
+            name = asset.objectName;
+            string type = asset.type;
+            string componentType = asset.componentType;
+            string accessToken = asset.ionAccessToken;
+            long assetId = asset.ionAssetID;
+            bool isNull = asset.IsNull();
+            tileset = asset.tileset;
+            server = tileset.ionServer;
+            ionOverlay = asset.overlay;
+            server = ionOverlay.ionServer;
+
+            AssetTroubleshootingDetails assetDetails = troubleshootingWindow.assetDetails;
+            assetDetails.assetExistsInUserAccount = true;
+            assetDetails.loaded = true;
+
+            EditorApplication.ExecuteMenuItem("Window/General/Hierarchy");
+
+            EditorUtility.SetDirty(null);
+
+            System.Exception exception = null;
+            var exceptionMessage = exception.Message;
+        }
+    }
+}

package/Editor/ConfigureReinterop.cs.meta

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

package/Editor/Helpers.cs

@@ -0,0 +1,102 @@
+using System;
+
+namespace CesiumForUnity
+{
+    internal class Helpers
+    {
+        public static string ToString<T>(T value)
+        {
+            return value.ToString();
+        }
+
+        /// <summary>
+        /// Produces an angle in the range -Pi <= angle <= Pi which is equivalent to the provided angle.
+        /// </summary>
+        /// <param name="angle">The angle in radians.</param>
+        /// <returns>The angle in the range [`-Math.PI`, `Math.PI`].</returns>
+        public static double NegativePiToPi(double angle)
+        {
+            if (angle >= -Math.PI && angle <= Math.PI)
+            { 
+                // Early exit if the input is already inside the range. This avoids
+                // unnecessary math which could introduce floating point error.
+                return angle;
+            }
+            return Helpers.ZeroToTwoPi(angle + Math.PI) - Math.PI;
+        }
+
+        /// <summary>
+        /// Produces an angle in the range -180 <= angle <= 180 which is equivalent to the provided angle.
+        /// </summary>
+        /// <param name="angle">The angle in degrees.</param>
+        /// <returns>The angle in the range [-180, 180].</returns>
+        public static double Negative180To180(double angle)
+        {
+            if (angle >= -180.0 && angle <= 180.0)
+            {
+                // Early exit if the input is already inside the range. This avoids
+                // unnecessary math which could introduce floating point error.
+                return angle;
+            }
+            return Helpers.ZeroTo360(angle + 180.0) - 180.0;
+        }
+
+        /// <summary>
+        /// Produces an angle in the range 0 <= angle <= 2Pi which is equivalent to the provided angle.
+        /// </summary>
+        /// <param name="angle">The angle in radians.</param>
+        /// <returns>The angle in the range [0, `Math::TwoPi`]</returns>
+        public static double ZeroToTwoPi(double angle)
+        {
+            if (angle >= 0 && angle <= 2.0 * Math.PI)
+            {
+                // Early exit if the input is already inside the range. This avoids
+                // unnecessary math which could introduce floating point error.
+                return angle;
+            }
+            double mod = Helpers.Mod(angle, 2.0 * Math.PI);
+            if (Math.Abs(mod) < 1.0e-14 && Math.Abs(angle) > 1.0e-14)
+            {
+                return 2.0 * Math.PI;
+            }
+            return mod;
+        }
+
+        /// <summary>
+        /// Produces an angle in the range 0 <= angle <= 360 which is equivalent to the provided angle.
+        /// </summary>
+        /// <param name="angle">The angle in degrees.</param>
+        /// <returns>The angle in the range [0, 360]</returns>
+        public static double ZeroTo360(double angle)
+        {
+            if (angle >= 0 && angle <= 360.0)
+            {
+                // Early exit if the input is already inside the range. This avoids
+                // unnecessary math which could introduce floating point error.
+                return angle;
+            }
+            double mod = Helpers.Mod(angle, 360.0);
+            if (Math.Abs(mod) < 1.0e-14 && Math.Abs(angle) > 1.0e-14)
+            {
+                return 360.0;
+            }
+            return mod;
+        }
+
+        /// <summary>
+        /// The modulo operation that also works for negative dividends.
+        /// </summary>
+        /// <param name="m">The dividend.</param>
+        /// <param name="n">The divisor.</param>
+        /// <returns>The remainder.</returns>
+        public static double Mod(double m, double n)
+        {
+            if (Math.Sign(m) == Math.Sign(n) && Math.Abs(m) < Math.Abs(n)) {
+              // Early exit if the input does not need to be modded. This avoids
+              // unnecessary math which could introduce floating point error.
+              return m;
+            }
+            return ((m % n) + n) % n;
+        }
+    }
+}

package/Editor/Helpers.cs.meta

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

package/Editor/IonAssetsMultiColumnHeader.cs

@@ -0,0 +1,45 @@
+using UnityEditor.IMGUI.Controls;
+
+namespace CesiumForUnity
+{
+    public class IonAssetsMultiColumnHeader : MultiColumnHeader
+    {
+        private IonAssetsTreeView _treeView;
+        private int _lastSortedColumnIndex;
+
+        public IonAssetsMultiColumnHeader(
+            MultiColumnHeaderState state,
+            IonAssetsTreeView treeView) :
+            base(state)
+        {
+            this._treeView = treeView;
+            ResizeToFit();
+        }
+
+        protected override void ColumnHeaderClicked(
+            MultiColumnHeaderState.Column column,
+            int columnIndex)
+        {
+            if (this.sortedColumnIndex == columnIndex)
+            {
+                if (column.sortedAscending)
+                {
+                    column.sortedAscending = false;
+                }
+                else
+                {
+                    // Remove the sorting entirely.
+                    sortedColumnIndex = -1;
+                }
+            }
+            else
+            {
+                sortedColumnIndex = columnIndex;
+                column.sortedAscending = true;
+            }
+
+            this._treeView.Refresh();
+        }
+    }
+
+}

package/Editor/IonAssetsMultiColumnHeader.cs.meta

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

package/Editor/IonAssetsTreeView.cs

@@ -0,0 +1,214 @@
+using Reinterop;
+using System;
+using System.Collections.Generic;
+using UnityEditor.IMGUI.Controls;
+using UnityEngine;
+
+namespace CesiumForUnity
+{
+    public enum IonAssetsColumn
+    {
+        Name = 0,
+        Type = 1,
+        DateAdded = 2,
+    }
+
+    public class IonAssetDetails
+    {
+        private string _name;
+        private string _type;
+        private long _id;
+        private string _description;
+        private string _attribution;
+
+        public IonAssetDetails(string name, string type, long id, string description, string attribution)
+        {
+            this._name = name;
+            this._type = type;
+            this._id = id;
+            this._description = description;
+            this._attribution = attribution;
+        }
+
+        public string name
+        {
+            get => this._name;
+        }
+
+        public string type
+        {
+            get => this._type;
+        }
+
+        public long id
+        {
+            get => this._id;
+        }
+
+        public string description
+        {
+            get => this._description;
+        }
+
+        public string attribution
+        {
+            get => this._attribution;
+        }
+
+        private static Dictionary<string, string> typeLookup = new Dictionary<string, string>
+        {
+            { "3DTILES", "3D Tiles" },
+            { "GLTF", "glTF" },
+            { "IMAGERY", "Imagery" },
+            { "TERRAIN", "Terrain" },
+            { "CZML", "CZML" },
+            { "KML", "KML" },
+            { "GEOJSON", "GeoJSON" }
+        };
+
+        public static string FormatType(string type)
+        {
+            string value;
+            if (typeLookup.TryGetValue(type, out value))
+            {
+                return value;
+            }
+            return "(Unknown)";
+        }
+
+        public static string FormatDate(string assetDate)
+        {
+            DateTime date = new DateTime();
+            bool success = DateTime.TryParse(
+                assetDate,
+                System.Globalization.CultureInfo.InvariantCulture,
+                System.Globalization.DateTimeStyles.RoundtripKind,
+                out date);
+
+            if (!success)
+            {
+                Debug.Log("Could not parse date " + assetDate);
+            }
+
+            return date.ToString("yyyy-MM-dd");
+        }
+    }
+
+    [ReinteropNativeImplementation("CesiumForUnityNative::IonAssetsTreeViewImpl", "IonAssetsTreeViewImpl.h")]
+    public partial class IonAssetsTreeView : TreeView
+    {
+        private MultiColumnHeaderState _headerState;
+
+        public IonAssetsTreeView(TreeViewState assetsTreeState)
+            : base(assetsTreeState)
+        {
+            BuildMultiColumnHeader();
+            CreateImplementation();
+        }
+
+        private void BuildMultiColumnHeader()
+        {
+            string[] columnNames = new string[Enum.GetNames(typeof(IonAssetsColumn)).Length];
+            columnNames[(int)IonAssetsColumn.Name] = "Name";
+            columnNames[(int)IonAssetsColumn.Type] = "Type";
+            columnNames[(int)IonAssetsColumn.DateAdded] = "Date added";
+
+            MultiColumnHeaderState.Column[] columns = new MultiColumnHeaderState.Column[columnNames.Length];
+
+            for (int i = 0; i < columns.Length; i++)
+            {
+                columns[i] = new MultiColumnHeaderState.Column()
+                {
+                    allowToggleVisibility = false,
+                    autoResize = true,
+                    minWidth = 135.0f,
+                    canSort = true,
+                    sortingArrowAlignment = TextAlignment.Center,
+                    headerContent = new GUIContent(columnNames[i]),
+                    headerTextAlignment = TextAlignment.Left,
+                    sortedAscending = true,
+                };
+            }
+
+            this._headerState = new MultiColumnHeaderState(columns);
+            multiColumnHeader = new IonAssetsMultiColumnHeader(this._headerState, this);
+        }
+
+        protected override TreeViewItem BuildRoot()
+        {
+            int rootId = 0;
+            int rootDepth = -1;
+            return new TreeViewItem(rootId, rootDepth, "Root");
+        }
+
+        public partial int GetAssetsCount();
+
+        protected override IList<TreeViewItem> BuildRows(TreeViewItem root)
+        {
+            int count = GetAssetsCount();
+            IList<TreeViewItem> rows = new List<TreeViewItem>();
+            // All items are counted as children of the root item, such that when displayed
+            // they appear in a list.
+            const int itemDepth = 0;
+
+            for (int i = 0; i < count; i++)
+            {
+                // The root of the tree is typically assigned as 0, so all of the ids
+                // have to be offset by 1. Otherwise, the selection behavior of the TreeView
+                // may be inaccurate.
+                TreeViewItem assetItem = new TreeViewItem(i + 1, itemDepth);
+                rows.Add(assetItem);
+                root.AddChild(assetItem);
+            }
+
+            return rows;
+        }
+
+        private partial string GetAssetName(int index);
+        private partial string GetAssetType(int index);
+        private partial long GetAssetID(int index);
+        private partial string GetAssetDescription(int index);
+        private partial string GetAssetAttribution(int index);
+
+        public IonAssetDetails GetAssetDetails(int treeId)
+        {
+            int index = treeId - 1;
+            string name = GetAssetName(index);
+            string type = GetAssetType(index);
+            long id = GetAssetID(index);
+            string description = GetAssetDescription(index);
+            string attribution = GetAssetAttribution(index);
+
+            return new IonAssetDetails(name, type, id, description, attribution);
+        }
+
+        protected override void RowGUI(RowGUIArgs args)
+        {
+            for (int index = 0; index < args.GetNumVisibleColumns(); ++index)
+            {
+                int assetIndex = args.item.id - 1;
+                CellGUI(args.GetCellRect(index), assetIndex, (IonAssetsColumn)index);
+            }
+        }
+
+        private partial void CellGUI(Rect cellRect, int assetIndex, IonAssetsColumn column);
+
+        public partial void Refresh();
+
+        protected override void SearchChanged(string newSearch)
+        {
+            this.Refresh();
+            this.SetSelection(new List<int>());
+        }
+
+        protected override bool CanMultiSelect(TreeViewItem item)
+        {
+            return false;
+        }
+
+        public partial void AddAssetToLevel(int index);
+
+        public partial void AddOverlayToTerrain(int index);
+    }
+}
+

package/Editor/IonAssetsTreeView.cs.meta

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