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

package/Editor/CesiumRasterOverlayEditor.cs

@@ -0,0 +1,230 @@
+using UnityEditor;
+using UnityEngine;
+using System.Collections.Generic;
+
+namespace CesiumForUnity
+{
+    [CustomEditor(typeof(CesiumRasterOverlay))]
+    public class CesiumRasterOverlayEditor : Editor
+    {
+        private const string _overlayPrefix = "_overlayTexture_";
+
+        private Cesium3DTileset _tileset;
+        private CesiumRasterOverlay _overlay;
+
+        private SerializedProperty _showCreditsOnScreen;
+        private SerializedProperty _materialKey;
+        private SerializedProperty _maximumScreenSpaceError;
+        private SerializedProperty _maximumTextureSize;
+        private SerializedProperty _maximumSimultaneousTileLoads;
+        private SerializedProperty _subTileCacheBytes;
+
+        private int _materialCRC = 0;
+        private string[] _materialKeys;
+        private int _selectedMaterialKeyIndex;
+        private bool _showMaterialKeyWarning;
+
+        public bool drawShowCreditsOnScreen = true;
+        public bool drawOverlayProperties = true;
+
+        private void OnEnable()
+        {
+            this._overlay = (CesiumRasterOverlay)target;
+            this._tileset = _overlay.gameObject.GetComponent<Cesium3DTileset>();
+
+            this._materialKey = this.serializedObject.FindProperty("_materialKey");
+            this._showCreditsOnScreen = this.serializedObject.FindProperty("_showCreditsOnScreen");
+            this._maximumScreenSpaceError =
+                this.serializedObject.FindProperty("_maximumScreenSpaceError");
+            this._maximumTextureSize = this.serializedObject.FindProperty("_maximumTextureSize");
+            this._maximumSimultaneousTileLoads =
+                this.serializedObject.FindProperty("_maximumSimultaneousTileLoads");
+            this._subTileCacheBytes = this.serializedObject.FindProperty("_subTileCacheBytes");
+
+            this._materialKeys = new string[] { };
+        }
+
+        public override void OnInspectorGUI()
+        {
+            this.serializedObject.Update();
+
+            this.DrawTilesetWarning();
+
+            EditorGUIUtility.labelWidth = CesiumEditorStyle.inspectorLabelWidth;
+
+            this.UpdateMaterialKeys();
+
+            this.DrawMaterialKeyProperty();
+
+            if (this.drawShowCreditsOnScreen)
+            {
+                this.DrawShowCreditsOnScreenProperty();
+            }
+
+            if (this.drawOverlayProperties)
+            {
+                this.DrawRasterOverlayProperties();
+            }
+
+            this.serializedObject.ApplyModifiedProperties();
+        }
+
+        private void DrawTilesetWarning()
+        {
+            if (this._tileset == null)
+            {
+                EditorGUILayout.HelpBox("CesiumRasterOverlay should be used in combination with a " +
+                    "Cesium3DTileset component on this GameObject.", MessageType.Warning);
+            }
+        }
+
+        private void UpdateMaterialKeys()
+        {
+            if (this._tileset != null)
+            {
+                Material material = this._tileset.opaqueMaterial;
+
+                if (material == null)
+                {
+                    material = Resources.Load<Material>("CesiumDefaultTilesetMaterial");
+                }
+
+                if (material == null)
+                {
+                    Debug.LogError("Couldn't find default tileset material in Resources.");
+                    return;
+                }
+
+                int materialCRC = material.ComputeCRC();
+                if (this._materialCRC == materialCRC)
+                {
+                    return;
+                }
+
+                string[] propertyNames = material.GetTexturePropertyNames();
+                List<string> materialKeys = new List<string>();
+
+                bool foundMaterialKey = false;
+                foreach (string name in propertyNames)
+                {
+                    if (name.StartsWith(_overlayPrefix))
+                    {
+                        string key = name.Substring(_overlayPrefix.Length);
+
+                        if (this._materialKey.stringValue == key)
+                        {
+                            this._selectedMaterialKeyIndex = materialKeys.Count;
+                            foundMaterialKey = true;
+                            this._showMaterialKeyWarning = false;
+                        }
+
+                        materialKeys.Add(key);
+                    }
+                }
+
+                if (!foundMaterialKey)
+                {
+                    this._showMaterialKeyWarning = true;
+                    this._selectedMaterialKeyIndex = materialKeys.Count;
+                    materialKeys.Add(this._materialKey.stringValue);
+                }
+
+                this._materialKeys = materialKeys.ToArray();
+            }
+        }
+
+
+        private void DrawMaterialKeyProperty()
+        {
+            GUIContent materialKeyContent = new GUIContent(
+                "Material Key",
+                "The key to use to match this overlay to the corresponding parameters " +
+                "in the tileset's material." +
+                "\n\n" +
+                "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." +
+                "\n\n" +
+                "- Overlay Texture: _overlayTexture_KEY\n" +
+                "- Overlay Texture Coordinate Index: _overlayTextureCoordinateIndex_KEY\n" +
+                "- Overlay Translation and Scale: _overlayTranslationScale_KEY\n" +
+                "\n\n" +
+                "Material keys are useful for specifying the order of the raster overlays, or distinguishing " +
+                "them for overlay-specific effects."
+                );
+            int selectedIndex =
+                EditorGUILayout.Popup(materialKeyContent, this._selectedMaterialKeyIndex, this._materialKeys);
+
+            if (this._showMaterialKeyWarning)
+            {
+                EditorGUILayout.HelpBox("The specified Material Key does not exist in the " +
+                    "Cesium3DTileset's material.", MessageType.Warning);
+            }
+
+            if (selectedIndex == this._selectedMaterialKeyIndex ||
+                selectedIndex < 0 || selectedIndex >= this._materialKeys.Length)
+            {
+                return;
+            }
+
+            this._materialKey.stringValue = this._materialKeys[selectedIndex];
+            this._selectedMaterialKeyIndex = selectedIndex;
+
+        }
+
+        private void DrawShowCreditsOnScreenProperty()
+        {
+            GUIContent showCreditsOnScreenContent = new GUIContent(
+                "Show Credits On Screen",
+                "Whether or not to show credits of this raster overlay on screen.");
+            EditorGUILayout.PropertyField(
+                this._showCreditsOnScreen, showCreditsOnScreenContent);
+        }
+
+        private void DrawRasterOverlayProperties()
+        {
+            GUIContent maximumScreenSpaceErrorContent = new GUIContent(
+                "Maximum Screen Space Error",
+                "The maximum number of pixels of error when rendering this overlay. " +
+                "This is used to select an appropriate level-of-detail. " +
+                "\n\n" +
+                "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.");
+            EditorGUILayout.PropertyField(
+                this._maximumScreenSpaceError, maximumScreenSpaceErrorContent);
+
+            GUIContent maximumTextureSizeContent = new GUIContent(
+                "Maximum Texture Size",
+                "The maximum texel size of raster overlay textures, in either direction." +
+                "\n\n" +
+                "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.");
+            EditorGUILayout.PropertyField(
+                this._maximumTextureSize, maximumTextureSizeContent);
+
+            GUIContent maximumSimultaneousTileLoadsContent = new GUIContent(
+                "Maximum Simultaneous Tile Loads",
+                "The maximum number of overlay tiles that may simultaneously be in " +
+                "the process of loading.");
+            EditorGUILayout.PropertyField(
+                this._maximumSimultaneousTileLoads, maximumSimultaneousTileLoadsContent);
+
+            GUIContent subTileCacheBytesContent = new GUIContent(
+                "Sub Tile Cache Bytes",
+                "The maximum number of bytes to use to cache sub-tiles in memory." +
+                "\n\n" +
+                "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.");
+            EditorGUILayout.PropertyField(
+                this._subTileCacheBytes, subTileCacheBytesContent);
+        }
+    }
+}

