public boolean isEmpty() { return size.x + size.y + size().z == 0; }
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 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 BaseFieldFacet3D(Region3i targetRegion, Border3D border) { super(targetRegion, border); Vector3i size = getRelativeRegion().size(); this.data = new float[size.x * size.y * size.z]; }
public BaseBooleanFieldFacet3D(Region3i targetRegion, Border3D border) { super(targetRegion, border); Vector3i size = getRelativeRegion().size(); data = new boolean[size.x * size.y * size.z]; }
public BaseObjectFacet3D(Region3i targetRegion, Border3D border, Class<T> objectType) { super(targetRegion, border); Vector3i size = getRelativeRegion().size(); this.data = (T[]) Array.newInstance(objectType, size.x * size.y * size.z); }
private ChunkViewCore createWorldView(Region3i region, Vector3i offset) { Chunk[] chunks = new Chunk[region.size().x * region.size().y * region.size().z]; for (Vector3i chunkPos : region) { Chunk chunk = chunkCache.get(chunkPos); if (chunk == null || !chunk.isReady()) { return null; } chunkPos.sub(region.min()); int index = TeraMath.calculate3DArrayIndex(chunkPos, region.size()); chunks[index] = chunk; } return new ChunkViewCoreImpl(chunks, region, offset, blockManager.getBlock(BlockManager.AIR_ID)); }
@Override public void propagateBetween(LitChunk chunk, LitChunk adjChunk, Side side, boolean propagateExternal) { IndexProvider indexProvider = createIndexProvider(side); Region3i edgeRegion = ChunkMath.getEdgeRegion(Region3i.createFromMinAndSize(Vector3i.zero(), ChunkConstants.CHUNK_SIZE), side); int edgeSize = edgeRegion.size().x * edgeRegion.size().y * edgeRegion.size().z; int[] depth = new int[edgeSize]; propagateSide(chunk, adjChunk, side, indexProvider, edgeRegion, depth); propagateDepth(adjChunk, side, propagateExternal, indexProvider, edgeRegion, depth); }
@Override public void setDirtyAround(Vector3i blockPos) { for (Vector3i pos : ChunkMath.getChunkRegionAroundWorldPos(blockPos, 1)) { chunks[pos.x + offset.x + chunkRegion.size().x * (pos.z + offset.z)].setDirty(true); } }
public BaseFacet3D(Region3i targetRegion, Border3D border) { worldRegion = border.expandTo3D(targetRegion); relativeRegion = border.expandTo3D(targetRegion.size()); }
public BaseFacet2D(Region3i targetRegion, Border3D border) { worldRegion = border.expandTo2D(targetRegion); relativeRegion = border.expandTo2D(targetRegion.size()); }
public SparseFacet3D(Region3i targetRegion, Border3D border) { worldRegion = border.expandTo3D(targetRegion); relativeRegion = border.expandTo3D(targetRegion.size()); }
@Override public PersistedData serialize(Region3i value, SerializationContext context) { if (value == null) { return context.createNull(); } else { Map<String, PersistedData> map = Maps.newLinkedHashMap(); map.put(MIN_FIELD, context.create(value.min(), Vector3i.class)); map.put(SIZE_FIELD, context.create(value.size(), Vector3i.class)); return context.create(map); } }
@Override public String toString() { Vector3i worldMin = getWorldRegion().min(); Vector3i relMin = getRelativeRegion().min(); Vector3i size = getRelativeRegion().size(); return String.format("SparseFacet3D [worldMin=%s, relativeMin=%s, size=%s]", worldMin, relMin, size); } }
protected int relChunkIndex(int x, int y, int z) { return TeraMath.calculate3DArrayIndex(ChunkMath.calcChunkPosX(x, chunkPower.x) + offset.x, ChunkMath.calcChunkPosY(y, chunkPower.y) + offset.y, ChunkMath.calcChunkPosZ(z, chunkPower.z) + offset.z, chunkRegion.size()); }
@Test public void testCreateRegionWithMinAndSize() { List<Vector3i> mins = Arrays.asList(new Vector3i(), new Vector3i(1, 1, 1), new Vector3i(3, 4, 5)); List<Vector3i> size = Arrays.asList(new Vector3i(1, 1, 1), new Vector3i(3, 3, 3), new Vector3i(8, 5, 2)); List<Vector3i> expectedMax = Arrays.asList(new Vector3i(), new Vector3i(3, 3, 3), new Vector3i(10, 8, 6)); for (int i = 0; i < mins.size(); ++i) { Region3i region = Region3i.createFromMinAndSize(mins.get(i), size.get(i)); assertEquals(mins.get(i), region.min()); assertEquals(size.get(i), region.size()); assertEquals(expectedMax.get(i), region.max()); assertFalse(region.isEmpty()); } }
@Test public void testCreateRegionWithMinMax() { List<Vector3i> mins = Arrays.asList(new Vector3i(), new Vector3i(1, 1, 1), new Vector3i(3, 4, 5)); List<Vector3i> expectedSize = Arrays.asList(new Vector3i(1, 1, 1), new Vector3i(3, 3, 3), new Vector3i(8, 5, 2)); List<Vector3i> max = Arrays.asList(new Vector3i(), new Vector3i(3, 3, 3), new Vector3i(10, 8, 6)); for (int i = 0; i < mins.size(); ++i) { Region3i region = Region3i.createFromMinMax(mins.get(i), max.get(i)); assertEquals(mins.get(i), region.min()); assertEquals(max.get(i), region.max()); assertEquals(expectedSize.get(i), region.size()); assertFalse(region.isEmpty()); } }
@Override public void setDirtyAround(Region3i region) { Vector3i minPos = new Vector3i(region.min()); minPos.sub(1, 1, 1); Vector3i maxPos = new Vector3i(region.max()); maxPos.add(1, 1, 1); Vector3i minChunk = ChunkMath.calcChunkPos(minPos, chunkPower); Vector3i maxChunk = ChunkMath.calcChunkPos(maxPos, chunkPower); for (Vector3i pos : Region3i.createFromMinMax(minChunk, maxChunk)) { chunks[pos.x + offset.x + chunkRegion.size().x * (pos.z + offset.z)].setDirty(true); } }
public void setChunkSize(Vector3i chunkSize) { this.chunkFilterSize = new Vector3i(TeraMath.ceilPowerOfTwo(chunkSize.x) - 1, TeraMath.ceilPowerOfTwo(chunkSize.y) - 1, TeraMath.ceilPowerOfTwo(chunkSize.z) - 1); this.chunkPower = new Vector3i(TeraMath.sizeOfPower(chunkSize.x), TeraMath.sizeOfPower(chunkSize.y), TeraMath.sizeOfPower(chunkSize.z)); Vector3i blockMin = new Vector3i(); blockMin.sub(offset); blockMin.mul(chunkSize.x, chunkSize.y, chunkSize.z); Vector3i blockSize = chunkRegion.size(); blockSize.mul(chunkSize.x, chunkSize.y, chunkSize.z); this.blockRegion = Region3i.createFromMinAndSize(blockMin, blockSize); }
@Test public void testEmptyRegion() { assertEquals(Region3i.empty().size(), Vector3i.zero()); assertTrue(Region3i.empty().isEmpty()); }