*

Assets/Procedural/BoxGenerator.cs

@@ -0,0 +1,100 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+
+public class BoxGenerator : MeshProcessor
+{
+    public Vector3 Size = Vector3.one;
+    public int SliceX;
+    public int SliceY;
+    public int SliceZ;
+
+    public override void Execute(ProceduralMeshData m)
+    {
+        ProceduralMeshData[] sides = new ProceduralMeshData[6];
+
+        PlaneGenerator p = new PlaneGenerator();
+        p.Width = 1;
+        p.Height = 1;
+
+        //x+
+        sides[0] = new ProceduralMeshData();
+        p.WidthSlices = SliceZ;
+        p.HeightSlices = SliceY;
+        p.Execute(sides[0]);
+
+        //x-
+        sides[1] = new ProceduralMeshData();
+        p.Execute(sides[1]);
+
+        //y+
+        sides[2] = new ProceduralMeshData();
+        p.WidthSlices = SliceX;
+        p.HeightSlices = SliceZ;
+        p.Execute(sides[2]);
+
+        //y-
+        sides[3] = new ProceduralMeshData();
+        p.Execute(sides[3]);
+
+        //z+
+        sides[4] = new ProceduralMeshData();
+        p.WidthSlices = SliceX;
+        p.HeightSlices = SliceY;
+        p.Execute(sides[4]);
+
+        //z-
+        sides[5] = new ProceduralMeshData();
+        p.Execute(sides[5]);
+
+        //x+
+        TransformVertexNode transform = new TransformVertexNode();
+        transform.Offset = Vector3.right*0.5f;
+        transform.Rotation = Quaternion.AngleAxis(-90, Vector3.up) * Quaternion.AngleAxis(-90, Vector3.right);
+        transform.Execute(sides[0]);
+
+        //x-
+        transform.Offset = Vector3.right * -0.5f;
+        transform.Rotation = Quaternion.AngleAxis(90, Vector3.up) * Quaternion.AngleAxis(-90, Vector3.right);
+        transform.Execute(sides[1]);
+
+
+        //y+
+        transform.Offset = Vector3.up * 0.5f;
+        transform.Rotation = Quaternion.identity;
+        transform.Execute(sides[2]);
+
+        //y-
+        transform.Offset = Vector3.up * -0.5f;
+        transform.Rotation = Quaternion.AngleAxis(180, Vector3.forward);
+        transform.Execute(sides[3]);
+
+        //z+
+        transform.Offset = Vector3.forward * 0.5f;
+        transform.Rotation = Quaternion.AngleAxis(180, Vector3.up) * Quaternion.AngleAxis(-90, Vector3.right);
+        transform.Execute(sides[4]);
+
+        //z-
+        transform.Offset = Vector3.forward * -0.5f;
+        transform.Rotation = Quaternion.AngleAxis(-90, Vector3.right);
+        transform.Execute(sides[5]);
+
+        CombineMeshNode combiner = new CombineMeshNode();
+        combiner.Source.Add(sides[0]);
+        combiner.Source.Add(sides[1]);
+        combiner.Source.Add(sides[2]);
+        combiner.Source.Add(sides[3]);
+        combiner.Source.Add(sides[4]);
+        combiner.Source.Add(sides[5]);
+        combiner.Execute(m);
+
+        CombineSubmeshesNode submeshCombiner = new CombineSubmeshesNode();
+        submeshCombiner.Execute(m);
+
+        transform.Offset = Vector3.zero;
+        transform.Rotation = Quaternion.identity;
+        transform.Scale = Size;
+        transform.Execute(m);
+    }
+}

Assets/Procedural/BoxGenerator.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 20da85e4530510045b3327cf8857fde1
+timeCreated: 1481452209
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Procedural/CombineMeshNode.cs

