Question

这是来自How to make individual anchor points of bezier continuous or non-continuous的后续问题。请参考已接受答案中的相关代码（请注意，由于相关代码很长，我这样做是为了保持问题的清晰性。）

我正在努力实现以下目标：

以如下方式选择贝塞尔曲线手柄/控制点，即在选中时在检查器窗口中显示单个手柄的属性（例如连续性）。请注意，我希望在不为手柄/控制点创建游戏对象的情况下完成此操作
保留用于处理每个点的移动的单个方法，而不是为每个点的移动使用单独的方法。

Answer 1

我要晚参加聚会吗？

以如下方式选择贝塞尔曲线手柄/控制点：选中时，在检查器窗口中显示单个手柄的属性（例如连续性）。请注意，我希望在不为手柄/控制点创建游戏对象的情况下完成此操作

除了一件事，我总体上喜欢@jour的解决方案：使用Handles.Button必须单击一个点以将其选中，然后单击然后单击并拖动以移动控制点。 / p>

我提出了另一种方法。使用相同的Handles.FreeMoveHandle，但有一个变量可以记住上次单击的句柄的ID，因此我可以识别它。

通常，内置的Handle不会为您提供比其设计目的更多的信息。例如，FreeMoveHandle返回其翻译的增量，仅此而已。问题是：您想捕获一个简单的单击，但是如果您只是单击但没有拖动，则返回值为Vector3.zero，这与您根本没有单击一样。

好消息：在任何Handle的重载中，有一些调用带有名为controlID的参数-它是每个可交互GUI对象的标识符。如果您抑制它，引擎将选择一个，而您将永远不会知道。但是，如果您传递一个int，则该值将成为该句柄的ID。 但是，如果我传递一个int值并且碰巧与我看不到的其他任何id发生冲突？那么，您可以致电GUIUtility.GetControlID以获得安全的ID。

然后，它很简单。如果Handle的ID与EditorGUIUtility.hotControl相同（即被单击或具有键盘焦点的控件），那么我将此点的索引保存在selectedControlPointId中并用它来显示Inspector中的自定义属性。

保留用于处理每个点的移动的单个方法，而不是为每个点的移动使用单独的方法。

嗯...在这里引起争议。如果我理解正确，则您希望使用一个代码来绘制节点和切线。问题是：这两件事本质上是不同的。当然，如果保持简洁明了，它们是场景中机器人可移动的点。但是，当您引入约束（连续性或smooth）和选择之类的东西时，它们变成具有不同逻辑的不同野兽。即使您要将ControlPoint设为struct（就像我现在所做的那样）并将其作为一个整体传递，您仍然需要指出要更新的组件，因此约束将应用于其他对象-您将始终需要一个“主”字段来避免循环更新（您更改tangentBack，这会使tangentFront进行更新，从而触发tangentBack进行更新，依此类推上）。

这就是为什么即使我以某种方式重组了ControlPoint方法并使其成为struct的原因，我也无法用单一的逻辑来绘制节点和切线。

这是一些代码。我从上一个问题中的my answer上的代码开始。

ControlPoint.cs

using System;
using UnityEngine;

[Serializable]
public struct ControlPoint
{
  public Vector2 position;
  public Vector2 tangentBack;
  public Vector2 tangentFront;
  public bool smooth;

  static public ControlPoint MovePosition(ControlPoint pt, Vector2 newPos)
  {
    var newPt = pt;
    newPt.position = newPos;
    return newPt;
  }

  static public ControlPoint MoveTangentBack(ControlPoint pt, Vector2 newTanBack)
  {
    var newPt = pt;
    newPt.tangentBack = newTanBack;
    if (pt.smooth) newPt.tangentFront = pt.tangentFront.magnitude * -newTanBack.normalized;
    return newPt;
  }
  static public ControlPoint MoveTangentFront(ControlPoint pt, Vector2 newTanFront)
  {
    var newPt = pt;
    newPt.tangentFront = newTanFront;
    if (pt.smooth) newPt.tangentBack = pt.tangentBack.magnitude * -newTanFront.normalized;
    return newPt;
  }

