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);
}
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 FindWheels(TrackMarksBuilderComponent builder, ChassisAnimationComponent chassis, TrackMarksComponent trackMarks)
{
List <Transform> list = this.FindAllNodes(trackMarks.transform, chassis.movingWheelName, null);
List <Transform> list2 = new List <Transform>();
List <Transform> list3 = new List <Transform>();
for (int i = 0; i < list.Count; i++)
{
Transform item = list[i];
if (item.name.Contains("left_"))
{
list2.Add(item);
}
if (item.name.Contains("right_"))
{
list3.Add(item);
}
}
ZSorter comparer = new ZSorter();
list2.Sort(comparer);
list3.Sort(comparer);
builder.leftWheels = list2.ToArray();
builder.rightWheels = list3.ToArray();
}
public void OnInit(ChassisInitEvent e, ChassisAnimationInitNode node)
{
Transform root = node.tankVisualRoot.transform;
ChassisAnimationComponent chassisAnimation = node.chassisAnimation;
ChassisTrackControllerComponent component = new ChassisTrackControllerComponent {
LeftTrack = this.ConstructController(chassisAnimation.leftTrackData, root),
RightTrack = this.ConstructController(chassisAnimation.rightTrackData, root)
};
chassisAnimation.TracksMaterial = TankMaterialsUtil.GetTrackMaterial(node.trackRenderer.Renderer);
node.Entity.AddComponent(component);
}
public void AnimateWheelsAndTracksRotation(TimeUpdateEvent evt, AliveChassisAnimationNode node)
{
if (node.cameraVisibleTrigger.IsVisibleAtRange(50f))
{
ChassisAnimationComponent chassisAnimation = node.chassisAnimation;
TrackComponent track = node.track;
TrackController leftTrack = node.chassisTrackController.LeftTrack;
TrackController rightTrack = node.chassisTrackController.RightTrack;
float maxSpeed = node.effectiveSpeed.MaxSpeed;
float deltaTime = evt.DeltaTime;
this.CalculateTrackAnimationSpeed(track.LeftTrack, node, maxSpeed, deltaTime);
chassisAnimation.LeftTrackPosition += (track.LeftTrack.animationSpeed * deltaTime) * 0.5f;
leftTrack.UpdateWheelsRotation(chassisAnimation.LeftTrackPosition);
this.CalculateTrackAnimationSpeed(track.RightTrack, node, maxSpeed, deltaTime);
chassisAnimation.RightTrackPosition += (track.RightTrack.animationSpeed * deltaTime) * 0.5f;
rightTrack.UpdateWheelsRotation(chassisAnimation.RightTrackPosition);
if (chassisAnimation.TracksMaterial != null)
{
float num4 = -chassisAnimation.RightTrackPosition * chassisAnimation.tracksMaterialSpeedMultiplyer;
Vector2 vector = new Vector2((-chassisAnimation.LeftTrackPosition * chassisAnimation.tracksMaterialSpeedMultiplyer) % 1f, num4 % 1f);
chassisAnimation.TracksMaterial.SetVector(TankMaterialPropertyNames.TRACKS_OFFSET, vector);
}
}
}
public void AnimateWheelsAndTracksPosition(TimeUpdateEvent evt, ChassisAnimationNode node)
{
if (((GraphicsSettings.INSTANCE.CurrentQualityLevel > 1) || !node.Entity.HasComponent <SelfTankComponent>()) ? ((GraphicsSettings.INSTANCE.CurrentQualityLevel > 1) && node.cameraVisibleTrigger.IsVisibleAtRange(50f)) : true)
{
ChassisAnimationComponent chassisAnimation = node.chassisAnimation;
TrackController leftTrack = node.chassisTrackController.LeftTrack;
TrackController rightTrack = node.chassisTrackController.RightTrack;
leftTrack.highDistance = chassisAnimation.highDistance;
leftTrack.lowDistance = chassisAnimation.lowDistance;
rightTrack.highDistance = chassisAnimation.highDistance;
rightTrack.lowDistance = chassisAnimation.lowDistance;
Transform transform = node.tankVisualRoot.transform;
if (chassisAnimation.additionalRaycastsEnabled)
{
leftTrack.AnimateWithAdditionalRays(transform, chassisAnimation.smoothSpeed, chassisAnimation.maxStretchingCoeff);
rightTrack.AnimateWithAdditionalRays(transform, chassisAnimation.smoothSpeed, chassisAnimation.maxStretchingCoeff);
}
else
{
leftTrack.Animate(transform, chassisAnimation.smoothSpeed, chassisAnimation.maxStretchingCoeff);
rightTrack.Animate(transform, chassisAnimation.smoothSpeed, chassisAnimation.maxStretchingCoeff);
}
}
}
