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

package/Editor/CesiumIonServerManager.cs

@@ -0,0 +1,153 @@
+using System.Collections.Generic;
+using System;
+using UnityEditor;
+using UnityEngine;
+
+namespace CesiumForUnity
+{
+    [FilePath("UserSettings/CesiumIonServerManager.asset", FilePathAttribute.Location.ProjectFolder)]
+    public class CesiumIonServerManager : ScriptableSingleton<CesiumIonServerManager>
+    {
+        public event Action<CesiumIonServerManager> CurrentChanged;
+        public event Action<CesiumIonServerManager> ServerListChanged;
+
+        public CesiumIonServer current
+        {
+            get
+            {
+                if (this._currentCesiumIonServer == null)
+                {
+                    this._currentCesiumIonServer = CesiumIonServer.defaultServer;
+
+                    // For backward compatibility, look for an existing user access token in the EditorPrefs
+                    // and move it to the user access token map.
+                    if (string.IsNullOrEmpty(this.GetUserAccessToken(this._currentCesiumIonServer)))
+                    {
+                        const string editorPrefKey = "CesiumUserAccessToken";
+                        string userAccessToken = EditorPrefs.GetString(editorPrefKey);
+                        if (!string.IsNullOrEmpty(userAccessToken))
+                        {
+                            this.SetUserAccessToken(this._currentCesiumIonServer, userAccessToken);
+                            EditorPrefs.DeleteKey(editorPrefKey);
+                        }
+                    }
+
+                }
+                return this._currentCesiumIonServer;
+            }
+            set
+            {
+                this._currentCesiumIonServer = value;
+                CesiumIonServer.serverForNewObjects = value;
+                CurrentChanged?.Invoke(this);
+                this.Save(true);
+            }
+        }
+
+        public CesiumIonSession currentSession
+        { 
+            get
+            {
+                return this.GetSession(this.current);
+            }
+        }
+
+        public CesiumIonSession GetSession(CesiumIonServer server)
+        {
+            CesiumIonSession session;
+            if (!this._sessions.TryGetValue(server, out session))
+            {
+                session = new CesiumIonSession(server);
+                this._sessions.Add(server, session);
+            }
+            return session;
+        }
+
+        public void ResumeAll()
+        {
+            foreach (CesiumIonServer server in this.servers)
+            {
+                CesiumIonSession session = this.GetSession(server);
+                if (session != null)
+                {
+                    session.Resume();
+                    session.GetProfileUsername();
+                }
+            }
+        }
+
+        public IReadOnlyList<CesiumIonServer> servers
+        {
+            get
+            {
+                this.RefreshServerList();
+                return this._servers;
+            }
+        }
+
+        public void RefreshServerList()
+        {
+            this._servers = new List<CesiumIonServer>();
+
+            string[] guids = AssetDatabase.FindAssets("t:" + typeof(CesiumIonServer).FullName);
+            foreach (string guid in guids)
+            {
+                string path = AssetDatabase.GUIDToAssetPath(guid);
+                this._servers.Add(AssetDatabase.LoadAssetAtPath<CesiumIonServer>(path));
+            }
+            ServerListChanged?.Invoke(this);
+        }
+
+        internal string GetUserAccessToken(CesiumIonServer server)
+        {
+            int index = this._userAccessTokenMap.FindIndex(record => record.server == server);
+            return index >= 0 ? this._userAccessTokenMap[index].token : null;
+        }
+
+        internal void SetUserAccessToken(CesiumIonServer server, string token)
+        {
+            int index = this._userAccessTokenMap.FindIndex(record => record.server == server);
+            if (index >= 0)
+            {
+                this._userAccessTokenMap[index].token = token;
+            }
+            else
+            {
+                UserAccessTokenRecord record = new UserAccessTokenRecord();
+                record.server = server;
+                record.token = token;
+                this._userAccessTokenMap.Add(record);
+            }
+
+            this.Save(true);
+        }
+
+        class RefreshServers : AssetPostprocessor
+        {
+            static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths, bool didDomainReload)
+            {
+                CesiumIonServerManager.instance.ResumeAll();
+
+                // Ensure the `serverForNewObjects` matches the current server. This is
+                // essential when the manager is first loaded, and harmless otherwise.
+                CesiumIonServer.serverForNewObjects = CesiumIonServerManager.instance.current;
+            }
+        }
+
+        [Serializable]
+        private class UserAccessTokenRecord
+        {
+            public CesiumIonServer server;
+            public string token;
+        }
+
+        [SerializeField]
+        private List<UserAccessTokenRecord> _userAccessTokenMap = new List<UserAccessTokenRecord>();
+
+        [SerializeField]
+        private CesiumIonServer _currentCesiumIonServer;
+
+        private Dictionary<CesiumIonServer, CesiumIonSession> _sessions = new Dictionary<CesiumIonServer, CesiumIonSession>();
+        private List<CesiumIonServer> _servers = new List<CesiumIonServer>();
+    }
+}

package/Editor/CesiumIonServerManager.cs.meta

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

package/Editor/CesiumIonServerSelector.cs

@@ -0,0 +1,127 @@
+using System;
+using UnityEditor;
+using UnityEditor.IMGUI.Controls;
+using UnityEditor.SearchService;
+using UnityEngine;
+
+namespace CesiumForUnity
+{
+    public class CesiumIonServerSelector : IDisposable
+    {
+        public static void DisplaySelected(CesiumIonServer server)
+        {
+            EditorGUILayout.BeginHorizontal();
+            EditorGUILayout.Space(10, false);
+            bool enabled = GUI.enabled;
+            GUI.enabled = false;
+            EditorGUILayout.TextField("Cesium ion Server:", server.name, GUILayout.Width(500));
+            GUI.enabled = enabled;
+            GUILayout.FlexibleSpace();
+            EditorGUILayout.EndHorizontal();
+        }
+
+        public static string GetLabelFromCesiumIonServer(CesiumIonServer server)
+        {
+            if (server == null)
+                return "Error: No Cesium ion server configured.";
+
+            CesiumIonSession session = CesiumIonServerManager.instance.GetSession(server);
+
+            string profileName = session.GetProfileUsername();
+
+            string prefix = "";
+            string suffix = "";
+
+            if (session.IsConnecting() || session.IsResuming())
+                suffix = " (connecting...)";
+            else if (session.IsLoadingProfile())
+                suffix = " (loading profile...)";
+            else if (session.IsConnected() && session.IsProfileLoaded())
+                prefix = profileName + " @ ";
+            else
+                suffix = " (not connected)";
+
+            return prefix + server.name + suffix;
+        }
+
+        private EditorWindow _parent;
+        private AdvancedDropdownState _dropDownState = new AdvancedDropdownState();
+
+        public CesiumIonServerSelector(EditorWindow parent)
+        {
+            this._parent = parent;
+            CesiumIonServerManager.instance.CurrentChanged += OnCurrentChanged;
+        }
+
+        public void Dispose()
+        {
+            CesiumIonServerManager.instance.CurrentChanged -= OnCurrentChanged;
+        }
+
+        private void OnCurrentChanged(CesiumIonServerManager manager)
+        {
+            this._parent.Repaint();
+        }
+
+        public void OnGUI()
+        {
+            CesiumIonServer server = CesiumIonServerManager.instance.current;
+            GUIContent content = new GUIContent(GetLabelFromCesiumIonServer(server), "The current Cesium ion server");
+            Rect rect = EditorGUILayout.BeginHorizontal();
+            if (EditorGUILayout.DropdownButton(content, FocusType.Keyboard))
+            {
+                var serverDropDown = new ServerDropDown(this._dropDownState, rect);
+                serverDropDown.Show(rect);
+            }
+
+            GUIContent browseButtonContent = new GUIContent(
+                CesiumEditorStyle.folderIcon,
+                "Show this server in the Project view.");
+            if (GUILayout.Button(browseButtonContent, GUILayout.Height(EditorGUIUtility.singleLineHeight), GUILayout.ExpandWidth(false)))
+            {
+                EditorUtility.FocusProjectWindow();
+                EditorGUIUtility.PingObject(CesiumIonServerManager.instance.current);
+
+            }
+            EditorGUILayout.EndHorizontal();
+        }
+
+        private class ServerDropDownItem : AdvancedDropdownItem
+        {
+            public CesiumIonServer server;
+
+            public ServerDropDownItem(CesiumIonServer server)
+                : base(GetLabelFromCesiumIonServer(server))
+            {
+                this.server = server;
+            }
+        }
+
+        private class ServerDropDown : AdvancedDropdown
+        {
+            public ServerDropDown(AdvancedDropdownState state, Rect rect)
+                : base(state)
+            {
+                int itemCount = Math.Min(10, CesiumIonServerManager.instance.servers.Count);
+                this.minimumSize = new Vector2(50.0f, (itemCount + 3) * EditorGUIUtility.singleLineHeight);
+            }
+
+            protected override AdvancedDropdownItem BuildRoot()
+            {
+                AdvancedDropdownItem root = new AdvancedDropdownItem("Cesium ion Servers");
+
+                foreach (CesiumIonServer server in CesiumIonServerManager.instance.servers)
+                {
+                    root.AddChild(new ServerDropDownItem(server));
+                }
+
+                return root;
+            }
+
+            protected override void ItemSelected(AdvancedDropdownItem item)
+            {
+                CesiumIonServerManager.instance.current = ((ServerDropDownItem)item).server;
+            }
+        }
+    }
+}

package/Editor/CesiumIonServerSelector.cs.meta

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

package/Editor/CesiumIonSession.cs

@@ -0,0 +1,102 @@
+using System.Collections.Generic;
+using Reinterop;
+
+namespace CesiumForUnity
+{
+    [ReinteropNativeImplementation("CesiumForUnityNative::CesiumIonSessionImpl", "CesiumIonSessionImpl.h")]
+    public partial class CesiumIonSession
+    {
+        public delegate void GUIUpdateDelegate();
+
+        public static event GUIUpdateDelegate OnConnectionUpdated;
+        public static event GUIUpdateDelegate OnAssetsUpdated;
+        public static event GUIUpdateDelegate OnProfileUpdated;
+        public static event GUIUpdateDelegate OnTokensUpdated;
+        public static event GUIUpdateDelegate OnDefaultsUpdated;
+
+        public CesiumIonServer server
+        {
+            get;
+            internal set;
+        }
+
+        public CesiumIonSession(CesiumIonServer server)
+        {
+            this.server = server;
+            this.CreateImplementation();
+        }
+
+        public partial bool IsConnected();
+        public partial bool IsConnecting();
+        public partial bool IsResuming();
+
+        public partial bool IsProfileLoaded();
+        public partial bool IsLoadingProfile();
+
+        public partial bool IsAssetListLoaded();
+        public partial bool IsLoadingAssetList();
+
+        public partial bool IsTokenListLoaded();
+        public partial bool IsLoadingTokenList();
+
+        public partial bool IsDefaultsLoaded();
+        public partial bool IsLoadingDefaults();
+        public partial bool IsAuthenticationRequired();
+
+        public partial void Connect();
+        public partial void Resume();
+        public partial void Disconnect();
+
+        public partial string GetProfileUsername();
+        public partial string GetAuthorizeUrl();
+        public partial string GetRedirectUrl();
+        public partial List<QuickAddItem> GetQuickAddItems();
+
+        public partial void Tick();
+
+        public partial void RefreshProfile();
+        public partial void RefreshTokens();
+        public partial void RefreshAssets();
+        public partial void RefreshDefaults();
+
+        public void BroadcastConnectionUpdate()
+        {
+            if (OnConnectionUpdated != null)
+            {
+                OnConnectionUpdated();
+            }
+        }
+
+        public void BroadcastAssetsUpdate()
+        {
+            if (OnAssetsUpdated != null)
+            {
+                OnAssetsUpdated();
+            }
+        }
+
+        public void BroadcastProfileUpdate()
+        {
+            if (OnProfileUpdated != null)
+            {
+                OnProfileUpdated();
+            }
+        }
+
+        public void BroadcastTokensUpdate()
+        {
+            if (OnTokensUpdated != null)
+            {
+                OnTokensUpdated();
+            }
+        }
+
+        public void BroadcastDefaultsUpdate()
+        {
+            if (OnDefaultsUpdated != null)
+            {
+                OnDefaultsUpdated();
+            }
+        }
+    }
+}

package/Editor/CesiumIonSession.cs.meta

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

package/Editor/CesiumPolygonRasterOverlayEditor.cs