  static public ControlPoint WithSmooth(ControlPoint pt, bool smooth)
  {
    var newPt = pt;
    if (smooth != pt.smooth) newPt.tangentBack = -pt.tangentFront;
    return newPt;

  }

  public ControlPoint(Vector2 position, Vector2 tanBack, Vector2 tanFront, bool smooth = false)
  {
    this.position = position;
    this.tangentBack = tanBack;
    this.tangentFront = tanFront;
    this.smooth = smooth;
  }
}

我删除了ControlPointDrawer，因此您添加到其中的其他属性不会隐藏在检查器中。

Path.cs

using System;
using UnityEngine;
using System.Collections.Generic;

[Serializable]
public class Path
{
  [SerializeField] List<ControlPoint> _points;

  [SerializeField] bool _loop = false;

  public Path(Vector2 position)
  {
    _points = new List<ControlPoint>
    {
      new ControlPoint(position, -Vector2.one, Vector2.one),
      new ControlPoint(position + Vector2.right, -Vector2.one, Vector2.one)
    };
  }

  public bool loop { get { return _loop; } set { _loop = value; } }

  public ControlPoint this[int i]
  {
    get { return _points[(_loop && i == _points.Count) ? 0 : i]; }
    set { _points[(_loop && i == _points.Count) ? 0 : i] = value; }
  }

  public int NumPoints { get { return _points.Count; } }

  public int NumSegments { get { return _points.Count - (_loop ? 0 : 1); } }

  public ControlPoint InsertPoint(int i, Vector2 position)
  {
    _points.Insert(i, new ControlPoint(position, -Vector2.one, Vector2.one));
    return this[i];
  }
  public ControlPoint RemovePoint(int i)
  {
    var item = this[i];
    _points.RemoveAt(i);
    return item;
  }
  public Vector2[] GetBezierPointsInSegment(int i)
  {
    var pointBack = this[i];
    var pointFront = this[i + 1];
    return new Vector2[4]
    {
      pointBack.position,
      pointBack.position + pointBack.tangentFront,
      pointFront.position + pointFront.tangentBack,
      pointFront.position
    };
  }

  public ControlPoint MovePoint(int i, Vector2 position)
  {
    this[i] = ControlPoint.MovePosition(this[i], position);
    return this[i];
  }

  public ControlPoint MoveTangentBack(int i, Vector2 position)
  {
    this[i] = ControlPoint.MoveTangentBack(this[i], position);
    return this[i];
  }

  public ControlPoint MoveTangentFront(int i, Vector2 position)
  {
    this[i] = ControlPoint.MoveTangentFront(this[i], position);
    return this[i];
  }
}

PathCreator.cs 相同

PathCreatorEditor.cs

using UnityEngine;
using UnityEditor;

[CustomEditor(typeof(PathCreator))]
public class PathCreatorEditor : Editor
{
  PathCreator creator;
  Path path;
  SerializedProperty property;
  static int selectedControlPointId = -1;

  public override void OnInspectorGUI()
  {
    serializedObject.Update();
    var loopProp = property.FindPropertyRelative("_loop");
    EditorGUI.BeginChangeCheck();
    EditorGUILayout.PropertyField(loopProp);
    var ptsProp = property.FindPropertyRelative("_points");
    var msg = "Total points in path: " + ptsProp.arraySize + "\n";
    if (selectedControlPointId >= 0 && ptsProp.arraySize > 0)
    {
      EditorGUILayout.HelpBox(msg + "Selected control point: " + selectedControlPointId, MessageType.Info);
      EditorGUILayout.Separator();
      EditorGUILayout.PropertyField(ptsProp.GetArrayElementAtIndex(selectedControlPointId), true);
    }
    else
    {
      EditorGUILayout.HelpBox(msg + "No control points selected", MessageType.Info);
    }
    if (EditorGUI.EndChangeCheck()) serializedObject.ApplyModifiedProperties();
  }

