public ForkEventArgs(SplineBase spline, int splinePointIndex)
{
SelectedConnectionIndex = -1;
m_junction = spline.GetJunction(splinePointIndex);
m_spline = spline;
m_splinePointIndex = splinePointIndex;
}
public virtual void CreateSplineWalker(
SplineBase spline,
SplineWalkerMode mode,
int duration,
bool canTriggerEvents = true,
SplineWalkerTriggerDirection triggerDirection = SplineWalkerTriggerDirection.Forward,
bool autoStart = true)
{
_Spline = spline;
_AutoStart = autoStart;
CanTriggerEvents = canTriggerEvents;
TriggerDirection = triggerDirection;
Duration = duration;
WalkerMode = mode;
SetPosition(0);
GetProgress = 0;
ResetTriggerIndex(false);
_Spline.EventTriggered += EventTriggered;
_oldKeyboardState = Keyboard.GetState();
_oldGamePadState = GamePad.GetState(PlayerIndex.One);
Initialized = true;
}
private void UpdateDraggingPositionOnSpline()
{
Vector3 positionOnSpline = _target.PositionWithoutOffsetFromSpline(_target.PathPosition);
Quaternion rotationOnSpline = _target.RotationWithoutOffsetFromSpline(_target.PathPosition);
EditorGUI.BeginChangeCheck();
Vector3 newPosition = Handles.PositionHandle(Tools.pivotMode != PivotMode.Center ? positionOnSpline : _target.transform.position, Tools.pivotRotation == PivotRotation.Global ? Quaternion.identity : rotationOnSpline);
//newPosition = _target.SplineBase.AttemptToApplyGrid(newPosition, 0.1f);
if (EditorGUI.EndChangeCheck())
{
SerializedProperty offset = this.GetPropertie("_offsetFromTarget");
SerializedProperty splineProperty = this.GetPropertie("_spline");
SplineBase spline = splineProperty.GetValue <SplineBase>();
float closestPositionOnSpline = spline.FindClosestPoint(newPosition, 0, -1, 10);
float currentUnits = spline.FromPathNativeUnits(closestPositionOnSpline, _target.PositionUnits);
currentUnits = _target.SplineBase.AttemptToApplyGrid(currentUnits, 0.01f);
offset.floatValue = currentUnits - _target.PathPositionTarget;
UpdatePositionFromEditor(offset);
this.ApplyModification();
}
}
public static void DrawPathGizmo(SplineBase path, Color pathColor)
{
// Draw the path
Color colorOld = Gizmos.color;
Gizmos.color = pathColor;
float step = 1f / path.Resolution;
Vector3 lastPos = path.EvaluatePosition(path.MinPos);
Vector3 lastW = (path.EvaluateOrientation(path.MinPos)
* Vector3.right) * path.Appearances.Width / 2;
for (float t = path.MinPos + step; t <= path.MaxPos + step / 2; t += step)
{
Vector3 p = path.EvaluatePosition(t);
Quaternion q = path.EvaluateOrientation(t);
Vector3 w = (q * Vector3.right) * path.Appearances.Width / 2;
Vector3 w2 = w * 1.2f;
Vector3 p0 = p - w2;
Vector3 p1 = p + w2;
Gizmos.DrawLine(p0, p1);
Gizmos.DrawLine(lastPos - lastW, p - w);
Gizmos.DrawLine(lastPos + lastW, p + w);
#if false
// Show the normals, for debugging
Gizmos.color = Color.red;
Vector3 y = (q * Vector3.up) * path.m_Appearance.width / 2;
Gizmos.DrawLine(p, p + y);
Gizmos.color = pathColor;
#endif
lastPos = p;
lastW = w;
}
Gizmos.color = colorOld;
}
private static float GetT(this SplineBase spline, float tStart, float tEnd, Vector3 testPoint, ref int iter, float eps = 0.01f)
{
iter++;
float sqrEps = eps * eps;
Vector3 start = spline.GetPoint(tStart);
Vector3 end = spline.GetPoint(tEnd);
Vector3 toStart = start - testPoint;
Vector3 toEnd = end - testPoint;
if (toStart.sqrMagnitude < toEnd.sqrMagnitude)
{
if ((end - start).sqrMagnitude <= sqrEps)
{
return(tStart);
}
return(spline.GetT(tStart, (tStart + tEnd) / 2.0f, testPoint, ref iter, eps));
}
if ((end - start).sqrMagnitude <= sqrEps)
{
return(tEnd);
}
return(spline.GetT((tStart + tEnd) / 2.0f, tEnd, testPoint, ref iter, eps));
}
public void OnClosed()
{
if (RuntimeSelection.gameObjects == null)
{
return;
}
GameObject[] gameObjects = RuntimeSelection.gameObjects.OfType <GameObject>().ToArray();
for (int i = 0; i < gameObjects.Length; ++i)
{
GameObject go = gameObjects[i];
if (go == null)
{
continue;
}
SplineBase spline = go.GetComponentInParent <SplineBase>();
if (spline == null)
{
continue;
}
spline.Unselect();
}
}
private void Restart()
{
m_spline = Spline;
m_t = Offset % 1;
m_isCompleted = false;
IsRunning = true;
}
public bool ChangeSplineAndPosition(SplineBase splineBase, float newPosition)
{
if (_splineController.SplineBase == splineBase)
{
ChangePosition(newPosition);
return(false);
}
SerializedProperty spline = this.GetPropertie("_spline");
SerializedProperty pathPosition = this.GetPropertie("_pathPosition");
spline.objectReferenceValue = splineBase;
pathPosition.floatValue = newPosition;
this.ApplyModification();
ResetEventsOfControllersEvents(_splineController.transform);
ControllerStickOffset[] allOffset = FindObjectsOfType <ControllerStickOffset>();
for (int i = 0; i < allOffset.Length; i++)
{
if (allOffset[i] == _splineController)
{
continue;
}
ControllerStickOffsetEditor offsetEditor = (ControllerStickOffsetEditor)UnityEditor.Editor.CreateEditor((ControllerStickOffset)allOffset[i], typeof(ControllerStickOffsetEditor));
offsetEditor.ChangeSplineOfController(splineBase);
DestroyImmediate(offsetEditor);
ResetEventsOfControllersEvents(allOffset[i].transform);
}
this.ApplyModification();
return(true);
}
protected override SplineEditorEvent GetEvent(out SplineEditorEventArgs args)
{
SplineEditorEvent evnt = SplineEditorEvent.None;
args = null;
SplineBase[] splines = Splines;
SplineRenderer[] splineRenderers = SplineRenderers;
if (splines == null || splineRenderers == null)
{
return(SplineEditorEvent.None);
}
SplineRenderer dragSplineRenderer = null;
for (int i = 0; i < splines.Length; ++i)
{
SplineRenderer splineRenderer = splineRenderers[i];
SplineBase spline = splines[i];
for (int j = 0; j < spline.PointsCount; ++j)
{
if ((IsJunctionDrag || IsSplinePointCreator) && DragSpline == spline && j == DragPointIndex)
{
dragSplineRenderer = splineRenderer;
continue;
}
DrawSplinePoint(ref args, ref evnt, splineRenderer, spline, j);
}
}
if (IsSplinePointCreator || IsJunctionDrag)
{
DrawSplinePoint(ref args, ref evnt, dragSplineRenderer, DragSpline, DragPointIndex);
}
if (evnt == SplineEditorEvent.SplinePointDrag || evnt == SplineEditorEvent.SplinePointCreatorDrag)
{
m_pointerOver = false;
}
if (evnt == SplineEditorEvent.SplinePointDrop || evnt == SplineEditorEvent.SplinePointCreatorDrop)
{
if (m_pointerOverSpline != null && m_pointerOverSplinePointIndex != -1)
{
if (!m_pointerOver)
{
m_pointerOverSpline = null;
m_pointerOverSplinePointIndex = -1;
}
args = new SplineEditorEventArgs(m_pointerOverSpline, m_pointerOverSplinePointIndex);
m_pointerOverSpline = null;
m_pointerOverSplinePointIndex = -1;
}
}
return(evnt);
}
public override void OnInspectorGUI()
{
SerializedObject sObj = GetSerializedObject();
sObj.Update();
m_firstTarget = targets[0];
if (m_splineBase == null)
{
m_splineBase = GetTarget();
}
if (m_splineBase == null)
{
return;
}
DrawSelectedPointInspectorsOverride();
OnInspectorGUIOverride();
if (target != null)
{
sObj.ApplyModifiedProperties();
}
}
private void EndDrag()
{
if (m_junctionDrag)
{
if (m_dragJunction.ConnectionsCount < 2)
{
DestroyObject(m_dragJunction.gameObject);
}
}
m_beforeSplinePointCreatorDrag = false;
m_splinePointCreatorDrag = false;
m_splinePointDrag = false;
m_beforeJunctionDrag = false;
m_junctionDrag = false;
m_splineCtrlPointDrag = false;
m_newJunction = null;
m_dragSpline = null;
m_dragPointIndex = -1;
m_dragCtrlPointIndex = -1;
m_dragJunction = null;
}
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 override void OnInspectorGUI()
{
SplineBase spline = (target as SplineBase);
if (GUILayout.Button("Copy material parameters to layer"))
{
Layer layer = spline.Layer;
Material[] sharedMaterials = spline.GetComponent <Renderer>().sharedMaterials;
for (int i = 0; i < sharedMaterials.Length; ++i)
{
if (!sharedMaterials[i].HasProperty("CMain"))
{
continue;
}
layer.mainColor = sharedMaterials[i].GetColor("CMain");
layer.specularColor = sharedMaterials[i].GetColor("CSpecular");
layer.fresnelIntensity = sharedMaterials[i].GetFloat("CFresnelIntensity");
layer.diffuse.tile = sharedMaterials[i].GetFloat("CDiffuseTile");
layer.detail.tile = sharedMaterials[i].GetFloat("CDetailTile");
layer.normal.tile = sharedMaterials[i].GetFloat("CNormalTile");
layer.detailNormal.tile = sharedMaterials[i].GetFloat("CDetailNormalTile");
layer.normal.bump = sharedMaterials[i].GetFloat("CNormalBump");
layer.detailNormal.bump = sharedMaterials[i].GetFloat("CDetailNormalBump");
}
}
}
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));
}
static void AddPoint(SplineBase spline)
{
Vector3[] points = spline.Points;
string[] colorNames = spline.Info.colorNames;
int i = spline.ActivePoint;
if (spline.IsHazard)
{
ArrayUtility.Insert(ref colorNames, i, colorNames[i]);
}
if (i != 0)
{
ArrayUtility.Insert(ref points, i, Vector3.Lerp(points[i], points[i - 1], 0.5f));
points[i].y = CourseBase.TerrainHeight(points[i].x, points[i].z);
points[i - 1].y = CourseBase.TerrainHeight(points[i - 1].x, points[i - 1].z);
}
else
{
ArrayUtility.Insert(ref points, i, Vector3.Lerp(points[i], points[points.Length - 1], 0.5f));
points[i].y = CourseBase.TerrainHeight(points[i].x, points[i].z);
points[points.Length - 1].y = CourseBase.TerrainHeight(points[points.Length - 1].x, points[points.Length - 1].z);
}
spline.Points = points;
spline.Info.colorNames = colorNames;
spline.UpdateLine();
spline.LineChanged();
}
protected override void Initialize()
{
base.Initialize();
Setup.Initialize(Editor.graphics);
Setup.ShowCurves = false;
Setup.ShowDirectionVectors = false;
Setup.ShowLines = false;
Setup.ShowPoints = false;
UseWorldUnits = true;
MySpline = Editor.Content.Load <SplineBase>("RaceTrack");
MySpline.PolygonStripeTexture = Editor.Content.Load <Texture2D>("roadTexture");
MySpline.Loop = true;
GetSpline = MySpline;
CenterSpline();
SetMultiSampleCount(8);
Editor.SetDisplayStyle = Forms.Services.GFXService.DisplayStyle.TopRight;
Editor.ShowCursorPosition = false;
Editor.ShowFPS = false;
OnMouseWheelUpwards += PolygonSplineControl_OnMouseWheelUpwards;
OnMouseWheelDownwards += PolygonSplineControl_OnMouseWheelDownwards;
}
private void Start()
{
SplineRuntimeEditor.Created += OnRuntimeEditorCreated;
SplineRuntimeEditor.Destroyed += OnRuntimeEditorDestroyed;
CreateRuntimeComponents();
if (m_spline == null)
{
m_spline = GetComponentInParent <SplineBase>();
if (m_spline == null)
{
Debug.LogError("Is not a child of gameobject with Spline or MeshDeformer component");
return;
}
m_spline.ControlPointModeChanged -= OnControlPointModeChanged;
m_spline.ControlPointModeChanged += OnControlPointModeChanged;
m_spline.ControlPointPositionChanged -= OnControlPointPositionChanged;
m_spline.ControlPointPositionChanged += OnControlPointPositionChanged;
}
m_localPosition = m_spline.GetControlPointLocal(m_index);
transform.localPosition = m_localPosition;
UpdateMaterial();
}
public static GameObject CreatePointsLister(string nameGameObject = "Points Lister")
{
GameObject whereToPut;
if (Selection.activeGameObject != null)
{
SplineBase spline = Selection.activeGameObject.GetComponent <SplineBase>();
if (spline != null)
{
whereToPut = new GameObject(nameGameObject);
whereToPut.transform.SetParent(spline.transform);
whereToPut.transform.localPosition = Vector3.zero;
Undo.RegisterCreatedObjectUndo(whereToPut, "Create " + nameGameObject);
}
else
{
whereToPut = Selection.activeGameObject;
}
}
else
{
whereToPut = new GameObject(nameGameObject);
whereToPut.transform.localPosition = Vector3.zero;
Undo.RegisterCreatedObjectUndo(whereToPut, "Create " + nameGameObject);
}
return(whereToPut);
}
protected override void LoadContent()
{
spriteBatch = new SpriteBatch(GraphicsDevice);
// Loading a spline with the MonoGame.SplineFlower.Content.Pipeline
// MySpline = Content.Load<SplineBase>(@"BezierTest");
// MySpline = Content.Load<SplineBase>(@"CatMulRomTest");
MySpline = Content.Load <SplineBase>(@"HermiteTest");
// Place a SplineWalker on the spline
MySplineWalker = new Car();
MySplineWalker.CreateSplineWalker(MySpline, SplineWalker.SplineWalkerMode.Loop, 7);
MySplineWalker.LoadContent(Content, Content.Load <SpriteFont>(@"GameFont"));
// Uncomment to directly set the position of the spline (SplineCenter)
// MySpline.Position(new Vector2(200, 150));
// Uncomment to translate all control points of the spline from where the it spawned
// MySpline.Translate(new Vector2(200, 150));
// Uncomment to rotate the spline
// MySpline.Rotate(-90f);
// Uncomment to scale the spline
// MySpline.Scale(-50f);
// Uncomment to scale-rotate the spline and scale it again afterwards
// MySpline.ScaleRotate(-180f);
// MySpline.Scale(-50f);
}
private void Awake()
{
enabled = false;
m_splinePoint = GetComponentInParent <SplinePointBase>();
m_spline = GetComponentInParent <SplineBase>();
}
static void HazardChangeClear()
{
startSpline = null;
startSplineIndex = -1;
startSplineDirection = 1;
startSplineLayer = null;
endSplineIndex = -1;
}
private void OnScriptReloaded()
{
m_spline = GetComponent <SplineBase>();
if (GLRenderer.Instance != null)
{
GLRenderer.Instance.Add(this);
}
}
private void Start()
{
if (m_spline == null)
{
m_spline = GetComponent <SplineBase>();
}
Initialize();
}
public override void ChangeSpline(SplineBase newSpline, float newPosition)
{
base.ChangeSpline(newSpline, newPosition);
ManageSplineChange();
if (_isOnDifferentSpline)
{
_lastPathPosition = newPosition;
}
}
//protected virtual void OnStartDragging(GameObject current)
//{
// if (_splineController == null)
// {
// return;
// }
// if (current != _splineController.gameObject)
// {
// return;
// }
// this.UpdateEditor();
//
// _anchorOption = this.GetPropertie("_anchorOnSplineMoved").boolValue;
// this.GetPropertie("_anchorOnSplineMoved").boolValue = true;
//
//
// _positionAtStartLerp = _previousDraggingPosition = _splineController.PathPosition;
// //SetSticky(false);
// this.ApplyModification();
//}
//protected virtual void OnEndDragging(GameObject current)
//{
// if (_splineController == null)
// {
// return;
// }
// if (current != _splineController.gameObject)
// {
// return;
// }
// this.UpdateEditor();
//
// this.GetPropertie("_anchorOnSplineMoved").boolValue = _anchorOption;
//
//
// //SetSticky(true);
// this.ApplyModification();
//}
public void ConstructSpline(SplineBase spline)
{
this.UpdateEditor();
if (spline != null)
{
ExtSerializedProperties.SetObjectReferenceValueIfEmpty <SplineBase>(this.GetPropertie("_spline"), spline.transform);
}
ExtSerializedProperties.SetObjectReferenceValueIfEmpty <Transform>(this.GetPropertie("_toMove"), _splineController.transform);
this.ApplyModification();
}
public static float GetLengthAS(this SplineBase spline, int curve, float tmax, float error)
{
Vector3[] v = spline.Slice(curve, tmax);
float length = 0.0f;
AddIfClose(v, ref length, error);
return(length);
}
protected override SplineBase GetTarget()
{
ControlPoint controlPoint = (ControlPoint)target;
if (controlPoint != null)
{
SplineBase spline = controlPoint.GetComponentInParent <SplineBase>();
return(spline);
}
return(null);
}
protected override SplineBase GetTarget()
{
Scaffold scaffold = (Scaffold)target;
if (scaffold != null)
{
SplineBase spline = scaffold.GetComponentInParent <SplineBase>();
return(spline);
}
return(null);
}
private void Start()
{
SplineFollow[] splineFollow = SplineFollow.Where(sf => sf != null).ToArray();
if (splineFollow.Length == 0)
{
return;
}
if (Distances.Length == 0)
{
Debug.LogError("At least one distance required");
return;
}
int initialDistancesCount = Distances.Length;
System.Array.Resize(ref Distances, SplineFollow.Length - 1);
for (int i = initialDistancesCount; i < Distances.Length; ++i)
{
Distances[i] = Distances[i % initialDistancesCount];
}
float offset = InitialOffset;
SplineBase spline = splineFollow[0].Spline;
for (int i = 0;; ++i)
{
SplineFollow sf = splineFollow[i];
if (sf.Spline != spline)
{
Debug.LogError("SplineFollow.Spline != " + spline);
return;
}
sf.Offset = offset;
if (i == splineFollow.Length - 1)
{
break;
}
float distance = Distances[i];
Vector3 pt0 = spline.GetPoint(offset);
for (int j = 1; j <= Precision; ++j)
{
float t = offset - ((float)j) / Precision;
if (t < 0)
{
t = (1.0f + t % 1.0f);
}
Vector3 pt = spline.GetPoint(t);
if ((pt - pt0).magnitude >= distance)
{
offset = t;
break;
}
}
}
}
private void OnDisable()
{
OnDisableOverride();
SplineBase spline = GetTarget();
if (spline)
{
spline.Unselect();
}
}
