コード例 #1
0
 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);
 }
コード例 #2
0
        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);
        }
コード例 #3
0
 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;
         }
     }
 }
コード例 #4
0
 private void ResetTrack(TrackMarksBuilderComponent builder, TrackMarksComponent trackMarks, int i, ref RaycastHit hitData)
 {
     builder.directions[i]      = trackMarks.transform.forward;
     builder.nextPositions[i]   = builder.positions[i] = hitData.point;
     builder.nextNormals[i]     = builder.normals[i] = hitData.normal;
     builder.contiguous[i]      = false;
     builder.remaingDistance[i] = 0f;
 }
コード例 #5
0
 private bool CheckDirectionChange(TrackMarksBuilderComponent builder, TrackMarksComponent trackMarks, int i, ref RaycastHit hitData)
 {
     if (Mathf.Abs(Vector3.Dot(this.GetVelocity(builder).normalized, builder.directions[i])) >= 0.75f)
     {
         return(true);
     }
     this.ResetTrack(builder, trackMarks, i, ref hitData);
     return(false);
 }
コード例 #6
0
        public void InitBuilder(InitTrackBuilderEvent e, TrackMarksInitNode node, SingleNode <TrackMarksRenderComponent> renderer)
        {
            TrackMarksComponent        trackMarks = node.trackMarks;
            TrackMarksBuilderComponent builder    = new TrackMarksBuilderComponent();

            AllocateBuilder(builder, trackMarks, renderer.component);
            this.FindWheels(builder, node.chassisAnimation, trackMarks);
            node.Entity.AddComponent(builder);
        }
コード例 #7
0
 private bool CheckNormalChange(TrackMarksBuilderComponent builder, TrackMarksComponent trackMarks, int i, ref RaycastHit hitData)
 {
     if (Vector3.Dot(builder.normals[i], hitData.normal) >= 0.95f)
     {
         return(true);
     }
     this.ResetTrack(builder, trackMarks, i, ref hitData);
     return(false);
 }
コード例 #8
0
        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);
            }
        }
コード例 #9
0
        private bool IsHit(TrackMarksBuilderComponent builder, TrackMarksComponent trackMarks, WheelData[] wheels, float hitDistance, out RaycastHit hit)
        {
            WheelData data = wheels[wheels.Length / 2];
            bool      flag = Physics.Raycast(data.position, -trackMarks.transform.up, out hit, hitDistance * 2f, TRACK_LAYER_MASK);

            if (flag)
            {
                RaycastHit hit2;
                if ((hit.distance >= (hitDistance * 1.5f)) && !this.CheckExtraContacts(builder, trackMarks, wheels, hitDistance))
                {
                    return(false);
                }
                float maxDistance = hit.distance + 0.1f;
                flag &= Physics.Raycast(data.position + (data.right * trackMarks.markTestShift), -trackMarks.transform.up, out hit2, maxDistance, TRACK_LAYER_MASK);
                if (flag)
                {
                    RaycastHit hit3;
                    flag      &= Physics.Raycast(data.position - (data.right * trackMarks.markTestShift), -trackMarks.transform.up, out hit3, maxDistance, TRACK_LAYER_MASK);
                    hit.normal = (hit3.normal + hit3.normal) / 2f;
                    hit.point  = (hit3.point + hit2.point) / 2f;
                }
            }
            return(flag);
        }
コード例 #10
0
        private bool CheckExtraContacts(TrackMarksBuilderComponent builder, TrackMarksComponent trackMarks, WheelData[] wheels, float hitDistance)
        {
            float maxDistance = hitDistance + 0.2f;

            return(Physics.Raycast(wheels[0].position, -trackMarks.transform.up, maxDistance, TRACK_LAYER_MASK) || !Physics.Raycast(wheels[wheels.Length - 1].position, -trackMarks.transform.up, maxDistance, TRACK_LAYER_MASK));
        }
コード例 #11
0
        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;
        }
コード例 #12
0
 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;
 }
コード例 #13
0
 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);
 }
コード例 #14
0
 private bool NeedUpdateMarks(TrackMarksBuilderComponent builder, TrackMarksComponent trackMarks) =>
 (builder.CachedCamera.transform.position - trackMarks.transform.position).magnitude <= trackMarks.maxDistance;
コード例 #15
0
        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();
        }
コード例 #16
0
 private Vector3 ComputeTrackDiagonal(TrackMarksBuilderComponent builder, TrackMarksComponent trackMarks, WheelData[] data, ref Vector3 left) =>
 (data[data.Length - 1].position + ((data[data.Length - 1].right * trackMarks.markWidth) / 2f)) - (data[0].position - ((data[0].right * trackMarks.markWidth) / 2f));