public void Find(IEnumerable <JunctionBase> junctions, IEnumerable <SplineBase> splines)
{
m_queue.Clear();
m_visitedSplines = new HashSet <SplineBase>(splines.Distinct());
m_visitedJunctions = new HashSet <JunctionBase>(junctions.Distinct());
foreach (JunctionBase junction in m_visitedJunctions)
{
m_queue.Enqueue(junction);
}
foreach (SplineBase spline in m_visitedSplines)
{
ExtractJunctions(spline);
}
while (m_queue.Count != 0)
{
JunctionBase junction = m_queue.Dequeue();
for (int i = 0; i < junction.ConnectionsCount; ++i)
{
SplineBase spline = junction.GetSpline(i);
if (spline != null)
{
if (!m_visitedSplines.Contains(spline))
{
ExtractJunctions(spline);
m_visitedSplines.Add(spline);
}
}
}
}
}
public bool IsControlPointVisible(int pointIndex, int controlPointIndex)
{
JunctionBase junction = m_spline.GetJunction(pointIndex);
if (junction != null)
{
if (m_spline.InterpolationMode == 1)
{
return(false);
}
if (junction.GetSpline(0) != m_spline || junction.GetSplinePointIndex(0) != pointIndex)
{
return(false);
}
return(true);
}
if (m_spline.InterpolationMode == 0)
{
if (pointIndex == 0 && controlPointIndex == 0 || pointIndex == m_spline.PointsCount - 1 && controlPointIndex == m_spline.GetCtrlPointsCount(pointIndex) - 1)
{
return(false);
}
}
else
{
if (pointIndex != 0 && pointIndex != m_spline.PointsCount - 1)
{
return(false);
}
if (pointIndex == 0 && controlPointIndex == m_spline.GetCtrlPointsCount(pointIndex) - 1 || pointIndex == m_spline.PointsCount - 1 && controlPointIndex == 0)
{
return(false);
}
}
return(true);
}
private void DrawSplinePoint(ref SplineEditorEventArgs args, ref SplineEditorEvent evnt, SplineRenderer splineRenderer, SplineBase spline, int j)
{
int mode = spline.GetPointMode(j);
if (mode >= 0 && mode < splineRenderer.ControlPointColors.Length)
{
Handles.color = splineRenderer.ControlPointColors[mode];
}
int controlPointsCount = spline.GetCtrlPointsCount(j);
for (int k = 0; k < controlPointsCount; ++k)
{
int scale = 1;
if (!splineRenderer.IsControlPointVisible(j, k))
{
scale = 0;
}
Vector3 ctrlPosition = spline.GetCtrlPointPosition(j, k);
SplinePointHandle.Result ctrlPointDragResult = DrawPointHandle(splineRenderer, ctrlPosition, scale, true);
if (ctrlPointDragResult == SplinePointHandle.Result.Drag)
{
if (evnt == SplineEditorEvent.None)
{
args = new SplineEditorEventArgs(spline, j, k);
evnt = SplineEditorEvent.SplineCtrlPointDrag;
}
}
if (ctrlPointDragResult == SplinePointHandle.Result.EndDrag)
{
if (evnt == SplineEditorEvent.None)
{
args = new SplineEditorEventArgs(spline, j, k);
evnt = SplineEditorEvent.SplineCtrlPointDrop;
}
}
}
float dragHandleScale = 1;
if (m_draggingDragPointHandle && spline == DragSpline && DragPointIndex == j)
{
dragHandleScale = 0;
}
JunctionBase junction = spline.GetJunction(j);
if (junction != null && junction != NewJunction)
{
bool drawSplinePoint = junction == null || spline == junction.GetSpline(0) && j == junction.GetSplinePointIndex(0);
if (drawSplinePoint)
{
dragHandleScale = 1.5f;
}
else
{
dragHandleScale = 0;
}
}
Handles.color = splineRenderer.SplinePointColor;
Vector3 position = spline.GetPointPosition(j);
SplinePointHandle.Result dragResult = DrawDragHandle(splineRenderer, position, dragHandleScale, DragSpline == null);
if (dragResult == SplinePointHandle.Result.Drag)
{
if (evnt == SplineEditorEvent.None)
{
args = new SplineEditorEventArgs(spline, j);
evnt = SplineEditorEvent.SplinePointDrag;
}
}
else if (dragResult == SplinePointHandle.Result.EndDrag)
{
if (evnt == SplineEditorEvent.None)
{
args = new SplineEditorEventArgs(spline, j);
evnt = SplineEditorEvent.SplinePointDrop;
}
}
else if (dragResult == SplinePointHandle.Result.PointerOver)
{
m_pointerOverSpline = spline;
m_pointerOverSplinePointIndex = j;
m_pointerOver = true;
}
if (junction != null && junction != NewJunction)
{
Handles.color = splineRenderer.JunctionColor;
JunctionHandle.Result junctionResult = DrawJunctionHandle(splineRenderer, junction.transform.position, 1);
if (junctionResult == JunctionHandle.Result.Click)
{
evnt = SplineEditorEvent.JunctionClick;
args = new SplineEditorEventArgs(junction);
}
else if (junctionResult == JunctionHandle.Result.Drag)
{
evnt = SplineEditorEvent.JunctionDrag;
args = new SplineEditorEventArgs(junction);
}
}
Handles.color = splineRenderer.SplinePointColor;
SplinePointHandle.Result result = DrawPointHandle(splineRenderer, position, 1, false);
if (result == SplinePointHandle.Result.EndDrag)
{
m_draggingDragPointHandle = false;
if (evnt == SplineEditorEvent.None)
{
args = new SplineEditorEventArgs(spline, j);
evnt = SplineEditorEvent.SplinePointCreatorDrop;
}
}
else if (result == SplinePointHandle.Result.Drag)
{
m_draggingDragPointHandle = true;
if (evnt == SplineEditorEvent.None)
{
args = new SplineEditorEventArgs(spline, j);
evnt = SplineEditorEvent.SplinePointCreatorDrag;
}
}
}
private void SetDragPointRotation()
{
if (m_splinePointCreatorDrag || IsRotate())
{
if (m_dragSpline.PointsCount > 1)
{
JunctionBase junction = m_dragSpline.GetJunction(m_dragPointIndex);
if (junction != null)
{
SplineBase closestSpline = null;
int closestPointIndex = -1;
int closestPointIndex2 = -1;
int ctrlPointIndex = -1;
float minMag = float.MaxValue;
int connectionsCount = junction.ConnectionsCount;
for (int i = 0; i < connectionsCount; ++i)
{
SplineBase spline = junction.GetSpline(i);
int pointIndex = junction.GetSplinePointIndex(i);
if (pointIndex == spline.PointsCount - 1)
{
float mag = (spline.GetPointPosition(pointIndex) - spline.GetPointPosition(pointIndex - 1)).sqrMagnitude;
if (mag < minMag)
{
ctrlPointIndex = 1;
closestPointIndex = pointIndex;
closestPointIndex2 = pointIndex - 1;
closestSpline = spline;
minMag = mag;
}
}
else if (pointIndex == 0)
{
float mag = (spline.GetPointPosition(pointIndex) - spline.GetPointPosition(pointIndex + 1)).sqrMagnitude;
if (mag < minMag)
{
ctrlPointIndex = 0;
closestPointIndex = pointIndex;
closestPointIndex2 = pointIndex + 1;
closestSpline = spline;
minMag = mag;
}
}
else
{
float mag1 = (spline.GetPointPosition(pointIndex) - spline.GetPointPosition(pointIndex - 1)).sqrMagnitude;
float mag2 = (spline.GetPointPosition(pointIndex) - spline.GetPointPosition(pointIndex + 1)).sqrMagnitude;
if (mag1 < mag2)
{
if (mag1 < minMag)
{
ctrlPointIndex = 1;
closestPointIndex = pointIndex;
closestPointIndex2 = pointIndex - 1;
closestSpline = spline;
minMag = mag1;
}
}
else
{
if (mag2 < minMag)
{
ctrlPointIndex = 0;
closestPointIndex = pointIndex;
closestPointIndex2 = pointIndex + 1;
closestSpline = spline;
minMag = mag2;
}
}
}
}
if (closestSpline != null)
{
Quaternion rotation = GetDragPointRotation(closestSpline, closestPointIndex, closestPointIndex2, ctrlPointIndex);
closestSpline.SetPointRotation(closestPointIndex, rotation);
}
}
else
{
if (m_dragPointIndex == 0)
{
Quaternion rotation = GetDragPointRotation(m_dragSpline, m_dragPointIndex, m_dragPointIndex + 1, 0);
m_dragSpline.SetPointRotation(m_dragPointIndex, rotation);
}
else if (m_dragPointIndex == m_dragSpline.PointsCount - 1)
{
Quaternion rotation = GetDragPointRotation(m_dragSpline, m_dragPointIndex, m_dragPointIndex - 1, 1);
m_dragSpline.SetPointRotation(m_dragPointIndex, rotation);
}
else
{
Vector3 prevPosition = m_dragSpline.GetPointPosition(m_dragPointIndex - 1);
Vector3 nextPosition = m_dragSpline.GetPointPosition(m_dragPointIndex + 1);
Vector3 position = m_dragSpline.GetPointPosition(m_dragPointIndex);
float toPrevMag = (prevPosition - position).sqrMagnitude;
float toNextMag = (nextPosition - position).sqrMagnitude;
if (toNextMag >= toPrevMag)
{
Quaternion r1 = GetDragPointRotation(m_dragSpline, m_dragPointIndex, m_dragPointIndex - 1, 1);
m_dragSpline.SetPointRotation(m_dragPointIndex, r1);
}
else
{
Quaternion r2 = GetDragPointRotation(m_dragSpline, m_dragPointIndex, m_dragPointIndex + 1, 0);
m_dragSpline.SetPointRotation(m_dragPointIndex, r2);
}
}
}
}
}
}
private bool BeginDragSplinePoint()
{
Vector3 position;
if (GetPositionOnDragPlane(ScreenPointToRay(MousePosition), out position))
{
Vector3 offset = position - m_dragSpline.GetPointPosition(m_dragPointIndex);
const float s = 0.1f;
if (offset.magnitude > HandleSize(m_beginDragPosition) * s)
{
JunctionBase junction = m_dragSpline.GetJunction(m_dragPointIndex);
if (m_dragPointIndex == 0 && junction == null)
{
m_dragSpline.Prepend(position);
GameObject splinePoint = m_dragSpline.GetPoint(0);
RegisterCreatedObjectUndo(splinePoint, "BH.S3.Prepend");
SetTransformParentUndo(splinePoint.transform, splinePoint.transform.parent, "BH.S3.Prepend");
}
else if (m_dragPointIndex == m_dragSpline.PointsCount - 1 && junction == null)
{
m_dragSpline.Append(position);
m_dragPointIndex = m_dragSpline.PointsCount - 1;
RegisterCreatedObjectUndo(m_dragSpline.GetPoint(m_dragPointIndex), "BH.S3.Append");
}
else
{
Vector3 dir;
if (m_dragSpline.CurveCount == m_dragPointIndex)
{
dir = m_dragSpline.GetDirection(1.0f);
}
else
{
dir = m_dragSpline.GetDirection(0, m_dragPointIndex);
}
bool isOut = Mathf.Sign(Vector3.Dot(offset.normalized, dir)) >= 0;
int connectionIndex = m_dragSpline.CreateBranch(m_dragPointIndex, isOut);
junction = m_dragSpline.GetJunction(m_dragPointIndex);
m_dragSpline = junction.GetSpline(connectionIndex);
RegisterCreatedObjectUndo(m_dragSpline.gameObject, "BH.S3.Branch");
if (junction.ConnectionsCount == 2)
{
m_newJunction = junction;
RegisterCreatedObjectUndo(junction.gameObject, "BH.S3.Branch");
}
m_splines = m_splines.Add(m_dragSpline);
SplineRenderer splineRenderer = m_dragSpline.GetComponent <SplineRenderer>();
m_splineRenderers = m_splineRenderers.Add(splineRenderer);
if (splineRenderer != null)
{
splineRenderer.IsSelected = true;
}
m_dragPointIndex = isOut ? 1 : 0;
}
return(true);
}
}
return(false);
}
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();
}
}
private bool BeginDragJunction()
{
Vector3 position;
if (GetPositionOnDragPlane(ScreenPointToRay(MousePosition), out position))
{
Vector3 offset = position - m_dragJunction.transform.position;
const float s = 0.1f;
if (offset.magnitude > HandleSize(m_beginDragPosition) * s)
{
int connectionsCount = m_dragJunction.ConnectionsCount;
SplineBase disconnectSpline = null;
int disconnectSplinePointIndex = -1;
float maxDot = 0;
for (int i = 0; i < connectionsCount; ++i)
{
SplineBase spline = m_dragJunction.GetSpline(i);
int splinePointIndex = m_dragJunction.GetSplinePointIndex(i);
float dot;
if (splinePointIndex == spline.CurveCount)
{
dot = Vector3.Dot(offset.normalized, -spline.GetDirection(0.9f));
}
else if (splinePointIndex == 0)
{
dot = Vector3.Dot(offset.normalized, spline.GetDirection(0.1f, splinePointIndex));
}
else
{
dot = Mathf.Max(
Vector3.Dot(offset.normalized, spline.GetDirection(0.1f, splinePointIndex)),
Vector3.Dot(offset.normalized, -spline.GetDirection(0.9f, splinePointIndex - 1)));
}
if (dot > maxDot)
{
maxDot = dot;
disconnectSpline = spline;
disconnectSplinePointIndex = splinePointIndex;
}
}
if (disconnectSpline != null && disconnectSplinePointIndex != -1)
{
RecordObject(m_dragJunction, "BH.S3.JunctionDisconnect");
m_dragPointIndex = disconnectSplinePointIndex;
m_dragSpline = disconnectSpline;
GameObject splinePointGO = m_dragSpline.GetPoint(m_dragPointIndex);
if (splinePointGO != null)
{
RecordObject(splinePointGO.transform, "BH.S3.JunctionDisconnect");
SplinePointBase splinePoint = splinePointGO.GetComponent <SplinePointBase>();
if (splinePoint != null)
{
RecordObject(splinePoint, "BH.S3.JunctionDisconnect");
}
}
m_dragJunction.Disconnect(disconnectSpline, disconnectSplinePointIndex);
return(true);
}
}
}
return(false);
}
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();
}
}
private void Move(float deltaTime, bool allowRecursiveCall)
{
float v, deltaT;
v = m_spline.GetVelocity(m_t).magnitude;
v *= m_spline.CurveCount;
deltaT = (deltaTime * Speed) / v;// F.1
int pointIndex;
if (deltaT >= 0)
{
pointIndex = m_spline.GetCurveIndex(m_t);
}
else
{
pointIndex = m_spline.GetCurveIndex(m_t) + 1;
}
int nextPointIndex;
float nextT = m_t + deltaT;
bool endOfSpline = nextT <= 0.0f || 1.0f <= nextT;
if (endOfSpline)
{
if (deltaT >= 0)
{
nextPointIndex = (pointIndex + 1) % m_spline.PointsCount;
}
else
{
nextPointIndex = (m_spline.PointsCount + pointIndex - 1) % m_spline.PointsCount;
}
}
else
{
if (deltaT >= 0)
{
nextPointIndex = m_spline.GetCurveIndex(nextT);
}
else
{
nextPointIndex = m_spline.GetCurveIndex(nextT) + 1;
}
}
bool continueIfLoop = IsLoop;
if (pointIndex != nextPointIndex)
{
//Debug.Log("Point Index " + pointIndex + " Next Point Index " + nextPointIndex);
JunctionBase junction = m_spline.GetJunction(nextPointIndex);
if (junction != null)
{
ForkEventArgs args = new ForkEventArgs(m_spline, nextPointIndex);
Fork.Invoke(args);
int connection = -1;
if (args.SelectedConnectionIndex == -1)
{
if (StopAtJunction)
{
IsRunning = false;
return;
}
if (endOfSpline)
{
if (deltaT > 0)
{
connection = junction.FirstOut();
if (connection == -1)
{
connection = junction.FirstIn();
}
}
else
{
connection = junction.FirstIn();
if (connection == -1)
{
connection = junction.FirstOut();
}
}
if (connection == -1)
{
continueIfLoop = false;
}
}
}
else
{
connection = args.SelectedConnectionIndex;
}
if (connection != -1)
{
float nextPointT = m_spline.GetTAt(nextPointIndex);
deltaT = m_t + deltaT - nextPointT;
float remDeltaTime = deltaT * v / Speed; //Calculated using F.1
m_spline = junction.GetSpline(connection);
int splinePointIndex = junction.GetSplinePointIndex(connection);
m_t = m_spline.GetTAt(splinePointIndex);
bool isOut = junction.IsOut(connection);
bool isIn = junction.IsIn(connection);
if (isOut && !isIn && Speed < 0 || isIn && !isOut && Speed > 0)
{
Speed *= -1;
}
if (allowRecursiveCall)
{
Move(remDeltaTime, false);
return;
}
else
{
v = m_spline.GetVelocity(m_t).magnitude;
v *= m_spline.CurveCount;
deltaT = (remDeltaTime * Speed) / v;// F.1
}
}
}
}
MoveOrStop(deltaT, endOfSpline, continueIfLoop);
}