/// <summary>
/// Insert a trail into this trail renderer.
/// </summary>
/// <param name="from">The start position of the trail.</param>
/// <param name="to">The end position of the trail.</param>
/// <param name="distanceBetweenPoints">Distance between each point on the trail</param>
public void CreateTrail(Vector3 from, Vector3 to, float distanceBetweenPoints)
{
float distanceBetween = Vector3.Distance(from, to);
Vector3 dirVector = to - from;
dirVector = dirVector.normalized;
float currentLength = 0;
CircularBuffer <PCTrailPoint> newLine = new CircularBuffer <PCTrailPoint>(GetMaxNumberOfPoints());
int pointNumber = 0;
while (currentLength < distanceBetween)
{
PCTrailPoint newPoint = new PCTrailPoint();
newPoint.PointNumber = pointNumber;
newPoint.Position = from + dirVector * currentLength;
newLine.Add(newPoint);
InitialiseNewPoint(newPoint);
pointNumber++;
if (distanceBetweenPoints <= 0)
{
break;
}
else
{
currentLength += distanceBetweenPoints;
}
}
PCTrailPoint lastPoint = new PCTrailPoint();
lastPoint.PointNumber = pointNumber;
lastPoint.Position = to;
newLine.Add(lastPoint);
InitialiseNewPoint(lastPoint);
PCTrail newTrail = new PCTrail(GetMaxNumberOfPoints());
newTrail.Points = newLine;
_fadingTrails.Add(newTrail);
}
protected void AddPoint(PCTrailPoint newPoint, Vector3 pos)
{
if (_activeTrail == null)
{
return;
}
newPoint.Position = pos;
newPoint.PointNumber = _activeTrail.Points.Count == 0 ? 0 : _activeTrail.Points[_activeTrail.Points.Count - 1].PointNumber + 1;
InitialiseNewPoint(newPoint);
newPoint.SetDistanceFromStart(_activeTrail.Points.Count == 0
? 0
: _activeTrail.Points[_activeTrail.Points.Count - 1].GetDistanceFromStart() + Vector3.Distance(_activeTrail.Points[_activeTrail.Points.Count - 1].Position, pos));
if (TrailData.UseForwardOverride)
{
newPoint.Forward = TrailData.ForwardOverrideRelative
? _t.TransformDirection(TrailData.ForwardOverride.normalized)
: TrailData.ForwardOverride.normalized;
}
_activeTrail.Points.Add(newPoint);
}
protected override void InitialiseNewPoint(PCTrailPoint newPoint)
{
((SmokeTrailPoint)newPoint).RandomVec = Random.onUnitSphere * RandomForceScale;
}
protected override void UpdateTrail(PCTrail trail, float deltaTime)
{
if (trail.IsActiveTrail == false)
{
return;
}
//TODO Must optimize this further, I don't need to keep recalculating point positions unless we are
//dealng with the points between the last and 2nd last CP (+ the last CP itself)
int trailPointIndex = 0;
for (int i = 0; i < _controlPoints.Count; i++)
{
trail.Points[trailPointIndex].Position = _controlPoints[i].p;
if (TrailData.UseForwardOverride)
{
trail.Points[trailPointIndex].Forward = _controlPoints[i].forward;
}
trailPointIndex++;
if (i < _controlPoints.Count - 1)
{
Vector3 Handle1, Handle2;
float distanceBetween = Vector3.Distance(_controlPoints[i].p, _controlPoints[i + 1].p) / 2;
if (i == 0)
{
Handle1 = _controlPoints[i].p + (_controlPoints[i + 1].p - _controlPoints[i].p).normalized * distanceBetween;
}
else
{
Handle1 = _controlPoints[i].p + (_controlPoints[i + 1].p - _controlPoints[i - 1].p).normalized * distanceBetween;
}
int nextI = i + 1;
if (nextI == _controlPoints.Count - 1)
{
Handle2 = _controlPoints[nextI].p + (_controlPoints[nextI - 1].p - _controlPoints[nextI].p).normalized * distanceBetween;
}
else
{
Handle2 = _controlPoints[nextI].p + (_controlPoints[nextI - 1].p - _controlPoints[nextI + 1].p).normalized * distanceBetween;
}
PCTrailPoint currentHandle = trail.Points[trailPointIndex - 1];
PCTrailPoint nextHandle = trail.Points[(trailPointIndex - 1) + PointsBetweenControlPoints + 1];
for (int pointBetween = 0; pointBetween < PointsBetweenControlPoints; pointBetween++)
{
float t = (((float)pointBetween + 1f) / ((float)PointsBetweenControlPoints + 1f));
trail.Points[trailPointIndex].Position = GetPointAlongCurve(_controlPoints[i].p, Handle1, _controlPoints[i + 1].p, Handle2, t, 0.3f);
trail.Points[trailPointIndex].SetTimeActive(Mathf.Lerp(currentHandle.TimeActive(), nextHandle.TimeActive(), t));
if (TrailData.UseForwardOverride)
{
trail.Points[trailPointIndex].Forward = Vector3.Lerp(currentHandle.Forward, nextHandle.Forward, t);
}
trailPointIndex++;
}
}
}
int lastControlPointPointIndex = ((_controlPoints.Count - 1) + ((_controlPoints.Count - 1) * PointsBetweenControlPoints));
int prevControlPointPointIndex = lastControlPointPointIndex - PointsBetweenControlPoints - 1;
int activePointCount = lastControlPointPointIndex + 1;
float distanceFromStart = trail.Points[prevControlPointPointIndex].GetDistanceFromStart();
for (int i = prevControlPointPointIndex + 1; i < activePointCount; i++)
{
distanceFromStart += Vector3.Distance(trail.Points[i - 1].Position, trail.Points[i].Position);
trail.Points[i].SetDistanceFromStart(distanceFromStart);
}
}
private void GenerateMesh(PCTrail trail)
{
trail.mesh.Clear(false);
Vector3 camForward = Initialize.mainCam != null ? Initialize.mainCam.transform.forward : Vector3.forward;
if (TrailData.UseForwardOverride)
{
camForward = TrailData.ForwardOverride.normalized;
}
trail.activePointCount = NumberOfActivePoints(trail);
if (trail.activePointCount < 2)
{
return;
}
int vertIndex = 0;
for (int i = 0; i < trail.Points.Count; i++)
{
PCTrailPoint p = trail.Points[i];
float timeAlong = p.TimeActive() / TrailData.Lifetime;
if (p.TimeActive() > TrailData.Lifetime)
{
continue;
}
if (TrailData.UseForwardOverride && TrailData.ForwardOverrideRelative)
{
camForward = p.Forward;
}
Vector3 cross = Vector3.zero;
if (i < trail.Points.Count - 1)
{
cross =
Vector3.Cross((trail.Points[i + 1].Position - p.Position).normalized, camForward).
normalized;
}
else
{
cross =
Vector3.Cross((p.Position - trail.Points[i - 1].Position).normalized, camForward).
normalized;
}
//yuck! lets move these into their own functions some time
Color c = TrailData.StretchColorToFit ?
(TrailData.UsingSimpleColor ? Color.Lerp(TrailData.SimpleColorOverLifeStart, TrailData.SimpleColorOverLifeEnd, 1 - ((float)vertIndex / (float)trail.activePointCount / 2f)) : TrailData.ColorOverLife.Evaluate(1 - ((float)vertIndex / (float)trail.activePointCount / 2f))) :
(TrailData.UsingSimpleColor ? Color.Lerp(TrailData.SimpleColorOverLifeStart, TrailData.SimpleColorOverLifeEnd, timeAlong) : TrailData.ColorOverLife.Evaluate(timeAlong));
float s = TrailData.StretchSizeToFit ?
(TrailData.UsingSimpleSize ? Mathf.Lerp(TrailData.SimpleSizeOverLifeStart, TrailData.SimpleSizeOverLifeEnd, 1 - ((float)vertIndex / (float)trail.activePointCount / 2f)) : TrailData.SizeOverLife.Evaluate(1 - ((float)vertIndex / (float)trail.activePointCount / 2f))) :
(TrailData.UsingSimpleSize ? Mathf.Lerp(TrailData.SimpleSizeOverLifeStart, TrailData.SimpleSizeOverLifeEnd, timeAlong) : TrailData.SizeOverLife.Evaluate(timeAlong));
trail.verticies[vertIndex] = p.Position + cross * s;
if (TrailData.MaterialTileLength <= 0)
{
trail.uvs[vertIndex] = new Vector2((float)vertIndex / (float)trail.activePointCount / 2f, 0);
}
else
{
trail.uvs[vertIndex] = new Vector2(p.GetDistanceFromStart() / TrailData.MaterialTileLength, 0);
}
trail.normals[vertIndex] = camForward;
trail.colors[vertIndex] = c;
vertIndex++;
trail.verticies[vertIndex] = p.Position - cross * s;
if (TrailData.MaterialTileLength <= 0)
{
trail.uvs[vertIndex] = new Vector2((float)vertIndex / (float)trail.activePointCount / 2f, 1);
}
else
{
trail.uvs[vertIndex] = new Vector2(p.GetDistanceFromStart() / TrailData.MaterialTileLength, 1);
}
trail.normals[vertIndex] = camForward;
trail.colors[vertIndex] = c;
vertIndex++;
}
Vector2 finalPosition = trail.verticies[vertIndex - 1];
for (int i = vertIndex; i < trail.verticies.Length; i++)
{
trail.verticies[i] = finalPosition;
}
int indIndex = 0;
for (int pointIndex = 0; pointIndex < 2 * (trail.activePointCount - 1); pointIndex++)
{
if (pointIndex % 2 == 0)
{
trail.indicies[indIndex] = pointIndex;
indIndex++;
trail.indicies[indIndex] = pointIndex + 1;
indIndex++;
trail.indicies[indIndex] = pointIndex + 2;
}
else
{
trail.indicies[indIndex] = pointIndex + 2;
indIndex++;
trail.indicies[indIndex] = pointIndex + 1;
indIndex++;
trail.indicies[indIndex] = pointIndex;
}
indIndex++;
}
int finalIndex = trail.indicies[indIndex - 1];
for (int i = indIndex; i < trail.indicies.Length; i++)
{
trail.indicies[i] = finalIndex;
}
trail.mesh.vertices = trail.verticies;
trail.mesh.SetIndices(trail.indicies, MeshTopology.Triangles, 0);
trail.mesh.uv = trail.uvs;
trail.mesh.normals = trail.normals;
trail.mesh.colors = trail.colors;
}
protected virtual void InitialiseNewPoint(PCTrailPoint newPoint)
{
}
