示例#1
0
    public static List <RenderVertexShortcut> calculateShortcuts(Vector2[] borderline, bool noCircles)
    {
        List <RenderVertexShortcut> lSCs = new List <RenderVertexShortcut>();

        int startIndexLeft = -1;

        for (int i = 0; i < borderline.Length; i++)
        {
            int  i2       = (i + 1) % borderline.Length;
            Line lineHere = new Line(borderline[i], borderline[i2]);

            bool intersectsSomewhere = false;

            for (int j = 1; j < borderline.Length - 2; j++)
            {
                int  j1       = (j + i2) % borderline.Length;
                int  j2       = (j1 + 1) % borderline.Length;
                Line lineTest = new Line(borderline[j1], borderline[j2]);

                Vector2 isecPoint;
                if (lineHere.Intersects(lineTest, out isecPoint))
                {
                    intersectsSomewhere = true;
                    break;
                }
            }

            if (!intersectsSomewhere)
            {
                startIndexLeft = i;
                break;
            }
        }

        for (int i = 1; i < borderline.Length; i++)
        {
            int i1 = (i + startIndexLeft) % borderline.Length;
            int i2 = (i1 + 1) % borderline.Length;

            Line lineHere = new Line(borderline[i1], borderline[i2]);

            for (int j = 1; j < borderline.Length - 2; j++)      //Perhaps -1 is working too
            {
                int j1 = (i1 - j) < 0 ? (i1 - j) + borderline.Length : (i1 - j);
                int j2 = (j1 - 1) < 0 ? (j1 - 1) + borderline.Length : (j1 - 1);


                if (noCircles == false || Mathf.Abs(j1 - j2) <= 1)
                {
                    if (j1 < 0 || j2 < 0 || j1 >= borderline.Length || j2 >= borderline.Length)
                    {
                        Debug.LogError("what: " + j1 + "," + j2 + " at " + borderline.Length);
                    }
                    else
                    {
                        Line lineOther = new Line(borderline[j1], borderline[j2]);

                        Vector2 isecPoint;
                        if (lineHere.Intersects(lineOther, out isecPoint))
                        {
                            RenderVertexShortcut rvs = new RenderVertexShortcut();
                            rvs.indexAfter     = j1;
                            rvs.indexBefore    = i1;
                            rvs.intersectPoint = isecPoint;
                            lSCs.Add(rvs);

                            int jumpedDistance = j1 - i1;
                            if (jumpedDistance < 0)
                            {
                                jumpedDistance = (j1 + borderline.Length) - i1;
                            }

                            i += (jumpedDistance - 1);
                        }
                    }
                }
            }
        }

        return(lSCs);
    }
