protected override void UpdateTrail(PCTrail trail, float deltaTime) { if (_clampPosition && trail.Points.Count > 0) { trail.Points[0].Position = _clampPosition.position; } }
private void CheckEmitChange() { if (this._emit != this.Emit) { this._emit = this.Emit; if (this._emit) { if (this._activeTrail == null || this._activeTrail.NumPoints != this.GetMaxNumberOfPoints()) { if (this._activeTrail != null) { this._activeTrail.Dispose(); } this._activeTrail = new PCTrail(this.GetMaxNumberOfPoints()); } else { this._activeTrail.Points.Clear(); } this._activeTrail.IsActiveTrail = true; this.OnStartEmit(); } else { this.OnStopEmit(); this._activeTrail.IsActiveTrail = false; this._fadingTrails.Add(this._activeTrail); } } }
public void Translate(Vector3 t) { if (this._activeTrail != null) { for (int i = 0; i < this._activeTrail.Points.Count; i++) { PCTrailPoint local1 = this._activeTrail.Points[i]; local1.Position += t; } } if (this._fadingTrails != null) { for (int j = 0; j < this._fadingTrails.Count; j++) { PCTrail trail = this._fadingTrails[j]; if (trail != null) { for (int k = 0; k < trail.Points.Count; k++) { PCTrailPoint local2 = trail.Points[k]; local2.Position += t; } } } } this.OnTranslate(t); }
protected virtual void OnDestroy() { OnDisable(); if (_activeTrail != null) { _activeTrail.Dispose(); _activeTrail = null; } if (_fadingTrails != null) { { var __list3 = _fadingTrails; var __listCount3 = __list3.Count; for (int __i3 = 0; __i3 < __listCount3; ++__i3) { var fadingTrail = (PCTrail)__list3[__i3]; { if (fadingTrail != null) { fadingTrail.Dispose(); } } } } _fadingTrails.Clear(); } }
protected override void UpdateTrail(PCTrail trail, float deltaTime) { foreach (PCTrailPoint point in trail.Points) { point.Position += ConstantForce * deltaTime; } }
/// <summary> /// Clears all active trails from the system. /// </summary> /// <param name="emitState">Desired emit state after clearing</param> public void ClearSystem(bool emitState) { if (_activeTrail != null) { _activeTrail.Dispose(); _activeTrail = null; } if (_fadingTrails != null) { foreach (PCTrail fadingTrail in _fadingTrails) { if (fadingTrail != null) { fadingTrail.Dispose(); } } _fadingTrails.Clear(); } Emit = emitState; _emit = !emitState; CheckEmitChange(); }
/// <summary> /// Clears all active trails from the system. /// </summary> /// <param name="emitState">Desired emit state after clearing</param> public void ClearSystem(bool emitState) { if (_activeTrail != null) { _activeTrail.MeshUpdated = false; _activeTrail.Dispose(); _activeTrail = null; } if (_fadingTrails != null) { { var __list5 = _fadingTrails; var __listCount5 = __list5.Count; for (int __i5 = 0; __i5 < __listCount5; ++__i5) { var fadingTrail = (PCTrail)__list5[__i5]; { if (fadingTrail != null) { fadingTrail.Dispose(); } } } } _fadingTrails.Clear(); } Emit = emitState; _emit = !emitState; CheckEmitChange(); }
private void UpdatePoints(PCTrail line, float deltaTime) { for (int i = 0; i < line.Points.Count; i++) { line.Points[i].Update(_noDecay ? 0 : deltaTime); } }
public void Translate(Vector3 t) { if (this._activeTrail != null) { for (int i = 0; i < this._activeTrail.Points.Count; i++) { this._activeTrail.Points[i].Position += t; } } if (this._fadingTrails != null) { for (int j = 0; j < this._fadingTrails.Count; j++) { PCTrail pCTrail = this._fadingTrails[j]; if (pCTrail != null) { for (int k = 0; k < pCTrail.Points.Count; k++) { pCTrail.Points[k].Position += t; } } } } this.OnTranslate(t); }
public void CreateTrail(Vector3 from, Vector3 to, float distanceBetweenPoints) { float num = Vector3.Distance(from, to); Vector3 normalized = (to - from).normalized; float num2 = 0f; CircularBuffer <PCTrailPoint> circularBuffer = new CircularBuffer <PCTrailPoint>(this.GetMaxNumberOfPoints()); int num3 = 0; while (num2 < num) { PCTrailPoint pCTrailPoint = new PCTrailPoint(); pCTrailPoint.PointNumber = num3; pCTrailPoint.Position = from + normalized * num2; circularBuffer.Add(pCTrailPoint); this.InitialiseNewPoint(pCTrailPoint); num3++; if (distanceBetweenPoints <= 0f) { break; } num2 += distanceBetweenPoints; } PCTrailPoint pCTrailPoint2 = new PCTrailPoint(); pCTrailPoint2.PointNumber = num3; pCTrailPoint2.Position = to; circularBuffer.Add(pCTrailPoint2); this.InitialiseNewPoint(pCTrailPoint2); PCTrail pCTrail = new PCTrail(this.GetMaxNumberOfPoints()); pCTrail.Points = circularBuffer; this._fadingTrails.Add(pCTrail); }
private void UpdatePoints(PCTrail line, float deltaTime) { for (int i = 0; i < line.Points.Count; i++) { line.Points[i].Update((!this._noDecay) ? deltaTime : 0f); } }
public void CreateTrail(Vector3 from, Vector3 to, float distanceBetweenPoints) { float num = Vector3.Distance(from, to); Vector3 normalized = (to - from).normalized; float num2 = 0f; CircularBuffer<PCTrailPoint> circularBuffer = new CircularBuffer<PCTrailPoint>(this.GetMaxNumberOfPoints()); int num3 = 0; while (num2 < num) { PCTrailPoint pCTrailPoint = new PCTrailPoint(); pCTrailPoint.PointNumber = num3; pCTrailPoint.Position = from + normalized * num2; circularBuffer.Add(pCTrailPoint); this.InitialiseNewPoint(pCTrailPoint); num3++; if (distanceBetweenPoints <= 0f) { break; } num2 += distanceBetweenPoints; } PCTrailPoint pCTrailPoint2 = new PCTrailPoint(); pCTrailPoint2.PointNumber = num3; pCTrailPoint2.Position = to; circularBuffer.Add(pCTrailPoint2); this.InitialiseNewPoint(pCTrailPoint2); PCTrail pCTrail = new PCTrail(this.GetMaxNumberOfPoints()); pCTrail.Points = circularBuffer; this._fadingTrails.Add(pCTrail); }
private void UpdatePoints(float deltaTime, PCTrail line) { for (int i = 0; i < line.Points.Count; i++) { line.Points[i].Update(deltaTime); UpdatePoint(line.Points[i], deltaTime); } }
protected override void UpdateTrail(PCTrail trail, float deltaTime) { if (_noDecay) return; foreach (PCTrailPoint point in trail.Points) { point.Position += ConstantForce * deltaTime; } }
protected override void UpdateTrail(PCTrail trail, float deltaTime) { if (this._noDecay) { return; } foreach (PCTrailPoint current in trail.Points) { current.Position += this.ConstantForce * deltaTime; } }
private int NumberOfActivePoints(PCTrail line) { int num = 0; for (int i = 0; i < line.Points.Count; i++) { if (line.Points[i].TimeActive() < this.TrailData.Lifetime) { num++; } } return(num); }
private int NumberOfActivePoints(PCTrail line) { int count = 0; for (int index = 0; index < line.Points.Count; index++) { if (line.Points[index].TimeActive() < TrailData.Lifetime) { count++; } } return(count); }
protected virtual void Awake() { GlobalTrailRendererCount++; if (GlobalTrailRendererCount == 1) { _matToTrailList = new Dictionary <Material, List <PCTrail> >(); _toClean = new List <Mesh>(); } _activeTrail = new PCTrail(MaxNumberOfPoints); _fadingTrails = new List <PCTrail>(); _t = transform; _emit = Emit; }
protected override void UpdateTrail(PCTrail trail, float deltaTime) { if (this._noDecay) { return; } using (IEnumerator <PCTrailPoint> enumerator = trail.Points.GetEnumerator()) { while (enumerator.MoveNext()) { PCTrailPoint current = enumerator.get_Current(); current.Position += this.ConstantForce * deltaTime; } } }
/// <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 virtual void OnDestroy() { GlobalTrailRendererCount--; if (GlobalTrailRendererCount == 0) { if (_toClean != null && _toClean.Count > 0) { foreach (Mesh mesh in _toClean) { if (Application.isEditor) { DestroyImmediate(mesh, true); } else { Destroy(mesh); } } } _toClean = null; _matToTrailList.Clear(); _matToTrailList = null; } if (_activeTrail != null) { _activeTrail.Dispose(); _activeTrail = null; } if (_fadingTrails != null) { foreach (PCTrail fadingTrail in _fadingTrails) { if (fadingTrail != null) { fadingTrail.Dispose(); } } _fadingTrails.Clear(); } }
protected virtual void OnDestroy() { TrailRenderer_Base.GlobalTrailRendererCount--; if (TrailRenderer_Base.GlobalTrailRendererCount == 0) { if (TrailRenderer_Base._toClean != null && TrailRenderer_Base._toClean.Count > 0) { for (int i = 0; i < TrailRenderer_Base._toClean.Count; i++) { Mesh mesh = TrailRenderer_Base._toClean[i]; if (mesh != null) { if (Application.isEditor) { Object.DestroyImmediate(mesh, true); } else { Object.Destroy(mesh); } } } } TrailRenderer_Base._toClean = null; TrailRenderer_Base._matToTrailList.Clear(); TrailRenderer_Base._matToTrailList = null; } if (this._activeTrail != null) { this._activeTrail.Dispose(); this._activeTrail = null; } if (this._fadingTrails != null) { for (int j = 0; j < this._fadingTrails.Count; j++) { PCTrail pCTrail = this._fadingTrails[j]; if (pCTrail != null) { pCTrail.Dispose(); } } this._fadingTrails.Clear(); } }
protected virtual void OnDestroy() { GlobalTrailRendererCount--; if (GlobalTrailRendererCount == 0) { if ((_toClean != null) && (_toClean.Count > 0)) { for (int i = 0; i < _toClean.Count; i++) { Mesh mesh = _toClean[i]; if (mesh != null) { if (Application.isEditor) { UnityEngine.Object.DestroyImmediate(mesh, true); } else { UnityEngine.Object.Destroy(mesh); } } } } _toClean = null; _matToTrailList.Clear(); _matToTrailList = null; } if (this._activeTrail != null) { this._activeTrail.Dispose(); this._activeTrail = null; } if (this._fadingTrails != null) { for (int j = 0; j < this._fadingTrails.Count; j++) { PCTrail trail = this._fadingTrails[j]; if (trail != null) { trail.Dispose(); } } this._fadingTrails.Clear(); } }
protected virtual void Awake() { TrailRenderer_Base.GlobalTrailRendererCount++; if (TrailRenderer_Base.GlobalTrailRendererCount == 1) { TrailRenderer_Base._matToTrailList = new DictionaryView <Material, ListView <PCTrail> >(); TrailRenderer_Base._toClean = new ListView <Mesh>(); } this._fadingTrails = new ListView <PCTrail>(); this._t = base.transform; this._emit = this.Emit; if (this._emit) { this._activeTrail = new PCTrail(this.GetMaxNumberOfPoints()); this._activeTrail.IsActiveTrail = true; this.OnStartEmit(); } }
protected override void UpdateTrail(PCTrail trail, float deltaTime) { if (_noDecay) { return; } { // foreach(var point in trail.Points) var __enumerator1 = (trail.Points).GetEnumerator(); while (__enumerator1.MoveNext()) { var point = (PCTrailPoint)__enumerator1.Current; { point.Position += ConstantForce * deltaTime; } } } }
private void CheckEmitChange() { if (_emit != Emit) { _emit = Emit; if (_emit) { OnStartEmit(); _activeTrail = new PCTrail(MaxNumberOfPoints); } else { OnStopEmit(); _fadingTrails.Add(_activeTrail); _activeTrail = null; } } }
public void ClearSystem(bool emitState) { if (this._fadingTrails != null) { for (int i = 0; i < this._fadingTrails.Count; i++) { PCTrail pCTrail = this._fadingTrails[i]; if (pCTrail != null && pCTrail != this._activeTrail) { pCTrail.Dispose(); } } this._fadingTrails.Clear(); } this.Emit = emitState; this._emit = !emitState; this.CheckEmitChange(); }
private void CheckEmitChange() { if (_emit != Emit) { _emit = Emit; if (_emit) { _activeTrail = new PCTrail(GetMaxNumberOfPoints()); _activeTrail.IsActiveTrail = true; OnStartEmit(); } else { OnStopEmit(); _activeTrail.IsActiveTrail = false; _fadingTrails.Add(_activeTrail); _activeTrail = null; } } }
public void ClearSystem(bool emitState) { if (this._activeTrail != null) { this._activeTrail.Dispose(); this._activeTrail = null; } if (this._fadingTrails != null) { foreach (PCTrail current in this._fadingTrails) { if (current != null) { current.Dispose(); } } this._fadingTrails.Clear(); } this.Emit = emitState; this._emit = !emitState; this.CheckEmitChange(); }
protected virtual void Awake() { GlobalTrailRendererCount++; if (GlobalTrailRendererCount == 1) { _matToTrailList = new Dictionary <Material, List <PCTrail> > (); _toClean = new List <Mesh> (); } combineList = new List <CombineInstance>(); _fadingTrails = new List <PCTrail> (); _t = transform; _emit = Emit; if (_emit) { _activeTrail = new PCTrail(GetMaxNumberOfPoints()); _activeTrail.IsActiveTrail = true; OnStartEmit(); } }
protected virtual void Awake() { GlobalTrailRendererCount++; if(GlobalTrailRendererCount == 1) { _matToTrailList = new Dictionary<Material, List<PCTrail>>(); _toClean = new List<Mesh>(); } _fadingTrails = new List<PCTrail>(); _t = transform; _emit = Emit; if (_emit) { _activeTrail = new PCTrail(GetMaxNumberOfPoints()); _activeTrail.IsActiveTrail = true; OnStartEmit(); } }
public void CreateTrail(Vector3 from, Vector3 to, float distanceBetweenPoints) { float num = Vector3.Distance(from, to); Vector3 normalized = to - from; normalized = normalized.normalized; float num2 = 0f; CircularBuffer <PCTrailPoint> buffer = new CircularBuffer <PCTrailPoint>(this.GetMaxNumberOfPoints()); int num3 = 0; while (num2 < num) { PCTrailPoint point = new PCTrailPoint { PointNumber = num3, Position = from + ((Vector3)(normalized * num2)) }; buffer.Add(point); this.InitialiseNewPoint(point); num3++; if (distanceBetweenPoints <= 0f) { break; } num2 += distanceBetweenPoints; } PCTrailPoint item = new PCTrailPoint { PointNumber = num3, Position = to }; buffer.Add(item); this.InitialiseNewPoint(item); PCTrail trail = new PCTrail(this.GetMaxNumberOfPoints()) { Points = buffer }; this._fadingTrails.Add(trail); }
protected override void UpdateTrail(PCTrail trail, float deltaTime) { if (!base._noDecay) { IEnumerator <PCTrailPoint> enumerator = trail.Points.GetEnumerator(); try { while (enumerator.MoveNext()) { PCTrailPoint current = enumerator.Current; current.Position += (Vector3)(this.ConstantForce * deltaTime); } } finally { if (enumerator == null) { } enumerator.Dispose(); } } }
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 int NumberOfActivePoints(PCTrail line) { int num = 0; for (int i = 0; i < line.Points.Count; i++) { if (line.Points[i].TimeActive() < this.TrailData.Lifetime) { num++; } } return num; }
protected virtual void UpdateTrail(PCTrail trail, float deltaTime) { }
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; }
/// <summary> /// Clears all active trails from the system. /// </summary> /// <param name="emitState">Desired emit state after clearing</param> public void ClearSystem(bool emitState) { if(_activeTrail != null) { _activeTrail.Dispose(); _activeTrail = null; } if (_fadingTrails != null) { foreach (PCTrail fadingTrail in _fadingTrails) { if (fadingTrail != null) fadingTrail.Dispose(); } _fadingTrails.Clear(); } Emit = emitState; _emit = !emitState; CheckEmitChange(); }
protected virtual void Awake() { TrailRenderer_Base.GlobalTrailRendererCount++; if (TrailRenderer_Base.GlobalTrailRendererCount == 1) { TrailRenderer_Base._matToTrailList = new Dictionary<Material, List<PCTrail>>(); TrailRenderer_Base._toClean = new List<Mesh>(); } this._fadingTrails = new List<PCTrail>(); this._t = base.transform; this._emit = this.Emit; if (this._emit) { this._activeTrail = new PCTrail(this.GetMaxNumberOfPoints()); this._activeTrail.IsActiveTrail = true; this.OnStartEmit(); } }
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); } }
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); } }
private int NumberOfActivePoints(PCTrail line) { int count = 0; for (int index = 0; index < line.Points.Count; index++) { if (line.Points[index].TimeActive() < TrailData.Lifetime) count++; } return count; }
private void CheckEmitChange() { if (this._emit != this.Emit) { this._emit = this.Emit; if (this._emit) { this._activeTrail = new PCTrail(this.GetMaxNumberOfPoints()); this._activeTrail.IsActiveTrail = true; this.OnStartEmit(); } else { this.OnStopEmit(); this._activeTrail.IsActiveTrail = false; this._fadingTrails.Add(this._activeTrail); this._activeTrail = null; } } }
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 virtual void OnDestroy() { TrailRenderer_Base.GlobalTrailRendererCount--; if (TrailRenderer_Base.GlobalTrailRendererCount == 0) { if (TrailRenderer_Base._toClean != null && TrailRenderer_Base._toClean.Count > 0) { foreach (Mesh current in TrailRenderer_Base._toClean) { if (Application.isEditor) { UnityEngine.Object.DestroyImmediate(current, true); } else { UnityEngine.Object.Destroy(current); } } } TrailRenderer_Base._toClean = null; TrailRenderer_Base._matToTrailList.Clear(); TrailRenderer_Base._matToTrailList = null; } if (this._activeTrail != null) { this._activeTrail.Dispose(); this._activeTrail = null; } if (this._fadingTrails != null) { foreach (PCTrail current2 in this._fadingTrails) { if (current2 != null) { current2.Dispose(); } } this._fadingTrails.Clear(); } }
protected virtual void OnDestroy() { GlobalTrailRendererCount--; if(GlobalTrailRendererCount == 0) { if(_toClean != null && _toClean.Count > 0) { foreach (Mesh mesh in _toClean) { if (Application.isEditor) DestroyImmediate(mesh, true); else Destroy(mesh); } } _toClean = null; _matToTrailList.Clear(); _matToTrailList = null; } if (_activeTrail != null) { _activeTrail.Dispose(); _activeTrail = null; } if (_fadingTrails != null) { foreach (PCTrail fadingTrail in _fadingTrails) { if (fadingTrail != null) fadingTrail.Dispose(); } _fadingTrails.Clear(); } }
/// <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); }