code a marching cubes algorithim in unity using rotation maps based on on marching cubes by greg nielson in csharp

main.cs
// Define vertex and triangle table for marching cubes algorithm
private int[,] vertTable = new int[,] { ... };
private int[,] triTable = new int[,] { ... };

// Define rotation maps for marching cubes algorithm
private int[] rotMapX = new int[] { ... };
private int[] rotMapY = new int[] { ... };
private int[] rotMapZ = new int[] { ... };

// Marching cubes algorithm implementation
public void MarchingCubes(float[,,] data, Vector3 voxelSize, Vector3 offset)
{
    // Create mesh object
    Mesh mesh = new Mesh();
    List<Vector3> vertices = new List<Vector3>();
    List<int> triangles = new List<int>();

    // Iterate over each voxel
    for (int x = 0; x < data.GetLength(0) - 1; x++)
    {
        for (int y = 0; y < data.GetLength(1) - 1; y++)
        {
            for (int z = 0; z < data.GetLength(2) - 1; z++)
            {
                // Get corner values of voxel
                float[] values = new float[8];
                for (int i = 0; i < 8; i++)
                {
                    int cx = x + (int)rotMapX[i];
                    int cy = y + (int)rotMapY[i];
                    int cz = z + (int)rotMapZ[i];
                    values[i] = data[cx, cy, cz];
                }

                // Determine edge intersections and vertex positions
                int cubeIndex = 0;
                Vector3[] vertexPositions = new Vector3[12];
                for (int i = 0; i < 8; i++)
                {
                    if (values[i] < threshold)
                        cubeIndex |= 1 << i;
                }
                for (int i = 0; i < 12; i++)
                {
                    if ((edgeTable[cubeIndex] & (1 << i)) != 0)
                    {
                        int v1 = cornerIndexAFromEdge[i];
                        int v2 = cornerIndexBFromEdge[i];
                        float delta = (threshold - values[v1]) / (values[v2] - values[v1]);
                        vertexPositions[i] = new Vector3(
                            (float)(x + (int)rotMapX[v1] + delta * ((int)rotMapX[v2] - (int)rotMapX[v1])) * voxelSize.x + offset.x,
                            (float)(y + (int)rotMapY[v1] + delta * ((int)rotMapY[v2] - (int)rotMapY[v1])) * voxelSize.y + offset.y,
                            (float)(z + (int)rotMapZ[v1] + delta * ((int)rotMapZ[v2] - (int)rotMapZ[v1])) * voxelSize.z + offset.z
                            );
                    }
                }

                // Add triangles to mesh
                for (int i = 0; triTable[cubeIndex, i] != -1; i += 3)
                {
                    triangles.Add(vertices.Count);
                    triangles.Add(vertices.Count + 1);
                    triangles.Add(vertices.Count + 2);
                    vertices.Add(vertexPositions[triTable[cubeIndex, i]]);
                    vertices.Add(vertexPositions[triTable[cubeIndex, i + 1]]);
                    vertices.Add(vertexPositions[triTable[cubeIndex, i + 2]]);
                }
            }
        }
    }

    // Set mesh vertices and triangles
    mesh.vertices = vertices.ToArray();
    mesh.triangles = triangles.ToArray();

    // Set mesh to gameobject
    MeshFilter meshFilter = GetComponent<MeshFilter>();
    MeshRenderer meshRenderer = GetComponent<MeshRenderer>();
    meshFilter.mesh = mesh;
    meshRenderer.enabled = true;
}
3339 chars
82 lines