package/Editor/CesiumRasterOverlayEditor.cs.meta

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

package/Editor/CesiumSubSceneEditor.cs

@@ -0,0 +1,201 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace CesiumForUnity
+{
+    [CustomEditor(typeof(CesiumSubScene))]
+    public class CesiumSubSceneEditor : Editor
+    {
+        private CesiumSubScene _subScene;
+
+        private SerializedProperty _activationRadius;
+        private SerializedProperty _showActivationRadius;
+
+        private SerializedProperty _originAuthority;
+
+        // Converts the SerializedProperty's value to the CesiumGeoreferenceOriginAuthority
+        // enum it corresponds to, for convenience.
+        internal CesiumGeoreferenceOriginAuthority originAuthority
+        {
+            get
+            {
+                return (CesiumGeoreferenceOriginAuthority)
+                    this._originAuthority.enumValueIndex;
+            }
+        }
+
+        private SerializedProperty _latitude;
+        private SerializedProperty _longitude;
+        private SerializedProperty _height;
+
+        private SerializedProperty _ecefX;
+        private SerializedProperty _ecefY;
+        private SerializedProperty _ecefZ;
+
+        private void OnEnable()
+        {
+            this._subScene = (CesiumSubScene)this.target;
+
+            this._activationRadius = this.serializedObject.FindProperty("_activationRadius");
+            this._showActivationRadius =
+                this.serializedObject.FindProperty("_showActivationRadius");
+            this._originAuthority =
+                this.serializedObject.FindProperty("_originAuthority");
+
+            this._latitude = this.serializedObject.FindProperty("_latitude");
+            this._longitude = this.serializedObject.FindProperty("_longitude");
+            this._height = this.serializedObject.FindProperty("_height");
+
+            this._ecefX = this.serializedObject.FindProperty("_ecefX");
+            this._ecefY = this.serializedObject.FindProperty("_ecefY");
+            this._ecefZ = this.serializedObject.FindProperty("_ecefZ");
+        }
+
+        public override void OnInspectorGUI()
+        {
+            this.serializedObject.Update();
+
+            DrawToolbarButton();
+            EditorGUILayout.Space(5);
+            DrawSubSceneProperties();
+            EditorGUILayout.Space(5);
+            
+            DrawLongitudeLatitudeHeightProperties();
+            EditorGUILayout.Space(5);
+            DrawEarthCenteredEarthFixedProperties();
+
+            this.serializedObject.ApplyModifiedProperties();
+        }
+
+        private void DrawToolbarButton()
+        {
+            // Don't modify the sub-scene if the editor is in play mode.
+            EditorGUI.BeginDisabledGroup(EditorApplication.isPlaying);
+
+            GUILayout.BeginHorizontal();
+            GUILayout.FlexibleSpace();
+
+            GUIContent placeOriginHereContent = new GUIContent(
+                "Place Origin Here",
+                "Places the sub-scene origin at the camera's current location. " +
+                "Rotates the globe so the current longitude/latitude/height of the " +
+                "camera is at the Unity origin. The camera is also teleported to the " +
+                "Unity origin." +
+                "\n\n" +
+                "Warning: Before clicking, ensure that all non-Cesium objects in the " +
+                "persistent scene are georeferenced with the \"CesiumGlobeAnchor\" " +
+                "component or are children of a GameObject with that component. " +
+                "Ensure that static GameObjects only exist under georeferenced sub-scenes.");
+            if (GUILayout.Button(placeOriginHereContent, GUILayout.Width(200)))
+            {
+                CesiumEditorUtility.PlaceSubSceneAtCameraPosition(this._subScene);
+            }
+
+            GUILayout.FlexibleSpace();
+            GUILayout.EndHorizontal();
+
+            EditorGUI.EndDisabledGroup();
+        }
+
+        private void DrawSubSceneProperties()
+        {
+            GUIContent activationRadiusContent = new GUIContent(
+                "Activation Radius",
+                "The radius from the origin at which this sub-scene becomes active. " +
+                "The sub-scene may not become active if another sub-scene is closer, " +
+                "even when the camera is inside this radius.");
+            EditorGUILayout.PropertyField(this._activationRadius, activationRadiusContent);
+
+            GUIContent showActivationRadiusContent = new GUIContent(
+                "Show Activation Radius",
+                "Whether to visualize the sub-scene loading radius in the editor. " +
+                "Helpful for initially positioning the sub-scene and choosing a load radius.");
+            EditorGUILayout.PropertyField(this._showActivationRadius, showActivationRadiusContent);
+
+            GUIContent originAuthorityContent = new GUIContent(
+                "Origin Authority",
+                "The set of coordinates that authoritatively define the origin of " +
+                "this sub-scene.");
+            EditorGUILayout.PropertyField(this._originAuthority, originAuthorityContent);
+        }
+
+        private void DrawLongitudeLatitudeHeightProperties()
+        {
+            CesiumGeoreferenceOriginAuthority authority = this.originAuthority;
+            EditorGUI.BeginDisabledGroup(
+                authority != CesiumGeoreferenceOriginAuthority.LongitudeLatitudeHeight);
+
+            GUILayout.Label(
+                "Origin (Longitude Latitude Height)", EditorStyles.boldLabel);
+
+            GUIContent latitudeContent = new GUIContent(
+                "Latitude",
+                "The latitude of the origin of this sub-scene in degrees, in the range [-90, 90].");
+            CesiumInspectorGUI.ClampedDoubleField(
+                this._latitude,
+                -90.0,
+                90.0,
+                latitudeContent);
+
+            GUIContent longitudeContent = new GUIContent(
+                "Longitude",
+                "The longitude of the origin of this sub-scene in degrees, in the range [-180, 180].");
+            CesiumInspectorGUI.ClampedDoubleField(
+                 this._longitude,
+                 -180.0,
+                 180.0,
+                 longitudeContent);
+
+            GUIContent heightContent = new GUIContent(
+                "Height",
+                "The height of the origin of this sub-scene in meters above the ellipsoid (usually WGS84)." +
+                "\n\n" +
+                "Do not confuse this with a geoid height or height above mean sea level, which " +
+                "can be tens of meters higher or lower depending on where in the world the " +
+                "origin is located.");
+            EditorGUILayout.PropertyField(this._height, heightContent);
+
+            EditorGUI.EndDisabledGroup();
+        }
+
+        private void DrawEarthCenteredEarthFixedProperties()
+        {
+            CesiumGeoreferenceOriginAuthority authority = this.originAuthority;
+            EditorGUI.BeginDisabledGroup(
+                 authority != CesiumGeoreferenceOriginAuthority.EarthCenteredEarthFixed);
+
+            GUILayout.Label(
+                "Origin (Earth Centered, Earth Fixed)", EditorStyles.boldLabel);
+
+            GUIContent ecefXContent = new GUIContent(
+                "ECEF X",
+                "The Earth-Centered, Earth-Fixed X-coordinate of the origin of this " +
+                "sub-scene in meters." +
+                "\n\n" +
+                 "In the ECEF coordinate system, the origin is at the center of the Earth " +
+                 "and the positive X axis points toward where the Prime Meridian crosses " +
+                 "the Equator.");
+            EditorGUILayout.PropertyField(this._ecefX, ecefXContent);
+
+            GUIContent ecefYContent = new GUIContent(
+                "ECEF Y",
+                "The Earth-Centered, Earth-Fixed Y-coordinate of the origin of this " +
+                "sub-scene in meters." +
+                "\n\n" +
+                "In the ECEF coordinate system, the origin is at the center of the Earth " +
+                "and the positive Y axis points toward the Equator at 90 degrees longitude.");
+            EditorGUILayout.PropertyField(this._ecefY, ecefYContent);
+
+            GUIContent ecefZContent = new GUIContent(
+                "ECEF Z",
+                "The Earth-Centered, Earth-Fixed Z-coordinate of the origin of this " +
+                "sub-scene in meters." +
+                "\n\n" +
+                "In the ECEF coordinate system, the origin is at the center of the Earth " +
+                "and the positive Z axis points toward the North pole.");
+            EditorGUILayout.PropertyField(this._ecefZ, ecefZContent);
+
+            EditorGUI.EndDisabledGroup();
+        }
+    }
+}

