public void OnInspectorGUI(Spline spline)
{
m_Spline = spline;
if (SpriteShapeTool.instance != null)
{
if (SpriteShapeTool.instance.splineEditor != null)
{
SpriteShapeTool.instance.splineEditor.GetAngleRange = GetAngleRange;
}
}
EditorGUI.BeginChangeCheck();
if (GUI.enabled && SplineEditorCache.GetSelection().Count > 0)
{
EditorGUILayout.LabelField(Contents.pointLabel, EditorStyles.boldLabel);
DoTangentGUI();
DoPointInspector();
SnappingUtility.enabled = EditorGUILayout.Toggle(Contents.enableSnapLabel, SnappingUtility.enabled);
}
if (EditorGUI.EndChangeCheck())
{
SetDirty();
}
}
private void ValidateTangents(bool rightTangentChanged)
{
var selection = SplineEditorCache.GetSelection();
var mode = GetTangentMode(selection.single);
var leftTangent = GetLeftTangent(selection.single);
var rightTangent = GetRightTangent(selection.single);
if (mode == TangentMode.Continuous)
{
if (rightTangentChanged && rightTangent.magnitude > 0)
{
var len = leftTangent.magnitude;
var rta = rightTangent.normalized;
leftTangent = -rta * len;
}
else if (leftTangent.magnitude > 0)
{
var len = rightTangent.magnitude;
var lta = leftTangent.normalized;
rightTangent = -lta * len;
}
}
SetLeftTangent(selection.single, leftTangent);
SetRightTangent(selection.single, rightTangent);
SplineEditorCache.instance.rightTangentChanged = rightTangentChanged;
UpdateTangentCache();
}
private void ClearSelection()
{
SplineEditorCache.RigisterUndo("Edit Selection");
SplineEditorCache.ClearSelection();
GUI.changed = true;
}
private void DrawPoints()
{
if (currentEvent.type != EventType.Repaint)
{
return;
}
for (int index = 0; index < GetPointCount(); index++)
{
var position = GetPosition(index);
if (m_ActivePointIndex == index)
{
GetPointCapActive(0, position, Quaternion.LookRotation(GetForwardVector(), GetUpVector()), GetHandleSize(position), currentEvent.type);
}
else if (m_HoveredPointIndex == index && GUIUtility.hotControl == 0)
{
GetPointCapHovered(0, position, Quaternion.LookRotation(GetForwardVector(), GetUpVector()), GetHandleSize(position), currentEvent.type);
}
else if (SplineEditorCache.GetSelection().IsSelected(index))
{
GetPointCapSelected(0, position, Quaternion.LookRotation(GetForwardVector(), GetUpVector()), GetHandleSize(position), currentEvent.type);
}
else
{
GetPointCapNormal(0, position, Quaternion.LookRotation(GetForwardVector(), GetUpVector()), GetHandleSize(position), currentEvent.type);
}
}
}
private int GetAngleRange(int index)
{
int startPoint = 0;
SpriteShapeController sc = SplineEditorCache.GetTarget();
return(GetAngleRange(sc, index, ref startPoint));
}
private void ResetTangents(int pointIndex)
{
Vector3 position = GetPosition(pointIndex);
Vector3 positionNext = GetPosition(SplineUtility.NextIndex(pointIndex, GetPointCount()));
Vector3 positionPrev = GetPosition(SplineUtility.PreviousIndex(pointIndex, GetPointCount()));
Vector3 forward = Vector3.forward;
if (SplineEditorCache.IsValid() && SplineEditorCache.GetTarget() != null)
{
forward = SplineEditorCache.GetTarget().transform.forward;
}
float scale = Mathf.Min((positionNext - position).magnitude, (positionPrev - position).magnitude) * 0.33f;
Vector3 leftTangent = (positionPrev - position).normalized * scale;
Vector3 rightTangent = (positionNext - position).normalized * scale;
if (GetTangentMode(pointIndex) == TangentMode.Continuous)
{
SplineUtility.CalculateTangents(position, positionPrev, positionNext, forward, scale, out rightTangent, out leftTangent);
}
SetLeftTangent(pointIndex, leftTangent);
SetRightTangent(pointIndex, rightTangent);
}
public void SetTangentModeUseThisOne(int pointIndex, TangentMode mode)
{
SetTangentMode(pointIndex, mode);
if (SplineEditorCache.IsValid() && SplineEditorCache.GetTarget() != null)
{
if (mode == TangentMode.Continuous)
{
SetLeftTangent(pointIndex, SplineEditorCache.instance.GetLeftTangentContinous(pointIndex));
SetRightTangent(pointIndex, SplineEditorCache.instance.GetRightTangentContinous(pointIndex));
}
if (mode == TangentMode.Broken)
{
SetLeftTangent(pointIndex, SplineEditorCache.instance.GetLeftTangentBroken(pointIndex));
SetRightTangent(pointIndex, SplineEditorCache.instance.GetRightTangentBroken(pointIndex));
}
}
if (mode == TangentMode.Continuous || mode == TangentMode.Broken)
{
if (GetLeftTangent(pointIndex).sqrMagnitude == 0f && GetRightTangent(pointIndex).sqrMagnitude == 0f)
{
ResetTangents(pointIndex);
}
}
SetDirty();
}
public void CycleSpriteIndex()
{
var selection = SplineEditorCache.GetSelection();
var spriteShape = SplineEditorCache.GetTarget().spriteShape;
if (selection.single == -1 || spriteShape == null)
{
return;
}
Debug.Assert(SplineEditorCache.GetTarget() != null);
var angleRangeIndex = GetAngleRange(selection.single);
if (angleRangeIndex != -1)
{
var angleRange = spriteShape.angleRanges[angleRangeIndex];
var spriteIndex = 0;
if (angleRange.sprites.Count > 0)
{
spriteIndex = (GetSpriteIndex(selection.single) + 1) % angleRange.sprites.Count;
}
RegisterUndo();
SetSpriteIndex(selection.single, spriteIndex);
SetDirty();
}
}
private void DrawTangents()
{
ISelection selection = SplineEditorCache.GetSelection();
int selectedPoint = selection.single;
if (selectedPoint == -1 || GetTangentMode(selectedPoint) == TangentMode.Linear || currentEvent.type != EventType.Repaint)
{
return;
}
Vector3 position = GetPosition(selectedPoint);
Vector3 leftTangent = GetLeftTangent(selectedPoint);
Vector3 rightTangent = GetRightTangent(selection.single);
Color color = kTangentColor;
DrawTangentLine(position, leftTangent, color);
if (GetTangentMode(selectedPoint) == TangentMode.Broken)
{
color = kTangentColorAlternative;
}
DrawTangentLine(position, rightTangent, color);
if (m_ActiveTangentPointIndex != -1)
{
if (m_DragLeftTangent)
{
GetTangentCapActive(0, leftTangent + position, Quaternion.identity, GetHandleSize(leftTangent + position), EventType.Repaint);
GetTangentCapNormal(0, rightTangent + position, Quaternion.identity, GetHandleSize(rightTangent + position), EventType.Repaint);
}
else
{
GetTangentCapNormal(0, leftTangent + position, Quaternion.identity, GetHandleSize(leftTangent + position), EventType.Repaint);
GetTangentCapActive(0, rightTangent + position, Quaternion.identity, GetHandleSize(rightTangent + position), EventType.Repaint);
}
}
else if (GUIUtility.hotControl == 0 && m_HoveredTangentPoint != -1)
{
if (m_HoveredLeftTangent)
{
GetTangentCapHovered(0, leftTangent + position, Quaternion.identity, GetHandleSize(leftTangent + position), EventType.Repaint);
GetTangentCapNormal(0, rightTangent + position, Quaternion.identity, GetHandleSize(rightTangent + position), EventType.Repaint);
}
else
{
GetTangentCapNormal(0, leftTangent + position, Quaternion.identity, GetHandleSize(leftTangent + position), EventType.Repaint);
GetTangentCapHovered(0, rightTangent + position, Quaternion.identity, GetHandleSize(rightTangent + position), EventType.Repaint);
}
}
else
{
GetTangentCapNormal(0, leftTangent + position, Quaternion.identity, GetHandleSize(leftTangent + position), EventType.Repaint);
GetTangentCapNormal(0, rightTangent + position, Quaternion.identity, GetHandleSize(rightTangent + position), EventType.Repaint);
}
}
private int ResolveSpriteIndex(List <int> spriteIndices, ISelection selection, ref List <int> startPoints)
{
var spriteIndexValue = spriteIndices.FirstOrDefault();
SpriteShapeController sc = SplineEditorCache.GetTarget();
if (sc == null || sc.spriteShape == null)
{
return(-1);
}
// Either SpriteShape Asset or SpriteShape Data has changed.
List <ShapeAngleRange> angleRanges = GetAngleRangeSorted(sc.spriteShape);
if (m_SpriteShapeHashCode != sc.spriteShapeHashCode)
{
GenerateSegments(sc, angleRanges);
m_SpriteShapeHashCode = sc.spriteShapeHashCode;
m_SelectedPoint = -1;
}
if (sc.spriteShape != null)
{
if (selection.single != -1)
{
m_SelectedAngleRange = GetAngleRange(sc, selection.single, ref m_SelectedPoint);
startPoints.Add(m_SelectedPoint);
spriteIndexValue = m_Spline.GetSpriteIndex(m_SelectedPoint);
}
else
{
m_SelectedAngleRange = -1;
foreach (var index in selection)
{
int startPoint = index;
int angleRange = GetAngleRange(sc, index, ref startPoint);
if (m_SelectedAngleRange != -1 && angleRange != m_SelectedAngleRange)
{
m_SelectedAngleRange = -1;
break;
}
startPoints.Add(startPoint);
m_SelectedAngleRange = angleRange;
}
}
}
if (m_SelectedAngleRange != -1)
{
spriteSelector.UpdateSprites(sc.spriteShape.angleRanges[m_SelectedAngleRange].sprites.ToArray());
}
else
{
spriteIndexValue = -1;
}
return(spriteIndexValue);
}
private void RegisterUndoOnSliderChangedOnce()
{
Debug.Assert(GUIUtility.hotControl != 0);
if (m_SliderChanged == false)
{
m_SliderChanged = true;
RegisterUndo();
SplineEditorCache.RigisterUndo();
}
}
private int GetAngleRangeLocal(int index)
{
var selection = SplineEditorCache.GetSelection();
var spriteShape = SplineEditorCache.GetTarget().spriteShape;
var nextIndex = SplineUtility.NextIndex(selection.single, GetPointCount());
var pos1 = GetLocalPosition(selection.single);
var pos2 = GetLocalPosition(nextIndex);
var angle = SplineUtility.SlopeAngle(pos1, pos2) + 90;
var angleRangeIndex = SpriteShapeEditorUtility.GetRangeIndexFromAngle(spriteShape, angle);
return(angleRangeIndex);
}
private void SelectionChanged()
{
if (target == null)
{
return;
}
if (target != SplineEditorCache.GetTarget())
{
SplineEditorCache.RigisterUndo();
}
InvalidateShapeEditor();
}
private void LayoutTangents()
{
ISelection selection = SplineEditorCache.GetSelection();
int selectedPoint = selection.single;
if (selectedPoint == -1 || selectedPoint >= GetPointCount())
{
return;
}
if (GetTangentMode(selectedPoint) == TangentMode.Linear)
{
return;
}
int tangentId = GUIUtility.GetControlID(m_TangentHashCode, FocusType.Passive);
Vector3 position = GetPosition(selectedPoint);
if (currentEvent.type == EventType.Layout)
{
Vector3 leftTangentPosition = GetLeftTangent(selectedPoint);
GetTangentCapNormal(tangentId, leftTangentPosition + position, Quaternion.identity, GetHandleSize(leftTangentPosition + position), EventType.Layout);
if (HandleUtility.nearestControl == tangentId)
{
m_HoveredTangentPoint = selectedPoint;
m_HoveredLeftTangent = true;
m_HoveredPointIndex = -1;
}
}
tangentId = GUIUtility.GetControlID(m_TangentHashCode, FocusType.Passive);
if (currentEvent.type == EventType.Layout)
{
Vector3 rightTangentPosition = GetRightTangent(selection.single);
GetTangentCapNormal(tangentId, rightTangentPosition + position, Quaternion.identity, GetHandleSize(rightTangentPosition + position), EventType.Layout);
if (HandleUtility.nearestControl == tangentId)
{
m_HoveredTangentPoint = selectedPoint;
m_HoveredLeftTangent = false;
m_HoveredPointIndex = -1;
}
}
}
private void MoveSelectedPoints(Vector3 delta)
{
ISelection selection = SplineEditorCache.GetSelection();
RegisterUndo();
if (delta.sqrMagnitude < float.Epsilon)
{
return;
}
foreach (int index in selection)
{
SetPosition(index, GetPosition(index) + delta);
}
}
public void CycleTangentMode()
{
var selection = SplineEditorCache.GetSelection();
if (selection.single == -1)
{
return;
}
RegisterUndo();
var oldMode = GetTangentMode(selection.single);
var newMode = GetNextTangentMode(oldMode);
SetTangentModeUseThisOne(selection.single, newMode);
}
private bool InitializeCheck()
{
if (target != SplineEditorCache.GetTarget())
{
InvalidateShapeEditor();
SplineEditorCache.ClearSelection();
SplineEditorCache.SetTarget(target);
}
if (target != null && m_SplineEditor == null)
{
SetupSpriteShapeEditor(target.spline);
}
return(target != null);
}
private void DoRectSelectionGUI()
{
Debug.Assert(m_Spline != null);
var selection = SplineEditorCache.GetSelection();
if (m_RectSelectionID == -1)
{
m_RectSelectionID = GUIUtility.GetControlID("RectSelection".GetHashCode(), FocusType.Passive);
}
if (Event.current.GetTypeForControl(m_RectSelectionID) == EventType.MouseDown && Event.current.button == 0)
{
if (!Event.current.shift && !EditorGUI.actionKey)
{
SplineEditorCache.RigisterUndo("Edit Selection");
SplineEditorCache.ClearSelection();
GUI.changed = true;
}
}
if (Event.current.GetTypeForControl(m_RectSelectionID) == EventType.MouseUp && Event.current.button == 0)
{
SplineEditorCache.RigisterUndo("Edit Selection");
selection.EndSelection(true);
GUI.changed = true;
}
EditorGUI.BeginChangeCheck();
var selectionRect = m_RectSelectionTool.Do(m_RectSelectionID, GetTransform().position);
if (EditorGUI.EndChangeCheck())
{
selection.BeginSelection();
for (int i = 0; i < m_Spline.GetPointCount(); ++i)
{
if (selectionRect.Contains(HandleUtility.WorldToGUIPoint(LocalToWorld(m_Spline.GetPosition(i))), true))
{
selection.Select(i, true);
}
}
}
}
private void Framing()
{
if (GetPointCount() == 0)
{
return;
}
ISelection selection = SplineEditorCache.GetSelection();
if (currentEvent.commandName == "FrameSelected" && selection.Count > 0)
{
switch (currentEvent.type)
{
case EventType.ExecuteCommand:
Bounds bounds = default(Bounds);
if (selection.Count == 0)
{
bounds = new Bounds(GetPosition(0), Vector3.zero);
for (int index = 1; index < GetPointCount(); ++index)
{
bounds.Encapsulate(GetPosition(index));
}
}
else
{
bounds = new Bounds(GetPosition(selection.any), Vector3.zero);
foreach (int index in selection)
{
bounds.Encapsulate(GetPosition(index));
}
}
Frame(bounds);
currentEvent.Use();
break;
case EventType.ValidateCommand:
currentEvent.Use();
break;
}
}
}
private void SelectPoint(int index)
{
ISelection selection = SplineEditorCache.GetSelection();
bool additive = currentEvent.shift;
bool subtractive = EditorGUI.actionKey;
SplineEditorCache.RigisterUndo("Edit Selection");
if (!additive && !subtractive)
{
SplineEditorCache.ClearSelection();
}
selection.Select(index, (!selection.IsSelected(index) || additive) && !subtractive);
GUI.changed = true;
}
public void MirrorTangent()
{
if (SpriteShapeTool.instance.isActive && SplineEditorCache.IsValid() && SplineEditorCache.GetTarget() != null)
{
var selection = SplineEditorCache.GetSelection();
if (selection.Count != 1)
{
return;
}
var mode = GetTangentMode(selection.single);
if (mode == TangentMode.Linear)
{
return;
}
var leftTangent = GetLeftTangent(selection.single);
var rightTangent = GetRightTangent(selection.single);
if (!Mathf.Approximately((leftTangent + rightTangent).sqrMagnitude, 0f))
{
if (GUIUtility.hotControl == 0)
{
Undo.RegisterCompleteObjectUndo(SplineEditorCache.GetTarget(), "Mirror Tangents");
}
if (SplineEditorCache.instance.rightTangentChanged)
{
SetLeftTangent(selection.single, rightTangent * -1);
}
else
{
SetRightTangent(selection.single, leftTangent * -1);
}
UpdateTangentCache();
}
}
}
private void DeleteSelected()
{
ISelection selection = SplineEditorCache.GetSelection();
if (GetPointCount() <= 2)
{
return;
}
RegisterUndo();
List <int> indices = new List <int>(selection);
indices.Sort();
for (int i = indices.Count - 1; i >= 0; --i)
{
RemovePointAt(indices[i]);
}
ClearSelection();
GUI.changed = true;
}
private void SetDirty()
{
Debug.Assert(SpriteShapeTool.instance.isActive);
EditorUtility.SetDirty(SplineEditorCache.GetTarget());
}
private void RegisterUndo(string name)
{
Debug.Assert(SpriteShapeTool.instance.isActive);
Undo.RegisterCompleteObjectUndo(SplineEditorCache.GetTarget(), name);
}
private void DoPointInspector()
{
var selection = SplineEditorCache.GetSelection();
var positions = new List <Vector3>();
var heights = new List <float>();
var spriteIndices = new List <int>();
var corners = new List <bool>();
foreach (int index in selection)
{
positions.Add(m_Spline.GetPosition(index));
heights.Add(m_Spline.GetHeight(index));
spriteIndices.Add(m_Spline.GetSpriteIndex(index));
corners.Add(m_Spline.GetCorner(index));
}
EditorGUIUtility.wideMode = true;
EditorGUI.BeginChangeCheck();
positions = MultiVector2Field(Contents.positionLabel, positions, 1.5f);
if (EditorGUI.EndChangeCheck())
{
RegisterUndo("Inspector");
for (int index = 0; index < positions.Count; index++)
{
m_Spline.SetPosition(selection.ElementAt(index), positions[index]);
}
SceneView.RepaintAll();
}
EditorGUIUtility.wideMode = false;
bool mixedValue = EditorGUI.showMixedValue;
EditorGUI.BeginChangeCheck();
var heightValue = heights.FirstOrDefault();
EditorGUI.showMixedValue = heights.All(h => Mathf.Approximately(h, heightValue)) == false;
heightValue = EditorGUILayout.Slider(Contents.heightLabel, heightValue, 0.1f, 4.0f);
if (EditorGUI.EndChangeCheck())
{
RegisterUndo("Inspector");
foreach (var index in selection)
{
m_Spline.SetHeight(index, heightValue);
}
}
List <int> startPoints = new List <int>();
var spriteIndexValue = ResolveSpriteIndex(spriteIndices, selection, ref startPoints);
if (spriteIndexValue != -1)
{
EditorGUI.BeginChangeCheck();
spriteSelector.ShowGUI(spriteIndexValue);
if (EditorGUI.EndChangeCheck())
{
RegisterUndo("Inspector");
foreach (var index in startPoints)
{
m_Spline.SetSpriteIndex(index, spriteSelector.selectedIndex);
}
}
}
EditorGUILayout.Space();
EditorGUI.BeginChangeCheck();
var cornerValue = corners.FirstOrDefault();
EditorGUI.showMixedValue = corners.All(v => (v == cornerValue)) == false;
cornerValue = EditorGUILayout.IntPopup(Contents.cornerLabel, cornerValue ? 1 : 0, Contents.cornerOptions, Contents.cornerValues) > 0;
if (EditorGUI.EndChangeCheck())
{
RegisterUndo("Inspector");
foreach (var index in selection)
{
m_Spline.SetCorner(index, cornerValue);
}
}
EditorGUI.showMixedValue = mixedValue;
}
private void DoTangentGUI()
{
ISelection selection = SplineEditorCache.GetSelection();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.PrefixLabel(Contents.pointModeLabel);
ShapeTangentMode?tangentMode = null;
if (selection.single != -1)
{
tangentMode = m_Spline.GetTangentMode(selection.single);
}
else
{
foreach (int index in selection)
{
if (tangentMode == null)
{
tangentMode = m_Spline.GetTangentMode(index);
}
else
{
if (tangentMode != m_Spline.GetTangentMode(index))
{
tangentMode = null;
break;
}
}
}
}
ShapeTangentMode?prevTangentMode = tangentMode;
GUIContent tangentStraightIcon = Contents.tangentStraightIcon;
GUIContent tangentCurvedIcon = Contents.tangentCurvedIcon;
GUIContent tangentAsymmetricIcon = Contents.tangentAsymmetricIcon;
if (EditorGUIUtility.isProSkin)
{
tangentStraightIcon = Contents.tangentStraightIconPro;
tangentCurvedIcon = Contents.tangentCurvedIconPro;
tangentAsymmetricIcon = Contents.tangentAsymmetricIconPro;
}
if (selection.single != -1)
{
if (GUILayout.Toggle(tangentMode == ShapeTangentMode.Linear, tangentStraightIcon, new GUIStyle("Button"), GUILayout.Height(23), GUILayout.Width(29)))
{
tangentMode = ShapeTangentMode.Linear;
}
if (GUILayout.Toggle(tangentMode == ShapeTangentMode.Continuous, tangentCurvedIcon, new GUIStyle("Button"), GUILayout.Height(23), GUILayout.Width(29)))
{
tangentMode = ShapeTangentMode.Continuous;
}
if (GUILayout.Toggle(tangentMode == ShapeTangentMode.Broken, tangentAsymmetricIcon, new GUIStyle("Button"), GUILayout.Height(23), GUILayout.Width(29)))
{
tangentMode = ShapeTangentMode.Broken;
}
if (tangentMode.HasValue && prevTangentMode.HasValue && tangentMode.Value != prevTangentMode.Value)
{
RegisterUndo("Edit Tangent Mode");
SpriteShapeTool.instance.SetTangentMode(selection.single, tangentMode.Value);
}
}
else
{
EditorGUI.BeginChangeCheck();
if (GUILayout.Toggle(tangentMode == ShapeTangentMode.Linear, tangentStraightIcon, new GUIStyle("Button"), GUILayout.Height(23), GUILayout.Width(29)))
{
tangentMode = ShapeTangentMode.Linear;
}
if (GUILayout.Toggle(tangentMode == ShapeTangentMode.Continuous, tangentCurvedIcon, new GUIStyle("Button"), GUILayout.Height(23), GUILayout.Width(29)))
{
tangentMode = ShapeTangentMode.Continuous;
}
if (GUILayout.Toggle(tangentMode == ShapeTangentMode.Broken, tangentAsymmetricIcon, new GUIStyle("Button"), GUILayout.Height(23), GUILayout.Width(29)))
{
tangentMode = ShapeTangentMode.Broken;
}
if (EditorGUI.EndChangeCheck())
{
if (tangentMode.HasValue && prevTangentMode.HasValue && tangentMode.Value != prevTangentMode.Value)
{
RegisterUndo("Edit Tangent Mode");
foreach (int index in selection)
{
SpriteShapeTool.instance.SetTangentMode(index, tangentMode.Value);
}
}
}
}
EditorGUILayout.EndHorizontal();
}
private void RegisterUndo()
{
Undo.RegisterCompleteObjectUndo(SplineEditorCache.GetTarget(), "Edit Sprite Shape");
}
private void InvalidateShapeEditor()
{
m_SplineEditor = null;
m_Spline = null;
SplineEditorCache.SetTarget(null);
}