示例#2
0
    public void GenerateMesh()
    {
        // right Track Vertices
        List <Vector2> rT = new List <Vector2>();
        // left Track Vertices
        List <Vector2> lT = new List <Vector2>();
        // right Grass Vertices
        List <Vector2> rG = new List <Vector2>();
        // right Grass Vertices
        List <Vector2> lG = new List <Vector2>();


        /*if (Elements[0].GetType() == typeof(GeneratedStraight))
         * {
         *  GeneratedStraight straight = (GeneratedStraight)Elements[0];
         *
         *  Vector3 toRight = (Quaternion.Euler(0f, (straight.Direction * 180f) / Mathf.PI, 0f)) * (new Vector3(straight.WidthStart, 0f, 0f));
         *
         *  lT.Add(new Vector2((straight.Position - toRight).x, (straight.Position - toRight).z));
         *  rT.Add(new Vector2((straight.Position + toRight).x, (straight.Position + toRight).z));
         *
         * }
         * else if (Elements[0].GetType() == typeof(GeneratedTurn))
         * {
         *  GeneratedTurn turn = (GeneratedTurn)Elements[0];
         *
         *  Vector3 toRight = (Quaternion.Euler(0f, (turn.Direction * 180f) / Mathf.PI, 0f)) * (new Vector3(turn.WidthStart, 0f, 0f));
         *
         *  lT.Add(new Vector2((turn.Position - toRight).x, (turn.Position - toRight).z));
         *  rT.Add(new Vector2((turn.Position + toRight).x, (turn.Position + toRight).z));
         * }
         * else if (Elements[0].GetType() == typeof(GeneratedBezSpline))
         * {
         *  GeneratedBezSpline bezSpline = (GeneratedBezSpline)Elements[0];
         *
         *  lT.Add(new Vector2((bezSpline.RenderVertsLeft[0]).x, (bezSpline.RenderVertsLeft[0]).z));
         *  rT.Add(new Vector2((bezSpline.RenderVertsRight[0]).x, (bezSpline.RenderVertsRight[0]).z));
         * }*/


        for (int i = 0; i < Elements.Length; i++)
        {
            if (Elements[i].GetType() == typeof(GeneratedStraight))
            {
                GeneratedStraight straight = (GeneratedStraight)Elements[i];

                Vector3 toRight = (Quaternion.Euler(0f, (straight.Direction * 180f) / Mathf.PI, 0f)) * (new Vector3(straight.WidthEnd, 0f, 0f));
                Vector3 toFront = (Quaternion.Euler(0f, (straight.Direction * 180f) / Mathf.PI, 0f)) * (new Vector3(0f, 0f, straight.Length));


                int segmentsAmount = (int)(straight.Length / DiscreteTrack.straightSegmentingFactorMesh);

                for (int j = 1; j <= segmentsAmount; j++)
                {
                    float s = ((float)j) / segmentsAmount;


                    lT.Add(new Vector2((straight.Position + (toFront * s) - toRight).x, (straight.Position + (toFront * s) - toRight).z));
                    rT.Add(new Vector2((straight.Position + (toFront * s) + toRight).x, (straight.Position + (toFront * s) + toRight).z));

                    /*
                     *  -2    -1
                     *   x-----x
                     *   |\    |
                     *   | \   |  / \
                     *   |  \  |   |  Drive Direction
                     *   |   \ |   |
                     *   |    \|
                     *   x-----x
                     *  -4    -3
                     *
                     * */
                }
            }
            else if (Elements[i].GetType() == typeof(GeneratedTurn))
            {
                GeneratedTurn turn = (GeneratedTurn)Elements[i];

                bool rightTurn = turn.Degree >= 0f;

                Vector3 toRight = (Quaternion.Euler(0f, (turn.Direction * 180f) / Mathf.PI, 0f)) * (new Vector3(1f, 0f, 0f));
                Vector3 toFront = (Quaternion.Euler(0f, (turn.Direction * 180f) / Mathf.PI, 0f)) * (new Vector3(0f, 0f, 1f));

                Vector3 middlePoint = toRight * turn.Radius * (rightTurn ? 1f : -1f);

                int segmentsAmount = ((int)(Mathf.Abs(turn.Degree) / maxTurnDegreeResolution)) + 1;

                for (int j = 1; j <= segmentsAmount; j++)
                {
                    Vector3 toRightTurned = (Quaternion.Euler(0f, (turn.Degree / ((float)segmentsAmount)) * j, 0f)) * toRight;

                    Vector3 segmentPos = middlePoint + (toRightTurned * (rightTurn ? -1f : 1f) * turn.Radius);

                    float currentWidth = (turn.WidthEnd - turn.WidthStart) * (float)((float)j / (float)segmentsAmount) + turn.WidthStart;

                    lT.Add(new Vector2((segmentPos + toRightTurned * currentWidth * -1f + turn.Position).x, (segmentPos + toRightTurned * currentWidth * -1f + turn.Position).z));
                    rT.Add(new Vector2((segmentPos + toRightTurned * currentWidth + turn.Position).x, (segmentPos + toRightTurned * currentWidth + turn.Position).z));
                }
            }
            else if (Elements[i].GetType() == typeof(GeneratedBezSpline))
            {
                GeneratedBezSpline bezierSpline = (GeneratedBezSpline)Elements[i];

                for (int j = 1; j < bezierSpline.RenderVertsLeft.Length; j++)
                {
                    lT.Add(new Vector2((bezierSpline.RenderVertsLeft[j]).x, (bezierSpline.RenderVertsLeft[j]).z));
                    rT.Add(new Vector2((bezierSpline.RenderVertsRight[j]).x, (bezierSpline.RenderVertsRight[j]).z));
                }
            }
        }



        // Cutting of the overlapping segments

        List <RenderVertexShortcut> lSCs = calculateShortcuts(lT);
        List <RenderVertexShortcut> rSCs = calculateShortcuts(rT);

        for (int i = 0; i < lSCs.Count; i++)
        {
            RenderVertexShortcut rvs = lSCs[i];
            for (int j = rvs.indexBefore + 1; j < (rvs.indexAfter < rvs.indexBefore ? lT.Count : rvs.indexAfter); j++)
            {
                lT[j] = rvs.intersectPoint;
            }
            for (int j = 0; j < (rvs.indexAfter < rvs.indexBefore ? rvs.indexAfter : 0); j++)
            {
                lT[j] = rvs.intersectPoint;
            }
        }
        for (int i = 0; i < rSCs.Count; i++)
        {
            RenderVertexShortcut rvs = rSCs[i];
            for (int j = rvs.indexBefore + 1; j < (rvs.indexAfter < rvs.indexBefore ? rT.Count : rvs.indexAfter); j++)
            {
                rT[j] = rvs.intersectPoint;
            }
            for (int j = 0; j < (rvs.indexAfter < rvs.indexBefore ? rvs.indexAfter : 0); j++)
            {
                rT[j] = rvs.intersectPoint;
            }
        }



        float grassWidth = 8f;

        List <Vector2> lGFull = new List <Vector2>();
        List <Vector2> rGFull = new List <Vector2>();

        for (int i = 0; i < lT.Count; i++)
        {
            int i0 = (i - 1) < 0 ? lT.Count - 1 : i - 1;
            int i2 = (i + 1) % lT.Count;

            Vector2 tangentLeft  = lT[i2] - lT[i0];
            Vector2 newVLeft     = (new Vector2(-tangentLeft.y, tangentLeft.x)).normalized * grassWidth + lT[i];
            Vector2 tangentRight = rT[i2] - rT[i0];
            Vector2 newVRight    = (new Vector2(tangentRight.y, -tangentRight.x)).normalized * grassWidth + rT[i];

            Vector2 vLeft  = (lT[i] - rT[i]).normalized * grassWidth + lT[i];
            Vector2 vRight = (rT[i] - lT[i]).normalized * grassWidth + rT[i];

            lG.Add(newVLeft);
            rG.Add(newVRight);
            lGFull.Add(newVLeft);
            rGFull.Add(newVRight);
        }

        int grassPlanesNewStartIndex = -1;

        if (discreteTrack != null)
        {
            Vector2 startFinishPos = new Vector2(elements[(int)discreteTrack.startFinishLineIndex].Position.x, elements[(int)discreteTrack.startFinishLineIndex].Position.z);


            float minDistance = float.MaxValue;

            for (int i = 0; i < lGFull.Count; i++)
            {
                if (Vector2.Distance(lGFull[i], startFinishPos) < minDistance)
                {
                    grassPlanesNewStartIndex = i;
                    minDistance = Vector2.Distance(lGFull[i], startFinishPos);
                }
            }

            Debug.Log("Grass start index: " + grassPlanesNewStartIndex);

            List <Vector2> lGFullNew = new List <Vector2>();
            List <Vector2> rGFullNew = new List <Vector2>();
            List <Vector2> rTNew     = new List <Vector2>();
            List <Vector2> lTNew     = new List <Vector2>();
            List <Vector2> rGNew     = new List <Vector2>();
            List <Vector2> lGNew     = new List <Vector2>();

            for (int i = 0; i < lGFull.Count; i++)
            {
                lGFullNew.Add(lGFull[(i + grassPlanesNewStartIndex) % lGFull.Count]);
                lTNew.Add(lT[(i + grassPlanesNewStartIndex) % lGFull.Count]);
                lGNew.Add(lG[(i + grassPlanesNewStartIndex) % lGFull.Count]);

                rGFullNew.Add(rGFull[(i + grassPlanesNewStartIndex) % lGFull.Count]);
                rTNew.Add(rT[(i + grassPlanesNewStartIndex) % lGFull.Count]);
                rGNew.Add(rG[(i + grassPlanesNewStartIndex) % lGFull.Count]);
            }

            lGFull = lGFullNew;
            rGFull = rGFullNew;
            rT     = rTNew;
            lT     = lTNew;
            lG     = lGNew;
            rG     = rGNew;
        }



        // Curbs


        curbsGenerator = new CurbsGenerator(lT.ToArray(), rT.ToArray(), grassPlanesNewStartIndex);

        curbsGenerator.CalculateCurbs(discreteTrack);



        /*lGFull.Add(lGFull[0]);
         * rGFull.Add(rGFull[0]);
         * lG.Add(lG[0]);
         * rG.Add(rG[0]);
         * lT.Add(lT[0]);
         * rT.Add(rT[0]);*/



        // Generating the grass zones on the sides

        List <GeneratedGrassPlane> grassplanes = new List <GeneratedGrassPlane>();


        GeneratedPlaneElement[] leftGrassPlanes  = generateGrassplanes(lGFull, lG, lT, 0, 0, 0);
        GeneratedPlaneElement[] rightGrassPlanes = generateGrassplanes(rGFull, rG, rT, 0, 0, 0);
        GeneratedPlaneElement[] combinedPlanes   = new GeneratedPlaneElement[leftGrassPlanes.Length + rightGrassPlanes.Length];
        for (int i = 0; i < leftGrassPlanes.Length; i++)
        {
            combinedPlanes[i] = leftGrassPlanes[i];
        }
        for (int i = 0; i < rightGrassPlanes.Length; i++)
        {
            combinedPlanes[i + leftGrassPlanes.Length] = rightGrassPlanes[i];
        }



        // Track vertices

        List <Vector3> vertices  = new List <Vector3>();
        List <int>     triangles = new List <int>();
        List <Vector2> uvs       = new List <Vector2>();

        float rightUvCounter = 0f;
        float leftUvCounter  = 0f;

        vertices.Add(new Vector3(lT[0].x, 0f, lT[0].y));
        uvs.Add(new Vector2(0f, leftUvCounter));
        vertices.Add(new Vector3(rT[0].x, 0f, rT[0].y));
        uvs.Add(new Vector2(1f, rightUvCounter));
        for (int i = 1; i < lT.Count; i++)
        {
            vertices.Add(new Vector3(lT[i].x, 0f, lT[i].y));
            leftUvCounter += (Vector3.Distance(vertices[vertices.Count - 3], vertices[vertices.Count - 1])) * (1f / 16f);
            uvs.Add(new Vector2(0f, leftUvCounter));
            vertices.Add(new Vector3(rT[i].x, 0f, rT[i].y));
            rightUvCounter += (Vector3.Distance(vertices[vertices.Count - 3], vertices[vertices.Count - 1])) * (1f / 16f);
            uvs.Add(new Vector2(1f, rightUvCounter));

            triangles.Add(vertices.Count - 4);
            triangles.Add(vertices.Count - 2);
            triangles.Add(vertices.Count - 3);
            triangles.Add(vertices.Count - 2);
            triangles.Add(vertices.Count - 1);
            triangles.Add(vertices.Count - 3);
        }


        vertices.Add(new Vector3(lT[0].x, 0f, lT[0].y));
        leftUvCounter += (Vector3.Distance(vertices[vertices.Count - 3], vertices[vertices.Count - 1])) * (1f / 16f);
        uvs.Add(new Vector2(0f, leftUvCounter));
        vertices.Add(new Vector3(rT[0].x, 0f, rT[0].y));
        rightUvCounter += (Vector3.Distance(vertices[vertices.Count - 3], vertices[vertices.Count - 1])) * (1f / 16f);
        uvs.Add(new Vector2(1f, rightUvCounter));

        triangles.Add(vertices.Count - 4);
        triangles.Add(vertices.Count - 2);
        triangles.Add(vertices.Count - 3);
        triangles.Add(vertices.Count - 2);
        triangles.Add(vertices.Count - 1);
        triangles.Add(vertices.Count - 3);



        RenderVerticesTrack  = vertices.ToArray();
        RenderTrianglesTrack = triangles.ToArray();
        RenderUVsTrack       = uvs.ToArray();


        // Grass vertices

        List <GeneratedGrassPlane> leftGrass = new List <GeneratedGrassPlane>();

        for (int i = 0; i < leftGrassPlanes.Length; i++)
        {
            GeneratedGrassPlane plane = new GeneratedGrassPlane();

            List <Vector3> verticesOutside    = new List <Vector3>();
            List <Vector3> directionsOutside  = new List <Vector3>();
            List <Vector3> verticesGrassLeft  = new List <Vector3>();
            List <int>     trianglesGrassLeft = new List <int>();
            List <Vector2> uvsGrassLeft       = new List <Vector2>();

            if (leftGrassPlanes[i].GetType() == typeof(GeneratedGrassPlane2D))
            {
                GeneratedGrassPlane2D ggp2d = (GeneratedGrassPlane2D)leftGrassPlanes[i];

                verticesOutside.Add(new Vector3(ggp2d.vertices[0].x, 0f, ggp2d.vertices[0].y));

                verticesGrassLeft.Add(new Vector3(ggp2d.vertices[0].x, 0f, ggp2d.vertices[0].y));
                uvsGrassLeft.Add(ggp2d.vertices[0]);
                verticesGrassLeft.Add(new Vector3(lT[ggp2d.trackStartIndex + 0].x, 0f, lT[ggp2d.trackStartIndex + 0].y));
                verticesGrassLeft[verticesGrassLeft.Count - 1] = verticesGrassLeft[verticesGrassLeft.Count - 2] + ((verticesGrassLeft[verticesGrassLeft.Count - 1] - verticesGrassLeft[verticesGrassLeft.Count - 2]).normalized * (Vector3.Distance(verticesGrassLeft[verticesGrassLeft.Count - 1], verticesGrassLeft[verticesGrassLeft.Count - 2]) - curbsGenerator.LeftWidths[ggp2d.trackStartIndex + 0]));
                uvsGrassLeft.Add(lT[ggp2d.trackStartIndex + 0]);

                directionsOutside.Add((verticesGrassLeft[verticesGrassLeft.Count - 2] - verticesGrassLeft[verticesGrassLeft.Count - 1]).normalized);

                for (int j = 1; j < ggp2d.vertices.Count; j++)
                {
                    bool locked = false;
                    for (int k = 0; k < ggp2d.jumpIndices.Count; k++)
                    {
                        if (j + ggp2d.trackStartIndex >= ggp2d.jumpIndices[k] && j + ggp2d.trackStartIndex < ggp2d.jumpIndices[k] + ggp2d.jumpWidths[k])
                        {
                            locked = true;
                        }
                    }


                    if (!locked)
                    {
                        verticesOutside.Add(new Vector3(ggp2d.vertices[j].x, 0f, ggp2d.vertices[j].y));

                        verticesGrassLeft.Add(new Vector3(ggp2d.vertices[j].x, 0f, ggp2d.vertices[j].y));
                        uvsGrassLeft.Add(ggp2d.vertices[j]);
                        verticesGrassLeft.Add(new Vector3(lT[ggp2d.trackStartIndex + j].x, 0f, lT[ggp2d.trackStartIndex + j].y));
                        verticesGrassLeft[verticesGrassLeft.Count - 1] = verticesGrassLeft[verticesGrassLeft.Count - 2] + ((verticesGrassLeft[verticesGrassLeft.Count - 1] - verticesGrassLeft[verticesGrassLeft.Count - 2]).normalized * (Vector3.Distance(verticesGrassLeft[verticesGrassLeft.Count - 1], verticesGrassLeft[verticesGrassLeft.Count - 2]) - curbsGenerator.LeftWidths[ggp2d.trackStartIndex + j]));
                        uvsGrassLeft.Add(lT[ggp2d.trackStartIndex + j]);

                        directionsOutside.Add((verticesGrassLeft[verticesGrassLeft.Count - 2] - verticesGrassLeft[verticesGrassLeft.Count - 1]).normalized);

                        trianglesGrassLeft.Add(verticesGrassLeft.Count - 4);
                        trianglesGrassLeft.Add(verticesGrassLeft.Count - 2);
                        trianglesGrassLeft.Add(verticesGrassLeft.Count - 3);
                        trianglesGrassLeft.Add(verticesGrassLeft.Count - 2);
                        trianglesGrassLeft.Add(verticesGrassLeft.Count - 1);
                        trianglesGrassLeft.Add(verticesGrassLeft.Count - 3);
                    }
                }

                verticesOutside.Add(new Vector3(ggp2d.vertices[0].x, 0f, ggp2d.vertices[0].y));
                verticesGrassLeft.Add(new Vector3(ggp2d.vertices[0].x, 0f, ggp2d.vertices[0].y));
                uvsGrassLeft.Add(ggp2d.vertices[0]);
                verticesGrassLeft.Add(new Vector3(lT[ggp2d.trackStartIndex + 0].x, 0f, lT[ggp2d.trackStartIndex + 0].y));
                verticesGrassLeft[verticesGrassLeft.Count - 1] = verticesGrassLeft[verticesGrassLeft.Count - 2] + ((verticesGrassLeft[verticesGrassLeft.Count - 1] - verticesGrassLeft[verticesGrassLeft.Count - 2]).normalized * (Vector3.Distance(verticesGrassLeft[verticesGrassLeft.Count - 1], verticesGrassLeft[verticesGrassLeft.Count - 2]) - curbsGenerator.LeftWidths[ggp2d.trackStartIndex + 0]));
                uvsGrassLeft.Add(lT[ggp2d.trackStartIndex + 0]);
                directionsOutside.Add((verticesGrassLeft[verticesGrassLeft.Count - 2] - verticesGrassLeft[verticesGrassLeft.Count - 1]).normalized);
                trianglesGrassLeft.Add(verticesGrassLeft.Count - 4);
                trianglesGrassLeft.Add(verticesGrassLeft.Count - 2);
                trianglesGrassLeft.Add(verticesGrassLeft.Count - 3);
                trianglesGrassLeft.Add(verticesGrassLeft.Count - 2);
                trianglesGrassLeft.Add(verticesGrassLeft.Count - 1);
                trianglesGrassLeft.Add(verticesGrassLeft.Count - 3);



                plane.vertices          = verticesGrassLeft.ToArray();
                plane.triangles         = trianglesGrassLeft.ToArray();
                plane.uvs               = uvsGrassLeft.ToArray();
                plane.AllowBordercross  = true;
                plane.verticesOutside   = verticesOutside.ToArray();
                plane.directionsOutside = directionsOutside.ToArray();

                leftGrass.Add(plane);
            }
            else
            {
                GeneratedPlaneBetween gpb = (GeneratedPlaneBetween)leftGrassPlanes[i];

                for (int j = 0; j < gpb.vertices.Count; j++)
                {
                    verticesGrassLeft.Add(new Vector3(gpb.vertices[j].x, 0f, gpb.vertices[j].y));
                    uvsGrassLeft.Add(gpb.vertices[j]);
                }

                plane.vertices  = verticesGrassLeft.ToArray();
                plane.triangles = gpb.triangles.ToArray();
                plane.uvs       = uvsGrassLeft.ToArray();

                leftGrass.Add(plane);
            }
        }

        for (int i = 0; i < rightGrassPlanes.Length; i++)
        {
            GeneratedGrassPlane plane = new GeneratedGrassPlane();

            List <Vector3> verticesOutside    = new List <Vector3>();
            List <Vector3> directionsOutside  = new List <Vector3>();
            List <Vector3> verticesGrassLeft  = new List <Vector3>();
            List <int>     trianglesGrassLeft = new List <int>();
            List <Vector2> uvsGrassLeft       = new List <Vector2>();

            if (rightGrassPlanes[i].GetType() == typeof(GeneratedGrassPlane2D))
            {
                GeneratedGrassPlane2D ggp2d = (GeneratedGrassPlane2D)rightGrassPlanes[i];

                verticesOutside.Add(new Vector3(ggp2d.vertices[0].x, 0f, ggp2d.vertices[0].y));

                verticesGrassLeft.Add(new Vector3(ggp2d.vertices[0].x, 0f, ggp2d.vertices[0].y));
                uvsGrassLeft.Add(ggp2d.vertices[0]);
                verticesGrassLeft.Add(new Vector3(rT[ggp2d.trackStartIndex + 0].x, 0f, rT[ggp2d.trackStartIndex + 0].y));
                verticesGrassLeft[verticesGrassLeft.Count - 1] = verticesGrassLeft[verticesGrassLeft.Count - 2] + ((verticesGrassLeft[verticesGrassLeft.Count - 1] - verticesGrassLeft[verticesGrassLeft.Count - 2]).normalized * (Vector3.Distance(verticesGrassLeft[verticesGrassLeft.Count - 1], verticesGrassLeft[verticesGrassLeft.Count - 2]) - curbsGenerator.RightWidths[ggp2d.trackStartIndex + 0]));
                uvsGrassLeft.Add(rT[ggp2d.trackStartIndex + 0]);

                directionsOutside.Add((verticesGrassLeft[verticesGrassLeft.Count - 2] - verticesGrassLeft[verticesGrassLeft.Count - 1]).normalized);

                for (int j = 1; j < ggp2d.vertices.Count; j++)
                {
                    bool locked = false;
                    for (int k = 0; k < ggp2d.jumpIndices.Count; k++)
                    {
                        if (j + ggp2d.trackStartIndex >= ggp2d.jumpIndices[k] && j + ggp2d.trackStartIndex < ggp2d.jumpIndices[k] + ggp2d.jumpWidths[k])
                        {
                            locked = true;
                        }
                    }


                    if (!locked)
                    {
                        verticesOutside.Add(new Vector3(ggp2d.vertices[j].x, 0f, ggp2d.vertices[j].y));

                        verticesGrassLeft.Add(new Vector3(ggp2d.vertices[j].x, 0f, ggp2d.vertices[j].y));
                        uvsGrassLeft.Add(ggp2d.vertices[j]);
                        verticesGrassLeft.Add(new Vector3(rT[ggp2d.trackStartIndex + j].x, 0f, rT[ggp2d.trackStartIndex + j].y));
                        verticesGrassLeft[verticesGrassLeft.Count - 1] = verticesGrassLeft[verticesGrassLeft.Count - 2] + ((verticesGrassLeft[verticesGrassLeft.Count - 1] - verticesGrassLeft[verticesGrassLeft.Count - 2]).normalized * (Vector3.Distance(verticesGrassLeft[verticesGrassLeft.Count - 1], verticesGrassLeft[verticesGrassLeft.Count - 2]) - curbsGenerator.RightWidths[ggp2d.trackStartIndex + j]));
                        uvsGrassLeft.Add(rT[ggp2d.trackStartIndex + j]);

                        directionsOutside.Add((verticesGrassLeft[verticesGrassLeft.Count - 2] - verticesGrassLeft[verticesGrassLeft.Count - 1]).normalized);

                        trianglesGrassLeft.Add(verticesGrassLeft.Count - 4);
                        trianglesGrassLeft.Add(verticesGrassLeft.Count - 3);
                        trianglesGrassLeft.Add(verticesGrassLeft.Count - 2);
                        trianglesGrassLeft.Add(verticesGrassLeft.Count - 2);
                        trianglesGrassLeft.Add(verticesGrassLeft.Count - 3);
                        trianglesGrassLeft.Add(verticesGrassLeft.Count - 1);
                    }
                }
                verticesOutside.Add(new Vector3(ggp2d.vertices[0].x, 0f, ggp2d.vertices[0].y));
                verticesGrassLeft.Add(new Vector3(ggp2d.vertices[0].x, 0f, ggp2d.vertices[0].y));
                uvsGrassLeft.Add(ggp2d.vertices[0]);
                verticesGrassLeft.Add(new Vector3(rT[ggp2d.trackStartIndex + 0].x, 0f, rT[ggp2d.trackStartIndex + 0].y));
                verticesGrassLeft[verticesGrassLeft.Count - 1] = verticesGrassLeft[verticesGrassLeft.Count - 2] + ((verticesGrassLeft[verticesGrassLeft.Count - 1] - verticesGrassLeft[verticesGrassLeft.Count - 2]).normalized * (Vector3.Distance(verticesGrassLeft[verticesGrassLeft.Count - 1], verticesGrassLeft[verticesGrassLeft.Count - 2]) - curbsGenerator.RightWidths[ggp2d.trackStartIndex + 0]));
                uvsGrassLeft.Add(rT[ggp2d.trackStartIndex + 0]);
                directionsOutside.Add((verticesGrassLeft[verticesGrassLeft.Count - 2] - verticesGrassLeft[verticesGrassLeft.Count - 1]).normalized);
                trianglesGrassLeft.Add(verticesGrassLeft.Count - 4);
                trianglesGrassLeft.Add(verticesGrassLeft.Count - 3);
                trianglesGrassLeft.Add(verticesGrassLeft.Count - 2);
                trianglesGrassLeft.Add(verticesGrassLeft.Count - 2);
                trianglesGrassLeft.Add(verticesGrassLeft.Count - 3);
                trianglesGrassLeft.Add(verticesGrassLeft.Count - 1);



                plane.vertices          = verticesGrassLeft.ToArray();
                plane.triangles         = trianglesGrassLeft.ToArray();
                plane.uvs               = uvsGrassLeft.ToArray();
                plane.AllowBordercross  = true;
                plane.verticesOutside   = verticesOutside.ToArray();
                plane.directionsOutside = directionsOutside.ToArray();

                leftGrass.Add(plane);
            }
            else
            {
                GeneratedPlaneBetween gpb = (GeneratedPlaneBetween)rightGrassPlanes[i];

                for (int j = 0; j < gpb.vertices.Count; j++)
                {
                    verticesGrassLeft.Add(new Vector3(gpb.vertices[j].x, 0f, gpb.vertices[j].y));
                    uvsGrassLeft.Add(gpb.vertices[j]);
                }
                for (int j = 0; j < gpb.triangles.Count; j += 3)
                {
                    trianglesGrassLeft.Add(gpb.triangles[j]);
                    trianglesGrassLeft.Add(gpb.triangles[j + 2]);
                    trianglesGrassLeft.Add(gpb.triangles[j + 1]);
                }

                plane.vertices         = verticesGrassLeft.ToArray();
                plane.triangles        = trianglesGrassLeft.ToArray();
                plane.uvs              = uvsGrassLeft.ToArray();
                plane.AllowBordercross = false;

                leftGrass.Add(plane);
            }
        }

        GrassPlanes = leftGrass.ToArray();
    }
