// Function to check each corner of a given cube - this is the "March" of Marching Cubes
// The x,y,z arguments are the positions of nodes in a chunk's node matrix
// The currChunk argument is the nodes within the current chunk's matrix data
ChunkMatrix PolygonizeCube(ChunkMatrix currChunk, int x, int y, int z)
{
Node[,,] nodes = currChunk.nodes;
// get the type of cube dependant on the active vertices within it
int cubeIndex = MarchingCubes.CheckVertices(currChunk, chunks, surfaceLevel, x, y, z);
// if there were no active nodes in this cube, break the function
if (cubeIndex == 0)
{
return(currChunk);
}
// use the edge table to obtain which edges are active for this cube configuration
int edges = MarchingCubes.edgeTable[cubeIndex];
// array holding the positions of each edge vertex
Vector3[] edgeVertices = emptyVertices;
// value of which vertex is being worked on at the moment for the mesh creation
int vert;
// Find the vertices for the triangles in the cube - TODO: do the interpolation here *****************************************
for (int i = 0; i < edgeVertices.Length; i++) // edge vertices length is the numver of edges in the cube
{
if ((edges & (1 << i)) != 0) // checks the boolean values from the edges table to see which edges are active
{
// start by assuming a hard edge - turn softEdge to false to create a more flat terrain
float edgeOffset = 1 / (float)cubeResolution / 2f;
// turning on softEdge will use the linear interpolation to smooth out the edges
if (softEdge)
{
float[] cube = MarchingCubes.GetIsovaluesOfCube(nodes, x, y, z);
edgeOffset = MarchingCubes.CalculateEdgeOffset(cube[MarchingCubes.edgeConnection[i, 0]], cube[MarchingCubes.edgeConnection[i, 1]], surfaceLevel) / (float)cubeResolution;
}
// The edgeVertices array holds the position for where the vertex will be drawn along the edge
// To figure this out, we need the position of the current node added to the
// VertexOffset defined by the LUT that shows where the next edge is in comparison to this current one
// The vertex offset needs to be divided by the cube resolution because the distance between edges will change if there are more cubes in the same amount of space
// The edgeOffset is the linear interpolated value we found and it is basically a percentage of how far between the current and next node that the vertex should be placed
// The edgeOffset needs to be multiplied by the edgeDirection value in order to know which direction that the offset is in
edgeVertices[i].x = nodes[x, y, z].position.x + MarchingCubes.vertexOffset[MarchingCubes.edgeConnection[i, 0], 0] / (float)cubeResolution + edgeOffset * MarchingCubes.edgeDirection[i, 0];
edgeVertices[i].y = nodes[x, y, z].position.y + MarchingCubes.vertexOffset[MarchingCubes.edgeConnection[i, 0], 1] / (float)cubeResolution + edgeOffset * MarchingCubes.edgeDirection[i, 1];
edgeVertices[i].z = nodes[x, y, z].position.z + MarchingCubes.vertexOffset[MarchingCubes.edgeConnection[i, 0], 2] / (float)cubeResolution + edgeOffset * MarchingCubes.edgeDirection[i, 2];
}
}
// Create the triangles from these verts - there will be at most 5 triangles to be made per cube
for (int i = 0; i < 5; i++)
{
if (MarchingCubes.triTable[cubeIndex, 3 * i] < 0) // no triangles to be made
{
break;
}
// get the current number of verts in the mesh
int vertexCount = currChunk.vertices.Count;
for (int j = 0; j < 3; j++) // iterate through the triangle verts
{
vert = MarchingCubes.triTable[cubeIndex, 3 * i + j];
currChunk.indices.Add(vertexCount + windingOrder[j]);
currChunk.vertices.Add(edgeVertices[vert]);
}
}
return(currChunk);
}