  void OnSceneGUI()
  {
    Input();
    Draw();
  }

  void Input()
  {
    Event guiEvent = Event.current;
    Vector2 mousePos = HandleUtility.GUIPointToWorldRay(guiEvent.mousePosition).origin;
    mousePos = creator.transform.InverseTransformPoint(mousePos);
    if (guiEvent.type == EventType.MouseDown && guiEvent.button == 0 && guiEvent.shift)
    {
      Undo.RecordObject(creator, "Insert point");
      path.InsertPoint(path.NumPoints, mousePos);
    }
    else if (guiEvent.type == EventType.MouseDown && guiEvent.button == 0 && guiEvent.control)
    {
      for (int i = 0; i < path.NumPoints; i++)
      {
        if (Vector2.Distance(mousePos, path[i].position) <= .25f)
        {
          Undo.RecordObject(creator, "Remove point");
          path.RemovePoint(i);
          break;
        }
      }
    }
  }

  void Draw()
  {
    Handles.matrix = creator.transform.localToWorldMatrix;
    var rot = Quaternion.Inverse(creator.transform.rotation) * Tools.handleRotation;
    var snap = Vector2.zero;
    Handles.CapFunction cap = Handles.DotHandleCap;
    for (int i = 0; i < path.NumPoints; i++)
    {
      float size;
      var pos = path[i].position;
      size = HandleUtility.GetHandleSize(pos) * .05f;
      Handles.Label(pos, i.ToString());
      Handles.color = i == selectedControlPointId ? Handles.selectedColor : Color.red;
      int ctrlId = GUIUtility.GetControlID(FocusType.Passive);
      Vector2 newPos = Handles.FreeMoveHandle(ctrlId, pos, rot, size, snap, cap);
      if (ctrlId == EditorGUIUtility.hotControl) selectedControlPointId = i;
      if (pos != newPos)
      {
        Undo.RecordObject(creator, "Move point position");
        path.MovePoint(i, newPos);
      }
      pos = newPos;
      Handles.color = Color.black;
      if (path.loop || i != 0)
      {
        var tanBack = pos + path[i].tangentBack;
        Handles.DrawLine(pos, tanBack);
        size = HandleUtility.GetHandleSize(tanBack) * .03f;
        Vector2 newTanBack = Handles.FreeMoveHandle(tanBack, rot, size, snap, cap);
        if (tanBack != newTanBack)
        {
          Undo.RecordObject(creator, "Move point tangent");
          path.MoveTangentBack(i, newTanBack - pos);
        }
      }
      if (path.loop || i != path.NumPoints - 1)
      {
        var tanFront = pos + path[i].tangentFront;
        Handles.DrawLine(pos, tanFront);
        size = HandleUtility.GetHandleSize(tanFront) * .03f;
        Vector2 newTanFront = Handles.FreeMoveHandle(tanFront, rot, size, snap, cap);
        if (tanFront != newTanFront)
        {
          Undo.RecordObject(creator, "Move point tangent");
          path.MoveTangentFront(i, newTanFront - pos);
        }
      }
    }
    Repaint();
  }



  [DrawGizmo(GizmoType.Selected | GizmoType.NonSelected | GizmoType.Pickable)]
  static void DrawGizmo(PathCreator creator, GizmoType gizmoType)
  {
    Gizmos.matrix = creator.transform.localToWorldMatrix;
    var path = creator.path;
    for (int i = 0; i < path.NumSegments; i++)
    {
      Vector2[] points = path.GetBezierPointsInSegment(i);
      var pts = Handles.MakeBezierPoints(points[0], points[3], points[1], points[2], 30);
      Gizmos.color = Color.green;
      for (int j = 0; j < pts.Length - 1; j++)
      {
        Gizmos.DrawLine(pts[j], pts[j + 1]);
      }
    }
  }

  void OnEnable()
  {
    creator = (PathCreator)target;
    path = creator.path ?? creator.CreatePath();
    property = serializedObject.FindProperty("path");
  }
}

