protected bool AnyElement(CircularBuffer <PCTrailPoint> InPoints)
{
for (int i = 0; i < InPoints.Count; i++)
{
PCTrailPoint pCTrailPoint = InPoints[i];
if (pCTrailPoint.TimeActive() < this.TrailData.Lifetime)
{
return(true);
}
}
return(false);
}
private void GenerateMesh(PCTrail trail)
{
trail.Mesh.Clear(false);
Vector3 camForward = Camera.main != null ? Camera.main.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 override void UpdateTrail(PCTrail trail, float deltaTime)
{
if (!trail.IsActiveTrail)
{
return;
}
int num = 0;
for (int i = 0; i < this._controlPoints.Count; i++)
{
trail.Points[num].Position = this._controlPoints[i].p;
if (this.TrailData.UseForwardOverride)
{
trail.Points[num].Forward = this._controlPoints[i].forward;
}
num++;
if (i < this._controlPoints.Count - 1)
{
float d = Vector3.Distance(this._controlPoints[i].p, this._controlPoints[i + 1].p) / 2f;
Vector3 curveStartHandle;
if (i == 0)
{
curveStartHandle = this._controlPoints[i].p + (this._controlPoints[i + 1].p - this._controlPoints[i].p).normalized * d;
}
else
{
curveStartHandle = this._controlPoints[i].p + (this._controlPoints[i + 1].p - this._controlPoints[i - 1].p).normalized * d;
}
int num2 = i + 1;
Vector3 curveEndHandle;
if (num2 == this._controlPoints.Count - 1)
{
curveEndHandle = this._controlPoints[num2].p + (this._controlPoints[num2 - 1].p - this._controlPoints[num2].p).normalized * d;
}
else
{
curveEndHandle = this._controlPoints[num2].p + (this._controlPoints[num2 - 1].p - this._controlPoints[num2 + 1].p).normalized * d;
}
PCTrailPoint pCTrailPoint = trail.Points[num - 1];
PCTrailPoint pCTrailPoint2 = trail.Points[num - 1 + this.PointsBetweenControlPoints + 1];
for (int j = 0; j < this.PointsBetweenControlPoints; j++)
{
float t = ((float)j + 1f) / ((float)this.PointsBetweenControlPoints + 1f);
trail.Points[num].Position = this.GetPointAlongCurve(this._controlPoints[i].p, curveStartHandle, this._controlPoints[i + 1].p, curveEndHandle, t, 0.3f);
trail.Points[num].SetTimeActive(Mathf.Lerp(pCTrailPoint.TimeActive(), pCTrailPoint2.TimeActive(), t));
if (this.TrailData.UseForwardOverride)
{
trail.Points[num].Forward = Vector3.Lerp(pCTrailPoint.Forward, pCTrailPoint2.Forward, t);
}
num++;
}
}
}
int num3 = this._controlPoints.Count - 1 + (this._controlPoints.Count - 1) * this.PointsBetweenControlPoints;
int num4 = num3 - this.PointsBetweenControlPoints - 1;
int num5 = num3 + 1;
float num6 = trail.Points[num4].GetDistanceFromStart();
for (int k = num4 + 1; k < num5; k++)
{
num6 += Vector3.Distance(trail.Points[k - 1].Position, trail.Points[k].Position);
trail.Points[k].SetDistanceFromStart(num6);
}
}
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;
/*
*
* This is that optimisation mentioned above..sort of works, but smoothing isn't working right so i am leaving it out for now
*
*
*
* int lastControlPointIndex = _controlPoints.Count - 1;
* int prevControlPointIndex = _controlPoints.Count - 2;
*
* Vector3 Handle1, Handle2;
* float distanceBetween = Vector3.Distance(_controlPoints[lastControlPointIndex].p, _controlPoints[prevControlPointIndex].p) / 2;
*
* if (prevControlPointIndex == 0)
* Handle1 = _controlPoints[prevControlPointIndex].p + (_controlPoints[lastControlPointIndex].p - _controlPoints[prevControlPointIndex].p).normalized * distanceBetween;
* else
* Handle1 = _controlPoints[prevControlPointIndex].p + (_controlPoints[lastControlPointIndex].p - _controlPoints[prevControlPointIndex - 1].p).normalized * distanceBetween;
*
*
* Handle2 = _controlPoints[lastControlPointIndex].p + (_controlPoints[prevControlPointIndex].p - _controlPoints[lastControlPointIndex].p).normalized * distanceBetween;
*
*
* float timeActiveLastControlPoint = trail.Points[lastControlPointPointIndex].TimeActive();
* float timeActivePrevControlPoint = trail.Points[prevControlPointPointIndex].TimeActive();
*
* for (int pointBetween = 0; pointBetween < PointsBetweenControlPoints; pointBetween++)
* {
* float t= (((float)pointBetween + 1f) / ((float)PointsBetweenControlPoints + 1f));
* trail.Points[prevControlPointPointIndex + pointBetween + 1].Position = GetPointAlongCurve(_controlPoints[prevControlPointIndex].p, Handle1, _controlPoints[lastControlPointIndex].p, Handle2, t, 0.3f);
* trail.Points[prevControlPointPointIndex + pointBetween + 1].SetTimeActive(Mathf.Lerp(timeActivePrevControlPoint, timeActiveLastControlPoint, t));
* }
* trail.Points[lastControlPointPointIndex].Position = _controlPoints[lastControlPointIndex].p;
*/
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 Mesh GenerateMesh(CircularBuffer <PCTrailPoint> trail)
{
Vector3 camForward = Camera.main != null ? Camera.main.transform.forward : Vector3.forward;
if (TrailData.UseForwardOverride)
{
camForward = TrailData.ForwardOverride.normalized;
}
Mesh generatedMesh = new Mesh();
int activePointCount = NumberOfActivePoints(trail);
if (activePointCount < 2)
{
return(null);
}
Vector3[] verticies = new Vector3[2 * activePointCount];
Vector3[] normals = new Vector3[2 * activePointCount];
Vector2[] uvs = new Vector2[2 * activePointCount];
Color[] colors = new Color[2 * activePointCount];
int[] indicies = new int[2 * (activePointCount) * 3];
int vertIndex = 0;
for (int i = 0; i < trail.Count; i++)
{
PCTrailPoint p = trail[i];
float timeAlong = p.TimeActive() / TrailData.Lifetime;
if (p.TimeActive() > TrailData.Lifetime)
{
continue;
}
if (TrailData.UseForwardOverride && TrailData.ForwardOverideRelative)
{
camForward = p.Forward;
}
Vector3 cross = Vector3.zero;
if (i < trail.Count - 1)
{
cross =
Vector3.Cross((trail[i + 1].Position - p.Position).normalized, camForward).
normalized;
}
else
{
cross =
Vector3.Cross((p.Position - trail[i - 1].Position).normalized, camForward).
normalized;
}
Color c = TrailData.StretchToFit ? TrailData.ColorOverLife.Evaluate(1 - ((float)vertIndex / (float)activePointCount / 2f)) : TrailData.ColorOverLife.Evaluate(timeAlong);
float s = TrailData.StretchToFit ? TrailData.SizeOverLife.Evaluate(1 - ((float)vertIndex / (float)activePointCount / 2f)) : TrailData.SizeOverLife.Evaluate(timeAlong);
verticies[vertIndex] = p.Position + cross * s;
if (TrailData.MaterialTileLength <= 0)
{
uvs[vertIndex] = new Vector2((float)vertIndex / (float)activePointCount / 2f, 0);
}
else
{
uvs[vertIndex] = new Vector2(p.GetDistanceFromStart() / TrailData.MaterialTileLength, 0);
}
normals[vertIndex] = camForward;
colors[vertIndex] = c;
vertIndex++;
verticies[vertIndex] = p.Position - cross * s;
if (TrailData.MaterialTileLength <= 0)
{
uvs[vertIndex] = new Vector2((float)vertIndex / (float)activePointCount / 2f, 1);
}
else
{
uvs[vertIndex] = new Vector2(p.GetDistanceFromStart() / TrailData.MaterialTileLength, 1);
}
normals[vertIndex] = camForward;
colors[vertIndex] = c;
vertIndex++;
}
int indIndex = 0;
for (int pointIndex = 0; pointIndex < 2 * (activePointCount - 1); pointIndex++)
{
if (pointIndex % 2 == 0)
{
indicies[indIndex] = pointIndex;
indIndex++;
indicies[indIndex] = pointIndex + 1;
indIndex++;
indicies[indIndex] = pointIndex + 2;
}
else
{
indicies[indIndex] = pointIndex + 2;
indIndex++;
indicies[indIndex] = pointIndex + 1;
indIndex++;
indicies[indIndex] = pointIndex;
}
indIndex++;
}
generatedMesh.vertices = verticies;
generatedMesh.SetIndices(indicies, MeshTopology.Triangles, 0);
generatedMesh.uv = uvs;
generatedMesh.normals = normals;
generatedMesh.colors = colors;
return(generatedMesh);
}
private void GenerateMesh(PCTrail trail)
{
trail.Mesh.Clear(false);
float3 camForward = Camera.main != null ?(float3)Camera.main.transform.forward : float3(0, 0, 1);
if (TrailData.UseForwardOverride)
{
camForward = normalize(TrailData.ForwardOverride);
}
trail.activePointCount = NumberOfActivePoints(trail);
if (trail.activePointCount < 2)
{
return;
}
Profiler.BeginSample("generameshTest");
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;
}
float3 Cross = float3.zero;
if (i < trail.Points.Count - 1)
{
Cross =
cross(normalize(trail.Points[i + 1].Position - p.Position), camForward);
}
else
{
Cross =
cross(normalize(p.Position - trail.Points[i - 1].Position), camForward);
}
Cross = normalize(Cross);
//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.vertexDatas[vertIndex].verticies = p.Position + Cross * s;
trail.vertexDatas[vertIndex].normals = camForward;
if (TrailData.MaterialTileLength <= 0)
{
trail.vertexDatas[vertIndex].uvs = new float2((float)vertIndex / (float)trail.activePointCount / 2f, 0);
}
else
{
trail.vertexDatas[vertIndex].uvs = new float2(p.GetDistanceFromStart() / TrailData.MaterialTileLength, 0);
}
trail.vertexDatas[vertIndex].colors = c;
vertIndex++;
trail.vertexDatas[vertIndex].verticies = p.Position - Cross * s;
trail.vertexDatas[vertIndex].normals = camForward;
if (TrailData.MaterialTileLength <= 0)
{
trail.vertexDatas[vertIndex].uvs = new float2((float)vertIndex / (float)trail.activePointCount / 2f, 1);
}
else
{
trail.vertexDatas[vertIndex].uvs = new float2(p.GetDistanceFromStart() / TrailData.MaterialTileLength, 1);
}
trail.vertexDatas[vertIndex].colors = c;
vertIndex++;
}
float3 finalPosition = trail.vertexDatas[vertIndex - 1].verticies;
for (int i = vertIndex; i < trail.vertexDatas.Length; i++)
{
trail.vertexDatas[i].verticies = 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++;
}
Profiler.EndSample();
Profiler.BeginSample("SetMeshVertexTest");
trail.Mesh.SetVertexBufferParams(trail.vertexDatas.Length,
new VertexAttributeDescriptor(VertexAttribute.Position, VertexAttributeFormat.Float32, 3),
new VertexAttributeDescriptor(VertexAttribute.Normal, VertexAttributeFormat.Float32, 3),
new VertexAttributeDescriptor(VertexAttribute.Color, VertexAttributeFormat.UNorm8, 4),
new VertexAttributeDescriptor(VertexAttribute.TexCoord0, VertexAttributeFormat.Float32, 2));
trail.Mesh.SetVertexBufferData(trail.vertexDatas, 0, 0, trail.vertexDatas.Length);
trail.Mesh.SetIndexBufferParams(trail.indicies.Length, IndexFormat.UInt32);
trail.Mesh.SetIndexBufferData(trail.indicies, 0, 0, trail.indicies.Length);
trail.Mesh.subMeshCount = 1;
var subMeshDescriptor = new SubMeshDescriptor(0, trail.indicies.Length, MeshTopology.Triangles);
trail.Mesh.SetSubMesh(0, subMeshDescriptor);
Profiler.EndSample();
}
private void GenerateMesh(PCTrail trail)
{
trail.Mesh.Clear(false);
Vector3 rhs = (Camera.main == null) ? Vector3.forward : Camera.main.transform.forward;
if (base.TrailData.UseForwardOverride)
{
rhs = base.TrailData.ForwardOverride.normalized;
}
trail.activePointCount = trail.Points.Count;
if (trail.activePointCount >= 2)
{
int index = 0;
for (int i = 0; i < trail.Points.Count; i++)
{
PCTrailPoint point = trail.Points[i];
if (point.TimeActive() <= base.TrailData.Lifetime)
{
if (base.TrailData.UseForwardOverride && base.TrailData.ForwardOverrideRelative)
{
rhs = point.Forward;
}
Vector3 zero = Vector3.zero;
if (i < (trail.Points.Count - 1))
{
if (base.TrailData.UseForwardOverride && base.TrailData.ForwardOverrideRelative)
{
Vector3 vector5 = trail.Points[i + 1].Position - point.Position;
zero = Vector3.Cross(vector5.normalized, rhs).normalized;
}
else
{
Vector3 vector7 = trail.Points[i + 1].Position - point.Position;
zero = vector7.normalized;
}
}
else if (base.TrailData.UseForwardOverride && base.TrailData.ForwardOverrideRelative)
{
Vector3 vector8 = point.Position - trail.Points[i - 1].Position;
zero = Vector3.Cross(vector8.normalized, rhs).normalized;
}
else
{
Vector3 vector10 = point.Position - trail.Points[i - 1].Position;
zero = vector10.normalized;
}
trail.verticies[index] = point.Position;
trail.normals[index] = (Vector3)(zero * base.StretchUpRatio);
if (base.clockSize)
{
trail.uvs[index] = new Vector2(point.GetDistanceFromStart() / trail.Points[trail.Points.Count - 1].GetDistanceFromStart(), 1f);
}
else
{
trail.uvs[index] = new Vector2(point.GetDistanceFromStart() / trail.Points[trail.Points.Count - 1].GetDistanceFromStart(), 0f);
}
trail.colors[index] = Color.white;
index++;
trail.verticies[index] = point.Position;
trail.normals[index] = (Vector3)(-zero * base.StretchDownRatio);
if (base.clockSize)
{
trail.uvs[index] = new Vector2(point.GetDistanceFromStart() / trail.Points[trail.Points.Count - 1].GetDistanceFromStart(), 0f);
}
else
{
trail.uvs[index] = new Vector2(point.GetDistanceFromStart() / trail.Points[trail.Points.Count - 1].GetDistanceFromStart(), 1f);
}
trail.colors[index] = Color.white;
index++;
}
}
Vector2 vector3 = trail.verticies[index - 1];
Vector3 vector4 = trail.normals[index - 1];
for (int j = index; j < trail.verticies.Length; j++)
{
trail.verticies[j] = (Vector3)vector3;
trail.normals[j] = vector4;
}
int num4 = 0;
for (int k = 0; k < (2 * (trail.activePointCount - 1)); k++)
{
if ((k % 2) == 0)
{
trail.indicies[num4] = k;
num4++;
trail.indicies[num4] = k + 1;
num4++;
trail.indicies[num4] = k + 2;
}
else
{
trail.indicies[num4] = k + 2;
num4++;
trail.indicies[num4] = k + 1;
num4++;
trail.indicies[num4] = k;
}
num4++;
}
int num6 = trail.indicies[num4 - 1];
for (int m = num4; m < trail.indicies.Length; m++)
{
trail.indicies[m] = num6;
}
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 GenerateTrail(PCTrail trail)
{
int num = 0;
for (int i = 0; i < this._controlPoints.Count; i++)
{
trail.Points[num].Position = this._controlPoints[i].p;
if (base.TrailData.UseForwardOverride)
{
trail.Points[num].Forward = this._controlPoints[i].forward;
}
num++;
if (i < (this._controlPoints.Count - 1))
{
Vector3 vector;
Vector3 vector2;
float num3 = Vector3.Distance(this._controlPoints[i].p, this._controlPoints[i + 1].p) / 2f;
if (i == 0)
{
Vector3 vector3 = this._controlPoints[i + 1].p - this._controlPoints[i].p;
vector = this._controlPoints[i].p + ((Vector3)(vector3.normalized * num3));
}
else
{
Vector3 vector4 = this._controlPoints[i + 1].p - this._controlPoints[i - 1].p;
vector = this._controlPoints[i].p + ((Vector3)(vector4.normalized * num3));
}
int num4 = i + 1;
if (num4 == (this._controlPoints.Count - 1))
{
Vector3 vector5 = this._controlPoints[num4 - 1].p - this._controlPoints[num4].p;
vector2 = this._controlPoints[num4].p + ((Vector3)(vector5.normalized * num3));
}
else
{
Vector3 vector6 = this._controlPoints[num4 - 1].p - this._controlPoints[num4 + 1].p;
vector2 = this._controlPoints[num4].p + ((Vector3)(vector6.normalized * num3));
}
PCTrailPoint point = trail.Points[num - 1];
PCTrailPoint point2 = trail.Points[((num - 1) + this.PointsBetweenControlPoints) + 1];
for (int k = 0; k < this.PointsBetweenControlPoints; k++)
{
float t = (k + 1f) / (this.PointsBetweenControlPoints + 1f);
trail.Points[num].Position = this.GetPointAlongCurve(this._controlPoints[i].p, vector, this._controlPoints[i + 1].p, vector2, t, 0.3f);
trail.Points[num].SetTimeActive(Mathf.Lerp(point.TimeActive(), point2.TimeActive(), t));
if (base.TrailData.UseForwardOverride)
{
trail.Points[num].Forward = Vector3.Lerp(point.Forward, point2.Forward, t);
}
num++;
}
}
}
float distance = 0f;
for (int j = 1; j < trail.Points.Count; j++)
{
distance += Vector3.Distance(trail.Points[j - 1].Position, trail.Points[j].Position);
trail.Points[j].SetDistanceFromStart(distance);
}
}
private void GenerateMesh(PCTrail trail)
{
trail.Mesh.Clear(false);
Vector3 vector = (!(Camera.main != null)) ? Vector3.forward : Camera.main.transform.forward;
if (this.TrailData.UseForwardOverride)
{
vector = this.TrailData.ForwardOverride.normalized;
}
trail.activePointCount = this.NumberOfActivePoints(trail);
if (trail.activePointCount < 2)
{
return;
}
int num = 0;
for (int i = 0; i < trail.Points.Count; i++)
{
PCTrailPoint pCTrailPoint = trail.Points[i];
float num2 = pCTrailPoint.TimeActive() / this.TrailData.Lifetime;
if (pCTrailPoint.TimeActive() <= this.TrailData.Lifetime)
{
if (this.TrailData.UseForwardOverride && this.TrailData.ForwardOverrideRelative)
{
vector = pCTrailPoint.Forward;
}
Vector3 a = Vector3.zero;
if (i < trail.Points.Count - 1)
{
a = Vector3.Cross((trail.Points[i + 1].Position - pCTrailPoint.Position).normalized, vector).normalized;
}
else
{
a = Vector3.Cross((pCTrailPoint.Position - trail.Points[i - 1].Position).normalized, vector).normalized;
}
Color color = (!this.TrailData.StretchColorToFit) ? ((!this.TrailData.UsingSimpleColor) ? this.TrailData.ColorOverLife.Evaluate(num2) : Color.Lerp(this.TrailData.SimpleColorOverLifeStart, this.TrailData.SimpleColorOverLifeEnd, num2)) : ((!this.TrailData.UsingSimpleColor) ? this.TrailData.ColorOverLife.Evaluate(1f - (float)num / (float)trail.activePointCount / 2f) : Color.Lerp(this.TrailData.SimpleColorOverLifeStart, this.TrailData.SimpleColorOverLifeEnd, 1f - (float)num / (float)trail.activePointCount / 2f));
float d = (!this.TrailData.StretchSizeToFit) ? ((!this.TrailData.UsingSimpleSize) ? this.TrailData.SizeOverLife.Evaluate(num2) : Mathf.Lerp(this.TrailData.SimpleSizeOverLifeStart, this.TrailData.SimpleSizeOverLifeEnd, num2)) : ((!this.TrailData.UsingSimpleSize) ? this.TrailData.SizeOverLife.Evaluate(1f - (float)num / (float)trail.activePointCount / 2f) : Mathf.Lerp(this.TrailData.SimpleSizeOverLifeStart, this.TrailData.SimpleSizeOverLifeEnd, 1f - (float)num / (float)trail.activePointCount / 2f));
trail.verticies[num] = pCTrailPoint.Position + a * d;
if (this.TrailData.MaterialTileLength <= 0f)
{
trail.uvs[num] = new Vector2((float)num / (float)trail.activePointCount / 2f, 0f);
}
else
{
trail.uvs[num] = new Vector2(pCTrailPoint.GetDistanceFromStart() / this.TrailData.MaterialTileLength, 0f);
}
trail.normals[num] = vector;
trail.colors[num] = color;
num++;
trail.verticies[num] = pCTrailPoint.Position - a * d;
if (this.TrailData.MaterialTileLength <= 0f)
{
trail.uvs[num] = new Vector2((float)num / (float)trail.activePointCount / 2f, 1f);
}
else
{
trail.uvs[num] = new Vector2(pCTrailPoint.GetDistanceFromStart() / this.TrailData.MaterialTileLength, 1f);
}
trail.normals[num] = vector;
trail.colors[num] = color;
num++;
}
}
Vector2 v = trail.verticies[num - 1];
for (int j = num; j < trail.verticies.Length; j++)
{
trail.verticies[j] = v;
}
int num3 = 0;
for (int k = 0; k < 2 * (trail.activePointCount - 1); k++)
{
if (k % 2 == 0)
{
trail.indicies[num3] = k;
num3++;
trail.indicies[num3] = k + 1;
num3++;
trail.indicies[num3] = k + 2;
}
else
{
trail.indicies[num3] = k + 2;
num3++;
trail.indicies[num3] = k + 1;
num3++;
trail.indicies[num3] = k;
}
num3++;
}
int num4 = trail.indicies[num3 - 1];
for (int l = num3; l < trail.indicies.Length; l++)
{
trail.indicies[l] = num4;
}
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;
}
private void GenerateMesh(PCTrail trail)
{
trail.Mesh.Clear(false);
Vector3 rhs = (Camera.main == null) ? Vector3.forward : Camera.main.transform.forward;
if (this.TrailData.UseForwardOverride)
{
rhs = this.TrailData.ForwardOverride.normalized;
}
trail.activePointCount = this.NumberOfActivePoints(trail);
if (trail.activePointCount >= 2)
{
int index = 0;
for (int i = 0; i < trail.Points.Count; i++)
{
PCTrailPoint point = trail.Points[i];
float time = point.TimeActive() / this.TrailData.Lifetime;
if (point.TimeActive() <= this.TrailData.Lifetime)
{
if (this.TrailData.UseForwardOverride && this.TrailData.ForwardOverrideRelative)
{
rhs = point.Forward;
}
Vector3 zero = Vector3.zero;
if (i < (trail.Points.Count - 1))
{
Vector3 vector4 = trail.Points[i + 1].Position - point.Position;
zero = Vector3.Cross(vector4.normalized, rhs).normalized;
}
else
{
Vector3 vector6 = point.Position - trail.Points[i - 1].Position;
zero = Vector3.Cross(vector6.normalized, rhs).normalized;
}
Color color = !this.TrailData.StretchColorToFit ? (!this.TrailData.UsingSimpleColor ? this.TrailData.ColorOverLife.Evaluate(time) : Color.Lerp(this.TrailData.SimpleColorOverLifeStart, this.TrailData.SimpleColorOverLifeEnd, time)) : (!this.TrailData.UsingSimpleColor ? this.TrailData.ColorOverLife.Evaluate(1f - ((((float)index) / ((float)trail.activePointCount)) / 2f)) : Color.Lerp(this.TrailData.SimpleColorOverLifeStart, this.TrailData.SimpleColorOverLifeEnd, 1f - ((((float)index) / ((float)trail.activePointCount)) / 2f)));
float num4 = !this.TrailData.StretchSizeToFit ? (!this.TrailData.UsingSimpleSize ? this.TrailData.SizeOverLife.Evaluate(time) : Mathf.Lerp(this.TrailData.SimpleSizeOverLifeStart, this.TrailData.SimpleSizeOverLifeEnd, time)) : (!this.TrailData.UsingSimpleSize ? this.TrailData.SizeOverLife.Evaluate(1f - ((((float)index) / ((float)trail.activePointCount)) / 2f)) : Mathf.Lerp(this.TrailData.SimpleSizeOverLifeStart, this.TrailData.SimpleSizeOverLifeEnd, 1f - ((((float)index) / ((float)trail.activePointCount)) / 2f)));
trail.verticies[index] = point.Position + ((Vector3)(zero * num4));
if (this.TrailData.MaterialTileLength <= 0f)
{
trail.uvs[index] = new Vector2((((float)index) / ((float)trail.activePointCount)) / 2f, 0f);
}
else
{
trail.uvs[index] = new Vector2(point.GetDistanceFromStart() / this.TrailData.MaterialTileLength, 0f);
}
trail.normals[index] = rhs;
trail.colors[index] = color;
index++;
trail.verticies[index] = point.Position - ((Vector3)(zero * num4));
if (this.TrailData.MaterialTileLength <= 0f)
{
trail.uvs[index] = new Vector2((((float)index) / ((float)trail.activePointCount)) / 2f, 1f);
}
else
{
trail.uvs[index] = new Vector2(point.GetDistanceFromStart() / this.TrailData.MaterialTileLength, 1f);
}
trail.normals[index] = rhs;
trail.colors[index] = color;
index++;
}
}
Vector2 vector3 = trail.verticies[index - 1];
for (int j = index; j < trail.verticies.Length; j++)
{
trail.verticies[j] = (Vector3)vector3;
}
int num6 = 0;
for (int k = 0; k < (2 * (trail.activePointCount - 1)); k++)
{
if ((k % 2) == 0)
{
trail.indicies[num6] = k;
num6++;
trail.indicies[num6] = k + 1;
num6++;
trail.indicies[num6] = k + 2;
}
else
{
trail.indicies[num6] = k + 2;
num6++;
trail.indicies[num6] = k + 1;
num6++;
trail.indicies[num6] = k;
}
num6++;
}
int num8 = trail.indicies[num6 - 1];
for (int m = num6; m < trail.indicies.Length; m++)
{
trail.indicies[m] = num8;
}
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;
}
}
