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

package/Editor/CesiumInspectorGUI.cs.meta

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

package/Editor/CesiumIonAsset.cs

@@ -0,0 +1,192 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace CesiumForUnity
+{
+    /*
+     * This class functions like a std::variant in C++. It only contains
+     * either a Cesium3DTileset or a CesiumRasterOverlay.
+     */
+    public class CesiumIonAsset
+    {
+        private enum AssetType
+        {
+            Tileset,
+            Overlay,
+            Null
+        }
+
+        private AssetType _type = AssetType.Null;
+        private Cesium3DTileset _tileset;
+        private CesiumIonRasterOverlay _overlay;
+
+        public CesiumIonAsset()
+        {
+            this._type = AssetType.Null;
+        }
+
+        public CesiumIonAsset(Cesium3DTileset tileset)
+        {
+            this._type = AssetType.Tileset;
+            this._tileset = tileset;
+        }
+
+        public CesiumIonAsset(CesiumIonRasterOverlay overlay)
+        {
+            this._type = AssetType.Overlay;
+            this._overlay = overlay;
+        }
+
+        public Cesium3DTileset tileset
+        {
+            get => this._type == AssetType.Tileset ? this._tileset : null;
+        }
+
+        public CesiumIonRasterOverlay overlay
+        {
+            get => this._type == AssetType.Overlay ? this._overlay : null;
+        }
+
+        public string objectName
+        {
+            get
+            {
+                if (this._type == AssetType.Tileset && this._tileset != null)
+                {
+                    return this._tileset.gameObject.name;
+                }
+
+                if (this._type == AssetType.Overlay && this._overlay != null)
+                {
+                    return this._overlay.gameObject.name;
+                }
+
+                return "";
+            }
+        }
+
+        public string type
+        {
+            get
+            {
+                if (this._type == AssetType.Tileset)
+                {
+                    return "Tileset";
+                }
+
+                if (this._type == AssetType.Overlay)
+                {
+                    return "Raster Overlay";
+                }
+
+                return "";
+            }
+        }
+
+        public string componentType
+        {
+            get
+            {
+                if (this._type == AssetType.Tileset && this._tileset != null)
+                {
+                    return this._tileset.GetType().Name;
+                }
+
+                if (this._type == AssetType.Overlay && this._overlay != null)
+                {
+                    return this._overlay.GetType().Name;
+                }
+
+                return "";
+            }
+        }
+
+        public string ionAccessToken
+        {
+            get
+            {
+                if (this._type == AssetType.Tileset && this._tileset != null)
+                {
+                    return this._tileset.tilesetSource == CesiumDataSource.FromCesiumIon
+                        ? this._tileset.ionAccessToken : "";
+                }
+
+                if (this._type == AssetType.Overlay)
+                {
+                    CesiumIonRasterOverlay ionOverlay = this._overlay as CesiumIonRasterOverlay;
+                    return ionOverlay != null ? ionOverlay.ionAccessToken : "";
+                }
+
+                return "";
+            }
+            set
+            {
+                if (this._type == AssetType.Tileset && this._tileset != null)
+                {
+                    this._tileset.ionAccessToken = value;
+                }
+
+                if (this._type == AssetType.Overlay)
+                {
+                    CesiumIonRasterOverlay ionOverlay = this._overlay as CesiumIonRasterOverlay;
+                    if (ionOverlay != null)
+                    {
+                        ionOverlay.ionAccessToken = value;
+                    }
+                }
+            }
+        }
+
+        public long ionAssetID
+        {
+            get
+            {
+                if (this._type == AssetType.Tileset && this._tileset != null)
+                {
+                    return this._tileset.tilesetSource == CesiumDataSource.FromCesiumIon
+                        ? this._tileset.ionAssetID : 0;
+                }
+
+                if (this._type == AssetType.Overlay && this._overlay != null)
+                {
+                    CesiumIonRasterOverlay ionOverlay = this._overlay as CesiumIonRasterOverlay;
+                    return ionOverlay != null ? ionOverlay.ionAssetID : 0;
+                }
+
+                return 0;
+            }
+        }
+
+        public bool IsNull()
+        {
+            if(this._type == AssetType.Tileset)
+            {
+                return this._tileset == null;
+            }
+
+            if(this._type == AssetType.Overlay)
+            {
+                return this._overlay == null;
+            }
+
+            return true;
+        }
+
+        public bool IsUsingCesiumIon()
+        {
+            if (this._type == AssetType.Tileset && this._tileset != null)
+            {
+                return this._tileset.tilesetSource == CesiumDataSource.FromCesiumIon;
+            }
+
+            if (this._type == AssetType.Overlay && this._overlay != null)
+            {
+                CesiumIonRasterOverlay ionOverlay = this._overlay as CesiumIonRasterOverlay;
+                return ionOverlay != null;
+            }
+
+            return false;
+        }
+    }
+}

package/Editor/CesiumIonAsset.cs.meta

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

package/Editor/CesiumIonAssetsWindow.cs

@@ -0,0 +1,257 @@
+using Reinterop;
+using System;
+using UnityEngine;
+using UnityEditor;
+using UnityEditor.IMGUI.Controls;
+
+namespace CesiumForUnity
+{
+    public class CesiumIonAssetsWindow : EditorWindow
+    {
+        public static CesiumIonAssetsWindow currentWindow = null;
+
+        [MenuItem("Cesium/Cesium ion Assets")]
+        public static void ShowWindow()
+        {
+            if (currentWindow == null)
+            {
+                // Get existing open window or if none, make a new one docked next
+                // to the Project / Console window.
+                Type[] siblingWindows = new Type[] {
+                    Type.GetType("UnityEditor.ProjectBrowser,UnityEditor.dll"),
+                    Type.GetType("UnityEditor.ConsoleWindow,UnityEditor.dll")
+                };
+                currentWindow = GetWindow<CesiumIonAssetsWindow>(siblingWindows);
+            }
+
+            currentWindow.Show();
+            currentWindow.Focus();
+        }
+
+        private TreeViewState _assetsTreeState;
+        private IonAssetsTreeView _assetsTreeView;
+        private SearchField _searchField;
+        private CesiumIonServerSelector _serverSelector;
+
+        private void OnEnable()
+        {
+            this._serverSelector = new CesiumIonServerSelector(this);
+
+            // Load the icon separately from the other resources.
+            Texture2D icon = Resources.Load<Texture2D>("Cesium-64x64");
+            icon.wrapMode = TextureWrapMode.Clamp;
+            this.titleContent = new GUIContent("Cesium ion Assets", icon);
+
+            this._searchField = new SearchField();
+
+            CesiumIonSession session = CesiumIonServerManager.instance.currentSession;
+            session.Resume();
+            BuildTreeView();
+            CesiumIonSession.OnConnectionUpdated += this._assetsTreeView.Refresh;
+            CesiumIonSession.OnAssetsUpdated += this._assetsTreeView.Refresh;
+            CesiumIonServerManager.instance.CurrentChanged += this.OnCurrentServerChanged;
+
+            session.RefreshAssets();
+        }
+
+        private void OnDisable()
+        {
+            CesiumIonServerManager.instance.CurrentChanged -= this.OnCurrentServerChanged;
+            CesiumIonSession.OnConnectionUpdated -= this._assetsTreeView.Refresh;
+            CesiumIonSession.OnAssetsUpdated -= this._assetsTreeView.Refresh;
+
+            this._serverSelector.Dispose();
+            this._serverSelector = null;
+        }
+
+        private void OnCurrentServerChanged(CesiumIonServerManager manager)
+        {
+            CesiumIonSession session = CesiumIonServerManager.instance.currentSession;
+            session.RefreshAssets();
+            this._assetsTreeView.Refresh();
+        }
+
+        void BuildTreeView()
+        {
+            this._assetsTreeState = new TreeViewState();
+            this._assetsTreeView = new IonAssetsTreeView(this._assetsTreeState);
+            this._assetsTreeView.Reload();
+        }
+
+        void OnGUI()
+        {
+            GUILayout.BeginHorizontal();
+            this.DrawAssetListPanel();
+            this.DrawAssetDescriptionPanel();
+            GUILayout.EndHorizontal();
+
+            // Force the window to repaint if the cursor is hovered over it.
+            // By default, it only repaints sporadically, so the hover and
+            // selection behavior will appear delayed.
+            if (mouseOverWindow == currentWindow)
+            {
+                Repaint();
+            }
+        }
+
+        void DrawAssetListPanel()
+        {
+            GUILayout.BeginVertical(GUILayout.Width(position.width / 2));
+            this.DrawRefreshButtonAndSearchBar();
+            GUILayout.Space(15);
+            this.DrawAssetTreeView();
+            GUILayout.EndVertical();
+        }
+
+        private string _assetsSearchString = "";
+
+        void DrawRefreshButtonAndSearchBar()
+        {
+            EditorGUILayout.BeginHorizontal();
+
+            EditorGUILayout.BeginVertical();
+            EditorGUILayout.Space(15.0f);
+            this._serverSelector.OnGUI();
+            EditorGUILayout.EndVertical();
+
+            if (GUILayout.Button(
+                new GUIContent(CesiumEditorStyle.refreshIcon, "Refresh the asset list"),
+                CesiumEditorStyle.refreshButtonStyle))
+            {
+                CesiumIonSession session = CesiumIonServerManager.instance.currentSession;
+                session.RefreshAssets();
+                this._assetsTreeView.Refresh();
+            }
+
+            EditorGUILayout.BeginVertical();
+            EditorGUILayout.Space(15);
+
+            string searchString = this._searchField.OnToolbarGUI(
+                this._assetsSearchString,
+                GUILayout.Height(EditorGUIUtility.singleLineHeight)
+            );
+
+            if (searchString != null)
+            {
+                searchString = searchString.Trim();
+                if (!searchString.Equals(this._assetsSearchString))
+                {
+                    this._assetsSearchString = searchString;
+                    this._assetsTreeView.searchString = this._assetsSearchString;
+                }
+            }
+            else if (this._assetsSearchString.Length > 0)
+            {
+                this._assetsSearchString = "";
+                this._assetsTreeView.searchString = this._assetsSearchString;
+            }
+
+            EditorGUILayout.EndVertical();
+            EditorGUILayout.EndHorizontal();
+        }
+
+        void DrawAssetTreeView()
+        {
+            // Use this to get the corner of the rect that the TreeView should fill.
+            GUILayout.FlexibleSpace();
+            Rect viewRect = GUILayoutUtility.GetLastRect();
+            viewRect.width = position.width / 2.0f;
+
+            this._assetsTreeView.OnGUI(viewRect);
+        }
+
+        private static bool IsSupportedTileset(string type)
+        {
+            return type == "3DTILES" || type == "TERRAIN";
+        }
+
+        private static bool IsSupportedImagery(string type)
+        {
+            return type == "IMAGERY";
+        }
+
+        private Vector2 _scrollPosition = Vector2.zero;
+
+        void DrawAssetDescriptionPanel()
+        {
+            if (this._assetsTreeView.GetAssetsCount() == 0)
+            {
+                return;
+            }
+
+            int selectedId = this._assetsTreeState.lastClickedID;
+            if (selectedId <= 0 || selectedId > this._assetsTreeView.GetAssetsCount())
+            {
+                return;
+            }
+
+            IonAssetDetails assetDetails = this._assetsTreeView.GetAssetDetails(selectedId);
+
+            GUILayout.Space(10);
+            this._scrollPosition = GUILayout.BeginScrollView(this._scrollPosition);
+            GUILayout.BeginVertical();
+
+            GUILayout.Label(assetDetails.name, CesiumEditorStyle.headerStyle);
+            GUILayout.Label("(ID: " + assetDetails.id + ")");
+
+            if (IsSupportedTileset(assetDetails.type))
+            {
+                GUILayout.BeginHorizontal();
+                GUILayout.FlexibleSpace();
+                if (GUILayout.Button(
+                    "Add to Level",
+                    CesiumEditorStyle.cesiumButtonStyle))
+                {
+                    // Asset indices are offset from the tree item IDs by 1.
+                    this._assetsTreeView.AddAssetToLevel(selectedId - 1);
+                }
+                GUILayout.FlexibleSpace();
+                GUILayout.EndHorizontal();
+            }
+            else if (IsSupportedImagery(assetDetails.type))
+            {
+                GUILayout.BeginHorizontal();
+                GUILayout.FlexibleSpace();
+                // TODO: once multiple overlays are supported, we need the option to
+                // add the asset as a layer.
+                GUIContent addOverlayAsBaseLayerContent = new GUIContent(
+                    "Use as Tileset Base Layer",
+                    "Makes this asset the base overlay on the selected tileset. " +
+                    "If no tileset is selected, then the overlay will be applied to the " +
+                    "first found tileset." +
+                    "\n\n" +
+                    "If the tileset already has an overlay it will be replaced. " +
+                    "If no tileset exists in the level, Cesium World Terrain is added.");
+                if (GUILayout.Button(
+                    addOverlayAsBaseLayerContent,
+                    CesiumEditorStyle.cesiumButtonStyle))
+                {
+                    // Asset indices are offset from the tree item IDs by 1.
+                    this._assetsTreeView.AddOverlayToTerrain(selectedId - 1);
+                }
+                GUILayout.FlexibleSpace();
+                GUILayout.EndHorizontal();
+            }
+            else
+            {
+                GUILayout.BeginHorizontal();
+                GUILayout.FlexibleSpace();
+                GUILayout.Button(
+                    "This type of asset is not currently supported",
+                    CesiumEditorStyle.cesiumButtonDisabledStyle
+                );
+                GUILayout.FlexibleSpace();
+                GUILayout.EndHorizontal();
+            }
+
+            GUILayout.Label("Description", CesiumEditorStyle.subheaderStyle);
+            EditorGUILayout.LabelField(assetDetails.description, EditorStyles.wordWrappedLabel);
+
+            GUILayout.Label("Attribution", CesiumEditorStyle.subheaderStyle);
+            EditorGUILayout.LabelField(assetDetails.attribution, EditorStyles.wordWrappedLabel);
+
+            GUILayout.EndVertical();
+            GUILayout.EndScrollView();
+        }
+    }
+}

