Add GUI setting window and save preferences

Edit > Scene VIew FoV Settings
t-mat · Feb 5, 2017 · f2a2a09 · f2a2a09
1 parent fb71e72
commit f2a2a09
Show file tree

Hide file tree

Showing 3 changed files with 175 additions and 19 deletions.
diff --git a/Assets/SceneViewFovControl/Editor/SceneViewFovControl.cs b/Assets/SceneViewFovControl/Editor/SceneViewFovControl.cs
@@ -15,6 +15,7 @@ namespace UTJ.UnityEditor.Extension.SceneViewFovControl {
 public static class SceneViewFovControl
 {
     static Dictionary<int, Status> statuses = new Dictionary<int, Status>();
+    static public bool EnableFlag = false;
 
     static SceneViewFovControl() {
         Enable(true);
@@ -33,10 +34,13 @@ static void MenuitemDisable() {
 #endif
 
     public static void Enable(bool enable) {
-        if(enable) {
-            SceneViewHiddenApi.AddOnPreSceneGUIDelegate(OnScene);
-        } else {
-            SceneViewHiddenApi.RemoveOnPreSceneGUIDelegate(OnScene);
+        if(enable != EnableFlag) {
+            if(enable) {
+                SceneViewHiddenApi.AddOnPreSceneGUIDelegate(OnScene);
+            } else {
+                SceneViewHiddenApi.RemoveOnPreSceneGUIDelegate(OnScene);
+            }
+            EnableFlag = enable;
         }
         SceneView.RepaintAll();
     }

diff --git a/Assets/SceneViewFovControl/Editor/Settings.cs b/Assets/SceneViewFovControl/Editor/Settings.cs
@@ -1,21 +1,171 @@
 using UnityEngine;
 using UnityEditor;
+using System;
 
 #if !UNITY_EDITOR
 #error This script must be placed under "Editor/" directory.
 #endif
 
 namespace UTJ.UnityEditor.Extension.SceneViewFovControl {
     static class Settings {
-        public static EventModifiers ModifiersNormal = EventModifiers.Alt | EventModifiers.Control;
-        public static EventModifiers ModifiersQuick  = EventModifiers.Alt | EventModifiers.Control | EventModifiers.Shift;
+        static SettingsData data = new SettingsData();
 
-        public static KeyCode KeyCodeIncreaseFov = KeyCode.O;
-        public static KeyCode KeyCodeDecreaseFov = KeyCode.P;
+        public const string MenuItemName = "Edit/Scene View FoV Settings";
+        public const string EditorPrefsKey = "UTJ.UnityEditor.Extension.SceneViewFovControl";
 
-        public static float FovSpeed = 0.5f * 0.3f;
-        public static float FovQuickMultiplier = 5.0f;
-        public static float MinFov = 2.0f;
-        public static float MaxFov = 160.0f;
+        public const float FovSpeedMin = 0.01f;
+        public const float FovSpeedMax = 10.0f;
+        public const float FovQuickMultiplierMin = 0.1f;
+        public const float FovQuickMultiplierMax = 20.0f;
+        public const float MinFovMin = 1.0f;
+        public const float MinFovMax = 160.0f;
+        public const float MaxFovMin = 1.0f;
+        public const float MaxFovMax = 160.0f;
+
+        public static SettingsData Data {
+            get {
+                return data;
+            }
+
+            set {
+                data = value;
+            }
+        }
+
+        static Settings() {
+            Reset();
+
+            if(EditorPrefs.HasKey(EditorPrefsKey)) {
+                Data = Load(EditorPrefsKey);
+            }
+        }
+
+        public static void Reset() {
+            Data.Reset();
+        }
+
+        public static void Save() {
+            Store(EditorPrefsKey, Data);
+        }
+
+        public static SettingsData Load(string key) {
+            var jsonString = EditorPrefs.GetString(key);
+            return JsonUtility.FromJson<SettingsData>(jsonString);
+        }
+
+        public static void Store(string key, SettingsData settingsData) {
+            var jsonString = JsonUtility.ToJson(settingsData);
+            EditorPrefs.SetString(key, jsonString);
+        }
+    }
+
+    [Serializable]
+    public class SettingsData {
+        public EventModifiers ModifiersNormal;
+        public EventModifiers ModifiersQuick;
+
+        public KeyCode KeyCodeIncreaseFov;
+        public KeyCode KeyCodeDecreaseFov;
+
+        public float FovSpeed;
+        public float FovQuickMultiplier;
+        public float MinFov;
+        public float MaxFov;
+
+        public void Reset() {
+            ModifiersNormal = EventModifiers.Alt | EventModifiers.Control;
+            ModifiersQuick  = EventModifiers.Alt | EventModifiers.Control | EventModifiers.Shift;
+
+            KeyCodeIncreaseFov = KeyCode.O;
+            KeyCodeDecreaseFov = KeyCode.P;
+
+            FovSpeed = 0.15f;
+            FovQuickMultiplier = 5.0f;
+            MinFov = 2.0f;
+            MaxFov = 160.0f;
+        }
+    }
+
+
+    class SettingsGui : EditorWindow {
+        static SettingsGui settingGui;
+
+        [MenuItem(Settings.MenuItemName)]
+        static void Open() {
+            if(settingGui == null) {
+                settingGui = CreateInstance<SettingsGui>();
+            }
+            settingGui.ShowUtility();
+        }
+
+        void OnGUI() {
+            var d = Settings.Data;
+
+            GUILayout.Space(4);
+
+            GUILayout.Label("<<< Scene View FoV Control Settings >>>");
+
+            GUILayout.Space(8);
+
+            GUILayout.Label("FoV Speed:" + d.FovSpeed);
+            d.FovSpeed = GUILayout.HorizontalSlider(d.FovSpeed, Settings.FovSpeedMin, Settings.FovSpeedMax);
+
+            GUILayout.Space(8);
+
+            GUILayout.Label("FoV <Shift> Modifier Multiplier:" + d.FovQuickMultiplier);
+            d.FovQuickMultiplier = GUILayout.HorizontalSlider(d.FovQuickMultiplier, Settings.FovQuickMultiplierMin, Settings.FovQuickMultiplierMax);
+
+            GUILayout.Space(8);
+
+            GUILayout.Label("Min FoV:" + d.MinFov);
+            d.MinFov = GUILayout.HorizontalSlider(d.MinFov, Settings.MinFovMin, Settings.MinFovMax);
+
+            if(d.MinFov > d.MaxFov) {
+                d.MaxFov = d.MinFov;
+            }
+
+            GUILayout.Space(8);
+
+            GUILayout.Label("Max FoV:" + d.MaxFov);
+            d.MaxFov = GUILayout.HorizontalSlider(d.MaxFov, Settings.MaxFovMin, Settings.MaxFovMax);
+
+            if(d.MaxFov < d.MinFov) {
+                d.MinFov = d.MaxFov;
+            }
+
+            GUILayout.Space(20);
+
+            if(SceneViewFovControl.EnableFlag) {
+                if(GUILayout.Button("Disable")) {
+                    SceneViewFovControl.Enable(false);
+                }
+            } else {
+                if(GUILayout.Button("Enable")) {
+                    SceneViewFovControl.Enable(true);
+                }
+            }
+
+            GUILayout.Space(20);
+
+            EditorGUILayout.BeginHorizontal();
+            {
+                if(GUILayout.Button("Save")) {
+                    Settings.Save();
+                }
+
+                GUILayout.Space(20);
+
+                if(GUILayout.Button("Default")) {
+                    d.Reset();
+                }
+
+                GUILayout.Space(20);
+
+                if(GUILayout.Button("Close")) {
+                    this.Close();
+                }
+            }
+            EditorGUILayout.EndHorizontal();
+        }
     }
 }
diff --git a/Assets/SceneViewFovControl/Editor/Status.cs b/Assets/SceneViewFovControl/Editor/Status.cs
@@ -25,30 +25,32 @@ public void OnScene(SceneView sceneView) {
         }
 
         var ev = Event.current;
+        var settings = Settings.Data;
         float deltaFov = 0.0f;
 
-        if(ev.modifiers == Settings.ModifiersNormal || ev.modifiers == Settings.ModifiersQuick) {
+        if(ev.modifiers == settings.ModifiersNormal || ev.modifiers == settings.ModifiersQuick) {
             if(ev.type == EventType.ScrollWheel) {
                 // todo : Check compatibility of Event.delta.y.
                 //        e.g. Platform, mice, etc.
+                // note : In MacOS, ev.delta becomes zero when "Shift" pressed.  I don't know the reason.
                 deltaFov = ev.delta.y;
                 ev.Use();
-            } else if(ev.type == EventType.KeyDown && ev.keyCode == Settings.KeyCodeIncreaseFov) {
+            } else if(ev.type == EventType.KeyDown && ev.keyCode == settings.KeyCodeIncreaseFov) {
                 deltaFov = +1.0f;
                 ev.Use();
-            } else if(ev.type == EventType.KeyDown && ev.keyCode == Settings.KeyCodeDecreaseFov) {
+            } else if(ev.type == EventType.KeyDown && ev.keyCode == settings.KeyCodeDecreaseFov) {
                 deltaFov = -1.0f;
                 ev.Use();
             }
         }
 
         if(deltaFov != 0.0f) {
-            deltaFov *= Settings.FovSpeed;
-            if(ev.modifiers == Settings.ModifiersQuick) {
-                deltaFov *= Settings.FovQuickMultiplier;
+            deltaFov *= settings.FovSpeed;
+            if(ev.modifiers == settings.ModifiersQuick) {
+                deltaFov *= settings.FovQuickMultiplier;
             }
             fov += deltaFov;
-            fov = Mathf.Clamp(fov, Settings.MinFov, Settings.MaxFov);
+            fov = Mathf.Clamp(fov, settings.MinFov, settings.MaxFov);
         }
 
         camera.fieldOfView = fov;