示例#3
0
    private GeneratedPlaneElement[] generateGrassplanes(List <Vector2> lGsFull, List <Vector2> lG, List <Vector2> lT, int startIndex, int trackStartIndex, int recDepth)
    {
        List <GeneratedPlaneElement> planes = new List <GeneratedPlaneElement>();

        List <RenderVertexShortcut> lGSCs = calculateShortcuts(lG);

        List <int> jumpIndices = new List <int>();
        List <int> jumpWidths  = new List <int>();

        for (int i = 0; i < lGSCs.Count; i++)
        {
            RenderVertexShortcut rvs = lGSCs[i];

            List <Vector2> innerLG = new List <Vector2>();

            for (int j = rvs.indexBefore + 1; j < rvs.indexAfter; j++)
            {
                innerLG.Add(lG[j]);
                lG[j] = rvs.intersectPoint;
            }

            /*for (int j = rvs.indexBefore + 1; j < (rvs.indexAfter < rvs.indexBefore ? lG.Count : rvs.indexAfter); j++)
             * {
             *  innerLG.Add(lG[j]);
             *  lG[j] = rvs.intersectPoint;
             * }
             * for (int j = 0; j < (rvs.indexAfter < rvs.indexBefore ? rvs.indexAfter : 0); j++)
             * {
             *  innerLG.Add(lG[j]);
             *  lG[j] = rvs.intersectPoint;
             * }*/

            List <RenderVertexShortcut> innerLGSCs = calculateShortcuts(innerLG);


            bool intersectsSomewhere = false;
            for (int j = rvs.indexBefore + 1; j < rvs.indexAfter; j++)
            {
                Line throughField = new Line(rvs.intersectPoint, lT[(j + startIndex) % lT.Count] - (lT[(j + startIndex) % lT.Count] - rvs.intersectPoint).normalized * 0.4f);

                for (int k = rvs.indexBefore + 1; k < rvs.indexAfter; k++)
                {
                    if (k - 2 != j && k - 1 != j && k != j && k + 1 != j)
                    {
                        Line trackAlong = new Line(lT[(k + startIndex - 1) % lT.Count], lT[(k + startIndex) % lT.Count]);

                        Vector2 isecPt;
                        if (trackAlong.Intersects(throughField, out isecPt))
                        {
                            //Debug.Log("Isec: " + isecPt.ToString());
                            intersectsSomewhere = true;
                            break;
                        }
                    }
                }
            }

            if (innerLGSCs.Count > 0 && intersectsSomewhere)
            {
                List <Vector2> recLG = new List <Vector2>();
                List <Vector2> recLT = new List <Vector2>();

                for (int recI = innerLGSCs[0].indexBefore + 1; recI < (innerLGSCs[0].indexAfter + (lGsFull.Count / 2) <= innerLGSCs[0].indexBefore ? innerLGSCs[0].indexAfter + lGsFull.Count : innerLGSCs[0].indexAfter); recI++)
                {
                    recLG.Add(lGsFull[(recI + rvs.indexBefore + 1 + startIndex) % lGsFull.Count]);
                }

                if (recLG.Count >= 2)
                {
                    jumpIndices.Add(rvs.indexBefore + startIndex);
                    jumpWidths.Add((rvs.indexAfter > rvs.indexBefore ? rvs.indexAfter : rvs.indexAfter + lGsFull.Count) - rvs.indexBefore);

                    planes.AddRange(generateGrassplanes(lGsFull, recLG, lT, innerLGSCs[0].indexBefore + 1 + rvs.indexBefore + 1, startIndex, recDepth + 1));

                    Vector2 pointDown = rvs.intersectPoint;
                    Vector2 pointUp   = innerLGSCs[0].intersectPoint;
                    Line    lineMid   = new Line(pointDown, pointUp);

                    GeneratedPlaneBetween gpb       = new GeneratedPlaneBetween();
                    List <Vector2>        leftVerts = new List <Vector2>();
                    for (int j = rvs.indexAfter; j >= innerLGSCs[0].indexAfter + rvs.indexBefore; j--)
                    {
                        leftVerts.Add(lT[(j + startIndex) % lT.Count]);
                    }
                    List <Vector2> rightVerts = new List <Vector2>();
                    for (int j = rvs.indexBefore - 1; j <= innerLGSCs[0].indexBefore + rvs.indexBefore + 2; j++)
                    {
                        rightVerts.Add(lT[(j + startIndex) % lT.Count]);
                    }

                    int leftEndIndex  = innerLGSCs[0].indexAfter + rvs.indexBefore;
                    int rightEndIndex = innerLGSCs[0].indexBefore + rvs.indexBefore + 2;


                    //gpb.vertices.Add(leftVerts[0]);
                    //gpb.vertices.Add(rightVerts[0]);
                    for (int j = 0; j < leftVerts.Count; j++)
                    {
                        gpb.vertices.Add(leftVerts[j]);
                    }
                    for (int j = 0; j < rightVerts.Count; j++)
                    {
                        gpb.vertices.Add(rightVerts[j]);
                    }

                    int lI = 0;
                    int rI = 0;

                    while (lI < leftVerts.Count && rI < rightVerts.Count)
                    {
                        if (lI < leftVerts.Count - 1 && rI < rightVerts.Count - 1)
                        {
                            if (Vector2.Distance(leftVerts[lI + 1], rightVerts[rI]) < Vector2.Distance(leftVerts[lI], rightVerts[rI + 1]))
                            {
                                lI++;
                                if (lI >= leftVerts.Count)
                                {
                                    break;
                                }

                                gpb.triangles.Add(lI);
                                gpb.triangles.Add(rI + leftVerts.Count);
                                gpb.triangles.Add(lI - 1);
                            }
                            else
                            {
                                rI++;
                                if (rI >= rightVerts.Count)
                                {
                                    break;
                                }

                                gpb.triangles.Add(rI + leftVerts.Count);
                                gpb.triangles.Add(rI + leftVerts.Count - 1);
                                gpb.triangles.Add(lI);
                            }
                        }
                        else if (lI == leftVerts.Count - 1)
                        {
                            rI++;
                            if (rI >= rightVerts.Count)
                            {
                                break;
                            }

                            gpb.triangles.Add(rI + leftVerts.Count);
                            gpb.triangles.Add(rI + leftVerts.Count - 1);
                            gpb.triangles.Add(lI);
                        }
                        else if (rI == rightVerts.Count - 1)
                        {
                            lI++;
                            if (lI >= leftVerts.Count)
                            {
                                break;
                            }

                            gpb.triangles.Add(lI);
                            gpb.triangles.Add(rI + leftVerts.Count);
                            gpb.triangles.Add(lI - 1);
                        }
                    }

                    gpb.vertices.Add(lGsFull[(leftEndIndex + startIndex) % lGsFull.Count]);
                    gpb.vertices.Add(lGsFull[(rightEndIndex + startIndex) % lGsFull.Count]);
                    gpb.triangles.Add(gpb.vertices.Count - 1);
                    gpb.triangles.Add(gpb.vertices.Count - 2);
                    gpb.triangles.Add(rightVerts.Count + leftVerts.Count - 1);
                    gpb.triangles.Add(gpb.vertices.Count - 1);
                    gpb.triangles.Add(rightVerts.Count + leftVerts.Count - 1);
                    gpb.triangles.Add(leftVerts.Count - 1);

                    gpb.triangles.Add(leftVerts.Count - 1);
                    gpb.triangles.Add(gpb.vertices.Count - 2);
                    gpb.triangles.Add(gpb.vertices.Count - 1);

                    gpb.triangles.Add(gpb.vertices.Count - 2);
                    gpb.triangles.Add(rightVerts.Count + leftVerts.Count - 1);
                    gpb.triangles.Add(gpb.vertices.Count - 1);

                    /*for (int j = 1; j < Mathf.Min(leftVerts.Count, rightVerts.Count); j++)
                     * {
                     *  gpb.vertices.Add(leftVerts[j]);
                     *  gpb.vertices.Add(rightVerts[j]);
                     *  gpb.triangles.Add(gpb.vertices.Count - 4);
                     *  gpb.triangles.Add(gpb.vertices.Count - 2);
                     *  gpb.triangles.Add(gpb.vertices.Count - 3);
                     *  gpb.triangles.Add(gpb.vertices.Count - 2);
                     *  gpb.triangles.Add(gpb.vertices.Count - 1);
                     *  gpb.triangles.Add(gpb.vertices.Count - 3);
                     * }
                     *
                     * if (leftVerts.Count > rightVerts.Count)
                     * {
                     *  for (int j = rightVerts.Count; j < leftVerts.Count; j++)
                     *  {
                     *      gpb.vertices.Add(leftVerts[j]);
                     *      gpb.triangles.Add(gpb.vertices.Count - 3);
                     *      gpb.triangles.Add(gpb.vertices.Count - 1);
                     *      gpb.triangles.Add(gpb.vertices.Count - 2);
                     *  }
                     * }
                     * else  if (leftVerts.Count < rightVerts.Count)
                     * {
                     *  for (int j = leftVerts.Count; j < rightVerts.Count; j++)
                     *  {
                     *      gpb.vertices.Add(rightVerts[j]);
                     *      gpb.triangles.Add(gpb.vertices.Count - 3);
                     *      gpb.triangles.Add(gpb.vertices.Count - 1);
                     *      gpb.triangles.Add(gpb.vertices.Count - 2);
                     *  }
                     * }*/

                    planes.Add(gpb);
                }

                // TODO recursive
            }
        }

        GeneratedGrassPlane2D ggp2d = new GeneratedGrassPlane2D();

        ggp2d.trackStartIndex = startIndex + trackStartIndex;
        ggp2d.vertices        = lG;
        ggp2d.jumpIndices.AddRange(jumpIndices);
        ggp2d.jumpWidths.AddRange(jumpWidths);
        planes.Add(ggp2d);

        return(planes.ToArray());
    }
