protected TreeBranch(List <TreeBranch> branches, int generation, int generations, Vector3 from, Vector3 tangent, Vector3 normal, Vector3 binormal, float length, float radius, float offset, TreeData data)
        {
            this.generation = generation;

            this.fromRadius = radius;
            this.toRadius   = (generation == 0) ? 0f : radius *data.radiusAttenuation;

            this.from = from;

            var scale    = Mathf.Lerp(1f, data.growthAngleScale, 1f - 1f * generation / generations);
            var rotation = Quaternion.AngleAxis(scale * data.RandomGrowthAngle, normal) * Quaternion.AngleAxis(scale * data.RandomGrowthAngle, binormal);

            this.to = from + rotation * tangent * length;

            this.length = length;
            this.offset = offset;

            segments = BuildSegments(data, fromRadius, toRadius, normal, binormal);

            branches.Add(this);

            children = new List <TreeBranch>();
            if (generation > 0)
            {
                int count = data.RandomBranches;
                for (int i = 0; i < count; i++)
                {
                    float ratio;
                    if (count == 1)
                    {
                        // for zero division
                        ratio = 1f;
                    }
                    else
                    {
                        ratio = Mathf.Lerp(0.5f, 1f, (1f * i) / (count - 1));
                    }

                    var index   = Mathf.FloorToInt(ratio * (segments.Count - 1));
                    var segment = segments[index];

                    Vector3 nt, nn, nb;
                    if (ratio >= 1f)
                    {
                        // sequence branch
                        nt = segment.Frame.Tangent;
                        nn = segment.Frame.Normal;
                        nb = segment.Frame.Binormal;
                    }
                    else
                    {
                        var rot = Quaternion.AngleAxis(i * 90f, tangent);
                        nt = rot * tangent;
                        nn = rot * normal;
                        nb = rot * binormal;
                    }

                    var child = new TreeBranch(
                        branches,
                        this.generation - 1,
                        generations,
                        segment.Position,
                        nt,
                        nn,
                        nb,
                        length * Mathf.Lerp(1f, data.lengthAttenuation, ratio),
                        radius * Mathf.Lerp(1f, data.radiusAttenuation, ratio),
                        offset + length,
                        data
                        );

                    children.Add(child);
                }
            }
        }
        static MeshObjectData CreateFoliage(TreeData data, TreeBranch Branch, int index)
        {
            MeshDraft m;

            switch (data.FoliageBasePrimitiveShape)
            {
            case TreeData.BasePrimitiveShapes.Dodecahedron:
                m = MeshDraft.Dodecahedron(0.5f);
                break;

            case TreeData.BasePrimitiveShapes.Icosahedron:
                m = MeshDraft.Icosahedron(0.5f, false);
                break;

            case TreeData.BasePrimitiveShapes.Prism:
                m = MeshDraft.Prism(0.5f, data.foliageSegments, 0.1f, false);
                break;

            case TreeData.BasePrimitiveShapes.Pyramid:
                m = MeshDraft.Pyramid(0.5f, data.foliageSegments, 0.5f, false);
                break;

            default:
                m = MeshDraft.Sphere(0.5f, data.foliageSegments, data.foliageSegments, false);
                break;
            }

            MeshObjectData plant = new MeshObjectData();

            plant.vertices  = m.vertices.ToArray();
            plant.triangles = m.triangles.ToArray();
            plant.tangents  = m.tangents.ToArray();
            plant.AutoWeldMesh(0.0001f, 0.4f);

            Vector3[] verts        = plant.vertices;
            float     currentNoise = data.noise;

            currentNoise *= 0.4f;
            Vector3 Pos = Branch.To;

            plant.position = Pos;

            int  s = data.TreeSeed + index + Mathf.RoundToInt(Pos.x) + Mathf.RoundToInt(Pos.y) + Mathf.RoundToInt(Pos.z) + Mathf.RoundToInt(Branch.Length);
            Rand r = new Rand(s);

            for (int i = 0; i < verts.Length; i++)
            {
                verts[i].x += r.Range(-currentNoise, currentNoise);
                verts[i].y += r.Range(-currentNoise, currentNoise);
                verts[i].z += r.Range(-currentNoise, currentNoise);
            }

            plant.vertices = verts;

            plant.flatShade();

            Color[] vertexColor = new Color[plant.vertices.Length];
            Color   CC          = data.foliageColors[r.Range(0, data.foliageColors.Length)];

            for (int c = 0; c < plant.vertices.Length; c++)
            {
                vertexColor[c] = CC;
            }
            plant.colors = vertexColor;
            return(plant);
        }
 // for Root branch constructor
 public TreeBranch(int generation, float length, float radius, TreeData data) : this(new List <TreeBranch>(), generation, generation, Vector3.zero, Vector3.up, Vector3.right, Vector3.back, length, radius, 0f, data)
 {
 }
        public static void Build(TreeThreadReturnData ReturnData)
        {
            TreeData data = ReturnData.TreeData;

            var root = new TreeBranch(
                data.generations,
                data.length,
                data.radius,
                data
                );

            var vertices  = new List <Vector3>();
            var normals   = new List <Vector3>();
            var tangents  = new List <Vector4>();
            var uvs       = new List <Vector2>();
            var triangles = new List <int>();

            List <MeshObjectData> Foliages = new List <MeshObjectData>();

            Rand rand;
            int  FolCheckCount = 0;

            float maxLength = TraverseMaxLength(root);

            Traverse(root, (branch) =>
            {
                var offset = vertices.Count;

                var vOffset = branch.Offset / maxLength;
                var vLength = branch.Length / maxLength;

                for (int i = 0, n = branch.Segments.Count; i < n; i++)
                {
                    var t = 1f * i / (n - 1);
                    var v = vOffset + vLength * t;

                    var segment = branch.Segments[i];
                    var N       = segment.Frame.Normal;
                    var B       = segment.Frame.Binormal;
                    for (int j = 0; j <= data.radialSegments; j++)
                    {
                        // 0.0 ~ 2π
                        var u     = 1f * j / data.radialSegments;
                        float rad = u * PI2;

                        float cos  = Mathf.Cos(rad), sin = Mathf.Sin(rad);
                        var normal = (cos * N + sin * B).normalized;
                        vertices.Add(segment.Position + segment.Radius * normal);
                        normals.Add(normal);

                        var tangent = segment.Frame.Tangent;
                        tangents.Add(new Vector4(tangent.x, tangent.y, tangent.z, 0f));

                        uvs.Add(new Vector2(u, v));
                    }
                }

                for (int j = 1; j <= data.heightSegments; j++)
                {
                    for (int i = 1; i <= data.radialSegments; i++)
                    {
                        int a = (data.radialSegments + 1) * (j - 1) + (i - 1);
                        int b = (data.radialSegments + 1) * j + (i - 1);
                        int c = (data.radialSegments + 1) * j + i;
                        int d = (data.radialSegments + 1) * (j - 1) + i;

                        a += offset;
                        b += offset;
                        c += offset;
                        d += offset;

                        triangles.Add(a); triangles.Add(d); triangles.Add(b);
                        triangles.Add(b); triangles.Add(d); triangles.Add(c);
                    }
                }

                //plants
                if (branch.Children == null || branch.Children.Count == 0)
                {
                    rand         = new Rand(FolCheckCount + data.TreeSeed);
                    float chance = rand.Range(0f, 100f);
                    Debug.Log(chance);
                    if (chance <= data.foliageChance)
                    {
                        Foliages.Add(CreateFoliage(data, branch, Foliages.Count + FolCheckCount));
                    }
                    FolCheckCount++;
                }
            });

            MeshObjectData TreeMeshData = new MeshObjectData();

            TreeMeshData.vertices  = vertices.ToArray();
            TreeMeshData.triangles = triangles.ToArray();
            TreeMeshData.position  = ReturnData.TreePos;

            TreeMeshData.flatShade();

            Color[] treecolor = new Color[TreeMeshData.vertices.Length];

            for (int i = 0; i < TreeMeshData.vertices.Length; i++)
            {
                treecolor[i] = data.branchColor;
            }

            TreeMeshData.colors = treecolor;

            ReturnData.TreeBuildData = TreeMeshData;

            ReturnData.FoliagesBuildData = Foliages.ToArray();
            ReturnData.ManagerCallBack(ReturnData);
        }