Генерация непрямых объектов

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
 
public class BuildRoad : MonoBehaviour
{
    public int Length = 300;
    public int Seed = 1;
    public float Curvature = 0.2f;
    public float Frequency = 0.1f;
 
    public Material Material;
 
    void Start ()
    {
        var mesh = new Mesh();
 
        BuildMesh(mesh);
 
        var road = new GameObject();
        var mr = road.AddComponent<MeshRenderer>();
        mr.sharedMaterial = Material;
        var mf = road.AddComponent<MeshFilter>();
        mf.mesh = mesh;
        var mc = road.AddComponent<MeshCollider>();
        mc.sharedMesh = mesh;
    }
 
    private void BuildMesh(Mesh mesh)
    {
        var verticies = new List<Vector3>();
        var triangles = new List<int>();
        var p = new Vector3(0, 0, 0);//start point
        var d = new Vector3(0, 0, 1);//start direction
        var n = new Vector3(0, 1, 0);//start normal
 
        for (int i = 0; i < Length; i++)
        {
            //add segment to mesh
            var pp = Vector3.Cross(d, n);
            verticies.Add(p + pp);
            verticies.Add(p - pp);
            if (i >= 2)
            {
                var j = verticies.Count - 1;
                triangles.Add(j - 2);
                triangles.Add(j - 1);
                triangles.Add(j - 0);
 
                triangles.Add(j - 1);
                triangles.Add(j - 2);
                triangles.Add(j - 3);
            }
            //build next segment
            BuildNextSegment(i, ref p, ref d, ref n);
        }
 
        //build mesh
        mesh.vertices = verticies.ToArray();
        mesh.triangles = triangles.ToArray();
        mesh.RecalculateNormals();
        mesh.RecalculateTangents();
        mesh.RecalculateBounds();
    }
 
    private void BuildNextSegment(int i, ref Vector3 p, ref Vector3 d, ref Vector3 n)
    {
        var dd = GetRandomVector(i, 5) * Curvature;
        var dn = GetRandomVector(i, 15) * Curvature;
 
        d += dd;
        n += dn;
 
        d.Normalize();
        n.Normalize();
 
        p += d;
    }
 
    Vector3 GetRandomVector(int i, int seed)
    {
        var x = LPWNoise.GetValue(i * Frequency, seed + Seed * 10);
        var y = LPWNoise.GetValue(i * Frequency, seed + 100 + Seed * 10);
        var z = LPWNoise.GetValue(i * Frequency, seed + 130 + Seed * 10);
 
        return new Vector3(x, y, z).normalized;
    }
}

using UnityEngine;
 
public static class LPWNoise
{
 
    public static float GetValue(float x, float y)
    {
        int ix = Mathf.FloorToInt(x);
        int iy = Mathf.FloorToInt(y);
 
        float xs = x - ix;
        float ys = y - iy;
 
        float n0 = Hash(ix, iy);
        float n1 = Hash(ix + 1, iy);
        float ix0 = Mathf.Lerp(n0, n1, xs);
 
        n0 = Hash(ix, iy + 1);
        n1 = Hash(ix + 1, iy + 1);
        float ix1 = Mathf.Lerp(n0, n1, xs);
 
        return Mathf.Lerp(ix0, ix1, ys);
    }
 
    const int factorX = 1619;
    const int factorY = 31337;
    const int factorZ = 6971;
    const int factorSeed = 1013;
    //static int seed = 1337;
 
    public static float Hash(int x, int z)
    {
        int n = (
                    factorX * x
                    + factorZ * z
                    + factorSeed) //* seed)
                & 0x7fffffff;
        n = (n >> 13) ^ n;
        n = (n * (n * n * 60493 + 19990303) + 1376312589) & 0x7fffffff;
        return 1 - (n / 1073741824f); // normalize for [-1,1]
    }
}