void AddPoint(TrailPoint point, Vector3 direction, float uv)
{
float lifePercent = (Time.time - point.creationTime) / lefttime;
float halfWidth = unit;// (1 - lifePercent) * unit;
float normalStrength = 1 - lifePercent;
Vector2 dir = new Vector2();
dir.x = direction.x * 0.5f + 0.5f;
dir.y = direction.z * 0.5f + 0.5f;
Color normalStrengthColor = new Color(dir.x, normalStrength * 0.5f, dir.y, 1f);
Vector3 pos = point.pos;
Vector3 right = Vector3.Cross(upDir, direction);
vertices.Add(pos - right * halfWidth);
vertices.Add(pos + right * halfWidth);
colors.Add(normalStrengthColor);
colors.Add(normalStrengthColor);
int lastVert = vertices.Count - 1;
if (lastVert >= 3)
{
triangles.Add(lastVert - 1);
triangles.Add(lastVert);
triangles.Add(lastVert - 2);
triangles.Add(lastVert - 2);
triangles.Add(lastVert - 3);
triangles.Add(lastVert - 1);
}
}
public TrailPoint AddPoint(ITrailOwner owner)
{
TrailPoint point = new TrailPoint(owner);
queue.Enqueue(point);
return(point);
}
public void myUpdate()
{
float delta = 0;
delta = (transform.position - trailPointList.First.Value.pos).magnitude;
Vector3 newPos = transform.position;
Quaternion newRot = transform.rotation;
++num;
TrailPoint point = new TrailPoint(newPos, newRot, num, newPos.magnitude);
if( flyingDevice.isInAir() == true ){
numOfAir++;
point.state = SegmentState.AIR;
}else{
numOfGround++;
point.state = SegmentState.GROUND;
}
trailPointList.AddFirst(point);
LinkedListNode<SegmentScript> runner = segmentList.Last; //doesn't matter from which side we start, because we move each at same rate.
while (runner != null)
{
runner.Value.move(delta);
runner = runner.Previous;
}
if (create)
{
create_segment();
create = false;
}
trim_tail();
}
private void AddPoint(TrailPoint point, Vector3 direction, float uv)
{
float lifePercent = (Time.time - point.creationTime) / lifetime;
float halfWidth = width.Evaluate(lifePercent);
float normalStrength = strength.Evaluate(lifePercent);
Color normalStrengthColor = new Color(normalStrength, normalStrength, normalStrength, normalStrength);
direction.Normalize();
Vector3 pos = point.pos;
Vector3 right = Vector3.Cross(upDir, direction);
vertices.Add(pos - right * halfWidth);
vertices.Add(pos + right * halfWidth);
uvs.Add(new Vector2(0, uv));
uvs.Add(new Vector2(1, uv));
normals.Add(upDir);
normals.Add(upDir);
tangents.Add(new Vector4(direction.x, direction.y, direction.z, 1));
tangents.Add(new Vector4(direction.x, direction.y, direction.z, 1));
colors.Add(normalStrengthColor);
colors.Add(normalStrengthColor);
int lastVert = vertices.Count - 1;
if (lastVert >= 3)
{
triangles.Add(lastVert - 1);
triangles.Add(lastVert);
triangles.Add(lastVert - 2);
triangles.Add(lastVert - 2);
triangles.Add(lastVert - 3);
triangles.Add(lastVert - 1);
}
}
private void UpdateMesh(List <TrailPoint> renderPoints)
{
mesh.Clear();
if (renderPoints.Count < 2)
{
return;
}
//Clear lists
vertices.Clear();
triangles.Clear();
uvs.Clear();
normals.Clear();
tangents.Clear();
colors.Clear();
float uvFactor = 1.0f / (renderPoints.Count - 1);
//Iterate though all previous points
for (int i = 0; i < renderPoints.Count; i++)
{
//First point
TrailPoint point = renderPoints[i];
if (i == 0)
{
AddPoint(point, renderPoints[i + 1].pos - point.pos, 0);
continue;
}
//Last point
TrailPoint lastPoint = renderPoints[i - 1];
if (i == renderPoints.Count - 1)
{
AddPoint(point, point.pos - lastPoint.pos, 1);
break;
}
//In-between points
TrailPoint nextPoint = renderPoints[i + 1];
AddPoint(point, nextPoint.pos - lastPoint.pos, i * uvFactor);
}
mesh.vertices = vertices.ToArray();
mesh.triangles = triangles.ToArray();
mesh.uv = uvs.ToArray();
mesh.normals = normals.ToArray();
mesh.tangents = tangents.ToArray();
mesh.colors = colors.ToArray();
//Those only work in Unity 5.2 and above... shouldn't be much faster anyways.
//mesh.SetVertices(vertices);
//mesh.SetTriangles(triangles, 0);
//mesh.SetUVs(0, uvs);
//mesh.SetNormals(normals);
//mesh.SetTangents(tangents);
//mesh.SetColors(colors);
}
/// <summary>
/// Adds new <see cref="TrailPoint"></see>.
/// </summary>
/// <param name="code">Code of trail point.</param>
/// <param name="name">Name of trail point.</param>
public void AddTrailPoint(string code, string name)
{
var trailPoint = new TrailPoint
{
Code = code,
Name = name,
};
_dataSource.AddTrailPoint(trailPoint);
}
private void ShiftMeshArrays()
{
bool removeTwo = _points[0].ConnectsNext && _pointsCount > 1 && !_points[1].ConnectsNext;
bool removeTris = removeTwo || _points[0].ConnectsNext;
var newPoints = new TrailPoint[_points.Length];
Array.Copy(_points, removeTwo ? 2 : 1, newPoints, 0, _points.Length - (removeTwo ? 2 : 1));
_points = newPoints;
Vector3[] verts = new Vector3[_mesh.vertices.Length];
Vector2[] uvs = new Vector2[_mesh.uv.Length];
Color[] cols = new Color[_mesh.colors.Length];
Vector3[] norms = new Vector3[_mesh.normals.Length];
int vertsToRemove = removeTwo ? 4 : 2;
Array.Copy(_mesh.vertices, vertsToRemove, verts, 0, _mesh.vertices.Length - vertsToRemove);
Array.Copy(_mesh.uv, vertsToRemove, uvs, 0, _mesh.uv.Length - vertsToRemove);
Array.Copy(_mesh.colors, vertsToRemove, cols, 0, _mesh.colors.Length - vertsToRemove);
Array.Copy(_mesh.normals, vertsToRemove, norms, 0, _mesh.normals.Length - vertsToRemove);
_mesh.vertices = verts;
_mesh.uv = uvs;
_mesh.colors = cols;
_mesh.normals = norms;
var tris = _mesh.triangles;
for (int i = 0; i < tris.Length; i++)
{
tris[i] -= vertsToRemove;
if (tris[i] < 0)
{
tris[i] = 0;
}
}
if (removeTris)
{
_trisCount -= 2;
var newTris = new int[_trisCount * 3];
Array.Copy(tris, 6, newTris, 0, tris.Length - 6);
tris = newTris;
}
_mesh.triangles = tris;
_pointsCount -= removeTwo ? 2 : 1;
_points[0].ConnectsPrevious = false;
}
private void CreatePoint()
{
TrailPoint p = new TrailPoint()
{
position = transform.position,
lifeTime = lifeTime
};
points.Insert(0, p);
lastPos = transform.position;
}
private bool CheckShouldBeAdded(TrailPoint newPoint, TrailPoint referencePoint)
{
Vector3 diff = (newPoint.Point2 + newPoint.Point1) / 2 -
(referencePoint.Point2 + referencePoint.Point1) / 2;
if (diff.sqrMagnitude < _minDistanceBetweenSegmentsSqr)
{
return(false);
}
if (diff.sqrMagnitude > newPoint.Vector.sqrMagnitude &&
diff.sqrMagnitude > referencePoint.Vector.sqrMagnitude)
{
return(true);
}
if (AngleTo90(newPoint.Point1 - newPoint.Point2, referencePoint.Point1 - referencePoint.Point2) < 15f)
{
return(true);
}
Vector3 referencePerpendicular =
Vector3.Cross(referencePoint.Point2 - referencePoint.Point1, referencePoint.Normal);
Vector3 halfPlaneDirection = referencePerpendicular *
Mathf.Sign(Vector3.Dot(referencePerpendicular, referencePoint.DeltaPosition));
int c = 0;
if (Vector3.Dot(newPoint.Point1 - referencePoint.Point1, halfPlaneDirection) > 0)
{
c++;
}
if (Vector3.Dot(newPoint.Point1 - referencePoint.Point2, halfPlaneDirection) > 0)
{
c++;
}
if (Vector3.Dot(newPoint.Point2 - referencePoint.Point1, halfPlaneDirection) > 0)
{
c++;
}
if (Vector3.Dot(newPoint.Point2 - referencePoint.Point2, halfPlaneDirection) > 0)
{
c++;
}
return(c >= 3);
}
private void UpdateTrailPoints(float deltaTime)
{
for (int i = trailPoints.Length - 1; i >= 0; i--)
{
TrailPoint p = trailPoints[i];
if (p.isObsolete)
{
trailPoints.RemoveAtSwapBack(i);
}
else
{
p.Attenuate(trailAttenuation * deltaTime);
trailPoints[i] = p;
}
}
}
// Use this for initialization
void Start()
{
GameObject parent = new GameObject();
parent.name = "TrailParent";
for (int i = 0; i < numberOfTrailPoints; i++)
{
Debug.Log("Instantiating 'pool'");
TrailPoint newPoint = Instantiate(trailPointPrefab, transform.position, transform.rotation).GetComponent <TrailPoint>();
inactiveTrailPoints.Add(newPoint);
newPoint.gameObject.name = "TrailPoint";
newPoint.transform.parent = parent.transform;
newPoint.gameObject.SetActive(false);
newPoint.trailHandler = this;
}
}
public void Execute()
{
for (int i = 0, n = trailPoints.Length; i < n; i++)
{
TrailPoint p = trailPoints[i];
ushort x = (ushort)math.floor(length * p.uv.x);
ushort y = (ushort)math.floor(length * p.uv.y);
// Inv. channel -> smaller value represents higher point strength.
ushort a = colors[y * length + x].r;
ushort b = (ushort)(255 - math.round(255 * p.strength));
// Keep a if it's clearly stronger than b.
// TODO threshold (64) should be derived from life time.
byte col = (byte)(a + 64 < b ? a : b);
colors[y * length + x] = new Color32(col, col, col, 255);
}
}
public void AddSyncedTrailPoints(Vector3[] positions)
{
trailPointList.Clear(); //reset
for(int i=0; i<positions.Length; ++i) {
TrailPoint newPoint = new TrailPoint(
positions[i],
trailNum++
);
if(shouldShowTrail) {
GameObject newTrailGizmo = Instantiate(trailGizmo) as GameObject;
newTrailGizmo.transform.SetParent(null);
newTrailGizmo.name = trailNum.ToString();
newTrailGizmo.transform.position = positions[i];
newTrailGizmo.transform.GetChild(0).GetComponent<MeshRenderer>().material.color = Color.blue;
newTrailGizmo.transform.LookAt(Vector3.zero);
}
trailPointList.AddLast(newPoint);
}
isSet = true;
}
void RemoveOldPoints(List <TrailPoint> pointList)
{
List <TrailPoint> remove = new List <TrailPoint>();
for (int i = 0; i < pointList.Count; i++)
{
TrailPoint p = pointList[i];
if (Time.time - p.timeCreated > lifeTime)
{
remove.Add(p);
}
}
foreach (TrailPoint p in remove)
{
pointList.Remove(p);
}
}
// Update is called once per frame
void Update()
{
if (trailTimer + trailFrequencyInSeconds < Time.time)
{
if (inactiveTrailPoints.Count > 0)
{
trailTimer = Time.time;
TrailPoint newPoint = inactiveTrailPoints[0];
activeTrailPoints.Add(newPoint);
inactiveTrailPoints.RemoveAt(0);
newPoint.deactivationTime = trailPointLifetime;
newPoint.trailPointType = currentTrailType;
newPoint.transform.position = transform.position;
newPoint.gameObject.SetActive(true);
if (lastTrailPoint)
{
newPoint.connectedTrailPoint = lastTrailPoint;
}
lastTrailPoint = newPoint;
}
}
}
// Update is called once per frame
void Update()
{
while (points.Count > 0)
{
if (Time.time - points[0].creationTime > lefttime)
{
points.RemoveAt(0);
}
else
{
break;
}
}
Vector3 pos = transform.position;
bool addedPoint = false;
if (points.Count == 0 || Vector3.Distance(points[points.Count - 1].pos, pos) > minVertexDistance)
{
points.Add(new TrailPoint(pos, Time.time));
addedPoint = true;
}
List <TrailPoint> renderPoints = new List <TrailPoint>(points);
if (!addedPoint)
{
renderPoints.Add(new TrailPoint(pos, Time.time));
}
if (renderPoints.Count < 2)
{
return;
}
mesh.Clear();
if (renderPoints.Count < 2)
{
return;
}
vertices.Clear();
triangles.Clear();
colors.Clear();
float uvFactor = 1f / (renderPoints.Count - 1);
for (int i = 0; i < renderPoints.Count; i++)
{
TrailPoint point = renderPoints[i];
if (i == 0)
{
AddPoint(point, renderPoints[i + 1].pos - point.pos, 0);
continue;
}
TrailPoint lastPoint = renderPoints[i - 1];
if (i == renderPoints.Count - 1)
{
AddPoint(point, point.pos - lastPoint.pos, 1f);
break;
}
TrailPoint nextPoint = renderPoints[i + 1];
AddPoint(point, nextPoint.pos - lastPoint.pos, i * uvFactor);
}
mesh.vertices = vertices.ToArray();
mesh.triangles = triangles.ToArray();
mesh.colors = colors.ToArray();
Graphics.DrawMesh(mesh, Matrix4x4.identity, material, layer);
}
void Start()
{
flyingDevice = Flying.instance;
tailLength = firstTrailSize;
segmentList = new LinkedList<SegmentScript>();
trailPointList = new LinkedList<TrailPoint>();
Vector3 newPos = transform.position;
Quaternion newRot = transform.rotation;
++num;
TrailPoint point = new TrailPoint(newPos, newRot, num, newPos.magnitude);
point.state = SegmentState.GROUND;
++numOfGround;
trailPointList.AddFirst(point);
}
void LateUpdate()
{
if (!_isInitialized)
{
return;
}
int numPoints = dots.Count;
if (Emit)
{
TrailPoint p = new TrailPoint();
p.basePosition = _baseAnchor.position;
p.circlePoints = MakeCircle();
p.rotationVector = _baseAnchor.rotation.eulerAngles;
p.timeCreated = Time.time;
points.Add(p);
}
RemoveOldPoints(points);
if (points.Count == 0)
{
trailMesh.Clear();
}
if (points.Count > 0)
{
newVertices = new Vector3[points.Count * dots.Count];
newUV = new Vector2[points.Count * dots.Count];
newTriangles = new int[points.Count * (dots.Count * 6 + 6)]; //+6
colors = new Color[points.Count * dots.Count];
int trianglesCounter = 0;
float uRatio = 1.0f / (float)(points.Count);
float vRatio = 1.0f / (points.Count);
float colorPart = 1.0f / points.Count;
float coneDecresCoef = 1f;//(1.0f - coneCoef) / points.Count;
Vector3[] prevPos = null;
trianglesCounter = (numPoints) * (points.Count) * 6 - 1;
for (int i = points.Count - 1; i >= 0; i--)
{
TrailPoint p = points[i];
Color curColor = _gradient.Evaluate((points.Count - i) * colorPart);
for (int j = numPoints - 1; j >= 0; j--)
{
Vector3 currentPoint = p.circlePoints[j];
Vector3 newPoint = Quaternion.Euler(p.rotationVector) * currentPoint + p.basePosition;// ((currentPoint) * (coneCoef + i * coneDecresCoef)) + p.basePosition;
// Vector3 newPoint = ((currentPoint - p.basePosition) * (coneCoef + i * coneDecresCoef)) + p.basePosition;
newVertices[i * numPoints + j] = newPoint;
newUV[i * numPoints + j] = new Vector2((numPoints - j) * uRatio, (points.Count - i) * vRatio);
colors[i * numPoints + j] = curColor;
if (j % n == 0)
{
int index = j / (numPoints - n);
if (prevPos != null)
{
Debug.DrawLine(prevPos[index], newPoint, Color.blue);
}
else
{
prevPos = new Vector3[n];
}
prevPos[index] = newPoint;
}
}
if (i > 0)
{
for (int j = numPoints - 2; j >= 0; j--)
{
newTriangles[trianglesCounter--] = (i - 1) * numPoints + j;
newTriangles[trianglesCounter--] = (i - 1) * numPoints + (j + 1);
newTriangles[trianglesCounter--] = i * numPoints + j;
newTriangles[trianglesCounter--] = (i - 1) * numPoints + (j + 1);
newTriangles[trianglesCounter--] = i * numPoints + (j + 1);
newTriangles[trianglesCounter--] = i * numPoints + j;
}
newTriangles[trianglesCounter--] = (i - 1) * numPoints;
newTriangles[trianglesCounter--] = i * numPoints;
newTriangles[trianglesCounter--] = (i - 1) * numPoints + (numPoints - 1);
newTriangles[trianglesCounter--] = i * numPoints;
newTriangles[trianglesCounter--] = i * numPoints + (numPoints - 1);
newTriangles[trianglesCounter--] = (i - 1) * numPoints + (numPoints - 1);
}
}
// for(int i = 0; i < newTriangles.Length - 1; i++)
// {
// Debug.DrawLine(newVertices[newTriangles[i]],newVertices[newTriangles[i + 1]], Color.red);
// }
trailMesh.Clear();
trailMesh.vertices = newVertices;
trailMesh.uv = newUV;
trailMesh.colors = colors;
trailMesh.triangles = newTriangles;
if (meshCollider != null)
{
meshCollider.sharedMesh = trailMesh;
}
trailMesh.RecalculateNormals();
}
}
private void AddPoint(TrailPoint point, Vector3 direction, float uv)
{
float lifePercent = (Time.time - point.creationTime) / lifetime;
float halfWidth = width.Evaluate(lifePercent);
float normalStrength = strength.Evaluate(lifePercent);
Color normalStrengthColor = new Color(normalStrength, normalStrength, normalStrength, normalStrength);
direction.Normalize();
Vector3 pos = point.pos;
Vector3 right = Vector3.Cross(upDir, direction);
vertices.Add(pos - right * halfWidth);
vertices.Add(pos + right * halfWidth);
uvs.Add(new Vector2(0, uv));
uvs.Add(new Vector2(1, uv));
normals.Add(upDir);
normals.Add(upDir);
tangents.Add(new Vector4(direction.x, direction.y, direction.z, 1));
tangents.Add(new Vector4(direction.x, direction.y, direction.z, 1));
colors.Add(normalStrengthColor);
colors.Add(normalStrengthColor);
int lastVert = vertices.Count-1;
if (lastVert >= 3)
{
triangles.Add(lastVert - 1);
triangles.Add(lastVert);
triangles.Add(lastVert - 2);
triangles.Add(lastVert - 2);
triangles.Add(lastVert - 3);
triangles.Add(lastVert - 1);
}
}
public void DeactivatePoint(TrailPoint trailPoint)
{
activeTrailPoints.Remove(trailPoint);
trailPoint.gameObject.SetActive(false);
inactiveTrailPoints.Add(trailPoint);
}
public static List<Point> CalculatePath(GameMap map, Point start, Point end)
{
// should never happen but just to be sure
if (start == end)
return new List<Point> {start};
// nodes are points we have walked to
Dictionary<Point, TrailPoint> nodes = new Dictionary<Point, TrailPoint>();
// points we have in a TrailPoint, but not yet evaluated.
List<TrailPoint> notEvaluated = new List<TrailPoint>();
TrailPoint tpOn = new TrailPoint(start, end, 0);
while (true)
{
nodes.Add(tpOn.MapTile, tpOn);
// get the neighbors
TrailPoint tpClosest = null;
foreach (Point ptOffset in offsets)
{
Point pt = new Point(tpOn.MapTile.X + ptOffset.X, tpOn.MapTile.Y + ptOffset.Y);
MapSquare square = map.SquareOrDefault(pt);
// off the map or not a road/bus stop
if ((square == null) || (!square.Tile.IsDriveable))
continue;
// already evaluated - add it in
if (nodes.ContainsKey(pt))
{
TrailPoint tpAlreadyEvaluated = nodes[pt];
tpAlreadyEvaluated.Cost = Math.Min(tpAlreadyEvaluated.Cost, tpOn.Cost + 1);
tpOn.Neighbors.Add(tpAlreadyEvaluated);
continue;
}
// add this one in
TrailPoint tpNeighbor = new TrailPoint(pt, end, tpOn.Cost + 1);
tpOn.Neighbors.Add(tpNeighbor);
// may already be in notEvaluated. If so remove it as this is a more recent cost estimate
int indTp = notEvaluated.FindIndex(tp => tp.MapTile == tpNeighbor.MapTile);
if (indTp != -1)
notEvaluated.RemoveAt(indTp);
// we only assign to tpClosest if it is closer to the destination. If it's further away, then we
// use notEvaluated below to find the one closest to the dest that we have not walked yet.
if (tpClosest == null)
{
if (tpNeighbor.Distance < tpOn.Distance)
// new neighbor is closer - work from this next.
tpClosest = tpNeighbor;
else
// this is further away - put in the list to try if a better route is not found
notEvaluated.Add(tpNeighbor);
}
else
if (tpClosest.Distance <= tpNeighbor.Distance)
// this is further away - put in the list to try if a better route is not found
notEvaluated.Add(tpNeighbor);
else
{
// this is closer than tpOn and another neighbor - use it next.
notEvaluated.Add(tpClosest);
tpClosest = tpNeighbor;
}
}
// re-calc based on neighbors
tpOn.RecalculateDistance(ptOffMap, map.Width);
// if no closest, then get from notEvaluated. This is where it guarantees that we are getting the shortest
// route - we go in here if the above did not move a step closer. This may not either as the best choice
// may be the neighbor we didn't go with above - but we drop into this to find the closest based on what we know.
if (tpClosest == null)
{
if (notEvaluated.Count == 0)
{
Trap.trap();
break;
}
// We need the closest one as that's how we find the shortest path.
tpClosest = notEvaluated[0];
int index = 0;
for (int ind = 1; ind < notEvaluated.Count; ind++ )
{
TrailPoint tpNotEval = notEvaluated[ind];
if (tpNotEval.Distance >= tpClosest.Distance)
continue;
tpClosest = tpNotEval;
index = ind;
}
notEvaluated.RemoveAt(index);
}
// if we're at end - we're done!
if (tpClosest.MapTile == end)
{
tpClosest.Neighbors.Add(tpOn);
nodes.Add(tpClosest.MapTile, tpClosest);
break;
}
// try this one
tpOn = tpClosest;
}
List<Point> path = new List<Point>();
if (! nodes.ContainsKey(end))
{
Trap.trap();
return path;
}
// Create the return path - from end back to beginning.
tpOn = nodes[end];
path.Add(tpOn.MapTile);
while (tpOn.MapTile != start)
{
List<TrailPoint> neighbors = tpOn.Neighbors;
int cost = tpOn.Cost;
tpOn = tpOn.Neighbors[0];
for (int ind = 1; ind < neighbors.Count; ind++)
if (neighbors[ind].Cost < tpOn.Cost)
tpOn = neighbors[ind];
// we didn't get to the start.
if (tpOn.Cost >= cost)
{
Trap.trap();
return path;
}
path.Insert(0, tpOn.MapTile);
}
return path;
}
// Update is called once per frame
void Update()
{
// If the follow died, then die.
if (Follow == null)
{
// Disable it
Enabled = false;
}
else
{
// Cooldown
cooldown -= Time.deltaTime;
if (cooldown < 0)
{
// Reset it.
cooldown = DropRate;
// Check if we have a rigid body.
Vector2 normal = Vector2.zero;
Vector2 outdir = OutDir;
Rigidbody rigidBody = Follow.GetComponent <Rigidbody>();
if (rigidBody)
{
normal = new Vector2(-rigidBody.velocity.z, rigidBody.velocity.x).normalized;
}
else
{
normal = new Vector2(-BackwardsDir.y, BackwardsDir.x).normalized;
outdir = BackwardsDir;
}
// Drop down some points.
TrailPoint left = new TrailPoint();
left.Normal = normal;
left.Forwards = outdir;
left.Pos = new Vector2(Follow.position.x, Follow.position.z) + normal * StartWidth;
left.Speed = DispersionRate + Random.Range(-0.5f, 0.5f) * DispersionRate;
left.BackSpeed = BackSpeed; // + Follow.rigidbody.velocity.magnitude;
TrailPoint right = new TrailPoint();
right.Normal = normal;
right.Forwards = outdir;
right.Pos = new Vector2(Follow.position.x, Follow.position.z) - normal * StartWidth;
right.Speed = -DispersionRate + Random.Range(-0.5f, 0.5f) * DispersionRate;
right.BackSpeed = BackSpeed; // + Follow.rigidbody.velocity.magnitude;
// Set the color
if (BoostEnabled)
{
left.Color = BoostColor;
right.Color = BoostColor;
}
else
{
left.Color = Color;
right.Color = Color;
}
// Make them invisible if it is disabled.
if (!Enabled)
{
left.Color *= 0;
right.Color *= 0;
}
points.AddLast(right);
points.AddLast(left);
}
}
// If the point list is over the maximimum.
while (points.Count >= MaxVerts)
{
points.RemoveFirst();
}
// Update the points.
int count = 0;
bool allAlpha = true;
foreach (TrailPoint p in points)
{
p.Pos += p.Normal * p.Speed * Time.deltaTime;
p.Pos -= p.Forwards * p.BackSpeed * Time.deltaTime;
p.Color.a -= p.Color.a * AlphaDecay * Time.deltaTime;
vertices[count] = new Vector3(p.Pos.x, 0, p.Pos.y);
colors[count] = p.Color;
++count;
if (p.Color.a > 0.01f)
{
allAlpha = false;
}
}
if (allAlpha && Follow == null)
{
Destroy(gameObject);
}
// Create the mesh.
filter.mesh.vertices = vertices;
filter.mesh.uv = uvs;
filter.mesh.colors = colors;
// Generate indices
indices = new int[(points.Count - 2) * 3];
for (int i = 0; i < points.Count - 2; ++i)
{
if (i % 2 == 0)
{
indices[i * 3 + 0] = i;
indices[i * 3 + 1] = i + 1;
indices[i * 3 + 2] = i + 2;
}
else
{
indices[i * 3 + 0] = i + 2;
indices[i * 3 + 1] = i + 1;
indices[i * 3 + 2] = i;
}
}
//filter.mesh.SetTriangleStrip(indices, 0);
// Temp
filter.mesh.SetTriangles(indices, 0);
//filter.mesh.RecalculateNormals();
// Set the mesh bounds
filter.mesh.RecalculateBounds();
}
void addTrailPoint()
{
Vector3 newPos = transform.position.normalized;
TrailPoint point = new TrailPoint(newPos, trailNum++);
trailPointList.AddFirst(point);
if( shouldShowTrail) {
GameObject newTrailGizmo = Instantiate(trailGizmo) as GameObject;
newTrailGizmo.transform.SetParent(null);
newTrailGizmo.name = trailNum.ToString();
newTrailGizmo.transform.position = newPos;
newTrailGizmo.transform.LookAt(Vector3.zero);
}
}
public void AddTrailPoint(TrailPoint trailPoint)
{
TrailPoints.Add(trailPoint.Code, trailPoint);
}