@@ -0,0 +1,63 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class CombineMeshNode : MeshProcessor {
+    public List<ProceduralMeshData> Source = new List<ProceduralMeshData>();
+
+    public override void Execute(ProceduralMeshData m)
+    {
+        List<Vector3> vertices = new List<Vector3>();
+        List<int[]> indices = new List<int[]>();
+        List<Vector3> normals = new List<Vector3>();
+        List<Vector4> tangents = new List<Vector4>();
+        List<List<Vector4>> uvs = new List<List<Vector4>>();
+
+        //combine 
+        foreach (var meshData in Source)
+        {
+            if (meshData != null)
+            {
+                //append all indices
+                foreach (var submeshIndices in meshData.Indices)
+                {
+                    var newIndices = new int[submeshIndices.Length];
+                    //offset indices
+                    for (int i = 0; i < newIndices.Length; ++i)
+                    {
+                        newIndices[i] = submeshIndices[i] + vertices.Count;
+                    }
+                    indices.Add(newIndices);
+                }
+
+
+                vertices.AddRange(meshData.Vertices);
+
+                normals.AddRange(meshData.Normals);
+
+                if (meshData.Tangents != null)
+                {
+                    tangents.AddRange(meshData.Tangents);
+                }
+               
+
+                while (uvs.Count < meshData.Uvs.Count){
+                    uvs.Add(new List<Vector4>());
+                }
+
+                for (int i = 0; i < meshData.Uvs.Count; ++i)
+                {
+                    uvs[i].AddRange(meshData.Uvs[i]);
+                }
+
+            }
+        }
+
+        m.Vertices = vertices.ToArray();
+        m.Indices = indices;
+        m.Normals = normals.ToArray();
+        m.Tangents = tangents.Count == 0 ? null : tangents.ToArray();
+        m.Uvs = uvs;
+    }
+}

Assets/Procedural/CombineMeshNode.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: c69a57e361120bf4db873f79fdc136de
+timeCreated: 1481458480
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Procedural/CombineSubmeshesNode.cs

@@ -0,0 +1,18 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class CombineSubmeshesNode : MeshProcessor {
+
+    public override void Execute(ProceduralMeshData m)
+    {
+        List<int> indices = new List<int>();
+
+        foreach (var i in m.Indices)
+        {
+            indices.AddRange(i);
+        }
+        m.Indices = new List<int[]>();
+        m.Indices.Add(indices.ToArray());
+    }
+}

Assets/Procedural/CombineSubmeshesNode.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: ff34137884a6c4f47a6c6bb289cfc1d9
+timeCreated: 1481577533
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Procedural/MeshProcessor.cs

@@ -0,0 +1,8 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public abstract class MeshProcessor
+{
+    public abstract void Execute(ProceduralMeshData m);
+}

Assets/Procedural/MeshProcessor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 8e6532d55438865429adf68ffdc9b141
+timeCreated: 1481457685
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Procedural/PlaneGenerator.cs

