第1章　Unityではじめるプロシージャルモデリング

// Meshのインスタンスを生成
var mesh = new Mesh();

// Quadの横幅と縦幅がそれぞれsizeの長さになるように半分の長さを求める
var hsize = size * 0.5f;

// Quadの頂点データ
var vertices = new Vector3[] {
    new Vector3(-hsize,  hsize, 0f), // 1つ目の頂点 Quadの左上の位置
    new Vector3( hsize,  hsize, 0f), // 2つ目の頂点 Quadの右上の位置
    new Vector3( hsize, -hsize, 0f), // 3つ目の頂点 Quadの右下の位置
    new Vector3(-hsize, -hsize, 0f)  // 4つ目の頂点 Quadの左下の位置
};

// Quadのuv座標データ
var uv = new Vector2[] {
    new Vector2(0f, 0f), // 1つ目の頂点のuv座標
    new Vector2(1f, 0f), // 2つ目の頂点のuv座標
    new Vector2(1f, 1f), // 3つ目の頂点のuv座標
    new Vector2(0f, 1f)  // 4つ目の頂点のuv座標
};

// Quadの法線データ
var normals = new Vector3[] {
    new Vector3(0f, 0f, -1f), // 1つ目の頂点の法線
    new Vector3(0f, 0f, -1f), // 2つ目の頂点の法線
    new Vector3(0f, 0f, -1f), // 3つ目の頂点の法線
    new Vector3(0f, 0f, -1f)  // 4つ目の頂点の法線
};

// Quadの面データ 頂点のindexを3つ並べて1つの面(三角形)として認識する
var triangles = new int[] {
    0, 1, 2, // 1つ目の三角形
    2, 3, 0  // 2つ目の三角形
};

mesh.vertices = vertices;
mesh.uv = uv;
mesh.normals = normals;
mesh.triangles = triangles;

// Meshが占める境界領域を計算する（cullingに必要）
mesh.RecalculateBounds();

return mesh;

var vertices = new List<Vector3>();
var uv = new List<Vector2>();
var normals = new List<Vector3>();

// 頂点のグリッド上での位置の割合(0.0 ~ 1.0)を算出するための行列数の逆数
var winv = 1f / (widthSegments - 1);
var hinv = 1f / (heightSegments - 1);

for(int y = 0; y < heightSegments; y++) {
    // 行の位置の割合(0.0 ~ 1.0)
    var ry = y * hinv;

    for(int x = 0; x < widthSegments; x++) {
        // 列の位置の割合(0.0 ~ 1.0)
        var rx = x * winv;

        vertices.Add(new Vector3(
            (rx - 0.5f) * width,
            0f,
            (0.5f - ry) * height
        ));
        uv.Add(new Vector2(rx, ry));
        normals.Add(new Vector3(0f, 1f, 0f));
    }
}

var triangles = new List<int>();

