private bool ExpandZ(ChunkBlocks blocks, ref bool[] mask, Block block, int x1, int y1, int x2, int y2, ref int z2) { int sizeWithPadding = sideSize + Env.CHUNK_PADDING_2; int sizeWithPaddingPow2 = sizeWithPadding * sizeWithPadding; int yOffset = sizeWithPaddingPow2 - x2 + x1; int index0 = Helpers.GetChunkIndex1DFrom3D(x1, y1, z2, pow); // Check the quad formed by XY axes and try to expand the Z axis int index = index0; for (int y = y1; y < y2; ++y, index += yOffset) { for (int x = x1; x < x2; ++x, ++index) { if (mask[index] || !CanCreateBox(block, blocks.GetBlock(index))) { return(false); } } } // If the box can expand, mark the position as tested and expand the X axis index = index0; for (int y = y1; y < y2; ++y, index += yOffset) { for (int x = x1; x < x2; ++x, ++index) { mask[index] = true; } } ++z2; return(true); }
protected override void BuildBox(Chunk chunk, Block block, int minX, int minY, int minZ, int maxX, int maxY, int maxZ) { // Order of vertices when building faces: // 1--2 // | | // | | // 0--3 int sizeWithPadding = sideSize + Env.CHUNK_PADDING_2; int sizeWithPaddingPow2 = sizeWithPadding * sizeWithPadding; LocalPools pools = Globals.WorkPool.GetPool(chunk.ThreadID); ChunkBlocks blocks = chunk.Blocks; Chunk[] listeners = chunk.Neighbors; // Custom blocks have their own rules if (block.custom) { for (int yy = minY; yy < maxY; yy++) { for (int zz = minZ; zz < maxZ; zz++) { for (int xx = minX; xx < maxX; xx++) { Vector3Int pos = new Vector3Int(xx, yy, zz); block.BuildBlock(chunk, ref pos, block.renderMaterialID); } } } return; } int n, w, h, l, k, maskIndex; Vector3Int texturePos = new Vector3Int(minX, minY, minZ); Vector3[] face = pools.vector3ArrayPool.PopExact(4); BlockFace[] mask = pools.blockFaceArrayPool.PopExact(sideSize * sideSize); #region Top face if (listeners[(int)Direction.up] != null || // Don't render faces on world's edges for chunks with no neighbor (SideMask & Side.up) == 0 || maxY != sideSize) { Array.Clear(mask, 0, mask.Length); // x axis - width // z axis - height int neighborIndex = Helpers.GetChunkIndex1DFrom3D(minX, maxY, minZ, pow); int zOffset = sizeWithPadding - maxX + minX; // Build the mask for (int zz = minZ; zz < maxZ; ++zz, neighborIndex += zOffset) { n = minX + zz * sideSize; for (int xx = minX; xx < maxX; ++xx, ++n, ++neighborIndex) { int currentIndex = neighborIndex - sizeWithPaddingPow2; // (xx, maxY-1, zz); Block neighborBlock = blocks.GetBlock(neighborIndex); // Let's see whether we can merge faces if (block.CanBuildFaceWith(neighborBlock)) { mask[n] = new BlockFace { block = block, pos = texturePos, side = Direction.up, light = BlockUtils.CalculateColors(chunk, currentIndex, Direction.up), materialID = block.renderMaterialID }; } } } // Build faces from the mask if it's possible for (int zz = minZ; zz < maxZ; ++zz) { n = minX + zz * sideSize; for (int xx = minX; xx < maxX;) { if (mask[n].block == null) { ++xx; ++n; continue; } // Compute width and height w = 1; h = 1; // Build the face bool rotated = mask[n].light.FaceRotationNecessary; if (!rotated) { face[0] = new Vector3(xx, maxY, zz) * scale + BlockUtils.paddingOffsets[(int)Direction.up][0]; face[1] = new Vector3(xx, maxY, zz + h) * scale + BlockUtils.paddingOffsets[(int)Direction.up][1]; face[2] = new Vector3(xx + w, maxY, zz + h) * scale + BlockUtils.paddingOffsets[(int)Direction.up][2]; face[3] = new Vector3(xx + w, maxY, zz) * scale + BlockUtils.paddingOffsets[(int)Direction.up][3]; } else { face[0] = new Vector3(xx, maxY, zz + h) * scale + BlockUtils.paddingOffsets[(int)Direction.up][1]; face[1] = new Vector3(xx + w, maxY, zz + h) * scale + BlockUtils.paddingOffsets[(int)Direction.up][2]; face[2] = new Vector3(xx + w, maxY, zz) * scale + BlockUtils.paddingOffsets[(int)Direction.up][3]; face[3] = new Vector3(xx, maxY, zz) * scale + BlockUtils.paddingOffsets[(int)Direction.up][0]; } block.BuildFace(chunk, face, Palette, ref mask[n], rotated); // Zero out the mask. We don't need to process the same fields again for (l = 0; l < h; ++l) { maskIndex = n + l * sideSize; for (k = 0; k < w; ++k, ++maskIndex) { mask[maskIndex] = new BlockFace(); } } xx += w; n += w; } } } #endregion #region Bottom face if (listeners[(int)Direction.down] != null || // Don't render faces on world's edges for chunks with no neighbor (SideMask & Side.down) == 0 || minY != 0) { Array.Clear(mask, 0, mask.Length); // x axis - width // z axis - height int currentIndex = Helpers.GetChunkIndex1DFrom3D(minX, minY, minZ, pow); int zOffset = sizeWithPadding - maxX + minX; // Build the mask for (int zz = minZ; zz < maxZ; ++zz, currentIndex += zOffset) { n = minX + zz * sideSize; for (int xx = minX; xx < maxX; ++xx, ++n, ++currentIndex) { int neighborIndex = currentIndex - sizeWithPaddingPow2; Block neighborBlock = blocks.GetBlock(neighborIndex); // Let's see whether we can merge faces if (block.CanBuildFaceWith(neighborBlock)) { mask[n] = new BlockFace { block = block, pos = texturePos, side = Direction.down, light = BlockUtils.CalculateColors(chunk, currentIndex, Direction.down), materialID = block.renderMaterialID }; } } } // Build faces from the mask if it's possible for (int zz = minZ; zz < maxZ; ++zz) { n = minX + zz * sideSize; for (int xx = minX; xx < maxX;) { if (mask[n].block == null) { ++xx; ++n; continue; } // Compute width and height w = 1; h = 1; // Build the face bool rotated = mask[n].light.FaceRotationNecessary; if (!rotated) { face[0] = new Vector3(xx, minY, zz) * scale + BlockUtils.paddingOffsets[(int)Direction.down][0]; face[1] = new Vector3(xx, minY, zz + h) * scale + BlockUtils.paddingOffsets[(int)Direction.down][1]; face[2] = new Vector3(xx + w, minY, zz + h) * scale + BlockUtils.paddingOffsets[(int)Direction.down][2]; face[3] = new Vector3(xx + w, minY, zz) * scale + BlockUtils.paddingOffsets[(int)Direction.down][3]; } else { face[0] = new Vector3(xx, minY, zz + h) * scale + BlockUtils.paddingOffsets[(int)Direction.down][1]; face[1] = new Vector3(xx + w, minY, zz + h) * scale + BlockUtils.paddingOffsets[(int)Direction.down][2]; face[2] = new Vector3(xx + w, minY, zz) * scale + BlockUtils.paddingOffsets[(int)Direction.down][3]; face[3] = new Vector3(xx, minY, zz) * scale + BlockUtils.paddingOffsets[(int)Direction.down][0]; } block.BuildFace(chunk, face, Palette, ref mask[n], rotated); // Zero out the mask. We don't need to process the same fields again for (l = 0; l < h; ++l) { maskIndex = n + l * sideSize; for (k = 0; k < w; ++k, ++maskIndex) { mask[maskIndex] = new BlockFace(); } } xx += w; n += w; } } } #endregion #region Right face if (listeners[(int)Direction.east] != null || // Don't render faces on world's edges for chunks with no neighbor (SideMask & Side.east) == 0 || maxX != sideSize) { Array.Clear(mask, 0, mask.Length); // y axis - height // z axis - width int neighborIndex = Helpers.GetChunkIndex1DFrom3D(maxX, minY, minZ, pow); int yOffset = sizeWithPaddingPow2 - (maxZ - minZ) * sizeWithPadding; // Build the mask for (int yy = minY; yy < maxY; ++yy, neighborIndex += yOffset) { n = minZ + yy * sideSize; for (int zz = minZ; zz < maxZ; ++zz, ++n, neighborIndex += sizeWithPadding) { int currentIndex = neighborIndex - 1; Block neighborBlock = blocks.GetBlock(neighborIndex); // Let's see whether we can merge faces if (block.CanBuildFaceWith(neighborBlock)) { mask[n] = new BlockFace { block = block, pos = texturePos, side = Direction.east, light = BlockUtils.CalculateColors(chunk, currentIndex, Direction.east), materialID = block.renderMaterialID }; } } } // Build faces from the mask if it's possible for (int yy = minY; yy < maxY; ++yy) { n = minZ + yy * sideSize; for (int zz = minZ; zz < maxZ;) { if (mask[n].block == null) { ++zz; ++n; continue; } // Compute width and height w = 1; h = 1; // Build the face bool rotated = mask[n].light.FaceRotationNecessary; if (!rotated) { face[0] = new Vector3(maxX, yy, zz) * scale + BlockUtils.paddingOffsets[(int)Direction.east][0]; face[1] = new Vector3(maxX, yy + h, zz) * scale + BlockUtils.paddingOffsets[(int)Direction.east][1]; face[2] = new Vector3(maxX, yy + h, zz + w) * scale + BlockUtils.paddingOffsets[(int)Direction.east][2]; face[3] = new Vector3(maxX, yy, zz + w) * scale + BlockUtils.paddingOffsets[(int)Direction.east][3]; } else { face[0] = new Vector3(maxX, yy + h, zz) * scale + BlockUtils.paddingOffsets[(int)Direction.east][1]; face[1] = new Vector3(maxX, yy + h, zz + w) * scale + BlockUtils.paddingOffsets[(int)Direction.east][2]; face[2] = new Vector3(maxX, yy, zz + w) * scale + BlockUtils.paddingOffsets[(int)Direction.east][3]; face[3] = new Vector3(maxX, yy, zz) * scale + BlockUtils.paddingOffsets[(int)Direction.east][0]; } block.BuildFace(chunk, face, Palette, ref mask[n], rotated); // Zero out the mask. We don't need to process the same fields again for (l = 0; l < h; ++l) { maskIndex = n + l * sideSize; for (k = 0; k < w; ++k, ++maskIndex) { mask[maskIndex] = new BlockFace(); } } zz += w; n += w; } } } #endregion #region Left face if (listeners[(int)Direction.west] != null || // Don't render faces on world's edges for chunks with no neighbor (SideMask & Side.west) == 0 || minX != 0) { Array.Clear(mask, 0, mask.Length); // y axis - height // z axis - width int currentIndex = Helpers.GetChunkIndex1DFrom3D(minX, minY, minZ, pow); int yOffset = sizeWithPaddingPow2 - (maxZ - minZ) * sizeWithPadding; // Build the mask for (int yy = minY; yy < maxY; ++yy, currentIndex += yOffset) { n = minZ + yy * sideSize; for (int zz = minZ; zz < maxZ; ++zz, ++n, currentIndex += sizeWithPadding) { int neighborIndex = currentIndex - 1; Block neighborBlock = blocks.GetBlock(neighborIndex); // Let's see whether we can merge faces if (block.CanBuildFaceWith(neighborBlock)) { mask[n] = new BlockFace { block = block, pos = texturePos, side = Direction.west, light = BlockUtils.CalculateColors(chunk, currentIndex, Direction.west), materialID = block.renderMaterialID }; } } } // Build faces from the mask if it's possible for (int yy = minY; yy < maxY; ++yy) { n = minZ + yy * sideSize; for (int zz = minZ; zz < maxZ;) { if (mask[n].block == null) { ++zz; ++n; continue; } // Compute width and height w = 1; h = 1; // Build the face bool rotated = mask[n].light.FaceRotationNecessary; if (!rotated) { face[0] = new Vector3(minX, yy, zz) * scale + BlockUtils.paddingOffsets[(int)Direction.west][0]; face[1] = new Vector3(minX, yy + h, zz) * scale + BlockUtils.paddingOffsets[(int)Direction.west][1]; face[2] = new Vector3(minX, yy + h, zz + w) * scale + BlockUtils.paddingOffsets[(int)Direction.west][2]; face[3] = new Vector3(minX, yy, zz + w) * scale + BlockUtils.paddingOffsets[(int)Direction.west][3]; } else { face[0] = new Vector3(minX, yy + h, zz) * scale + BlockUtils.paddingOffsets[(int)Direction.west][1]; face[1] = new Vector3(minX, yy + h, zz + w) * scale + BlockUtils.paddingOffsets[(int)Direction.west][2]; face[2] = new Vector3(minX, yy, zz + w) * scale + BlockUtils.paddingOffsets[(int)Direction.west][3]; face[3] = new Vector3(minX, yy, zz) * scale + BlockUtils.paddingOffsets[(int)Direction.west][0]; } block.BuildFace(chunk, face, Palette, ref mask[n], rotated); // Zero out the mask. We don't need to process the same fields again for (l = 0; l < h; ++l) { maskIndex = n + l * sideSize; for (k = 0; k < w; ++k, ++maskIndex) { mask[maskIndex] = new BlockFace(); } } zz += w; n += w; } } } #endregion #region Front face if (listeners[(int)Direction.north] != null || // Don't render faces on world's edges for chunks with no neighbor (SideMask & Side.north) == 0 || maxZ != sideSize) { Array.Clear(mask, 0, mask.Length); // x axis - width // y axis - height int neighborIndex = Helpers.GetChunkIndex1DFrom3D(minX, minY, maxZ, pow); int yOffset = sizeWithPaddingPow2 - maxX + minX; // Build the mask for (int yy = minY; yy < maxY; ++yy, neighborIndex += yOffset) { n = minX + yy * sideSize; for (int xx = minX; xx < maxX; ++xx, ++n, ++neighborIndex) { int currentIndex = neighborIndex - sizeWithPadding; Block neighborBlock = blocks.GetBlock(neighborIndex); // Let's see whether we can merge faces if (block.CanBuildFaceWith(neighborBlock)) { mask[n] = new BlockFace { block = block, pos = texturePos, side = Direction.north, light = BlockUtils.CalculateColors(chunk, currentIndex, Direction.north), materialID = block.renderMaterialID }; } } } // Build faces from the mask if it's possible for (int yy = minY; yy < maxY; ++yy) { n = minX + yy * sideSize; for (int xx = minX; xx < maxX;) { if (mask[n].block == null) { ++xx; ++n; continue; } // Compute width and height w = 1; h = 1; // Build the face bool rotated = mask[n].light.FaceRotationNecessary; if (!rotated) { face[0] = new Vector3(xx, yy, maxZ) * scale + BlockUtils.paddingOffsets[(int)Direction.north][0]; face[1] = new Vector3(xx, yy + h, maxZ) * scale + BlockUtils.paddingOffsets[(int)Direction.north][1]; face[2] = new Vector3(xx + w, yy + h, maxZ) * scale + BlockUtils.paddingOffsets[(int)Direction.north][2]; face[3] = new Vector3(xx + w, yy, maxZ) * scale + BlockUtils.paddingOffsets[(int)Direction.north][3]; } else { face[0] = new Vector3(xx, yy + h, maxZ) * scale + BlockUtils.paddingOffsets[(int)Direction.north][1]; face[1] = new Vector3(xx + w, yy + h, maxZ) * scale + BlockUtils.paddingOffsets[(int)Direction.north][2]; face[2] = new Vector3(xx + w, yy, maxZ) * scale + BlockUtils.paddingOffsets[(int)Direction.north][3]; face[3] = new Vector3(xx, yy, maxZ) * scale + BlockUtils.paddingOffsets[(int)Direction.north][0]; } block.BuildFace(chunk, face, Palette, ref mask[n], rotated); // Zero out the mask. We don't need to process the same fields again for (l = 0; l < h; ++l) { maskIndex = n + l * sideSize; for (k = 0; k < w; ++k, ++maskIndex) { mask[maskIndex] = new BlockFace(); } } xx += w; n += w; } } } #endregion #region Back face if (listeners[(int)Direction.south] != null || // Don't render faces on world's edges for chunks with no neighbor (SideMask & Side.south) == 0 || minZ != 0) { Array.Clear(mask, 0, mask.Length); // x axis - width // y axis - height int currentIndex = Helpers.GetChunkIndex1DFrom3D(minX, minY, minZ, pow); int yOffset = sizeWithPaddingPow2 - maxX + minX; // Build the mask for (int yy = minY; yy < maxY; ++yy, currentIndex += yOffset) { n = minX + yy * sideSize; for (int xx = minX; xx < maxX; ++xx, ++n, ++currentIndex) { int neighborIndex = currentIndex - sizeWithPadding; Block neighborBlock = blocks.GetBlock(neighborIndex); // Let's see whether we can merge faces if (block.CanBuildFaceWith(neighborBlock)) { mask[n] = new BlockFace { block = block, pos = texturePos, side = Direction.south, light = BlockUtils.CalculateColors(chunk, currentIndex, Direction.south), materialID = block.renderMaterialID }; } } } // Build faces from the mask if it's possible for (int yy = minY; yy < maxY; ++yy) { n = minX + yy * sideSize; for (int xx = minX; xx < maxX;) { if (mask[n].block == null) { ++xx; ++n; continue; } // Compute width and height w = 1; h = 1; // Build the face bool rotated = mask[n].light.FaceRotationNecessary; if (!rotated) { face[0] = new Vector3(xx, yy, minZ) * scale + BlockUtils.paddingOffsets[(int)Direction.south][0]; face[1] = new Vector3(xx, yy + h, minZ) * scale + BlockUtils.paddingOffsets[(int)Direction.south][1]; face[2] = new Vector3(xx + w, yy + h, minZ) * scale + BlockUtils.paddingOffsets[(int)Direction.south][2]; face[3] = new Vector3(xx + w, yy, minZ) * scale + BlockUtils.paddingOffsets[(int)Direction.south][3]; } else { face[0] = new Vector3(xx, yy + h, minZ) * scale + BlockUtils.paddingOffsets[(int)Direction.south][1]; face[1] = new Vector3(xx + w, yy + h, minZ) * scale + BlockUtils.paddingOffsets[(int)Direction.south][2]; face[2] = new Vector3(xx + w, yy, minZ) * scale + BlockUtils.paddingOffsets[(int)Direction.south][3]; face[3] = new Vector3(xx, yy, minZ) * scale + BlockUtils.paddingOffsets[(int)Direction.south][0]; } block.BuildFace(chunk, face, Palette, ref mask[n], rotated); // Zero out the mask. We don't need to process the same fields again for (l = 0; l < h; ++l) { maskIndex = n + l * sideSize; for (k = 0; k < w; ++k, ++maskIndex) { mask[maskIndex] = new BlockFace(); } } xx += w; n += w; } } } #endregion pools.blockFaceArrayPool.Push(mask); pools.vector3ArrayPool.Push(face); }
public override void Build(Chunk chunk, out int minBounds, out int maxBounds) { ChunkBlocks blocks = chunk.Blocks; LocalPools pools = Globals.WorkPool.GetPool(chunk.ThreadID); int sizeWithPadding = sideSize + Env.CHUNK_PADDING_2; int sizeWithPaddingPow2 = sizeWithPadding * sizeWithPadding; int sizeWithPaddingPow3 = sizeWithPaddingPow2 * sizeWithPadding; bool[] mask = pools.boolArrayPool.PopExact(sizeWithPaddingPow3); Array.Clear(mask, 0, mask.Length); // This compression is essentialy RLE. However, instead of working on 1 axis // it works in 3 dimensions. int index = Env.CHUNK_PADDING + (Env.CHUNK_PADDING << pow) + (Env.CHUNK_PADDING << (pow << 1)); int yOffset = sizeWithPaddingPow2 - sideSize * sizeWithPadding; int zOffset = sizeWithPadding - sideSize; int minX = sideSize; int minY = sideSize; int minZ = sideSize; int maxX = 0; int maxY = 0; int maxZ = 0; for (int y = 0; y < sideSize; ++y, index += yOffset) { for (int z = 0; z < sideSize; ++z, index += zOffset) { for (int x = 0; x < sideSize; ++x, ++index) { // Skip already checked blocks if (mask[index]) { continue; } mask[index] = true; Block block = blocks.GetBlock(index); // Skip blocks we're not interested in right away if (!CanConsiderBlock(block)) { continue; } int x1 = x, y1 = y, z1 = z, x2 = x + 1, y2 = y + 1, z2 = z + 1; bool expandX = true; bool expandY = true; bool expandZ = true; bool expand; // Try to expand our box in all axes do { expand = false; if (expandY) { expandY = y2 < sideSize && ExpandY(blocks, ref mask, block, x1, z1, x2, ref y2, z2); expand = expandY; } if (expandZ) { expandZ = z2 < sideSize && ExpandZ(blocks, ref mask, block, x1, y1, x2, y2, ref z2); expand |= expandZ; } if (expandX) { expandX = x2 < sideSize && ExpandX(blocks, ref mask, block, y1, z1, ref x2, y2, z2); expand |= expandX; } } while (expand); BuildBox(chunk, block, x1, y1, z1, x2, y2, z2); // Calculate bounds if (x1 < minX) { minX = x1; } if (y1 < minY) { minY = y1; } if (z1 < minZ) { minZ = z1; } if (x2 > maxX) { maxX = x2; } if (y2 > maxY) { maxY = y2; } if (z2 > maxZ) { maxZ = z2; } } } } // Update chunk's geoemetry bounds minBounds = minX | (minY << 8) | (minZ << 16); maxBounds = maxX | (maxY << 8) | (maxZ << 16); pools.boolArrayPool.Push(mask); }
protected override void BuildBox(Chunk chunk, Block block, int minX, int minY, int minZ, int maxX, int maxY, int maxZ) { // Order of vertices when building faces: // 1--2 // | | // | | // 0--3 int sizeWithPadding = sideSize + Env.CHUNK_PADDING_2; int sizeWithPaddingPow2 = sizeWithPadding * sizeWithPadding; LocalPools pools = Globals.WorkPool.GetPool(chunk.ThreadID); ChunkBlocks blocks = chunk.Blocks; Chunk[] listeners = chunk.Neighbors; // Custom blocks have their own rules // TODO: Implement custom block colliders /*if (block.Custom) * { * for (int yy = minY; yy < maxY; yy++) * { * for (int zz = minZ; zz < maxZ; zz++) * { * for (int xx = minX; xx < maxX; xx++) * { * ... // build collider here * } * } * } * * return; * }*/ Vector3[] vertexData = pools.vector3ArrayPool.PopExact(4); bool[] mask = pools.boolArrayPool.PopExact(sideSize * sideSize); int n, w, h, l, k, maskIndex; #region Top face if (listeners[(int)Direction.up] != null || // Don't render faces on world's edges for chunks with no neighbor maxY != sideSize) { Array.Clear(mask, 0, mask.Length); // x axis - width // z axis - height int neighborIndex = Helpers.GetChunkIndex1DFrom3D(minX, maxY, minZ, pow); int zOffset = sizeWithPadding - maxX + minX; // Build the mask for (int zz = minZ; zz < maxZ; ++zz, neighborIndex += zOffset) { n = minX + zz * sideSize; for (int xx = minX; xx < maxX; ++xx, ++n, ++neighborIndex) { // Let's see whether we can merge the faces if (!blocks.GetBlock(neighborIndex).CanCollide) { mask[n] = true; } } } // Build faces from the mask if it's possible for (int zz = minZ; zz < maxZ; ++zz) { n = minX + zz * sideSize; for (int xx = minX; xx < maxX;) { if (mask[n] == false) { ++xx; ++n; continue; } bool m = mask[n]; // Compute width for (w = 1; xx + w < sideSize && mask[n + w] == m; w++) { } // Compute height for (h = 1; zz + h < sideSize; h++) { for (k = 0; k < w; k++) { maskIndex = n + k + h * sideSize; if (mask[maskIndex] == false || mask[maskIndex] != m) { goto cont; } } } cont: // Build the face { vertexData[0] = new Vector3(xx, maxY, zz) * scale + BlockUtils.paddingOffsets[(int)Direction.up][0]; vertexData[1] = new Vector3(xx, maxY, zz + h) * scale + BlockUtils.paddingOffsets[(int)Direction.up][1]; vertexData[2] = new Vector3(xx + w, maxY, zz + h) * scale + BlockUtils.paddingOffsets[(int)Direction.up][2]; vertexData[3] = new Vector3(xx + w, maxY, zz) * scale + BlockUtils.paddingOffsets[(int)Direction.up][3]; chunk.ColliderGeometryHandler.Batcher.AddFace(block.physicMaterialID, vertexData, DirectionUtils.IsBackface(Direction.up)); } // Zero out the mask. We don't need to process the same fields again for (l = 0; l < h; ++l) { maskIndex = n + l * sideSize; for (k = 0; k < w; ++k, ++maskIndex) { mask[maskIndex] = false; } } xx += w; n += w; } } } #endregion #region Bottom face if (listeners[(int)Direction.down] != null || // Don't render faces on world's edges for chunks with no neighbor minY != 0) { Array.Clear(mask, 0, mask.Length); // x axis - width // z axis - height int neighborIndex = Helpers.GetChunkIndex1DFrom3D(minX, minY - 1, minZ, pow); int zOffset = sizeWithPadding - maxX + minX; // Build the mask for (int zz = minZ; zz < maxZ; ++zz, neighborIndex += zOffset) { n = minX + zz * sideSize; for (int xx = minX; xx < maxX; ++xx, ++n, ++neighborIndex) { // Let's see whether we can merge the faces if (!blocks.GetBlock(neighborIndex).CanCollide) { mask[n] = true; } } } // Build faces from the mask if it's possible for (int zz = minZ; zz < maxZ; ++zz) { n = minX + zz * sideSize; for (int xx = minX; xx < maxX;) { if (mask[n] == false) { ++xx; ++n; continue; } bool m = mask[n]; // Compute width for (w = 1; xx + w < sideSize && mask[n + w] == m; w++) { } // Compute height for (h = 1; zz + h < sideSize; h++) { for (k = 0; k < w; k++) { maskIndex = n + k + h * sideSize; if (mask[maskIndex] == false || mask[maskIndex] != m) { goto cont; } } } cont: // Build the face { vertexData[0] = new Vector3(xx, minY, zz) * scale + BlockUtils.paddingOffsets[(int)Direction.down][0]; vertexData[1] = new Vector3(xx, minY, zz + h) * scale + BlockUtils.paddingOffsets[(int)Direction.down][1]; vertexData[2] = new Vector3(xx + w, minY, zz + h) * scale + BlockUtils.paddingOffsets[(int)Direction.down][2]; vertexData[3] = new Vector3(xx + w, minY, zz) * scale + BlockUtils.paddingOffsets[(int)Direction.down][3]; chunk.ColliderGeometryHandler.Batcher.AddFace(block.physicMaterialID, vertexData, DirectionUtils.IsBackface(Direction.down)); } // Zero out the mask. We don't need to process the same fields again for (l = 0; l < h; ++l) { maskIndex = n + l * sideSize; for (k = 0; k < w; ++k, ++maskIndex) { mask[maskIndex] = false; } } xx += w; n += w; } } } #endregion #region Right face if (listeners[(int)Direction.east] != null || // Don't render faces on world's edges for chunks with no neighbor maxX != sideSize) { Array.Clear(mask, 0, mask.Length); // y axis - height // z axis - width int neighborIndex = Helpers.GetChunkIndex1DFrom3D(maxX, minY, minZ, pow); int yOffset = sizeWithPaddingPow2 - (maxZ - minZ) * sizeWithPadding; // Build the mask for (int yy = minY; yy < maxY; ++yy, neighborIndex += yOffset) { n = minZ + yy * sideSize; for (int zz = minZ; zz < maxZ; ++zz, ++n, neighborIndex += sizeWithPadding) { // Let's see whether we can merge the faces if (!blocks.GetBlock(neighborIndex).CanCollide) { mask[n] = true; } } } // Build faces from the mask if it's possible for (int yy = minY; yy < maxY; ++yy) { n = minZ + yy * sideSize; for (int zz = minZ; zz < maxZ;) { if (mask[n] == false) { ++zz; ++n; continue; } bool m = mask[n]; // Compute width for (w = 1; zz + w < sideSize && mask[n + w] == m; w++) { } // Compute height for (h = 1; yy + h < sideSize; h++) { for (k = 0; k < w; k++) { maskIndex = n + k + h * sideSize; if (mask[maskIndex] == false || mask[maskIndex] != m) { goto cont; } } } cont: // Build the face { vertexData[0] = new Vector3(maxX, yy, zz) * scale + BlockUtils.paddingOffsets[(int)Direction.east][0]; vertexData[1] = new Vector3(maxX, yy + h, zz) * scale + BlockUtils.paddingOffsets[(int)Direction.east][1]; vertexData[2] = new Vector3(maxX, yy + h, zz + w) * scale + BlockUtils.paddingOffsets[(int)Direction.east][2]; vertexData[3] = new Vector3(maxX, yy, zz + w) * scale + BlockUtils.paddingOffsets[(int)Direction.east][3]; chunk.ColliderGeometryHandler.Batcher.AddFace(block.physicMaterialID, vertexData, DirectionUtils.IsBackface(Direction.east)); } // Zero out the mask. We don't need to process the same fields again for (l = 0; l < h; ++l) { maskIndex = n + l * sideSize; for (k = 0; k < w; ++k, ++maskIndex) { mask[maskIndex] = false; } } zz += w; n += w; } } } #endregion #region Left face if (listeners[(int)Direction.west] != null || // Don't render faces on world's edges for chunks with no neighbor minX != 0) { Array.Clear(mask, 0, mask.Length); // y axis - height // z axis - width int neighborIndex = Helpers.GetChunkIndex1DFrom3D(minX - 1, minY, minZ, pow); int yOffset = sizeWithPaddingPow2 - (maxZ - minZ) * sizeWithPadding; // Build the mask for (int yy = minY; yy < maxY; ++yy, neighborIndex += yOffset) { n = minZ + yy * sideSize; for (int zz = minZ; zz < maxZ; ++zz, ++n, neighborIndex += sizeWithPadding) { // Let's see whether we can merge the faces if (!blocks.GetBlock(neighborIndex).CanCollide) { mask[n] = true; } } } // Build faces from the mask if it's possible for (int yy = minY; yy < maxY; ++yy) { n = minZ + yy * sideSize; for (int zz = minZ; zz < maxZ;) { if (mask[n] == false) { ++zz; ++n; continue; } bool m = mask[n]; // Compute width for (w = 1; zz + w < sideSize && mask[n + w] == m; w++) { } // Compute height for (h = 1; yy + h < sideSize; h++) { for (k = 0; k < w; k++) { maskIndex = n + k + h * sideSize; if (mask[maskIndex] == false || mask[maskIndex] != m) { goto cont; } } } cont: // Build the face { vertexData[0] = new Vector3(minX, yy, zz) * scale + BlockUtils.paddingOffsets[(int)Direction.west][0]; vertexData[1] = new Vector3(minX, yy + h, zz) * scale + BlockUtils.paddingOffsets[(int)Direction.west][1]; vertexData[2] = new Vector3(minX, yy + h, zz + w) * scale + BlockUtils.paddingOffsets[(int)Direction.west][2]; vertexData[3] = new Vector3(minX, yy, zz + w) * scale + BlockUtils.paddingOffsets[(int)Direction.west][3]; chunk.ColliderGeometryHandler.Batcher.AddFace(block.physicMaterialID, vertexData, DirectionUtils.IsBackface(Direction.west)); } // Zero out the mask. We don't need to process the same fields again for (l = 0; l < h; ++l) { maskIndex = n + l * sideSize; for (k = 0; k < w; ++k, ++maskIndex) { mask[maskIndex] = false; } } zz += w; n += w; } } } #endregion #region Front face if (listeners[(int)Direction.north] != null || // Don't render faces on world's edges for chunks with no neighbor maxZ != sideSize) { Array.Clear(mask, 0, mask.Length); // x axis - width // y axis - height int neighborIndex = Helpers.GetChunkIndex1DFrom3D(minX, minY, maxZ, pow); int yOffset = sizeWithPaddingPow2 - maxX + minX; // Build the mask for (int yy = minY; yy < maxY; ++yy, neighborIndex += yOffset) { n = minX + yy * sideSize; for (int xx = minX; xx < maxX; ++xx, ++n, ++neighborIndex) { // Let's see whether we can merge the faces if (!blocks.GetBlock(neighborIndex).CanCollide) { mask[n] = true; } } } // Build faces from the mask if it's possible for (int yy = minY; yy < maxY; ++yy) { n = minX + yy * sideSize; for (int xx = minX; xx < maxX;) { if (mask[n] == false) { ++xx; ++n; continue; } bool m = mask[n]; // Compute width for (w = 1; xx + w < sideSize && mask[n + w] == m; w++) { } // Compute height for (h = 1; yy + h < sideSize; h++) { for (k = 0; k < w; k++) { maskIndex = n + k + h * sideSize; if (mask[maskIndex] == false || mask[maskIndex] != m) { goto cont; } } } cont: // Build the face { vertexData[0] = new Vector3(xx, yy, maxZ) * scale + BlockUtils.paddingOffsets[(int)Direction.north][0]; vertexData[1] = new Vector3(xx, yy + h, maxZ) * scale + BlockUtils.paddingOffsets[(int)Direction.north][1]; vertexData[2] = new Vector3(xx + w, yy + h, maxZ) * scale + BlockUtils.paddingOffsets[(int)Direction.north][2]; vertexData[3] = new Vector3(xx + w, yy, maxZ) * scale + BlockUtils.paddingOffsets[(int)Direction.north][3]; chunk.ColliderGeometryHandler.Batcher.AddFace(block.physicMaterialID, vertexData, DirectionUtils.IsBackface(Direction.north)); } // Zero out the mask. We don't need to process the same fields again for (l = 0; l < h; ++l) { maskIndex = n + l * sideSize; for (k = 0; k < w; ++k, ++maskIndex) { mask[maskIndex] = false; } } xx += w; n += w; } } } #endregion #region Back face if (listeners[(int)Direction.south] != null || // Don't render faces on world's edges for chunks with no neighbor minZ != 0) { Array.Clear(mask, 0, mask.Length); // x axis - width // y axis - height int neighborIndex = Helpers.GetChunkIndex1DFrom3D(minX, minY, minZ - 1, pow); int yOffset = sizeWithPaddingPow2 - maxX + minX; // Build the mask for (int yy = minY; yy < maxY; ++yy, neighborIndex += yOffset) { n = minX + yy * sideSize; for (int xx = minX; xx < maxX; ++xx, ++n, ++neighborIndex) { // Let's see whether we can merge the faces if (!blocks.GetBlock(neighborIndex).CanCollide) { mask[n] = true; } } } // Build faces from the mask if it's possible for (int yy = minY; yy < maxY; ++yy) { n = minX + yy * sideSize; for (int xx = minX; xx < maxX;) { if (mask[n] == false) { ++xx; ++n; continue; } bool m = mask[n]; // Compute width for (w = 1; xx + w < sideSize && mask[n + w] == m; w++) { } // Compute height for (h = 1; yy + h < sideSize; h++) { for (k = 0; k < w; k++) { maskIndex = n + k + h * sideSize; if (mask[maskIndex] == false || mask[maskIndex] != m) { goto cont; } } } cont: // Build the face { vertexData[0] = new Vector3(xx, yy, minZ) * scale + BlockUtils.paddingOffsets[(int)Direction.south][0]; vertexData[1] = new Vector3(xx, yy + h, minZ) * scale + BlockUtils.paddingOffsets[(int)Direction.south][1]; vertexData[2] = new Vector3(xx + w, yy + h, minZ) * scale + BlockUtils.paddingOffsets[(int)Direction.south][2]; vertexData[3] = new Vector3(xx + w, yy, minZ) * scale + BlockUtils.paddingOffsets[(int)Direction.south][3]; chunk.ColliderGeometryHandler.Batcher.AddFace(block.physicMaterialID, vertexData, DirectionUtils.IsBackface(Direction.south)); } // Zero out the mask. We don't need to process the same fields again for (l = 0; l < h; ++l) { maskIndex = n + l * sideSize; for (k = 0; k < w; ++k, ++maskIndex) { mask[maskIndex] = false; } } xx += w; n += w; } } } #endregion pools.boolArrayPool.Push(mask); pools.vector3ArrayPool.Push(vertexData); }