@@ -0,0 +1,68 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+/// <summary>
+/// Generate XZ plane
+/// </summary>
+public class PlaneGenerator : MeshProcessor
+{
+    public float Width = 1;
+    public float Height = 1;
+
+    public int WidthSlices = 0;
+    public int HeightSlices = 0;
+
+
+    public override void Execute(ProceduralMeshData m)
+    {
+        int widthVertexCount = 2 + WidthSlices;
+        int heightVertexCount = 2 + HeightSlices;
+        int vertexCount = widthVertexCount*heightVertexCount;
+
+        //generate vertices && normals
+        Vector3 offset = new Vector3(-Width / 2, 0, Height / 2);
+        m.Vertices = new Vector3[vertexCount];
+        m.Normals = new Vector3[vertexCount];
+
+        for (int x = 0; x < widthVertexCount; ++x)
+        {
+            for (int z = 0; z < heightVertexCount; ++z)
+            {
+                int id = z*widthVertexCount + x;
+                m.Vertices[id]= new Vector3((Width / (widthVertexCount - 1)) * x, 0, (-Height / (heightVertexCount - 1)) * z) + offset;
+                m.Normals[id] = Vector3.up;
+            }
+        }
+
+
+        //generate indices
+        int[] indices = new int[(widthVertexCount - 1) * (heightVertexCount - 1) * 6];
+        int indexOffset = 0;
+        for (int x = 0; x < widthVertexCount - 1; ++x){
+            for (int z = 0; z < heightVertexCount - 1; ++z) {
+                indices[indexOffset + 0] = z * widthVertexCount + x;
+                indices[indexOffset + 1] = z * widthVertexCount + x + 1;
+                indices[indexOffset + 2] = (z + 1) * widthVertexCount + x;
+                indices[indexOffset + 3] = indices[indexOffset + 2];
+                indices[indexOffset + 4] = indices[indexOffset + 1];
+                indices[indexOffset + 5] = (z + 1) * widthVertexCount + x + 1;
+                indexOffset += 6;
+            }
+        }
+
+        m.Indices.Add(indices);
+
+        //generate uvs
+        List<Vector4> uvs = new List<Vector4>(vertexCount);
+        for (int z = 0; z < heightVertexCount; ++z)
+        {
+            for (int x = 0; x < widthVertexCount; ++x)
+            {
+           
+                uvs.Add(new Vector4((float)x / (widthVertexCount - 1), (float)z / (heightVertexCount - 1), 0, 0));
+            }
+        }
+        m.Uvs.Add(uvs);
+    }
+}

Assets/Procedural/PlaneGenerator.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: cc5da59754a9bd84c81c707581bd1a6b
+timeCreated: 1481452239
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Procedural/ProceduralMeshData.cs

@@ -0,0 +1,32 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class ProceduralMeshData {
+    public Vector3[] Vertices;
+    public Vector3[] Normals;
+    public Vector4[] Tangents;
+    public List<int[]> Indices = new List<int[]>();
+    public List<List<Vector4>> Uvs = new List<List<Vector4>>();
+
+    public void ApplyToMesh(Mesh m)
+    {
+        m.Clear();
+        m.subMeshCount = Indices.Count;
+
+        m.vertices = Vertices;
+
+        for (int i = 0; i < Indices.Count; ++i)
+        {
+            m.SetIndices(Indices[i], MeshTopology.Triangles, i);
+        }
+
+        m.normals = Normals;
+        m.tangents = Tangents;
+
+        for (int i = 0; i < Uvs.Count; ++i){
+            m.SetUVs(i, Uvs[i]);
+        }
+        m.UploadMeshData(false);
+    }
+}

Assets/Procedural/ProceduralMeshData.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: d40bf391bd891254fa896c0c953cdc60
+timeCreated: 1481453030
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Procedural/TransformVertexNode.cs

@@ -0,0 +1,34 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class TransformVertexNode : MeshProcessor
+{
+    public Vector3 Offset = Vector3.zero;
+    public Quaternion Rotation = Quaternion.identity;
+    public Vector3 Scale = Vector3.one;
+
+    public override void Execute(ProceduralMeshData m){
+        var transform = Matrix4x4.TRS(Offset, Rotation, Scale);
+        int count = m.Vertices.Length;
+        for (int i = 0; i < count; ++i){
+            m.Vertices[i] = transform.MultiplyPoint3x4(m.Vertices[i]);
+        }
+
+        var normalTransform = Matrix4x4.TRS(Vector3.zero, Rotation, Scale).inverse.transpose;
+
+        for (int i = 0; i < count; ++i) {
+            m.Normals[i] = normalTransform.MultiplyPoint3x4(m.Normals[i]);
+        }
+
+        if (m.Tangents != null)
+        {
+            for (int i = 0; i < count; ++i)
+            {
+                var t = normalTransform.MultiplyPoint3x4((Vector3)m.Tangents[i]);
+                m.Tangents[i] = new Vector4(t.x, t.y, t.z, m.Tangents[i].w);
+            }
+        }
+        
+    }
+}

Assets/Procedural/TransformVertexNode.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 8d5f93e1c179aab4b8ed81b816616c32
+timeCreated: 1481457925
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: