347 lines
7.6 KiB
C#
347 lines
7.6 KiB
C#
using System;
|
|
using System.Collections;
|
|
using UnityEngine;
|
|
using System.Collections.Generic;
|
|
|
|
public class WaypointCircuit : MonoBehaviour
|
|
{
|
|
public List<Transform> waypointList = new List<Transform> ();
|
|
public bool showGizmo;
|
|
public Color gizmoLabelColor;
|
|
public bool useHandleForVertex;
|
|
|
|
public bool showVertexHandles;
|
|
|
|
public Color handleGizmoColor;
|
|
public float gizmoRadius;
|
|
public float handleRadius;
|
|
|
|
public bool smoothRoute = true;
|
|
int numPoints;
|
|
Vector3[] points;
|
|
float[] distances;
|
|
|
|
[Range (1, 100)] public float editorVisualisationSubsteps = 100;
|
|
|
|
public float Length { get; set; }
|
|
|
|
//this being here will save GC allocs
|
|
int p0n;
|
|
int p1n;
|
|
int p2n;
|
|
int p3n;
|
|
|
|
float i;
|
|
Vector3 P0;
|
|
Vector3 P1;
|
|
Vector3 P2;
|
|
Vector3 P3;
|
|
|
|
// Use this for initialization
|
|
void Awake ()
|
|
{
|
|
if (waypointList.Count > 1) {
|
|
CachePositionsAndDistances ();
|
|
}
|
|
}
|
|
|
|
public Vector3 getClosestPosition (Vector3 position)
|
|
{
|
|
float minDistance = Mathf.Infinity;
|
|
|
|
int index = -1;
|
|
|
|
for (int i = 0; i < waypointList.Count; ++i) {
|
|
float distance = GKC_Utils.distance (position, waypointList [i].position);
|
|
|
|
if (distance < minDistance) {
|
|
minDistance = distance;
|
|
|
|
index = i;
|
|
}
|
|
}
|
|
|
|
if (index > -1) {
|
|
return waypointList [index].position;
|
|
} else {
|
|
return Vector3.zero;
|
|
}
|
|
}
|
|
|
|
public float getProgressValue (Vector3 position)
|
|
{
|
|
float minDistance = Mathf.Infinity;
|
|
|
|
int index = -1;
|
|
|
|
for (int i = 0; i < waypointList.Count; ++i) {
|
|
float distance = GKC_Utils.distance (position, waypointList [i].position);
|
|
|
|
if (distance < minDistance) {
|
|
minDistance = distance;
|
|
|
|
index = i;
|
|
}
|
|
}
|
|
|
|
if (index > -1) {
|
|
|
|
Vector3 closestPosition = waypointList [index].position;
|
|
|
|
float totalDistance = 0;
|
|
|
|
if (index > 0) {
|
|
Vector3 currentPosition = waypointList [0].position;
|
|
|
|
for (int i = 1; i < index; ++i) {
|
|
float distance = GKC_Utils.distance (currentPosition, waypointList [i].position);
|
|
|
|
totalDistance += distance;
|
|
|
|
currentPosition = waypointList [i].position;
|
|
}
|
|
|
|
return totalDistance;
|
|
|
|
} else {
|
|
float distance = GKC_Utils.distance (position, waypointList [0].position);
|
|
|
|
return distance;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
public RoutePoint GetRoutePoint (float dist)
|
|
{
|
|
// position and direction
|
|
Vector3 p1 = GetRoutePosition (dist);
|
|
Vector3 p2 = GetRoutePosition (dist + 0.1f);
|
|
|
|
Vector3 delta = p2 - p1;
|
|
|
|
return new RoutePoint (p1, delta.normalized);
|
|
}
|
|
|
|
public Vector3 GetRoutePosition (float dist)
|
|
{
|
|
numPoints = waypointList.Count;
|
|
|
|
int point = 0;
|
|
|
|
if (Length == 0) {
|
|
Length = distances [distances.Length - 1];
|
|
}
|
|
|
|
dist = Mathf.Repeat (dist, Length);
|
|
|
|
while (distances [point] < dist) {
|
|
++point;
|
|
}
|
|
|
|
|
|
// get nearest two points, ensuring points wrap-around start & end of circuit
|
|
p1n = ((point - 1) + numPoints) % numPoints;
|
|
p2n = point;
|
|
|
|
// found point numbers, now find interpolation value between the two middle points
|
|
|
|
i = Mathf.InverseLerp (distances [p1n], distances [p2n], dist);
|
|
|
|
if (smoothRoute) {
|
|
// smooth catmull-rom calculation between the two relevant points
|
|
|
|
// get indices for the surrounding 2 points, because
|
|
// four points are required by the catmull-rom function
|
|
p0n = ((point - 2) + numPoints) % numPoints;
|
|
p3n = (point + 1) % numPoints;
|
|
|
|
// 2nd point may have been the 'last' point - a dupe of the first,
|
|
// (to give a value of max track distance instead of zero)
|
|
// but now it must be wrapped back to zero if that was the case.
|
|
p2n = p2n % numPoints;
|
|
|
|
P0 = points [p0n];
|
|
P1 = points [p1n];
|
|
P2 = points [p2n];
|
|
P3 = points [p3n];
|
|
|
|
return CatmullRom (P0, P1, P2, P3, i);
|
|
} else {
|
|
// simple linear lerp between the two points:
|
|
|
|
p1n = ((point - 1) + numPoints) % numPoints;
|
|
p2n = point;
|
|
|
|
return Vector3.Lerp (points [p1n], points [p2n], i);
|
|
}
|
|
}
|
|
|
|
Vector3 CatmullRom (Vector3 p0, Vector3 p1, Vector3 p2, Vector3 p3, float i)
|
|
{
|
|
// comments are no use here... it's the catmull-rom equation.
|
|
// Un-magic this, lord vector!
|
|
return 0.5f * (2 * p1 + (-p0 + p2) * i + (2 * p0 - 5 * p1 + 4 * p2 - p3) * (i * i) + (-p0 + 3 * p1 - 3 * p2 + p3) * (i * i * i));
|
|
}
|
|
|
|
void CachePositionsAndDistances ()
|
|
{
|
|
// transfer the position of each point and distances between points to arrays for
|
|
// speed of lookup at runtime
|
|
points = new Vector3[waypointList.Count + 1];
|
|
|
|
distances = new float[waypointList.Count + 1];
|
|
|
|
float accumulateDistance = 0;
|
|
|
|
for (int i = 0; i < points.Length; ++i) {
|
|
Transform t1 = waypointList [(i) % waypointList.Count];
|
|
Transform t2 = waypointList [(i + 1) % waypointList.Count];
|
|
|
|
if (t1 != null && t2 != null) {
|
|
Vector3 p1 = t1.position;
|
|
Vector3 p2 = t2.position;
|
|
|
|
points [i] = waypointList [i % waypointList.Count].position;
|
|
|
|
distances [i] = accumulateDistance;
|
|
|
|
accumulateDistance += (p1 - p2).magnitude;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void addNewWayPoint ()
|
|
{
|
|
Vector3 newPosition = transform.position;
|
|
|
|
if (waypointList.Count > 0) {
|
|
newPosition = waypointList [waypointList.Count - 1].position + waypointList [waypointList.Count - 1].forward;
|
|
}
|
|
|
|
GameObject newWayPoint = new GameObject ();
|
|
|
|
newWayPoint.transform.SetParent (transform);
|
|
|
|
newWayPoint.transform.position = newPosition;
|
|
|
|
newWayPoint.name = (waypointList.Count + 1).ToString ();
|
|
|
|
waypointList.Add (newWayPoint.transform);
|
|
|
|
//Undo.RegisterCreatedObjectUndo (newWayPoint, "add new waypoint circuit");
|
|
updateComponent ();
|
|
}
|
|
|
|
public void addNewWayPointAtIndex (int index)
|
|
{
|
|
addNewWayPoint ();
|
|
|
|
GameObject currentWaypoint = waypointList [waypointList.Count - 1].gameObject;
|
|
|
|
currentWaypoint.transform.position = waypointList [index].position + waypointList [index].right * 3;
|
|
|
|
waypointList.Insert ((index + 1), currentWaypoint.transform);
|
|
|
|
waypointList.RemoveAt (waypointList.Count - 1);
|
|
|
|
renameWaypoints ();
|
|
}
|
|
|
|
public void renameWaypoints ()
|
|
{
|
|
for (int i = 0; i < waypointList.Count; ++i) {
|
|
waypointList [i].name = (i + 1).ToString ();
|
|
|
|
waypointList [i].SetParent (null);
|
|
|
|
waypointList [i].SetParent (transform);
|
|
}
|
|
|
|
updateComponent ();
|
|
}
|
|
|
|
public void resetWaypointsPositions ()
|
|
{
|
|
Vector3 targetPosition = Vector3.zero;
|
|
|
|
for (int i = 0; i < waypointList.Count; ++i) {
|
|
|
|
waypointList [i].localPosition = targetPosition;
|
|
|
|
targetPosition += Vector3.forward * 2;
|
|
}
|
|
|
|
updateComponent ();
|
|
}
|
|
|
|
public void updateComponent ()
|
|
{
|
|
GKC_Utils.updateComponent (this);
|
|
|
|
GKC_Utils.updateDirtyScene ("Update Waypoint Circut System", gameObject);
|
|
}
|
|
|
|
void OnDrawGizmos ()
|
|
{
|
|
if (!showGizmo) {
|
|
return;
|
|
}
|
|
|
|
if (GKC_Utils.isCurrentSelectionActiveGameObject (gameObject)) {
|
|
DrawGizmos ();
|
|
}
|
|
}
|
|
|
|
void OnDrawGizmosSelected ()
|
|
{
|
|
DrawGizmos ();
|
|
}
|
|
|
|
void DrawGizmos ()
|
|
{
|
|
if (showGizmo) {
|
|
if (waypointList.Count > 1) {
|
|
numPoints = waypointList.Count;
|
|
|
|
CachePositionsAndDistances ();
|
|
|
|
Length = distances [distances.Length - 1];
|
|
|
|
Gizmos.color = gizmoLabelColor;
|
|
Vector3 prev = waypointList [0].position;
|
|
|
|
if (smoothRoute) {
|
|
if (editorVisualisationSubsteps <= 0) {
|
|
editorVisualisationSubsteps = 1;
|
|
}
|
|
for (float dist = 0; dist < Length; dist += Length / editorVisualisationSubsteps) {
|
|
Vector3 next = GetRoutePosition (dist + 1);
|
|
Gizmos.DrawLine (prev, next);
|
|
prev = next;
|
|
}
|
|
Gizmos.DrawLine (prev, waypointList [0].position);
|
|
} else {
|
|
for (int n = 0; n < waypointList.Count; ++n) {
|
|
Vector3 next = waypointList [(n + 1) % waypointList.Count].position;
|
|
Gizmos.DrawLine (prev, next);
|
|
prev = next;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public struct RoutePoint
|
|
{
|
|
public Vector3 position;
|
|
public Vector3 direction;
|
|
|
|
public RoutePoint (Vector3 position, Vector3 direction)
|
|
{
|
|
this.position = position;
|
|
this.direction = direction;
|
|
}
|
|
}
|
|
} |