mirrors/Iris
1
0
Fork 0
mirror of https://github.com/VolmitSoftware/Iris.git synced 2025-07-19 10:43:14 +00:00
Code Issues Packages Projects Releases Wiki Activity

Drop BKCommonLib (unused)

Browse Source
This commit is contained in:
Daniel Mills 2021-07-30 08:52:06 -04:00
parent e2b533db64
commit 8ee39d3822
19 changed files with 0 additions and 3462 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
build.gradle
View File

@ -96,7 +96,6 @@ dependencies {
implementation 'org.bukkit.craftbukkit:1.16.5:1.16.5' implementation 'org.bukkit.craftbukkit:1.16.5:1.16.5'
implementation 'org.bukkit.craftbukkit:1.16.3:1.16.3' implementation 'org.bukkit.craftbukkit:1.16.3:1.16.3'
implementation 'org.bukkit.craftbukkit:1.16.1:1.16.1' implementation 'org.bukkit.craftbukkit:1.16.1:1.16.1'
implementation 'com.bergerkiller.bukkit:BKCommonLib:1.16.4-v2'
implementation 'com.sk89q.worldedit:worldedit-bukkit:7.2.0-SNAPSHOT' implementation 'com.sk89q.worldedit:worldedit-bukkit:7.2.0-SNAPSHOT'
implementation 'io.lumine.xikage:MythicMobs:4.9.1' implementation 'io.lumine.xikage:MythicMobs:4.9.1'
implementation 'com.google.code.gson:gson:2.8.5' implementation 'com.google.code.gson:gson:2.8.5'

3
src/main/java/com/volmit/iris/Iris.java
View File

@ -22,7 +22,6 @@ import com.volmit.iris.core.*;
import com.volmit.iris.core.command.CommandIris; import com.volmit.iris.core.command.CommandIris;
import com.volmit.iris.core.command.PermissionIris; import com.volmit.iris.core.command.PermissionIris;
import com.volmit.iris.core.command.world.CommandLocate; import com.volmit.iris.core.command.world.CommandLocate;
import com.volmit.iris.core.link.BKLink;
import com.volmit.iris.core.link.MultiverseCoreLink; import com.volmit.iris.core.link.MultiverseCoreLink;
import com.volmit.iris.core.link.MythicMobsLink; import com.volmit.iris.core.link.MythicMobsLink;
import com.volmit.iris.core.nms.INMS; import com.volmit.iris.core.nms.INMS;
@ -75,7 +74,6 @@ public class Iris extends VolmitPlugin implements Listener {
public static WandManager wand; public static WandManager wand;
public static EditManager edit; public static EditManager edit;
public static IrisBoardManager board; public static IrisBoardManager board;
public static BKLink linkBK;
public static MultiverseCoreLink linkMultiverseCore; public static MultiverseCoreLink linkMultiverseCore;
public static MythicMobsLink linkMythicMobs; public static MythicMobsLink linkMythicMobs;
public static TreeManager saplingManager; public static TreeManager saplingManager;
@ -180,7 +178,6 @@ public class Iris extends VolmitPlugin implements Listener {
wand = new WandManager(); wand = new WandManager();
board = new IrisBoardManager(); board = new IrisBoardManager();
linkMultiverseCore = new MultiverseCoreLink(); linkMultiverseCore = new MultiverseCoreLink();
linkBK = new BKLink();
linkMythicMobs = new MythicMobsLink(); linkMythicMobs = new MythicMobsLink();
saplingManager = new TreeManager(); saplingManager = new TreeManager();
edit = new EditManager(); edit = new EditManager();

46
src/main/java/com/volmit/iris/core/link/BKLink.java
View File

@ -1,46 +0,0 @@
/*
* Iris is a World Generator for Minecraft Bukkit Servers
* Copyright (c) 2021 Arcane Arts (Volmit Software)
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.volmit.iris.core.link;
import org.bukkit.Bukkit;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.block.data.BlockData;
import org.bukkit.plugin.Plugin;
public class BKLink {
public BKLink() {
}
public void updateBlock(Block b) {
BlockData d = b.getBlockData();
b.setType(Material.AIR, false);
b.setBlockData(d, true);
}
public boolean supported() {
return getBK() != null;
}
public Plugin getBK() {
return Bukkit.getPluginManager().getPlugin("BKCommonLib");
}
}

36
src/main/java/com/volmit/iris/engine/lighting/BlockFaceSetSection.java
View File

@ -1,36 +0,0 @@
/*
* Iris is a World Generator for Minecraft Bukkit Servers
* Copyright (c) 2021 Arcane Arts (Volmit Software)
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.volmit.iris.engine.lighting;
import com.bergerkiller.bukkit.common.collections.BlockFaceSet;
/**
* Maps {@link BlockFaceSet} values to a 16x16x16 area of blocks
*/
public class BlockFaceSetSection {
private final byte[] _maskData = new byte[4096];
public void set(int x, int y, int z, BlockFaceSet faces) {
_maskData[(y << 8) | (z << 4) | x] = (byte) faces.mask();
}
public BlockFaceSet get(int x, int y, int z) {
return BlockFaceSet.byMask(_maskData[(y << 8) | (z << 4) | x]);
}
}

169
src/main/java/com/volmit/iris/engine/lighting/FlatRegionInfo.java
View File

@ -1,169 +0,0 @@
/*
* Iris is a World Generator for Minecraft Bukkit Servers
* Copyright (c) 2021 Arcane Arts (Volmit Software)
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.volmit.iris.engine.lighting;
import com.bergerkiller.bukkit.common.utils.WorldUtil;
import org.bukkit.World;
import java.util.Arrays;
import java.util.BitSet;
import java.util.stream.IntStream;
/**
* Loads region information, storing whether or not
* the 32x32 (1024) chunks are available.
*/
public class FlatRegionInfo {
private static final int[] DEFAULT_RY_0 = new int[]{0}; // Optimization
public final World world;
public final int rx, rz;
public final int[] ry;
public final int cx, cz;
private final BitSet _chunks;
private boolean _loadedFromDisk;
public FlatRegionInfo(World world, int rx, int ry, int rz) {
this(world, rx, (ry == 0) ? DEFAULT_RY_0 : new int[]{ry}, rz);
}
public FlatRegionInfo(World world, int rx, int[] ry, int rz) {
this.world = world;
this.rx = rx;
this.rz = rz;
this.ry = ry;
this.cx = (rx << 5);
this.cz = (rz << 5);
this._chunks = new BitSet(1024);
this._loadedFromDisk = false;
}
private FlatRegionInfo(FlatRegionInfo copy, int[] new_ry) {
this.world = copy.world;
this.rx = copy.rx;
this.ry = new_ry;
this.rz = copy.rz;
this.cx = copy.cx;
this.cz = copy.cz;
this._chunks = copy._chunks;
this._loadedFromDisk = copy._loadedFromDisk;
}
public void addChunk(int cx, int cz) {
cx -= this.cx;
cz -= this.cz;
if (cx < 0 || cx >= 32 || cz < 0 || cz >= 32) {
return;
}
this._chunks.set((cz << 5) | cx);
}
/**
* Gets the number of chunks in this region.
* If not loaded yet, the default 1024 is returned.
*
* @return chunk count
*/
public int getChunkCount() {
return this._chunks.cardinality();
}
/**
* Gets the region Y-coordinates as a sorted, immutable distinct stream
*
* @return ry int stream
*/
public IntStream getRYStream() {
return IntStream.of(this.ry);
}
/**
* Loads the region information, now telling what chunks are contained
*/
public void load() {
if (!this._loadedFromDisk) {
this._loadedFromDisk = true;
for (int ry : this.ry) {
this._chunks.or(WorldUtil.getWorldSavedRegionChunks3(this.world, this.rx, ry, this.rz));
}
}
}
/**
* Ignores loading region chunk information from chunks that aren't loaded
*/
public void ignoreLoad() {
this._loadedFromDisk = true;
}
/**
* Gets whether the chunk coordinates specified are within the range
* of coordinates of this region
*
* @param cx - chunk coordinates (world coordinates)
* @param cz - chunk coordinates (world coordinates)
* @return True if in range
*/
public boolean isInRange(int cx, int cz) {
cx -= this.cx;
cz -= this.cz;
return cx >= 0 && cz >= 0 && cx < 32 && cz < 32;
}
/**
* Gets whether a chunk is contained and exists inside this region
*
* @param cx - chunk coordinates (world coordinates)
* @param cz - chunk coordinates (world coordinates)
* @return True if the chunk is contained
*/
public boolean containsChunk(int cx, int cz) {
cx -= this.cx;
cz -= this.cz;
if (cx < 0 || cx >= 32 || cz < 0 || cz >= 32) {
return false;
}
// Load region file information the first time this is accessed
this.load();
// Check in bitset
return this._chunks.get((cz << 5) | cx);
}
/**
* Adds another Region Y-coordinate to the list.
* The set of chunks and other properties are copied.
*
* @return new flat region info object with updated ry
*/
public FlatRegionInfo addRegionYCoordinate(int ry) {
int index = Arrays.binarySearch(this.ry, ry);
if (index >= 0) {
return this; // Already contained
}
// Insert at this index (undo insertion point - 1)
index = -index - 1;
int[] new_y_coordinates = new int[this.ry.length + 1];
System.arraycopy(this.ry, 0, new_y_coordinates, 0, index);
new_y_coordinates[index] = ry;
System.arraycopy(this.ry, index, new_y_coordinates, index + 1, this.ry.length - index);
return new FlatRegionInfo(this, new_y_coordinates);
}
}

198
src/main/java/com/volmit/iris/engine/lighting/FlatRegionInfoMap.java
View File

@ -1,198 +0,0 @@
/*
* Iris is a World Generator for Minecraft Bukkit Servers
* Copyright (c) 2021 Arcane Arts (Volmit Software)
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.volmit.iris.engine.lighting;
import com.bergerkiller.bukkit.common.bases.IntVector3;
import com.bergerkiller.bukkit.common.utils.MathUtil;
import com.bergerkiller.bukkit.common.utils.WorldUtil;
import com.bergerkiller.bukkit.common.wrappers.LongHashMap;
import org.bukkit.Chunk;
import org.bukkit.World;
import java.util.Collection;
import java.util.Set;
import java.util.stream.IntStream;
/**
* A map of region information
*/
public class FlatRegionInfoMap {
private final World _world;
private final LongHashMap<FlatRegionInfo> _regions;
private FlatRegionInfoMap(World world, LongHashMap<FlatRegionInfo> regions) {
this._world = world;
this._regions = regions;
}
public World getWorld() {
return this._world;
}
public int getRegionCount() {
return this._regions.size();
}
public Collection<FlatRegionInfo> getRegions() {
return this._regions.getValues();
}
public FlatRegionInfo getRegion(int rx, int rz) {
return this._regions.get(rx, rz);
}
public FlatRegionInfo getRegionAtChunk(int cx, int cz) {
return this._regions.get(cx >> 5, cz >> 5);
}
/**
* Gets whether a chunk exists
*
* @return True if the chunk exists
*/
public boolean containsChunk(int cx, int cz) {
FlatRegionInfo region = getRegionAtChunk(cx, cz);
return region != null && region.containsChunk(cx, cz);
}
/**
* Gets whether a chunk, and all its 8 neighbours, exist
*
* @return True if the chunk and all its neighbours exist
*/
public boolean containsChunkAndNeighbours(int cx, int cz) {
FlatRegionInfo region = getRegionAtChunk(cx, cz);
if (region == null) {
return false;
}
for (int dx = -2; dx <= 2; dx++) {
for (int dz = -2; dz <= 2; dz++) {
int mx = cx + dx;
int mz = cz + dz;
if (region.isInRange(mx, mz)) {
if (!region.containsChunk(mx, mz)) {
return false;
}
} else {
if (!this.containsChunk(mx, mz)) {
return false;
}
}
}
}
return true;
}
/**
* Computes all the region Y-coordinates used by a region and its neighbouring 8 regions.
* The returned array is sorted in increasing order and is distinct (no duplicate values).
*
* @return region and neighbouring regions' Y-coordinates
*/
public int[] getRegionYCoordinatesSelfAndNeighbours(FlatRegionInfo region) {
IntStream region_y_coord_stream = region.getRYStream();
for (int drx = -1; drx <= 1; drx++) {
for (int drz = -1; drz <= 1; drz++) {
if (drx == 0 && drz == 0) {
continue;
}
FlatRegionInfo neigh_region = this.getRegion(region.rx + drx, region.rz + drz);
if (neigh_region != null) {
region_y_coord_stream = IntStream.concat(region_y_coord_stream, neigh_region.getRYStream());
}
}
}
//TODO: There's technically a way to significantly speed up sorting two concatenated sorted streams
// Sadly, the java 8 SDK doesn't appear to do any optimizations here :(
return region_y_coord_stream.sorted().distinct().toArray();
}
/**
* Creates a region information mapping of all existing chunks of a world
* that are currently loaded. No further loading is required.
*
* @return region info map
*/
public static FlatRegionInfoMap createLoaded(World world) {
LongHashMap<FlatRegionInfo> regions = new LongHashMap<>();
for (Chunk chunk : world.getLoadedChunks()) {
int rx = WorldUtil.chunkToRegionIndex(chunk.getX());
int rz = WorldUtil.chunkToRegionIndex(chunk.getZ());
FlatRegionInfo prev_info = regions.get(rx, rz);
FlatRegionInfo new_info = prev_info;
if (new_info == null) {
new_info = new FlatRegionInfo(world, rx, 0, rz);
new_info.ignoreLoad();
}
// Refresh y-coordinates
for (Integer y_coord : WorldUtil.getLoadedSectionCoordinates(chunk)) {
new_info = new_info.addRegionYCoordinate(WorldUtil.chunkToRegionIndex(y_coord));
}
// Add chunk to region bitset
new_info.addChunk(chunk.getX(), chunk.getZ());
// Store if new or changed
if (new_info != prev_info) {
regions.put(rx, rz, new_info);
}
}
return new FlatRegionInfoMap(world, regions);
}
/**
* Creates a region information mapping of all existing chunks of a world
*
* @return region info map
*/
public static FlatRegionInfoMap create(World world) {
LongHashMap<FlatRegionInfo> regions = new LongHashMap<>();
// Obtain the region coordinates in 3d space (vertical too!)
Set<IntVector3> regionCoordinates = WorldUtil.getWorldRegions3(world);
// For each region, create a RegionInfo entry
for (IntVector3 region : regionCoordinates) {
long key = MathUtil.longHashToLong(region.x, region.z);
FlatRegionInfo prev = regions.get(key);
if (prev != null) {
regions.put(key, prev.addRegionYCoordinate(region.y));
} else {
regions.put(key, new FlatRegionInfo(world, region.x, region.y, region.z));
}
}
// For all loaded chunks, add those chunks to their region up-front
// They may not yet have been saved to the region file
for (Chunk chunk : world.getLoadedChunks()) {
int rx = WorldUtil.chunkToRegionIndex(chunk.getX());
int rz = WorldUtil.chunkToRegionIndex(chunk.getZ());
FlatRegionInfo info = regions.get(rx, rz);
if (info != null) {
info.addChunk(chunk.getX(), chunk.getZ());
}
}
return new FlatRegionInfoMap(world, regions);
}
}

118
src/main/java/com/volmit/iris/engine/lighting/LightingAutoClean.java
View File

@ -1,118 +0,0 @@
/*
* Iris is a World Generator for Minecraft Bukkit Servers
* Copyright (c) 2021 Arcane Arts (Volmit Software)
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.volmit.iris.engine.lighting;
import com.bergerkiller.bukkit.common.Task;
import com.bergerkiller.bukkit.common.utils.WorldUtil;
import com.bergerkiller.bukkit.common.wrappers.LongHashSet;
import com.volmit.iris.Iris;
import org.bukkit.World;
import java.util.HashMap;
/**
* Handles the automatic cleanup of chunk lighting when chunks are generated
*/
public class LightingAutoClean {
private static final HashMap<World, LongHashSet> queues = new HashMap<>();
private static Task autoCleanTask = null;
/**
* Checks all neighbouring chunks to see if they are fully surrounded by chunks (now), and
* schedules lighting repairs. This function only does anything when automatic cleaning is activated.
*
* @param world the chunk is in
* @param chunkX coordinate
* @param chunkZ coordinate
*/
public static void handleChunkGenerated(World world, int chunkX, int chunkZ) {
for (int dx = -1; dx <= 1; dx++) {
for (int dz = -1; dz <= 1; dz++) {
if (dx == 0 && dz == 0) {
continue;
}
if (!WorldUtil.isChunkAvailable(world, chunkX + dx, chunkZ + dz)) {
continue;
}
// Check that all chunks surrounding this chunk are all available
boolean allNeighboursLoaded = true;
for (int dx2 = -1; dx2 <= 1 && allNeighboursLoaded; dx2++) {
for (int dz2 = -1; dz2 <= 1 && allNeighboursLoaded; dz2++) {
if (dx2 == 0 && dz2 == 0) {
continue; // ignore self
}
if (dx2 == -dx && dz2 == -dz) {
continue; // ignore the original generated chunk
}
allNeighboursLoaded &= WorldUtil.isChunkAvailable(world, chunkX + dx + dx2, chunkZ + dz + dz2);
}
}
// If all neighbours are available, schedule it for fixing
if (allNeighboursLoaded) {
schedule(world, chunkX + dx, chunkZ + dz);
}
}
}
}
private static synchronized void processAutoClean() {
while (queues.size() > 0) {
World world = queues.keySet().iterator().next();
LongHashSet chunks = queues.remove(world);
LightingService.schedule(world, chunks);
}
}
public static void schedule(World world, int chunkX, int chunkZ) {
schedule(world, chunkX, chunkZ, 80);
}
public static synchronized void schedule(World world, int chunkX, int chunkZ, int tickDelay) {
LongHashSet queue = queues.get(world);
if (queue == null) {
queue = new LongHashSet(9);
queues.put(world, queue);
}
// Queue this chunk, and all its neighbours
for (int dx = -1; dx <= 1; dx++) {
for (int dz = -1; dz <= 1; dz++) {
queue.add(chunkX + dx, chunkZ + dz);
}
}
// Initialize clean task if it hasn't been yet
if (autoCleanTask == null) {
autoCleanTask = new Task(Iris.instance) {
@Override
public void run() {
processAutoClean();
}
};
}
// Postpone the tick task while there are less than 100 chunks in the queue
if (queue.size() < 100) {
autoCleanTask.stop().start(tickDelay);
}
}
}

198
src/main/java/com/volmit/iris/engine/lighting/LightingCategory.java
View File

@ -1,198 +0,0 @@
/*
* Iris is a World Generator for Minecraft Bukkit Servers
* Copyright (c) 2021 Arcane Arts (Volmit Software)
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.volmit.iris.engine.lighting;
import com.bergerkiller.bukkit.common.collections.BlockFaceSet;
/**
* Represents a category of light being processed. All conditional logic
* for this is handled by this class.
*/
public enum LightingCategory {
SKY() {
@Override
public String getName() {
return "Sky";
}
@Override
public void initialize(LightingChunk chunk) {
if (!chunk.hasSkyLight) {
return;
}
// Find out the highest possible Y-position
int x, y, z, light, height, opacity;
BlockFaceSet opaqueFaces;
LightingCube cube = null;
// Apply initial sky lighting from top to bottom
for (z = chunk.start.z; z <= chunk.end.z; z++) {
for (x = chunk.start.x; x <= chunk.end.x; x++) {
light = 15;
height = chunk.getHeight(x, z) + 1;
for (y = chunk.maxY; y >= chunk.minY; y--) {
if ((cube = chunk.nextCube(cube, y)) == null) {
// Skip the remaining 15: they are all inaccessible as well
y -= 15;
// If not full skylight, reset light level, assuming it dimmed out
if (light != 15) {
light = 0;
}
continue;
}
// Set quickly when light level is at 0, or we are above height level
if (y > height || light <= 0) {
cube.skyLight.set(x, y & 0xf, z, light);
continue;
}
// If opaque at the top, set light to 0 instantly
opaqueFaces = cube.getOpaqueFaces(x, y & 0xf, z);
if (opaqueFaces.up()) {
light = 0;
} else {
// Apply the opacity to the light level
opacity = cube.opacity.get(x, y & 0xf, z);
if (light < 15 && opacity == 0) {
opacity = 1;
}
if ((light -= opacity) <= 0) {
light = 0;
}
}
// Apply sky light to block
cube.skyLight.set(x, y & 0xf, z, light);
// If opaque at the bottom, reset light to 0 for next block
// The block itself is lit
if (opaqueFaces.down()) {
light = 0;
}
}
}
}
}
@Override
public int getStartY(LightingChunk chunk, int x, int z) {
return chunk.getHeight(x, z);
}
@Override
public void setDirty(LightingChunk chunk, boolean dirty) {
chunk.isSkyLightDirty = dirty;
}
@Override
public int get(LightingCube section, int x, int y, int z) {
return section.skyLight.get(x, y, z);
}
@Override
public void set(LightingCube section, int x, int y, int z, int level) {
section.skyLight.set(x, y, z, level);
}
},
BLOCK() {
@Override
public String getName() {
return "Block";
}
@Override
public void initialize(LightingChunk chunk) {
// Some blocks that emit light, also have opaque faces
// They still emit light through the opaque faces to other blocks
// To fix this, run an initial processing step that spreads all
// emitted light to the neighbouring blocks' block light, ignoring own opaque faces
int x, y, z;
for (LightingCube cube : chunk.getSections()) {
for (y = 0; y < 16; y++) {
for (z = chunk.start.z; z <= chunk.end.z; z++) {
for (x = chunk.start.x; x <= chunk.end.x; x++) {
cube.spreadBlockLight(x, y, z);
}
}
}
}
}
@Override
public int getStartY(LightingChunk chunk, int x, int z) {
return chunk.maxY;
}
@Override
public void setDirty(LightingChunk chunk, boolean dirty) {
chunk.isBlockLightDirty = dirty;
}
@Override
public int get(LightingCube section, int x, int y, int z) {
return section.blockLight.get(x, y, z);
}
@Override
public void set(LightingCube section, int x, int y, int z, int level) {
section.blockLight.set(x, y, z, level);
}
};
/**
* Gets the name of this type of light, used when logging
*
* @return category name
*/
public abstract String getName();
/**
* Initializes the lighting in the chunk for this category
*/
public abstract void initialize(LightingChunk chunk);
/**
* Gets the y-coordinate to start processing from when spreading light around
*
* @return start y-coordinate
*/
public abstract int getStartY(LightingChunk chunk, int x, int z);
/**
* Sets whether this category of light is dirty, indicating this category of light is all good,
* or that more work is needed spreading light around.
*/
public abstract void setDirty(LightingChunk chunk, boolean dirty);
/**
* Gets the light level in a section at the coordinates specified.
* No bounds checking is performed.
*
* @return light level
*/
public abstract int get(LightingCube section, int x, int y, int z);
/**
* Sets the light level in a section at the coordinates specified.
* No bounds checking is performed.
*/
public abstract void set(LightingCube section, int x, int y, int z, int level);
}

474
src/main/java/com/volmit/iris/engine/lighting/LightingChunk.java
View File

@ -1,474 +0,0 @@
/*
* Iris is a World Generator for Minecraft Bukkit Servers
* Copyright (c) 2021 Arcane Arts (Volmit Software)
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.volmit.iris.engine.lighting;
import com.bergerkiller.bukkit.common.bases.IntVector2;
import com.bergerkiller.bukkit.common.chunk.ForcedChunk;
import com.bergerkiller.bukkit.common.collections.BlockFaceSet;
import com.bergerkiller.bukkit.common.utils.ChunkUtil;
import com.bergerkiller.bukkit.common.utils.WorldUtil;
import com.bergerkiller.bukkit.common.wrappers.ChunkSection;
import com.bergerkiller.bukkit.common.wrappers.HeightMap;
import com.bergerkiller.bukkit.common.wrappers.IntHashMap;
import com.bergerkiller.generated.net.minecraft.server.ChunkHandle;
import com.volmit.iris.Iris;
import org.bukkit.Chunk;
import org.bukkit.World;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
/**
* Represents a single chunk full with lighting-relevant information.
* Initialization and use of this chunk in the process is as follows:<br>
* - New lighting chunks are created for all chunks to be processed<br>
* - notifyAccessible is called for all chunks, passing in all chunks<br>
* - fill/fillSection is called for all chunks, after which initLight is called<br>
* - spread is called on all chunks until all spreading is finished<br>
* - data from all LightingChunks/Sections is gathered and saved to chunks or region files<br>
* - possible chunk resends are performed
*/
public class LightingChunk {
public static final int OB = ~0xf; // Outside blocks
public static final int OC = ~0xff; // Outside chunk
public IntHashMap<LightingCube> sections;
public final LightingChunkNeighboring neighbors = new LightingChunkNeighboring();
public final int[] heightmap = new int[256];
public final World world;
public final int chunkX, chunkZ;
public boolean hasSkyLight = true;
public boolean isSkyLightDirty = true;
public boolean isBlockLightDirty = true;
public boolean isFilled = false;
public boolean isApplied = false;
public IntVector2 start = new IntVector2(1, 1);
public IntVector2 end = new IntVector2(14, 14);
public int minY = 0;
public int maxY = 0;
public final ForcedChunk forcedChunk = ForcedChunk.none();
public volatile boolean loadingStarted = false;
public LightingChunk(World world, int x, int z) {
this.world = world;
this.chunkX = x;
this.chunkZ = z;
}
/**
* Gets all the sections inside this chunk.
* Elements are never null.
*
* @return sections
*/
public Collection<LightingCube> getSections() {
return this.sections.values();
}
/**
* Efficiently iterates the vertical cubes of a chunk, only
* querying the lookup table every 16 blocks
*
* @param previous The previous cube we iterated
* @param y Block y-coordinate
* @return the cube at the Block y-coordinate, or null if this cube does not exist
*/
public LightingCube nextCube(LightingCube previous, int y) {
int cy = y >> 4;
if (previous != null && previous.cy == cy) {
return previous;
} else {
return this.sections.get(cy);
}
}
/**
* Notifies that a new chunk is accessible.
*
* @param chunk that is accessible
*/
public void notifyAccessible(LightingChunk chunk) {
final int dx = chunk.chunkX - this.chunkX;
final int dz = chunk.chunkZ - this.chunkZ;
// Only check neighbours, ignoring the corners and self
if (Math.abs(dx) > 1 || Math.abs(dz) > 1 || (dx != 0) == (dz != 0)) {
return;
}
// Results in -16, 16 or 0 for the x/z coordinates
neighbors.set(dx, dz, chunk);
// Update start/end coordinates
if (dx == 1) {
end = new IntVector2(15, end.z);
} else if (dx == -1) {
start = new IntVector2(0, start.z);
} else if (dz == 1) {
end = new IntVector2(end.x, 15);
} else if (dz == -1) {
start = new IntVector2(start.x, 0);
}
}
/**
* Initializes the neighboring cubes of all the cubes of this
* lighting chunk. This initializes the neighbors both within
* the same chunk (vertical) and for neighboring chunks (horizontal).
*/
public void detectCubeNeighbors() {
for (LightingCube cube : this.sections.values()) {
// Neighbors above and below
cube.neighbors.set(0, 1, 0, this.sections.get(cube.cy + 1));
cube.neighbors.set(0, -1, 0, this.sections.get(cube.cy - 1));
// Neighbors in neighboring chunks
cube.neighbors.set(-1, 0, 0, this.neighbors.getCube(-1, 0, cube.cy));
cube.neighbors.set(1, 0, 0, this.neighbors.getCube(1, 0, cube.cy));
cube.neighbors.set(0, 0, -1, this.neighbors.getCube(0, -1, cube.cy));
cube.neighbors.set(0, 0, 1, this.neighbors.getCube(0, 1, cube.cy));
}
}
public void fill(Chunk chunk, int[] region_y_coordinates) {
// Fill using chunk sections
hasSkyLight = WorldUtil.getDimensionType(chunk.getWorld()).hasSkyLight();
List<LightingCube> lightingChunkSectionList;
{
// First create a list of ChunkSection objects storing the data
// We must do this sequentially, because asynchronous access is not permitted
List<ChunkSection> chunkSectionList = IntStream.of(region_y_coordinates)
.map(WorldUtil::regionToChunkIndex)
.flatMap(base_cy -> IntStream.range(base_cy, base_cy + WorldUtil.CHUNKS_PER_REGION_AXIS))
.mapToObj(cy -> WorldUtil.getSection(chunk, cy))
.filter(Objects::nonNull)
.collect(Collectors.toList());
// Then process all the gathered chunk sections into a LightingChunkSection in parallel
lightingChunkSectionList = chunkSectionList.stream()
.parallel()
.map(section -> new LightingCube(this, section, hasSkyLight))
.collect(Collectors.toList());
}
// Add to mapping
this.sections = new IntHashMap<>();
for (LightingCube lightingChunkSection : lightingChunkSectionList) {
this.sections.put(lightingChunkSection.cy, lightingChunkSection);
}
// Compute min/max y using sections that are available
// Make use of the fact that they are pre-sorted by y-coordinate
this.minY = 0;
this.maxY = 0;
if (!lightingChunkSectionList.isEmpty()) {
this.minY = lightingChunkSectionList.get(0).cy << 4;
this.maxY = (lightingChunkSectionList.get(lightingChunkSectionList.size() - 1).cy << 4) + 15;
}
// Initialize and then load sky light heightmap information
if (this.hasSkyLight) {
HeightMap heightmap = ChunkUtil.getLightHeightMap(chunk, true);
for (int x = 0; x < 16; ++x) {
for (int z = 0; z < 16; ++z) {
this.heightmap[this.getHeightKey(x, z)] = Math.max(this.minY, heightmap.getHeight(x, z));
}
}
} else {
Arrays.fill(this.heightmap, this.maxY);
}
this.isFilled = true;
}
private int getHeightKey(int x, int z) {
return x | (z << 4);
}
/**
* Gets the height level (the top block that does not block light)
*
* @param x - coordinate
* @param z - coordinate
* @return height
*/
public int getHeight(int x, int z) {
return this.heightmap[getHeightKey(x, z)];
}
private final int getMaxLightLevel(LightingCube section, LightingCategory category, int lightLevel, int x, int y, int z) {
BlockFaceSet selfOpaqueFaces = section.getOpaqueFaces(x, y, z);
if (x >= 1 && z >= 1 && x <= 14 && z <= 14) {
// All within this chunk - simplified calculation
if (!selfOpaqueFaces.west()) {
lightLevel = section.getLightIfHigher(category, lightLevel,
BlockFaceSet.MASK_EAST, x - 1, y, z);
}
if (!selfOpaqueFaces.east()) {
lightLevel = section.getLightIfHigher(category, lightLevel,
BlockFaceSet.MASK_WEST, x + 1, y, z);
}
if (!selfOpaqueFaces.north()) {
lightLevel = section.getLightIfHigher(category, lightLevel,
BlockFaceSet.MASK_SOUTH, x, y, z - 1);
}
if (!selfOpaqueFaces.south()) {
lightLevel = section.getLightIfHigher(category, lightLevel,
BlockFaceSet.MASK_NORTH, x, y, z + 1);
}
// If dy is also within this section, we can simplify it
if (y >= 1 && y <= 14) {
if (!selfOpaqueFaces.down()) {
lightLevel = section.getLightIfHigher(category, lightLevel,
BlockFaceSet.MASK_UP, x, y - 1, z);
}
if (!selfOpaqueFaces.up()) {
lightLevel = section.getLightIfHigher(category, lightLevel,
BlockFaceSet.MASK_DOWN, x, y + 1, z);
}
return lightLevel;
}
} else {
// Crossing chunk boundaries - requires neighbor checks
if (!selfOpaqueFaces.west()) {
lightLevel = section.getLightIfHigherNeighbor(category, lightLevel,
BlockFaceSet.MASK_EAST, x - 1, y, z);
}
if (!selfOpaqueFaces.east()) {
lightLevel = section.getLightIfHigherNeighbor(category, lightLevel,
BlockFaceSet.MASK_WEST, x + 1, y, z);
}
if (!selfOpaqueFaces.north()) {
lightLevel = section.getLightIfHigherNeighbor(category, lightLevel,
BlockFaceSet.MASK_SOUTH, x, y, z - 1);
}
if (!selfOpaqueFaces.south()) {
lightLevel = section.getLightIfHigherNeighbor(category, lightLevel,
BlockFaceSet.MASK_NORTH, x, y, z + 1);
}
}
// Above and below, may need to check cube boundaries
// Below
if (!selfOpaqueFaces.down()) {
lightLevel = section.getLightIfHigherNeighbor(category, lightLevel,
BlockFaceSet.MASK_UP, x, y - 1, z);
}
// Above
if (!selfOpaqueFaces.up()) {
lightLevel = section.getLightIfHigherNeighbor(category, lightLevel,
BlockFaceSet.MASK_DOWN, x, y + 1, z);
}
return lightLevel;
}
/**
* Gets whether this lighting chunk has faults that need to be fixed
*
* @return True if there are faults, False if not
*/
public boolean hasFaults() {
return isSkyLightDirty || isBlockLightDirty;
}
public void forceSpreadBlocks() {
spread(LightingCategory.BLOCK);
}
/**
* Spreads the light from sources to 'zero' light level blocks
*
* @return Number of processing loops executed. 0 indicates no faults were found.
*/
public int spread() {
if (hasFaults()) {
int count = 0;
if (isSkyLightDirty) {
count += spread(LightingCategory.SKY);
}
if (isBlockLightDirty) {
count += spread(LightingCategory.BLOCK);
}
return count;
} else {
return 0;
}
}
private int spread(LightingCategory category) {
if ((category == LightingCategory.SKY) && !hasSkyLight) {
this.isSkyLightDirty = false;
return 0;
}
int x, y, z, light, factor, startY, newlight;
int loops = 0;
int lasterrx = 0, lasterry = 0, lasterrz = 0;
boolean haserror;
boolean err_neigh_nx = false;
boolean err_neigh_px = false;
boolean err_neigh_nz = false;
boolean err_neigh_pz = false;
LightingCube cube = null;
// Keep spreading the light in this chunk until it is done
boolean mode = false;
IntVector2 loop_start, loop_end;
int loop_increment;
while (true) {
haserror = false;
// Alternate iterating positive and negative
// This allows proper optimized spreading in all directions
mode = !mode;
if (mode) {
loop_start = start;
loop_end = end.add(1, 1);
loop_increment = 1;
} else {
loop_start = end;
loop_end = start.subtract(1, 1);
loop_increment = -1;
}
// Go through all blocks, using the heightmap for sky light to skip a few
for (x = loop_start.x; x != loop_end.x; x += loop_increment) {
for (z = loop_start.z; z != loop_end.z; z += loop_increment) {
startY = category.getStartY(this, x, z);
for (y = startY; y >= this.minY; y--) {
if ((cube = nextCube(cube, y)) == null) {
// Skip this section entirely by setting y to the bottom of the section
y &= ~0xf;
continue;
}
// Take block opacity into account, skip if fully solid
factor = Math.max(1, cube.opacity.get(x, y & 0xf, z));
if (factor == 15) {
continue;
}
// Read the old light level and try to find a light level around it that exceeds
light = category.get(cube, x, y & 0xf, z);
newlight = light + factor;
if (newlight < 15) {
newlight = getMaxLightLevel(cube, category, newlight, x, y & 0xf, z);
}
newlight -= factor;
// pick the highest value
if (newlight > light) {
category.set(cube, x, y & 0xf, z, newlight);
lasterrx = x;
lasterry = y;
lasterrz = z;
err_neigh_nx |= (x == 0);
err_neigh_nz |= (z == 0);
err_neigh_px |= (x == 15);
err_neigh_pz |= (z == 15);
haserror = true;
}
}
}
}
if (!haserror) {
break;
} else if (++loops > 100) {
lasterrx += this.chunkX << 4;
lasterrz += this.chunkZ << 4;
String msg = "Failed to fix all " + category.getName() + " lighting at [" +
lasterrx + '/' + lasterry +
'/' + lasterrz + ']';
Iris.warn(msg);
break;
}
}
// Set self as no longer dirty, all light is good
category.setDirty(this, false);
// When we change blocks at our chunk borders, neighbours have to do another spread cycle
if (err_neigh_nx) setNeighbourDirty(-1, 0, category);
if (err_neigh_px) setNeighbourDirty(1, 0, category);
if (err_neigh_nz) setNeighbourDirty(0, -1, category);
if (err_neigh_pz) setNeighbourDirty(0, 1, category);
return loops;
}
private void setNeighbourDirty(int dx, int dz, LightingCategory category) {
LightingChunk n = neighbors.get(dx, dz);
if (n != null) {
category.setDirty(n, true);
}
}
/**
* Applies the lighting information to a chunk. The returned completable future is called
* on the main thread when saving finishes.
*
* @param chunk to save to
* @return completable future completed when the chunk is saved,
* with value True passed when saving occurred, False otherwise
*/
@SuppressWarnings("unchecked")
public CompletableFuture<Boolean> saveToChunk(Chunk chunk) {
// Create futures for saving to all the chunk sections in parallel
List<LightingCube> sectionsToSave = this.sections.values();
final CompletableFuture<Boolean>[] futures = new CompletableFuture[sectionsToSave.size()];
{
int futureIndex = 0;
for (LightingCube sectionToSave : sectionsToSave) {
ChunkSection sectionToWriteTo = WorldUtil.getSection(chunk, sectionToSave.cy);
if (sectionToWriteTo == null) {
futures[futureIndex++] = CompletableFuture.completedFuture(Boolean.FALSE);
} else {
futures[futureIndex++] = sectionToSave.saveToChunk(sectionToWriteTo);
}
}
}
// When all of them complete, combine them into a single future
// If any changes were made to the chunk, return True as completed value
return CompletableFuture.allOf(futures).thenApply((o) -> {
isApplied = true;
try {
for (CompletableFuture<Boolean> future : futures) {
if (future.get()) {
ChunkHandle.fromBukkit(chunk).markDirty();
return Boolean.TRUE;
}
}
} catch (Throwable t) {
Iris.reportError(t);
t.printStackTrace();
}
// None of the futures completed true
return Boolean.FALSE;
});
}
}

85
src/main/java/com/volmit/iris/engine/lighting/LightingChunkNeighboring.java
View File

@ -1,85 +0,0 @@
/*
* Iris is a World Generator for Minecraft Bukkit Servers
* Copyright (c) 2021 Arcane Arts (Volmit Software)
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.volmit.iris.engine.lighting;
/**
* Keeps track of the 4 x/z neighbors of chunks
*/
public class LightingChunkNeighboring {
public final LightingChunk[] values = new LightingChunk[4];
/**
* Generates a key ranging 0 - 3 for fixed x/z combinations<br>
* - Bit 1 is set to contain which of the two is not 1<br>
* - Bit 2 is set to contain whether x/z is 1 or -1<br><br>
* <p/>
* This system requires that the x/z pairs are one the following:<br>
* (0, 1) | (0, -1) | (1, 0) | (-1, 0)
*
* @param x value
* @param z value
* @return key
*/
private static final int getIndexByChunk(int x, int z) {
return (x & 1) | ((x + z + 1) & 0x2);
}
/**
* Gets whether all 4 chunk neighbors are accessible
*
* @return True if all neighbors are accessible
*/
public boolean hasAll() {
for (int i = 0; i < 4; i++) {
if (values[i] == null) {
return false;
}
}
return true;
}
/**
* Gets the neighbor representing the given relative chunk
*
* @return neighbor
*/
public LightingChunk get(int deltaChunkX, int deltaChunkZ) {
return values[getIndexByChunk(deltaChunkX, deltaChunkZ)];
}
/**
* Gets a relative neighboring chunk, and then a vertical cube in that chunk, if possible.
*
* @param cy Cube absolute y-coordinate
* @return cube, null if the chunk or cube is not available
*/
public LightingCube getCube(int deltaChunkX, int deltaChunkZ, int cy) {
LightingChunk chunk = get(deltaChunkX, deltaChunkZ);
return (chunk == null) ? null : chunk.sections.get(cy);
}
/**
* Sets the neighbor representing the given relative chunk
*
* @param neighbor to set to
*/
public void set(int deltaChunkX, int deltaChunkZ, LightingChunk neighbor) {
values[getIndexByChunk(deltaChunkX, deltaChunkZ)] = neighbor;
}
}

334
src/main/java/com/volmit/iris/engine/lighting/LightingCube.java
View File

@ -1,334 +0,0 @@
/*
* Iris is a World Generator for Minecraft Bukkit Servers
* Copyright (c) 2021 Arcane Arts (Volmit Software)
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.volmit.iris.engine.lighting;
import com.bergerkiller.bukkit.common.collections.BlockFaceSet;
import com.bergerkiller.bukkit.common.utils.WorldUtil;
import com.bergerkiller.bukkit.common.wrappers.BlockData;
import com.bergerkiller.bukkit.common.wrappers.ChunkSection;
import com.bergerkiller.generated.net.minecraft.server.NibbleArrayHandle;
import com.volmit.iris.Iris;
import java.util.concurrent.CompletableFuture;
/**
* A single 16x16x16 cube of stored block information
*/
public class LightingCube {
public static final int OOC = ~0xf; // Outside Of Cube
public final LightingChunk owner;
public final LightingCubeNeighboring neighbors = new LightingCubeNeighboring();
public final int cy;
public final NibbleArrayHandle skyLight;
public final NibbleArrayHandle blockLight;
public final NibbleArrayHandle emittedLight;
public final NibbleArrayHandle opacity;
private final BlockFaceSetSection opaqueFaces;
public LightingCube(LightingChunk owner, ChunkSection chunkSection, boolean hasSkyLight) {
this.owner = owner;
this.cy = chunkSection.getY();
if (owner.neighbors.hasAll()) {
// Block light data (is re-initialized in the fill operation below, no need to read)
this.blockLight = NibbleArrayHandle.createNew();
// Sky light data (is re-initialized using heightmap operation later, no need to read)
if (hasSkyLight) {
this.skyLight = NibbleArrayHandle.createNew();
} else {
this.skyLight = null;
}
} else {
// We need to load the original light data, because we have a border that we do not update
// Block light data
byte[] blockLightData = WorldUtil.getSectionBlockLight(owner.world,
owner.chunkX, this.cy, owner.chunkZ);
if (blockLightData != null) {
this.blockLight = NibbleArrayHandle.createNew(blockLightData);
} else {
this.blockLight = NibbleArrayHandle.createNew();
}
// Sky light data
if (hasSkyLight) {
byte[] skyLightData = WorldUtil.getSectionSkyLight(owner.world,
owner.chunkX, this.cy, owner.chunkZ);
if (skyLightData != null) {
this.skyLight = NibbleArrayHandle.createNew(skyLightData);
} else {
this.skyLight = NibbleArrayHandle.createNew();
}
} else {
this.skyLight = null;
}
}
// World coordinates
int worldX = owner.chunkX << 4;
int worldY = chunkSection.getYPosition();
int worldZ = owner.chunkZ << 4;
// Fill opacity and initial block lighting values
this.opacity = NibbleArrayHandle.createNew();
this.emittedLight = NibbleArrayHandle.createNew();
this.opaqueFaces = new BlockFaceSetSection();
int x, y, z, opacity, blockEmission;
BlockFaceSet opaqueFaces;
BlockData info;
for (z = owner.start.z; z <= owner.end.z; z++) {
for (x = owner.start.x; x <= owner.end.x; x++) {
for (y = 0; y < 16; y++) {
info = chunkSection.getBlockData(x, y, z);
blockEmission = info.getEmission();
opacity = info.getOpacity(owner.world, worldX + x, worldY + y, worldZ + z);
if (opacity >= 0xf) {
opacity = 0xf;
opaqueFaces = BlockFaceSet.ALL;
} else {
if (opacity < 0) {
opacity = 0;
}
opaqueFaces = info.getOpaqueFaces(owner.world, worldX + x, worldY + y, worldZ + z);
}
this.opacity.set(x, y, z, opacity);
this.emittedLight.set(x, y, z, blockEmission);
this.blockLight.set(x, y, z, blockEmission);
this.opaqueFaces.set(x, y, z, opaqueFaces);
}
}
}
}
/**
* Gets the opaque faces of a block
*
* @param x - coordinate
* @param y - coordinate
* @param z - coordinate
* @return opaque face set
*/
public BlockFaceSet getOpaqueFaces(int x, int y, int z) {
return this.opaqueFaces.get(x, y, z);
}
/**
* Read light level of a neighboring block.
* If possibly more, also check opaque faces, and then return the
* higher light value if all these tests pass.
* The x/y/z coordinates are allowed to check neighboring cubes.
*
* @param x The X-coordinate of the block (-1 to 16)
* @param y The Y-coordinate of the block (-1 to 16)
* @param z The Z-coordinate of the block (-1 to 16)
* @return higher light level if propagated, otherwise the old light value
*/
public int getLightIfHigherNeighbor(LightingCategory category, int old_light, int faceMask, int x, int y, int z) {
if ((x & OOC | y & OOC | z & OOC) == 0) {
return this.getLightIfHigher(category, old_light, faceMask, x, y, z);
} else {
LightingCube neigh = this.neighbors.get(x >> 4, y >> 4, z >> 4);
if (neigh != null) {
return neigh.getLightIfHigher(category, old_light, faceMask, x & 0xf, y & 0xf, z & 0xf);
} else {
return old_light;
}
}
}
/**
* Read light level of a neighboring block.
* If possibly more, also check opaque faces, and then return the
* higher light value if all these tests pass.
* Requires the x/y/z coordinates to lay within this cube.
*
* @param category Category of light to check
* @param old_light Previous light value
* @param faceMask The BlockFaceSet mask indicating the light-traveling direction
* @param x The X-coordinate of the block (0 to 15)
* @param y The Y-coordinate of the block (0 to 15)
* @param z The Z-coordinate of the block (0 to 15)
* @return higher light level if propagated, otherwise the old light value
*/
public int getLightIfHigher(LightingCategory category, int old_light, int faceMask, int x, int y, int z) {
int new_light_level = category.get(this, x, y, z);
return (new_light_level > old_light && !this.getOpaqueFaces(x, y, z).get(faceMask))
? new_light_level : old_light;
}
/**
* Called during initialization of block light to spread the light emitted by a block
* to all neighboring blocks.
*
* @param x The X-coordinate of the block (0 to 15)
* @param y The Y-coordinate of the block (0 to 15)
* @param z The Z-coordinate of the block (0 to 15)
*/
public void spreadBlockLight(int x, int y, int z) {
int emitted = this.emittedLight.get(x, y, z);
if (emitted <= 1) {
return; // Skip if neighbouring blocks won't receive light from it
}
if (x >= 1 && z >= 1 && x <= 14 && z <= 14) {
trySpreadBlockLightWithin(emitted, BlockFaceSet.MASK_EAST, x - 1, y, z);
trySpreadBlockLightWithin(emitted, BlockFaceSet.MASK_WEST, x + 1, y, z);
trySpreadBlockLightWithin(emitted, BlockFaceSet.MASK_SOUTH, x, y, z - 1);
trySpreadBlockLightWithin(emitted, BlockFaceSet.MASK_NORTH, x, y, z + 1);
} else {
trySpreadBlockLight(emitted, BlockFaceSet.MASK_EAST, x - 1, y, z);
trySpreadBlockLight(emitted, BlockFaceSet.MASK_WEST, x + 1, y, z);
trySpreadBlockLight(emitted, BlockFaceSet.MASK_SOUTH, x, y, z - 1);
trySpreadBlockLight(emitted, BlockFaceSet.MASK_NORTH, x, y, z + 1);
}
if (y >= 1 && y <= 14) {
trySpreadBlockLightWithin(emitted, BlockFaceSet.MASK_UP, x, y - 1, z);
trySpreadBlockLightWithin(emitted, BlockFaceSet.MASK_DOWN, x, y + 1, z);
} else {
trySpreadBlockLight(emitted, BlockFaceSet.MASK_UP, x, y - 1, z);
trySpreadBlockLight(emitted, BlockFaceSet.MASK_DOWN, x, y + 1, z);
}
}
/**
* Tries to spread block light from an emitting block to one of the 6 sites.
* The block being spread to is allowed to be outside of the bounds of this cube,
* in which case neighboring cubes are spread to instead.
*
* @param emitted The light that is emitted by the block
* @param faceMask The BlockFaceSet mask indicating the light-traveling direction
* @param x The X-coordinate of the block to spread to (-1 to 16)
* @param y The Y-coordinate of the block to spread to (-1 to 16)
* @param z The Z-coordinate of the block to spread to (-1 to 16)
*/
public void trySpreadBlockLight(int emitted, int faceMask, int x, int y, int z) {
if ((x & OOC | y & OOC | z & OOC) == 0) {
this.trySpreadBlockLightWithin(emitted, faceMask, x, y, z);
} else {
LightingCube neigh = this.neighbors.get(x >> 4, y >> 4, z >> 4);
if (neigh != null) {
neigh.trySpreadBlockLightWithin(emitted, faceMask, x & 0xf, y & 0xf, z & 0xf);
}
}
}
/**
* Tries to spread block light from an emitting block to one of the 6 sides.
* Assumes that the block being spread to is within this cube.
*
* @param emitted The light that is emitted by the block
* @param faceMask The BlockFaceSet mask indicating the light-traveling direction
* @param x The X-coordinate of the block to spread to (0 to 15)
* @param y The Y-coordinate of the block to spread to (0 to 15)
* @param z The Z-coordinate of the block to spread to (0 to 15)
*/
public void trySpreadBlockLightWithin(int emitted, int faceMask, int x, int y, int z) {
if (!this.getOpaqueFaces(x, y, z).get(faceMask)) {
int new_level = emitted - Math.max(1, this.opacity.get(x, y, z));
if (new_level > this.blockLight.get(x, y, z)) {
this.blockLight.set(x, y, z, new_level);
}
}
}
/**
* Applies the lighting information to a chunk section
*
* @param chunkSection to save to
* @return future completed when saving is finished. Future resolves to False if no changes occurred, True otherwise.
*/
public CompletableFuture<Boolean> saveToChunk(ChunkSection chunkSection) {
CompletableFuture<Void> blockLightFuture = null;
CompletableFuture<Void> skyLightFuture = null;
try {
if (this.blockLight != null) {
byte[] newBlockLight = this.blockLight.getData();
byte[] oldBlockLight = WorldUtil.getSectionBlockLight(owner.world,
owner.chunkX, this.cy, owner.chunkZ);
boolean blockLightChanged = false;
if (oldBlockLight == null || newBlockLight.length != oldBlockLight.length) {
blockLightChanged = true;
} else {
for (int i = 0; i < oldBlockLight.length; i++) {
if (oldBlockLight[i] != newBlockLight[i]) {
blockLightChanged = true;
break;
}
}
}
//TODO: Maybe do blockLightChanged check inside BKCommonLib?
if (blockLightChanged) {
blockLightFuture = WorldUtil.setSectionBlockLightAsync(owner.world,
owner.chunkX, this.cy, owner.chunkZ,
newBlockLight);
}
}
if (this.skyLight != null) {
byte[] newSkyLight = this.skyLight.getData();
byte[] oldSkyLight = WorldUtil.getSectionSkyLight(owner.world,
owner.chunkX, this.cy, owner.chunkZ);
boolean skyLightChanged = false;
if (oldSkyLight == null || newSkyLight.length != oldSkyLight.length) {
skyLightChanged = true;
} else {
for (int i = 0; i < oldSkyLight.length; i++) {
if (oldSkyLight[i] != newSkyLight[i]) {
skyLightChanged = true;
break;
}
}
}
//TODO: Maybe do skyLightChanged check inside BKCommonLib?
if (skyLightChanged) {
skyLightFuture = WorldUtil.setSectionSkyLightAsync(owner.world,
owner.chunkX, this.cy, owner.chunkZ,
newSkyLight);
}
}
} catch (Throwable t) {
Iris.reportError(t);
CompletableFuture<Boolean> exceptionally = new CompletableFuture<>();
exceptionally.completeExceptionally(t);
return exceptionally;
}
// No updates performed
if (blockLightFuture == null && skyLightFuture == null) {
return CompletableFuture.completedFuture(Boolean.FALSE);
}
// Join both completable futures as one, if needed
CompletableFuture<Void> combined;
if (blockLightFuture == null) {
combined = skyLightFuture;
} else if (skyLightFuture == null) {
combined = blockLightFuture;
} else {
combined = CompletableFuture.allOf(blockLightFuture, skyLightFuture);
}
// When combined resolves, return one that returns True
return combined.thenApply((c) -> Boolean.TRUE);
}
}

76
src/main/java/com/volmit/iris/engine/lighting/LightingCubeNeighboring.java
View File

@ -1,76 +0,0 @@
/*
* Iris is a World Generator for Minecraft Bukkit Servers
* Copyright (c) 2021 Arcane Arts (Volmit Software)
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.volmit.iris.engine.lighting;
/**
* Keeps track of the 6 x/y/z neighbors of cubes
*/
public class LightingCubeNeighboring {
public final LightingCube[] values = new LightingCube[6];
/**
* Generates a key ranging 0 - 5 for fixed x/y/z combinations<br>
* - Bit 1 is set to contain whether x/y/z is 1 or -1
* - Bit 2 is set to 1 when the axis is x<br>
* - Bit 3 is set to 1 when the axis is z<br><br>
* <p/>
* This system requires that the x/y/z pairs are one the following:<br>
* (0, 0, 1) | (0, 0, -1) | (0, 1, 0) | (0, -1, 0) | (1, 0, 0) | (-1, 0, 0)
*
* @param x value
* @param y value
* @param z value
* @return key
*/
private static final int getIndexByCube(int x, int y, int z) {
return (((x + y + z + 1) & 0x2) >> 1) | ((x & 0x1) << 1) | ((z & 0x1) << 2);
}
/**
* Gets whether all 6 cube neighbors are accessible
*
* @return True if all neighbors are accessible
*/
public boolean hasAll() {
for (int i = 0; i < 6; i++) {
if (values[i] == null) {
return false;
}
}
return true;
}
/**
* Gets the neighbor representing the given relative cube
*
* @return neighbor, null if no neighbor is available here
*/
public LightingCube get(int deltaCubeX, int deltaCubeY, int deltaCubeZ) {
return values[getIndexByCube(deltaCubeX, deltaCubeY, deltaCubeZ)];
}
/**
* Sets the neighbor representing the given relative cube
*
* @param neighbor to set to, is allowed to be null to set to 'none'
*/
public void set(int deltaCubeX, int deltaCubeY, int deltaCubeZ, LightingCube neighbor) {
values[getIndexByCube(deltaCubeX, deltaCubeY, deltaCubeZ)] = neighbor;
}
}

94
src/main/java/com/volmit/iris/engine/lighting/LightingForcedChunkCache.java
View File

@ -1,94 +0,0 @@
/*
* Iris is a World Generator for Minecraft Bukkit Servers
* Copyright (c) 2021 Arcane Arts (Volmit Software)
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.volmit.iris.engine.lighting;
import com.bergerkiller.bukkit.common.chunk.ForcedChunk;
import com.bergerkiller.bukkit.common.utils.WorldUtil;
import org.bukkit.World;
import java.util.HashMap;
import java.util.Map;
/**
* Shortly remembers the forced chunks it has kept loaded from a previous operation.
* Reduces chunk unloading-loading grind.
*/
public class LightingForcedChunkCache {
private static final Map<Key, ForcedChunk> _cache = new HashMap<>();
public static ForcedChunk get(World world, int x, int z) {
ForcedChunk cached;
synchronized (_cache) {
cached = _cache.get(new Key(world, x, z));
}
if (cached != null) {
return cached.clone();
} else {
return WorldUtil.forceChunkLoaded(world, x, z);
}
}
public static void store(ForcedChunk chunk) {
ForcedChunk prev;
synchronized (_cache) {
prev = _cache.put(new Key(chunk.getWorld(), chunk.getX(), chunk.getZ()), chunk.clone());
}
if (prev != null) {
prev.close();
}
}
public static void reset() {
synchronized (_cache) {
for (ForcedChunk chunk : _cache.values()) {
chunk.close();
}
_cache.clear();
}
}
@SuppressWarnings("ClassCanBeRecord")
private static final class Key {
public final World world;
public final int x;
public final int z;
public Key(World world, int x, int z) {
this.world = world;
this.x = x;
this.z = z;
}
@Override
public int hashCode() {
return this.x * 31 + this.z;
}
@Override
public boolean equals(Object o) {
if (o instanceof Key other) {
return other.x == this.x &&
other.z == this.z &&
other.world == this.world;
} else {
return false;
}
}
}
}

664
src/main/java/com/volmit/iris/engine/lighting/LightingService.java
View File

@ -1,664 +0,0 @@
/*
* Iris is a World Generator for Minecraft Bukkit Servers
* Copyright (c) 2021 Arcane Arts (Volmit Software)
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.volmit.iris.engine.lighting;
import com.bergerkiller.bukkit.common.AsyncTask;
import com.bergerkiller.bukkit.common.bases.IntVector2;
import com.bergerkiller.bukkit.common.bases.IntVector3;
import com.bergerkiller.bukkit.common.permissions.NoPermissionException;
import com.bergerkiller.bukkit.common.utils.MathUtil;
import com.bergerkiller.bukkit.common.utils.WorldUtil;
import com.bergerkiller.bukkit.common.wrappers.LongHashSet;
import com.bergerkiller.bukkit.common.wrappers.LongHashSet.LongIterator;
import com.volmit.iris.Iris;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.*;
@SuppressWarnings("ALL")
public class LightingService extends AsyncTask {
private static final Set<RecipientWhenDone> recipientsForDone = new HashSet<RecipientWhenDone>();
private static final LinkedList<LightingTask> tasks = new LinkedList<LightingTask>();
private static final int PENDING_WRITE_INTERVAL = 10;
private static AsyncTask fixThread = null;
private static int taskChunkCount = 0;
private static int taskCounter = 0;
private static boolean pendingFileInUse = false;
private static LightingTask currentTask;
private static boolean paused = false;
private static final boolean lowOnMemory = false;
/**
* Gets whether this service is currently processing something
*
* @return True if processing, False if not
*/
public static boolean isProcessing() {
return fixThread != null;
}
/**
* Starts or stops the processing service.
* Stopping the service does not instantly abort, the current task is continued.
*
* @param process to abort
*/
public static void setProcessing(boolean process) {
if (process == isProcessing()) {
return;
}
if (process) {
fixThread = new LightingService().start(true);
} else {
// Fix thread is running, abort
AsyncTask.stop(fixThread);
fixThread = null;
}
}
/**
* Gets whether execution is paused, and pending tasks are not being processed
*
* @return True if paused
*/
public static boolean isPaused() {
return paused;
}
/**
* Sets whether execution is paused.
*
* @param pause state to set to
*/
public static void setPaused(boolean pause) {
if (paused != pause) {
paused = pause;
}
}
/**
* Gets the status of the currently processed task
*
* @return current task status
*/
public static String getCurrentStatus() {
final LightingTask current = currentTask;
if (lowOnMemory) {
return ChatColor.RED + "Too low on available memory (paused)";
} else if (current == null) {
return "Finished.";
} else {
return current.getStatus();
}
}
/**
* Gets the time the currently processing task was started. If no task is being processed,
* an empty result is returned. If processing didn't start yet, the value will be 0.
*
* @return time when the current task was started
*/
public static java.util.OptionalLong getCurrentStartTime() {
final LightingTask current = currentTask;
return (current == null) ? java.util.OptionalLong.empty() : OptionalLong.of(current.getTimeStarted());
}
public static void addRecipient(CommandSender sender) {
synchronized (recipientsForDone) {
recipientsForDone.add(new RecipientWhenDone(sender));
}
}
public static void scheduleWorld(final World world) {
ScheduleArguments args = new ScheduleArguments();
args.setWorld(world);
args.setEntireWorld();
schedule(args);
}
/**
* Schedules a square chunk area for lighting fixing
*
* @param world the chunks are in
* @param middleX
* @param middleZ
* @param radius
*/
public static void scheduleArea(World world, int middleX, int middleZ, int radius) {
ScheduleArguments args = new ScheduleArguments();
args.setWorld(world);
args.setChunksAround(middleX, middleZ, radius);
schedule(args);
}
@Deprecated
public static void schedule(World world, Collection<IntVector2> chunks) {
ScheduleArguments args = new ScheduleArguments();
args.setWorld(world);
args.setChunks(chunks);
schedule(args);
}
public static void schedule(World world, LongHashSet chunks) {
ScheduleArguments args = new ScheduleArguments();
args.setWorld(world);
args.setChunks(chunks);
schedule(args);
}
public static void schedule(ScheduleArguments args) {
// World not allowed to be null
if (args.getWorld() == null) {
throw new IllegalArgumentException("Schedule arguments 'world' is null");
}
// If no chunks specified, entire world
if (args.isEntireWorld()) {
LightingTaskWorld task = new LightingTaskWorld(args.getWorld());
task.applyOptions(args);
schedule(task);
return;
}
// If less than 34x34 chunks are requested, schedule as one task
// In that case, be sure to only schedule chunks that actually exist
// This prevents generating new chunks as part of this command
LongHashSet chunks = args.getChunks();
if (chunks.size() <= (34 * 34)) {
LongHashSet chunks_filtered = new LongHashSet(chunks.size());
Set<IntVector2> region_coords_filtered = new HashSet<IntVector2>();
LongIterator iter = chunks.longIterator();
if (args.getLoadedChunksOnly()) {
// Remove coordinates of chunks that aren't loaded
while (iter.hasNext()) {
long chunk = iter.next();
int cx = MathUtil.longHashMsw(chunk);
int cz = MathUtil.longHashLsw(chunk);
if (WorldUtil.isLoaded(args.getWorld(), cx, cz)) {
chunks_filtered.add(chunk);
region_coords_filtered.add(new IntVector2(
WorldUtil.chunkToRegionIndex(cx),
WorldUtil.chunkToRegionIndex(cz)));
}
}
} else if (true) {
// Remove coordinates of chunks that don't actually exist (avoid generating new chunks)
// isChunkAvailable isn't very fast, but fast enough below this threshold of chunks
// To check for border chunks, we check that all 9 chunks are are available
Map<IntVector2, Boolean> tmp = new HashMap<>();
while (iter.hasNext()) {
long chunk = iter.next();
int cx = MathUtil.longHashMsw(chunk);
int cz = MathUtil.longHashLsw(chunk);
boolean fully_loaded = true;
for (int dx = -2; dx <= 2 && fully_loaded; dx++) {
for (int dz = -2; dz <= 2 && fully_loaded; dz++) {
IntVector2 pos = new IntVector2(cx + dx, cz + dz);
fully_loaded &= tmp.computeIfAbsent(pos, p -> WorldUtil.isChunkAvailable(args.getWorld(), p.x, p.z)).booleanValue();
}
}
if (fully_loaded) {
chunks_filtered.add(chunk);
region_coords_filtered.add(new IntVector2(
WorldUtil.chunkToRegionIndex(cx),
WorldUtil.chunkToRegionIndex(cz)));
}
}
} else {
// Remove coordinates of chunks that don't actually exist (avoid generating new chunks)
// isChunkAvailable isn't very fast, but fast enough below this threshold of chunks
while (iter.hasNext()) {
long chunk = iter.next();
int cx = MathUtil.longHashMsw(chunk);
int cz = MathUtil.longHashLsw(chunk);
if (WorldUtil.isChunkAvailable(args.getWorld(), cx, cz)) {
chunks_filtered.add(chunk);
region_coords_filtered.add(new IntVector2(
WorldUtil.chunkToRegionIndex(cx),
WorldUtil.chunkToRegionIndex(cz)));
}
}
}
// For all filtered chunk coordinates, compute regions
int[] regionYCoordinates;
{
Set<IntVector3> regions = WorldUtil.getWorldRegions3ForXZ(args.getWorld(), region_coords_filtered);
// Simplify to just the unique Y-coordinates
regionYCoordinates = regions.stream().mapToInt(r -> r.y).sorted().distinct().toArray();
}
// Schedule it
if (!chunks_filtered.isEmpty()) {
LightingTaskBatch task = new LightingTaskBatch(args.getWorld(), regionYCoordinates, chunks_filtered);
task.applyOptions(args);
schedule(task);
}
return;
}
// Too many chunks requested. Separate the operations per region file with small overlap.
FlatRegionInfoMap regions;
if (args.getLoadedChunksOnly()) {
regions = FlatRegionInfoMap.createLoaded(args.getWorld());
} else {
regions = FlatRegionInfoMap.create(args.getWorld());
}
LongIterator iter = chunks.longIterator();
LongHashSet scheduledRegions = new LongHashSet();
while (iter.hasNext()) {
long first_chunk = iter.next();
int first_chunk_x = MathUtil.longHashMsw(first_chunk);
int first_chunk_z = MathUtil.longHashLsw(first_chunk);
FlatRegionInfo region = regions.getRegionAtChunk(first_chunk_x, first_chunk_z);
if (region == null || scheduledRegions.contains(region.rx, region.rz)) {
continue; // Does not exist or already scheduled
}
if (!region.containsChunk(first_chunk_x, first_chunk_z)) {
continue; // Chunk does not exist in world (not generated yet) or isn't loaded (loaded chunks only option)
}
// Collect all the region Y coordinates used for this region and the neighbouring regions
// This makes sure we find all chunk slices we might need on an infinite height world
int[] region_y_coordinates = regions.getRegionYCoordinatesSelfAndNeighbours(region);
// Collect all chunks to process for this region.
// This is an union of the 34x34 area of chunks and the region file data set
LongHashSet buffer = new LongHashSet();
int rdx, rdz;
for (rdx = -1; rdx < 33; rdx++) {
for (rdz = -1; rdz < 33; rdz++) {
int cx = region.cx + rdx;
int cz = region.cz + rdz;
long chunk_key = MathUtil.longHashToLong(cx, cz);
if (!chunks.contains(chunk_key)) {
continue;
}
if (true) {
// Check the chunk and the surrounding chunks are all present
if (!regions.containsChunkAndNeighbours(cx, cz)) {
continue;
}
} else {
// Only check chunk
if (!regions.containsChunk(cx, cz)) {
continue;
}
}
buffer.add(chunk_key);
}
}
// Schedule the region
if (!buffer.isEmpty()) {
scheduledRegions.add(region.rx, region.rz);
LightingTaskBatch task = new LightingTaskBatch(args.getWorld(), region_y_coordinates, buffer);
task.applyOptions(args);
schedule(task);
}
}
}
public static void schedule(LightingTask task) {
synchronized (tasks) {
tasks.offer(task);
taskChunkCount += task.getChunkCount();
}
setProcessing(true);
}
/**
* Loads the pending chunk batch operations from a save file.
* If it is there, it will start processing these again.
*/
public static void loadPendingBatches() {
pendingFileInUse = false;
}
/**
* Saves all pending chunk batch operations to a save file.
* If the server, for whatever reason, crashes, it can restore using this file.
*/
public static void savePendingBatches() {
if (pendingFileInUse) {
return;
}
}
/**
* Clears all pending tasks, does continue with the current tasks
*/
public static void clearTasks() {
synchronized (tasks) {
tasks.clear();
}
final LightingTask current = currentTask;
if (current != null) {
current.abort();
}
synchronized (tasks) {
tasks.clear();
}
currentTask = null;
taskChunkCount = 0;
LightingForcedChunkCache.reset();
}
/**
* Orders this service to abort all tasks, finishing the current task in an orderly fashion.
* This method can only be called from the main Thread.
*/
public static void abort() {
// Finish the current lighting task if available
final LightingTask current = currentTask;
final AsyncTask service = fixThread;
if (service != null && current != null) {
setProcessing(false);
current.abort();
}
// Clear lighting tasks
synchronized (tasks) {
if (current != null) {
tasks.addFirst(current);
}
if (!tasks.isEmpty()) {
}
savePendingBatches();
clearTasks();
}
}
/**
* Gets the amount of chunks that are still faulty
*
* @return faulty chunk count
*/
public static int getChunkFaults() {
final LightingTask current = currentTask;
return taskChunkCount + (current == null ? 0 : current.getChunkCount());
}
@Override
public void run() {
// While paused, do nothing
while (paused) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
Iris.reportError(e);
e.printStackTrace();
}
synchronized (tasks) {
if (tasks.isEmpty()) {
break; // Stop processing.
}
}
if (fixThread.isStopRequested()) {
return;
}
}
synchronized (tasks) {
currentTask = tasks.poll();
}
if (currentTask == null) {
// No more tasks, end this thread
// Messages
final String message = ChatColor.GREEN + "All lighting operations are completed.";
synchronized (recipientsForDone) {
for (RecipientWhenDone recipient : recipientsForDone) {
CommandSender recip = recipient.player_name == null ?
Bukkit.getConsoleSender() : Bukkit.getPlayer(recipient.player_name);
if (recip != null) {
String timeStr = LightingUtil.formatDuration(System.currentTimeMillis() - recipient.timeStarted);
recip.sendMessage(message + ChatColor.WHITE + " (Took " + timeStr + ")");
}
}
recipientsForDone.clear();
}
// Stop task and abort
taskCounter = 0;
setProcessing(false);
LightingForcedChunkCache.reset();
savePendingBatches();
return;
} else {
// Write to file?
if (taskCounter++ >= PENDING_WRITE_INTERVAL) {
taskCounter = 0;
// Start saving on another thread (IO access is slow...)
new AsyncTask() {
public void run() {
savePendingBatches();
}
}.start();
// Save the world of the current task being processed
}
// Subtract task from the task count
taskChunkCount -= currentTask.getChunkCount();
// Process the task
try {
currentTask.process();
} catch (Throwable t) {
Iris.reportError(t);
t.printStackTrace();
Iris.error("Failed to process task: " + currentTask.getStatus());
}
}
}
private static long calcAvailableMemory(Runtime runtime) {
long max = runtime.maxMemory();
if (max == Long.MAX_VALUE) {
return Long.MAX_VALUE;
} else {
long used = (runtime.totalMemory() - runtime.freeMemory());
return (max - used);
}
}
public static class ScheduleArguments {
private World world;
private String worldName;
private LongHashSet chunks;
private boolean debugMakeCorrupted = false;
private boolean loadedChunksOnly = false;
private int radius = Bukkit.getServer().getViewDistance();
public boolean getDebugMakeCorrupted() {
return this.debugMakeCorrupted;
}
public boolean getLoadedChunksOnly() {
return this.loadedChunksOnly;
}
public int getRadius() {
return this.radius;
}
public boolean isEntireWorld() {
return this.chunks == null;
}
public World getWorld() {
return this.world;
}
public String getWorldName() {
return this.worldName;
}
public LongHashSet getChunks() {
return this.chunks;
}
/**
* Sets the world itself. Automatically updates the world name.
*
* @param world
* @return these arguments
*/
public ScheduleArguments setWorld(World world) {
this.world = world;
this.worldName = world.getName();
return this;
}
/**
* Sets the world name to perform operations on.
* If the world by this name does not exist, the world is null.
*
* @param worldName
* @return these arguments
*/
public ScheduleArguments setWorldName(String worldName) {
this.world = Bukkit.getWorld(worldName);
this.worldName = worldName;
return this;
}
public ScheduleArguments setEntireWorld() {
this.chunks = null;
return this;
}
public ScheduleArguments setDebugMakeCorrupted(boolean debug) {
this.debugMakeCorrupted = debug;
return this;
}
public ScheduleArguments setLoadedChunksOnly(boolean loadedChunksOnly) {
this.loadedChunksOnly = loadedChunksOnly;
return this;
}
public ScheduleArguments setRadius(int radius) {
this.radius = radius;
return this;
}
public ScheduleArguments setChunksAround(Location location, int radius) {
this.setWorld(location.getWorld());
return this.setChunksAround(location.getBlockX() >> 4, location.getBlockZ() >> 4, radius);
}
public ScheduleArguments setChunksAround(int middleX, int middleZ, int radius) {
this.setRadius(radius);
LongHashSet chunks_hashset = new LongHashSet((2 * radius) * (2 * radius));
for (int a = -radius; a <= radius; a++) {
for (int b = -radius; b <= radius; b++) {
int cx = middleX + a;
int cz = middleZ + b;
chunks_hashset.add(cx, cz);
}
}
return this.setChunks(chunks_hashset);
}
/**
* Sets the chunks to a cuboid area of chunks.
* Make sure the minimum chunk coordinates are less or equal to
* the maximum chunk coordinates.
*
* @param minChunkX Minimum chunk x-coordinate (inclusive)
* @param minChunkZ Minimum chunk z-coordinate (inclusive)
* @param maxChunkX Maximum chunk x-coordinate (inclusive)
* @param maxChunkZ Maximum chunk z-coordinate (inclusive)
* @return this
*/
public ScheduleArguments setChunkFromTo(int minChunkX, int minChunkZ, int maxChunkX, int maxChunkZ) {
int num_dx = (maxChunkX - minChunkX) + 1;
int num_dz = (maxChunkZ - minChunkZ) + 1;
if (num_dx <= 0 || num_dz <= 0) {
return this.setChunks(new LongHashSet()); // nothing
}
LongHashSet chunks_hashset = new LongHashSet(num_dx * num_dz);
for (int chunkX = minChunkX; chunkX <= maxChunkX; chunkX++) {
for (int chunkZ = minChunkZ; chunkZ <= maxChunkZ; chunkZ++) {
chunks_hashset.add(chunkX, chunkZ);
}
}
return this.setChunks(chunks_hashset);
}
public ScheduleArguments setChunks(Collection<IntVector2> chunks) {
LongHashSet chunks_hashset = new LongHashSet(chunks.size());
for (IntVector2 coord : chunks) {
chunks_hashset.add(coord.x, coord.z);
}
return this.setChunks(chunks_hashset);
}
public ScheduleArguments setChunks(LongHashSet chunks) {
this.chunks = chunks;
return this;
}
private boolean checkRadiusPermission(CommandSender sender, int radius) throws NoPermissionException {
return false;
}
/**
* Parses the arguments specified in a command
*
* @param sender
* @return false if the input is incorrect and operations may not proceed
* @throws NoPermissionException
*/
public boolean handleCommandInput(CommandSender sender, String[] args) throws NoPermissionException {
return true;
}
/**
* Creates a new ScheduleArguments instance ready to be configured
*
* @return args
*/
public static ScheduleArguments create() {
return new ScheduleArguments();
}
}
private static class RecipientWhenDone {
public final String player_name;
public final long timeStarted;
public RecipientWhenDone(CommandSender sender) {
this.player_name = (sender instanceof Player) ? sender.getName() : null;
this.timeStarted = System.currentTimeMillis();
}
}
}

79
src/main/java/com/volmit/iris/engine/lighting/LightingTask.java
View File

@ -1,79 +0,0 @@
/*
* Iris is a World Generator for Minecraft Bukkit Servers
* Copyright (c) 2021 Arcane Arts (Volmit Software)
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.volmit.iris.engine.lighting;
import org.bukkit.World;
/**
* A single task the Lighting Service can handle
*/
public interface LightingTask {
/**
* Gets the world this task is working on
*
* @return task world
*/
World getWorld();
/**
* Gets the amount of chunks this task is going to fix.
* This can be a wild estimate. While processing this amount should be
* updated as well.
*
* @return estimated total chunk count
*/
int getChunkCount();
/**
* Gets a descriptive status of the current task being processed
*
* @return status
*/
String getStatus();
/**
* Gets the timestamp (milliseconds since epoch) when this task was first started.
* If 0 is returned, then the task wasn't started yet.
*
* @return time this task was started
*/
long getTimeStarted();
/**
* Processes this task (called from another thread!)
*/
void process();
/**
* Orders this task to abort
*/
void abort();
/**
* Whether this task can be saved to PendingLight.dat
*
* @return True if it can be saved
*/
boolean canSave();
/**
* Loads additional options
*/
void applyOptions(LightingService.ScheduleArguments args);
}

584
src/main/java/com/volmit/iris/engine/lighting/LightingTaskBatch.java
View File

@ -1,584 +0,0 @@
/*
* Iris is a World Generator for Minecraft Bukkit Servers
* Copyright (c) 2021 Arcane Arts (Volmit Software)
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.volmit.iris.engine.lighting;
import com.bergerkiller.bukkit.common.bases.IntVector2;
import com.bergerkiller.bukkit.common.utils.CommonUtil;
import com.bergerkiller.bukkit.common.utils.LogicUtil;
import com.bergerkiller.bukkit.common.utils.MathUtil;
import com.bergerkiller.bukkit.common.utils.WorldUtil;
import com.bergerkiller.bukkit.common.wrappers.LongHashSet;
import com.volmit.iris.Iris;
import com.volmit.iris.core.IrisSettings;
import org.bukkit.Chunk;
import org.bukkit.World;
import java.util.Arrays;
import java.util.Comparator;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.stream.Stream;
/**
* Contains all the chunk coordinates that have to be fixed,
* and handles the full process of this fixing.
* It is literally a batch of chunks being processed.
*/
public class LightingTaskBatch implements LightingTask {
private static final boolean DEBUG_LOG = false; // logs performance stats
public final World world;
private final Object chunks_lock = new Object();
private final int[] region_y_coords;
private volatile LightingChunk[] chunks = null;
private volatile long[] chunks_coords;
private boolean done = false;
private boolean aborted = false;
private volatile long timeStarted = 0;
private int numBeingLoaded = 0;
private volatile Stage stage = Stage.LOADING;
private LightingService.ScheduleArguments options = new LightingService.ScheduleArguments();
public LightingTaskBatch(World world, int[] regionYCoordinates, long[] chunkCoordinates) {
this.world = world;
this.region_y_coords = regionYCoordinates;
this.chunks_coords = chunkCoordinates;
}
public LightingTaskBatch(World world, int[] regionYCoordinates, LongHashSet chunkCoordinates) {
this.world = world;
this.region_y_coords = regionYCoordinates;
// Turn contents of the long hash set into an easily sortable IntVector2[] array
IntVector2[] coordinates = new IntVector2[chunkCoordinates.size()];
{
LongHashSet.LongIterator iter = chunkCoordinates.longIterator();
for (int i = 0; iter.hasNext(); i++) {
long coord = iter.next();
coordinates[i] = new IntVector2(MathUtil.longHashMsw(coord), MathUtil.longHashLsw(coord));
}
}
// Sort the array along the axis. This makes chunk loading more efficient.
Arrays.sort(coordinates, Comparator.comparingInt((IntVector2 a) -> a.x).thenComparingInt(a -> a.z));
// Turn back into a long[] array for memory efficiency
this.chunks_coords = Stream.of(coordinates).mapToLong(c -> MathUtil.longHashToLong(c.x, c.z)).toArray();
}
@Override
public World getWorld() {
return world;
}
/**
* Gets the X and Z-coordinates of all the chunk columns to process.
* The coordinates are combined into a single Long, which can be decoded
* using {@link MathUtil#longHashMsw(long)} for X and {@link MathUtil#longHashLsw(long) for Z.
*
* @return chunk coordinates
*/
public long[] getChunks() {
synchronized (this.chunks_lock) {
LightingChunk[] chunks = this.chunks;
if (chunks != null) {
long[] coords = new long[chunks.length];
for (int i = 0; i < chunks.length; i++) {
coords[i] = MathUtil.longHashToLong(chunks[i].chunkX, chunks[i].chunkZ);
}
return coords;
} else //noinspection ReplaceNullCheck
if (this.chunks_coords != null) {
return this.chunks_coords;
} else {
return new long[0];
}
}
}
/**
* Gets the Y-coordinates of all the regions to look for chunk data. A region stores 32 chunk
* slices vertically, and goes up/down 512 blocks every coordinate increase/decrease.
*
* @return region Y-coordinates
*/
public int[] getRegionYCoordinates() {
return this.region_y_coords;
}
@Override
public int getChunkCount() {
synchronized (this.chunks_lock) {
if (this.chunks == null) {
return this.done ? 0 : this.chunks_coords.length;
} else {
int faults = 0;
for (LightingChunk chunk : this.chunks) {
if (chunk.hasFaults()) {
faults++;
}
}
return faults;
}
}
}
@Override
public long getTimeStarted() {
return this.timeStarted;
}
@SuppressWarnings("ClassCanBeRecord")
private static final class BatchChunkInfo {
public final int cx;
public final int cz;
public final int count;
public BatchChunkInfo(int cx, int cz, int count) {
this.cx = cx;
this.cz = cz;
this.count = count;
}
}
public BatchChunkInfo getAverageChunk() {
int count = 0;
long cx = 0;
long cz = 0;
synchronized (this.chunks_lock) {
if (this.chunks != null) {
count = this.chunks.length;
for (LightingChunk chunk : this.chunks) {
cx += chunk.chunkX;
cz += chunk.chunkZ;
}
} else if (this.chunks_coords != null) {
count = this.chunks_coords.length;
for (long chunk : this.chunks_coords) {
cx += MathUtil.longHashMsw(chunk);
cz += MathUtil.longHashLsw(chunk);
}
} else {
return null;
}
}
if (count > 0) {
cx /= count;
cz /= count;
}
return new BatchChunkInfo((int) cx, (int) cz, count);
}
@Override
public String getStatus() {
BatchChunkInfo chunk = this.getAverageChunk();
if (chunk != null) {
String postfix = " chunks near " +
"x=" + (chunk.cx * 16) + " z=" + (chunk.cz * 16);
if (this.stage == Stage.LOADING) {
synchronized (this.chunks_lock) {
if (this.chunks != null) {
int num_loaded = 0;
for (LightingChunk lc : this.chunks) {
if (!lc.forcedChunk.isNone() && lc.forcedChunk.getChunkAsync().isDone()) {
num_loaded++;
}
}
return "Loaded " + num_loaded + "/" + chunk.count + postfix;
}
}
} else if (this.stage == Stage.APPLYING) {
synchronized (this.chunks_lock) {
if (this.chunks != null) {
int num_saved = 0;
for (LightingChunk lc : this.chunks) {
if (lc.isApplied) {
num_saved++;
}
}
return "Saved " + num_saved + "/" + chunk.count + postfix;
}
}
}
return "Cleaning " + chunk.count + postfix;
} else {
return done ? "Done" : "No Data";
}
}
private String getShortStatus() {
BatchChunkInfo chunk = this.getAverageChunk();
if (chunk != null) {
return "[x=" + (chunk.cx * 16) + " z=" + (chunk.cz * 16) + " count=" + chunk.count + "]";
} else {
return "[Unknown]";
}
}
@SuppressWarnings("BooleanMethodIsAlwaysInverted")
private boolean waitForCheckAborted(CompletableFuture<?> future) {
while (!aborted) {
try {
future.get(200, TimeUnit.MILLISECONDS);
return true;
} catch (InterruptedException | TimeoutException e1) {
Iris.reportError(e1);
} catch (ExecutionException ex) {
Iris.reportError(ex);
ex.printStackTrace();
Iris.error("Error while processing");
return false;
}
}
return false;
}
private void tryLoadMoreChunks(final CompletableFuture<Void>[] chunkFutures) {
if (this.aborted) {
return;
}
int i = 0;
while (true) {
// While synchronized, pick the next chunk to load
LightingChunk nextChunk = null;
CompletableFuture<Void> nextChunkFuture = null;
synchronized (chunks_lock) {
for (; i < chunks.length && numBeingLoaded < IrisSettings.getThreadCount(IrisSettings.get().getConcurrency().getEngineThreadCount()); i++) {
LightingChunk lc = chunks[i];
if (lc.loadingStarted) {
continue; // Already (being) loaded
}
// Pick it
numBeingLoaded++;
lc.loadingStarted = true;
nextChunk = lc;
nextChunkFuture = chunkFutures[i];
break;
}
}
// No more chunks to load / capacity reached
if (nextChunk == null) {
break;
}
// This shouldn't happen, but just in case, a check
if (nextChunkFuture.isDone()) {
continue;
}
// Outside of the lock, start loading the next chunk
final CompletableFuture<Void> f_nextChunkFuture = nextChunkFuture;
nextChunk.forcedChunk.move(LightingForcedChunkCache.get(world, nextChunk.chunkX, nextChunk.chunkZ));
nextChunk.forcedChunk.getChunkAsync().whenComplete((chunk, t) -> {
synchronized (chunks_lock) {
numBeingLoaded--;
}
f_nextChunkFuture.complete(null);
tryLoadMoreChunks(chunkFutures);
});
}
}
@SuppressWarnings("unchecked")
private CompletableFuture<Void> loadChunks() {
// For every LightingChunk, make a completable future
// Once all these futures are resolved the returned completable future resolves
CompletableFuture<Void>[] chunkFutures;
synchronized (this.chunks_lock) {
chunkFutures = new CompletableFuture[this.chunks.length];
}
for (int i = 0; i < chunkFutures.length; i++) {
chunkFutures[i] = new CompletableFuture<>();
}
// Start loading up to [asyncLoadConcurrency] number of chunks right now
// When a callback for a chunk load completes, we start loading additional chunks
tryLoadMoreChunks(chunkFutures);
return CompletableFuture.allOf(chunkFutures);
}
@Override
public void process() {
// Begin
this.stage = Stage.LOADING;
this.timeStarted = System.currentTimeMillis();
// Initialize lighting chunks
synchronized (this.chunks_lock) {
LightingChunk[] chunks_new = new LightingChunk[this.chunks_coords.length];
this.done = false;
int chunkIdx = 0;
for (long longCoord : this.chunks_coords) {
int x = MathUtil.longHashMsw(longCoord);
int z = MathUtil.longHashLsw(longCoord);
chunks_new[chunkIdx++] = new LightingChunk(this.world, x, z);
if (this.aborted) {
return;
}
}
// Update fields. We can remove the coordinates to free memory.
this.chunks = chunks_new;
this.chunks_coords = null;
}
// Check aborted
if (aborted) {
return;
}
// Load all the chunks. Wait for loading to finish.
// Regularly check that this task is not aborted
CompletableFuture<Void> loadChunksFuture = this.loadChunks();
if (!waitForCheckAborted(loadChunksFuture)) {
return;
}
// Causes all chunks in cache not used for this task to unload
// All chunks of this task are put into the cache, instead
LightingForcedChunkCache.reset();
for (LightingChunk lc : LightingTaskBatch.this.chunks) {
LightingForcedChunkCache.store(lc.forcedChunk);
}
// All chunks that can be loaded, are now loaded.
// Some chunks may have failed to be loaded, get rid of those now!
// To avoid massive spam, only show the average x/z coordinates of the chunk affected
synchronized (this.chunks_lock) {
long failed_chunk_avg_x = 0;
long failed_chunk_avg_z = 0;
int failed_chunk_count = 0;
LightingChunk[] new_chunks = this.chunks;
for (int i = new_chunks.length - 1; i >= 0; i--) {
LightingChunk lc = new_chunks[i];
if (lc.forcedChunk.getChunkAsync().isCompletedExceptionally()) {
failed_chunk_avg_x += lc.chunkX;
failed_chunk_avg_z += lc.chunkZ;
failed_chunk_count++;
new_chunks = LogicUtil.removeArrayElement(new_chunks, i);
}
}
this.chunks = new_chunks;
// Tell all the (remaining) chunks about other neighbouring chunks before initialization
for (LightingChunk lc : new_chunks) {
for (LightingChunk neigh : new_chunks) {
lc.notifyAccessible(neigh);
}
}
// Log when chunks fail to be loaded
if (failed_chunk_count > 0) {
failed_chunk_avg_x = ((failed_chunk_avg_x / failed_chunk_count) << 4);
failed_chunk_avg_z = ((failed_chunk_avg_z / failed_chunk_count) << 4);
Iris.error("Failed to load " + failed_chunk_count + " chunks near " +
"world=" + world.getName() + " x=" + failed_chunk_avg_x + " z=" + failed_chunk_avg_z);
}
}
// Schedule, on the main thread, to fill all the loaded chunks with data
CompletableFuture<Void> chunkFillFuture = CompletableFuture.runAsync(() -> {
synchronized (this.chunks_lock) {
for (LightingChunk lc : chunks) {
lc.fill(lc.forcedChunk.getChunk(), region_y_coords);
}
}
}, CommonUtil.getPluginExecutor(Iris.instance));
if (!waitForCheckAborted(chunkFillFuture)) {
return;
}
// Now that all chunks we can process are filled, let all the 16x16x16 cubes know of their neighbors
// This neighboring data is only used during the fix() (initialize + spread) phase
synchronized (this.chunks_lock) {
for (LightingChunk lc : chunks) {
lc.detectCubeNeighbors();
}
}
// Fix
this.stage = Stage.FIXING;
fix();
if (this.aborted) {
return;
}
// Apply and wait for it to be finished
// Wait in 200ms intervals to allow for aborting
// After 2 minutes of inactivity, stop waiting and consider applying failed
this.stage = Stage.APPLYING;
try {
CompletableFuture<Void> future = apply();
int max_num_of_waits = (5 * 120);
while (true) {
if (--max_num_of_waits == 0) {
Iris.error("Failed to apply lighting data for " + getShortStatus() + ": Timeout");
break;
}
try {
future.get(200, TimeUnit.MILLISECONDS);
break;
} catch (TimeoutException e) {
Iris.reportError(e);
if (this.aborted) {
return;
}
}
}
} catch (InterruptedException e) {
Iris.reportError(e);
// Ignore
} catch (ExecutionException e) {
Iris.reportError(e);
e.printStackTrace();
Iris.error("Failed to apply lighting data for " + getShortStatus());
}
this.done = true;
synchronized (this.chunks_lock) {
this.chunks = null;
}
}
@Override
public void abort() {
this.aborted = true;
// Close chunks kept loaded
LightingChunk[] chunks;
synchronized (this.chunks_lock) {
chunks = this.chunks;
}
if (chunks != null) {
for (LightingChunk lc : chunks) {
lc.forcedChunk.close();
}
}
}
/**
* Starts applying the new data to the world.
* This is done in several ticks on the main thread.
* The completable future is resolved when applying is finished.
*/
public CompletableFuture<Void> apply() {
// Apply data to chunks and unload if needed
LightingChunk[] chunks = LightingTaskBatch.this.chunks;
CompletableFuture<?>[] applyFutures = new CompletableFuture[chunks.length];
for (int i = 0; i < chunks.length; i++) {
LightingChunk lc = chunks[i];
Chunk bchunk = lc.forcedChunk.getChunk();
// Save to chunk
applyFutures[i] = lc.saveToChunk(bchunk).whenComplete((changed, t) -> {
if (t != null) {
t.printStackTrace();
} else if (changed) {
WorldUtil.queueChunkSendLight(world, lc.chunkX, lc.chunkZ);
}
// Closes our forced chunk, may cause the chunk to now unload
lc.forcedChunk.close();
});
}
return CompletableFuture.allOf(applyFutures);
}
/**
* Performs the (slow) fixing procedure (call from another thread)
*/
public void fix() {
// Initialize light
for (LightingCategory category : LightingCategory.values()) {
for (LightingChunk chunk : chunks) {
category.initialize(chunk);
if (this.aborted) {
return;
}
}
}
// Skip spread phase when debug mode is active
if (this.options.getDebugMakeCorrupted()) {
return;
}
// Before spreading, change the opacity values to have a minimum of 1
// Spreading can never be done without losing light
// This isn't done during initialization because it is important
// for calculating the first opacity>0 block for sky light.
for (LightingChunk chunk : chunks) {
for (LightingCube section : chunk.getSections()) {
//TODO: Maybe build something into BKCommonLib for this
int x, y, z;
for (y = 0; y < 16; y++) {
for (z = 0; z < 16; z++) {
for (x = 0; x < 16; x++) {
if (section.opacity.get(x, y, z) == 0) {
section.opacity.set(x, y, z, 1);
}
}
}
}
}
}
// Spread (timed, for debug)
boolean hasFaults;
long startTime = System.currentTimeMillis();
int totalLoops = 0;
do {
hasFaults = false;
for (LightingChunk chunk : chunks) {
int count = chunk.spread();
totalLoops += count;
hasFaults |= count > 0;
}
} while (hasFaults && !this.aborted);
long duration = System.currentTimeMillis() - startTime;
if (DEBUG_LOG) {
System.out.println("Processed " + totalLoops + " in " + duration + " ms");
}
}
@Override
public void applyOptions(LightingService.ScheduleArguments args) {
this.options = args;
}
@Override
public boolean canSave() {
return !this.options.getLoadedChunksOnly() && !this.options.getDebugMakeCorrupted();
}
private enum Stage {
LOADING, FIXING, APPLYING
}
}

195
src/main/java/com/volmit/iris/engine/lighting/LightingTaskWorld.java
View File

@ -1,195 +0,0 @@
/*
* Iris is a World Generator for Minecraft Bukkit Servers
* Copyright (c) 2021 Arcane Arts (Volmit Software)
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.volmit.iris.engine.lighting;
import com.bergerkiller.bukkit.common.utils.CommonUtil;
import com.bergerkiller.bukkit.common.wrappers.LongHashSet;
import com.volmit.iris.Iris;
import org.bukkit.World;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
public class LightingTaskWorld implements LightingTask {
private static final int ASSUMED_CHUNKS_PER_REGION = 34 * 34;
private final World world;
private volatile FlatRegionInfoMap regions = null;
private volatile int regionCountLoaded;
private volatile int chunkCount;
private volatile long timeStarted;
private volatile boolean aborted;
private LightingService.ScheduleArguments options = new LightingService.ScheduleArguments();
public LightingTaskWorld(World world) {
this.world = world;
this.regionCountLoaded = 0;
this.aborted = false;
this.chunkCount = 0;
this.timeStarted = 0;
}
@Override
public World getWorld() {
return this.world;
}
@Override
public int getChunkCount() {
return chunkCount;
}
@Override
public long getTimeStarted() {
return this.timeStarted;
}
@Override
public String getStatus() {
if (regions == null) {
return "Reading available regions from world " + getWorld().getName();
} else {
return "Reading available chunks from world " + getWorld().getName() + " (region " + (regionCountLoaded + 1) + "/" + regions.getRegionCount() + ")";
}
}
@SuppressWarnings("NonAtomicOperationOnVolatileField")
@Override
public void process() {
// Load regions on the main thread
// TODO: Can use main thread executor instead
this.timeStarted = System.currentTimeMillis();
final CompletableFuture<Void> regionsLoadedFuture = new CompletableFuture<>();
CommonUtil.nextTick(() -> {
try {
if (this.options.getLoadedChunksOnly()) {
this.regions = FlatRegionInfoMap.createLoaded(this.getWorld());
this.regionCountLoaded = this.regions.getRegionCount();
this.chunkCount = 0;
for (FlatRegionInfo region : this.regions.getRegions()) {
this.chunkCount += region.getChunkCount();
}
} else {
this.regions = FlatRegionInfoMap.create(this.getWorld());
this.regionCountLoaded = 0;
this.chunkCount = this.regions.getRegionCount() * ASSUMED_CHUNKS_PER_REGION;
}
regionsLoadedFuture.complete(null);
} catch (Throwable ex) {
Iris.reportError(ex);
regionsLoadedFuture.completeExceptionally(ex);
}
});
// Wait until region list is loaded synchronously
try {
regionsLoadedFuture.get();
} catch (InterruptedException ex) {
Iris.reportError(ex);
// Ignore
} catch (ExecutionException ex) {
Iris.reportError(ex);
throw new RuntimeException("Failed to load regions", ex.getCause());
}
// Check aborted
if (this.aborted) {
return;
}
// Start loading all chunks contained in the regions
if (!this.options.getLoadedChunksOnly()) {
for (FlatRegionInfo region : this.regions.getRegions()) {
// Abort handling
if (this.aborted) {
return;
}
// Load and update stats
region.load();
this.chunkCount -= ASSUMED_CHUNKS_PER_REGION - region.getChunkCount();
this.regionCountLoaded++;
}
}
// We now know of all the regions to be processed, convert all of them into tasks
// Use a slightly larger area to avoid cross-region errors
for (FlatRegionInfo region : regions.getRegions()) {
// Abort handling
if (this.aborted) {
return;
}
// If empty, skip
if (region.getChunkCount() == 0) {
continue;
}
// Find region Y-coordinates for this 34x34 section of chunks
int[] region_y_coordinates = regions.getRegionYCoordinatesSelfAndNeighbours(region);
// Reduce count, schedule and clear the buffer
// Put the coordinates that are available
final LongHashSet buffer = new LongHashSet(34 * 34);
if (true) {
int dx, dz;
for (dx = -1; dx < 33; dx++) {
for (dz = -1; dz < 33; dz++) {
int cx = region.cx + dx;
int cz = region.cz + dz;
if (this.regions.containsChunkAndNeighbours(cx, cz)) {
buffer.add(cx, cz);
}
}
}
} else {
int dx, dz;
for (dx = -1; dx < 33; dx++) {
for (dz = -1; dz < 33; dz++) {
int cx = region.cx + dx;
int cz = region.cz + dz;
if (this.regions.containsChunk(cx, cz)) {
buffer.add(cx, cz);
}
}
}
}
// Schedule and return amount of chunks
this.chunkCount -= buffer.size();
LightingTaskBatch batch_task = new LightingTaskBatch(this.getWorld(), region_y_coordinates, buffer);
batch_task.applyOptions(this.options);
LightingService.schedule(batch_task);
}
}
@Override
public void abort() {
this.aborted = true;
}
@Override
public void applyOptions(LightingService.ScheduleArguments args) {
this.options = args;
}
@Override
public boolean canSave() {
return false;
}
}

48
src/main/java/com/volmit/iris/engine/lighting/LightingUtil.java
View File

@ -1,48 +0,0 @@
/*
* Iris is a World Generator for Minecraft Bukkit Servers
* Copyright (c) 2021 Arcane Arts (Volmit Software)
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.volmit.iris.engine.lighting;
import com.bergerkiller.bukkit.common.utils.MathUtil;
/**
* Just some utilities used by Light Cleaner
*/
public class LightingUtil {
private static final TimeDurationFormat timeFormat_hh_mm = new TimeDurationFormat("HH 'hours' mm 'minutes'");
private static final TimeDurationFormat timeFormat_mm_ss = new TimeDurationFormat("mm 'minutes' ss 'seconds'");
private static final long SECOND_MILLIS = 1000L;
private static final long MINUTE_MILLIS = 60L * SECOND_MILLIS;
private static final long HOUR_MILLIS = 60L * MINUTE_MILLIS;
private static final long DAY_MILLIS = 24L * HOUR_MILLIS;
public static String formatDuration(long duration) {
if (duration < MINUTE_MILLIS) {
return MathUtil.round((double) duration / (double) SECOND_MILLIS, 2) + " seconds";
} else if (duration < HOUR_MILLIS) {
return timeFormat_mm_ss.format(duration);
} else if (duration < (2 * DAY_MILLIS)) {
return timeFormat_hh_mm.format(duration);
} else {
long num_days = duration / DAY_MILLIS;
long num_hours = (duration % DAY_MILLIS) / HOUR_MILLIS;
return num_days + " days " + num_hours + " hours";
}
}
}

