import com.mojang.blaze3d.systems.RenderSystem;
import com.mojang.blaze3d.vertex.Tesselator;
import com.mojang.math.Transformation;
-import it.unimi.dsi.fastutil.longs.Long2ReferenceMap;
-import it.unimi.dsi.fastutil.longs.Long2ReferenceOpenHashMap;
+import it.unimi.dsi.fastutil.longs.Long2ByteMap;
import me.shedaniel.architectury.event.events.GuiEvent;
import me.shedaniel.architectury.event.events.client.ClientTickEvent;
import me.shedaniel.architectury.platform.Platform;
import net.minecraft.world.entity.EntityType;
import net.minecraft.world.entity.MobCategory;
import net.minecraft.world.level.BlockGetter;
-import net.minecraft.world.level.ChunkPos;
import net.minecraft.world.level.Level;
import net.minecraft.world.level.LightLayer;
import net.minecraft.world.level.biome.Biome;
public static boolean smoothLines = true;
public static boolean underwater = false;
public static boolean mushroom = false;
+ public static boolean useListWhileCaching = true;
public static float lineWidth = 1.0F;
public static int yellowColor = 0xFFFF00, redColor = 0xFF0000, secondaryColor = 0x0000FF;
public static File configFile;
-
+
private static KeyMapping enableOverlay;
private static boolean enabled = false;
private static final LazyLoadedValue<EntityType<Entity>> TESTING_ENTITY_TYPE = new LazyLoadedValue<>(() ->
thread.setDaemon(true);
return thread;
});
- private static final Set<ChunkPos> POS = Collections.synchronizedSet(new HashSet<>());
- private static final Set<ChunkPos> CALCULATING_POS = Collections.synchronizedSet(new HashSet<>());
- private static final Map<ChunkPos, Long2ReferenceMap<Object>> CHUNK_MAP = Maps.newConcurrentMap();
+ private static final Set<CubicChunkPos> POS = Collections.synchronizedSet(new HashSet<>());
+ private static final Set<CubicChunkPos> CALCULATING_POS = Collections.synchronizedSet(new HashSet<>());
+ private static final Map<CubicChunkPos, ChunkData> CHUNK_MAP = Maps.newConcurrentMap();
private static final Minecraft CLIENT = Minecraft.getInstance();
private static long ticks = 0;
RenderSystem.depthMask(true);
BlockPos.MutableBlockPos mutable = new BlockPos.MutableBlockPos();
BlockPos.MutableBlockPos downMutable = new BlockPos.MutableBlockPos();
- for (Map.Entry<ChunkPos, Long2ReferenceMap<Object>> entry : CHUNK_MAP.entrySet()) {
+ for (Map.Entry<CubicChunkPos, ChunkData> entry : CHUNK_MAP.entrySet()) {
if (caching && (Mth.abs(entry.getKey().x - playerPosX) > getChunkRange() || Mth.abs(entry.getKey().z - playerPosZ) > getChunkRange())) {
continue;
}
- for (Long2ReferenceMap.Entry<Object> objectEntry : entry.getValue().long2ReferenceEntrySet()) {
- if (objectEntry.getValue() instanceof Byte) {
- mutable.set(BlockPos.getX(objectEntry.getLongKey()), BlockPos.getY(objectEntry.getLongKey()), BlockPos.getZ(objectEntry.getLongKey()));
- if (mutable.closerThan(playerPos, reach)) {
- if (frustum == null || isFrustumVisible(frustum, mutable.getX(), mutable.getY(), mutable.getZ(), mutable.getX() + 1, mutable.getX() + 1, mutable.getX() + 1)) {
- downMutable.set(mutable.getX(), mutable.getY() - 1, mutable.getZ());
- renderLevel(CLIENT, camera, world, mutable, downMutable, (Byte) objectEntry.getValue(), collisionContext);
- }
+ for (Long2ByteMap.Entry objectEntry : entry.getValue().data().long2ByteEntrySet()) {
+ mutable.set(BlockPos.getX(objectEntry.getLongKey()), BlockPos.getY(objectEntry.getLongKey()), BlockPos.getZ(objectEntry.getLongKey()));
+ if (mutable.closerThan(playerPos, reach)) {
+ if (frustum == null || isFrustumVisible(frustum, mutable.getX(), mutable.getY(), mutable.getZ(), mutable.getX() + 1, mutable.getX() + 1, mutable.getX() + 1)) {
+ downMutable.set(mutable.getX(), mutable.getY() - 1, mutable.getZ());
+ renderLevel(CLIENT, camera, world, mutable, downMutable, objectEntry.getByteValue(), collisionContext);
}
}
}
}
RenderSystem.enableDepthTest();
} else {
+ boolean useList = useListWhileCaching && caching;
RenderSystem.enableDepthTest();
RenderSystem.disableTexture();
RenderSystem.enableBlend();
+ RenderSystem.enableCull();
RenderSystem.blendFunc(GlStateManager.SourceFactor.SRC_ALPHA, GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA);
if (smoothLines) GL11.glEnable(GL11.GL_LINE_SMOOTH);
GL11.glLineWidth(lineWidth);
- GL11.glBegin(GL11.GL_LINES);
+ if (!useList) GL11.glBegin(GL11.GL_LINES);
+
BlockPos.MutableBlockPos mutable = new BlockPos.MutableBlockPos();
- for (Map.Entry<ChunkPos, Long2ReferenceMap<Object>> entry : CHUNK_MAP.entrySet()) {
- if (caching && (Mth.abs(entry.getKey().x - playerPosX) > getChunkRange() || Mth.abs(entry.getKey().z - playerPosZ) > getChunkRange())) {
+
+ if (useList) GL11.glTranslated(-camera.getPosition().x, -camera.getPosition().y + .01D, -camera.getPosition().z);
+ for (Map.Entry<CubicChunkPos, ChunkData> entry : CHUNK_MAP.entrySet()) {
+ CubicChunkPos chunkPos = entry.getKey();
+ if (caching && (Mth.abs(chunkPos.x - playerPosX) > getChunkRange() || Mth.abs(chunkPos.z - playerPosZ) > getChunkRange())) {
continue;
}
- for (Long2ReferenceMap.Entry<Object> objectEntry : entry.getValue().long2ReferenceEntrySet()) {
- if (objectEntry.getValue() instanceof CrossType) {
+
+ if (useList) {
+ if (frustum == null || isFrustumVisible(frustum, chunkPos.getMinBlockX(), chunkPos.getMinBlockY(), chunkPos.getMinBlockZ(), chunkPos.getMaxBlockX(), chunkPos.getMaxBlockY(), chunkPos.getMaxBlockZ())) {
+ entry.getValue().renderList(world, collisionContext);
+ }
+ } else {
+ for (Long2ByteMap.Entry objectEntry : entry.getValue().data().long2ByteEntrySet()) {
+ byte crossType = objectEntry.getByteValue();
mutable.set(BlockPos.getX(objectEntry.getLongKey()), BlockPos.getY(objectEntry.getLongKey()), BlockPos.getZ(objectEntry.getLongKey()));
if (mutable.closerThan(playerPos, reach)) {
if (frustum == null || isFrustumVisible(frustum, mutable.getX(), mutable.getY(), mutable.getZ(), mutable.getX() + 1, mutable.getX() + 1, mutable.getX() + 1)) {
- int color = objectEntry.getValue() == CrossType.RED ? redColor : objectEntry.getValue() == CrossType.YELLOW ? yellowColor : secondaryColor;
+ int color = crossType == CROSS_RED ? redColor : crossType == CROSS_YELLOW ? yellowColor : secondaryColor;
renderCross(camera, world, mutable, color, collisionContext);
}
}
}
}
}
- GL11.glEnd();
+
+ if (!useList) GL11.glEnd();
RenderSystem.disableBlend();
RenderSystem.enableTexture();
if (smoothLines) GL11.glDisable(GL11.GL_LINE_SMOOTH);
}
}
});
-
+
GuiEvent.DEBUG_TEXT_LEFT.register(list -> {
if (enabled) {
if (caching) {
} else {
list.add("[Light Overlay] Enabled");
}
- }else {
+ } else {
list.add("[Light Overlay] Disabled");
}
});
ClientTickEvent.CLIENT_POST.register(LightOverlay::tick);
}
- private static void processChunk(ChunkPos pos, int playerPosX, int playerPosZ, CollisionContext context) {
+ private static void processChunk(CubicChunkPos pos, int playerPosX, int playerPosY, int playerPosZ, CollisionContext context) {
CALCULATING_POS.remove(pos);
- if (Mth.abs(pos.x - playerPosX) > getChunkRange() || Mth.abs(pos.z - playerPosZ) > getChunkRange() || POS.contains(pos)) {
+ if (Mth.abs(pos.x - playerPosX) > getChunkRange() || Mth.abs(pos.y - playerPosY) > getChunkRange() || Mth.abs(pos.z - playerPosZ) > getChunkRange() || POS.contains(pos)) {
return;
}
try {
}
}
- public static void queueChunkAndNear(ChunkPos pos) {
+ public static void queueChunkAndNear(CubicChunkPos pos) {
for (int xOffset = -1; xOffset <= 1; xOffset++) {
- for (int zOffset = -1; zOffset <= 1; zOffset++) {
- queueChunk(new ChunkPos(pos.x + xOffset, pos.z + zOffset));
+ for (int yOffset = -1; yOffset <= 1; yOffset++) {
+ for (int zOffset = -1; zOffset <= 1; zOffset++) {
+ queueChunk(new CubicChunkPos(pos.x + xOffset, pos.y + yOffset, pos.z + zOffset));
+ }
}
}
}
- public static void queueChunk(ChunkPos pos) {
+ public static void queueChunk(CubicChunkPos pos) {
if (enabled && caching && !CALCULATING_POS.contains(pos)) {
POS.add(pos);
}
return Math.max(Mth.ceil(reach / 16f), 1);
}
- private static void calculateChunk(LevelChunk chunk, Level world, ChunkPos chunkPos, CollisionContext entityContext) {
+ private static void calculateChunk(LevelChunk chunk, Level world, CubicChunkPos chunkPos, CollisionContext collisionContext) {
if (world != null && chunk != null) {
- Long2ReferenceMap<Object> map = new Long2ReferenceOpenHashMap<>();
+ ChunkData chunkData = new ChunkData();
LayerLightEventListener block = world.getLightEngine().getLayerListener(LightLayer.BLOCK);
LayerLightEventListener sky = showNumber ? null : world.getLightEngine().getLayerListener(LightLayer.SKY);
- for (BlockPos pos : BlockPos.betweenClosed(chunkPos.getMinBlockX(), 0, chunkPos.getMinBlockZ(), chunkPos.getMaxBlockX(), 256, chunkPos.getMaxBlockZ())) {
+ for (BlockPos pos : BlockPos.betweenClosed(chunkPos.getMinBlockX(), chunkPos.getMinBlockY(), chunkPos.getMinBlockZ(), chunkPos.getMaxBlockX(), chunkPos.getMaxBlockY(), chunkPos.getMaxBlockZ())) {
BlockPos down = pos.below();
if (showNumber) {
- int level = getCrossLevel(pos, down, chunk, block, entityContext);
+ int level = getCrossLevel(pos, down, chunk, block, collisionContext);
if (level >= 0) {
- map.put(pos.asLong(), Byte.valueOf((byte) level));
+ chunkData.data().put(pos.asLong(), (byte) level);
}
} else {
- Biome biome = mushroom ? world.getBiome(pos) : null;
- CrossType type = getCrossType(pos, biome,down, chunk, block, sky, entityContext);
- if (type != CrossType.NONE) {
- map.put(pos.asLong(), type);
+ Biome biome = !mushroom ? world.getBiome(pos) : null;
+ byte type = getCrossType(pos, biome, down, chunk, block, sky, collisionContext);
+ if (type != CROSS_NONE) {
+ chunkData.data().put(pos.asLong(), type);
}
}
}
- CHUNK_MAP.put(chunkPos, map);
+ CHUNK_MAP.put(chunkPos, chunkData);
} else {
- CHUNK_MAP.remove(chunkPos);
+ ChunkData data = CHUNK_MAP.remove(chunkPos);
+
+ if (data != null) {
+ data.close();
+ }
}
}
- public static CrossType getCrossType(BlockPos pos, Biome biome, BlockPos down, BlockGetter world, LayerLightEventListener block, LayerLightEventListener sky, CollisionContext entityContext) {
+ public static byte getCrossType(BlockPos pos, Biome biome, BlockPos down, BlockGetter world, LayerLightEventListener block, LayerLightEventListener sky, CollisionContext entityContext) {
BlockState blockBelowState = world.getBlockState(down);
BlockState blockUpperState = world.getBlockState(pos);
VoxelShape upperCollisionShape = blockUpperState.getCollisionShape(world, pos, entityContext);
if (!underwater && !blockUpperState.getFluidState().isEmpty())
- return CrossType.NONE;
+ return CROSS_NONE;
// Check if the outline is full
if (Block.isFaceFull(upperCollisionShape, Direction.UP))
- return CrossType.NONE;
+ return CROSS_NONE;
// TODO: Not to hard code no redstone
if (blockUpperState.isSignalSource())
- return CrossType.NONE;
+ return CROSS_NONE;
// Check if the collision has a bump
if (upperCollisionShape.max(Direction.Axis.Y) > 0)
- return CrossType.NONE;
+ return CROSS_NONE;
if (blockUpperState.getBlock().is(BlockTags.RAILS))
- return CrossType.NONE;
+ return CROSS_NONE;
// Check block state allow spawning (excludes bedrock and barriers automatically)
if (!blockBelowState.isValidSpawn(world, down, TESTING_ENTITY_TYPE.get()))
- return CrossType.NONE;
+ return CROSS_NONE;
if (!mushroom && Biome.BiomeCategory.MUSHROOM == biome.getBiomeCategory())
- return CrossType.NONE;
+ return CROSS_NONE;
int blockLightLevel = block.getLightValue(pos);
int skyLightLevel = sky.getLightValue(pos);
if (blockLightLevel > higherCrossLevel)
- return CrossType.NONE;
+ return CROSS_NONE;
if (skyLightLevel > higherCrossLevel)
- return CrossType.YELLOW;
- return lowerCrossLevel >= 0 && blockLightLevel > lowerCrossLevel ? CrossType.SECONDARY : CrossType.RED;
+ return CROSS_YELLOW;
+ return lowerCrossLevel >= 0 && blockLightLevel > lowerCrossLevel ? CROSS_SECONDARY : CROSS_RED;
}
public static int getCrossLevel(BlockPos pos, BlockPos down, BlockGetter world, LayerLightEventListener view, CollisionContext collisionContext) {
}
public static void renderCross(Camera camera, Level world, BlockPos pos, int color, CollisionContext collisionContext) {
- double d0 = camera.getPosition().x;
- double d1 = camera.getPosition().y - .005D;
+ double cameraX = camera.getPosition().x;
+ double cameraY = camera.getPosition().y - .005D;
+ double blockOffset = 0;
VoxelShape upperOutlineShape = world.getBlockState(pos).getShape(world, pos, collisionContext);
if (!upperOutlineShape.isEmpty())
- d1 -= upperOutlineShape.max(Direction.Axis.Y);
- double d2 = camera.getPosition().z;
+ blockOffset += upperOutlineShape.max(Direction.Axis.Y);
+ double cameraZ = camera.getPosition().z;
int red = (color >> 16) & 255;
int green = (color >> 8) & 255;
int y = pos.getY();
int z = pos.getZ();
RenderSystem.color4f(red / 255f, green / 255f, blue / 255f, 1f);
- GL11.glVertex3d(x + .01 - d0, y - d1, z + .01 - d2);
- GL11.glVertex3d(x - .01 + 1 - d0, y - d1, z - .01 + 1 - d2);
- GL11.glVertex3d(x - .01 + 1 - d0, y - d1, z + .01 - d2);
- GL11.glVertex3d(x + .01 - d0, y - d1, z - .01 + 1 - d2);
+ GL11.glVertex3d(x + .01 - cameraX, y - cameraY + blockOffset, z + .01 - cameraZ);
+ GL11.glVertex3d(x - .01 + 1 - cameraX, y - cameraY + blockOffset, z - .01 + 1 - cameraZ);
+ GL11.glVertex3d(x - .01 + 1 - cameraX, y - cameraY + blockOffset, z + .01 - cameraZ);
+ GL11.glVertex3d(x + .01 - cameraX, y - cameraY + blockOffset, z - .01 + 1 - cameraZ);
}
@SuppressWarnings("deprecation")
- public static void renderLevel(Minecraft client, Camera camera, Level world, BlockPos pos, BlockPos down, int level, CollisionContext collisionContext) {
+ public static void renderLevel(Minecraft client, Camera camera, Level world, BlockPos pos, BlockPos down, byte level, CollisionContext collisionContext) {
String text = String.valueOf(level);
- Font textRenderer_1 = client.font;
- double double_4 = camera.getPosition().x;
- double double_5 = camera.getPosition().y;
+ Font font = client.font;
+ double cameraX = camera.getPosition().x;
+ double cameraY = camera.getPosition().y;
VoxelShape upperOutlineShape = world.getBlockState(down).getShape(world, down, collisionContext);
if (!upperOutlineShape.isEmpty())
- double_5 += 1 - upperOutlineShape.max(Direction.Axis.Y);
- double double_6 = camera.getPosition().z;
+ cameraY += 1 - upperOutlineShape.max(Direction.Axis.Y);
+ double cameraZ = camera.getPosition().z;
RenderSystem.pushMatrix();
- RenderSystem.translatef((float) (pos.getX() + 0.5f - double_4), (float) (pos.getY() - double_5) + 0.005f, (float) (pos.getZ() + 0.5f - double_6));
+ RenderSystem.translatef((float) (pos.getX() + 0.5f - cameraX), (float) (pos.getY() - cameraY) + 0.005f, (float) (pos.getZ() + 0.5f - cameraZ));
RenderSystem.rotatef(90, 1, 0, 0);
RenderSystem.normal3f(0.0F, 1.0F, 0.0F);
float size = 0.07F;
RenderSystem.scalef(-size, -size, size);
- float float_3 = (float) (-textRenderer_1.width(text)) / 2.0F + 0.4f;
+ float float_3 = (float) (-font.width(text)) / 2.0F + 0.4f;
RenderSystem.enableAlphaTest();
- MultiBufferSource.BufferSource immediate = MultiBufferSource.immediate(Tesselator.getInstance().getBuilder());
- textRenderer_1.drawInBatch(text, float_3, -3.5f, level > higherCrossLevel ? 0xff042404 : (lowerCrossLevel >= 0 && level > lowerCrossLevel ? 0xff0066ff : 0xff731111), false, Transformation.identity().getMatrix(), immediate, false, 0, 15728880);
- immediate.endBatch();
+ MultiBufferSource.BufferSource source = MultiBufferSource.immediate(Tesselator.getInstance().getBuilder());
+ font.drawInBatch(text, float_3, -3.5f, level > higherCrossLevel ? 0xff042404 : (lowerCrossLevel >= 0 && level > lowerCrossLevel ? 0xff0066ff : 0xff731111), false, Transformation.identity().getMatrix(), source, false, 0, 15728880);
+ source.endBatch();
RenderSystem.popMatrix();
}
showNumber = ((String) properties.computeIfAbsent("showNumber", a -> "false")).equalsIgnoreCase("true");
smoothLines = ((String) properties.computeIfAbsent("smoothLines", a -> "true")).equalsIgnoreCase("true");
underwater = ((String) properties.computeIfAbsent("underwater", a -> "false")).equalsIgnoreCase("true");
+ mushroom = ((String) properties.computeIfAbsent("mushroom", a -> "false")).equalsIgnoreCase("true");
+ useListWhileCaching = ((String) properties.computeIfAbsent("useListWhileCaching", a -> "true")).equalsIgnoreCase("true");
lineWidth = Float.parseFloat((String) properties.computeIfAbsent("lineWidth", a -> "1"));
{
int r, g, b;
showNumber = false;
smoothLines = true;
underwater = false;
+ mushroom = false;
+ useListWhileCaching = true;
try {
saveConfig(file);
} catch (IOException ex) {
if (secondaryLevel >= crossLevel) System.err.println("[Light Overlay] Secondary Level is higher than Cross Level");
lowerCrossLevel = Math.min(crossLevel, secondaryLevel);
higherCrossLevel = Math.max(crossLevel, secondaryLevel);
+ for (ChunkData data : CHUNK_MAP.values()) {
+ data.close();
+ }
CHUNK_MAP.clear();
POS.clear();
}
fos.write("\n".getBytes());
fos.write(("underwater=" + underwater).getBytes());
fos.write("\n".getBytes());
+ fos.write(("mushroom=" + mushroom).getBytes());
+ fos.write("\n".getBytes());
+ fos.write(("useListWhileCaching=" + useListWhileCaching).getBytes());
+ fos.write("\n".getBytes());
fos.write(("lineWidth=" + FORMAT.format(lineWidth)).getBytes());
fos.write("\n".getBytes());
fos.write(("yellowColorRed=" + ((yellowColor >> 16) & 255)).getBytes());
private static void tick(Minecraft minecraft) {
while (enableOverlay.consumeClick())
enabled = !enabled;
-
+
try {
ticks++;
if (CLIENT.player == null || !enabled) {
POS.clear();
CALCULATING_POS.clear();
EXECUTOR.getQueue().clear();
+ for (ChunkData data : CHUNK_MAP.values()) {
+ data.close();
+ }
CHUNK_MAP.clear();
} else {
LocalPlayer player = CLIENT.player;
ClientLevel world = CLIENT.level;
CollisionContext collisionContext = CollisionContext.of(player);
-
+
if (!caching) {
CALCULATING_POS.clear();
POS.clear();
+ for (ChunkData data : CHUNK_MAP.values()) {
+ data.close();
+ }
CHUNK_MAP.clear();
BlockPos playerPos = player.blockPosition();
LayerLightEventListener block = world.getLightEngine().getLayerListener(LightLayer.BLOCK);
BlockPos.MutableBlockPos downPos = new BlockPos.MutableBlockPos();
Iterable<BlockPos> iterate = BlockPos.betweenClosed(playerPos.getX() - reach, playerPos.getY() - reach, playerPos.getZ() - reach,
playerPos.getX() + reach, playerPos.getY() + reach, playerPos.getZ() + reach);
- Long2ReferenceMap<Object> map = new Long2ReferenceOpenHashMap<>();
- CHUNK_MAP.put(new ChunkPos(0, 0), map);
+ ChunkData chunkData = new ChunkData();
+ CHUNK_MAP.put(new CubicChunkPos(0, 0, 0), chunkData);
for (BlockPos blockPos : iterate) {
downPos.set(blockPos.getX(), blockPos.getY() - 1, blockPos.getZ());
if (showNumber) {
int level = getCrossLevel(blockPos, downPos, world, block, collisionContext);
if (level >= 0) {
- map.put(blockPos.asLong(), Byte.valueOf((byte) level));
+ chunkData.data().put(blockPos.asLong(), (byte) level);
}
} else {
- Biome biome = mushroom ? world.getBiome(blockPos) : null;
- CrossType type = getCrossType(blockPos, biome, downPos, world, block, sky, collisionContext);
- if (type != CrossType.NONE) {
- map.put(blockPos.asLong(), type);
+ Biome biome = !mushroom ? world.getBiome(blockPos) : null;
+ byte type = getCrossType(blockPos, biome, downPos, world, block, sky, collisionContext);
+ if (type != CROSS_NONE) {
+ chunkData.data().put(blockPos.asLong(), type);
}
}
}
} else {
int playerPosX = ((int) player.getX()) >> 4;
+ int playerPosY = ((int) player.getY()) >> 4;
int playerPosZ = ((int) player.getZ()) >> 4;
for (int chunkX = playerPosX - getChunkRange(); chunkX <= playerPosX + getChunkRange(); chunkX++) {
- for (int chunkZ = playerPosZ - getChunkRange(); chunkZ <= playerPosZ + getChunkRange(); chunkZ++) {
- if (Mth.abs(chunkX - playerPosX) > getChunkRange() || Mth.abs(chunkZ - playerPosZ) > getChunkRange())
- continue;
- ChunkPos chunkPos = new ChunkPos(chunkX, chunkZ);
- if (!CHUNK_MAP.containsKey(chunkPos))
- queueChunk(chunkPos);
+ for (int chunkY = Math.max(playerPosY - getChunkRange(), 0); chunkY <= playerPosY + getChunkRange() && chunkY <= 15; chunkY++) {
+ for (int chunkZ = playerPosZ - getChunkRange(); chunkZ <= playerPosZ + getChunkRange(); chunkZ++) {
+ if (Mth.abs(chunkX - playerPosX) > getChunkRange() || Mth.abs(chunkY - playerPosY) > getChunkRange() || Mth.abs(chunkZ - playerPosZ) > getChunkRange())
+ continue;
+ CubicChunkPos chunkPos = new CubicChunkPos(chunkX, chunkY, chunkZ);
+ if (!CHUNK_MAP.containsKey(chunkPos))
+ queueChunk(chunkPos);
+ }
}
}
for (int p = 0; p < 3; p++) {
if (EXECUTOR.getQueue().size() >= Runtime.getRuntime().availableProcessors()) break;
double d1 = Double.MAX_VALUE, d2 = Double.MAX_VALUE, d3 = Double.MAX_VALUE;
- ChunkPos c1 = null, c2 = null, c3 = null;
+ CubicChunkPos c1 = null, c2 = null, c3 = null;
synchronized (POS) {
- Iterator<ChunkPos> iterator = POS.iterator();
+ Iterator<CubicChunkPos> iterator = POS.iterator();
while (iterator.hasNext()) {
- ChunkPos pos = iterator.next();
- if (Mth.abs(pos.x - playerPosX) > getChunkRange() || Mth.abs(pos.z - playerPosZ) > getChunkRange() || CALCULATING_POS.contains(pos)) {
+ CubicChunkPos pos = iterator.next();
+ if (Mth.abs(pos.x - playerPosX) > getChunkRange() || Mth.abs(pos.y - playerPosY) > getChunkRange() || Mth.abs(pos.z - playerPosZ) > getChunkRange() || CALCULATING_POS.contains(pos)) {
iterator.remove();
} else {
- if (isFrustumVisible(frustum, pos.getMinBlockX(), 0, pos.getMinBlockZ(), pos.getMaxBlockX(), 256, pos.getMaxBlockZ())) {
+ if (isFrustumVisible(frustum, pos.getMinBlockX(), pos.getMinBlockY(), pos.getMinBlockZ(), pos.getMaxBlockX(), pos.getMaxBlockY(), pos.getMaxBlockZ())) {
int i = Math.abs(pos.x - playerPosX);
- int j = Math.abs(pos.z - playerPosZ);
- double distance = Math.sqrt(i * i + j * j);
+ int j = Math.abs(pos.y - playerPosY);
+ int k = Math.abs(pos.z - playerPosZ);
+ double distance = Math.sqrt(i * i + j * j + k * k);
if (distance < d1) {
d3 = d2;
d2 = d1;
}
}
}
- ChunkPos finalC1 = c1;
- ChunkPos finalC2 = c2;
- ChunkPos finalC3 = c3;
+ CubicChunkPos finalC1 = c1;
+ CubicChunkPos finalC2 = c2;
+ CubicChunkPos finalC3 = c3;
if (finalC1 != null) {
CALCULATING_POS.add(finalC1);
if (finalC2 != null) {
}
EXECUTOR.submit(() -> {
int playerPosX1 = ((int) CLIENT.player.getX()) >> 4;
+ int playerPosY1 = ((int) CLIENT.player.getY()) >> 4;
int playerPosZ1 = ((int) CLIENT.player.getZ()) >> 4;
- if (finalC1 != null) processChunk(finalC1, playerPosX1, playerPosZ1, collisionContext);
- if (finalC2 != null) processChunk(finalC2, playerPosX1, playerPosZ1, collisionContext);
- if (finalC3 != null) processChunk(finalC3, playerPosX1, playerPosZ1, collisionContext);
+ if (finalC1 != null) processChunk(finalC1, playerPosX1, playerPosY1, playerPosZ1, collisionContext);
+ if (finalC2 != null) processChunk(finalC2, playerPosX1, playerPosY1, playerPosZ1, collisionContext);
+ if (finalC3 != null) processChunk(finalC3, playerPosX1, playerPosY1, playerPosZ1, collisionContext);
});
}
}
if (ticks % 50 == 0) {
- CHUNK_MAP.entrySet().removeIf(pos -> Mth.abs(pos.getKey().x - playerPosX) > getChunkRange() * 2 || Mth.abs(pos.getKey().z - playerPosZ) > getChunkRange() * 2);
+ Iterator<Map.Entry<CubicChunkPos, ChunkData>> iterator = CHUNK_MAP.entrySet().iterator();
+ while (iterator.hasNext()) {
+ Map.Entry<CubicChunkPos, ChunkData> entry = iterator.next();
+ if (Mth.abs(entry.getKey().x - playerPosX) > getChunkRange() * 2 || Mth.abs(entry.getKey().y - playerPosY) > getChunkRange() * 2 || Mth.abs(entry.getKey().z - playerPosZ) > getChunkRange() * 2) {
+ entry.getValue().close();
+ iterator.remove();
+ }
+ }
}
}
}
}
}
- private enum CrossType {
- YELLOW,
- RED,
- SECONDARY,
- NONE
- }
+ public static final byte CROSS_YELLOW = 0;
+ public static final byte CROSS_RED = 1;
+ public static final byte CROSS_SECONDARY = 2;
+ public static final byte CROSS_NONE = 2;
}
projects / LightOverlay.git / blobdiff