//private static int getX(int index, int dimension) {
// return (y * VERTEX_DIMENSION + z) * VERTEX_DIMENSION + x;
//}
//private static int getY(int index, int dimension) {
// return ((VERTEX_DIMENSION + x) * VERTEX_DIMENSION + z) * VERTEX_DIMENSION + y;
//}
//private static int getZ(int index, int dimension) {
// return ((VERTEX_DIMENSION * 2 + x) * VERTEX_DIMENSION + y) * VERTEX_DIMENSION + z;
//}
//private static int getDimension(int index) {
// return index / (VERTEX_DIMENSION * VERTEX_DIMENSION * VERTEX_DIMENSION);
//}
private Voxel[, ,] createVoxelArray(VoxelUpdateInfo info)
{
setDimensions(info);
Voxel[, ,] voxels = new Voxel[VERTEX_DIMENSION, VERTEX_DIMENSION, VERTEX_DIMENSION];
for (byte y = (byte)(1 - yExtend); y < yDim; ++y)
{
for (byte z = (byte)(1 - zExtend); z < zDim; ++z)
{
voxels[1 - xExtend, y, z] = info.getSub(VOXEL_COUNT_POWER, VOXEL_DIMENSION - xExtend, VOXEL_DIMENSION - 1 + y, VOXEL_DIMENSION - 1 + z).toVoxel();
}
}
for (byte x = (byte)(2 - xExtend); x < xDim; ++x)
{
for (byte z = (byte)(1 - zExtend); z < zDim; ++z)
{
voxels[x, 1 - yExtend, z] = info.getSub(VOXEL_COUNT_POWER, VOXEL_DIMENSION - 1 + x, VOXEL_DIMENSION - yExtend, VOXEL_DIMENSION - 1 + z).toVoxel();
}
}
for (byte x = (byte)(2 - xExtend); x < xDim; ++x)
{
for (byte y = (byte)(2 - yExtend); y < yDim; ++y)
{
voxels[x, y, 1 - zExtend] = info.getSub(VOXEL_COUNT_POWER, VOXEL_DIMENSION - 1 + x, VOXEL_DIMENSION - 1 + y, VOXEL_DIMENSION - zExtend).toVoxel();
}
}
return(voxels);
}
public VoxelUpdateInfo(VoxelUpdateInfo super, byte xi, byte yi, byte zi)
: this()
{
size = super.size / VoxelBlock.CHILD_DIMENSION;
detailLevel = (byte)(super.detailLevel + 1);
control = super.control;
x = super.x * VoxelBlock.CHILD_DIMENSION + xi;
y = super.y * VoxelBlock.CHILD_DIMENSION + yi;
z = super.z * VoxelBlock.CHILD_DIMENSION + zi;
for (byte xii = 0; xii < DIMENSION; ++xii) {
for (byte yii = 0; yii < DIMENSION; ++yii) {
for (byte zii = 0; zii < DIMENSION; ++zii) {
blocks[xii, yii, zii] = super.getSub(VoxelBlock.CHILD_COUNT_POWER, (byte)(xii + xi + VoxelBlock.CHILD_DIMENSION - 1), (byte)(yii + yi + VoxelBlock.CHILD_DIMENSION - 1), (byte)(zii + zi + VoxelBlock.CHILD_DIMENSION - 1));
renderers[xii, yii, zii] = super.renderers[(int)((xii + xi + 1) * 0.5), (int)((yii + yi + 1) * 0.5), (int)((zii + zi + 1) * 0.5)];
if (renderers[xii, yii, zii] == null || renderers[xii, yii, zii].old) {
renderers[xii, yii, zii] = super.blocks[(int)((xii + xi + 1) * 0.5), (int)((yii + yi + 1) * 0.5), (int)((zii + zi + 1) * 0.5)].getRenderer(0, 0, 0, 0);
if (renderers[xii, yii, zii] == null || renderers[xii, yii, zii].old)
renderers[xii, yii, zii] = blocks[xii, yii, zii].getRenderer(0, 0, 0, 0);
if (renderers[xii, yii, zii] != null && renderers[xii, yii, zii].old)
renderers[xii, yii, zii] = null;
}
}
}
}
}
public override void execute()
{
lock (control) {
VoxelUpdateInfo info = control.getBaseUpdateInfo().getSubInfo(detailLevel, xOff, yOff, zOff);
getRenderer().genMesh(info);
}
}
public VoxelUpdateInfo(VoxelUpdateInfo super, byte xi, byte yi, byte zi)
: this()
{
size = super.size / VoxelBlock.CHILD_DIMENSION;
detailLevel = (byte)(super.detailLevel + 1);
control = super.control;
x = super.x * VoxelBlock.CHILD_DIMENSION + xi;
y = super.y * VoxelBlock.CHILD_DIMENSION + yi;
z = super.z * VoxelBlock.CHILD_DIMENSION + zi;
for (byte xii = 0; xii < DIMENSION; ++xii)
{
for (byte yii = 0; yii < DIMENSION; ++yii)
{
for (byte zii = 0; zii < DIMENSION; ++zii)
{
blocks[xii, yii, zii] = super.getSub(VoxelBlock.CHILD_COUNT_POWER, (byte)(xii + xi + VoxelBlock.CHILD_DIMENSION - 1), (byte)(yii + yi + VoxelBlock.CHILD_DIMENSION - 1), (byte)(zii + zi + VoxelBlock.CHILD_DIMENSION - 1));
renderers[xii, yii, zii] = super.renderers[(int)((xii + xi + 1) * 0.5), (int)((yii + yi + 1) * 0.5), (int)((zii + zi + 1) * 0.5)];
if (renderers[xii, yii, zii] == null || renderers[xii, yii, zii].old)
{
renderers[xii, yii, zii] = super.blocks[(int)((xii + xi + 1) * 0.5), (int)((yii + yi + 1) * 0.5), (int)((zii + zi + 1) * 0.5)].getRenderer(0, 0, 0, 0);
if (renderers[xii, yii, zii] == null || renderers[xii, yii, zii].old)
{
renderers[xii, yii, zii] = blocks[xii, yii, zii].getRenderer(0, 0, 0, 0);
}
if (renderers[xii, yii, zii] != null && renderers[xii, yii, zii].old)
{
renderers[xii, yii, zii] = null;
}
}
}
}
}
}
private void alignOtherEdge(VoxelUpdateInfo info, byte x, byte y, byte z)
{
VoxelRenderer other = info.renderers[1, 1, 1];
if (other == null)
{
if (info.blocks[1, 1, 1].GetType() == typeof(VoxelBlock))
{
byte xStart = (byte)((VoxelBlock.CHILD_DIMENSION - 1) * (2 - x) / 2);
byte xEnd = (byte)(1 + (VoxelBlock.CHILD_DIMENSION - 1) * (1 - x / 2));
byte yStart = (byte)((VoxelBlock.CHILD_DIMENSION - 1) * (2 - y) / 2);
byte yEnd = (byte)(1 + (VoxelBlock.CHILD_DIMENSION - 1) * (1 - y / 2));
byte zStart = (byte)((VoxelBlock.CHILD_DIMENSION - 1) * (2 - z) / 2);
byte zEnd = (byte)(1 + (VoxelBlock.CHILD_DIMENSION - 1) * (1 - z / 2));
for (byte xi = xStart; xi < xEnd; ++xi)
{
for (byte yi = yStart; yi < yEnd; ++yi)
{
for (byte zi = zStart; zi < zEnd; ++zi)
{
alignOtherEdge(new VoxelUpdateInfo(info, xi, yi, zi), x, y, z);
}
}
}
}
return;
}
other.addEdge(info, (byte)(2 - x), (byte)(2 - y), (byte)(2 - z));
}
protected void traverse(VoxelUpdateInfo info, byte detailLevel)
{
int factor = 1 << (detailLevel - VoxelBlock.CHILD_COUNT_POWER);
byte xiMin = (byte)Mathf.Max(min.x / factor - info.x * VoxelBlock.CHILD_DIMENSION, 0);
byte xiMax = (byte)Mathf.Min((max.x + 3) / factor - info.x * VoxelBlock.CHILD_DIMENSION, VoxelBlock.CHILD_DIMENSION - 1);
byte yiMin = (byte)Mathf.Max(min.y / factor - info.y * VoxelBlock.CHILD_DIMENSION, 0);
byte yiMax = (byte)Mathf.Min((max.y + 3) / factor - info.y * VoxelBlock.CHILD_DIMENSION, VoxelBlock.CHILD_DIMENSION - 1);
byte ziMin = (byte)Mathf.Max(min.z / factor - info.z * VoxelBlock.CHILD_DIMENSION, 0);
byte ziMax = (byte)Mathf.Min((max.z + 3) / factor - info.z * VoxelBlock.CHILD_DIMENSION, VoxelBlock.CHILD_DIMENSION - 1);
VoxelBlock block = (VoxelBlock)info.blocks[1, 1, 1];
int scale = VoxelBlock.CHILD_DIMENSION << (VoxelBlock.CHILD_COUNT_POWER *(detailLevel));
// MonoBehaviour.print (scale);
// MonoBehaviour.print (detailLevel);
uint minY = uint.MinValue;
uint maxY = uint.MaxValue;
foreach(VoxelMask mask in control.masks) {
if (mask.active) {
if (mask.maskAbove) {
if (maxY > mask.yPosition)
maxY = mask.yPosition;
} else if (minY < mask.yPosition) {
minY = mask.yPosition;
}
}
}
for (byte xi = xiMin; xi <= xiMax; ++xi) {
for (byte yi = yiMin; yi <= yiMax; ++yi) {
if ((info.y +yi +1) *scale <= minY ||
(info.y +yi) *scale >= maxY) {
continue;
}
for (byte zi = ziMin; zi <= ziMax; ++zi) {
if (detailLevel <= VoxelBlock.CHILD_COUNT_POWER) {
block.children[xi, yi, zi] = modifyVoxel(block.children[xi, yi, zi], info.x * VoxelBlock.CHILD_DIMENSION + xi, info.y * VoxelBlock.CHILD_DIMENSION + yi, info.z * VoxelBlock.CHILD_DIMENSION + zi);
} else {
if (block.children[xi, yi, zi].GetType() == typeof(Voxel)) {
block.children[xi, yi, zi] = new VoxelBlock((Voxel)block.children[xi, yi, zi]);
}
traverse(new VoxelUpdateInfo(info, xi, yi, zi), (byte)(detailLevel - VoxelBlock.CHILD_COUNT_POWER));
}
}
}
}
// TODO: this should check if completely contained, not if rendersize (for distant modifications) - FIXED?
if (updateMesh && info != null && (VoxelBlock.isRenderSize(info.size, control) || VoxelBlock.isRenderLod(info.x, info.y, info.z, control.sizes[detailLevel], control))) {
block.updateAll(info.x, info.y, info.z, info.detailLevel, control, true);
}
}
protected void traverse(VoxelUpdateInfo info, byte detailLevel)
{
int factor = 1 << (detailLevel - VoxelBlock.CHILD_COUNT_POWER);
byte xiMin = (byte)Mathf.Max(minX / factor - info.x * VoxelBlock.CHILD_DIMENSION, 0f);
byte xiMax = (byte)Mathf.Min((maxX + 1) / factor - info.x * VoxelBlock.CHILD_DIMENSION, VoxelBlock.CHILD_DIMENSION - 1f);
byte yiMin = (byte)Mathf.Max(minY / factor - info.y * VoxelBlock.CHILD_DIMENSION, 0f);
byte yiMax = (byte)Mathf.Min((maxY + 1) / factor - info.y * VoxelBlock.CHILD_DIMENSION, VoxelBlock.CHILD_DIMENSION - 1f);
byte ziMin = (byte)Mathf.Max(minZ / factor - info.z * VoxelBlock.CHILD_DIMENSION, 0f);
byte ziMax = (byte)Mathf.Min((maxZ + 1) / factor - info.z * VoxelBlock.CHILD_DIMENSION, VoxelBlock.CHILD_DIMENSION - 1f);
VoxelBlock block = (VoxelBlock)info.blocks[1, 1, 1];
uint scale = (uint)(1 << (VoxelBlock.CHILD_COUNT_POWER * (detailLevel - 1)));
for (byte yi = yiMin; yi <= yiMax; ++yi)
{
if ((info.y * VoxelBlock.CHILD_DIMENSION + yi) < maskMinY / scale ||
(info.y * VoxelBlock.CHILD_DIMENSION + yi) > maskMaxY / scale + 1)
{
continue;
}
for (byte xi = xiMin; xi <= xiMax; ++xi)
{
for (byte zi = ziMin; zi <= ziMax; ++zi)
{
if (detailLevel <= VoxelBlock.CHILD_COUNT_POWER)
{
block.children[xi, yi, zi] = modifyVoxel(block.children[xi, yi, zi], info.x * VoxelBlock.CHILD_DIMENSION + xi, info.y * VoxelBlock.CHILD_DIMENSION + yi, info.z * VoxelBlock.CHILD_DIMENSION + zi);
}
else
{
if (block.children[xi, yi, zi].GetType() == typeof(Voxel))
{
block.children[xi, yi, zi] = new VoxelBlock((Voxel)block.children[xi, yi, zi]);
}
traverse(new VoxelUpdateInfo(info, xi, yi, zi), (byte)(detailLevel - VoxelBlock.CHILD_COUNT_POWER));
}
}
}
}
if (updateMesh && info != null && (VoxelBlock.isRenderSize(info.size, control) || VoxelBlock.isRenderLod(info.x, info.y, info.z, info.size, control)))
{
//block.clearSubRenderers(control);
block.updateAll(info.x, info.y, info.z, info.detailLevel, control, true);
}
}
public void setFromSister(VoxelUpdateInfo sister, byte xi, byte yi, byte zi) {
size = sister.size;
detailLevel = sister.detailLevel;
control = sister.control;
x = sister.x + xi - 1;
y = sister.y + yi - 1;
z = sister.z + zi - 1;
for (byte xii = (byte)(1 - (xi + 1) / 2); xii < DIMENSION - (xi / 2); ++xii) {
for (byte yii = (byte)(1 - (yi + 1) / 2); yii < DIMENSION - (yi / 2); ++yii) {
for (byte zii = (byte)(1 - (zi + 1) / 2); zii < DIMENSION - (zi / 2); ++zii) {
blocks[xii, yii, zii] = sister.blocks[xii + xi - 1, yii + yi - 1, zii + zi - 1];
renderers[xii, yii, zii] = sister.renderers[xii + xi - 1, yii + yi - 1, zii + zi - 1];
}
}
}
}
private void setDimensions(VoxelUpdateInfo info)
{
if (info.renderers[0, 1, 1] == null)
{
xExtend = 0;
}
else
{
xExtend = 1;
}
if (info.renderers[1, 0, 1] == null)
{
yExtend = 0;
}
else
{
yExtend = 1;
}
if (info.renderers[1, 1, 0] == null)
{
zExtend = 0;
}
else
{
zExtend = 1;
}
xDim = (byte)(VOXEL_DIMENSION + 1);
yDim = (byte)(VOXEL_DIMENSION + 1);
zDim = (byte)(VOXEL_DIMENSION + 1);
if (info.renderers[2, 1, 1] != null && info.renderers[2, 1, 1].size > size * 1.1f)
{
++xDim;
}
if (info.renderers[1, 2, 1] != null && info.renderers[1, 2, 1].size > size * 1.1f)
{
++yDim;
}
if (info.renderers[1, 1, 2] != null && info.renderers[1, 1, 2].size > size * 1.1f)
{
++zDim;
}
}
public void setFromSister(VoxelUpdateInfo sister, byte xi, byte yi, byte zi)
{
size = sister.size;
detailLevel = sister.detailLevel;
control = sister.control;
x = sister.x + xi - 1;
y = sister.y + yi - 1;
z = sister.z + zi - 1;
for (byte xii = (byte)(1 - (xi + 1) / 2); xii < DIMENSION - (xi / 2); ++xii)
{
for (byte yii = (byte)(1 - (yi + 1) / 2); yii < DIMENSION - (yi / 2); ++yii)
{
for (byte zii = (byte)(1 - (zi + 1) / 2); zii < DIMENSION - (zi / 2); ++zii)
{
blocks[xii, yii, zii] = sister.blocks[xii + xi - 1, yii + yi - 1, zii + zi - 1];
renderers[xii, yii, zii] = sister.renderers[xii + xi - 1, yii + yi - 1, zii + zi - 1];
}
}
}
}
protected void traverse(VoxelUpdateInfo info, byte detailLevel)
{
int factor = 1 << (detailLevel - VoxelBlock.CHILD_COUNT_POWER);
byte xiMin = (byte)Mathf.Max(minX / factor - info.x * VoxelBlock.CHILD_DIMENSION, 0f);
byte xiMax = (byte)Mathf.Min((maxX + 1) / factor - info.x * VoxelBlock.CHILD_DIMENSION, VoxelBlock.CHILD_DIMENSION - 1f);
byte yiMin = (byte)Mathf.Max(minY / factor - info.y * VoxelBlock.CHILD_DIMENSION, 0f);
byte yiMax = (byte)Mathf.Min((maxY + 1) / factor - info.y * VoxelBlock.CHILD_DIMENSION, VoxelBlock.CHILD_DIMENSION - 1f);
byte ziMin = (byte)Mathf.Max(minZ / factor - info.z * VoxelBlock.CHILD_DIMENSION, 0f);
byte ziMax = (byte)Mathf.Min((maxZ + 1) / factor - info.z * VoxelBlock.CHILD_DIMENSION, VoxelBlock.CHILD_DIMENSION - 1f);
VoxelBlock block = (VoxelBlock)info.blocks[1, 1, 1];
uint scale = (uint) (1 << (VoxelBlock.CHILD_COUNT_POWER *(detailLevel -1)));
for (byte yi = yiMin; yi <= yiMax; ++yi) {
if ((info.y *VoxelBlock.CHILD_DIMENSION +yi) < maskMinY /scale ||
(info.y *VoxelBlock.CHILD_DIMENSION +yi) > maskMaxY /scale +1) {
continue;
}
for (byte xi = xiMin; xi <= xiMax; ++xi) {
for (byte zi = ziMin; zi <= ziMax; ++zi) {
if (detailLevel <= VoxelBlock.CHILD_COUNT_POWER) {
block.children[xi, yi, zi] = modifyVoxel(block.children[xi, yi, zi], info.x * VoxelBlock.CHILD_DIMENSION + xi, info.y * VoxelBlock.CHILD_DIMENSION + yi, info.z * VoxelBlock.CHILD_DIMENSION + zi);
} else {
if (block.children[xi, yi, zi].GetType() == typeof(Voxel)) {
block.children[xi, yi, zi] = new VoxelBlock((Voxel)block.children[xi, yi, zi]);
}
traverse(new VoxelUpdateInfo(info, xi, yi, zi), (byte)(detailLevel - VoxelBlock.CHILD_COUNT_POWER));
}
}
}
}
if (updateMesh && info != null && (VoxelBlock.isRenderSize(info.size, control) || VoxelBlock.isRenderLod(info.x, info.y, info.z, info.size, control))) {
//block.clearSubRenderers(control);
block.updateAll(info.x, info.y, info.z, info.detailLevel, control, true);
}
}
public void genMesh(VoxelUpdateInfo info)
{
if (control == null)
{
return;
}
size = info.size;
Queue <int[]> triangleSet = new Queue <int[]>();
vertices = new Dictionary <int, object>();
vertexSubstances = new Dictionary <int, byte>();
Voxel[, ,] voxels = createVoxelArray(info);
MarchingCubes.setup(info.size / VOXEL_DIMENSION, control.isoLevel, ref vertices, ref vertexSubstances, ref voxels, position - new Vector3(0.5f, 0.5f, 0.5f) * size / VOXEL_DIMENSION, null);
int totalTris = 0;
for (byte x = (byte)(1 - xExtend), x1 = (byte)(x + 1); x1 < xDim; x = x1++)
{
for (byte y = (byte)(1 - yExtend), y1 = (byte)(y + 1); y1 < yDim; y = y1++)
{
for (byte z = (byte)(1 - zExtend), z1 = (byte)(z + 1); z1 < zDim; z = z1++)
{
lock (control) {
VoxelHolder block = info.getSub(VOXEL_COUNT_POWER, VOXEL_DIMENSION + x, VOXEL_DIMENSION + y, VOXEL_DIMENSION + z);
voxels[x1, y1, z1] = block.toVoxel();
int[] tris = MarchingCubes.lookupTriangles(x, y, z, x1, y1, z1);
if (tris == null)
{
continue;
}
triangleSet.Enqueue(tris);
totalTris += tris.Length;
}
}
}
}
if (vertices.Count < 1)
{
applied = true;
return;
}
List <int> triangles = new List <int>();
List <Vector3> finalVertices = new List <Vector3>(vertices.Count);
//List<byte> finalMats = new List<byte>(vertices.Count);
while (triangleSet.Count > 0)
{
int[] triangleList = triangleSet.Dequeue();
for (int i = 0; i < triangleList.Length; ++i)
{
if (vertices[triangleList[i]].GetType() == typeof(Vector3))
{
finalVertices.Add((Vector3)vertices[triangleList[i]]);
//finalMats.Add(vertexSubstances[triangleList[i]]);
vertices[triangleList[i]] = finalVertices.Count - 1;
}
triangles.Add((int)vertices[triangleList[i]]);
}
}
VERTS = finalVertices.ToArray();
TRIS = triangles.ToArray();
//MATS = finalMats.ToArray();
calcNorms();
alignEdge(info, 0, 1, 1);
alignEdge(info, 2, 1, 1);
alignEdge(info, 1, 0, 1);
alignEdge(info, 1, 2, 1);
alignEdge(info, 1, 1, 0);
alignEdge(info, 1, 1, 2);
lock (control) {
control.enqueueJob(new ApplyMeshJob(this, info.detailLevel, info.x, info.y, info.z));
}
}
private void alignOtherEdge(VoxelUpdateInfo info, byte x, byte y, byte z)
{
VoxelRenderer other = info.renderers[1, 1, 1];
if (other == null) {
if (info.blocks[1, 1, 1].GetType() == typeof(VoxelBlock)) {
byte xStart = (byte)((VoxelBlock.CHILD_DIMENSION - 1) * (2 - x) / 2);
byte xEnd = (byte)(1 + (VoxelBlock.CHILD_DIMENSION - 1) * (1 - x / 2));
byte yStart = (byte)((VoxelBlock.CHILD_DIMENSION - 1) * (2 - y) / 2);
byte yEnd = (byte)(1 + (VoxelBlock.CHILD_DIMENSION - 1) * (1 - y / 2));
byte zStart = (byte)((VoxelBlock.CHILD_DIMENSION - 1) * (2 - z) / 2);
byte zEnd = (byte)(1 + (VoxelBlock.CHILD_DIMENSION - 1) * (1 - z / 2));
for (byte xi = xStart; xi < xEnd; ++xi) {
for (byte yi = yStart; yi < yEnd; ++yi) {
for (byte zi = zStart; zi < zEnd; ++zi) {
alignOtherEdge(new VoxelUpdateInfo(info, xi, yi, zi), x, y, z);
}
}
}
}
return;
}
other.addEdge(info, (byte)(2 - x), (byte)(2 - y), (byte)(2 - z));
}
public void addEdge(VoxelUpdateInfo info, byte x, byte y, byte z)
{
if (vertices == null)
{
return;
}
bool recalculate = false;
Voxel[, ,] voxels = new Voxel[VERTEX_DIMENSION, VERTEX_DIMENSION, VERTEX_DIMENSION];
if (x == 0 /* && xExtend == 0*/)
{
recalculate = true;
xExtend = 1;
for (byte yi = (byte)(1 - yExtend); yi < yDim; ++yi)
{
for (byte zi = (byte)(1 - zExtend); zi < zDim; ++zi)
{
voxels[0, yi, zi] = info.getSub(VOXEL_COUNT_POWER, VOXEL_DIMENSION - xExtend, VOXEL_DIMENSION - 1 + yi, VOXEL_DIMENSION - 1 + zi).toVoxel();
voxels[1, yi, zi] = info.getSub(VOXEL_COUNT_POWER, VOXEL_DIMENSION, VOXEL_DIMENSION - 1 + yi, VOXEL_DIMENSION - 1 + zi).toVoxel();
}
}
}
else if (x == 2 /* && xDim < VERTEX_DIMENSION*/)
{
recalculate = true;
xDim = VERTEX_DIMENSION;
for (byte yi = (byte)(1 - yExtend); yi < yDim; ++yi)
{
for (byte zi = (byte)(1 - zExtend); zi < zDim; ++zi)
{
voxels[VOXEL_DIMENSION + 1, yi, zi] = info.getSub(VOXEL_COUNT_POWER, VOXEL_DIMENSION * 2, VOXEL_DIMENSION - 1 + yi, VOXEL_DIMENSION - 1 + zi).toVoxel();
voxels[VOXEL_DIMENSION, yi, zi] = info.getSub(VOXEL_COUNT_POWER, VOXEL_DIMENSION * 2 - 1, VOXEL_DIMENSION - 1 + yi, VOXEL_DIMENSION - 1 + zi).toVoxel();
}
}
}
else if (y == 0 /* && yExtend == 0*/)
{
recalculate = true;
yExtend = 1;
for (byte xi = (byte)(1 - xExtend); xi < xDim; ++xi)
{
for (byte zi = (byte)(1 - zExtend); zi < zDim; ++zi)
{
voxels[xi, 0, zi] = info.getSub(VOXEL_COUNT_POWER, VOXEL_DIMENSION - 1 + xi, VOXEL_DIMENSION - yExtend, VOXEL_DIMENSION - 1 + zi).toVoxel();
voxels[xi, 1, zi] = info.getSub(VOXEL_COUNT_POWER, VOXEL_DIMENSION - 1 + xi, VOXEL_DIMENSION, VOXEL_DIMENSION - 1 + zi).toVoxel();
}
}
}
else if (y == 2 /* && yDim < VERTEX_DIMENSION*/)
{
recalculate = true;
yDim = VERTEX_DIMENSION;
for (byte xi = (byte)(1 - xExtend); xi < xDim; ++xi)
{
for (byte zi = (byte)(1 - zExtend); zi < zDim; ++zi)
{
voxels[xi, VOXEL_DIMENSION + 1, zi] = info.getSub(VOXEL_COUNT_POWER, VOXEL_DIMENSION - 1 + xi, VOXEL_DIMENSION * 2, VOXEL_DIMENSION - 1 + zi).toVoxel();
voxels[xi, VOXEL_DIMENSION, zi] = info.getSub(VOXEL_COUNT_POWER, VOXEL_DIMENSION - 1 + xi, VOXEL_DIMENSION * 2 - 1, VOXEL_DIMENSION - 1 + zi).toVoxel();
}
}
}
else if (z == 0 /* && zExtend == 0*/)
{
recalculate = true;
zExtend = 1;
for (byte xi = (byte)(1 - xExtend); xi < xDim; ++xi)
{
for (byte yi = (byte)(1 - yExtend); yi < yDim; ++yi)
{
voxels[xi, yi, 0] = info.getSub(VOXEL_COUNT_POWER, VOXEL_DIMENSION - 1 + xi, VOXEL_DIMENSION - 1 + yi, VOXEL_DIMENSION - zExtend).toVoxel();
voxels[xi, yi, 1] = info.getSub(VOXEL_COUNT_POWER, VOXEL_DIMENSION - 1 + xi, VOXEL_DIMENSION - 1 + yi, VOXEL_DIMENSION).toVoxel();
}
}
}
else if (z == 2 /* && zDim < VERTEX_DIMENSION*/)
{
recalculate = true;
zDim = VERTEX_DIMENSION;
for (byte xi = (byte)(1 - xExtend); xi < xDim; ++xi)
{
for (byte yi = (byte)(1 - yExtend); yi < yDim; ++yi)
{
voxels[xi, yi, VOXEL_DIMENSION + 1] = info.getSub(VOXEL_COUNT_POWER, VOXEL_DIMENSION - 1 + xi, VOXEL_DIMENSION - 1 + yi, VOXEL_DIMENSION * 2).toVoxel();
voxels[xi, yi, VOXEL_DIMENSION] = info.getSub(VOXEL_COUNT_POWER, VOXEL_DIMENSION - 1 + xi, VOXEL_DIMENSION - 1 + yi, VOXEL_DIMENSION * 2 - 1).toVoxel();
}
}
}
if (recalculate)
{
Queue <int[]> triangleSet = new Queue <int[]>();
MarchingCubes.setup(info.size / VOXEL_DIMENSION, control.isoLevel, ref vertices, ref vertexSubstances, ref voxels, position - new Vector3(0.5f, 0.5f, 0.5f) * size / VOXEL_DIMENSION, VERTS);
byte xStart = (byte)(1 - xExtend + (VOXEL_DIMENSION + xExtend - 1) * (x / 2));
byte xEnd = (byte)(2 + (xDim - 2) * ((x + 1) / 2));
byte yStart = (byte)(1 - yExtend + (VOXEL_DIMENSION + yExtend - 1) * (y / 2));
byte yEnd = (byte)(2 + (yDim - 2) * ((y + 1) / 2));
byte zStart = (byte)(1 - zExtend + (VOXEL_DIMENSION + zExtend - 1) * (z / 2));
byte zEnd = (byte)(2 + (zDim - 2) * ((z + 1) / 2));
for (byte xi = xStart, x1 = (byte)(xi + 1); x1 < xEnd; xi = x1++)
{
for (byte yi = yStart, y1 = (byte)(yi + 1); y1 < yEnd; yi = y1++)
{
for (byte zi = zStart, z1 = (byte)(zi + 1); z1 < zEnd; zi = z1++)
{
int[] tris = MarchingCubes.lookupTriangles(xi, yi, zi, x1, y1, z1);
if (tris == null)
{
continue;
}
triangleSet.Enqueue(tris);
}
}
}
if (vertices.Count < 1)
{
return;
}
List <int> newTriangles = new List <int>(TRIS);
List <Vector3> newVertices = new List <Vector3>(VERTS);
int tri = 0;
while (triangleSet.Count > 0)
{
int[] triangleList = triangleSet.Dequeue();
for (int i = 0; i < triangleList.Length; ++i)
{
if (vertices[triangleList[i]].GetType() == typeof(Vector3))
{
newVertices.Add((Vector3)vertices[triangleList[i]]);
vertices[triangleList[i]] = newVertices.Count - 1;
}
newTriangles.Add((int)vertices[triangleList[i]]);
}
tri += triangleList.Length;
}
Vector3[] finalNorms = new Vector3[newVertices.Count];
Array.Copy(NORMS, finalNorms, NORMS.Length);
int oldNormCount = NORMS.Length;
VERTS = newVertices.ToArray();
TRIS = newTriangles.ToArray();
calcNorms();
Array.Copy(NORMS, oldNormCount, finalNorms, oldNormCount, finalNorms.Length - oldNormCount);
NORMS = finalNorms;
}
alignEdge(info, x, y, z);
control.enqueueJob(new ApplyMeshJob(this, info.detailLevel, info.x, info.y, info.z));
}
public void removeEdge(VoxelUpdateInfo info, byte x, byte y, byte z)
{
if (vertices == null)
{
return;
}
bool recalculate = false;
if (x == 0 && xExtend == 1)
{
recalculate = true;
xExtend = 0;
for (byte yi = (byte)(1 - yExtend); yi < yDim; ++yi)
{
for (byte zi = (byte)(1 - zExtend); zi < zDim; ++zi)
{
vertices.Remove(getX(0, yi, zi));
vertices.Remove(getY(0, yi, zi));
vertices.Remove(getZ(0, yi, zi));
}
}
}
else if (x == 2 && xDim >= VERTEX_DIMENSION)
{
recalculate = true;
xDim = VERTEX_DIMENSION - 1;
for (byte yi = (byte)(1 - yExtend); yi < yDim; ++yi)
{
for (byte zi = (byte)(1 - zExtend); zi < zDim; ++zi)
{
vertices.Remove(getX(xDim - 1, yi, zi));
vertices.Remove(getY(xDim, yi, zi));
vertices.Remove(getZ(xDim, yi, zi));
}
}
}
else if (y == 0 && yExtend == 1)
{
recalculate = true;
yExtend = 0;
for (byte xi = (byte)(1 - xExtend); xi < xDim; ++xi)
{
for (byte zi = (byte)(1 - zExtend); zi < zDim; ++zi)
{
vertices.Remove(getX(xi, 0, zi));
vertices.Remove(getY(xi, 0, zi));
vertices.Remove(getZ(xi, 0, zi));
}
}
}
else if (y == 2 && yDim >= VERTEX_DIMENSION)
{
recalculate = true;
yDim = VERTEX_DIMENSION - 1;
for (byte xi = (byte)(1 - xExtend); xi < xDim; ++xi)
{
for (byte zi = (byte)(1 - zExtend); zi < zDim; ++zi)
{
vertices.Remove(getX(xi, yDim, zi));
vertices.Remove(getY(xi, yDim - 1, zi));
vertices.Remove(getZ(xi, yDim, zi));
}
}
}
else if (z == 0 && zExtend == 1)
{
recalculate = true;
zExtend = 0;
for (byte xi = (byte)(1 - xExtend); xi < xDim; ++xi)
{
for (byte yi = (byte)(1 - yExtend); yi < yDim; ++yi)
{
vertices.Remove(getX(xi, yi, 0));
vertices.Remove(getY(xi, yi, 0));
vertices.Remove(getZ(xi, yi, 0));
}
}
}
else if (z == 2 && zDim >= VERTEX_DIMENSION)
{
recalculate = true;
zDim = VERTEX_DIMENSION - 1;
for (byte xi = (byte)(1 - xExtend); xi < xDim; ++xi)
{
for (byte yi = (byte)(1 - yExtend); yi < yDim; ++yi)
{
vertices.Remove(getX(xi, yi, zDim));
vertices.Remove(getY(xi, yi, zDim));
vertices.Remove(getZ(xi, yi, zDim - 1));
}
}
}
if (recalculate)
{
List <KeyValuePair <int, object> > vertexList = new List <KeyValuePair <int, object> >(vertices);
int[] oldTris = TRIS;
Vector3[] oldVerts = VERTS;
Vector3[] oldNorms = NORMS;
List <int> newTris = new List <int>(TRIS.Length);
Vector3[] newVerts = new Vector3[vertexList.Count];
Vector3[] newNorms = new Vector3[newVerts.Length];
object[] oldReverseIndices = new object[oldVerts.Length];
int count = 0;
foreach (KeyValuePair <int, object> pair in vertexList)
{
int oldIndex = (int)pair.Value;
vertices[pair.Key] = count;
newVerts[count] = oldVerts[oldIndex];
newNorms[count] = oldNorms[oldIndex];
oldReverseIndices[oldIndex] = pair.Key;
++count;
}
int[] triangle = new int[3];
for (int i = 0; i < oldTris.Length; i += 3)
{
bool old = false;
for (int j = 0; j < 3; ++j)
{
object newIndex = oldReverseIndices[oldTris[i + j]];
if (newIndex == null)
{
old = true;
break;
}
triangle[j] = (int)vertices[(int)newIndex];
}
if (old)
{
continue;
}
newTris.AddRange(triangle);
}
VERTS = newVerts;
NORMS = newNorms;
TRIS = newTris.ToArray();
control.enqueueJob(new ApplyMeshJob(this, info.detailLevel, info.x, info.y, info.z));
}
}
// ~VoxelRenderer() {
// clear();
// }
public void genMesh(VoxelUpdateInfo info)
{
size = info.size;
Queue<int[]> triangleSet = new Queue<int[]>();
vertices = new Dictionary<int, object>();
vertexSubstances = new Dictionary<int, byte>();
Voxel[, ,] voxels = createVoxelArray(info);
MarchingCubes.setup(info.size / VOXEL_DIMENSION, control.isoLevel, ref vertices, ref vertexSubstances, ref voxels, position - new Vector3(0.5f, 0.5f, 0.5f) * size / VOXEL_DIMENSION, null);
int totalTris = 0;
for (byte x = (byte)(1 - xExtend), x1 = (byte)(x + 1); x1 < xDim; x = x1++) {
for (byte y = (byte)(1 - yExtend), y1 = (byte)(y + 1); y1 < yDim; y = y1++) {
for (byte z = (byte)(1 - zExtend), z1 = (byte)(z + 1); z1 < zDim; z = z1++) {
lock (control) {
VoxelHolder block = info.getSub(VOXEL_COUNT_POWER, VOXEL_DIMENSION + x, VOXEL_DIMENSION + y, VOXEL_DIMENSION + z);
voxels[x1, y1, z1] = block.toVoxel();
int[] tris = MarchingCubes.lookupTriangles(x, y, z, x1, y1, z1);
if (tris == null) continue;
triangleSet.Enqueue(tris);
totalTris += tris.Length;
}
}
}
}
if (vertices.Count < 1) {
applied = true;
return;
}
List<int> triangles = new List<int>();
List<Vector3> finalVertices = new List<Vector3>(vertices.Count);
//List<byte> finalMats = new List<byte>(vertices.Count);
while (triangleSet.Count > 0) {
int[] triangleList = triangleSet.Dequeue();
for (int i = 0; i < triangleList.Length; ++i) {
if (vertices[triangleList[i]].GetType() == typeof(Vector3)) {
finalVertices.Add((Vector3)vertices[triangleList[i]]);
//finalMats.Add(vertexSubstances[triangleList[i]]);
vertices[triangleList[i]] = finalVertices.Count - 1;
}
triangles.Add((int)vertices[triangleList[i]]);
}
}
VERTS = finalVertices.ToArray();
TRIS = triangles.ToArray();
//MATS = finalMats.ToArray();
calcNorms();
alignEdge(info, 0, 1, 1);
alignEdge(info, 2, 1, 1);
alignEdge(info, 1, 0, 1);
alignEdge(info, 1, 2, 1);
alignEdge(info, 1, 1, 0);
alignEdge(info, 1, 1, 2);
lock (control) {
control.enqueueMeshApply(new ApplyMeshJob(this, info.detailLevel, info.x, info.y, info.z));
}
}
private void alignEdge(VoxelUpdateInfo info, byte x, byte y, byte z)
{
if (info.renderers[x, y, z] == null || (x + y + z > 3 && info.renderers[x, y, z].size == size))
{
lock (control) {
VoxelUpdateInfo newInfo = new VoxelUpdateInfo(info.size, info.blocks[1, 1, 1], info.control);
newInfo.setFromSister(info, x, y, z);
alignOtherEdge(newInfo, x, y, z);
}
return;
}
lock (control) {
info.renderers[x, y, z].removeEdge(info, (byte)(2 - x), (byte)(2 - y), (byte)(2 - z));
}
Vector3[] newVerts = VERTS;
LinkedList <int> myIndices = new LinkedList <int>();
LinkedList <Vector3[]> otherVerts = new LinkedList <Vector3[]>();
Vector3[] newNorms = NORMS;
lock (control) {
if (x != 1)
{
if (xDim < VERTEX_DIMENSION && x == 2)
{
return;
}
int otherXInd = 1 + (VERTEX_DIMENSION - 3) * (1 - x / 2);
int myXInd = (VERTEX_DIMENSION - 1) * (x / 2);
for (int yi = 1 - yExtend; yi < yDim; ++yi)
{
for (int zi = 1 - zExtend; zi < zDim; ++zi)
{
addDualVertices(otherVerts, info.renderers[x, y, z], otherXInd, yi, zi, 0);
myIndices.AddFirst(getY(myXInd, yi, zi));
myIndices.AddFirst(getZ(myXInd, yi, zi));
}
}
addDualVertices(otherVerts, info.renderers[x, y + 1, z + 1], otherXInd, 0, 0, 0);
addDualVertices(otherVerts, info.renderers[x, y + 1, z - 1], otherXInd, 0, VERTEX_DIMENSION - 1, 0);
addDualVertices(otherVerts, info.renderers[x, y - 1, z + 1], otherXInd, VERTEX_DIMENSION - 1, 0, 0);
addDualVertices(otherVerts, info.renderers[x, y - 1, z - 1], otherXInd, VERTEX_DIMENSION - 1, VERTEX_DIMENSION - 1, 0);
for (int i = 0; i < VERTEX_DIMENSION; ++i)
{
addDualVertices(otherVerts, info.renderers[x, y, z + 1], otherXInd, i, 0, 0);
addDualVertices(otherVerts, info.renderers[x, y, z - 1], otherXInd, i, VERTEX_DIMENSION - 1, 0);
addDualVertices(otherVerts, info.renderers[x, y + 1, z], otherXInd, 0, i, 0);
addDualVertices(otherVerts, info.renderers[x, y - 1, z], otherXInd, VERTEX_DIMENSION - 1, i, 0);
}
}
else if (y != 1)
{
if (yDim < VERTEX_DIMENSION && y == 2)
{
return;
}
int otherYInd = 1 + (VERTEX_DIMENSION - 3) * (1 - y / 2);
int myYInd = (VERTEX_DIMENSION - 1) * (y / 2);
for (int xi = 1 - xExtend; xi < xDim; ++xi)
{
for (int zi = 1 - zExtend; zi < zDim; ++zi)
{
addDualVertices(otherVerts, info.renderers[x, y, z], xi, otherYInd, zi, 1);
myIndices.AddFirst(getX(xi, myYInd, zi));
myIndices.AddFirst(getZ(xi, myYInd, zi));
}
}
addDualVertices(otherVerts, info.renderers[x + 1, y, z + 1], 0, otherYInd, 0, 1);
addDualVertices(otherVerts, info.renderers[x + 1, y, z - 1], 0, otherYInd, VERTEX_DIMENSION - 1, 1);
addDualVertices(otherVerts, info.renderers[x - 1, y, z + 1], VERTEX_DIMENSION - 1, otherYInd, 0, 1);
addDualVertices(otherVerts, info.renderers[x - 1, y, z - 1], VERTEX_DIMENSION - 1, otherYInd, VERTEX_DIMENSION - 1, 1);
for (int i = 0; i < VERTEX_DIMENSION; ++i)
{
addDualVertices(otherVerts, info.renderers[x, y, z + 1], i, otherYInd, 0, 1);
addDualVertices(otherVerts, info.renderers[x, y, z - 1], i, otherYInd, VERTEX_DIMENSION - 1, 1);
addDualVertices(otherVerts, info.renderers[x + 1, y, z], 0, otherYInd, i, 1);
addDualVertices(otherVerts, info.renderers[x - 1, y, z], VERTEX_DIMENSION - 1, otherYInd, i, 1);
}
}
else if (z != 1)
{
if (zDim < VERTEX_DIMENSION && z == 2)
{
return;
}
int otherZInd = 1 + (VERTEX_DIMENSION - 3) * (1 - z / 2);
int myZInd = (VERTEX_DIMENSION - 1) * (z / 2);
for (int xi = 1 - xExtend; xi < xDim; ++xi)
{
for (int yi = 1 - yExtend; yi < yDim; ++yi)
{
addDualVertices(otherVerts, info.renderers[x, y, z], xi, yi, otherZInd, 2);
myIndices.AddFirst(getX(xi, yi, myZInd));
myIndices.AddFirst(getY(xi, yi, myZInd));
}
}
addDualVertices(otherVerts, info.renderers[x + 1, y + 1, z], 0, 0, otherZInd, 2);
addDualVertices(otherVerts, info.renderers[x + 1, y - 1, z], 0, VERTEX_DIMENSION - 1, otherZInd, 2);
addDualVertices(otherVerts, info.renderers[x - 1, y + 1, z], VERTEX_DIMENSION - 1, 0, otherZInd, 2);
addDualVertices(otherVerts, info.renderers[x - 1, y - 1, z], VERTEX_DIMENSION - 1, VERTEX_DIMENSION - 1, otherZInd, 2);
for (int i = 0; i < VERTEX_DIMENSION; ++i)
{
addDualVertices(otherVerts, info.renderers[x, y + 1, z], i, 0, otherZInd, 2);
addDualVertices(otherVerts, info.renderers[x, y - 1, z], i, VERTEX_DIMENSION - 1, otherZInd, 2);
addDualVertices(otherVerts, info.renderers[x + 1, y, z], 0, i, otherZInd, 2);
addDualVertices(otherVerts, info.renderers[x - 1, y, z], VERTEX_DIMENSION - 1, i, otherZInd, 2);
}
}
}
lock (control) {
foreach (int myIndex in myIndices)
{
if (vertices.ContainsKey(myIndex))
{
Vector3[] vertex = getClosestVertex(newVerts[(int)vertices[myIndex]], otherVerts);
if (vertex == null || (newVerts[(int)vertices[myIndex]] - vertex[0]).sqrMagnitude > Mathf.Pow(size / 4, 2))
{
continue;
}
newVerts[(int)vertices[myIndex]] = vertex[0];
newNorms[(int)vertices[myIndex]] = vertex[1];
}
}
}
VERTS = newVerts;
NORMS = newNorms;
}
public void removeEdge(VoxelUpdateInfo info, byte x, byte y, byte z)
{
if (vertices == null) return;
bool recalculate = false;
if (x == 0 && xExtend == 1) {
recalculate = true;
xExtend = 0;
for (byte yi = (byte)(1 - yExtend); yi < yDim; ++yi) {
for (byte zi = (byte)(1 - zExtend); zi < zDim; ++zi) {
vertices.Remove(getX(0, yi, zi));
vertices.Remove(getY(0, yi, zi));
vertices.Remove(getZ(0, yi, zi));
}
}
} else if (x == 2 && xDim >= VERTEX_DIMENSION) {
recalculate = true;
xDim = VERTEX_DIMENSION - 1;
for (byte yi = (byte)(1 - yExtend); yi < yDim; ++yi) {
for (byte zi = (byte)(1 - zExtend); zi < zDim; ++zi) {
vertices.Remove(getX(xDim - 1, yi, zi));
vertices.Remove(getY(xDim, yi, zi));
vertices.Remove(getZ(xDim, yi, zi));
}
}
} else if (y == 0 && yExtend == 1) {
recalculate = true;
yExtend = 0;
for (byte xi = (byte)(1 - xExtend); xi < xDim; ++xi) {
for (byte zi = (byte)(1 - zExtend); zi < zDim; ++zi) {
vertices.Remove(getX(xi, 0, zi));
vertices.Remove(getY(xi, 0, zi));
vertices.Remove(getZ(xi, 0, zi));
}
}
} else if (y == 2 && yDim >= VERTEX_DIMENSION) {
recalculate = true;
yDim = VERTEX_DIMENSION - 1;
for (byte xi = (byte)(1 - xExtend); xi < xDim; ++xi) {
for (byte zi = (byte)(1 - zExtend); zi < zDim; ++zi) {
vertices.Remove(getX(xi, yDim, zi));
vertices.Remove(getY(xi, yDim - 1, zi));
vertices.Remove(getZ(xi, yDim, zi));
}
}
} else if (z == 0 && zExtend == 1) {
recalculate = true;
zExtend = 0;
for (byte xi = (byte)(1 - xExtend); xi < xDim; ++xi) {
for (byte yi = (byte)(1 - yExtend); yi < yDim; ++yi) {
vertices.Remove(getX(xi, yi, 0));
vertices.Remove(getY(xi, yi, 0));
vertices.Remove(getZ(xi, yi, 0));
}
}
} else if (z == 2 && zDim >= VERTEX_DIMENSION) {
recalculate = true;
zDim = VERTEX_DIMENSION - 1;
for (byte xi = (byte)(1 - xExtend); xi < xDim; ++xi) {
for (byte yi = (byte)(1 - yExtend); yi < yDim; ++yi) {
vertices.Remove(getX(xi, yi, zDim));
vertices.Remove(getY(xi, yi, zDim));
vertices.Remove(getZ(xi, yi, zDim - 1));
}
}
}
if (recalculate) {
List<KeyValuePair<int, object>> vertexList = new List<KeyValuePair<int, object>>(vertices);
int[] oldTris = TRIS;
Vector3[] oldVerts = VERTS;
Vector3[] oldNorms = NORMS;
List<int> newTris = new List<int>(TRIS.Length);
Vector3[] newVerts = new Vector3[vertexList.Count];
Vector3[] newNorms = new Vector3[newVerts.Length];
object[] oldReverseIndices = new object[oldVerts.Length];
int count = 0;
foreach (KeyValuePair<int, object> pair in vertexList) {
int oldIndex = (int)pair.Value;
vertices[pair.Key] = count;
newVerts[count] = oldVerts[oldIndex];
newNorms[count] = oldNorms[oldIndex];
oldReverseIndices[oldIndex] = pair.Key;
++count;
}
int[] triangle = new int[3];
for (int i = 0; i < oldTris.Length; i += 3) {
bool old = false;
for (int j = 0; j < 3; ++j) {
object newIndex = oldReverseIndices[oldTris[i + j]];
if (newIndex == null) {
old = true;
break;
}
triangle[j] = (int)vertices[(int)newIndex];
}
if (old) continue;
newTris.AddRange(triangle);
}
VERTS = newVerts;
NORMS = newNorms;
TRIS = newTris.ToArray();
control.enqueueMeshApply(new ApplyMeshJob(this, info.detailLevel, info.x, info.y, info.z));
}
}
private void setDimensions(VoxelUpdateInfo info)
{
if (info.renderers[0, 1, 1] == null)
xExtend = 0;
else
xExtend = 1;
if (info.renderers[1, 0, 1] == null)
yExtend = 0;
else
yExtend = 1;
if (info.renderers[1, 1, 0] == null)
zExtend = 0;
else
zExtend = 1;
xDim = (byte)(VOXEL_DIMENSION + 1);
yDim = (byte)(VOXEL_DIMENSION + 1);
zDim = (byte)(VOXEL_DIMENSION + 1);
if (info.renderers[2, 1, 1] != null && info.renderers[2, 1, 1].size > size * 1.1f)
++xDim;
if (info.renderers[1, 2, 1] != null && info.renderers[1, 2, 1].size > size * 1.1f)
++yDim;
if (info.renderers[1, 1, 2] != null && info.renderers[1, 1, 2].size > size * 1.1f)
++zDim;
}
public void addEdge(VoxelUpdateInfo info, byte x, byte y, byte z)
{
if (vertices == null) return;
bool recalculate = false;
Voxel[, ,] voxels = new Voxel[VERTEX_DIMENSION, VERTEX_DIMENSION, VERTEX_DIMENSION];
if (x == 0/* && xExtend == 0*/) {
recalculate = true;
xExtend = 1;
for (byte yi = (byte)(1 - yExtend); yi < yDim; ++yi) {
for (byte zi = (byte)(1 - zExtend); zi < zDim; ++zi) {
voxels[0, yi, zi] = info.getSub(VOXEL_COUNT_POWER, VOXEL_DIMENSION - xExtend, VOXEL_DIMENSION - 1 + yi, VOXEL_DIMENSION - 1 + zi).toVoxel();
voxels[1, yi, zi] = info.getSub(VOXEL_COUNT_POWER, VOXEL_DIMENSION, VOXEL_DIMENSION - 1 + yi, VOXEL_DIMENSION - 1 + zi).toVoxel();
}
}
} else if (x == 2/* && xDim < VERTEX_DIMENSION*/) {
recalculate = true;
xDim = VERTEX_DIMENSION;
for (byte yi = (byte)(1 - yExtend); yi < yDim; ++yi) {
for (byte zi = (byte)(1 - zExtend); zi < zDim; ++zi) {
voxels[VOXEL_DIMENSION + 1, yi, zi] = info.getSub(VOXEL_COUNT_POWER, VOXEL_DIMENSION * 2, VOXEL_DIMENSION - 1 + yi, VOXEL_DIMENSION - 1 + zi).toVoxel();
voxels[VOXEL_DIMENSION, yi, zi] = info.getSub(VOXEL_COUNT_POWER, VOXEL_DIMENSION * 2 - 1, VOXEL_DIMENSION - 1 + yi, VOXEL_DIMENSION - 1 + zi).toVoxel();
}
}
} else if (y == 0/* && yExtend == 0*/) {
recalculate = true;
yExtend = 1;
for (byte xi = (byte)(1 - xExtend); xi < xDim; ++xi) {
for (byte zi = (byte)(1 - zExtend); zi < zDim; ++zi) {
voxels[xi, 0, zi] = info.getSub(VOXEL_COUNT_POWER, VOXEL_DIMENSION - 1 + xi, VOXEL_DIMENSION - yExtend, VOXEL_DIMENSION - 1 + zi).toVoxel();
voxels[xi, 1, zi] = info.getSub(VOXEL_COUNT_POWER, VOXEL_DIMENSION - 1 + xi, VOXEL_DIMENSION, VOXEL_DIMENSION - 1 + zi).toVoxel();
}
}
} else if (y == 2/* && yDim < VERTEX_DIMENSION*/) {
recalculate = true;
yDim = VERTEX_DIMENSION;
for (byte xi = (byte)(1 - xExtend); xi < xDim; ++xi) {
for (byte zi = (byte)(1 - zExtend); zi < zDim; ++zi) {
voxels[xi, VOXEL_DIMENSION + 1, zi] = info.getSub(VOXEL_COUNT_POWER, VOXEL_DIMENSION - 1 + xi, VOXEL_DIMENSION * 2, VOXEL_DIMENSION - 1 + zi).toVoxel();
voxels[xi, VOXEL_DIMENSION, zi] = info.getSub(VOXEL_COUNT_POWER, VOXEL_DIMENSION - 1 + xi, VOXEL_DIMENSION * 2 - 1, VOXEL_DIMENSION - 1 + zi).toVoxel();
}
}
} else if (z == 0/* && zExtend == 0*/) {
recalculate = true;
zExtend = 1;
for (byte xi = (byte)(1 - xExtend); xi < xDim; ++xi) {
for (byte yi = (byte)(1 - yExtend); yi < yDim; ++yi) {
voxels[xi, yi, 0] = info.getSub(VOXEL_COUNT_POWER, VOXEL_DIMENSION - 1 + xi, VOXEL_DIMENSION - 1 + yi, VOXEL_DIMENSION - zExtend).toVoxel();
voxels[xi, yi, 1] = info.getSub(VOXEL_COUNT_POWER, VOXEL_DIMENSION - 1 + xi, VOXEL_DIMENSION - 1 + yi, VOXEL_DIMENSION).toVoxel();
}
}
} else if (z == 2/* && zDim < VERTEX_DIMENSION*/) {
recalculate = true;
zDim = VERTEX_DIMENSION;
for (byte xi = (byte)(1 - xExtend); xi < xDim; ++xi) {
for (byte yi = (byte)(1 - yExtend); yi < yDim; ++yi) {
voxels[xi, yi, VOXEL_DIMENSION + 1] = info.getSub(VOXEL_COUNT_POWER, VOXEL_DIMENSION - 1 + xi, VOXEL_DIMENSION - 1 + yi, VOXEL_DIMENSION * 2).toVoxel();
voxels[xi, yi, VOXEL_DIMENSION] = info.getSub(VOXEL_COUNT_POWER, VOXEL_DIMENSION - 1 + xi, VOXEL_DIMENSION - 1 + yi, VOXEL_DIMENSION * 2 - 1).toVoxel();
}
}
}
if (recalculate) {
Queue<int[]> triangleSet = new Queue<int[]>();
MarchingCubes.setup(info.size / VOXEL_DIMENSION, control.isoLevel, ref vertices, ref vertexSubstances, ref voxels, position - new Vector3(0.5f, 0.5f, 0.5f) * size / VOXEL_DIMENSION, VERTS);
byte xStart = (byte)(1 - xExtend + (VOXEL_DIMENSION + xExtend - 1) * (x / 2));
byte xEnd = (byte)(2 + (xDim - 2) * ((x + 1) / 2));
byte yStart = (byte)(1 - yExtend + (VOXEL_DIMENSION + yExtend - 1) * (y / 2));
byte yEnd = (byte)(2 + (yDim - 2) * ((y + 1) / 2));
byte zStart = (byte)(1 - zExtend + (VOXEL_DIMENSION + zExtend - 1) * (z / 2));
byte zEnd = (byte)(2 + (zDim - 2) * ((z + 1) / 2));
for (byte xi = xStart, x1 = (byte)(xi + 1); x1 < xEnd; xi = x1++) {
for (byte yi = yStart, y1 = (byte)(yi + 1); y1 < yEnd; yi = y1++) {
for (byte zi = zStart, z1 = (byte)(zi + 1); z1 < zEnd; zi = z1++) {
int[] tris = MarchingCubes.lookupTriangles(xi, yi, zi, x1, y1, z1);
if (tris == null) continue;
triangleSet.Enqueue(tris);
}
}
}
if (vertices.Count < 1) {
return;
}
List<int> newTriangles = new List<int>(TRIS);
List<Vector3> newVertices = new List<Vector3>(VERTS);
List<Vector3> newNorms = new List<Vector3>(NORMS);
int tri = 0;
while (triangleSet.Count > 0) {
int[] triangleList = triangleSet.Dequeue();
for (int i = 0; i < triangleList.Length; ++i) {
if (vertices[triangleList[i]].GetType() == typeof(Vector3)) {
newVertices.Add((Vector3)vertices[triangleList[i]]);
newNorms.Add(Vector3.zero);
vertices[triangleList[i]] = newVertices.Count - 1;
}
newTriangles.Add((int)vertices[triangleList[i]]);
}
tri += triangleList.Length;
}
Vector3[] finalNorms = new Vector3[newNorms.Count];
Array.Copy(NORMS, finalNorms, NORMS.Length);
int oldNormCount = NORMS.Length;
VERTS = newVertices.ToArray();
TRIS = newTriangles.ToArray();
calcNorms();
Array.Copy(NORMS, oldNormCount, finalNorms, oldNormCount, finalNorms.Length - oldNormCount);
NORMS = finalNorms;
}
alignEdge(info, x, y, z);
control.enqueueMeshApply(new ApplyMeshJob(this, info.detailLevel, info.x, info.y, info.z));
}
//private static int getX(int index, int dimension) {
// return (y * VERTEX_DIMENSION + z) * VERTEX_DIMENSION + x;
//}
//private static int getY(int index, int dimension) {
// return ((VERTEX_DIMENSION + x) * VERTEX_DIMENSION + z) * VERTEX_DIMENSION + y;
//}
//private static int getZ(int index, int dimension) {
// return ((VERTEX_DIMENSION * 2 + x) * VERTEX_DIMENSION + y) * VERTEX_DIMENSION + z;
//}
//private static int getDimension(int index) {
// return index / (VERTEX_DIMENSION * VERTEX_DIMENSION * VERTEX_DIMENSION);
//}
private Voxel[, ,] createVoxelArray(VoxelUpdateInfo info)
{
setDimensions(info);
Voxel[, ,] voxels = new Voxel[VERTEX_DIMENSION, VERTEX_DIMENSION, VERTEX_DIMENSION];
for (byte y = (byte)(1 - yExtend); y < yDim; ++y) {
for (byte z = (byte)(1 - zExtend); z < zDim; ++z) {
voxels[1 - xExtend, y, z] = info.getSub(VOXEL_COUNT_POWER, VOXEL_DIMENSION - xExtend, VOXEL_DIMENSION - 1 + y, VOXEL_DIMENSION - 1 + z).toVoxel();
}
}
for (byte x = (byte)(2 - xExtend); x < xDim; ++x) {
for (byte z = (byte)(1 - zExtend); z < zDim; ++z) {
voxels[x, 1 - yExtend, z] = info.getSub(VOXEL_COUNT_POWER, VOXEL_DIMENSION - 1 + x, VOXEL_DIMENSION - yExtend, VOXEL_DIMENSION - 1 + z).toVoxel();
}
}
for (byte x = (byte)(2 - xExtend); x < xDim; ++x) {
for (byte y = (byte)(2 - yExtend); y < yDim; ++y) {
voxels[x, y, 1 - zExtend] = info.getSub(VOXEL_COUNT_POWER, VOXEL_DIMENSION - 1 + x, VOXEL_DIMENSION - 1 + y, VOXEL_DIMENSION - zExtend).toVoxel();
}
}
return voxels;
}
private void alignEdge(VoxelUpdateInfo info, byte x, byte y, byte z)
{
if (info.renderers[x, y, z] == null || (x + y + z > 3 && info.renderers[x, y, z].size == size)) {
lock (control) {
VoxelUpdateInfo newInfo = new VoxelUpdateInfo(info.size, info.blocks[1, 1, 1], info.control);
newInfo.setFromSister(info, x, y, z);
alignOtherEdge(newInfo, x, y, z);
}
return;
}
lock (control) {
info.renderers[x, y, z].removeEdge(info, (byte)(2 - x), (byte)(2 - y), (byte)(2 - z));
}
Vector3[] newVerts = VERTS;
LinkedList<int> myIndices = new LinkedList<int>();
LinkedList<Vector3[]> otherVerts = new LinkedList<Vector3[]>();
Vector3[] newNorms = NORMS;
lock (control) {
if (x != 1) {
if (xDim < VERTEX_DIMENSION && x == 2) return;
int otherXInd = 1 + (VERTEX_DIMENSION - 3) * (1 - x / 2);
int myXInd = (VERTEX_DIMENSION - 1) * (x / 2);
for (int yi = 1 - yExtend; yi < yDim; ++yi) {
for (int zi = 1 - zExtend; zi < zDim; ++zi) {
addDualVertices(otherVerts, info.renderers[x, y, z], otherXInd, yi, zi, 0);
myIndices.AddFirst(getY(myXInd, yi, zi));
myIndices.AddFirst(getZ(myXInd, yi, zi));
}
}
addDualVertices(otherVerts, info.renderers[x, y + 1, z + 1], otherXInd, 0, 0, 0);
addDualVertices(otherVerts, info.renderers[x, y + 1, z - 1], otherXInd, 0, VERTEX_DIMENSION - 1, 0);
addDualVertices(otherVerts, info.renderers[x, y - 1, z + 1], otherXInd, VERTEX_DIMENSION - 1, 0, 0);
addDualVertices(otherVerts, info.renderers[x, y - 1, z - 1], otherXInd, VERTEX_DIMENSION - 1, VERTEX_DIMENSION - 1, 0);
for (int i = 0; i < VERTEX_DIMENSION; ++i) {
addDualVertices(otherVerts, info.renderers[x, y, z + 1], otherXInd, i, 0, 0);
addDualVertices(otherVerts, info.renderers[x, y, z - 1], otherXInd, i, VERTEX_DIMENSION - 1, 0);
addDualVertices(otherVerts, info.renderers[x, y + 1, z], otherXInd, 0, i, 0);
addDualVertices(otherVerts, info.renderers[x, y - 1, z], otherXInd, VERTEX_DIMENSION - 1, i, 0);
}
} else if (y != 1) {
if (yDim < VERTEX_DIMENSION && y == 2) return;
int otherYInd = 1 + (VERTEX_DIMENSION - 3) * (1 - y / 2);
int myYInd = (VERTEX_DIMENSION - 1) * (y / 2);
for (int xi = 1 - xExtend; xi < xDim; ++xi) {
for (int zi = 1 - zExtend; zi < zDim; ++zi) {
addDualVertices(otherVerts, info.renderers[x, y, z], xi, otherYInd, zi, 1);
myIndices.AddFirst(getX(xi, myYInd, zi));
myIndices.AddFirst(getZ(xi, myYInd, zi));
}
}
addDualVertices(otherVerts, info.renderers[x + 1, y, z + 1], 0, otherYInd, 0, 1);
addDualVertices(otherVerts, info.renderers[x + 1, y, z - 1], 0, otherYInd, VERTEX_DIMENSION - 1, 1);
addDualVertices(otherVerts, info.renderers[x - 1, y, z + 1], VERTEX_DIMENSION - 1, otherYInd, 0, 1);
addDualVertices(otherVerts, info.renderers[x - 1, y, z - 1], VERTEX_DIMENSION - 1, otherYInd, VERTEX_DIMENSION - 1, 1);
for (int i = 0; i < VERTEX_DIMENSION; ++i) {
addDualVertices(otherVerts, info.renderers[x, y, z + 1], i, otherYInd, 0, 1);
addDualVertices(otherVerts, info.renderers[x, y, z - 1], i, otherYInd, VERTEX_DIMENSION - 1, 1);
addDualVertices(otherVerts, info.renderers[x + 1, y, z], 0, otherYInd, i, 1);
addDualVertices(otherVerts, info.renderers[x - 1, y, z], VERTEX_DIMENSION - 1, otherYInd, i, 1);
}
} else if (z != 1) {
if (zDim < VERTEX_DIMENSION && z == 2) return;
int otherZInd = 1 + (VERTEX_DIMENSION - 3) * (1 - z / 2);
int myZInd = (VERTEX_DIMENSION - 1) * (z / 2);
for (int xi = 1 - xExtend; xi < xDim; ++xi) {
for (int yi = 1 - yExtend; yi < yDim; ++yi) {
addDualVertices(otherVerts, info.renderers[x, y, z], xi, yi, otherZInd, 2);
myIndices.AddFirst(getX(xi, yi, myZInd));
myIndices.AddFirst(getY(xi, yi, myZInd));
}
}
addDualVertices(otherVerts, info.renderers[x + 1, y + 1, z], 0, 0, otherZInd, 2);
addDualVertices(otherVerts, info.renderers[x + 1, y - 1, z], 0, VERTEX_DIMENSION - 1, otherZInd, 2);
addDualVertices(otherVerts, info.renderers[x - 1, y + 1, z], VERTEX_DIMENSION - 1, 0, otherZInd, 2);
addDualVertices(otherVerts, info.renderers[x - 1, y - 1, z], VERTEX_DIMENSION - 1, VERTEX_DIMENSION - 1, otherZInd, 2);
for (int i = 0; i < VERTEX_DIMENSION; ++i) {
addDualVertices(otherVerts, info.renderers[x, y + 1, z], i, 0, otherZInd, 2);
addDualVertices(otherVerts, info.renderers[x, y - 1, z], i, VERTEX_DIMENSION - 1, otherZInd, 2);
addDualVertices(otherVerts, info.renderers[x + 1, y, z], 0, i, otherZInd, 2);
addDualVertices(otherVerts, info.renderers[x - 1, y, z], VERTEX_DIMENSION - 1, i, otherZInd, 2);
}
}
}
lock (control) {
foreach (int myIndex in myIndices) {
if (vertices.ContainsKey(myIndex)) {
Vector3[] vertex = getClosestVertex(newVerts[(int)vertices[myIndex]], otherVerts);
if (vertex == null || (newVerts[(int)vertices[myIndex]] -vertex[0]).sqrMagnitude > Mathf.Pow(size /4, 2))
continue;
newVerts[(int)vertices[myIndex]] = vertex[0];
newNorms[(int)vertices[myIndex]] = vertex[1];
}
}
}
VERTS = newVerts;
NORMS = newNorms;
}