for(int y = 0; y < heightSegments - 1; y++) {
    for(int x = 0; x < widthSegments - 1; x++) {
        int index = y * widthSegments + x;
        var a = index;
        var b = index + 1;
        var c = index + 1 + widthSegments;
        var d = index + widthSegments;

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

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

protected override Mesh Build() {
    // 元のPlaneモデルを生成
    var mesh = base.Build();

    // Planeモデルが持つ頂点の高さを再設定する
    var vertices = mesh.vertices;

    // 頂点のグリッド上での位置の割合(0.0 ~ 1.0)を算出するための行列数の逆数
    var winv = 1f / (widthSegments - 1);
    var hinv = 1f / (heightSegments - 1);

    for(int y = 0; y < heightSegments; y++) {
        // 行の位置の割合(0.0 ~ 1.0)
        var ry = y * hinv;
        for(int x = 0; x < widthSegments; x++) {
            // 列の位置の割合(0.0 ~ 1.0)
            var rx = x * winv;

            int index = y * widthSegments + x;
            vertices[index].y = Depth(rx, ry);
        }
    }

    // 頂点位置の再設定
    mesh.vertices = vertices;
    mesh.RecalculateBounds();

    // 法線方向を自動算出
    mesh.RecalculateNormals();

    return mesh;
}

for (int i = 0; i < segments; i++) {
    // 0.0 ~ 1.0
    float ratio = (float)i / (segments - 1);

    // [0.0 ~ 1.0]を[0.0 ~ 2π]に変換
    float rad = ratio * PI2;

    // 円周上の位置を得る
    float cos = Mathf.Cos(rad), sin = Mathf.Sin(rad);
    float x = cos * radius, y = sin * radius;
}

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

// 上端の高さと、下端の高さ
float top = height * 0.5f, bottom = -height * 0.5f;

// 側面を構成する頂点データを生成
GenerateCap(segments + 1, top, bottom, radius, vertices, uvs, normals, true);

// 側面の三角形を構築する際、円上の頂点を参照するために、
// indexが円を一周するための除数
var len = (segments + 1) * 2;

// 上端と下端をつなぎ合わせて側面を構築
for (int i = 0; i < segments + 1; i++) {
    int idx = i * 2;
    int a = idx, b = idx + 1, c = (idx + 2) % len, d = (idx + 3) % len;
    triangles.Add(a);
    triangles.Add(c);
    triangles.Add(b);

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

void GenerateCap(
    int segments,
    float top,
    float bottom,
    float radius,
    List<Vector3> vertices,
    List<Vector2> uvs,
    List<Vector3> normals,
    bool side
) {
    for (int i = 0; i < segments; i++) {
        // 0.0 ~ 1.0
        float ratio = (float)i / (segments - 1);

        // 0.0 ~ 2π
        float rad = ratio * PI2;

        // 円周に沿って上端と下端に均等に頂点を配置する
        float cos = Mathf.Cos(rad), sin = Mathf.Sin(rad);
        float x = cos * radius, z = sin * radius;
        Vector3 tp = new Vector3(x, top, z), bp = new Vector3(x, bottom, z);

        // 上端
        vertices.Add(tp);
        uvs.Add(new Vector2(ratio, 1f));

        // 下端
        vertices.Add(bp);
        uvs.Add(new Vector2(ratio, 0f));

        if(side) {
            // 側面の外側を向く法線
            var normal = new Vector3(cos, 0f, sin);
            normals.Add(normal);
            normals.Add(normal);
        } else {
            normals.Add(new Vector3(0f, 1f, 0f)); // 蓋の上を向く法線
            normals.Add(new Vector3(0f, -1f, 0f)); // 蓋の下を向く法線
        }
    }
}

// 上端と下端の蓋を生成
if(openEnded) {
    // 蓋のモデルのための頂点は、ライティング時に異なった法線を利用するために、側面とは共有せずに新しく追加する
    GenerateCap(
        segments + 1,
        top,
        bottom,
        radius,
        vertices,
        uvs,
        normals,
        false
    );

    // 上端の蓋の真ん中の頂点
    vertices.Add(new Vector3(0f, top, 0f));
    uvs.Add(new Vector2(0.5f, 1f));
    normals.Add(new Vector3(0f, 1f, 0f));

    // 下端の蓋の真ん中の頂点
    vertices.Add(new Vector3(0f, bottom, 0f)); // bottom
    uvs.Add(new Vector2(0.5f, 0f));
    normals.Add(new Vector3(0f, -1f, 0f));

    var it = vertices.Count - 2;
    var ib = vertices.Count - 1;

    // 側面の分の頂点indexを参照しないようにするためのoffset
    var offset = len;

    // 上端の蓋の面
    for (int i = 0; i < len; i += 2) {
        triangles.Add(it);
        triangles.Add((i + 2) % len + offset);
        triangles.Add(i + offset);
    }

    // 下端の蓋の面
    for (int i = 1; i < len; i += 2) {
        triangles.Add(ib);
        triangles.Add(i + offset);
        triangles.Add((i + 2) % len + offset);
    }
}

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>();

// 曲線からFrenet frameを取得
var frames = curve.ComputeFrenetFrames(tubularSegments, closed);

// Tubularの頂点データを生成
for(int i = 0; i < tubularSegments; i++) {
    GenerateSegment(curve, frames, vertices, normals, tangents, i);
}
// 閉じた筒型を生成する場合は曲線の始点に最後の頂点を配置し、閉じない場合は曲線の終点に配置する
GenerateSegment(
    curve,
    frames,
    vertices,
    normals,
    tangents,
    (!closed) ? tubularSegments : 0
);

// 曲線の始点から終点に向かってuv座標を設定していく
for (int i = 0; i <= tubularSegments; i++) {
    for (int j = 0; j <= radialSegments; j++) {
        float u = 1f * j / radialSegments;
        float v = 1f * i / tubularSegments;
        uvs.Add(new Vector2(u, v));
    }
}

// 側面を構築
for (int j = 1; j <= tubularSegments; j++) {
    for (int i = 1; i <= radialSegments; i++) {
        int a = (radialSegments + 1) * (j - 1) + (i - 1);
        int b = (radialSegments + 1) * j + (i - 1);
        int c = (radialSegments + 1) * j + i;
        int d = (radialSegments + 1) * (j - 1) + i;

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

var mesh = new Mesh();
mesh.vertices = vertices.ToArray();
mesh.normals = normals.ToArray();
mesh.tangents = tangents.ToArray();
mesh.uv = uvs.ToArray();
mesh.triangles = triangles.ToArray();

void GenerateSegment(
    CurveBase curve,
    List<FrenetFrame> frames,
    List<Vector3> vertices,
    List<Vector3> normals,
    List<Vector4> tangents,
    int index
) {
    // 0.0 ~ 1.0
    var u = 1f * index / tubularSegments;

    var p = curve.GetPointAt(u);
    var fr = frames[index];

    var N = fr.Normal;
    var B = fr.Binormal;

    for(int j = 0; j <= radialSegments; j++) {
        // 0.0 ~ 2π
        float rad = 1f * j / radialSegments * PI2;

        // 円周に沿って均等に頂点を配置する
        float cos = Mathf.Cos(rad), sin = Mathf.Sin(rad);
        var v = (cos * N + sin * B).normalized;
        vertices.Add(p + radius * v);
        normals.Add(v);

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

// 枝先ほど分岐する角度が大きくなる
var scale = Mathf.Lerp(
    1f,
    data.growthAngleScale,
    1f - 1f * generation / generations
);

// normal方向の回転
var qn = Quaternion.AngleAxis(scale * data.GetRandomGrowthAngle(), normal);

// binormal方向の回転
var qb = Quaternion.AngleAxis(scale * data.GetRandomGrowthAngle(), binormal);

// 枝先が向いているtangent方向にqn * qbの回転をかけつつ、枝先の位置を決める
this.to = from + (qn * qb) * tangent * length;

public class TreeSegment {
    public FrenetFrame Frame { get { return frame; } }
    public Vector3 Position { get { return position; } }
    public float Radius { get { return radius; } }

    // TreeSegmentが向いている方向ベクトルtangent、
    // それと直交するベクトルnormal、binormalを持つFrenetFrame
    FrenetFrame frame;

    // TreeSegmentの位置
    Vector3 position;

    // TreeSegmentの幅(半径)
    float radius;

    public TreeSegment(FrenetFrame frame, Vector3 position, float radius) {
        this.frame = frame;
        this.position = position;
        this.radius = radius;
    }
}

var root = new TreeBranch(
    generations,
    length,
    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>();

// 木の全長を取得
// 枝の長さを全長で割ることで、uv座標の高さ(uv.y)が
// 根元から枝先に至るまで[0.0 ~ 1.0]で変化するように設定する
float maxLength = TraverseMaxLength(root);

// 再帰的に全ての枝を辿り、1つ1つの枝に対応するMeshを生成する
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);
        }
    }
});

var mesh = new Mesh();
mesh.vertices = vertices.ToArray();
mesh.normals = normals.ToArray();
mesh.tangents = tangents.ToArray();
mesh.uv = uvs.ToArray();
mesh.triangles = triangles.ToArray();
mesh.RecalculateBounds();