注意：我将Bezier线的图形从OnSceneGui移到了DrawGizmo，所以即使没有切开对象，绿线也将可见，并且可以在“场景编辑器”中选择它，以使其被选中。

最后，我建议对该脚本进行一些进一步的开发。使多点选择成为可能并不是很难。也许使默认手柄（例如位置和旋转）可以分别应用于点。或将用于创建和删除点的方法更改为直观的内容，例如双击或拖动路径线。甚至是用于智能点操作的自定义工具栏，例如对齐，分布，雕刻...不同的约束，例如平滑，对称，尖点或笔直...

Answer 2

不确定我是否理解了这个问题，但是

以这种方式选择贝塞尔曲线手柄/控制点单个句柄的属性（例如连续性）选择后，将在检查器窗口中显示。请注意，我会这样就无需为游戏创建游戏对象处理/控制点

您需要使用OnSceneGUI选项才能选择手柄，每次选择新点时，只需存储其值即可。

    private void OnSceneGUI ()
    {
        spline = target as Path;
        handleTransform = spline.transform;
        handleRotation = Tools.pivotRotation == PivotRotation.Local
            ? handleTransform.rotation : Quaternion.identity;

        Vector3 p0 = ShowPoint (0);
        Color gg = Color.gray;
        gg.a = 0.25f;
        for (int i = 1; i < spline.ControlPointCount; i += 3)
        {
            Vector3 p1 = ShowPoint (i);
            Vector3 p2 = ShowPoint (i + 1);
            Vector3 p3 = ShowPoint (i + 2);

            Handles.color = gg;
            Handles.DrawLine (p0, p1);
            Handles.DrawLine (p2, p3);

            Handles.DrawBezier (p0, p3, p1, p2, Color.white, null, 2f);
            p0 = p3;
        }
        ShowDirections ();
    }

private Vector3 ShowPoint (int index)
        {
            Vector3 point = handleTransform.TransformPoint (spline.Points[index]);
            float size = HandleUtility.GetHandleSize (point);
            if (index == 0)
            {
                size *= 2f;
            }
            Handles.color = modeColors[(int) spline.GetControlPointMode (index)];
            if (Handles.Button (point, handleRotation, size * handleSize, size * pickSize, Handles.DotCap))
            {
                selectedIndex = index;
                Repaint ();
            }
            if (selectedIndex == index)
            {
                EditorGUI.BeginChangeCheck ();
                point = Handles.DoPositionHandle (point, handleRotation);
                if (EditorGUI.EndChangeCheck ())
                {
                    Undo.RecordObject (spline, "Move Point");
                    EditorUtility.SetDirty (spline);
                    spline.SetControlPoint (handleTransform.InverseTransformPoint (point), index);
                }
            }
            return point;
        }

并用于在检查器GUI上显示该点

    private void DrawSelectedPointInspector ()
    {
        GUILayout.Label ("Selected Point");
        EditorGUI.BeginChangeCheck ();
        Vector3 point = EditorGUILayout.Vector3Field ("Position", spline.Points[selectedIndex]);
        if (EditorGUI.EndChangeCheck ())
        {
            Undo.RecordObject (spline, "Move Point");
            EditorUtility.SetDirty (spline);
            spline.SetControlPoint (point, selectedIndex);
        }
        EditorGUI.BeginChangeCheck ();
        BezierControlPointModes mode = (BezierControlPointModes) EditorGUILayout.EnumPopup ("Mode", spline.GetControlPointMode (selectedIndex));
        if (EditorGUI.EndChangeCheck ())
        {
            Undo.RecordObject (spline, "Change Point Mode");
            spline.SetControlPointMode (selectedIndex, mode);
            EditorUtility.SetDirty (spline);
        }
    }

并在InspectorGUI上调用它

    if (selectedIndex >= 0 && selectedIndex < spline.points.Count)
    {
        DrawSelectedPointInspector ();
    }

保留一个单独的方法来处理每个点的移动每个点都有单独的移动方法。为此，您只需要保留

如何使编辑器句柄可选以显示属性检查器窗口

2 个答案: