@Override public String getWorldText(Region region, int wx, int wy) { FloraFacet floraFacet = region.getFacet(FloraFacet.class); Region3i worldRegion = floraFacet.getWorldRegion(); Region3i relativeRegion = floraFacet.getRelativeRegion(); int rx = wx - worldRegion.minX() + relativeRegion.minX(); int rz = wy - worldRegion.minZ() + relativeRegion.minZ(); for (Entry<BaseVector3i, FloraType> entry : floraFacet.getRelativeEntries().entrySet()) { BaseVector3i treePos = entry.getKey(); if (treePos.getX() == rx && treePos.getZ() == rz) { FloraType flora = entry.getValue(); return labelFunc.apply(flora); } } return "-no vegetation-"; }
protected final int getRelativeIndex(int x, int y, int z) { if (!relativeRegion.encompasses(x, y, z)) { throw new IllegalArgumentException(String.format("Out of bounds: (%d, %d, %d) for region %s", x, y, z, relativeRegion.toString())); } return x - relativeRegion.minX() + relativeRegion.sizeX() * (y - relativeRegion.minY() + relativeRegion.sizeY() * (z - relativeRegion.minZ())); }
protected final int getWorldIndex(int x, int y, int z) { if (!worldRegion.encompasses(x, y, z)) { throw new IllegalArgumentException(String.format("Out of bounds: (%d, %d, %d) for region %s", x, y, z, worldRegion.toString())); } return x - worldRegion.minX() + worldRegion.sizeX() * (y - worldRegion.minY() + worldRegion.sizeY() * (z - worldRegion.minZ())); } }
protected final Vector3i relativeToWorld(SparseFacet3D facet, BaseVector3i pos) { Region3i worldRegion = facet.getWorldRegion(); Region3i relativeRegion = facet.getRelativeRegion(); return new Vector3i( pos.x() - relativeRegion.minX() + worldRegion.minX(), pos.y() - relativeRegion.minY() + worldRegion.minY(), pos.z() - relativeRegion.minZ() + worldRegion.minZ()); } }
private float[] getKeyValues(Region3i fullRegion) { int xDim = fullRegion.size().x / sampleRate + 1; int yDim = fullRegion.size().y / sampleRate + 1; int zDim = fullRegion.size().z / sampleRate + 1; float[] fullData = new float[xDim * yDim * zDim]; for (int z = 0; z < zDim; z++) { for (int y = 0; y < yDim; y++) { for (int x = 0; x < xDim; x++) { int actualX = x * sampleRate + fullRegion.minX(); int actualY = y * sampleRate + fullRegion.minY(); int actualZ = z * sampleRate + fullRegion.minZ(); fullData[x + xDim * (y + yDim * z)] = source.noise(zoom.x * actualX, zoom.y * actualY, zoom.z * actualZ); } } } return fullData; }
private float[] getKeyValues(Region3i fullRegion) { int xDim = fullRegion.sizeX() / sampleRate + 1; int yDim = fullRegion.sizeY() / sampleRate + 1; int zDim = fullRegion.sizeZ() / sampleRate + 1; float[] fullData = new float[xDim * yDim * zDim]; for (int z = 0; z < zDim; z++) { for (int y = 0; y < yDim; y++) { for (int x = 0; x < xDim; x++) { int actualX = x * sampleRate + fullRegion.minX(); int actualY = y * sampleRate + fullRegion.minY(); int actualZ = z * sampleRate + fullRegion.minZ(); fullData[x + xDim * (y + yDim * z)] = source.noise(zoom.x * actualX, zoom.y * actualY, zoom.z * actualZ); } } } return fullData; }
/** * Returns a 2D representation of the world (top view) with the given borders added to the size of the original region. * @param region The original region to be used. * @return The 2D representation with the additional space added to it. */ public Rect2i expandTo2D(Region3i region) { return Rect2i.createFromMinAndMax(region.minX() - getSides(), region.minZ() - getSides(), region.maxX() + getSides(), region.maxZ() + getSides()); }
/** * Returns a 3D representation of the workd, a region in this case. With the borders added to it. * @param region The region to be expanded with the borders. * @return The 3D world representation with the additional space added to it in the 3 dimensions. */ public Region3i expandTo3D(Region3i region) { return Region3i.createFromMinMax(new Vector3i(region.minX() - sides, region.minY() - bottom, region.minZ() - sides), new Vector3i(region.maxX() + sides, region.maxY() + top, region.maxZ() + sides)); }
private Region3i determineRequiredRegion(Region3i region) { int newMinX = region.minX() - IntMath.mod(region.minX(), sampleRate); int newMinY = region.minY() - IntMath.mod(region.minY(), sampleRate); int newMinZ = region.minZ() - IntMath.mod(region.minZ(), sampleRate); int newMaxX = region.maxX() + 4 - IntMath.mod(region.maxX(), sampleRate) - 1; int newMaxY = region.maxY() + 4 - IntMath.mod(region.maxY(), sampleRate) - 1; int newMaxZ = region.maxZ() + 4 - IntMath.mod(region.maxZ(), sampleRate) - 1; return Region3i.createFromMinMax(new Vector3i(newMinX, newMinY, newMinZ), new Vector3i(newMaxX, newMaxY, newMaxZ)); } }
private Region3i determineRequiredRegion(Region3i region) { int newMinX = region.minX() - IntMath.mod(region.minX(), sampleRate); int newMinY = region.minY() - IntMath.mod(region.minY(), sampleRate); int newMinZ = region.minZ() - IntMath.mod(region.minZ(), sampleRate); int newMaxX = region.maxX() + 4 - IntMath.mod(region.maxX(), sampleRate) - 1; int newMaxY = region.maxY() + 4 - IntMath.mod(region.maxY(), sampleRate) - 1; int newMaxZ = region.maxZ() + 4 - IntMath.mod(region.maxZ(), sampleRate) - 1; return Region3i.createFromMinMax(new Vector3i(newMinX, newMinY, newMinZ), new Vector3i(newMaxX, newMaxY, newMaxZ)); } }
private float[] getSubset(float[] fullData, Region3i fullRegion, Region3i subRegion) { if (subRegion.size().x != fullRegion.size().x || subRegion.size().y != fullRegion.size().y || subRegion.size().z != fullRegion.size().z) { float[] result = new float[subRegion.size().x * subRegion.size().y * subRegion.size().z]; Vector3i offset = new Vector3i(subRegion.minX() - fullRegion.minX(), subRegion.minY() - fullRegion.minY(), subRegion.minZ() - fullRegion.minZ()); for (int z = 0; z < subRegion.size().z; ++z) { for (int y = 0; y < subRegion.size().y; ++y) { System.arraycopy(fullData, offset.x + fullRegion.sizeX() * (y + offset.y + fullRegion.sizeY() * (z + offset.z)), result, subRegion.sizeX() * (y + subRegion.sizeY() * z), subRegion.size().x); } } return result; } else { return fullData; } }
private float[] getSubset(float[] fullData, Region3i fullRegion, Region3i subRegion) { if (subRegion.sizeX() != fullRegion.sizeX() || subRegion.sizeY() != fullRegion.sizeY() || subRegion.sizeZ() != fullRegion.sizeZ()) { float[] result = new float[subRegion.sizeX() * subRegion.sizeY() * subRegion.sizeZ()]; Vector3i offset = new Vector3i(subRegion.minX() - fullRegion.minX(), subRegion.minY() - fullRegion.minY(), subRegion.minZ() - fullRegion.minZ()); for (int z = 0; z < subRegion.sizeZ(); ++z) { for (int y = 0; y < subRegion.sizeY(); ++y) { System.arraycopy(fullData, offset.x + fullRegion.sizeX() * (y + offset.y + fullRegion.sizeY() * (z + offset.z)), result, subRegion.sizeX() * (y + subRegion.sizeY() * z), subRegion.sizeX()); } } return result; } else { return fullData; } }
private ChunkViewCore createWorldView(Region3i region, Vector3i offset) { Chunk[] chunks = new Chunk[region.sizeX() * region.sizeY() * region.sizeZ()]; for (Vector3i chunkPos : region) { Chunk chunk = chunkCache.get(chunkPos); if (chunk == null) { return null; } chunkPos.sub(region.minX(), region.minY(), region.minZ()); int index = TeraMath.calculate3DArrayIndex(chunkPos, region.size()); chunks[index] = chunk; } return new ChunkViewCoreImpl(chunks, region, offset, blockManager.getBlock(BlockManager.AIR_ID)); }
public static Vector3i[] calcChunkPos(Region3i region, Vector3i chunkPower) { int minX = calcChunkPosX(region.minX(), chunkPower.x); int minY = calcChunkPosY(region.minY(), chunkPower.y); int minZ = calcChunkPosZ(region.minZ(), chunkPower.z); int maxX = calcChunkPosX(region.maxX(), chunkPower.x); int maxY = calcChunkPosY(region.maxY(), chunkPower.y); int maxZ = calcChunkPosZ(region.maxZ(), chunkPower.z); int size = (maxX - minX + 1) * (maxY - minY + 1) * (maxZ - minZ + 1); Vector3i[] result = new Vector3i[size]; int index = 0; for (int x = minX; x <= maxX; x++) { for (int y = minY; y <= maxY; y++) { for (int z = minZ; z <= maxZ; z++) { result[index++] = new Vector3i(x, y, z); } } } return result; }
for (int x = edgeRegion.minX(); x <= edgeRegion.maxX(); ++x) { for (int y = edgeRegion.minY(); y <= edgeRegion.maxY(); ++y) { for (int z = edgeRegion.minZ(); z <= edgeRegion.maxZ(); ++z) {
@Override public void process(GeneratingRegion region) { Region3i reg = region.getRegion(); Rect2i rc = Rect2i.createFromMinAndMax(reg.minX(), reg.minZ(), reg.maxX(), reg.maxZ()); if (rc.distanceSquared(centerPos.x(), centerPos.y()) <= outerRadius * outerRadius) { SurfaceHeightFacet facet = region.getRegionFacet(SurfaceHeightFacet.class); // update the surface height for (BaseVector2i pos : facet.getWorldRegion().contents()) { float originalValue = facet.getWorld(pos); int distSq = pos.distanceSquared(centerPos); if (distSq <= innerRadius * innerRadius) { facet.setWorld(pos, targetHeight); } else if (distSq <= outerRadius * outerRadius) { double dist = pos.distance(centerPos) - innerRadius; float norm = (float) dist / (outerRadius - innerRadius); facet.setWorld(pos, TeraMath.lerp(targetHeight, originalValue, norm)); } } } } }
for (int z = worldRegion.minZ(); z <= worldRegion.maxZ(); z++) { for (int x = worldRegion.minX(); x <= worldRegion.maxX(); x++) { int height = TeraMath.floorToInt(surfaceFacet.getWorld(x, z)) + 1;
@Override public void process(GeneratingRegion region) { SurfaceHeightFacet surfaceHeight = region.getRegionFacet(SurfaceHeightFacet.class); DensityFacet facet = new DensityFacet(region.getRegion(), region.getBorderForFacet(DensityFacet.class)); Region3i area = region.getRegion(); Rect2i rect = Rect2i.createFromMinAndMax(facet.getRelativeRegion().minX(), facet.getRelativeRegion().minZ(), facet.getRelativeRegion().maxX(), facet.getRelativeRegion().maxZ()); for (BaseVector2i pos : rect.contents()) { float height = surfaceHeight.get(pos); for (int y = facet.getRelativeRegion().minY(); y <= facet.getRelativeRegion().maxY(); ++y) { facet.set(pos.x(), y, pos.y(), height - area.minY() - y); } } region.setRegionFacet(DensityFacet.class, facet); } }