private Quaternion GetDragPointRotation(SplineBase spline, int index, int nextIndex, int ctrlPointIndex)
{
Vector3 nextCtrlPointPosition =
spline.InterpolationMode == 0 ?
spline.GetCtrlPointPosition(nextIndex, ctrlPointIndex) :
spline.GetPointPosition(nextIndex);
Vector3 toNextSplinePoint = index < nextIndex ?
nextCtrlPointPosition - spline.GetPointPosition(index) :
spline.GetPointPosition(index) - nextCtrlPointPosition;
GameObject ctrlPoint = index < nextIndex?spline.GetCtrlPoint(index, 1) : spline.GetCtrlPoint(index, 0);
Vector3 v = index < nextIndex ? Vector3.forward : Vector3.back;
if (toNextSplinePoint.magnitude > MinMag)
{
Quaternion rotation;
if (ctrlPoint != null)
{
Quaternion rot = Quaternion.FromToRotation(ctrlPoint.transform.localPosition.normalized, v);
rotation = Quaternion.LookRotation(toNextSplinePoint) * rot;
}
else
{
rotation = Quaternion.LookRotation(toNextSplinePoint);
}
return(rotation);
}
return(spline.GetPointRotation(index));
}
public virtual void SceneGUI()
{
if (m_refSpline != null)
{
if (m_refSplinePosition != m_refSpline.transform.position ||
m_refSplineRotation != m_refSpline.transform.rotation ||
m_refSplineScale != m_refSpline.transform.localScale)
{
m_refSpline.UpdateJunctions();
m_refSplinePosition = m_refSpline.transform.position;
m_refSplineRotation = m_refSpline.transform.rotation;
m_refSplineScale = m_refSpline.transform.localScale;
}
}
SplineEditorEventArgs eventArgs;
SplineEditorEvent eventType = GetEvent(out eventArgs);
if (m_splinePointCreatorDrag || m_splinePointDrag || m_beforeSplinePointCreatorDrag || m_beforeJunctionDrag || m_junctionDrag || m_splineCtrlPointDrag)
{
if (IsMouseUp())
{
EndDrag();
}
}
if (IsSnapToGrid())
{
SnapToGrid();
}
switch (eventType)
{
case SplineEditorEvent.SplineCtrlPointDrag:
{
m_dragSpline = eventArgs.Spline;
m_dragPointIndex = eventArgs.PointIndex;
m_dragCtrlPointIndex = eventArgs.CtrlPointIndex;
GetDragPlane(m_dragSpline.GetCtrlPointPosition(m_dragPointIndex, m_dragCtrlPointIndex));
if (GetPositionOnDragPlane(ScreenPointToRay(MousePosition), out m_beginDragPosition))
{
GameObject ctrlPoint = m_dragSpline.GetCtrlPoint(m_dragPointIndex, m_dragCtrlPointIndex);
GameObject splinePoint = m_dragSpline.GetPoint(m_dragPointIndex);
if (ctrlPoint != null)
{
RecordObject(ctrlPoint.transform, "BH.S3.DragSplinePoint");
}
if (splinePoint != null)
{
RecordObject(splinePoint.transform, "BH.S3.DragSplinePoint");
}
m_splineCtrlPointDrag = true;
}
else
{
m_dragSpline = null;
m_dragPointIndex = -1;
m_dragCtrlPointIndex = -1;
}
}
break;
case SplineEditorEvent.SplineCtrlPointDrop:
{
if (m_splineCtrlPointDrag)
{
EndDrag();
}
else
{
if (eventArgs.CtrlPointIndex >= 0)
{
GameObject splinePoint = eventArgs.Spline.GetCtrlPoint(eventArgs.PointIndex, eventArgs.CtrlPointIndex);
Select(splinePoint);
}
else
{
GameObject splinePoint = eventArgs.Spline.GetPoint(eventArgs.PointIndex);
Select(splinePoint);
}
}
}
break;
case SplineEditorEvent.SplinePointCreatorDrag:
{
if (!m_beforeSplinePointCreatorDrag && !m_splinePointCreatorDrag)
{
m_dragSpline = eventArgs.Spline;
m_dragPointIndex = eventArgs.PointIndex;
GetDragPlane(m_dragSpline.GetPointPosition(m_dragPointIndex));
if (GetPositionOnDragPlane(ScreenPointToRay(MousePosition), out m_beginDragPosition))
{
m_beforeSplinePointCreatorDrag = true;
}
else
{
m_dragSpline = null;
m_dragPointIndex = -1;
}
}
}
break;
case SplineEditorEvent.SplinePointCreatorDrop:
{
if (m_splinePointCreatorDrag)
{
SplineBase dropSpline = eventArgs.Spline;
int dropPointIndex = eventArgs.PointIndex;
if (m_dragPointIndex >= 0 && m_dragSpline != null && dropPointIndex >= 0 && dropSpline != null && (dropSpline != m_dragSpline || dropPointIndex != m_dragPointIndex))
{
dropSpline.Connect(dropPointIndex, m_dragSpline, m_dragPointIndex);
JunctionBase junction = dropSpline.GetJunction(dropPointIndex);
if (junction.ConnectionsCount == 2)
{
RegisterCreatedObjectUndo(junction.gameObject, "BH.S3.Junction");
}
}
Select(m_dragSpline.gameObject);
EndDrag();
}
else
{
if (eventArgs.CtrlPointIndex >= 0)
{
GameObject splinePoint = eventArgs.Spline.GetCtrlPoint(eventArgs.PointIndex, eventArgs.CtrlPointIndex);
Select(splinePoint);
}
else
{
GameObject splinePoint = eventArgs.Spline.GetPoint(eventArgs.PointIndex);
Select(splinePoint);
}
}
}
break;
case SplineEditorEvent.SplinePointDrag:
{
if (!m_splinePointDrag)
{
m_dragSpline = eventArgs.Spline;
m_dragPointIndex = eventArgs.PointIndex;
GetDragPlane(m_dragSpline.GetPointPosition(m_dragPointIndex));
if (GetPositionOnDragPlane(ScreenPointToRay(MousePosition), out m_beginDragPosition))
{
m_splinePointDrag = true;
JunctionBase junction = m_dragSpline.GetJunction(m_dragPointIndex);
if (junction == null)
{
GameObject splinePointGO = m_dragSpline.GetPoint(m_dragPointIndex);
if (splinePointGO != null)
{
RegisterFullObjectHierarchyUndo(splinePointGO, "BH.S3.DragSplinePoint");
}
}
else
{
int connectionsCount = junction.ConnectionsCount;
for (int i = 0; i < connectionsCount; ++i)
{
SplineBase spline = junction.GetSpline(i);
int pointIndex = junction.GetSplinePointIndex(i);
GameObject splinePointGO = spline.GetPoint(pointIndex);
if (splinePointGO != null)
{
RegisterFullObjectHierarchyUndo(splinePointGO, "BH.S3.DragSplinePoint");
}
}
RecordObject(junction.transform, "BH.S3.DragSplinePoint");
}
}
else
{
m_dragSpline = null;
m_dragPointIndex = -1;
}
}
}
break;
case SplineEditorEvent.SplinePointDrop:
{
if (m_splinePointDrag)
{
SplineBase dropSpline = eventArgs.Spline;
int dropPointIndex = eventArgs.PointIndex;
if (m_dragPointIndex >= 0 && m_dragSpline != null && dropPointIndex >= 0 && dropSpline != null && (dropSpline != m_dragSpline || dropPointIndex != m_dragPointIndex))
{
JunctionBase dropJunction = dropSpline.GetJunction(dropPointIndex);
JunctionBase dragJunction = m_dragSpline.GetJunction(m_dragPointIndex);
if (dragJunction != dropJunction || dragJunction == null && dropJunction == null)
{
if (dropJunction != null)
{
RecordObject(dropJunction, "BH.S3.EndDragSplinePoint");
GameObject splinePointGO = m_dragSpline.GetPoint(m_dragPointIndex);
if (splinePointGO != null)
{
SplinePointBase splinePoint = splinePointGO.GetComponent <SplinePointBase>();
if (splinePoint != null)
{
RecordObject(splinePoint, "BH.S3.EndDragSplinePoint");
}
}
}
if (dragJunction != null)
{
RecordObject(dragJunction, "BH.S3.EndDragSplinePoint");
GameObject splinePointGO = dropSpline.GetPoint(dropPointIndex);
if (splinePointGO != null)
{
SplinePointBase splinePoint = splinePointGO.GetComponent <SplinePointBase>();
if (splinePoint != null)
{
RegisterFullObjectHierarchyUndo(splinePointGO, "BH.S3.EndDragSplinePoint");
}
}
}
dropSpline.Connect(dropPointIndex, m_dragSpline, m_dragPointIndex);
if (dragJunction != null && dropJunction != null)
{
DestroyObject(dragJunction.gameObject);
}
if (dropJunction == null)
{
dropJunction = dropSpline.GetJunction(dropPointIndex);
if (dropJunction.ConnectionsCount == 2)
{
RegisterCreatedObjectUndo(dropJunction.gameObject, "BH.S3.EndDragSplinePoint");
}
}
}
}
}
else
{
GameObject splinePoint = eventArgs.Spline.GetPoint(eventArgs.PointIndex);
Select(splinePoint);
}
EndDrag();
}
break;
case SplineEditorEvent.JunctionClick:
{
Select(eventArgs.Junction.gameObject);
}
break;
case SplineEditorEvent.JunctionDrag:
{
if (!m_beforeJunctionDrag && !m_junctionDrag)
{
m_dragJunction = eventArgs.Junction;
GetDragPlane(m_dragJunction.transform.position);
if (GetPositionOnDragPlane(ScreenPointToRay(MousePosition), out m_beginDragPosition))
{
m_beforeJunctionDrag = true;
}
else
{
m_dragJunction = null;
}
}
}
break;
}
if (m_beforeSplinePointCreatorDrag)
{
if (BeginDragSplinePoint())
{
m_beforeSplinePointCreatorDrag = false;
m_splinePointCreatorDrag = true;
}
}
if (m_splinePointCreatorDrag)
{
DragSplinePoint();
}
if (m_splinePointDrag)
{
DragSplinePointUsingOffset();
}
if (m_splineCtrlPointDrag)
{
DragSplineCtrlPoint();
}
if (m_beforeJunctionDrag)
{
if (BeginDragJunction())
{
m_beforeJunctionDrag = false;
m_junctionDrag = true;
}
}
if (m_junctionDrag)
{
DragSplinePoint();
}
}
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
ControlPoint[] points = SplineBaseEditorImpl.Instance.SelectedBezierPoints;
int mode = points[0].Mode;
for (int i = 1; i < points.Length; ++i)
{
ControlPoint bezierPoint = points[i];
if (bezierPoint.Mode != mode)
{
mode = -1;
break;
}
}
int selectedMode;
if (mode == -1)
{
selectedMode = EditorGUILayout.Popup("Mode", mode + 1, new[] { "Different Modes", "Free", "Aligned", "Mirrored" }) - 1;
}
else
{
selectedMode = EditorGUILayout.Popup("Mode", mode, new[] { "Free", "Aligned", "Mirrored" });
}
if (selectedMode != -1 && selectedMode != mode)
{
for (int i = 0; i < points.Length; ++i)
{
ControlPoint bezierPoint = points[i];
if (bezierPoint.SplinePoint != null)
{
JunctionBase junction = bezierPoint.SplinePoint.GetJunction();
if (junction != null)
{
int connectionsCount = junction.ConnectionsCount;
for (int c = 0; c < connectionsCount; ++c)
{
SplineBase spline = junction.GetSpline(c);
int splinePointIndex = junction.GetSplinePointIndex(c);
GameObject splinePointGO = spline.GetPoint(splinePointIndex);
SplinePointBase splinePoint = splinePointGO.GetComponent <SplinePointBase>();
if (splinePoint != null)
{
Undo.RecordObject(splinePoint, "BH.S3.BezierPoint.Mode");
}
GameObject ctrlPoint = spline.GetCtrlPoint(splinePointIndex, 0);
if (ctrlPoint != null)
{
Undo.RecordObject(ctrlPoint.transform, "BH.S3.BezierPoint.Mode");
}
GameObject twinPoint = spline.GetCtrlPoint(splinePointIndex, 1);
if (twinPoint != null)
{
Undo.RecordObject(twinPoint.transform, "BH.S3.BezierPoint.Mode");
}
}
}
else
{
Undo.RecordObject(bezierPoint.SplinePoint, "BH.S3.BezierPoint.Mode");
GameObject twinPoint = bezierPoint.TwinPoint;
if (twinPoint != null)
{
Undo.RecordObject(twinPoint.transform, "BH.S3.BezierPoint.Mode");
}
Undo.RecordObject(bezierPoint.transform, "BH.S3.BezierPoint.Mode");
}
}
bezierPoint.Mode = selectedMode;
}
SceneView.RepaintAll();
}
}