package/Editor/CesiumIonAssetsWindow.cs.meta

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

package/Editor/CesiumIonRasterOverlayEditor.cs

@@ -0,0 +1,87 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace CesiumForUnity
+{
+    [CustomEditor(typeof(CesiumIonRasterOverlay))]
+    public class CesiumIonRasterOverlayEditor : Editor
+    {
+        private CesiumIonRasterOverlay _ionOverlay;
+        private CesiumRasterOverlayEditor _rasterOverlayEditor;
+
+        private SerializedProperty _ionAssetID;
+        private SerializedProperty _ionAccessToken;
+        private SerializedProperty _ionServer;
+
+        private void OnEnable()
+        {
+            this._ionOverlay = (CesiumIonRasterOverlay)this.target;
+            this._rasterOverlayEditor = 
+                (CesiumRasterOverlayEditor)Editor.CreateEditor(
+                                                    this.target,
+                                                    typeof(CesiumRasterOverlayEditor));
+
+            this._ionAssetID = this.serializedObject.FindProperty("_ionAssetID");
+            this._ionAccessToken = this.serializedObject.FindProperty("_ionAccessToken");
+            this._ionServer = this.serializedObject.FindProperty("_ionServer");
+        }
+
+        private void OnDisable()
+        {
+            if(this._rasterOverlayEditor != null)
+            {
+                DestroyImmediate(this._rasterOverlayEditor);
+            }
+        }
+
+        public override void OnInspectorGUI()
+        {
+            this.serializedObject.Update();
+
+            EditorGUIUtility.labelWidth = CesiumEditorStyle.inspectorLabelWidth;
+            DrawTroubleshootButton();
+            EditorGUILayout.Space(5);
+            DrawIonProperties();
+            EditorGUILayout.Space(5);
+            DrawRasterOverlayProperties();
+
+            this.serializedObject.ApplyModifiedProperties();
+        }
+
+        private void DrawTroubleshootButton()
+        {
+            GUIContent troubleshootTokenContent = new GUIContent(
+               "Troubleshoot Token",
+               "Check if the Cesium ion token used to access this raster overlay is working " +
+               "correctly, and fix it if necessary.");
+            if (GUILayout.Button(troubleshootTokenContent))
+            {
+                IonTokenTroubleshootingWindow.ShowWindow(this._ionOverlay, false);
+            }
+        }
+
+        private void DrawIonProperties()
+        {
+            GUIContent ionAssetIDContent = new GUIContent(
+                "ion Asset ID",
+                "The ID of the Cesium ion asset to use.");
+            EditorGUILayout.DelayedIntField(this._ionAssetID, ionAssetIDContent);
+
+            GUIContent ionAccessTokenContent = new GUIContent(
+                "ion Access Token",
+                "The access token to use to access the Cesium ion resource.");
+            EditorGUILayout.DelayedTextField(this._ionAccessToken, ionAccessTokenContent);
+
+            GUIContent ionServerContent = new GUIContent("ion Server", "The Cesium ion server to use.");
+            EditorGUILayout.PropertyField(this._ionServer, ionServerContent);
+        }
+
+        private void DrawRasterOverlayProperties()
+        {
+            if (this._rasterOverlayEditor != null)
+            {
+                this._rasterOverlayEditor.OnInspectorGUI();
+            }
+        }
+    }
+}

package/Editor/CesiumIonRasterOverlayEditor.cs.meta

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