Rail Sutff

Rail.cs

using ProceduralToolkit;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
public class Rail : MonoBehaviour {

    public RailNode[] Nodes;
    public int resolution = 10;
    private MeshFilter Mesh;
    private MeshRenderer Renderer;

    public void Start()
    {
        //for (int i = 0; i < Nodes.Length; i++) Debug.Log($"Nodes[{i}]: {Nodes[i]}");

        Mesh = gameObject.AddComponent<MeshFilter>();
        Renderer = gameObject.AddComponent<MeshRenderer>();


        var mat = new Material(Shader.Find("Standard"));
        //mat.color = Color.green;
        Renderer.material = mat;

        AssignMesh();

        //CreateCube(new Vector3(), new Vector3());
    }

    private void OnDrawGizmos()
    {
        if (Nodes.Count() < 2)
            return;

        var spline = new CatmullRom(Nodes.Select(x => x.transform.position).ToArray(),
            resolution,
            false);
        var points = spline.GetPoints().ToList();

        var Offset = 14f;
        var lastPoint = points.First();
        var OffsetVector3Temp = Offset * lastPoint.normal;
        var lastSide1 = lastPoint.position + OffsetVector3Temp;
        var lastSide2 = lastPoint.position + -OffsetVector3Temp;
        points.RemoveAt(0);
        //var OVector3 = new Vector3(0f, 0f, Offset - 5f);
        foreach (var v in points)
        {

            var OffsetVector3 = Offset * v.normal;
            //Main Line
            Debug.DrawLine(lastPoint.position, v.position, Color.black);

            //Connectors
            Debug.DrawLine(v.position, v.position + OffsetVector3, Color.green);
            Debug.DrawLine(v.position, v.position + -OffsetVector3, Color.green);

            //Side Lines
            var Side1 = v.position + OffsetVector3;
            var Side2 = v.position + -OffsetVector3;
            Debug.DrawLine(lastSide1, Side1, Color.red);
            Debug.DrawLine(lastSide2, Side2, Color.red);
            lastPoint = v;
            lastSide1 = Side1;
            lastSide2 = Side2;
        }
    }

    void AssignMesh()
    {
        var spline = new CatmullRom(Nodes.Select(x => x.transform.position).ToArray(),
            resolution,
            false);

        //spline.DrawSpline(Color.cyan);
        //spline.DrawNormals(3f, Color.red);
        //spline.DrawTangents(3f, Color.green);

        var points = spline.GetPoints().ToList();
        var lastPoint = points.First();
        points.RemoveAt(0);
        var Offset = 14f;
        List<CombineInstance> c = new List<CombineInstance>();
        var localDiff = (transform.position - transform.localPosition) *2f;
        Debug.Log(localDiff);
        float size = 1f;
        foreach (var v in points)
        {
            var lastPos = lastPoint.position;
            lastPos -= localDiff;
            var pos = v.position;
            pos -= localDiff;

            var OffsetVector3 = (Offset * v.normal);
            //Main Line
            //c.Add(ConvertRelativeToMe(CreateCube(lastPos, pos, size)));

            var connectorColor = Color.HSVToRGB(86f / 255f, 63f / 255f, 46f / 255f);
            //Connector
            float ConnectorExtraOffset = 3f;
            c.Add(ConvertRelativeToMe(CreateCube(pos + -(((Offset + ConnectorExtraOffset + 2f) * v.normal)), pos + (((Offset + ConnectorExtraOffset) * v.normal)), size, connectorColor)));

            var sideColor = Color.HSVToRGB(85f / 255f, 85f / 255f, 85f / 255f);
            //Side Lines
            c.Add(ConvertRelativeToMe(CreateCube(lastPos + OffsetVector3, pos + OffsetVector3, size, sideColor)));
            c.Add(ConvertRelativeToMe(CreateCube(lastPos + -OffsetVector3, pos + -OffsetVector3, size, sideColor)));
            lastPoint = v;
        }

        var end = new Mesh();
        end.Clear();

        end.CombineMeshes(c.ToArray());

        end.RecalculateNormals();

        Mesh.mesh = end;
    }

    public CombineInstance ConvertRelativeToMe(Mesh m)
        => new CombineInstance() { mesh = m, transform = transform.localToWorldMatrix };
    Mesh CreateCube(Vector3 a, Vector3 b, float size, Color color)
    {
        //Debug.Log($"a start: {a}");
        //Debug.Log($"b start: {b}");

        /*Vector3[] vertices = {
        new Vector3 (0, 0, 0) + front, // front         (0)
        new Vector3 (1, 0, 0) + front, // front         (1)
        new Vector3 (1, 1, 0) + front, // front         (2)
        new Vector3 (0, 1, 0) + front, // front         (3)
        new Vector3 (0, 1, 1) + back , // back          (4)
        new Vector3 (1, 1, 1) + back , // back          (5)
        new Vector3 (1, 0, 1) + back , // back          (6)
        new Vector3 (0, 0, 1) + back , // back          (7)
        };*/
        var centerOffset = new Vector3(size / 2f, size / 2f, size / 2f);
        a += centerOffset;
        b += centerOffset;

        var front = a;
        var distance = (b - a).magnitude;
        var distanceVector3 = Vector3.forward * distance;
        var back = distanceVector3 + front;

        Vector3[] vertices = {
            new Vector3 (0 * size + front.x, 0 * size + front.y, 0 * size + front.z),
            new Vector3 (1 * size + front.x, 0 * size + front.y, 0 * size + front.z),
            new Vector3 (1 * size + front.x, 1 * size + front.y, 0 * size + front.z),
            new Vector3 (0 * size + front.x, 1 * size + front.y, 0 * size + front.z), 
            new Vector3 (0 * size + back.x,  1 * size + back.y,  1 * size + back.z),
            new Vector3 (1 * size + back.x,  1 * size + back.y,  1 * size + back.z),
            new Vector3 (1 * size + back.x,  0 * size + back.y,  1 * size + back.z),
            new Vector3 (0 * size + back.x,  0 * size + back.y,  1 * size + back.z),
        };

        int[] triangles = {
            0, 2, 1, //face front
		    0, 3, 2,
            2, 3, 4, //face top
		    2, 4, 5,
            1, 2, 5, //face right
		    1, 5, 6,
            0, 7, 4, //face left
		    0, 4, 3,
            5, 4, 7, //face back
		    5, 7, 6,
            0, 6, 7, //face bottom
		    0, 1, 6
        };

        Quaternion rotation = Quaternion.LookRotation((b - a).normalized, Vector3.up);
        Vector3 center = front;

        for (int i = 0; i < vertices.Length; i++)
        {
            //      rotate relative     relative to pivot      absolute again
            vertices[i] = (rotation * (vertices[i] - center) + center);
        }

        vertices.Reverse();

        Mesh mesh = new Mesh();

        mesh.Clear();

        mesh.vertices = vertices;
        mesh.triangles = triangles;

        mesh.RecalculateNormals();
        mesh.Paint(color);

        return mesh;
    }
}