public override void OnToolGUI(EditorWindow window)
{
SceneViewOverlay.Window(k_ShapeTitle, OnOverlayGUI, 0, SceneViewOverlay.WindowDisplayOption.OneWindowPerTitle);
var evt = Event.current;
if (EditorHandleUtility.SceneViewInUse(evt))
{
return;
}
m_ControlID = GUIUtility.GetControlID(FocusType.Passive);
HandleUtility.AddDefaultControl(m_ControlID);
m_CurrentState = m_CurrentState.DoState(evt);
}
public override void OnToolGUI(EditorWindow window)
{
SceneViewOverlay.Window(k_ShapeTitle, OnOverlayGUI, 0, SceneViewOverlay.WindowDisplayOption.OneWindowPerTitle);
var evt = Event.current;
if (EditorHandleUtility.SceneViewInUse(evt))
{
return;
}
m_ControlID = GUIUtility.GetControlID(FocusType.Passive);
HandleUtility.AddDefaultControl(m_ControlID);
if (GUIUtility.hotControl == 0)
{
EditorGUIUtility.AddCursorRect(new Rect(0, 0, Screen.width, Screen.height), MouseCursor.ArrowPlus);
}
m_CurrentState = m_CurrentState.DoState(evt);
}
void DoExistingPointsGUI()
{
Transform trs = polygon.transform;
int len = polygon.m_Points.Count;
Vector3 up = polygon.transform.up;
Vector3 right = polygon.transform.right;
Vector3 forward = polygon.transform.forward;
Vector3 center = Vector3.zero;
Event evt = Event.current;
bool used = evt.type == EventType.Used;
if (!used &&
(evt.type == EventType.MouseDown &&
evt.button == 0 &&
!EditorHandleUtility.IsAppendModifier(evt.modifiers)))
{
m_SelectedIndex = -1;
Repaint();
}
if (polygon.polyEditMode == PolyShape.PolyEditMode.Height)
{
if (!used && evt.type == EventType.MouseUp && evt.button == 0 && !EditorHandleUtility.IsAppendModifier(evt.modifiers))
{
evt.Use();
SetPolyEditMode(PolyShape.PolyEditMode.Edit);
}
bool sceneInUse = EditorHandleUtility.SceneViewInUse(evt);
Ray r = HandleUtility.GUIPointToWorldRay(evt.mousePosition);
Vector3 origin = polygon.transform.TransformPoint(Math.Average(polygon.m_Points));
float extrude = polygon.extrude;
if (evt.type == EventType.MouseMove && !sceneInUse)
{
Vector3 p = Math.GetNearestPointRayRay(origin, up, r.origin, r.direction);
extrude = ProGridsInterface.ProGridsSnap(s_HeightMouseOffset + Vector3.Distance(origin, p) * Mathf.Sign(Vector3.Dot(p - origin, up)));
}
Vector3 extrudePoint = origin + (extrude * up);
Handles.color = k_HandleColor;
Handles.DotHandleCap(-1, origin, Quaternion.identity, HandleUtility.GetHandleSize(origin) * k_HandleSize, evt.type);
Handles.color = k_HandleColorGreen;
Handles.DrawLine(origin, extrudePoint);
Handles.DotHandleCap(-1, extrudePoint, Quaternion.identity, HandleUtility.GetHandleSize(extrudePoint) * k_HandleSize, evt.type);
Handles.color = Color.white;
if (!sceneInUse && polygon.extrude != extrude)
{
OnBeginVertexMovement();
polygon.extrude = extrude;
RebuildPolyShapeMesh(false);
}
}
else
{
// vertex dots
for (int ii = 0; ii < len; ii++)
{
Vector3 point = trs.TransformPoint(polygon.m_Points[ii]);
center.x += point.x;
center.y += point.y;
center.z += point.z;
float size = HandleUtility.GetHandleSize(point) * k_HandleSize;
Handles.color = ii == m_SelectedIndex ? k_HandleSelectedColor : k_HandleColor;
EditorGUI.BeginChangeCheck();
point = Handles.Slider2D(point, up, right, forward, size, Handles.DotHandleCap, Vector2.zero, true);
if (EditorGUI.EndChangeCheck())
{
UndoUtility.RecordObject(polygon, "Move Polygon Shape Point");
Vector3 snapMask = Snapping.GetSnappingMaskBasedOnNormalVector(m_Plane.normal);
polygon.m_Points[ii] = ProGridsInterface.ProGridsSnap(trs.InverseTransformPoint(point), snapMask);
OnBeginVertexMovement();
RebuildPolyShapeMesh(false);
}
// "clicked" a button
if (!used && evt.type == EventType.Used)
{
if (ii == 0 && polygon.m_Points.Count > 2 && polygon.polyEditMode == PolyShape.PolyEditMode.Path)
{
m_NextMouseUpAdvancesMode = true;
return;
}
else
{
used = true;
m_SelectedIndex = ii;
}
}
}
Handles.color = Color.white;
// height setting
if (polygon.polyEditMode != PolyShape.PolyEditMode.Path && polygon.m_Points.Count > 2)
{
center.x /= (float)len;
center.y /= (float)len;
center.z /= (float)len;
Vector3 extrude = center + (up * polygon.extrude);
m_DistanceFromHeightHandle = Vector2.Distance(HandleUtility.WorldToGUIPoint(extrude), evt.mousePosition);
EditorGUI.BeginChangeCheck();
Handles.color = k_HandleColor;
Handles.DotHandleCap(-1, center, Quaternion.identity, HandleUtility.GetHandleSize(center) * k_HandleSize, evt.type);
Handles.DrawLine(center, extrude);
Handles.color = k_HandleColorGreen;
extrude = Handles.Slider(extrude, up, HandleUtility.GetHandleSize(extrude) * k_HandleSize, Handles.DotHandleCap, 0f);
Handles.color = Color.white;
if (EditorGUI.EndChangeCheck())
{
UndoUtility.RecordObject(polygon, "Set Polygon Shape Height");
polygon.extrude = ProGridsInterface.ProGridsSnap(Vector3.Distance(extrude, center) * Mathf.Sign(Vector3.Dot(up, extrude - center)));
OnBeginVertexMovement();
RebuildPolyShapeMesh(false);
}
}
}
}
void OnSceneGUI()
{
if (polygon.polyEditMode == PolyShape.PolyEditMode.None)
{
return;
}
if (polygon == null || Tools.current != Tool.None)
{
SetPolyEditMode(PolyShape.PolyEditMode.None);
return;
}
if (m_LineMaterial != null)
{
m_LineMaterial.SetPass(0);
Graphics.DrawMeshNow(m_LineMesh, polygon.transform.localToWorldMatrix, 0);
}
Event evt = Event.current;
// used when finishing a loop by clicking the first created point
if (m_NextMouseUpAdvancesMode && evt.type == EventType.MouseUp)
{
evt.Use();
m_NextMouseUpAdvancesMode = false;
if (SceneCameraIsAlignedWithPolyUp())
{
SetPolyEditMode(PolyShape.PolyEditMode.Edit);
}
else
{
SetPolyEditMode(PolyShape.PolyEditMode.Height);
}
}
if (m_IsModifyingVertices && (
evt.type == EventType.MouseUp ||
evt.type == EventType.Ignore ||
evt.type == EventType.KeyDown ||
evt.type == EventType.KeyUp))
{
OnFinishVertexMovement();
}
DoExistingPointsGUI();
if (evt.type == EventType.KeyDown)
{
HandleKeyEvent(evt);
}
if (EditorHandleUtility.SceneViewInUse(evt))
{
return;
}
int controlID = GUIUtility.GetControlID(FocusType.Passive);
HandleUtility.AddDefaultControl(controlID);
DoPointPlacement();
}
/// <summary>
/// Main GUI update for the tool, calls every secondary methods to place points, update lines and compute the cut
/// </summary>
/// <param name="window">current window calling the tool : SceneView</param>
public override void OnToolGUI(EditorWindow window)
{
Event evt = Event.current;
SceneViewOverlay.Window(m_OverlayTitle, OnOverlayGUI, 0, SceneViewOverlay.WindowDisplayOption.OneWindowPerTitle);
if (polygon == null)
{
return;
}
if (polygon.polyEditMode == PolyShape.PolyEditMode.None)
{
return;
}
// used when finishing a loop by clicking the first created point
if (m_NextMouseUpAdvancesMode && evt.type == EventType.MouseUp)
{
evt.Use();
m_NextMouseUpAdvancesMode = false;
if (SceneCameraIsAlignedWithPolyUp())
{
SetPolyEditMode(PolyShape.PolyEditMode.Edit);
}
else
{
SetPolyEditMode(PolyShape.PolyEditMode.Height);
}
}
if (m_IsModifyingVertices && (
evt.type == EventType.MouseUp ||
evt.type == EventType.Ignore ||
evt.type == EventType.KeyDown ||
evt.type == EventType.KeyUp))
{
OnFinishVertexMovement();
}
if (evt.type == EventType.KeyDown)
{
HandleKeyEvent(evt);
}
//The user can press a key to exit editing mode,
//leading to null polygon at this point
if (polygon == null)
{
return;
}
if (EditorHandleUtility.SceneViewInUse(evt))
{
return;
}
m_ControlId = GUIUtility.GetControlID(FocusType.Passive);
if (evt.type == EventType.Layout)
{
HandleUtility.AddDefaultControl(m_ControlId);
}
if (polygon.polyEditMode == PolyShape.PolyEditMode.Path && !m_PlacingPoint)
{
m_MouseCursor = MouseCursor.ArrowPlus;
}
else if ((GUIUtility.hotControl != 0) || m_PlacingPoint)
{
m_MouseCursor = MouseCursor.MoveArrow;
}
else
{
m_MouseCursor = MouseCursor.Arrow;
}
if (evt.type == EventType.MouseMove)
{
SceneView.RepaintAll();
}
DoPointPlacement();
DoExistingPointsGUI();
if (evt.type == EventType.Repaint)
{
DoExistingLinesGUI();
Rect sceneViewRect = window.position;
sceneViewRect.x = 0;
sceneViewRect.y = 0;
SceneView.AddCursorRect(sceneViewRect, m_MouseCursor);
}
}
void OnSceneGUI(SceneView sceneView)
{
#if !UNITY_2018_2_OR_NEWER
if (s_ResetOnSceneGUIState != null)
{
s_ResetOnSceneGUIState.Invoke(sceneView, null);
}
#endif
SceneStyles.Init();
m_CurrentEvent = Event.current;
EditorMeshHandles.DrawSceneHandles(SceneDragAndDropListener.isDragging ? SelectMode.None : selectMode);
DrawHandleGUI(sceneView);
#if SHORTCUT_MANAGER
// Escape isn't assignable as a shortcut
if (m_CurrentEvent.type == EventType.KeyDown)
{
if (m_CurrentEvent.keyCode == KeyCode.Escape && selectMode != SelectMode.Object)
{
selectMode = SelectMode.Object;
m_CurrentEvent.Use();
}
}
#else
if (m_CurrentEvent.type == EventType.MouseDown && m_CurrentEvent.button == 1)
{
m_IsRightMouseDown = true;
}
if (m_CurrentEvent.type == EventType.MouseUp && m_CurrentEvent.button == 1 || m_CurrentEvent.type == EventType.Ignore)
{
m_IsRightMouseDown = false;
}
if (!m_IsRightMouseDown && (m_CurrentEvent.type == EventType.KeyUp ? m_CurrentEvent.keyCode : KeyCode.None) != KeyCode.None)
{
if (ShortcutCheck(m_CurrentEvent))
{
m_CurrentEvent.Use();
return;
}
}
if (m_CurrentEvent.type == EventType.KeyDown)
{
if (s_Shortcuts.value.Any(x => x.Matches(m_CurrentEvent.keyCode, m_CurrentEvent.modifiers)))
{
m_CurrentEvent.Use();
}
}
#endif
if (selectMode == SelectMode.Object)
{
return;
}
// Check mouse position in scene and determine if we should highlight something
if (s_ShowHoverHighlight &&
m_CurrentEvent.type == EventType.MouseMove &&
selectMode.IsMeshElementMode())
{
m_Hovering.CopyTo(m_HoveringPrevious);
if (GUIUtility.hotControl != 0 ||
EditorSceneViewPicker.MouseRayHitTest(m_CurrentEvent.mousePosition, selectMode, m_ScenePickerPreferences, m_Hovering) > ScenePickerPreferences.maxPointerDistance)
{
m_Hovering.Clear();
}
if (!m_Hovering.Equals(m_HoveringPrevious))
{
SceneView.RepaintAll();
}
}
if (Tools.current == Tool.View)
{
return;
}
// Overrides the toolbar transform tools
if (Tools.current != Tool.None && Tools.current != m_CurrentTool)
{
SetTool_Internal(Tools.current);
}
Tools.current = Tool.None;
if (selectMode.IsMeshElementMode() && MeshSelection.selectedVertexCount > 0)
{
var tool = GetToolForSelectMode(m_CurrentTool, s_SelectMode);
if (tool != null)
{
tool.OnSceneGUI(m_CurrentEvent);
}
}
if (EditorHandleUtility.SceneViewInUse(m_CurrentEvent) || m_CurrentEvent.isKey)
{
m_IsDragging = false;
if (GUIUtility.hotControl == m_DefaultControl)
{
GUIUtility.hotControl = 0;
}
return;
}
// This prevents us from selecting other objects in the scene,
// and allows for the selection of faces / vertices.
m_DefaultControl = GUIUtility.GetControlID(FocusType.Passive);
HandleUtility.AddDefaultControl(m_DefaultControl);
if (m_CurrentEvent.type == EventType.MouseDown && HandleUtility.nearestControl == m_DefaultControl)
{
// double clicking object
if (m_CurrentEvent.clickCount > 1)
{
DoubleClick(m_CurrentEvent);
}
m_InitialMousePosition = m_CurrentEvent.mousePosition;
// readyForMouseDrag prevents a bug wherein after ending a drag an errant
// MouseDrag event is sent with no corresponding MouseDown/MouseUp event.
m_IsReadyForMouseDrag = true;
GUIUtility.hotControl = m_DefaultControl;
}
if (m_CurrentEvent.type == EventType.MouseDrag && m_IsReadyForMouseDrag && GUIUtility.hotControl == m_DefaultControl)
{
if (!m_IsDragging && Vector2.Distance(m_CurrentEvent.mousePosition, m_InitialMousePosition) > k_MouseDragThreshold)
{
sceneView.Repaint();
m_IsDragging = true;
}
}
if (m_CurrentEvent.type == EventType.Ignore)
{
if (m_IsDragging)
{
m_IsReadyForMouseDrag = false;
m_IsDragging = false;
EditorSceneViewPicker.DoMouseDrag(m_MouseDragRect, selectMode, m_ScenePickerPreferences);
}
if (m_WasDoubleClick)
{
m_WasDoubleClick = false;
}
if (GUIUtility.hotControl == m_DefaultControl)
{
GUIUtility.hotControl = 0;
}
}
if (m_CurrentEvent.type == EventType.MouseUp && GUIUtility.hotControl == m_DefaultControl)
{
GUIUtility.hotControl = 0;
if (m_WasDoubleClick)
{
m_WasDoubleClick = false;
}
else
{
if (!m_IsDragging)
{
if (UVEditor.instance)
{
UVEditor.instance.ResetUserPivot();
}
EditorSceneViewPicker.DoMouseClick(m_CurrentEvent, selectMode, m_ScenePickerPreferences);
UpdateSelection();
SceneView.RepaintAll();
}
else
{
m_IsDragging = false;
m_IsReadyForMouseDrag = false;
if (UVEditor.instance)
{
UVEditor.instance.ResetUserPivot();
}
EditorSceneViewPicker.DoMouseDrag(m_MouseDragRect, selectMode, m_ScenePickerPreferences);
if (GUIUtility.hotControl == m_DefaultControl)
{
GUIUtility.hotControl = 0;
}
}
}
}
}
void OnSceneGUI()
{
Event e = Event.current;
bool eventHasBeenUsed = false;
if (m_IsMoving)
{
if (e.type == EventType.Ignore ||
e.type == EventType.MouseUp)
{
eventHasBeenUsed = true;
OnFinishVertexModification();
}
}
bool sceneViewInUse = EditorHandleUtility.SceneViewInUse(e);
if (e.type == EventType.KeyDown)
{
if (e.keyCode == KeyCode.Backspace && m_currentHandle > -1 && m_currentHandle < m_Points.Count)
{
UndoUtility.RecordObject(m_Target, "Delete Bezier Point");
m_Points.RemoveAt(m_currentHandle);
UpdateMesh(true);
}
else if (e.keyCode == KeyCode.Escape)
{
SetIsEditing(false);
}
}
int count = m_Points.Count;
Matrix4x4 handleMatrix = Handles.matrix;
Handles.matrix = m_Target.transform.localToWorldMatrix;
EditorGUI.BeginChangeCheck();
for (int index = 0; index < count; index++)
{
if (index < count - 1 || m_CloseLoop)
{
Handles.DrawBezier(m_Points[index].position,
m_Points[(index + 1) % count].position,
m_Points[index].tangentOut,
m_Points[(index + 1) % count].tangentIn,
Color.green,
EditorGUIUtility.whiteTexture,
1f);
}
if (!m_IsEditing)
{
continue;
}
// If the index is selected show the full transform gizmo, otherwise use free move handles
if (m_currentHandle == index)
{
BezierPoint point = m_Points[index];
if (!m_currentHandle.isTangent)
{
Vector3 prev = point.position;
prev = Handles.PositionHandle(prev, Quaternion.identity);
if (!Math.Approx3(prev, point.position))
{
if (!m_IsMoving)
{
OnBeginVertexModification();
}
prev = EditorSnapping.MoveSnap(prev);
Vector3 dir = prev - point.position;
point.position = prev;
point.tangentIn += dir;
point.tangentOut += dir;
}
// rotation
int prev_index = index > 0 ? index - 1 : (m_CloseLoop ? count - 1 : -1);
int next_index = index < count - 1 ? index + 1 : (m_CloseLoop ? 0 : -1);
Vector3 rd = BezierPoint.GetLookDirection(m_Points, index, prev_index, next_index);
Quaternion look = Quaternion.LookRotation(rd);
float size = HandleUtility.GetHandleSize(point.position);
Matrix4x4 pm = Handles.matrix;
Handles.matrix = pm * Matrix4x4.TRS(point.position, look, Vector3.one);
point.rotation = Handles.Disc(point.rotation, Vector3.zero, Vector3.forward, size, false, 0f);
Handles.matrix = pm;
}
else
{
Handles.color = bezierTangentHandleColor;
if (m_currentHandle.tangent == BezierTangentDirection.In && (m_CloseLoop || index > 0))
{
EditorGUI.BeginChangeCheck();
point.tangentIn = Handles.PositionHandle(point.tangentIn, Quaternion.identity);
if (EditorGUI.EndChangeCheck())
{
if (!m_IsMoving)
{
OnBeginVertexModification();
}
point.tangentIn = EditorSnapping.MoveSnap(point.tangentIn);
point.EnforceTangentMode(BezierTangentDirection.In, m_TangentMode);
}
Handles.color = Color.blue;
Handles.DrawLine(m_Points[index].position, m_Points[index].tangentIn);
}
if (m_currentHandle.tangent == BezierTangentDirection.Out && (m_CloseLoop || index < count - 1))
{
EditorGUI.BeginChangeCheck();
point.tangentOut = Handles.PositionHandle(point.tangentOut, Quaternion.identity);
if (EditorGUI.EndChangeCheck())
{
if (!m_IsMoving)
{
OnBeginVertexModification();
}
point.tangentOut = EditorSnapping.MoveSnap(point.tangentOut);
point.EnforceTangentMode(BezierTangentDirection.Out, m_TangentMode);
}
Handles.color = Color.red;
Handles.DrawLine(m_Points[index].position, m_Points[index].tangentOut);
}
}
m_Points[index] = point;
}
}
if (!m_IsEditing)
{
return;
}
EventType eventType = e.type;
if (!eventHasBeenUsed)
{
eventHasBeenUsed = eventType == EventType.Used;
}
for (int index = 0; index < count; index++)
{
Vector3 prev;
BezierPoint point = m_Points[index];
// Position Handle
float size = HandleUtility.GetHandleSize(point.position) * k_HandleSize;
Handles.color = bezierPositionHandleColor;
if (m_currentHandle == index && !m_currentHandle.isTangent)
{
Handles.DotHandleCap(0, point.position, Quaternion.identity, size, e.type);
}
else
{
prev = point.position;
prev = Handles.FreeMoveHandle(prev, Quaternion.identity, size, Vector3.zero, Handles.DotHandleCap);
if (!eventHasBeenUsed && eventType == EventType.MouseUp && e.type == EventType.Used)
{
eventHasBeenUsed = true;
m_currentHandle = (BezierHandle)index;
Repaint();
SceneView.RepaintAll();
}
else if (!Math.Approx3(prev, point.position))
{
if (!m_IsMoving)
{
OnBeginVertexModification();
}
point.SetPosition(EditorSnapping.MoveSnap(prev));
}
}
// Tangent handles
Handles.color = bezierTangentHandleColor;
// Tangent In Handle
if (m_CloseLoop || index > 0)
{
size = HandleUtility.GetHandleSize(point.tangentIn) * k_HandleSize;
Handles.DrawLine(point.position, point.tangentIn);
if (index == m_currentHandle && m_currentHandle.isTangent && m_currentHandle.tangent == BezierTangentDirection.In)
{
Handles.DotHandleCap(0, point.tangentIn, Quaternion.identity, size, e.type);
}
else
{
prev = point.tangentIn;
prev = Handles.FreeMoveHandle(prev, Quaternion.identity, size, Vector3.zero, Handles.DotHandleCap);
if (!eventHasBeenUsed && eventType == EventType.MouseUp && e.type == EventType.Used)
{
eventHasBeenUsed = true;
m_currentHandle.SetIndexAndTangent(index, BezierTangentDirection.In);
Repaint();
SceneView.RepaintAll();
}
else if (!Math.Approx3(prev, point.tangentIn))
{
if (!m_IsMoving)
{
OnBeginVertexModification();
}
point.tangentIn = EditorSnapping.MoveSnap(prev);
point.EnforceTangentMode(BezierTangentDirection.In, m_TangentMode);
}
}
}
// Tangent Out
if (m_CloseLoop || index < count - 1)
{
size = HandleUtility.GetHandleSize(point.tangentOut) * k_HandleSize;
Handles.DrawLine(point.position, point.tangentOut);
if (index == m_currentHandle && m_currentHandle.isTangent && m_currentHandle.tangent == BezierTangentDirection.Out)
{
Handles.DotHandleCap(0, point.tangentOut, Quaternion.identity, size, e.type);
}
else
{
prev = point.tangentOut;
prev = Handles.FreeMoveHandle(prev, Quaternion.identity, size, Vector3.zero, Handles.DotHandleCap);
if (!eventHasBeenUsed && eventType == EventType.MouseUp && e.type == EventType.Used)
{
eventHasBeenUsed = true;
m_currentHandle.SetIndexAndTangent(index, BezierTangentDirection.Out);
Repaint();
SceneView.RepaintAll();
}
else if (!Math.Approx3(prev, point.tangentOut))
{
if (!m_IsMoving)
{
OnBeginVertexModification();
}
point.tangentOut = EditorSnapping.MoveSnap(prev);
point.EnforceTangentMode(BezierTangentDirection.Out, m_TangentMode);
}
}
}
m_Points[index] = point;
}
// Do control point insertion
if (!eventHasBeenUsed && m_ControlPoints != null && m_ControlPoints.Count > 1)
{
int index = -1;
float distanceToLine;
Vector3 p = EditorHandleUtility.ClosestPointToPolyLine(m_ControlPoints, out index, out distanceToLine, false, null);
if (!IsHoveringHandlePoint(e.mousePosition) && distanceToLine < PreferenceKeys.k_MaxPointDistanceFromControl)
{
Handles.color = Color.green;
Handles.DotHandleCap(-1, p, Quaternion.identity, HandleUtility.GetHandleSize(p) * .05f, e.type);
Handles.color = Color.white;
if (!eventHasBeenUsed && eventType == EventType.MouseDown && e.button == 0)
{
UndoUtility.RecordObject(m_Target, "Add Point");
Vector3 dir = m_ControlPoints[(index + 1) % m_ControlPoints.Count] - m_ControlPoints[index];
m_Points.Insert((index / m_Columns) + 1, new BezierPoint(p, p - dir, p + dir, Quaternion.identity));
UpdateMesh(true);
e.Use();
}
SceneView.RepaintAll();
}
}
if (e.type == EventType.MouseUp && !sceneViewInUse)
{
m_currentHandle.SetIndex(-1);
}
Handles.matrix = handleMatrix;
if (EditorGUI.EndChangeCheck())
{
UpdateMesh(false);
}
}
void OnSceneGUI(SceneView sceneView)
{
SceneStyles.Init();
m_CurrentEvent = Event.current;
EditorHandleDrawing.DrawSceneHandles(SceneDragAndDropListener.isDragging ? SelectMode.None : selectMode);
DrawHandleGUI(sceneView);
if (m_CurrentEvent.type == EventType.KeyDown)
{
// Escape isn't assignable as a shortcut
if (m_CurrentEvent.keyCode == KeyCode.Escape && selectMode != SelectMode.Object)
{
selectMode = SelectMode.Object;
m_IsDragging = false;
m_IsReadyForMouseDrag = false;
m_CurrentEvent.Use();
}
}
if (selectMode == SelectMode.Object)
{
return;
}
bool pathSelectionModifier = EditorHandleUtility.IsSelectionPathModifier(m_CurrentEvent.modifiers);
// Check mouse position in scene and determine if we should highlight something
if (s_ShowHoverHighlight &&
selectMode.IsMeshElementMode() &&
(m_CurrentEvent.type == EventType.MouseMove ||
(m_wasSelectingPath != pathSelectionModifier && m_CurrentEvent.isKey)))
{
m_Hovering.CopyTo(m_HoveringPrevious);
if (GUIUtility.hotControl != 0 ||
EditorSceneViewPicker.MouseRayHitTest(m_CurrentEvent.mousePosition, selectMode, m_ScenePickerPreferences, m_Hovering) > ScenePickerPreferences.maxPointerDistance)
{
m_Hovering.Clear();
}
if (!m_Hovering.Equals(m_HoveringPrevious))
{
if (pathSelectionModifier)
{
EditorSceneViewPicker.DoMouseHover(m_Hovering);
}
SceneView.RepaintAll();
}
}
m_wasSelectingPath = pathSelectionModifier;
if (Tools.current == Tool.View)
{
return;
}
switch (m_CurrentEvent.type)
{
case EventType.ValidateCommand:
case EventType.ExecuteCommand:
bool execute = m_CurrentEvent.type == EventType.ExecuteCommand;
switch (m_CurrentEvent.commandName)
{
case "SelectAll":
if (execute)
{
SelectAll();
}
m_CurrentEvent.Use();
break;
case "DeselectAll":
if (execute)
{
DeselectAll();
}
m_CurrentEvent.Use();
break;
case "InvertSelection":
if (execute)
{
InvertSelection();
}
m_CurrentEvent.Use();
break;
}
break;
}
if (EditorHandleUtility.SceneViewInUse(m_CurrentEvent))
{
if (m_IsDragging)
{
m_IsDragging = false;
}
if (GUIUtility.hotControl == m_DefaultControl)
{
GUIUtility.hotControl = 0;
}
return;
}
// This prevents us from selecting other objects in the scene,
// and allows for the selection of faces / vertices.
m_DefaultControl = GUIUtility.GetControlID(FocusType.Passive);
if (Event.current.type == EventType.Layout)
{
HandleUtility.AddDefaultControl(m_DefaultControl);
}
if (m_CurrentEvent.type == EventType.MouseDown && HandleUtility.nearestControl == m_DefaultControl)
{
// double clicking object
if (m_CurrentEvent.clickCount > 1)
{
DoubleClick(m_CurrentEvent);
}
m_InitialMousePosition = m_CurrentEvent.mousePosition;
// readyForMouseDrag prevents a bug wherein after ending a drag an errant
// MouseDrag event is sent with no corresponding MouseDown/MouseUp event.
m_IsReadyForMouseDrag = true;
GUIUtility.hotControl = m_DefaultControl;
}
if (m_CurrentEvent.type == EventType.MouseDrag && m_IsReadyForMouseDrag && GUIUtility.hotControl == m_DefaultControl)
{
if (!m_IsDragging && Vector2.Distance(m_CurrentEvent.mousePosition, m_InitialMousePosition) > k_MouseDragThreshold)
{
sceneView.Repaint();
m_IsDragging = true;
}
}
if (m_CurrentEvent.type == EventType.Ignore)
{
if (m_IsDragging)
{
m_IsReadyForMouseDrag = false;
m_IsDragging = false;
EditorSceneViewPicker.DoMouseDrag(m_MouseDragRect, selectMode, m_ScenePickerPreferences);
}
if (m_WasDoubleClick)
{
m_WasDoubleClick = false;
}
if (GUIUtility.hotControl == m_DefaultControl)
{
GUIUtility.hotControl = 0;
}
}
if (m_CurrentEvent.type == EventType.MouseUp && GUIUtility.hotControl == m_DefaultControl)
{
GUIUtility.hotControl = 0;
if (m_WasDoubleClick)
{
m_WasDoubleClick = false;
}
else
{
if (!m_IsDragging)
{
if (UVEditor.instance)
{
UVEditor.instance.ResetUserPivot();
}
EditorSceneViewPicker.DoMouseClick(m_CurrentEvent, selectMode, m_ScenePickerPreferences);
UpdateSelection();
}
else
{
m_IsDragging = false;
m_IsReadyForMouseDrag = false;
if (UVEditor.instance)
{
UVEditor.instance.ResetUserPivot();
}
EditorSceneViewPicker.DoMouseDrag(m_MouseDragRect, selectMode, m_ScenePickerPreferences);
if (GUIUtility.hotControl == m_DefaultControl)
{
GUIUtility.hotControl = 0;
}
}
}
}
}
void OnSceneGUI(SceneView sceneView)
{
SceneStyles.Init();
m_CurrentEvent = Event.current;
EditorHandleDrawing.DrawSceneHandles(SceneDragAndDropListener.isDragging ? SelectMode.None : selectMode);
DrawHandleGUI(sceneView);
if (m_CurrentEvent.type == EventType.KeyDown)
{
// Escape isn't assignable as a shortcut
if (m_CurrentEvent.keyCode == KeyCode.Escape && selectMode != SelectMode.Object)
{
selectMode = SelectMode.Object;
m_IsDragging = false;
m_IsReadyForMouseDrag = false;
m_CurrentEvent.Use();
}
}
if (selectMode == SelectMode.Object)
{
return;
}
bool pathSelectionModifier = EditorHandleUtility.IsSelectionPathModifier(m_CurrentEvent.modifiers);
// Check mouse position in scene and determine if we should highlight something
if (s_ShowHoverHighlight &&
selectMode.IsMeshElementMode() &&
(m_CurrentEvent.type == EventType.MouseMove ||
(m_wasSelectingPath != pathSelectionModifier && m_CurrentEvent.isKey)))
{
m_Hovering.CopyTo(m_HoveringPrevious);
if (GUIUtility.hotControl != 0 ||
EditorSceneViewPicker.MouseRayHitTest(m_CurrentEvent.mousePosition, selectMode, m_ScenePickerPreferences, m_Hovering) > ScenePickerPreferences.maxPointerDistance)
{
m_Hovering.Clear();
}
if (!m_Hovering.Equals(m_HoveringPrevious))
{
if (pathSelectionModifier)
{
EditorSceneViewPicker.DoMouseHover(m_Hovering);
}
SceneView.RepaintAll();
}
}
m_wasSelectingPath = pathSelectionModifier;
if (Tools.current == Tool.View)
{
return;
}
switch (m_CurrentEvent.type)
{
case EventType.ValidateCommand:
case EventType.ExecuteCommand:
bool execute = m_CurrentEvent.type == EventType.ExecuteCommand;
switch (m_CurrentEvent.commandName)
{
case "SelectAll":
if (execute)
{
SelectAll();
}
m_CurrentEvent.Use();
break;
case "DeselectAll":
if (execute)
{
DeselectAll();
}
m_CurrentEvent.Use();
break;
case "InvertSelection":
if (execute)
{
InvertSelection();
}
m_CurrentEvent.Use();
break;
}
break;
}
if (EditorHandleUtility.SceneViewInUse(m_CurrentEvent))
{
if (m_IsDragging)
{
m_IsDragging = false;
}
if (GUIUtility.hotControl == m_DefaultControl)
{
GUIUtility.hotControl = 0;
}
return;
}
// This prevents us from selecting other objects in the scene,
// and allows for the selection of faces / vertices.
m_DefaultControl = GUIUtility.GetControlID(FocusType.Passive);
if (Event.current.type == EventType.Layout)
{
HandleUtility.AddDefaultControl(m_DefaultControl);
}
HandleMouseEvent(sceneView, m_DefaultControl);
}