示例#4
0
    public GeneratedCurb(Vector3[] vertices, Vector3[] directions, float width, float height, float endAngle, Vector3 prevT, Vector3 afteT)
    {
        Width = width;

        height = 0.1f;

        Vector3[] innerVerts = new Vector3[vertices.Length];
        Vector3[] outerVerts = new Vector3[vertices.Length];
        Vector2[] borderLine = new Vector2[vertices.Length];

        float wentDistance = 0f;

        innerVerts[0] = vertices[0];

        Vector3 toForwardFirst = Vector3.Cross(directions[0], Vector3.up);
        Vector3 goOffsetFirst  = Vector3.Cross(directions[0], toForwardFirst).normalized;

        if (goOffsetFirst.y < 0f)
        {
            goOffsetFirst *= -1f;
        }

        Vector3 newDirFirst = (directions[0].normalized * width + goOffsetFirst * minOuterOffset).normalized;

        outerVerts[0] = vertices[0] + directions[0].normalized * width;
        borderLine[0] = new Vector2(outerVerts[0].x, outerVerts[0].z);

        for (int i = 1; i < vertices.Length; i++)
        {
            innerVerts[i] = vertices[i];

            Vector3 toForward = Vector3.Cross(directions[i], Vector3.up);
            Vector3 goOffset  = Vector3.Cross(toForward, directions[i]).normalized;

            Vector3 newDir = (directions[i].normalized * width + goOffset * minOuterOffset).normalized;

            outerVerts[i] = vertices[i] + directions[i].normalized * width;
            borderLine[i] = new Vector2(outerVerts[i].x, outerVerts[i].z);
        }

        List <RenderVertexShortcut> scs = GeneratedTrack.calculateShortcuts(borderLine, true);

        for (int i = 0; i < scs.Count; i++)
        {
            RenderVertexShortcut rvs = scs[i];
            for (int j = rvs.indexBefore + 1; j < rvs.indexAfter; j++)
            {
                // The 0.2f offset results of that the inner of a sharp curve may always be a little higher on the curbs
                outerVerts[j] = new Vector3(rvs.intersectPoint.x, (outerVerts[rvs.indexBefore].y + outerVerts[rvs.indexAfter].y) * 0.5f + 0.2f, rvs.intersectPoint.y);
            }
        }



        wentDistance = 0f;

        renderVertices.Add(new Vector3(innerVerts[0].x, 0f, innerVerts[0].z));
        renderUVs.Add(new Vector2(0f, 0f));

        toForwardFirst = Vector3.Cross(directions[0], Vector3.up);
        goOffsetFirst  = Vector3.Cross(directions[0], toForwardFirst).normalized;
        if (goOffsetFirst.y < 0f)
        {
            goOffsetFirst *= -1f;
        }

        newDirFirst = (directions[0].normalized * width + goOffsetFirst * minOuterOffset).normalized;

        int plus3 = 0;

        if (height > 0f)
        {
            Vector3 v1 = renderVertices[renderVertices.Count - 1] + ((new Vector3(outerVerts[0].x, 0f, outerVerts[0].z)) - renderVertices[renderVertices.Count - 1]) * 0.25f + goOffsetFirst * (height * (2f / 3f));
            Vector3 v2 = renderVertices[renderVertices.Count - 1] + ((new Vector3(outerVerts[0].x, 0f, outerVerts[0].z)) - renderVertices[renderVertices.Count - 1]) * 0.5f + goOffsetFirst * (height * (1f));
            Vector3 v3 = renderVertices[renderVertices.Count - 1] + ((new Vector3(outerVerts[0].x, 0f, outerVerts[0].z)) - renderVertices[renderVertices.Count - 1]) * 0.75f + goOffsetFirst * (height * (2f / 3f));

            renderVertices.Add(v1);
            renderVertices.Add(v2);
            renderVertices.Add(v3);
            renderUVs.Add(new Vector2(0.25f, 0f));
            renderUVs.Add(new Vector2(0.5f, 0f));
            renderUVs.Add(new Vector2(0.75f, 0f));

            plus3 = 4;
        }

        renderVertices.Add(new Vector3(outerVerts[0].x, 0f, outerVerts[0].z));
        renderUVs.Add(new Vector2(1f, 0f));

        for (int i = 1; i < vertices.Length; i++)
        {
            wentDistance += Vector3.Distance(outerVerts[i - 1], outerVerts[i]);

            renderVertices.Add(new Vector3(innerVerts[i].x, 0f, innerVerts[i].z));
            renderUVs.Add(new Vector2(0f, wentDistance * curbDistanceFactor));

            Vector3 toForward = Vector3.Cross(directions[i], Vector3.up);
            Vector3 goOffset  = Vector3.Cross(toForward, directions[i]).normalized;

            if (goOffset.y < 0f)
            {
                goOffset *= -1f;
            }

            if (height > 0f)
            {
                Vector3 v1 = renderVertices[renderVertices.Count - 1] + ((new Vector3(outerVerts[i].x, 0f, outerVerts[i].z)) - renderVertices[renderVertices.Count - 1]) * 0.25f + goOffset * (height * (2f / 3f));
                Vector3 v2 = renderVertices[renderVertices.Count - 1] + ((new Vector3(outerVerts[i].x, 0f, outerVerts[i].z)) - renderVertices[renderVertices.Count - 1]) * 0.5f + goOffset * (height * (1f));
                Vector3 v3 = renderVertices[renderVertices.Count - 1] + ((new Vector3(outerVerts[i].x, 0f, outerVerts[i].z)) - renderVertices[renderVertices.Count - 1]) * 0.75f + goOffset * (height * (2f / 3f));

                renderVertices.Add(v1);
                renderVertices.Add(v2);
                renderVertices.Add(v3);
                renderUVs.Add(new Vector2(0.25f, wentDistance * curbDistanceFactor));
                renderUVs.Add(new Vector2(0.5f, wentDistance * curbDistanceFactor));
                renderUVs.Add(new Vector2(0.75f, wentDistance * curbDistanceFactor));
            }

            renderVertices.Add(new Vector3(outerVerts[i].x, 0f, outerVerts[i].z));
            renderUVs.Add(new Vector2(1f, wentDistance * curbDistanceFactor));


            /*renderTriangles.Add(renderVertices.Count - 4 - plus3);
             * if (Vector3.Cross(renderVertices[renderVertices.Count - 4 - plus3] - renderVertices[renderVertices.Count - 3 - plus3], renderVertices[renderVertices.Count - 2] - renderVertices[renderVertices.Count - 4 - plus3]).y < 0)
             * {
             *  renderTriangles.Add(renderVertices.Count - 3 - plus3);
             *  renderTriangles.Add(renderVertices.Count - 2);
             * }
             * else
             * {
             *  renderTriangles.Add(renderVertices.Count - 2);
             *  renderTriangles.Add(renderVertices.Count - 3 - plus3);
             * }*/

            if (plus3 == 0)
            {
                renderTriangles.Add(renderVertices.Count - 4 - plus3);
                if (Vector3.Cross(renderVertices[renderVertices.Count - 4 - plus3] - renderVertices[renderVertices.Count - 3 - plus3], renderVertices[renderVertices.Count - 2] - renderVertices[renderVertices.Count - 4 - plus3]).y < 0)
                {
                    renderTriangles.Add(renderVertices.Count - 3 - plus3);
                    renderTriangles.Add(renderVertices.Count - 2);
                }
                else
                {
                    renderTriangles.Add(renderVertices.Count - 2);
                    renderTriangles.Add(renderVertices.Count - 3 - plus3);
                }

                renderTriangles.Add(renderVertices.Count - 2);
                if (Vector3.Cross(renderVertices[renderVertices.Count - 2] - renderVertices[renderVertices.Count - 1], renderVertices[renderVertices.Count - 3 - plus3] - renderVertices[renderVertices.Count - 2]).y < 0)
                {
                    renderTriangles.Add(renderVertices.Count - 1);
                    renderTriangles.Add(renderVertices.Count - 3 - plus3);
                }
                else
                {
                    renderTriangles.Add(renderVertices.Count - 3 - plus3);
                    renderTriangles.Add(renderVertices.Count - 1);
                }
            }

            else
            {
                int newPlus1 = plus3 - 1;

                for (int j = 0; j < plus3; j++)
                {
                    renderTriangles.Add(renderVertices.Count - 4 - newPlus1 - j);
                    if (Vector3.Cross(renderVertices[renderVertices.Count - 4 - newPlus1 - j] - renderVertices[renderVertices.Count - 3 - newPlus1 - j], renderVertices[renderVertices.Count - 2 - j] - renderVertices[renderVertices.Count - 4 - newPlus1 - j]).y < 0)
                    {
                        renderTriangles.Add(renderVertices.Count - 3 - newPlus1 - j);
                        renderTriangles.Add(renderVertices.Count - 2 - j);
                    }
                    else
                    {
                        renderTriangles.Add(renderVertices.Count - 2 - j);
                        renderTriangles.Add(renderVertices.Count - 3 - newPlus1 - j);
                    }

                    renderTriangles.Add(renderVertices.Count - 2 - j);
                    if (Vector3.Cross(renderVertices[renderVertices.Count - 2 - j] - renderVertices[renderVertices.Count - 1 - j], renderVertices[renderVertices.Count - 3 - newPlus1 - j] - renderVertices[renderVertices.Count - 2 - j]).y < 0)
                    {
                        renderTriangles.Add(renderVertices.Count - 1 - j);
                        renderTriangles.Add(renderVertices.Count - 3 - newPlus1 - j);
                    }
                    else
                    {
                        renderTriangles.Add(renderVertices.Count - 3 - newPlus1 - j);
                        renderTriangles.Add(renderVertices.Count - 1 - j);
                    }
                }
            }
        }

        renderVertices.Add(new Vector3(prevT.x, 0f, prevT.z));
        renderUVs.Add(new Vector2(0f, Vector3.Distance(renderVertices[renderVertices.Count - 1], renderVertices[0]) * -curbDistanceFactor));
        renderVertices.Add(new Vector3(afteT.x, 0f, afteT.z));
        renderUVs.Add(new Vector2(0f, (wentDistance + Vector3.Distance(renderVertices[renderVertices.Count - 1], renderVertices[renderVertices.Count - 4])) * curbDistanceFactor));

        if (plus3 == 0)
        {
            renderTriangles.Add(renderVertices.Count - 2);
            if (Vector3.Cross(renderVertices[renderVertices.Count - 2] - renderVertices[0], renderVertices[1] - renderVertices[renderVertices.Count - 2]).y < 0)
            {
                renderTriangles.Add(0);
                renderTriangles.Add(1);
            }
            else
            {
                renderTriangles.Add(1);
                renderTriangles.Add(0);
            }

            renderTriangles.Add(renderVertices.Count - 1);
            if (Vector3.Cross(renderVertices[renderVertices.Count - 1] - renderVertices[renderVertices.Count - 4], renderVertices[renderVertices.Count - 3] - renderVertices[renderVertices.Count - 1]).y < 0)
            {
                renderTriangles.Add(renderVertices.Count - 4);
                renderTriangles.Add(renderVertices.Count - 3);
            }
            else
            {
                renderTriangles.Add(renderVertices.Count - 3);
                renderTriangles.Add(renderVertices.Count - 4);
            }
        }

        else
        {
            for (int j = 0; j < plus3; j++)
            {
                renderTriangles.Add(renderVertices.Count - 2);
                if (Vector3.Cross(renderVertices[renderVertices.Count - 2] - renderVertices[0 + j], renderVertices[1 + j] - renderVertices[renderVertices.Count - 2]).y < 0)
                {
                    renderTriangles.Add(0 + j);
                    renderTriangles.Add(1 + j);
                }
                else
                {
                    renderTriangles.Add(1 + j);
                    renderTriangles.Add(0 + j);
                }

                renderTriangles.Add(renderVertices.Count - 1);
                if (Vector3.Cross(renderVertices[renderVertices.Count - 1] - renderVertices[renderVertices.Count - 7 + j], renderVertices[renderVertices.Count - 6 + j] - renderVertices[renderVertices.Count - 1]).y < 0)
                {
                    renderTriangles.Add(renderVertices.Count - 7 + j);
                    renderTriangles.Add(renderVertices.Count - 6 + j);
                }
                else
                {
                    renderTriangles.Add(renderVertices.Count - 6 + j);
                    renderTriangles.Add(renderVertices.Count - 7 + j);
                }
            }
        }
    }