package/Editor/CesiumSubSceneEditor.cs.meta

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

package/Editor/CesiumTileMapServiceRasterOverlayEditor.cs

@@ -0,0 +1,88 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace CesiumForUnity
+{
+    [CustomEditor(typeof(CesiumTileMapServiceRasterOverlay))]
+    public class CesiumTileMapServiceRasterOverlayEditor : Editor
+    {
+        private CesiumTileMapServiceRasterOverlay _tileMapServiceOverlay;
+        private CesiumRasterOverlayEditor _rasterOverlayEditor;
+
+        private SerializedProperty _url;
+        private SerializedProperty _specifyZoomLevels;
+        private SerializedProperty _minimumLevel;
+        private SerializedProperty _maximumLevel;
+
+        private void OnEnable()
+        {
+            this._tileMapServiceOverlay =
+                (CesiumTileMapServiceRasterOverlay)this.target;
+            this._rasterOverlayEditor =
+                (CesiumRasterOverlayEditor)Editor.CreateEditor(
+                                                    this.target,
+                                                    typeof(CesiumRasterOverlayEditor));
+
+            this._url = this.serializedObject.FindProperty("_url");
+            this._specifyZoomLevels = this.serializedObject.FindProperty("_specifyZoomLevels");
+            this._minimumLevel = this.serializedObject.FindProperty("_minimumLevel");
+            this._maximumLevel = this.serializedObject.FindProperty("_maximumLevel");
+        }
+
+        private void OnDisable()
+        {
+            if (this._rasterOverlayEditor != null)
+            {
+                DestroyImmediate(this._rasterOverlayEditor);
+            }
+        }
+
+        public override void OnInspectorGUI()
+        {
+            this.serializedObject.Update();
+
+            EditorGUIUtility.labelWidth = CesiumEditorStyle.inspectorLabelWidth;
+            DrawTileMapServiceProperties();
+            EditorGUILayout.Space(5);
+            DrawRasterOverlayProperties();
+
+            this.serializedObject.ApplyModifiedProperties();
+        }
+
+        private void DrawTileMapServiceProperties()
+        {
+            GUIContent urlContent = new GUIContent(
+               "URL",
+               "The base URL of the Tile Map Service (TMS).");
+            EditorGUILayout.DelayedTextField(this._url, urlContent);
+
+            GUIContent specifyZoomLevelsContent = new GUIContent(
+                "Specify Zoom Levels",
+                "Set true to directly specify minimum and maximum zoom levels " +
+                "available from the server, or false to automatically determine " +
+                "the minimum and maximum zoom levels from the server's " +
+                "tilemapresource.xml file.");
+            EditorGUILayout.PropertyField(this._specifyZoomLevels, specifyZoomLevelsContent);
+
+            EditorGUI.BeginDisabledGroup(!this._specifyZoomLevels.boolValue);
+            GUIContent minimumLevelContent = new GUIContent(
+                "Minimum Level",
+                "Minimum zoom level.");
+            EditorGUILayout.PropertyField(this._minimumLevel, minimumLevelContent);
+
+            GUIContent maximumLevelContent = new GUIContent(
+                "Maximum Level",
+                "Maximum zoom level.");
+            EditorGUILayout.PropertyField(this._maximumLevel, maximumLevelContent);
+            EditorGUI.EndDisabledGroup();
+        }
+
+        private void DrawRasterOverlayProperties()
+        {
+            if (this._rasterOverlayEditor != null)
+            {
+                this._rasterOverlayEditor.OnInspectorGUI();
+            }
+        }
+    }
+}