60
src/main/java/com/volmit/iris/engine/lighting/TimeDurationFormat.java
View File

@ -1,60 +0,0 @@
/*
* Iris is a World Generator for Minecraft Bukkit Servers
* Copyright (c) 2021 Arcane Arts (Volmit Software)
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.volmit.iris.engine.lighting;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
import java.util.TimeZone;
/**
* Formatter for a duration String.
* Can represent a duration in milliseconds as a String.
* Taken from Traincarts (permission granted by same author)<br>
* <br>
* https://github.com/bergerhealer/TrainCarts/blob/master/src/main/java/com/bergerkiller/bukkit/tc/utils/TimeDurationFormat.java
*/
public class TimeDurationFormat {
private final TimeZone timeZone;
private final SimpleDateFormat sdf;
/**
* Creates a new time duration format. The format accepts the same formatting
* tokens as the Date formatter does.
*
* @throws IllegalArgumentException if the input format is invalid
*/
public TimeDurationFormat(String format) {
if (format == null) {
throw new IllegalArgumentException("Input format should not be null");
}
this.timeZone = TimeZone.getTimeZone("GMT+0");
this.sdf = new SimpleDateFormat(format, Locale.getDefault());
this.sdf.setTimeZone(this.timeZone);
}
/**
* Formats the duration
*
* @return formatted string
*/
public String format(long durationMillis) {
return this.sdf.format(new Date(durationMillis - this.timeZone.getRawOffset()));
}
}