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

package/Editor/CesiumGeoreferenceEditor.cs

@@ -0,0 +1,277 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace CesiumForUnity
+{
+    [CustomEditor(typeof(CesiumGeoreference))]
+    public class CesiumGeoreferenceEditor : Editor
+    {
+        private CesiumGeoreference _georeference;
+
+        private SerializedProperty _originPlacement;
+
+        // Converts the SerializedProperty's value to the CesiumGeoreferenceOriginPlacement
+        // enum it corresponds to, for convenience.
+        internal CesiumGeoreferenceOriginPlacement originPlacement
+        {
+            get
+            {
+                return (CesiumGeoreferenceOriginPlacement)
+                    this._originPlacement.enumValueIndex;
+            }
+        }
+
+        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 _ellipsoidOverride;
+        private SerializedProperty _latitude;
+        private SerializedProperty _longitude;
+        private SerializedProperty _height;
+
+        private SerializedProperty _ecefX;
+        private SerializedProperty _ecefY;
+        private SerializedProperty _ecefZ;
+
+        private SerializedProperty _scale;
+
+        private void OnEnable()
+        {
+            this._georeference = (CesiumGeoreference)this.target;
+
+            this._ellipsoidOverride = this.serializedObject.FindProperty("_ellipsoidOverride");
+            this._originPlacement =
+                this.serializedObject.FindProperty("_originPlacement");
+            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");
+
+            this._scale = this.serializedObject.FindProperty("_scale");
+        }
+
+        public override void OnInspectorGUI()
+        {
+            this.serializedObject.Update();
+
+            DrawInspectorButtons();
+            EditorGUILayout.Space(5);
+            
+            this.DrawOriginModeProperties();
+            EditorGUILayout.Space(5);
+            this.DrawLongitudeLatitudeHeightProperties();
+            EditorGUILayout.Space(5);
+            this.DrawEarthCenteredEarthFixedProperties();
+            EditorGUILayout.Space(5);
+            
+            this.DrawScaleProperty();
+            this.DrawEllipsoidOverrideProperty();
+
+            this.serializedObject.ApplyModifiedProperties();
+        }
+
+        private void DrawInspectorButtons()
+        {
+            // Don't modify the georeference if the editor is in play mode.
+            EditorGUI.BeginDisabledGroup(
+                EditorApplication.isPlaying
+                || this.originPlacement != CesiumGeoreferenceOriginPlacement.CartographicOrigin);
+
+            GUILayout.BeginHorizontal();
+            GUIContent placeOriginHereContent = new GUIContent(
+                "Place Origin Here",
+                "Places the georeference 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 level are georeferenced with the \"CesiumGeoreference\" component " +
+                "or are children of a GameObject with that component. Ensure that static " +
+                "GameObjects only exist in georeferenced sub-scenes.");
+            if (GUILayout.Button(placeOriginHereContent))
+            {
+                CesiumEditorUtility.PlaceGeoreferenceAtCameraPosition(this._georeference);
+            }
+
+            GUIContent createSubSceneContent = new GUIContent(
+                "Create Sub-Scene Here",
+                "Creates a child GameObject with a \"CesiumSubScene\" component whose origin " +
+                "is set to the camera's current location. A \"CesiumSubScene\" describes a " +
+                "corresponding world location that can be jumped to, and only one sub-scene " +
+                "can be worked on in the editor at a time." +
+                "\n\n" +
+                "This is disabled when \"Origin Placement\" is set to \"True Origin\".");
+            if (GUILayout.Button("Create Sub-Scene Here"))
+            {
+                CesiumEditorUtility.CreateSubScene(this._georeference);
+            }
+
+            GUILayout.EndHorizontal();
+
+            EditorGUI.EndDisabledGroup();
+        }
+
+        private void DrawOriginModeProperties()
+        {
+            GUILayout.Label("Origin Mode", EditorStyles.boldLabel);
+
+            GUIContent originPlacementContent = new GUIContent(
+                "Placement",
+                "The placement of this GameObject's origin (0,0,0) within the tileset." +
+                "\n\n" +
+                "3D Tiles tilesets often use Earth-centered, Earth-fixed coordinates, such that " +
+                "the tileset content is in a small bounding volume 6-7 million meters " +
+                "(the radius of the Earth) away from the coordinate system origin. This property " +
+                "allows an alternative position, other than the tileset's true origin, to be " +
+                "treated as the origin for the purpose of this GameObject. Using this property will " +
+                "preserve vertex precision (and thus avoid jittering) much better than setting the " +
+                "GameObject's Transform property.");
+            EditorGUILayout.PropertyField(this._originPlacement, originPlacementContent);
+            
+            EditorGUI.BeginDisabledGroup(
+                this.originPlacement != CesiumGeoreferenceOriginPlacement.CartographicOrigin);
+
+            GUIContent originAuthorityContent = new GUIContent(
+                "Authority",
+                "The set of coordinates that authoritatively define the origin of " +
+                "this georeference.");
+            EditorGUILayout.PropertyField(this._originAuthority, originAuthorityContent);
+
+            EditorGUI.EndDisabledGroup();
+        }
+
+        private void DrawEllipsoidOverrideProperty()
+        {
+            EditorGUI.BeginDisabledGroup(
+                this.originPlacement != CesiumGeoreferenceOriginPlacement.CartographicOrigin);
+
+            GUIContent ellipsoidOverrideContent = new GUIContent(
+                "Ellipsoid Override",
+                "The ellipsoid definition to use for this tileset. If this is left blank, " +
+                "the ellipsoid specified by the tileset is used, or WGS84 if the tileset " +
+                "doesn't list an ellipsoid to use.");
+            EditorGUI.BeginChangeCheck();
+            EditorGUILayout.PropertyField(this._ellipsoidOverride, ellipsoidOverrideContent);
+            if (EditorGUI.EndChangeCheck())
+            {
+                this.serializedObject.ApplyModifiedProperties();
+                this._georeference.ReloadEllipsoid();
+            }
+
+            EditorGUI.EndDisabledGroup();
+        }
+
+        private void DrawScaleProperty()
+        {
+            GUIContent scaleContent = new GUIContent(
+                "Scale",
+                "The scale of the globe in the Unity world. If this value is 0.5, for " +
+                "example, one meter on the globe occupies half a meter in the Unity world. " +
+                "The globe can also be scaled by modifying the georeference's Transform, " +
+                "but setting this property instead will do a better job of preserving precision.");
+            EditorGUILayout.PropertyField(this._scale, scaleContent);
+        }
+
+        private void DrawLongitudeLatitudeHeightProperties()
+        {
+            CesiumGeoreferenceOriginPlacement placement = this.originPlacement;
+            CesiumGeoreferenceOriginAuthority authority = this.originAuthority;
+            EditorGUI.BeginDisabledGroup(
+                placement != CesiumGeoreferenceOriginPlacement.CartographicOrigin ||
+                authority != CesiumGeoreferenceOriginAuthority.LongitudeLatitudeHeight);
+
+            GUILayout.Label(
+                "Origin (Longitude Latitude Height)", EditorStyles.boldLabel);
+
+            GUIContent latitudeContent = new GUIContent(
+                "Latitude",
+                "The latitude of the origin in degrees, in the range [-90, 90].");
+            CesiumInspectorGUI.ClampedDoubleField(
+                this._latitude,
+                -90.0,
+                90.0,
+                latitudeContent,
+                delayed: true);
+
+            GUIContent longitudeContent = new GUIContent(
+                "Longitude",
+                "The longitude of the origin in degrees, in the range [-180, 180].");
+            CesiumInspectorGUI.ClampedDoubleField(
+                 this._longitude,
+                 -180.0,
+                 180.0,
+                 longitudeContent,
+                 delayed: true);
+
+            GUIContent heightContent = new GUIContent(
+                "Height",
+                "The height of the origin 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()
+        {
+            CesiumGeoreferenceOriginPlacement placement = this.originPlacement;
+            CesiumGeoreferenceOriginAuthority authority = this.originAuthority;
+            EditorGUI.BeginDisabledGroup(
+                placement != CesiumGeoreferenceOriginPlacement.CartographicOrigin ||
+                 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 " +
+                "georeference 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 " +
+                "georeference 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 " +
+                "georeference 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/CesiumGeoreferenceEditor.cs.meta

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

package/Editor/CesiumGlobeAnchorEditor.cs

@@ -0,0 +1,202 @@
+using System;
+using Unity.Mathematics;
+using UnityEditor;
+using UnityEngine;
+
+namespace CesiumForUnity
+{
+    [CustomEditor(typeof(CesiumGlobeAnchor))]
+    public class CesiumGlobeAnchorEditor : Editor
+    {
+        private CesiumGlobeAnchor _globeAnchor;
+        private CesiumInspectorGUI _gui;
+
+        private void OnEnable()
+        {
+            this._globeAnchor = (CesiumGlobeAnchor)this.target;
+            this._gui = new CesiumInspectorGUI(this._globeAnchor);
+        }
+
+        private void OnDisable()
+        {
+            if (this._gui != null)
+            {
+                this._gui.Dispose();
+                this._gui = null;
+            }
+        }
+
+        public override void OnInspectorGUI()
+        {
+            this.serializedObject.Update();
+
+            DrawGlobeAnchorProperties();
+            EditorGUILayout.Space(5);
+            DrawLongitudeLatitudeHeightProperties();
+            EditorGUILayout.Space(5);
+            DrawEarthCenteredEarthFixedProperties();
+            EditorGUILayout.Space(5);
+            DrawEastUpNorthRotationProperties();
+            EditorGUILayout.Space(5);
+            DrawScaleProperties();
+
+            this.serializedObject.ApplyModifiedProperties();
+        }
+
+        private static readonly string adjustOrientationForGlobeWhenMovingTooltip = CesiumEditorUtility.FormatTooltip(@"
+            Whether to adjust the game object's orientation based on globe curvature
+            as the game object moves.
+
+            The Earth is not flat, so as we move across its surface, the direction of
+            ""up"" changes. If we ignore this fact and leave an object's orientation
+            unchanged as it moves over the globe surface, the object will become
+            increasingly tilted and eventually be completely upside-down when we arrive
+            at the opposite side of the globe.
+
+            When this setting is enabled, this component will automatically apply a
+            rotation to the Transform to account for globe curvature any time the game
+            object's position on the globe changes.
+
+            This property should usually be enabled, but it may be useful to disable it
+            when your application already accounts for globe curvature itself when it
+            updates a game object's transform, because in that case game object would
+            be over-rotated.");
+
+        private static readonly string detectTransformChangesTooltip = CesiumEditorUtility.FormatTooltip(@"
+            Whether this component should detect changes to the Transform component,
+            such as from physics, and update the precise coordinates accordingly.
+            Disabling this option improves performance for game objects that will not
+            move. Transform changes are always detected in Edit mode, no matter the
+            state of this flag.");
+
+        private void DrawGlobeAnchorProperties()
+        {
+            this._gui.Toggle(
+                "Adjust Orientation For Globe When Moving",
+                this._globeAnchor.adjustOrientationForGlobeWhenMoving,
+                (value) => this._globeAnchor.adjustOrientationForGlobeWhenMoving = value,
+                adjustOrientationForGlobeWhenMovingTooltip);
+
+            this._gui.Toggle(
+                "Detect Transform Changes",
+                this._globeAnchor.detectTransformChanges,
+                (value) => this._globeAnchor.detectTransformChanges = value,
+                detectTransformChangesTooltip);
+        }
+
+        private static readonly string longitudeLatitudeHeightTooltip = CesiumEditorUtility.FormatTooltip(@"
+            The Latitude, Longitude, and Height of this game object.
+
+            The Latitude (Lat) is expressed in degrees, in the range [-90, 90].
+
+            The Longitude (Lon) is expressed in degrees, in the range [-180, 180].
+
+            The Height (H) is expressed in meters above the ellipsoid (usually WGS84). 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
+            object is located.");
+
+        private static readonly GUIContent latitudeContent = new GUIContent("Lat");
+        private static readonly GUIContent longitudeContent = new GUIContent("Lon");
+        private static readonly GUIContent heightContent = new GUIContent("H");
+
+        private void DrawLongitudeLatitudeHeightProperties()
+        {
+            double3 longitudeLatitudeHeight = this._globeAnchor.longitudeLatitudeHeight;
+            longitudeLatitudeHeight.x = Math.Round(longitudeLatitudeHeight.x, 8);
+            longitudeLatitudeHeight.y = Math.Round(longitudeLatitudeHeight.y, 8);
+            longitudeLatitudeHeight.z = Math.Round(longitudeLatitudeHeight.z, 4);
+
+            // Swap X and Y so that latitude is first, to match most users' intuitions.
+            longitudeLatitudeHeight = longitudeLatitudeHeight.yxz;
+
+            this._gui.Double3(
+                "Position (Latitude, Longitude, Height)",
+                longitudeLatitudeHeight,
+                (value) =>
+                {
+                    this._globeAnchor.longitudeLatitudeHeight = value.yxz;
+                },
+                longitudeLatitudeHeightTooltip,
+                latitudeContent,
+                longitudeContent,
+                heightContent);
+        }
+
+        private static readonly string ecefTooltip = CesiumEditorUtility.FormatTooltip(@"
+            The Earth-Centered, Earth-Fixed (ECEF) coordinates of the origin of this
+            game object, in meters.
+
+            ECEF is a right-handed coordinate system with its origin at the
+            center of the Earth, the positive X axis pointing toward where the Prime
+            Meridian crosses the Equator, the positive Y axis pointing toward the
+            Equator at 90 degrees longitude, and the positive Z axis pointing toward
+            the North pole.");
+
+        private void DrawEarthCenteredEarthFixedProperties()
+        {
+            double3 ecefPosition = this._globeAnchor.positionGlobeFixed;
+            ecefPosition.x = Math.Round(ecefPosition.x, 4);
+            ecefPosition.y = Math.Round(ecefPosition.y, 4);
+            ecefPosition.z = Math.Round(ecefPosition.z, 4);
+
+            this._gui.Double3(
+                "Position (Earth-Centered, Earth-Fixed)",
+                ecefPosition,
+                (value) =>
+                {
+                    this._globeAnchor.positionGlobeFixed = value;
+                },
+                ecefTooltip);
+        }
+
+        private static readonly string rotationTooltip = CesiumEditorUtility.FormatTooltip(@"
+            The rotation of the object relative to the local East-Up-North
+            (EUN) frame centered at the object's position. In the EUN frame +X points East, +Y
+            points Up, and +Z points North.
+
+            These Euler angles are expressed in degrees and use Unity's normal ZXY convention.");
+
+        private void DrawEastUpNorthRotationProperties()
+        {
+            Quaternion rotation = this._globeAnchor.rotationEastUpNorth;
+            double3 eulerAngles = (float3)rotation.eulerAngles;
+
+            eulerAngles.x = Math.Round(Math.Clamp(Helpers.Negative180To180(eulerAngles.x), -180.0f, 180.0f), 4);
+            eulerAngles.y = Math.Round(Math.Clamp(Helpers.Negative180To180(eulerAngles.y), -180.0f, 180.0f), 4);
+            eulerAngles.z = Math.Round(Math.Clamp(Helpers.Negative180To180(eulerAngles.z), -180.0f, 180.0f), 4);
+
+            this._gui.Double3(
+                "Rotation (East-Up-North)",
+                eulerAngles,
+                (value) =>
+                {
+                    rotation.eulerAngles = (float3)value;
+                    this._globeAnchor.rotationEastUpNorth = rotation;
+                },
+                rotationTooltip);
+        }
+
+        private static readonly string scaleTooltip = CesiumEditorUtility.FormatTooltip(@"The local scaling of the object.");
+
+        private void DrawScaleProperties()
+        {
+            double3 scale = this._globeAnchor.scaleEastUpNorth;
+            scale.x = Math.Round(scale.x, 4);
+            scale.y = Math.Round(scale.y, 4);
+            scale.z = Math.Round(scale.z, 4);
+
+            this._gui.Double3(
+                "Scale",
+                scale,
+                (value) =>
+                {
+                    // Don't try to set a scale that is too close to zero.
+                    if (math.cmin(math.abs(value)) < 1.0e-15)
+                        return;
+                    this._globeAnchor.scaleEastUpNorth = value;
+                },
+                scaleTooltip);
+        }
+    }
+}

package/Editor/CesiumGlobeAnchorEditor.cs.meta

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

package/Editor/CesiumInspectorGUI.cs

@@ -0,0 +1,187 @@
+
+using System;
+using Unity.Mathematics;
+using UnityEditor;
+using UnityEngine;
+
+namespace CesiumForUnity
+{
+    public class CesiumInspectorGUI : IDisposable
+    {
+        public UnityEngine.Object[] targets { get; private set; }
+        public int tooltipLabelWidth { get; set; } = 265;
+
+        private bool _ignoreModifications = false;
+
+        public CesiumInspectorGUI(params UnityEngine.Object[] targets)
+        {
+            this.targets = targets;
+
+            Undo.undoRedoPerformed += OnUndoRedoPerformed;
+            Undo.postprocessModifications += OnPostProcessModifications;
+        }
+
+        ~CesiumInspectorGUI()
+        {
+            Debug.Log("CesiumGUI was not disposed. Be sure to call Dispose in OnDisable.");
+        }
+
+        public void Dispose()
+        {
+            GC.SuppressFinalize(this);
+            Undo.undoRedoPerformed -= OnUndoRedoPerformed;
+            Undo.postprocessModifications -= OnPostProcessModifications;
+        }
+
+        public void Toggle(string label, bool value, Action<bool> set, string tooltip)
+        {
+            bool newValue = EditorGUILayout.Toggle(new GUIContent(label, tooltip), value);
+            if (newValue != value)
+                ApplyChange(label, newValue, set);
+        }
+
+        public void Double(string label, double value, Action<double> set, string tooltip)
+        {
+            double newValue = EditorGUILayout.DoubleField(new GUIContent(label, tooltip), value);
+            if (newValue != value)
+                ApplyChange(label, newValue, set);
+        }
+
+        private static GUIContent defaultXContent = new GUIContent("X");
+        private static GUIContent defaultYContent = new GUIContent("Y");
+        private static GUIContent defaultZContent = new GUIContent("Z");
+
+        public void Double3(string label, double3 value, Action<double3> set, string tooltip, GUIContent xContent = null, GUIContent yContent = null, GUIContent zContent = null)
+        {
+            xContent = xContent ?? defaultXContent;
+            yContent = yContent ?? defaultYContent;
+            zContent = zContent ?? defaultZContent;
+
+            float originalLabelWidth = EditorGUIUtility.labelWidth;
+
+            GUIContent mainLabel = new GUIContent(label, tooltip);
+            bool mainLabelTooLong = EditorStyles.label.CalcSize(mainLabel).x + 4.0f > originalLabelWidth;
+            if (mainLabelTooLong)
+                GUILayout.Label(mainLabel);
+
+            using (new EditorGUILayout.HorizontalScope())
+            using (var changeScope = new EditorGUI.ChangeCheckScope())
+            {
+                if (!mainLabelTooLong)
+                    EditorGUILayout.PrefixLabel(mainLabel);
+
+                EditorGUIUtility.labelWidth = EditorStyles.label.CalcSize(xContent).x + 4.0f;
+                value.x = EditorGUILayout.DoubleField(xContent, value.x);
+                EditorGUIUtility.labelWidth = EditorStyles.label.CalcSize(yContent).x + 4.0f;
+                value.y = EditorGUILayout.DoubleField(yContent, value.y);
+                EditorGUIUtility.labelWidth = EditorStyles.label.CalcSize(zContent).x + 4.0f;
+                value.z = EditorGUILayout.DoubleField(zContent, value.z);
+
+                if (changeScope.changed)
+                    ApplyChange(label, value, set);
+            }
+
+            EditorGUIUtility.labelWidth = originalLabelWidth;
+        }
+
+        public void Enum<T>(string label, T value, Action<T> set, string tooltip) where T : Enum
+        {
+            T newValue = (T)EditorGUILayout.EnumPopup(new GUIContent(label, tooltip), (Enum)value);
+            if (!value.Equals(newValue))
+                ApplyChange(label, newValue, set);
+        }
+
+        private void ApplyChange<T>(string label, T newValue, Action<T> set)
+        {
+            Undo.FlushUndoRecordObjects();
+            this._ignoreModifications = true;
+            try
+            {
+                Undo.RecordObjects(this.targets, "Changed " + label);
+                set(newValue);
+                Undo.FlushUndoRecordObjects();
+            }
+            finally
+            {
+                this._ignoreModifications = false;
+            }
+        }
+
+        public static void ClampedIntField(
+            SerializedProperty property, int min, int max, GUIContent label)
+        {
+            if (property.propertyType == SerializedPropertyType.Integer)
+            {
+                int value = EditorGUILayout.IntField(label, property.intValue);
+                property.intValue = Math.Clamp(value, min, max);
+            }
+            else
+            {
+                EditorGUILayout.LabelField(
+                    label.text, "Use ClampedIntField for int only.");
+            }
+        }
+
+        public static void ClampedFloatField(
+            SerializedProperty property, float min, float max, GUIContent label)
+        {
+            if (property.propertyType == SerializedPropertyType.Float)
+            {
+                float value = EditorGUILayout.FloatField(label, property.floatValue);
+                property.floatValue = Math.Clamp(value, min, max);
+            }
+            else
+            {
+                EditorGUILayout.LabelField(
+                    label.text, "Use ClampedFloatField for float only.");
+            }
+        }
+
+        public static void ClampedDoubleField(
+            SerializedProperty property, double min, double max, GUIContent label, bool delayed = false)
+        {
+            // SerializedPropertyType.Float is used for both float and double;
+            // SerializedPropertyType.Double does not exist.
+            if (property.propertyType == SerializedPropertyType.Float)
+            {
+                double value;
+                if (delayed)
+                {
+                    value = EditorGUILayout.DelayedDoubleField(label, property.doubleValue);
+                }
+                else
+                {
+                    value = EditorGUILayout.DoubleField(label, property.doubleValue);
+                }
+                property.doubleValue = Math.Clamp(value, min, max);
+            }
+            else
+            {
+                EditorGUILayout.LabelField(
+                    label.text, "Use ClampedDoubleField for double only.");
+            }
+        }
+
+        private UndoPropertyModification[] OnPostProcessModifications(UndoPropertyModification[] modifications)
+        {
+            if (!this._ignoreModifications)
+                this.RestartTargets();
+
+            return modifications;
+        }
+
+        private void OnUndoRedoPerformed()
+        {
+            this.RestartTargets();
+        }
+
+        private void RestartTargets()
+        {
+            foreach (UnityEngine.Object target in this.targets)
+            {
+                if (target is ICesiumRestartable restartable)
+                    restartable.Restart();
+            }
+        }
+    }
+}