@@ -0,0 +1,102 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace CesiumForUnity
+{
+    [CustomEditor(typeof(CesiumPolygonRasterOverlay))]
+    public class CesiumPolygonRasterOverlayEditor : Editor
+    {
+        private CesiumRasterOverlayEditor _rasterOverlayEditor;
+
+        private SerializedProperty _polygons;
+        private SerializedProperty _invertSelection;
+        private SerializedProperty _excludeSelectedTiles;
+
+        private void OnEnable()
+        {
+            this._rasterOverlayEditor =
+                (CesiumRasterOverlayEditor)Editor.CreateEditor(
+                                                     this.target,
+                                                     typeof(CesiumRasterOverlayEditor));
+
+            this._rasterOverlayEditor.drawShowCreditsOnScreen = false;
+
+            this._polygons = this.serializedObject.FindProperty("_polygons");
+            this._invertSelection = this.serializedObject.FindProperty("_invertSelection");
+            this._excludeSelectedTiles = this.serializedObject.FindProperty("_excludeSelectedTiles");
+        }
+
+        private void OnDisable()
+        {
+            if (this._rasterOverlayEditor != null)
+            {
+                DestroyImmediate(this._rasterOverlayEditor);
+            }
+        }
+
+        public override void OnInspectorGUI()
+        {
+            this.serializedObject.Update();
+
+#if !SUPPORTS_SPLINES
+#if UNITY_2022_2_OR_NEWER
+            EditorGUILayout.HelpBox("CesiumCartographicPolygon requires the Splines package, which is currently " +
+             "not installed in the project. CesiumPolygonRasterOverlay will not have any effect until the Splines " +
+             "package is installed through the Package Manager.", MessageType.Error);
+#else
+            EditorGUILayout.HelpBox("CesiumCartographicPolygon requires the Splines package, which is not available " +
+                "in this version of Unity. This means CesiumPolygonRasterOverlay will not have any effect.", MessageType.Error);
+#endif
+#endif
+
+            EditorGUIUtility.labelWidth = CesiumEditorStyle.inspectorLabelWidth;
+            this.DrawPolygonRasterOverlayProperties();
+            EditorGUILayout.Space(5);
+            this.DrawRasterOverlayProperties();
+
+            this.serializedObject.ApplyModifiedProperties();
+        }
+
+        private void DrawPolygonRasterOverlayProperties()
+        {
+            GUIContent polygonsContent = new GUIContent(
+                "Polygons",
+                "The polygons to rasterize for this overlay.");
+            EditorGUILayout.PropertyField(this._polygons, polygonsContent);
+
+            GUIContent invertSelectionContent = new GUIContent(
+                "Invert Selection",
+                "Whether to invert the selection specified by the polygons." +
+                "\n\n" +
+                "When this setting is false, the areas inside the polygons are rasterized and therefore " +
+                "hidden from the rest of the tileset. In other words, they appear to cut holes in the " +
+                "tileset." +
+                "\n\n" +
+                "When this setting is true, the areas outside of all the polygons will be rasterized " +
+                "instead. This will hide everything except for the areas inside the polygons.");
+            EditorGUILayout.PropertyField(this._invertSelection, invertSelectionContent);
+
+            GUIContent excludeSelectedTilesContent = new GUIContent(
+                "Exclude Selected Tiles",
+                "Whether tiles that fall entirely within the rasterized selection should be " +
+                "excluded from loading and rendering." +
+                "\n\n" +
+                "For better performance, this should be enabled when this overlay will be used for clipping. " +
+                "But when this overlay is used for other effects, this option should be disabled to avoid " +
+                "missing tiles." +
+                "\n\n" +
+                "Note that if Invert Selection is true, this will cull tiles that are outside of all the " +
+                "polygons. If it is false, this will cull tiles that are completely inside at least one " +
+                "polygon.");
+            EditorGUILayout.PropertyField(this._excludeSelectedTiles, excludeSelectedTilesContent);
+        }
+
+        private void DrawRasterOverlayProperties()
+        {
+            if (this._rasterOverlayEditor != null)
+            {
+                this._rasterOverlayEditor.OnInspectorGUI();
+            }
+        }
+    }
+}

package/Editor/CesiumPolygonRasterOverlayEditor.cs.meta

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