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

package/Editor/CesiumCameraControllerEditor.cs

@@ -0,0 +1,174 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace CesiumForUnity
+{
+    [CustomEditor(typeof(CesiumCameraController))]
+    public class CesiumCameraControllerEditor : Editor
+    {
+        private SerializedProperty _enableMovement;
+        private SerializedProperty _enableRotation;
+
+        private SerializedProperty _defaultMaximumSpeed;
+
+        private SerializedProperty _enableDynamicSpeed;
+        private SerializedProperty _dynamicSpeedMinHeight;
+
+        private SerializedProperty _enableDynamicClippingPlanes;
+        private SerializedProperty _dynamicClippingPlanesMinHeight;
+
+#if ENABLE_INPUT_SYSTEM
+        private SerializedProperty _lookAction;
+        private SerializedProperty _moveAction;
+        private SerializedProperty _moveUpAction;
+        private SerializedProperty _speedChangeAction;
+        private SerializedProperty _speedResetAction;
+        private SerializedProperty _toggleDynamicSpeedAction;
+#endif
+
+        private void OnEnable()
+        {
+            this._enableMovement =
+                this.serializedObject.FindProperty("_enableMovement");
+            this._enableRotation =
+                this.serializedObject.FindProperty("_enableRotation");
+
+            this._defaultMaximumSpeed =
+                this.serializedObject.FindProperty("_defaultMaximumSpeed");
+
+            this._enableDynamicSpeed =
+                this.serializedObject.FindProperty("_enableDynamicSpeed");
+            this._dynamicSpeedMinHeight =
+                this.serializedObject.FindProperty("_dynamicSpeedMinHeight");
+
+            this._enableDynamicClippingPlanes =
+                this.serializedObject.FindProperty("_enableDynamicClippingPlanes");
+            this._dynamicClippingPlanesMinHeight =
+                this.serializedObject.FindProperty("_dynamicClippingPlanesMinHeight");
+
+#if ENABLE_INPUT_SYSTEM
+            this._lookAction = this.serializedObject.FindProperty("_lookAction");
+            this._moveAction = this.serializedObject.FindProperty("_moveAction");
+            this._moveUpAction = this.serializedObject.FindProperty("_moveUpAction");
+            this._speedChangeAction = this.serializedObject.FindProperty("_speedChangeAction");
+            this._speedResetAction = this.serializedObject.FindProperty("_speedResetAction");
+            this._toggleDynamicSpeedAction = this.serializedObject.FindProperty("_toggleDynamicSpeedAction");
+#endif
+        }
+
+        public override void OnInspectorGUI()
+        {
+            this.serializedObject.Update();
+            this.DrawProperties();
+            this.serializedObject.ApplyModifiedProperties();
+        }
+
+        private void DrawProperties()
+        {
+            // The labels for this component are particularly long, so use a custom value
+            // instead of the editor style's default.
+            int labelWidth = 215;
+
+            GUILayout.BeginHorizontal();
+            GUIContent enableMovementContent = new GUIContent(
+                "Enable Movement",
+                "Whether movement is enabled on this controller. Movement is controlled " +
+                "using the W, A, S, D keys, as well as the Q and E keys for vertical " +
+                "movement with respect to the globe.");
+            GUILayout.Label(enableMovementContent, GUILayout.Width(labelWidth));
+            EditorGUILayout.PropertyField(this._enableMovement, GUIContent.none);
+            GUILayout.EndHorizontal();
+
+            GUILayout.BeginHorizontal();
+            GUIContent enableRotationContent = new GUIContent(
+                "Enable Rotation",
+                "Whether rotation is enabled on this controller. Rotation is controlled " +
+                "by movement of the mouse.");
+            GUILayout.Label(enableRotationContent, GUILayout.Width(labelWidth));
+            EditorGUILayout.PropertyField(this._enableRotation, GUIContent.none);
+            GUILayout.EndHorizontal();
+
+            EditorGUILayout.Space(5);
+
+            GUILayout.BeginHorizontal();
+            GUIContent defaultMaximumSpeedContent = new GUIContent(
+                "Default Maximum Speed",
+                "The controller's maximum speed when dynamic speed is disabled. " +
+                "If dynamic speed is enabled, this value will not be used.");
+            GUILayout.Label(defaultMaximumSpeedContent, GUILayout.Width(labelWidth));
+            EditorGUILayout.PropertyField(this._defaultMaximumSpeed, GUIContent.none);
+            GUILayout.EndHorizontal();
+
+            GUILayout.BeginHorizontal();
+            GUIContent enableDynamicSpeedContent = new GUIContent(
+                "Enable Dynamic Speed",
+                "If enabled, the controller's speed will change dynamically based on " +
+                "elevation and other factors.");
+            GUILayout.Label(enableDynamicSpeedContent, GUILayout.Width(labelWidth));
+            EditorGUILayout.PropertyField(this._enableDynamicSpeed, GUIContent.none);
+            GUILayout.EndHorizontal();
+
+            EditorGUI.BeginDisabledGroup(!this._enableDynamicSpeed.boolValue);
+
+            GUILayout.BeginHorizontal();
+            GUIContent dynamicSpeedMinHeightContent = new GUIContent(
+                "Dynamic Speed Min Height",
+                "The minimum height where dynamic speed starts to take effect." +
+                "\n\n" +
+                "Below this height, the current speed will be set as the height of " +
+                "the camera above tilesets in the scene. This forces the camera to move " +
+                "more slowly when it is right above a tileset.");
+            GUILayout.Label(dynamicSpeedMinHeightContent, GUILayout.Width(labelWidth));
+            EditorGUILayout.PropertyField(this._dynamicSpeedMinHeight, GUIContent.none);
+            GUILayout.EndHorizontal();
+
+            EditorGUI.EndDisabledGroup();
+
+            EditorGUILayout.Space(5);
+
+            GUILayout.BeginHorizontal();
+            GUIContent enableDynamicClippingPlanesContent = new GUIContent(
+                "Enable Dynamic Clipping Planes",
+                "If enabled, the camera will dynamically reposition its clipping " +
+                "planes so that the globe will not get clipped from far away. " +
+                "If this option is disabled, the globe and other tilesets may not render " +
+                "at large distances because they will be clipped by the camera." +
+                "\n\n" +
+                "This setting may not work well for rendering objects that are far " +
+                "above the Earth but still close to the camera as it zooms out.");
+            GUILayout.Label(enableDynamicClippingPlanesContent, GUILayout.Width(labelWidth));
+            EditorGUILayout.PropertyField(this._enableDynamicClippingPlanes, GUIContent.none);
+            GUILayout.EndHorizontal();
+
+            EditorGUI.BeginDisabledGroup(!this._enableDynamicClippingPlanes.boolValue);
+
+            GUILayout.BeginHorizontal();
+            GUIContent dynamicClippingPlanesMinHeightContent = new GUIContent(
+                "Dynamic Clipping Planes Min Height",
+                "The height to start dynamically adjust the camera's clipping " +
+                "planes. Below this height, the clipping planes will be set to their " +
+                "initial values.");
+            GUILayout.Label(dynamicClippingPlanesMinHeightContent, GUILayout.Width(labelWidth));
+            EditorGUILayout.PropertyField(this._dynamicClippingPlanesMinHeight, GUIContent.none);
+            GUILayout.EndHorizontal();
+
+            EditorGUI.EndDisabledGroup();
+
+#if ENABLE_INPUT_SYSTEM
+            EditorGUILayout.Space(5);
+
+            this._lookAction.isExpanded = EditorGUILayout.BeginFoldoutHeaderGroup(this._lookAction.isExpanded, new GUIContent("Input Actions"));
+            if (this._lookAction.isExpanded)
+            {
+                EditorGUILayout.PropertyField(this._lookAction);
+                EditorGUILayout.PropertyField(this._moveAction);
+                EditorGUILayout.PropertyField(this._moveUpAction);
+                EditorGUILayout.PropertyField(this._speedChangeAction);
+                EditorGUILayout.PropertyField(this._speedResetAction);
+                EditorGUILayout.PropertyField(this._toggleDynamicSpeedAction);
+            }
+            EditorGUILayout.EndFoldoutHeaderGroup();
+#endif
+        }
+    }
+}