package/Editor/CesiumTileMapServiceRasterOverlayEditor.cs.meta

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

package/Editor/CesiumWebMapServiceRasterOverlayEditor.cs

@@ -0,0 +1,111 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace CesiumForUnity
+{
+    [CustomEditor(typeof(CesiumWebMapServiceRasterOverlay))]
+    public class CesiumWebMapServiceRasterOverlayEditor : Editor
+    {
+        private CesiumRasterOverlayEditor _rasterOverlayEditor;
+
+        private SerializedProperty _baseUrl;
+        private SerializedProperty _layers;
+        private SerializedProperty _tileWidth;
+        private SerializedProperty _tileHeight;
+        private SerializedProperty _minimumLevel;
+        private SerializedProperty _maximumLevel;
+
+        private void OnEnable()
+        {
+            this._rasterOverlayEditor =
+                (CesiumRasterOverlayEditor)Editor.CreateEditor(
+                                                     this.target,
+                                                     typeof(CesiumRasterOverlayEditor));
+
+            this._baseUrl = this.serializedObject.FindProperty("_baseUrl");
+            this._layers = this.serializedObject.FindProperty("_layers");
+            this._tileWidth = this.serializedObject.FindProperty("_tileWidth");
+            this._tileHeight = this.serializedObject.FindProperty("_tileHeight");
+            this._minimumLevel = this.serializedObject.FindProperty("_minimumLevel");
+            this._maximumLevel = this.serializedObject.FindProperty("_maximumLevel");
+        }
+
+        private void OnDisable()
+        {
+            if (this._rasterOverlayEditor != null)
+            {
+                DestroyImmediate(this._rasterOverlayEditor);
+            }
+        }
+
+        public override void OnInspectorGUI()
+        {
+            this.serializedObject.Update();
+
+            EditorGUIUtility.labelWidth = CesiumEditorStyle.inspectorLabelWidth;
+            DrawWebMapServiceProperties();
+            EditorGUILayout.Space(5);
+            DrawRasterOverlayProperties();
+
+            this.serializedObject.ApplyModifiedProperties();
+        }
+
+        private void DrawWebMapServiceProperties()
+        {
+            GUIContent baseUrlContent = new GUIContent(
+                "Base URL",
+                "The base URL of the Web Map Service (WMS)." +
+                "\n\n" +
+                "e.g." +
+                "\n\n" +
+                "https://services.ga.gov.au/gis/services/NM_Culture_and_Infrastructure/MapServer/WMSServer");
+            EditorGUILayout.DelayedTextField(this._baseUrl, baseUrlContent);
+
+            GUIContent layersContent = new GUIContent(
+                "Layers",
+                "Comma-separated layer names to request from the server.");
+            EditorGUILayout.DelayedTextField(this._layers, layersContent);
+
+            GUIContent tileWidthContent = new GUIContent(
+                "Tile Width",
+                "Image width.");
+            CesiumInspectorGUI.ClampedIntField(
+                this._tileWidth,
+                64,
+                2048,
+                tileWidthContent);
+
+            GUIContent tileHeightContent = new GUIContent(
+                "Tile Height",
+                "Image height.");
+            CesiumInspectorGUI.ClampedIntField(
+                this._tileHeight,
+                64,
+                2048,
+                tileHeightContent);
+
+            GUIContent minimumLevelContent = new GUIContent(
+                "Minimum Level",
+                "Minimum zoom level." +
+                "\n\n" +
+                "Take care when specifying this that the number of tiles at the " +
+                "minimum level is small, such as four or less. A larger number " +
+                "is likely to result in rendering problems.");
+            EditorGUILayout.PropertyField(this._minimumLevel, minimumLevelContent);
+
+            GUIContent maximumLevelContent = new GUIContent(
+                "Maximum Level",
+                "Maximum zoom level.");
+            EditorGUILayout.PropertyField(this._maximumLevel, maximumLevelContent);
+        }
+
+        private void DrawRasterOverlayProperties()
+        {
+            if (this._rasterOverlayEditor != null)
+            {
+                this._rasterOverlayEditor.OnInspectorGUI();
+            }
+        }
+    }
+}
+

package/Editor/CesiumWebMapServiceRasterOverlayEditor.cs.meta

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