Initial commit

Library/PackageCache/com.unity.2d.path@2.1.0/Editor/IMGUI/GUIFramework/ClickAction.cs

@@ -0,0 +1,52 @@
+using System;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Path.GUIFramework
+{
+    public class ClickAction : HoveredControlAction
+    {
+        private int m_Button;
+        private bool m_UseEvent;
+        public int clickCount = 1;
+        public Action<IGUIState, Control> onClick;
+        private int m_ClickCounter = 0;
+
+        public ClickAction(Control control, int button, bool useEvent = true) : base(control)
+        {
+            m_Button = button;
+            m_UseEvent = useEvent;
+        }
+
+        protected override bool GetTriggerContidtion(IGUIState guiState)
+        {
+            if (guiState.mouseButton == m_Button && guiState.eventType == EventType.MouseDown)
+            {
+                if (guiState.clickCount == 1)
+                    m_ClickCounter = 0;
+
+                ++m_ClickCounter;
+
+                if (m_ClickCounter == clickCount)
+                    return true;
+            }
+
+            return false;
+        }
+
+        protected override void OnTrigger(IGUIState guiState)
+        {
+            base.OnTrigger(guiState);
+            
+            if (onClick != null)
+                onClick(guiState, hoveredControl);
+
+            if (m_UseEvent)
+                guiState.UseEvent();
+        }
+
+        protected override bool GetFinishContidtion(IGUIState guiState)
+        {
+            return true;
+        }
+    }
+}

Library/PackageCache/com.unity.2d.path@2.1.0/Editor/IMGUI/GUIFramework/ClickAction.cs.meta

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

Library/PackageCache/com.unity.2d.path@2.1.0/Editor/IMGUI/GUIFramework/CommandAction.cs

@@ -0,0 +1,46 @@
+using System;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Path.GUIFramework
+{
+    public class CommandAction : GUIAction
+    {
+        private string m_CommandName;
+
+        public Action<IGUIState> onCommand;
+
+        public CommandAction(string commandName)
+        {
+            m_CommandName = commandName;
+        }
+
+        protected override bool GetTriggerContidtion(IGUIState guiState)
+        {
+            if (guiState.eventType == EventType.ValidateCommand && guiState.commandName == m_CommandName)
+            {
+                guiState.UseEvent();
+                return true;
+            }
+
+            return false;
+        }
+        
+        protected override bool GetFinishContidtion(IGUIState guiState)
+        {
+            if (guiState.eventType == EventType.ExecuteCommand && guiState.commandName == m_CommandName)
+            {
+                guiState.UseEvent();
+                
+                return true;
+            }
+
+            return false;
+        }
+
+        protected override void OnFinish(IGUIState guiState)
+        {
+            if (onCommand != null)
+                onCommand(guiState);
+        }
+    }
+}

Library/PackageCache/com.unity.2d.path@2.1.0/Editor/IMGUI/GUIFramework/CommandAction.cs.meta

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

Library/PackageCache/com.unity.2d.path@2.1.0/Editor/IMGUI/GUIFramework/Control.cs

@@ -0,0 +1,152 @@
+using System;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Path.GUIFramework
+{
+    public abstract class Control
+    {
+        private string m_Name;
+        private int m_NameHashCode;
+        private int m_ID;
+        private LayoutData m_LayoutData;
+        private int m_ActionID = -1;
+        private LayoutData m_HotLayoutData;
+
+        public string name
+        {
+            get { return m_Name; }
+        }
+
+        public int ID
+        {
+            get { return m_ID; }
+        }
+
+        public int actionID
+        {
+            get { return m_ActionID; }
+        }
+
+        public LayoutData layoutData
+        {
+            get { return m_LayoutData; }
+            set { m_LayoutData = value; }
+        }
+
+        public LayoutData hotLayoutData
+        {
+            get { return m_HotLayoutData; }
+        }
+
+        public Control(string name)
+        {
+            m_Name = name;
+            m_NameHashCode = name.GetHashCode();
+        }
+
+        public void GetControl(IGUIState guiState)
+        {
+            m_ID = guiState.GetControlID(m_NameHashCode, FocusType.Passive);
+        }
+
+        internal void SetActionID(int actionID)
+        {
+            m_ActionID = actionID;
+            m_HotLayoutData = m_LayoutData;
+        }
+
+        public void BeginLayout(IGUIState guiState)
+        {
+            Debug.Assert(guiState.eventType == EventType.Layout);
+
+            m_LayoutData = OnBeginLayout(LayoutData.zero, guiState);
+        }
+
+        public void Layout(IGUIState guiState)
+        {
+            Debug.Assert(guiState.eventType == EventType.Layout);
+
+            for (var i = 0; i < GetCount(); ++i)
+            {
+                if (guiState.hotControl == actionID && hotLayoutData.index == i)
+                    continue;
+
+                var layoutData = new LayoutData()
+                {
+                    index = i,
+                    position = GetPosition(guiState, i),
+                    distance = GetDistance(guiState, i),
+                    forward = GetForward(guiState, i),
+                    up = GetUp(guiState, i),
+                    right = GetRight(guiState, i),
+                    userData = GetUserData(guiState, i)
+                };
+
+                m_LayoutData = LayoutData.Nearest(m_LayoutData, layoutData);
+            }
+        }
+
+        public void EndLayout(IGUIState guiState)
+        {
+            Debug.Assert(guiState.eventType == EventType.Layout);
+
+            OnEndLayout(guiState);
+        }
+
+        public void Repaint(IGUIState guiState)
+        {
+            for (var i = 0; i < GetCount(); ++i)
+                OnRepaint(guiState, i);
+        }
+
+        protected virtual LayoutData OnBeginLayout(LayoutData data, IGUIState guiState)
+        {
+            return data;
+        }
+
+        protected virtual void OnEndLayout(IGUIState guiState)
+        {
+            
+        }
+
+        protected virtual void OnRepaint(IGUIState guiState, int index)
+        {
+            
+        }
+
+        protected virtual int GetCount()
+        {
+            return 1;
+        }
+
+        protected virtual Vector3 GetPosition(IGUIState guiState, int index)
+        {
+            return Vector3.zero;
+        }
+
+        protected virtual Vector3 GetForward(IGUIState guiState, int index)
+        {
+            return Vector3.forward;
+        }
+
+        protected virtual Vector3 GetUp(IGUIState guiState, int index)
+        {
+            return Vector3.up;
+        }
+
+        protected virtual Vector3 GetRight(IGUIState guiState, int index)
+        {
+            return Vector3.right;
+        }
+
+        protected virtual float GetDistance(IGUIState guiState, int index)
+        {
+            return layoutData.distance;
+        }
+
+        protected virtual object GetUserData(IGUIState guiState, int index)
+        {
+            return null;
+        }
+    }
+}

Library/PackageCache/com.unity.2d.path@2.1.0/Editor/IMGUI/GUIFramework/Control.cs.meta

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

Library/PackageCache/com.unity.2d.path@2.1.0/Editor/IMGUI/GUIFramework/DefaultControl.cs

@@ -0,0 +1,20 @@
+using System;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Path.GUIFramework
+{
+    public abstract class DefaultControl : Control
+    {
+        public static readonly float kPickDistance = 5f;
+        
+        public DefaultControl(string name) : base(name)
+        {
+        }
+
+        protected override LayoutData OnBeginLayout(LayoutData data, IGUIState guiState)
+        {
+            data.distance = kPickDistance;
+            return data;
+        }
+    }
+}

Library/PackageCache/com.unity.2d.path@2.1.0/Editor/IMGUI/GUIFramework/DefaultControl.cs.meta

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

Library/PackageCache/com.unity.2d.path@2.1.0/Editor/IMGUI/GUIFramework/GUIAction.cs

@@ -0,0 +1,112 @@
+using System;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Path.GUIFramework
+{
+    public abstract class GUIAction
+    {
+        private int m_ID = -1;
+
+        public Func<IGUIState, GUIAction, bool> enable;
+        public Func<IGUIState, GUIAction, bool> enableRepaint;
+        public Func<IGUIState, GUIAction, bool> repaintOnMouseMove;
+        public Action<IGUIState, GUIAction> onPreRepaint;
+        public Action<IGUIState, GUIAction> onRepaint;
+
+        public int ID
+        {
+            get { return m_ID; }
+        }
+
+        public void OnGUI(IGUIState guiState)
+        {
+            m_ID = guiState.GetControlID(GetType().GetHashCode(), FocusType.Passive);
+
+            if (guiState.hotControl == 0 && IsEnabled(guiState) && CanTrigger(guiState) && GetTriggerContidtion(guiState))
+            {
+                guiState.hotControl = ID;
+                OnTrigger(guiState);
+            }
+
+            if (guiState.hotControl == ID)
+            {
+                if (GetFinishContidtion(guiState))
+                {
+                    OnFinish(guiState);
+                    guiState.hotControl = 0;
+                }
+                else
+                {
+                    OnPerform(guiState);
+                }
+            }
+
+            if (guiState.eventType == EventType.Repaint && IsRepaintEnabled(guiState))
+                Repaint(guiState);
+        }
+
+        public bool IsEnabled(IGUIState guiState)
+        {
+            if (enable != null)
+                return enable(guiState, this);
+
+            return true;
+        }
+
+        public bool IsRepaintEnabled(IGUIState guiState)
+        {
+            if (!IsEnabled(guiState))
+                return false;
+
+            if (enableRepaint != null)
+                return enableRepaint(guiState, this);
+
+            return true;
+        }
+
+        public void PreRepaint(IGUIState guiState)
+        {
+            Debug.Assert(guiState.eventType == EventType.Repaint);
+
+            if (IsEnabled(guiState) && onPreRepaint != null)
+                onPreRepaint(guiState, this);
+        }
+
+        private void Repaint(IGUIState guiState)
+        {
+            Debug.Assert(guiState.eventType == EventType.Repaint);
+            
+            if (onRepaint != null)
+                onRepaint(guiState, this);
+        }
+
+        internal bool IsRepaintOnMouseMoveEnabled(IGUIState guiState)
+        {
+            if (!IsEnabled(guiState) || !IsRepaintEnabled(guiState))
+                return false;
+
+            if (repaintOnMouseMove != null)
+                return repaintOnMouseMove(guiState, this);
+
+            return false;
+        }
+
+        protected abstract bool GetFinishContidtion(IGUIState guiState);
+        protected abstract bool GetTriggerContidtion(IGUIState guiState);
+        protected virtual bool CanTrigger(IGUIState guiState) { return true; }
+        protected virtual void OnTrigger(IGUIState guiState)
+        {
+            
+        }
+
+        protected virtual void OnPerform(IGUIState guiState)
+        {
+
+        }
+
+        protected virtual void OnFinish(IGUIState guiState)
+        {
+            
+        }
+    }
+}

Library/PackageCache/com.unity.2d.path@2.1.0/Editor/IMGUI/GUIFramework/GUIAction.cs.meta

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

Library/PackageCache/com.unity.2d.path@2.1.0/Editor/IMGUI/GUIFramework/GUIState.cs

@@ -0,0 +1,156 @@
+using UnityEngine;
+using UnityEditor;
+
+namespace UnityEditor.U2D.Path.GUIFramework
+{
+    public class GUIState : IGUIState
+    {
+        private Handles.CapFunction nullCap = (int c, Vector3 p , Quaternion r, float s, EventType ev) => {};
+
+        public Vector2 mousePosition
+        {
+            get { return Event.current.mousePosition; }
+        }
+
+        public int mouseButton
+        {
+            get { return Event.current.button; }
+        }
+
+        public int clickCount
+        {
+            get { return Event.current.clickCount; }
+            set { Event.current.clickCount = Mathf.Max(0, value); }
+        }
+
+        public bool isShiftDown
+        {
+            get { return Event.current.shift; }
+        }
+
+        public bool isAltDown
+        {
+            get { return Event.current.alt; }
+        }
+
+        public bool isActionKeyDown
+        {
+            get { return EditorGUI.actionKey; }
+        }
+
+        public KeyCode keyCode
+        {
+            get { return Event.current.keyCode; }
+        }
+
+        public EventType eventType
+        {
+            get { return Event.current.type; }
+        }
+
+        public string commandName
+        {
+            get { return Event.current.commandName; }
+        }
+
+        public int nearestControl
+        {
+            get { return HandleUtility.nearestControl; }
+            set { HandleUtility.nearestControl = value; }
+        }
+
+        public int hotControl
+        {
+            get { return GUIUtility.hotControl; }
+            set { GUIUtility.hotControl = value; }
+        }
+
+        public bool changed
+        {
+            get { return GUI.changed; }
+            set { GUI.changed = value; }
+        }
+
+        public int GetControlID(int hint, FocusType focusType)
+        {
+            return GUIUtility.GetControlID(hint, focusType);
+        }
+
+        public void AddControl(int controlID, float distance)
+        {
+            HandleUtility.AddControl(controlID, distance);
+        }
+
+        public bool Slider(int id, SliderData sliderData, out Vector3 newPosition)
+        {
+            if (mouseButton == 0 && eventType == EventType.MouseDown)
+            {
+                hotControl = 0;
+                nearestControl = id;
+            }
+
+            EditorGUI.BeginChangeCheck();
+            newPosition = Handles.Slider2D(id, sliderData.position, sliderData.forward, sliderData.right, sliderData.up, 1f, nullCap, Vector2.zero);
+            return EditorGUI.EndChangeCheck();
+        }
+
+        public void UseEvent()
+        {
+            Event.current.Use();
+        }
+
+        public void Repaint()
+        {
+            HandleUtility.Repaint();
+        }
+
+        public bool HasCurrentCamera()
+        {
+            return Camera.current != null;
+        }
+
+        public float GetHandleSize(Vector3 position)
+        {
+            var scale = HasCurrentCamera() ? 0.01f : 0.05f;
+            return HandleUtility.GetHandleSize(position) * scale;
+        }
+
+        public float DistanceToSegment(Vector3 p1, Vector3 p2)
+        {
+            p1 = HandleUtility.WorldToGUIPoint(p1);
+            p2 = HandleUtility.WorldToGUIPoint(p2);
+
+            return HandleUtility.DistancePointToLineSegment(Event.current.mousePosition, p1, p2);
+        }
+        
+        public float DistanceToCircle(Vector3 center, float radius)
+        {
+            return HandleUtility.DistanceToCircle(center, radius);
+        }
+
+        public Vector3 GUIToWorld(Vector2 guiPosition, Vector3 planeNormal, Vector3 planePos)
+        {
+            Vector3 worldPos = Handles.inverseMatrix.MultiplyPoint(guiPosition);
+
+            if (Camera.current)
+            {
+                Ray ray = HandleUtility.GUIPointToWorldRay(guiPosition);
+
+                planeNormal = Handles.matrix.MultiplyVector(planeNormal);
+
+                planePos = Handles.matrix.MultiplyPoint(planePos);
+
+                Plane plane = new Plane(planeNormal, planePos);
+
+                float distance = 0f;
+
+                if (plane.Raycast(ray, out distance))
+                {
+                    worldPos = Handles.inverseMatrix.MultiplyPoint(ray.GetPoint(distance));
+                }
+            }
+
+            return worldPos;
+        }
+    }
+}

Library/PackageCache/com.unity.2d.path@2.1.0/Editor/IMGUI/GUIFramework/GUIState.cs.meta

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

Library/PackageCache/com.unity.2d.path@2.1.0/Editor/IMGUI/GUIFramework/GUISystem.cs

@@ -0,0 +1,124 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Path.GUIFramework
+{
+    public class GUISystem
+    {
+        private readonly int kControlIDCheckHashCode = "ControlIDCheckHashCode".GetHashCode();
+
+        private List<Control> m_Controls = new List<Control>();
+        private List<GUIAction> m_Actions = new List<GUIAction>();
+        private IGUIState m_GUIState;
+        private int m_PrevNearestControl = -1;
+        private LayoutData m_PrevNearestLayoutData = LayoutData.zero;
+        private int m_ControlIDCheck = -1;
+
+        public GUISystem(IGUIState guiState)
+        {
+            m_GUIState = guiState;
+        }
+
+        public void AddControl(Control control)
+        {
+            if (control == null)
+                throw new NullReferenceException("Control is null");
+
+            m_Controls.Add(control);
+        }
+
+        public void RemoveControl(Control control)
+        {
+            m_Controls.Remove(control);
+        }
+
+        public void AddAction(GUIAction action)
+        {
+            if (action == null)
+                throw new NullReferenceException("Action is null");
+
+            m_Actions.Add(action);
+        }
+
+        public void RemoveAction(GUIAction action)
+        {
+            m_Actions.Remove(action);
+        }
+
+        public void OnGUI()
+        {
+            var controlIDCheck = m_GUIState.GetControlID(kControlIDCheckHashCode, FocusType.Passive);
+
+            if (m_GUIState.eventType == EventType.Layout)
+                m_ControlIDCheck = controlIDCheck;
+            else if (m_GUIState.eventType != EventType.Used && m_ControlIDCheck != controlIDCheck)
+                Debug.LogWarning("GetControlID at event " + m_GUIState.eventType + " returns a controlID different from the one in Layout event");
+                
+            var nearestLayoutData = LayoutData.zero;
+
+            foreach (var control in m_Controls)
+                control.GetControl(m_GUIState);
+
+            if (m_GUIState.eventType == EventType.Layout)
+            {
+                foreach (var control in m_Controls)
+                    control.BeginLayout(m_GUIState);
+
+                foreach (var control in m_Controls)
+                {
+                    control.Layout(m_GUIState);
+                    nearestLayoutData = LayoutData.Nearest(nearestLayoutData, control.layoutData);
+                }
+
+                foreach (var control in m_Controls)
+                    m_GUIState.AddControl(control.ID, control.layoutData.distance);
+
+                foreach (var control in m_Controls)
+                    control.EndLayout(m_GUIState);
+
+                if (m_PrevNearestControl == m_GUIState.nearestControl)
+                {
+                    if (nearestLayoutData.index != m_PrevNearestLayoutData.index)
+                        m_GUIState.Repaint();
+                }
+                else
+                {
+                    m_PrevNearestControl = m_GUIState.nearestControl;
+                    m_GUIState.Repaint();
+                }
+
+                m_PrevNearestLayoutData = nearestLayoutData;
+            }
+
+            if (m_GUIState.eventType == EventType.Repaint)
+            {
+                foreach (var action in m_Actions)
+                    if (action.IsRepaintEnabled(m_GUIState))
+                        action.PreRepaint(m_GUIState);
+
+                foreach (var control in m_Controls)
+                    control.Repaint(m_GUIState);
+            }
+
+            var repaintOnMouseMove = false;
+
+            foreach (var action in m_Actions)
+            {
+                if (IsMouseMoveEvent())
+                    repaintOnMouseMove |= action.IsRepaintOnMouseMoveEnabled(m_GUIState);
+
+                action.OnGUI(m_GUIState);
+            }
+
+            if (repaintOnMouseMove)
+                m_GUIState.Repaint();
+        }
+
+        private bool IsMouseMoveEvent()
+        {
+            return m_GUIState.eventType == EventType.MouseMove || m_GUIState.eventType == EventType.MouseDrag;
+        }
+    }
+}

Library/PackageCache/com.unity.2d.path@2.1.0/Editor/IMGUI/GUIFramework/GUISystem.cs.meta

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

Library/PackageCache/com.unity.2d.path@2.1.0/Editor/IMGUI/GUIFramework/GenericControl.cs

@@ -0,0 +1,99 @@
+using System;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Path.GUIFramework
+{
+    public class GenericControl : Control
+    {
+        public Func<IGUIState, LayoutData> onBeginLayout;
+        public Action<IGUIState> onEndLayout;
+        public Action<IGUIState, Control, int> onRepaint;
+        public Func<int> count;
+        public Func<int, Vector3> position;
+        public Func<IGUIState, int, float> distance;
+        public Func<int, Vector3> forward;
+        public Func<int, Vector3> up;
+        public Func<int, Vector3> right;
+        public Func<int, object> userData;
+
+        public GenericControl(string name) : base(name)
+        {
+        }
+
+        protected override int GetCount()
+        {
+            if (count != null)
+                return count();
+
+            return base.GetCount();
+        }
+
+        protected override void OnEndLayout(IGUIState guiState)
+        {
+            if (onEndLayout != null)
+                onEndLayout(guiState);
+        }
+
+        protected override void OnRepaint(IGUIState guiState, int index)
+        {
+            if (onRepaint != null)
+                onRepaint(guiState, this, index);
+        }
+
+        protected override LayoutData OnBeginLayout(LayoutData data, IGUIState guiState)
+        {
+            if (onBeginLayout != null)
+                return onBeginLayout(guiState);
+
+            return data;
+        }
+
+        protected override Vector3 GetPosition(IGUIState guiState, int index)
+        {
+            if (position != null)
+                return position(index);
+
+            return base.GetPosition(guiState,index);
+        }
+
+        protected override float GetDistance(IGUIState guiState, int index)
+        {
+            if (distance != null)
+                return distance(guiState, index);
+
+            return base.GetDistance(guiState, index);
+        }
+
+        protected override Vector3 GetForward(IGUIState guiState, int index)
+        {
+            if (forward != null)
+                return forward(index);
+
+            return base.GetForward(guiState,index);
+        }
+
+        protected override Vector3 GetUp(IGUIState guiState, int index)
+        {
+            if (up != null)
+                return up(index);
+
+            return base.GetUp(guiState,index);
+        }
+
+        protected override Vector3 GetRight(IGUIState guiState, int index)
+        {
+            if (right != null)
+                return right(index);
+
+            return base.GetRight(guiState,index);
+        }
+
+        protected override object GetUserData(IGUIState guiState, int index)
+        {
+            if (userData != null)
+                return userData(index);
+            
+            return base.GetUserData(guiState,index);
+        }
+    }
+}

Library/PackageCache/com.unity.2d.path@2.1.0/Editor/IMGUI/GUIFramework/GenericControl.cs.meta

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

Library/PackageCache/com.unity.2d.path@2.1.0/Editor/IMGUI/GUIFramework/GenericDefaultControl.cs

@@ -0,0 +1,58 @@
+using System;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Path.GUIFramework
+{
+    public class GenericDefaultControl : DefaultControl
+    {
+        public Func<IGUIState, Vector3> position;
+        public Func<IGUIState, Vector3> forward;
+        public Func<IGUIState, Vector3> up;
+        public Func<IGUIState, Vector3> right;
+        public Func<IGUIState, object> userData;
+
+        public GenericDefaultControl(string name) : base(name)
+        {
+        }
+
+        protected override Vector3 GetPosition(IGUIState guiState, int index)
+        {
+            if (position != null)
+                return position(guiState);
+
+            return base.GetPosition(guiState, index);
+        }
+
+        protected override Vector3 GetForward(IGUIState guiState, int index)
+        {
+            if (forward != null)
+                return forward(guiState);
+
+            return base.GetForward(guiState, index);
+        }
+
+        protected override Vector3 GetUp(IGUIState guiState, int index)
+        {
+            if (up != null)
+                return up(guiState);
+
+            return base.GetUp(guiState, index);
+        }
+
+        protected override Vector3 GetRight(IGUIState guiState, int index)
+        {
+            if (right != null)
+                return right(guiState);
+
+            return base.GetRight(guiState, index);
+        }
+
+        protected override object GetUserData(IGUIState guiState, int index)
+        {
+            if (userData != null)
+                return userData(guiState);
+            
+            return base.GetUserData(guiState, index);
+        }
+    }
+}

Library/PackageCache/com.unity.2d.path@2.1.0/Editor/IMGUI/GUIFramework/GenericDefaultControl.cs.meta

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

Library/PackageCache/com.unity.2d.path@2.1.0/Editor/IMGUI/GUIFramework/HoveredControlAction.cs

@@ -0,0 +1,30 @@
+using System;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Path.GUIFramework
+{
+    public abstract class HoveredControlAction : GUIAction
+    {
+        private Control m_HoveredControl;
+
+        public Control hoveredControl
+        {
+            get { return m_HoveredControl; }
+        }
+
+        public HoveredControlAction(Control control)
+        {
+            m_HoveredControl = control;
+        }
+
+        protected override bool CanTrigger(IGUIState guiState)
+        {
+            return guiState.nearestControl == hoveredControl.ID;
+        }
+
+        protected override void OnTrigger(IGUIState guiState)
+        {
+            m_HoveredControl.SetActionID(ID);
+        }
+    }
+}

Library/PackageCache/com.unity.2d.path@2.1.0/Editor/IMGUI/GUIFramework/HoveredControlAction.cs.meta

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

Library/PackageCache/com.unity.2d.path@2.1.0/Editor/IMGUI/GUIFramework/IGUIState.cs

@@ -0,0 +1,41 @@
+using UnityEngine;
+using UnityEditor;
+
+namespace UnityEditor.U2D.Path.GUIFramework
+{
+    public struct SliderData
+    {
+        public Vector3 position;
+        public Vector3 forward;
+        public Vector3 up;
+        public Vector3 right;
+
+        public static readonly SliderData zero = new SliderData() { position = Vector3.zero, forward = Vector3.forward, up = Vector3.up, right = Vector3.right };
+    }
+
+    public interface IGUIState
+    {
+        Vector2 mousePosition { get; }
+        int mouseButton { get; }
+        int clickCount { get; set; }
+        bool isShiftDown { get; }
+        bool isAltDown { get; }
+        bool isActionKeyDown { get; }
+        KeyCode keyCode { get; }
+        EventType eventType { get; }
+        string commandName { get; }
+        int nearestControl { get; set; }
+        int hotControl { get; set; }
+        bool changed { get; set; }
+        int GetControlID(int hint, FocusType focusType);
+        void AddControl(int controlID, float distance);
+        bool Slider(int id, SliderData sliderData, out Vector3 newPosition);
+        void UseEvent();
+        void Repaint();
+        bool HasCurrentCamera();
+        float GetHandleSize(Vector3 position);
+        float DistanceToSegment(Vector3 p1, Vector3 p2);
+        float DistanceToCircle(Vector3 center, float radius);
+        Vector3 GUIToWorld(Vector2 guiPosition, Vector3 planeNormal, Vector3 planePos);
+    }
+}

Library/PackageCache/com.unity.2d.path@2.1.0/Editor/IMGUI/GUIFramework/IGUIState.cs.meta

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

Library/PackageCache/com.unity.2d.path@2.1.0/Editor/IMGUI/GUIFramework/LayoutData.cs

@@ -0,0 +1,25 @@
+using UnityEngine;
+
+namespace UnityEditor.U2D.Path.GUIFramework
+{
+    public struct LayoutData
+    {
+        public int index;
+        public float distance;
+        public Vector3 position;
+        public Vector3 forward;
+        public Vector3 up;
+        public Vector3 right;
+        public object userData;
+
+        public static readonly LayoutData zero = new LayoutData() { index = 0, distance = float.MaxValue, position = Vector3.zero, forward = Vector3.forward, up = Vector3.up, right = Vector3.right };
+
+        public static LayoutData Nearest(LayoutData currentData, LayoutData newData)
+        {
+            if (newData.distance <= currentData.distance)
+                return newData;
+
+            return currentData;
+        }
+    }
+}

Library/PackageCache/com.unity.2d.path@2.1.0/Editor/IMGUI/GUIFramework/LayoutData.cs.meta

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

Library/PackageCache/com.unity.2d.path@2.1.0/Editor/IMGUI/GUIFramework/SliderAction.cs

@@ -0,0 +1,60 @@
+using System;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Path.GUIFramework
+{
+    public class SliderAction : ClickAction
+    {
+        private SliderData m_SliderData;
+
+        public Action<IGUIState, Control, Vector3> onSliderBegin;
+        public Action<IGUIState, Control, Vector3> onSliderChanged;
+        public Action<IGUIState, Control, Vector3> onSliderEnd;
+
+        public SliderAction(Control control) : base(control, 0, false)
+        {
+        }
+
+        protected override bool GetFinishContidtion(IGUIState guiState)
+        {
+            return guiState.eventType == EventType.MouseUp && guiState.mouseButton == 0;
+        }
+
+
+        protected override void OnTrigger(IGUIState guiState)
+        {
+            base.OnTrigger(guiState);
+
+            m_SliderData.position = hoveredControl.hotLayoutData.position;
+            m_SliderData.forward = hoveredControl.hotLayoutData.forward;
+            m_SliderData.right = hoveredControl.hotLayoutData.right;
+            m_SliderData.up = hoveredControl.hotLayoutData.up;
+
+            if (onSliderBegin != null)
+                onSliderBegin(guiState, hoveredControl, m_SliderData.position);
+        }
+
+        protected override void OnFinish(IGUIState guiState)
+        {
+            if (onSliderEnd != null)
+                onSliderEnd(guiState, hoveredControl, m_SliderData.position);
+
+            guiState.UseEvent();
+            guiState.Repaint();
+        }
+
+        protected override void OnPerform(IGUIState guiState)
+        {
+            Vector3 newPosition;
+            var changed = guiState.Slider(ID, m_SliderData, out newPosition);
+
+            if (changed)
+            {
+                m_SliderData.position = newPosition;
+
+                if (onSliderChanged != null)
+                    onSliderChanged(guiState, hoveredControl, newPosition);
+            }
+        }
+    }
+}

Library/PackageCache/com.unity.2d.path@2.1.0/Editor/IMGUI/GUIFramework/SliderAction.cs.meta

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