1

Assets/Dreamteck/Splines/Editor/SplineComputerEditor.cs

@@ -0,0 +1,271 @@
+namespace Dreamteck.Splines.Editor
+{
+    using UnityEngine;
+    using System.Collections.Generic;
+    using UnityEditor;
+
+    [CustomEditor(typeof(SplineComputer), true)]
+    [CanEditMultipleObjects]
+    public partial class SplineComputerEditor : Editor 
+    {
+        public SplineComputer spline;
+        public SplineComputer[] splines = new SplineComputer[0];
+        public static bool hold = false;
+
+        public int[] pointSelection
+        {
+            get
+            {
+                return _selectedPoints.ToArray();
+            }
+        }
+
+        public int selectedPointsCount
+        {
+            get { return _selectedPoints.Count; }
+            set { }
+        }
+
+        protected bool closedOnMirror = false;
+
+        private DreamteckSplinesEditor _pathEditor;
+        private ComputerEditor _computerEditor;
+        private SplineTriggersEditor _triggersEditor;
+        private SplineComputerDebugEditor _debugEditor;
+        private bool _rebuildSpline = false;
+        private List<int> _selectedPoints = new List<int>();
+
+
+        [MenuItem("GameObject/3D Object/Spline Computer")]
+        private static void NewEmptySpline()
+        {
+            int count = GameObject.FindObjectsOfType<SplineComputer>().Length;
+            string objName = "Spline";
+            if (count > 0) objName += " " + count;
+            GameObject obj = new GameObject(objName);
+            obj.AddComponent<SplineComputer>();
+            if (Selection.activeGameObject != null)
+            {
+                if (EditorUtility.DisplayDialog("Make child?", "Do you want to make the new spline a child of " + Selection.activeGameObject.name + "?", "Yes", "No"))
+                {
+                    obj.transform.parent = Selection.activeGameObject.transform;
+                    obj.transform.localPosition = Vector3.zero;
+                    obj.transform.localRotation = Quaternion.identity;
+                }
+            }
+            Selection.activeGameObject = obj;
+        }
+
+        [MenuItem("GameObject/3D Object/Spline Node")]
+        private static void NewSplineNode()
+        {
+            int count = Object.FindObjectsOfType<Node>().Length;
+            string objName = "Node";
+            if (count > 0) objName += " " + count;
+            GameObject obj = new GameObject(objName);
+            obj.AddComponent<Node>();
+            if(Selection.activeGameObject != null)
+            {
+                if(EditorUtility.DisplayDialog("Make child?", "Do you want to make the new node a child of " + Selection.activeGameObject.name + "?", "Yes", "No"))
+                {
+                    obj.transform.parent = Selection.activeGameObject.transform;
+                    obj.transform.localPosition = Vector3.zero;
+                    obj.transform.localRotation = Quaternion.identity;
+                }
+            }
+            Selection.activeGameObject = obj;
+        }
+
+        public void UndoRedoPerformed()
+        {
+            _pathEditor.UndoRedoPerformed();
+            spline.EditorUpdateConnectedNodes();
+            spline.Rebuild();
+        }
+
+        private void OnEnable()
+        {
+            splines = new SplineComputer[targets.Length];
+            for (int i = 0; i < splines.Length; i++)
+            {
+                splines[i] = (SplineComputer)targets[i];
+                splines[i].EditorAwake();
+                if (splines[i].editorAlwaysDraw)
+                {
+                    DSSplineDrawer.RegisterComputer(splines[i]);
+                }
+            }
+            spline = splines[0];
+            InitializeSplineEditor();
+            InitializeComputerEditor();
+            _debugEditor = new SplineComputerDebugEditor(spline, serializedObject, _pathEditor);
+            _debugEditor.undoHandler += RecordUndo;
+            _debugEditor.repaintHandler += OnRepaint;
+            _triggersEditor = new SplineTriggersEditor(spline, serializedObject);
+            _triggersEditor.undoHandler += RecordUndo;
+            _triggersEditor.repaintHandler += OnRepaint;
+            hold = false;
+#if UNITY_2019_1_OR_NEWER
+            SceneView.beforeSceneGui += BeforeSceneGUI;
+            SceneView.duringSceneGui += DuringSceneGUI;
+#else
+            SceneView.onSceneGUIDelegate += BeforeSceneGUI;
+            SceneView.onSceneGUIDelegate += DuringSceneGUI;
+#endif
+            Undo.undoRedoPerformed += UndoRedoPerformed;
+        }
+
+        private void BeforeSceneGUI(SceneView current)
+        {
+            _pathEditor.BeforeSceneGUI(current);
+
+            if (Event.current.type == EventType.MouseUp)
+            {
+                if (Event.current.button == 0)
+                {
+                    for (int i = 0; i < splines.Length; i++)
+                    {
+                        if (splines[i].editorUpdateMode == SplineComputer.EditorUpdateMode.OnMouseUp)
+                        {
+                            splines[i].RebuildImmediate();
+                        }
+                    }
+                }
+            }
+        }
+
+        private void InitializeSplineEditor()
+        {
+            _pathEditor = new DreamteckSplinesEditor(spline, serializedObject);
+            _pathEditor.undoHandler = RecordUndo;
+            _pathEditor.repaintHandler = OnRepaint;
+            _pathEditor.editSpace = (SplineEditor.Space)SplinePrefs.pointEditSpace;
+        }
+
+        private void InitializeComputerEditor()
+        {
+            _computerEditor = new ComputerEditor(splines, serializedObject, _pathEditor);
+            _computerEditor.undoHandler = RecordUndo;
+            _computerEditor.repaintHandler = OnRepaint;
+        }
+
+        private void RecordUndo(string title)
+        {
+            for (int i = 0; i < splines.Length; i++)
+            {
+                Undo.RecordObject(splines[i], title);
+            }
+        }
+
+        private void OnRepaint()
+        {
+            SceneView.RepaintAll();
+            Repaint();
+        }
+
+        private void OnDisable()
+        {
+            Undo.undoRedoPerformed -= UndoRedoPerformed;
+#if UNITY_2019_1_OR_NEWER
+            SceneView.beforeSceneGui -= BeforeSceneGUI;
+            SceneView.duringSceneGui -= DuringSceneGUI;
+#else
+            SceneView.onSceneGUIDelegate -= BeforeSceneGUI;
+            SceneView.onSceneGUIDelegate -= DuringSceneGUI;
+#endif
+            _pathEditor.Destroy();
+            _computerEditor.Destroy();
+            _debugEditor.Destroy();
+            _triggersEditor.Destroy();
+        }
+
+        public override void OnInspectorGUI()
+        {
+            if (_debugEditor.editorUpdateMode == SplineComputer.EditorUpdateMode.OnMouseUp)
+            {
+                if (Event.current.type == EventType.MouseUp && Event.current.button == 0)
+                {
+                    _rebuildSpline = true;
+                }
+                if (Event.current.type == EventType.KeyDown && (Event.current.keyCode == KeyCode.Return || Event.current.keyCode == KeyCode.KeypadEnter))
+                {
+                    _rebuildSpline = true;
+                }
+            }
+            base.OnInspectorGUI();
+            spline = (SplineComputer)target;
+
+            if (splines.Length == 1)
+            {
+                SplineEditorGUI.BeginContainerBox(ref _pathEditor.open, "Edit");
+                if (_pathEditor.open)
+                {
+                    SplineEditor.Space lastSpace = _pathEditor.editSpace;
+                    _pathEditor.DrawInspector();
+                    if (lastSpace != _pathEditor.editSpace)
+                    {
+                        SplinePrefs.pointEditSpace = (SplineComputer.Space)_pathEditor.editSpace;
+                        SplinePrefs.SavePrefs();
+                    }
+                }
+                else if (_pathEditor.lastEditorTool != Tool.None && Tools.current == Tool.None)
+                {
+                    Tools.current = _pathEditor.lastEditorTool;
+                }
+                SplineEditorGUI.EndContainerBox();
+            }
+
+            SplineEditorGUI.BeginContainerBox(ref _computerEditor.open, "Spline Computer");
+            if (_computerEditor.open)
+            {
+                _computerEditor.DrawInspector();
+            }
+            SplineEditorGUI.EndContainerBox();
+
+            if (splines.Length == 1)
+            {
+                SplineEditorGUI.BeginContainerBox(ref _triggersEditor.open, "Triggers");
+                if (_triggersEditor.open) _triggersEditor.DrawInspector();
+                SplineEditorGUI.EndContainerBox();
+            }
+
+            SplineEditorGUI.BeginContainerBox(ref _debugEditor.open, "Editor Properties");
+            if (_debugEditor.open) _debugEditor.DrawInspector();
+            SplineEditorGUI.EndContainerBox();
+
+            if (GUI.changed)
+            {
+                EditorUtility.SetDirty(spline);
+            }
+
+
+            if (Event.current.type == EventType.Layout && _rebuildSpline)
+            {
+                for (int i = 0; i < splines.Length; i++)
+                {
+                    if (splines[i].editorUpdateMode == SplineComputer.EditorUpdateMode.OnMouseUp)
+                    {
+                        splines[i].RebuildImmediate(true);
+                    }
+                }
+                _rebuildSpline = false;
+            }
+
+        }
+
+        public bool IsPointSelected(int index)
+        {
+            return _selectedPoints.Contains(index);
+        }
+
+        private void DuringSceneGUI(SceneView currentSceneView)
+        {
+            _debugEditor.DrawScene(currentSceneView);
+            _computerEditor.drawComputer = !(_pathEditor.currentModule is CreatePointModule);
+            _computerEditor.drawPivot = _pathEditor.open && spline.editorDrawPivot;
+            _computerEditor.DrawScene(currentSceneView);
+            if (splines.Length == 1 && _triggersEditor.open) _triggersEditor.DrawScene(currentSceneView);
+            if (splines.Length == 1 && _pathEditor.open) _pathEditor.DrawScene(currentSceneView);
+        }
+    }
+}