public void OnUpdate(UpdateEvent evt, TrackMarkUpdateNode node, [JoinAll] CameraNode cameraNode)
{
if (cameraNode.camera.Enabled)
{
int num = 6 - GraphicsSettings.INSTANCE.CurrentQualityLevel;
if (num > 0)
{
long num2;
node.trackMarks.tick = num2 = node.trackMarks.tick + 1L;
if ((num2 % ((long)num)) != 0L)
{
return;
}
}
node.trackMarks.tick = 0L;
TrackMarksRenderComponent trackMarksRender = node.trackMarksRender;
TrackMarksBuilderComponent trackMarksBuilder = node.trackMarksBuilder;
ChassisAnimationComponent chassisAnimation = node.chassisAnimation;
TrackMarksComponent trackMarks = node.trackMarks;
trackMarksBuilder.rigidbody = node.rigidbody.Rigidbody;
if (this.NeedUpdateMarks(trackMarksBuilder, trackMarks))
{
this.UpdateSingleTrack(trackMarksBuilder, chassisAnimation, trackMarksRender, trackMarks, 0, trackMarksBuilder.leftWheels, trackMarksBuilder.prevLeftWheelsData, trackMarksBuilder.currentLeftWheelsData, trackMarksBuilder.tempLeftWheelsData);
this.UpdateSingleTrack(trackMarksBuilder, chassisAnimation, trackMarksRender, trackMarks, 1, trackMarksBuilder.rightWheels, trackMarksBuilder.prevRightWheelsData, trackMarksBuilder.currentRightWheelsData, trackMarksBuilder.tempRightWheelsData);
}
if (trackMarksRender.dirty)
{
this.UpdateMesh(trackMarksRender);
trackMarksRender.dirty = false;
}
}
}
private void UpdateTrack(TrackMarksBuilderComponent builder, TrackMarksRenderComponent render, TrackMarksComponent trackMarks, int track, bool hit, ref RaycastHit hitData, float width, float shiftToBack)
{
if (!hit)
{
this.ResetTrack(builder, trackMarks, track, ref hitData);
}
else if (!builder.prevHits[track])
{
this.ResetTrack(builder, trackMarks, track, ref hitData);
}
else
{
Vector3 normalized = this.GetVelocity(builder).normalized;
builder.nextPositions[track] = (hitData.point - (((trackMarks.transform.forward * shiftToBack) * trackMarks.markWidth) / 2f)) + ((normalized * shiftToBack) * trackMarks.markWidth);
builder.nextNormals[track] = hitData.normal;
if (this.CheckEnoughMove(builder, track, ref hitData) && (this.CheckDirectionChange(builder, trackMarks, track, ref hitData) && this.CheckNormalChange(builder, trackMarks, track, ref hitData)))
{
float rotationCos = Vector3.Dot(trackMarks.transform.forward, normalized);
if (rotationCos > 0.95f)
{
rotationCos = 1f;
}
else if (rotationCos < 0.8f)
{
rotationCos = 0f;
}
this.MakeTracks(render, track, builder.positions[track], builder.directions[track], builder.nextPositions[track], normalized, hitData.normal, width, width / trackMarks.markWidth, rotationCos, builder.contiguous[track]);
builder.directions[track] = normalized;
builder.positions[track] = builder.nextPositions[track];
builder.normals[track] = builder.nextNormals[track];
builder.contiguous[track] = true;
}
}
builder.prevHits[track] = hit;
}
public void InitTracks(InitTrackRendererEvent e, TrackMarksInitNode node)
{
Transform parent = node.assembledTank.AssemblyRoot.transform;
TrackMarksComponent trackMarks = node.trackMarks;
TrackMarksRenderComponent render = new TrackMarksRenderComponent {
mesh = new Mesh()
};
render.mesh.MarkDynamic();
GameObject obj2 = new GameObject("Track");
obj2.transform.SetParent(parent);
obj2.AddComponent <MeshFilter>().mesh = render.mesh;
trackMarks.material = new Material(trackMarks.material);
MeshRenderer renderer = obj2.AddComponent <MeshRenderer>();
renderer.material = trackMarks.material;
foreach (ParticleSystem system in trackMarks.particleSystems)
{
ParticleSystem.ShapeModule shape = system.shape;
shape.enabled = true;
shape.shapeType = ParticleSystemShapeType.MeshRenderer;
shape.meshRenderer = renderer;
}
this.InitTrackMarksRender(render, trackMarks);
node.Entity.AddComponent(render);
base.NewEvent <InitTrackBuilderEvent>().Attach(node).ScheduleDelayed(0.3f);
}
private void UpdateMesh(TrackMarksRenderComponent data)
{
int firstVertex = 0;
int firstIndex = 0;
for (int i = 0; i < 2; i++)
{
this.CopyToMesh(data.trackRenderDatas[i], data.meshPositions, data.meshUVs, data.meshNormals, data.meshColors, data.meshTris, firstVertex, firstIndex, out firstIndex, out firstVertex);
}
data.mesh.vertices = data.meshPositions;
data.mesh.uv = data.meshUVs;
data.mesh.normals = data.meshNormals;
data.mesh.triangles = data.meshTris;
data.mesh.colors = data.meshColors;
data.mesh.RecalculateBounds();
}
private void InitTrackMarksRender(TrackMarksRenderComponent render, TrackMarksComponent trackMarks)
{
int num = (2 * trackMarks.maxSectorsPerTrack) * 4;
int num2 = (2 * trackMarks.maxSectorsPerTrack) * 6;
render.meshColors = new Color[num];
render.meshNormals = new Vector3[num];
render.meshPositions = new Vector3[num];
render.meshUVs = new Vector2[num];
render.meshTris = new int[num2];
render.trackRenderDatas = new TrackRenderData[2];
for (int i = 0; i < 2; i++)
{
render.trackRenderDatas[i] = new TrackRenderData(trackMarks.maxSectorsPerTrack, trackMarks.hideSectorsFrom, trackMarks.baseAlpha, trackMarks.parts);
}
}
private static void AllocateBuilder(TrackMarksBuilderComponent builder, TrackMarksComponent component, TrackMarksRenderComponent renderer)
{
builder.leftWheels = new Transform[3];
builder.rightWheels = new Transform[3];
builder.prevLeftWheelsData = new WheelData[3];
builder.prevRightWheelsData = new WheelData[3];
builder.tempLeftWheelsData = new WheelData[3];
builder.tempRightWheelsData = new WheelData[3];
builder.currentLeftWheelsData = new WheelData[3];
builder.currentRightWheelsData = new WheelData[3];
builder.positions = new Vector3[2];
builder.nextPositions = new Vector3[2];
builder.normals = new Vector3[2];
builder.nextNormals = new Vector3[2];
builder.directions = new Vector3[2];
builder.contiguous = new bool[2];
builder.prevHits = new bool[2];
builder.remaingDistance = new float[2];
builder.resetWheels = new bool[2];
builder.side = new float[] { -1f, 1f };
for (int i = 0; i < 2; i++)
{
builder.contiguous[i] = false;
builder.prevHits[i] = false;
}
builder.moveStep = component.markWidth / ((float)component.parts);
}
private unsafe void UpdateWheels(TrackMarksBuilderComponent builder, ChassisAnimationComponent chassis, TrackMarksRenderComponent render, TrackMarksComponent trackMarks, int track, WheelData[] currentWheelsPositions, WheelData[] prevWheelsPosition, WheelData[] temp)
{
float highDistance = chassis.highDistance;
WheelData data = prevWheelsPosition[prevWheelsPosition.Length / 2];
WheelData data2 = currentWheelsPositions[currentWheelsPositions.Length / 2];
float num2 = (data.position - data2.position).magnitude + builder.remaingDistance[track];
int num3 = (int)(num2 / builder.moveStep);
Vector3 lhs = Vector3.Cross(trackMarks.transform.up, this.GetVelocity(builder) * Time.smoothDeltaTime).normalized *builder.side[track];
float b = Mathf.Max(Mathf.Abs(Vector3.Dot(lhs, this.ComputeTrackDiagonal(builder, trackMarks, currentWheelsPositions, ref lhs))) / 2f, trackMarks.markWidth);
float a = Mathf.Max(Mathf.Abs(Vector3.Dot(lhs, this.ComputeTrackDiagonal(builder, trackMarks, prevWheelsPosition, ref lhs))) / 2f, trackMarks.markWidth);
bool flag = false;
RaycastHit hit = new RaycastHit();
for (int i = 0; i < num3; i++)
{
float t = ((float)i) / ((float)num3);
float width = Mathf.Lerp(a, b, t);
float num9 = Mathf.Min((float)(width / trackMarks.markWidth), (float)2f);
this.InterpolateWheelsPosition(t, prevWheelsPosition, currentWheelsPositions, temp);
flag = this.IsHit(builder, trackMarks, temp, highDistance, out hit);
RaycastHit *hitPtr1 = &hit;
hitPtr1.point -= (builder.side[track] * trackMarks.transform.right) * trackMarks.shiftToCenter;
this.UpdateTrack(builder, render, trackMarks, track, flag, ref hit, width, num9 - 1f);
num2 -= builder.moveStep;
}
builder.remaingDistance[track] = num2;
}
private void UpdateSingleTrack(TrackMarksBuilderComponent builder, ChassisAnimationComponent chassis, TrackMarksRenderComponent render, TrackMarksComponent trackMarks, int track, Transform[] wheels, WheelData[] prevWheelsData, WheelData[] currentWheelsData, WheelData[] tempWheelsData)
{
this.CheckResetWheels(builder, track, wheels, prevWheelsData);
this.CopyWheelsPositionFromTransforms(wheels, currentWheelsData);
this.UpdateWheels(builder, chassis, render, trackMarks, track, currentWheelsData, prevWheelsData, tempWheelsData);
Array.Copy(currentWheelsData, prevWheelsData, currentWheelsData.Length);
}
private void MakeTracks(TrackMarksRenderComponent trackMarksRender, int track, Vector3 startPosition, Vector3 startForward, Vector3 endPosition, Vector3 endForward, Vector3 normal, float width, float textureWidth, float rotationCos, bool contiguous)
{
this.AddSectorToRender(ref trackMarksRender.trackRenderDatas[track], startPosition, startForward, endPosition, endForward, normal, width, textureWidth, rotationCos, contiguous);
trackMarksRender.dirty = true;
}