package/Editor/CesiumCameraControllerEditor.cs.meta

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

package/Editor/CesiumCameraManagerEditor.cs

@@ -0,0 +1,65 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace CesiumForUnity
+{
+    [CustomEditor(typeof(CesiumCameraManager))]
+    public class CesiumCameraManagerEditor : Editor
+    {
+        private SerializedProperty _useMainCamera;
+        private SerializedProperty _useActiveSceneViewCameraInEditor;
+        private SerializedProperty _additionalCameras;
+
+        private void OnEnable()
+        {
+            this._useMainCamera =
+                this.serializedObject.FindProperty("_useMainCamera");
+            this._useActiveSceneViewCameraInEditor =
+                this.serializedObject.FindProperty("_useSceneViewCameraInEditor");
+            this._additionalCameras =
+                this.serializedObject.FindProperty("_additionalCameras");
+        }
+
+        public override void OnInspectorGUI()
+        {
+            this.serializedObject.Update();
+            EditorGUIUtility.labelWidth = CesiumEditorStyle.inspectorLabelWidth;
+            this.DrawProperties();
+            this.serializedObject.ApplyModifiedProperties();
+        }
+
+        private static readonly string useMainCameraTooltip = CesiumEditorUtility.FormatTooltip(@"
+            Whether the camera tagged `MainCamera` should be used for Cesium3DTileset
+            culling and level-of-detail.");
+
+        private static readonly string useActiveSceneViewCameraInEditorTooltip = CesiumEditorUtility.FormatTooltip(@"
+            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.");
+
+        private static readonly string additionalCamerasTooltip = CesiumEditorUtility.FormatTooltip(@"
+            Other Cameras to use for Cesium3DTileset culling and level-of-detail, in addition to
+            the ones controlled by the checkboxes above.
+
+            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.");
+
+        private void DrawProperties()
+        {
+            GUIContent useMainCameraContent = new GUIContent("Use MainCamera", useMainCameraTooltip);
+            EditorGUILayout.PropertyField(
+                this._useMainCamera, useMainCameraContent);
+
+            EditorGUI.BeginDisabledGroup(EditorApplication.isPlaying);
+            GUIContent useActiveSceneViewCameraInEditorContent = new GUIContent("Use Editor Scene View Camera", useActiveSceneViewCameraInEditorTooltip);
+            EditorGUILayout.PropertyField(
+                this._useActiveSceneViewCameraInEditor, useActiveSceneViewCameraInEditorContent);
+            EditorGUI.EndDisabledGroup();
+
+            GUIContent additionalCamerasContent = new GUIContent("Additional Cameras", additionalCamerasTooltip);
+            EditorGUILayout.PropertyField(
+                this._additionalCameras, additionalCamerasContent);
+        }
+    }
+}

package/Editor/CesiumCameraManagerEditor.cs.meta

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

package/Editor/CesiumCartographicPolygonEditor.cs

@@ -0,0 +1,23 @@
+using UnityEditor;
+
+namespace CesiumForUnity
+{
+    [CustomEditor(typeof(CesiumCartographicPolygon))]
+    public class CesiumCartographicPolygonEditor : Editor
+    {
+        public override void OnInspectorGUI()
+        {
+#if !SUPPORTS_SPLINES
+#if UNITY_2022_2_OR_NEWER
+            EditorGUILayout.HelpBox("CesiumCartographicPolygon requires the Splines package, which is currently " +
+                "not installed in the project. Install the Splines package using the Package Manager.", MessageType.Error);
+#else
+            EditorGUILayout.HelpBox("CesiumCartographicPolygon requires the Splines package, which is not available " +
+                "in this version of Unity.", MessageType.Error);
+#endif
+#endif
+
+            base.OnInspectorGUI();
+        }
+    }
+}

package/Editor/CesiumCartographicPolygonEditor.cs.meta

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

package/Editor/CesiumDebugColorizeTilesRasterOverlayEditor.cs

@@ -0,0 +1,41 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace CesiumForUnity
+{
+    [CustomEditor(typeof(CesiumDebugColorizeTilesRasterOverlay))]
+    public class CesiumDebugColorizeTilesRasterOverlayEditor : Editor
+    {
+        private CesiumRasterOverlayEditor _rasterOverlayEditor;
+
+        private void OnEnable()
+        {
+            this._rasterOverlayEditor =
+                (CesiumRasterOverlayEditor)Editor.CreateEditor(
+                                                     this.target,
+                                                     typeof(CesiumRasterOverlayEditor));
+
+            // The other CesiumRasterOverlay options don't apply to
+            // CesiumDebugColorizeTilesRasterOverlay, so don't show them here.
+
+            this._rasterOverlayEditor.drawShowCreditsOnScreen = false;
+            this._rasterOverlayEditor.drawOverlayProperties = false;
+        }
+
+        private void OnDisable()
+        {
+            if (this._rasterOverlayEditor != null)
+            {
+                DestroyImmediate(this._rasterOverlayEditor);
+            }
+        }
+
+        public override void OnInspectorGUI()
+        {
+            if (this._rasterOverlayEditor != null)
+            {
+                this._rasterOverlayEditor.OnInspectorGUI();
+            }
+        }
+    }
+}

package/Editor/CesiumDebugColorizeTilesRasterOverlayEditor.cs.meta

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

package/Editor/CesiumEditor.asmdef

@@ -0,0 +1,26 @@
+{
+    "name": "CesiumEditor",
+    "rootNamespace": "",
+    "references": [
+        "GUID:63cab5ddbd23cf34ca160a9b3d74438d",
+        "GUID:d8b63aba1907145bea998dd612889d6b",
+        "GUID:21d1eb854b91ade49bc69a263d12bee2"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": true,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [
+        {
+            "name": "com.unity.splines",
+            "expression": "1.0.0",
+            "define": "SUPPORTS_SPLINES"
+        }
+    ],
+    "noEngineReferences": false
+}

package/Editor/CesiumEditor.asmdef.meta

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

package/Editor/CesiumEditorStyle.cs

@@ -0,0 +1,188 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+
+namespace CesiumForUnity
+{
+    public static class CesiumEditorStyle
+    {
+        public static GUIStyle toolbarStyle;
+        public static GUIStyle toolbarButtonStyle;
+        public static GUIStyle toolbarButtonDisabledStyle;
+
+        public static GUIStyle quickAddItemStyle;
+        public static GUIStyle quickAddButtonStyle;
+
+        public static GUIStyle cesiumButtonStyle;
+        public static GUIStyle cesiumButtonDisabledStyle;
+        public static GUIStyle refreshButtonStyle;
+
+        public static GUIStyle headerStyle;
+        public static GUIStyle subheaderStyle;
+
+        public static Texture2D cesiumForUnityLogoLight;
+        public static Texture2D cesiumForUnityLogoDark;
+        private static readonly int logoWidth = 400;
+        private static readonly int logoHeight = 330;
+
+        public static Texture2D quickAddIcon;
+        public static Dictionary<CesiumEditorWindow.ToolbarButton, Texture2D> toolbarIcons;
+        public static Texture2D refreshIcon;
+        public static Texture2D checkIcon;
+        public static Texture2D xIcon;
+        public static Texture2D folderIcon;
+
+        private static readonly Color buttonColor = new Color(0.2945f, 0.6317f, 0.7930f);
+        private static readonly Color buttonColorLighter = new Color(0.4475f, 0.7544f, 0.8904f);
+        private static readonly Color buttonColorDarker = new Color(0.2598f, 0.5785f, 0.7075f);
+        private static readonly Color disabledButtonTextColor = new Color(0.7f, 0.7f, 0.7f);
+
+        private static Texture2D buttonTexture;
+        private static Texture2D buttonHoverTexture;
+        private static Texture2D buttonPressedTexture;
+
+        public static readonly float inspectorLabelWidth = 205.0f;
+
+        private static Texture2D LoadImage(string resourcePath)
+        {
+            Texture2D icon = Resources.Load<Texture2D>(resourcePath);
+            icon.wrapMode = TextureWrapMode.Clamp;
+
+            return icon;
+        }
+
+        private static Texture2D LoadImage(
+            string resourcePath,
+            int desiredWidth, 
+            int desiredHeight)
+        {
+            // This is a roundabout way of resizing the image, since Reinitialize()
+            // doesn't work on textures that aren't readable and the textures
+            // from Resources.Load are non-readable by default.
+            Texture2D original = LoadImage(resourcePath);
+            RenderTexture renderTexture = new RenderTexture(
+                desiredWidth,
+                desiredHeight,
+                0);
+            RenderTexture oldActive = RenderTexture.active;
+            RenderTexture.active = renderTexture;
+            Graphics.Blit(original, renderTexture);
+
+            Texture2D resized = new Texture2D(desiredWidth, desiredHeight);
+            resized.ReadPixels(new Rect(0, 0, desiredWidth, desiredHeight), 0, 0);
+            resized.Apply();
+            resized.hideFlags = HideFlags.HideAndDontSave;
+
+            RenderTexture.active = oldActive;
+
+            return resized;
+        }
+
+        static CesiumEditorStyle()
+        {
+            cesiumForUnityLogoDark =
+                LoadImage("Cesium-for-Unity-dark", logoWidth, logoHeight);
+            cesiumForUnityLogoLight =
+                LoadImage("Cesium-for-Unity-light", logoWidth, logoHeight);
+
+            quickAddIcon = LoadImage("FontAwesome/plus-solid");
+
+            quickAddItemStyle = new GUIStyle();
+            quickAddItemStyle.margin = new RectOffset(5, 5, 10, 10);
+
+            quickAddButtonStyle = new GUIStyle();
+            quickAddButtonStyle.fixedWidth = 16.0f;
+            quickAddButtonStyle.fixedHeight = 16.0f;
+            quickAddButtonStyle.hover.background = Texture2D.grayTexture;
+
+            toolbarIcons = new Dictionary<CesiumEditorWindow.ToolbarButton, Texture2D>();
+            toolbarIcons.Add(
+                CesiumEditorWindow.ToolbarButton.Add,
+                quickAddIcon);
+            toolbarIcons.Add(
+                CesiumEditorWindow.ToolbarButton.Upload,
+                LoadImage("FontAwesome/cloud-upload-alt-solid"));
+            toolbarIcons.Add(
+                CesiumEditorWindow.ToolbarButton.Token,
+                LoadImage("FontAwesome/key-solid"));
+            toolbarIcons.Add(
+                CesiumEditorWindow.ToolbarButton.Learn,
+                LoadImage("FontAwesome/book-reader-solid"));
+            toolbarIcons.Add(
+                CesiumEditorWindow.ToolbarButton.Help,
+                LoadImage("FontAwesome/hands-helping-solid"));
+            toolbarIcons.Add(
+                CesiumEditorWindow.ToolbarButton.SignOut,
+                LoadImage("FontAwesome/sign-out-alt-solid"));
+
+            toolbarStyle = new GUIStyle();
+            toolbarStyle.margin = new RectOffset(5, 5, 5, 5);
+
+            toolbarButtonStyle = new GUIStyle();
+            toolbarButtonStyle.imagePosition = ImagePosition.ImageAbove;
+            toolbarButtonStyle.padding = new RectOffset(5, 5, 5, 5);
+            toolbarButtonStyle.alignment = TextAnchor.MiddleCenter;
+            toolbarButtonStyle.normal.textColor = EditorStyles.label.normal.textColor;
+            toolbarButtonStyle.hover.textColor = EditorStyles.label.normal.textColor;
+            toolbarButtonStyle.hover.background = Texture2D.grayTexture;
+
+            toolbarButtonDisabledStyle = new GUIStyle(toolbarButtonStyle);
+            toolbarButtonDisabledStyle.hover.background = null;
+
+            refreshIcon = LoadImage("FontAwesome/sync-alt-solid");
+
+            buttonTexture = new Texture2D(1, 1);
+            buttonTexture.SetPixel(0, 0, buttonColor);
+            buttonTexture.Apply();
+            buttonTexture.hideFlags = HideFlags.HideAndDontSave;
+
+            buttonHoverTexture = new Texture2D(1, 1);
+            buttonHoverTexture.SetPixel(0, 0, buttonColorLighter);
+            buttonHoverTexture.Apply();
+            buttonHoverTexture.hideFlags = HideFlags.HideAndDontSave;
+
+            buttonPressedTexture = new Texture2D(1, 1);
+            buttonPressedTexture.SetPixel(0, 0, buttonColorDarker);
+            buttonPressedTexture.Apply();
+            buttonPressedTexture.hideFlags = HideFlags.HideAndDontSave;
+
+            cesiumButtonStyle = new GUIStyle();
+            cesiumButtonStyle.padding = new RectOffset(25, 25, 10, 10);
+            cesiumButtonStyle.margin = new RectOffset(10, 10, 10, 10);
+            cesiumButtonStyle.fontStyle = FontStyle.Bold;
+            cesiumButtonStyle.alignment = TextAnchor.MiddleCenter;
+            cesiumButtonStyle.normal.background = buttonTexture;
+            cesiumButtonStyle.normal.textColor = Color.white;
+            cesiumButtonStyle.hover.background = buttonHoverTexture;
+            cesiumButtonStyle.hover.textColor = Color.white;
+            cesiumButtonStyle.active.background = buttonPressedTexture;
+            cesiumButtonStyle.active.textColor = Color.white;
+
+            cesiumButtonDisabledStyle = new GUIStyle(cesiumButtonStyle);
+            cesiumButtonDisabledStyle.normal.background = Texture2D.grayTexture;
+            cesiumButtonDisabledStyle.normal.textColor = disabledButtonTextColor;
+            cesiumButtonDisabledStyle.hover.background = Texture2D.grayTexture;
+            cesiumButtonDisabledStyle.hover.textColor = disabledButtonTextColor;
+            cesiumButtonDisabledStyle.active.background = Texture2D.grayTexture;
+            cesiumButtonDisabledStyle.active.textColor = disabledButtonTextColor;
+
+            refreshButtonStyle = new GUIStyle(cesiumButtonStyle);
+            refreshButtonStyle.padding = new RectOffset(5, 5, 5, 5);
+            refreshButtonStyle.fixedHeight = 32;
+            refreshButtonStyle.fixedWidth = 40;
+
+            headerStyle = new GUIStyle(EditorStyles.label);
+            headerStyle.fontSize = 18;
+            headerStyle.wordWrap = true;
+
+            subheaderStyle = new GUIStyle(EditorStyles.label);
+            subheaderStyle.fontSize = 14;
+            subheaderStyle.margin = new RectOffset(5, 5, 5, 5);
+
+            checkIcon = LoadImage("FontAwesome/check-solid");
+            xIcon = LoadImage("FontAwesome/times-solid");
+            folderIcon = LoadImage("FontAwesome/folder");
+        }
+    }
+}

package/Editor/CesiumEditorStyle.cs.meta

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