private void Awake()
{
enabled = false;
m_splinePoint = GetComponentInParent <SplinePointBase>();
m_spline = GetComponentInParent <SplineBase>();
}
public virtual void Disable()
{
EndDrag();
if (m_selectedJunctions != null)
{
for (int i = 0; i < m_selectedJunctions.Length; ++i)
{
JunctionBase junction = m_selectedJunctions[i];
if (junction != null)
{
junction.Unselect();
}
}
}
if (m_splineRenderers != null)
{
for (int i = 0; i < m_splineRenderers.Length; ++i)
{
SplineRenderer splineRenderer = m_splineRenderers[i];
if (splineRenderer != null)
{
splineRenderer.IsSelected = false;
}
}
}
if (m_selectedSplinePoints != null)
{
for (int i = 0; i < m_selectedSplinePoints.Length; ++i)
{
SplinePointBase splinePoint = m_selectedSplinePoints[i];
if (splinePoint != null)
{
splinePoint.Unselect();
}
}
}
if (m_selectedBezierPoints != null)
{
for (int i = 0; i < m_selectedBezierPoints.Length; ++i)
{
ControlPoint bezierPoint = m_selectedBezierPoints[i];
if (bezierPoint != null)
{
bezierPoint.Unselect();
}
}
}
m_splines = null;
m_splineRenderers = null;
m_selectedSplines = null;
m_selectedJunctions = null;
m_selectedSplinePoints = null;
m_selectedBezierPoints = null;
}
protected override void AddInternal(SplinePointBase point)
{
int index = Array.IndexOf(Connections, point);
if (index < 0)
{
Connections = Connections.Add(point);
m_connections = Connections;
}
}
protected override void RemoveInternal(SplinePointBase point)
{
int index = Array.IndexOf(Connections, point);
if (index >= 0)
{
Connections = Connections.RemoveAt(index);
m_connections = Connections;
}
}
private void UpdateConnectionRotations()
{
for (int i = 0; i < m_connections.Length; ++i)
{
SplinePointBase splinePoint = m_connections[i];
if (splinePoint.Rotation != transform.rotation)
{
splinePoint.Rotation = transform.rotation;
}
}
}
private void Start()
{
if (m_splinePoint == null)
{
m_splinePoint = GetComponentInParent <SplinePointBase>();
}
if (m_spline == null)
{
m_spline = GetComponentInParent <SplineBase>();
}
}
public override void Connect(SplineBase spline, int pointIndex)
{
GameObject pointGO = spline.GetPoint(pointIndex);
SplinePointBase splinePoint = pointGO.GetComponent <SplinePointBase>();
if (Array.IndexOf(Connections, splinePoint) < 0)
{
splinePoint.SetJunction(this);
Array.Resize(ref Connections, Connections.Length + 1);
Connections[Connections.Length - 1] = splinePoint;
m_connections = Connections;
}
}
protected virtual void OnSceneGUI()
{
if (m_splineBaseEditor == null)
{
m_splineBaseEditor = SplineBaseEditorImpl.Instance;
m_splineBaseEditor.Enable(Selection.objects, Selection.activeObject);
}
SplinePointBase point = (SplinePointBase)target;
if (Selection.activeObject == point.gameObject)
{
SplineBaseEditorImpl.Instance.SceneGUI();
}
}
public override void Disconnect()
{
for (int i = Connections.Length - 1; i >= 0; i--)
{
SplinePointBase splinePoint = Connections[i];
if (splinePoint != null)
{
if (splinePoint.GetJunction() == this)
{
splinePoint.SetJunction(null);
}
}
}
Connections = new SplinePointBase[0];
m_connections = Connections;
}
public override void Disconnect(SplineBase spline)
{
for (int i = Connections.Length - 1; i >= 0; i--)
{
SplinePointBase splinePoint = Connections[i];
if (splinePoint.Spline == spline)
{
if (splinePoint.GetJunction() == this)
{
splinePoint.SetJunction(null);
}
Connections = Connections.RemoveAt(i);
m_connections = Connections;
}
}
}
public override void Disconnect(SplineBase spline, int pointIndex)
{
GameObject pointGO = spline.GetPoint(pointIndex);
SplinePointBase splinePoint = pointGO.GetComponent <SplinePointBase>();
int index = Array.IndexOf(Connections, splinePoint);
if (index >= 0)
{
if (splinePoint.GetJunction() == this)
{
splinePoint.SetJunction(null);
}
Connections = Connections.RemoveAt(index);
m_connections = Connections;
}
}
private void SnapToGrid()
{
for (int i = 0; i < m_selectedSplines.Length; ++i)
{
SplineBase spline = m_selectedSplines[i];
if (spline != null)
{
SnapToGrid(spline.transform);
}
}
for (int i = 0; i < m_selectedJunctions.Length; ++i)
{
JunctionBase junction = m_selectedJunctions[i];
if (junction != null)
{
SnapToGrid(junction.transform);
}
}
for (int i = 0; i < m_selectedSplinePoints.Length; ++i)
{
SplinePointBase splinePoint = m_selectedSplinePoints[i];
if (splinePoint != null)
{
SnapToGrid(splinePoint.transform);
}
}
for (int i = 0; i < m_selectedBezierPoints.Length; ++i)
{
ControlPoint ctrlPoint = m_selectedBezierPoints[i];
if (ctrlPoint != null)
{
SnapToGrid(ctrlPoint.transform);
}
}
}
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();
}
}
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();
}
}
protected abstract void AddInternal(SplinePointBase point);
public virtual void Enable(UnityObject[] selection, UnityObject activeObject)
{
Disable();
m_refSpline = selection.Where(s => s is GameObject && ((GameObject)s).GetComponent <SplineBase>()).Select(g => ((GameObject)g).GetComponent <SplineBase>()).FirstOrDefault();
if (m_refSpline != null)
{
m_refSplinePosition = m_refSpline.transform.position;
m_refSplineRotation = m_refSpline.transform.rotation;
m_refSplineScale = m_refSpline.transform.localScale;
}
HashSet <JunctionBase> junctions = new HashSet <JunctionBase>();
HashSet <SplineBase> splines = new HashSet <SplineBase>();
HashSet <SplinePointBase> splinePoints = new HashSet <SplinePointBase>();
HashSet <ControlPoint> bezierPoints = new HashSet <ControlPoint>();
List <SplineBase> selectedSplines = new List <SplineBase>();
for (int i = 0; i < selection.Length; ++i)
{
UnityObject obj = selection[i];
if (obj is GameObject)
{
GameObject go = (GameObject)obj;
SplineBase spline = go.GetComponent <SplineBase>();
if (spline != null)
{
if (!splines.Contains(spline))
{
splines.Add(spline);
}
selectedSplines.Add(spline);
}
SplinePointBase splinePoint = go.GetComponent <SplinePointBase>();
if (splinePoint != null)
{
SplineBase parentSpline = splinePoint.GetComponentInParent <SplineBase>();
if (parentSpline != null)
{
if (!splines.Contains(parentSpline))
{
splines.Add(parentSpline);
}
}
if (!splinePoints.Contains(splinePoint))
{
splinePoints.Add(splinePoint);
}
}
ControlPoint bezierPoint = go.GetComponent <ControlPoint>();
if (bezierPoint != null)
{
SplineBase parentSpline = bezierPoint.GetComponentInParent <SplineBase>();
if (parentSpline != null)
{
if (!splines.Contains(parentSpline))
{
splines.Add(parentSpline);
}
}
if (!bezierPoints.Contains(bezierPoint))
{
bezierPoints.Add(bezierPoint);
}
}
JunctionBase junction = go.GetComponent <Junction>();
if (junction != null)
{
if (!junctions.Contains(junction))
{
junctions.Add(junction);
}
}
}
}
m_selectedJunctions = junctions.ToArray();
for (int i = 0; i < m_selectedJunctions.Length; ++i)
{
m_selectedJunctions[i].Select();
}
ConnectedSplinesFinder finder = new ConnectedSplinesFinder();
finder.Find(junctions, splines);
m_splines = finder.Splines;
m_splineRenderers = new SplineRenderer[m_splines.Length];
for (int i = 0; i < m_splines.Length; ++i)
{
m_splineRenderers[i] = m_splines[i].GetComponent <SplineRenderer>();
m_splineRenderers[i].IsSelected = true;
}
m_selectedSplinePoints = splinePoints.ToArray();
for (int i = 0; i < m_selectedSplinePoints.Length; ++i)
{
m_selectedSplinePoints[i].Select();
}
m_selectedBezierPoints = bezierPoints.ToArray();
for (int i = 0; i < m_selectedBezierPoints.Length; ++i)
{
m_selectedBezierPoints[i].Select();
}
SyncCtrlPoints();
m_selectedSplines = selectedSplines.ToArray();
}
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);
}
void IJunctionInternalAccessor.Remove(SplinePointBase point)
{
RemoveInternal(point);
}
private void OnTransformParentChanged()
{
m_splinePoint = GetComponentInParent <SplinePointBase>();
m_spline = GetComponentInParent <SplineBase>();
}
protected abstract void RemoveInternal(SplinePointBase point);
//public void SyncCtrlPointRotation()
//{
// if(m_spline != null && m_splinePoint != null)
// {
// Vector3 currentEuler = transform.localEulerAngles;
// float angle = m_spline.GetPointTwistAngle(m_splinePoint.Index);
// angle -= Mathf.DeltaAngle(m_euler.z, currentEuler.z);
// // Debug.Log(angle);
// m_spline.SetPointTwistAngle(m_splinePoint.Index, angle);
// m_euler = transform.localEulerAngles;
// m_rotation = transform.localRotation;
// }
//}
private void OnScriptReloaded()
{
m_splinePoint = GetComponentInParent <SplinePointBase>();
m_spline = GetComponentInParent <SplineBase>();
}
void IJunctionInternalAccessor.Add(SplinePointBase point)
{
AddInternal(point);
}