void SetupInputPlane(Vector2 mousePosition)
{
plane = EditorHandleUtility.FindBestPlane(mousePosition);
var planeNormal = plane.normal;
var planeCenter = plane.normal * -plane.distance;
// if hit point on plane is cardinal axis and on grid, snap to grid.
if (Math.IsCardinalAxis(planeNormal))
{
const float epsilon = .00001f;
bool offGrid = false;
Vector3 snapVal = EditorSnapping.activeMoveSnapValue;
Vector3 center = Vector3.Scale(ProBuilderSnapping.GetSnappingMaskBasedOnNormalVector(planeNormal), planeCenter);
for (int i = 0; i < 3; i++)
{
offGrid |= Mathf.Abs(snapVal[i] % center[i]) > epsilon;
}
polygon.isOnGrid = !offGrid;
}
else
{
polygon.isOnGrid = false;
}
}
// Returns a local space point,
Vector3 GetPointInLocalSpace(Vector3 point)
{
var trs = polygon.transform;
if (polygon.isOnGrid)
{
Vector3 snapMask = ProBuilderSnapping.GetSnappingMaskBasedOnNormalVector(plane.normal);
return(trs.InverseTransformPoint(ProBuilderSnapping.Snap(point, Vector3.Scale(EditorSnapping.activeMoveSnapValue, snapMask))));
}
return(trs.InverseTransformPoint(point));
}
// Returns a local space point,
Vector3 GetPointInLocalSpace(Vector3 point)
{
var trs = polygon.transform;
if (polygon.isOnGrid)
{
Vector3 snapMask = ProBuilderSnapping.GetSnappingMaskBasedOnNormalVector(m_Plane.normal);
return(trs.InverseTransformPoint(ProGridsInterface.ProGridsSnap(point, snapMask)));
}
return(trs.InverseTransformPoint(point));
}
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);
if (m_DrawHeightHandles)
{
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 = ProBuilderSnapping.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();
if (m_DrawHeightHandles)
{
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);
}
}
}
}
public override ShapeState DoState(Event evt)
{
if (evt.type == EventType.KeyDown)
{
switch (evt.keyCode)
{
case KeyCode.Escape:
ToolManager.RestorePreviousTool();
break;
}
}
if (tool.m_LastShapeCreated != null)
{
EditShapeTool.DoEditingHandles(tool.m_LastShapeCreated, true);
}
if (evt.isMouse && HandleUtility.nearestControl == tool.controlID)
{
var res = EditorHandleUtility.FindBestPlaneAndBitangent(evt.mousePosition);
Ray ray = HandleUtility.GUIPointToWorldRay(evt.mousePosition);
float hit;
if (res.item1.Raycast(ray, out hit))
{
//Plane init
tool.m_Plane = res.item1;
tool.m_PlaneForward = res.item2;
tool.m_PlaneRight = Vector3.Cross(tool.m_Plane.normal, tool.m_PlaneForward);
var planeNormal = tool.m_Plane.normal;
var planeCenter = tool.m_Plane.normal * -tool.m_Plane.distance;
// if hit point on plane is cardinal axis and on grid, snap to grid.
if (Math.IsCardinalAxis(planeNormal))
{
const float epsilon = .00001f;
bool offGrid = false;
Vector3 snapVal = EditorSnapping.activeMoveSnapValue;
Vector3 center =
Vector3.Scale(ProBuilderSnapping.GetSnappingMaskBasedOnNormalVector(planeNormal),
planeCenter);
for (int i = 0; i < 3; i++)
{
offGrid |= Mathf.Abs(snapVal[i] % center[i]) > epsilon;
}
tool.m_IsOnGrid = !offGrid;
}
else
{
tool.m_IsOnGrid = false;
}
m_HitPosition = tool.GetPoint(ray.GetPoint(hit));
//Click has been done => Define a plane for the tool
if (evt.type == EventType.MouseDown)
{
//BB init
tool.m_BB_Origin = m_HitPosition;
tool.m_BB_HeightCorner = tool.m_BB_Origin;
tool.m_BB_OppositeCorner = tool.m_BB_Origin;
return(NextState());
}
}
else
{
m_HitPosition = Vector3.negativeInfinity;
}
}
if (GUIUtility.hotControl == 0 && evt.shift && !(evt.control || evt.command))
{
tool.DuplicatePreview(m_HitPosition);
}
else if (tool.m_DuplicateGO != null)
{
Object.DestroyImmediate(tool.m_DuplicateGO);
}
// Repaint to visualize the placement preview dot
if (evt.type == EventType.MouseMove && HandleUtility.nearestControl == tool.controlID)
{
HandleUtility.Repaint();
}
if (evt.type == EventType.Repaint)
{
if (GUIUtility.hotControl == 0 && HandleUtility.nearestControl == tool.controlID)
{
using (new Handles.DrawingScope(EditorHandleDrawing.vertexSelectedColor))
{
Handles.DotHandleCap(-1, m_HitPosition, Quaternion.identity,
HandleUtility.GetHandleSize(m_HitPosition) * 0.05f, EventType.Repaint);
}
}
if (GUIUtility.hotControl == 0 && evt.shift && !(evt.control || evt.command))
{
tool.DrawBoundingBox(false);
}
}
return(this);
}
