From 7bbae51c7d2acce3758a8e99b773588498aff482 Mon Sep 17 00:00:00 2001 From: Daniel Mills Date: Sun, 27 Dec 2020 05:28:34 -0500 Subject: [PATCH] Faster --- pom.xml | 5 + .../java/com/volmit/iris/IrisSettings.java | 3 + .../generator/actuator/IrisBiomeActuator.java | 23 +- .../generator/modifier/IrisPostModifier.java | 13 +- .../java/com/volmit/iris/nms/INMSBinding.java | 2 + .../volmit/iris/nms/v16_2/NMSBinding16_2.java | 15 + .../volmit/iris/nms/v16_3/NMSBinding16_3.java | 15 + .../com/volmit/iris/nms/v1X/NMSBinding1X.java | 5 + .../scaffold/engine/DirectWorldWriter.java | 210 +++ .../engine/EngineCompositeGenerator.java | 125 ++ .../engine/EngineParallaxManager.java | 6 +- .../iris/scaffold/engine/IrisAccess.java | 5 + .../java/com/volmit/iris/util/FakeWorld.java | 1282 +++++++++++++++++ .../java/com/volmit/iris/util/PregenJob.java | 37 +- 14 files changed, 1730 insertions(+), 16 deletions(-) create mode 100644 src/main/java/com/volmit/iris/scaffold/engine/DirectWorldWriter.java create mode 100644 src/main/java/com/volmit/iris/util/FakeWorld.java diff --git a/pom.xml b/pom.xml index 6fa78abdc..a53f06917 100644 --- a/pom.xml +++ b/pom.xml @@ -154,6 +154,11 @@ + + com.github.Querz + NBT + 5.5 + org.spigotmc diff --git a/src/main/java/com/volmit/iris/IrisSettings.java b/src/main/java/com/volmit/iris/IrisSettings.java index aa91d316a..71b699dac 100644 --- a/src/main/java/com/volmit/iris/IrisSettings.java +++ b/src/main/java/com/volmit/iris/IrisSettings.java @@ -51,6 +51,9 @@ public class IrisSettings @DontObfuscate public boolean useGleamPregenerator = false; + @DontObfuscate + public boolean useExperimentalGleamMCADirectWriteMode = false; + @DontObfuscate public boolean disableNMS = false; diff --git a/src/main/java/com/volmit/iris/generator/actuator/IrisBiomeActuator.java b/src/main/java/com/volmit/iris/generator/actuator/IrisBiomeActuator.java index b93ac8651..062f4ce56 100644 --- a/src/main/java/com/volmit/iris/generator/actuator/IrisBiomeActuator.java +++ b/src/main/java/com/volmit/iris/generator/actuator/IrisBiomeActuator.java @@ -3,6 +3,8 @@ package com.volmit.iris.generator.actuator; import com.volmit.iris.scaffold.engine.Engine; import com.volmit.iris.scaffold.engine.EngineAssignedActuator; import com.volmit.iris.scaffold.hunk.Hunk; +import com.volmit.iris.scaffold.parallel.BurstExecutor; +import com.volmit.iris.scaffold.parallel.MultiBurst; import com.volmit.iris.util.PrecisionStopwatch; import org.bukkit.block.Biome; @@ -15,21 +17,28 @@ public class IrisBiomeActuator extends EngineAssignedActuator @Override public void onActuate(int x, int z, Hunk h) { PrecisionStopwatch p = PrecisionStopwatch.start(); - int i,zf; - Biome v; + int zf,hh; + BurstExecutor burst = MultiBurst.burst.burst(h.getWidth() * h.getDepth()); for(int xf = 0; xf < h.getWidth(); xf++) { for(zf = 0; zf < h.getDepth(); zf++) { - v = getComplex().getTrueBiomeStream().get(modX(xf+x), modZ(zf+z)).getDerivative(); + int xxf = xf; + int zzf = zf; - for(i = 0; i < h.getHeight(); i++) - { - h.set(xf, i, zf, v); - } + burst.queue(() -> { + Biome v = getComplex().getTrueBiomeStream().get(modX(xxf+x), modZ(zzf+z)).getDerivative(); + for(int i = 0; i < h.getHeight(); i++) + { + h.set(xxf, i, zzf, v); + } + }); } } + + burst.complete(); + getEngine().getMetrics().getBiome().put(p.getMilliseconds()); } } diff --git a/src/main/java/com/volmit/iris/generator/modifier/IrisPostModifier.java b/src/main/java/com/volmit/iris/generator/modifier/IrisPostModifier.java index fd6e56867..4d67b06c6 100644 --- a/src/main/java/com/volmit/iris/generator/modifier/IrisPostModifier.java +++ b/src/main/java/com/volmit/iris/generator/modifier/IrisPostModifier.java @@ -4,6 +4,8 @@ import com.volmit.iris.object.IrisBiome; import com.volmit.iris.scaffold.engine.Engine; import com.volmit.iris.scaffold.engine.EngineAssignedModifier; import com.volmit.iris.scaffold.hunk.Hunk; +import com.volmit.iris.scaffold.parallel.BurstExecutor; +import com.volmit.iris.scaffold.parallel.MultiBurst; import com.volmit.iris.util.B; import com.volmit.iris.util.CaveResult; import com.volmit.iris.util.PrecisionStopwatch; @@ -27,13 +29,18 @@ public class IrisPostModifier extends EngineAssignedModifier { @Override public void onModify(int x, int z, Hunk output) { PrecisionStopwatch p = PrecisionStopwatch.start(); - for(int i = 0; i < output.getWidth(); i++) + BurstExecutor b = MultiBurst.burst.burst(output.getWidth() * output.getDepth()); + int i, j; + for(i = 0; i < output.getWidth(); i++) { - for(int j = 0; j < output.getDepth(); j++) + int ii = i; + for(j = 0; j < output.getDepth(); j++) { - post(i, j, output, i+x, j+z); + int jj = j; + b.queue(() -> post(ii, jj, output, ii+x, jj+z)); } } + b.complete(); getEngine().getMetrics().getPost().put(p.getMilliseconds()); } diff --git a/src/main/java/com/volmit/iris/nms/INMSBinding.java b/src/main/java/com/volmit/iris/nms/INMSBinding.java index 3b41e3422..80e33ff9a 100644 --- a/src/main/java/com/volmit/iris/nms/INMSBinding.java +++ b/src/main/java/com/volmit/iris/nms/INMSBinding.java @@ -33,4 +33,6 @@ public interface INMSBinding return getCreator().createWorld(creator, loadSpawn); } + + int getBiomeId(Biome biome); } diff --git a/src/main/java/com/volmit/iris/nms/v16_2/NMSBinding16_2.java b/src/main/java/com/volmit/iris/nms/v16_2/NMSBinding16_2.java index 7f1475582..a19c457eb 100644 --- a/src/main/java/com/volmit/iris/nms/v16_2/NMSBinding16_2.java +++ b/src/main/java/com/volmit/iris/nms/v16_2/NMSBinding16_2.java @@ -6,6 +6,7 @@ import com.volmit.iris.scaffold.cache.AtomicCache; import com.volmit.iris.util.KMap; import net.minecraft.server.v1_16_R2.BiomeBase; import net.minecraft.server.v1_16_R2.IRegistry; +import org.bukkit.Bukkit; import org.bukkit.World; import org.bukkit.block.Biome; import org.bukkit.craftbukkit.v1_16_R2.CraftWorld; @@ -41,6 +42,20 @@ public class NMSBinding16_2 implements INMSBinding return v; } + @Override + public int getBiomeId(Biome biome) { + for(World i : Bukkit.getWorlds()) + { + if(i.getEnvironment().equals(World.Environment.NORMAL)) + { + IRegistry registry = ((CraftWorld)i).getHandle().r().b(IRegistry.ay); + return registry.a((BiomeBase) getBiomeBase(registry, biome)); + } + } + + return biome.ordinal(); + } + @Override public boolean isBukkit() { return false; diff --git a/src/main/java/com/volmit/iris/nms/v16_3/NMSBinding16_3.java b/src/main/java/com/volmit/iris/nms/v16_3/NMSBinding16_3.java index f24b1a83e..c79b0b661 100644 --- a/src/main/java/com/volmit/iris/nms/v16_3/NMSBinding16_3.java +++ b/src/main/java/com/volmit/iris/nms/v16_3/NMSBinding16_3.java @@ -6,6 +6,7 @@ import com.volmit.iris.scaffold.cache.AtomicCache; import com.volmit.iris.util.KMap; import net.minecraft.server.v1_16_R3.BiomeBase; import net.minecraft.server.v1_16_R3.IRegistry; +import org.bukkit.Bukkit; import org.bukkit.World; import org.bukkit.block.Biome; import org.bukkit.craftbukkit.v1_16_R3.CraftWorld; @@ -40,6 +41,20 @@ public class NMSBinding16_3 implements INMSBinding return v; } + @Override + public int getBiomeId(Biome biome) { + for(World i : Bukkit.getWorlds()) + { + if(i.getEnvironment().equals(World.Environment.NORMAL)) + { + IRegistry registry = ((CraftWorld)i).getHandle().r().b(net.minecraft.server.v1_16_R3.IRegistry.ay); + return registry.a((BiomeBase) getBiomeBase(registry, biome)); + } + } + + return biome.ordinal(); + } + @Override public boolean isBukkit() { return false; diff --git a/src/main/java/com/volmit/iris/nms/v1X/NMSBinding1X.java b/src/main/java/com/volmit/iris/nms/v1X/NMSBinding1X.java index 6633ec8ba..5be467e47 100644 --- a/src/main/java/com/volmit/iris/nms/v1X/NMSBinding1X.java +++ b/src/main/java/com/volmit/iris/nms/v1X/NMSBinding1X.java @@ -30,4 +30,9 @@ public class NMSBinding1X implements INMSBinding public boolean isBukkit() { return true; } + + @Override + public int getBiomeId(Biome biome) { + return biome.ordinal(); + } } diff --git a/src/main/java/com/volmit/iris/scaffold/engine/DirectWorldWriter.java b/src/main/java/com/volmit/iris/scaffold/engine/DirectWorldWriter.java new file mode 100644 index 000000000..c0e7cb2d9 --- /dev/null +++ b/src/main/java/com/volmit/iris/scaffold/engine/DirectWorldWriter.java @@ -0,0 +1,210 @@ +package com.volmit.iris.scaffold.engine; + +import com.volmit.iris.Iris; +import com.volmit.iris.nms.INMS; +import com.volmit.iris.scaffold.cache.Cache; +import com.volmit.iris.scaffold.parallel.BurstExecutor; +import com.volmit.iris.scaffold.parallel.MultiBurst; +import com.volmit.iris.util.B; +import com.volmit.iris.util.KList; +import com.volmit.iris.util.KMap; +import net.querz.mca.Chunk; +import net.querz.mca.MCAFile; +import net.querz.mca.MCAUtil; +import net.querz.mca.Section; +import net.querz.nbt.tag.CompoundTag; +import net.querz.nbt.tag.StringTag; +import org.bukkit.NamespacedKey; +import org.bukkit.block.Biome; +import org.bukkit.block.data.BlockData; + +import java.io.File; +import java.io.IOException; + +public class DirectWorldWriter { + private final File worldFolder; + private final KMap writeBuffer; + + public DirectWorldWriter(File worldFolder) + { + this.worldFolder = worldFolder; + writeBuffer = new KMap<>(); + new File(worldFolder, "region").mkdirs(); + } + + public void flush() + { + BurstExecutor ex = MultiBurst.burst.burst(writeBuffer.size()); + writeBuffer.v().forEach((i) -> ex.queue(i::cleanupPalettesAndBlockStates)); + ex.complete(); + BurstExecutor ex2 = MultiBurst.burst.burst(writeBuffer.size()); + + for(Long i : writeBuffer.k()) + { + int x = Cache.keyX(i); + int z = Cache.keyZ(i); + try { + File f = getMCAFile(x, z); + + if(!f.exists()) + { + f.getParentFile().mkdirs(); + f.createNewFile(); + } + + MCAUtil.write(writeBuffer.get(i), f, true); + } catch (Throwable e) { + e.printStackTrace(); + } + } + + writeBuffer.clear(); + } + + public File getMCAFile(int x, int z) + { + return new File(worldFolder, "region/r." + x + "." + z + ".mca"); + } + + public BlockData getBlockData(CompoundTag tag) + { + String p = tag.getString("Name"); + + if(tag.containsKey("Properties")) + { + CompoundTag props = tag.getCompoundTag("Properties"); + p += "["; + KList m = new KList<>(); + + for(String i : props.keySet()) + { + m.add(i + "=" + props.getString(i)); + } + + p += m.toString(",") + "]"; + } + + return B.get(p); + } + + public CompoundTag getCompound(BlockData blockData) + { + CompoundTag s = new CompoundTag(); + NamespacedKey key = blockData.getMaterial().getKey(); + s.putString("Name", key.getNamespace() + ":" + key.getKey()); + + String data = blockData.getAsString(true); + + if(data.contains("[")) + { + String raw = data.split("\\Q[\\E")[1].replaceAll("\\Q]\\E", ""); + CompoundTag props = new CompoundTag(); + if(raw.contains(",")) + { + for(String i : raw.split("\\Q,\\E")) + { + String[] m = i.split("\\Q=\\E"); + String k = m[0]; + String v = m[1]; + props.put(k, new StringTag(v)); + } + } + + else + { + String[] m = raw.split("\\Q=\\E"); + String k = m[0]; + String v = m[1]; + props.put(k, new StringTag(v)); + } + s.put("Properties", props); + } + + return s; + } + + public BlockData getBlockData(int x, int y, int z) + { + try + { + CompoundTag tag = getChunkSection(x >> 4, y >> 4, z >> 4).getBlockStateAt(x & 15, y & 15, z & 15); + + if(tag == null) + { + return B.get("AIR"); + } + + return getBlockData(tag); + } + + catch(Throwable e) + { + + } + return B.get("AIR"); + } + + public void setBlockData(int x, int y, int z, BlockData data) + { + getChunkSection(x >> 4, y >> 4, z >> 4).setBlockStateAt(x & 15, y & 15, z & 15, getCompound(data), false); + } + + public void setBiome(int x, int y, int z, Biome biome) + { + getChunk(x>>4, z>>4).setBiomeAt(x&15, y, z &15, INMS.get().getBiomeId(biome)); + } + + public Section getChunkSection(int x, int y, int z) + { + Chunk c = getChunk(x, z); + Section s = c.getSection(y); + + if(s == null) + { + s = Section.newSection(); + c.setSection(y, s); + } + + return s; + } + + public Chunk getChunk(int x, int z) + { + MCAFile mca = getMCA(x >> 5, z >> 5); + Chunk c = mca.getChunk(x & 31, z & 31); + + if(c == null) + { + c = Chunk.newChunk(); + mca.setChunk(x&31, z&31, c); + } + + return c; + } + + public MCAFile getMCA(int x, int z) + { + long key = Cache.key(x, z); + MCAFile mca = writeBuffer.get(key); + + if(mca != null) + { + return mca; + } + + File f = getMCAFile(x, z); + mca = new MCAFile(x, z); + if(f.exists()) + { + try { + mca = MCAUtil.read(f); + } catch (IOException e) { + e.printStackTrace(); + Iris.warn("Failed to read RandomAccessFile " + f.getAbsolutePath() + ", assuming empty region!"); + } + } + + writeBuffer.put(key, mca); + return mca; + } +} diff --git a/src/main/java/com/volmit/iris/scaffold/engine/EngineCompositeGenerator.java b/src/main/java/com/volmit/iris/scaffold/engine/EngineCompositeGenerator.java index cf7bfedb1..1b7bd5fb8 100644 --- a/src/main/java/com/volmit/iris/scaffold/engine/EngineCompositeGenerator.java +++ b/src/main/java/com/volmit/iris/scaffold/engine/EngineCompositeGenerator.java @@ -9,6 +9,8 @@ import com.volmit.iris.object.IrisDimension; import com.volmit.iris.scaffold.IrisWorlds; import com.volmit.iris.scaffold.cache.Cache; import com.volmit.iris.scaffold.hunk.Hunk; +import com.volmit.iris.scaffold.parallel.BurstExecutor; +import com.volmit.iris.scaffold.parallel.MultiBurst; import com.volmit.iris.util.*; import io.papermc.lib.PaperLib; import lombok.Getter; @@ -308,6 +310,129 @@ public class EngineCompositeGenerator extends ChunkGenerator implements IrisAcce return tc.getRaw(); } + public void directWriteMCA(World w, int x, int z, DirectWorldWriter writer, MultiBurst burst) + { + if(writer.getMCAFile(x, z).exists()) + { + return; + } + + BurstExecutor e = burst.burst(1024); + int mcaox = x << 5; + int mcaoz = z << 5; + + for(int i = 0; i < 32; i++) + { + int ii = i; + for(int j = 0; j < 32; j++) + { + int jj = j; + e.queue(() -> directWriteChunk(w, ii + mcaox, jj + mcaoz, writer)); + } + } + + e.complete(); + } + + public void directWriteChunk(World w, int x, int z, DirectWorldWriter writer) + { + int ox = x << 4; + int oz = z << 4; + generateChunkRawData(w, x, z, new TerrainChunk() { + @Override + public void setRaw(ChunkData data) { + + } + + @Override + public Biome getBiome(int x, int z) { + return Biome.THE_VOID; + } + + @Override + public Biome getBiome(int x, int y, int z) { + return Biome.THE_VOID; + } + + @Override + public void setBiome(int x, int z, Biome bio) { + writer.setBiome(ox + x, 0, oz + z, bio); + } + + @Override + public void setBiome(int x, int y, int z, Biome bio) { + writer.setBiome(ox + x, y, oz + z, bio); + } + + @Override + public int getMaxHeight() { + return w.getMaxHeight(); + } + + @Override + public void setBlock(int x, int y, int z, BlockData blockData) { + writer.setBlockData(x+ox, y, z+oz, blockData); + } + + @Override + public BlockData getBlockData(int x, int y, int z) { + return writer.getBlockData(x + ox, y, z + oz); + } + + @Override + public ChunkData getRaw() { + return null; + } + + @Override + public void inject(BiomeGrid biome) { + + } + + @Override + public void setBlock(int x, int y, int z, @NotNull Material material) { + + } + + @Override + public void setBlock(int x, int y, int z, @NotNull MaterialData material) { + + } + + @Override + public void setRegion(int xMin, int yMin, int zMin, int xMax, int yMax, int zMax, @NotNull Material material) { + + } + + @Override + public void setRegion(int xMin, int yMin, int zMin, int xMax, int yMax, int zMax, @NotNull MaterialData material) { + + } + + @Override + public void setRegion(int xMin, int yMin, int zMin, int xMax, int yMax, int zMax, @NotNull BlockData blockData) { + + } + + @NotNull + @Override + public Material getType(int x, int y, int z) { + return null; + } + + @NotNull + @Override + public MaterialData getTypeAndData(int x, int y, int z) { + return null; + } + + @Override + public byte getData(int x, int y, int z) { + return 0; + } + }).run(); + } + public Chunk generatePaper(World world, int x, int z) { precache(world, x, z); diff --git a/src/main/java/com/volmit/iris/scaffold/engine/EngineParallaxManager.java b/src/main/java/com/volmit/iris/scaffold/engine/EngineParallaxManager.java index c8fc7e687..e668b0eea 100644 --- a/src/main/java/com/volmit/iris/scaffold/engine/EngineParallaxManager.java +++ b/src/main/java/com/volmit/iris/scaffold/engine/EngineParallaxManager.java @@ -151,15 +151,19 @@ public interface EngineParallaxManager extends DataProvider, IObjectPlacer PrecisionStopwatch p = PrecisionStopwatch.start(); int s = (int) Math.ceil(getParallaxSize() / 2D); int i,j; + BurstExecutor b = MultiBurst.burst.burst((s * 2) * (s * 2)); for(i = -s; i <= s; i++) { + int ii = i; for(j = -s; j <= s; j++) { - generateParallaxLayer((i*16)+x, (j*16)+z); + int jj = j; + b.queue(() -> generateParallaxLayer((ii*16)+x, (jj*16)+z)); } } + b.complete(); getParallaxAccess().setChunkGenerated(x>>4, z>>4); p.end(); getEngine().getMetrics().getParallax().put(p.getMilliseconds()); diff --git a/src/main/java/com/volmit/iris/scaffold/engine/IrisAccess.java b/src/main/java/com/volmit/iris/scaffold/engine/IrisAccess.java index 2bd7b77d7..0d82ab855 100644 --- a/src/main/java/com/volmit/iris/scaffold/engine/IrisAccess.java +++ b/src/main/java/com/volmit/iris/scaffold/engine/IrisAccess.java @@ -3,6 +3,7 @@ package com.volmit.iris.scaffold.engine; import com.volmit.iris.manager.IrisDataManager; import com.volmit.iris.object.*; import com.volmit.iris.scaffold.data.DataProvider; +import com.volmit.iris.scaffold.parallel.MultiBurst; import com.volmit.iris.util.*; import org.bukkit.Chunk; import org.bukkit.Location; @@ -16,6 +17,10 @@ import java.util.function.Consumer; public interface IrisAccess extends Hotloadable, DataProvider { + public void directWriteMCA(World w, int x, int z, DirectWorldWriter writer, MultiBurst burst); + + public void directWriteChunk(World w, int x, int z, DirectWorldWriter writer); + public int getGenerated(); public double getGeneratedPerSecond(); diff --git a/src/main/java/com/volmit/iris/util/FakeWorld.java b/src/main/java/com/volmit/iris/util/FakeWorld.java new file mode 100644 index 000000000..a2b6724f3 --- /dev/null +++ b/src/main/java/com/volmit/iris/util/FakeWorld.java @@ -0,0 +1,1282 @@ +package com.volmit.iris.util; + +import org.bukkit.HeightMap; +import org.bukkit.*; +import org.bukkit.block.Biome; +import org.bukkit.block.Block; +import org.bukkit.block.data.BlockData; +import org.bukkit.boss.DragonBattle; +import org.bukkit.entity.*; +import org.bukkit.generator.BlockPopulator; +import org.bukkit.generator.ChunkGenerator; +import org.bukkit.inventory.ItemStack; +import org.bukkit.material.MaterialData; +import org.bukkit.metadata.MetadataValue; +import org.bukkit.plugin.Plugin; +import org.bukkit.util.BoundingBox; +import org.bukkit.util.Consumer; +import org.bukkit.util.RayTraceResult; +import org.bukkit.util.Vector; + +import java.io.File; +import java.util.*; +import java.util.function.Predicate; + +@SuppressWarnings("deprecation") +public class FakeWorld implements World +{ + private final int height; + private final long seed; + private final File worldFolder; + private final Environment environment; + + public FakeWorld(int height, long seed, File worldFolder, Environment environment) + { + this.height = height; + this.seed = seed; + this.worldFolder = worldFolder; + this.environment = environment; + } + + @Override + public void sendPluginMessage(Plugin source, String channel, byte[] message) + { + + } + + @Override + public Set getListeningPluginChannels() + { + + return null; + } + + @Override + public void setMetadata(String metadataKey, MetadataValue newMetadataValue) + { + + } + + @Override + public List getMetadata(String metadataKey) + { + + return null; + } + + @Override + public boolean hasMetadata(String metadataKey) + { + + return false; + } + + @Override + public void removeMetadata(String metadataKey, Plugin owningPlugin) + { + + } + + @Override + public Block getBlockAt(int x, int y, int z) + { + + return null; + } + + @Override + public Block getBlockAt(Location location) + { + + return null; + } + + @Override + public int getHighestBlockYAt(int x, int z) + { + + return 0; + } + + @Override + public int getHighestBlockYAt(Location location) + { + + return 0; + } + + @Override + public Block getHighestBlockAt(int x, int z) + { + + return null; + } + + @Override + public Block getHighestBlockAt(Location location) + { + + return null; + } + + @Override + public int getHighestBlockYAt(int x, int z, HeightMap heightMap) + { + + return 0; + } + + @Override + public int getHighestBlockYAt(Location location, HeightMap heightMap) + { + + return 0; + } + + @Override + public Block getHighestBlockAt(int x, int z, HeightMap heightMap) + { + + return null; + } + + @Override + public Block getHighestBlockAt(Location location, HeightMap heightMap) + { + + return null; + } + + @Override + public Chunk getChunkAt(int x, int z) + { + + return null; + } + + @Override + public Chunk getChunkAt(Location location) + { + + return null; + } + + @Override + public Chunk getChunkAt(Block block) + { + + return null; + } + + @Override + public boolean isChunkLoaded(Chunk chunk) + { + + return false; + } + + @Override + public Chunk[] getLoadedChunks() + { + + return null; + } + + @Override + public void loadChunk(Chunk chunk) + { + + } + + @Override + public boolean isChunkLoaded(int x, int z) + { + + return false; + } + + @Override + public boolean isChunkGenerated(int x, int z) + { + + return false; + } + + @Override + public boolean isChunkInUse(int x, int z) + { + + return false; + } + + @Override + public void loadChunk(int x, int z) + { + + } + + @Override + public boolean loadChunk(int x, int z, boolean generate) + { + + return false; + } + + @Override + public boolean unloadChunk(Chunk chunk) + { + + return false; + } + + @Override + public boolean unloadChunk(int x, int z) + { + + return false; + } + + @Override + public boolean unloadChunk(int x, int z, boolean save) + { + + return false; + } + + @Override + public boolean unloadChunkRequest(int x, int z) + { + + return false; + } + + @Override + public boolean regenerateChunk(int x, int z) + { + + return false; + } + + @Override + public boolean refreshChunk(int x, int z) + { + + return false; + } + + @Override + public boolean isChunkForceLoaded(int x, int z) + { + + return false; + } + + @Override + public void setChunkForceLoaded(int x, int z, boolean forced) + { + + } + + @Override + public Collection getForceLoadedChunks() + { + + return null; + } + + @Override + public boolean addPluginChunkTicket(int x, int z, Plugin plugin) + { + + return false; + } + + @Override + public boolean removePluginChunkTicket(int x, int z, Plugin plugin) + { + + return false; + } + + @Override + public void removePluginChunkTickets(Plugin plugin) + { + + } + + @Override + public Collection getPluginChunkTickets(int x, int z) + { + + return null; + } + + @Override + public Map> getPluginChunkTickets() + { + + return null; + } + + @Override + public Item dropItem(Location location, ItemStack item) + { + + return null; + } + + @Override + public Item dropItemNaturally(Location location, ItemStack item) + { + + return null; + } + + @Override + public Arrow spawnArrow(Location location, Vector direction, float speed, float spread) + { + + return null; + } + + @Override + public T spawnArrow(Location location, Vector direction, float speed, float spread, Class clazz) + { + + return null; + } + + @Override + public boolean generateTree(Location location, TreeType type) + { + + return false; + } + + @Override + public boolean generateTree(Location loc, TreeType type, BlockChangeDelegate delegate) + { + + return false; + } + + @Override + public Entity spawnEntity(Location loc, EntityType type) + { + + return null; + } + + @Override + public LightningStrike strikeLightning(Location loc) + { + + return null; + } + + @Override + public LightningStrike strikeLightningEffect(Location loc) + { + + return null; + } + + @Override + public List getEntities() + { + + return null; + } + + @Override + public List getLivingEntities() + { + + return null; + } + + @Override + public Collection getEntitiesByClass(@SuppressWarnings("unchecked") Class... classes) + { + + return null; + } + + @Override + public Collection getEntitiesByClass(Class cls) + { + + return null; + } + + @Override + public Collection getEntitiesByClasses(Class... classes) + { + + return null; + } + + @Override + public List getPlayers() + { + + return null; + } + + @Override + public Collection getNearbyEntities(Location location, double x, double y, double z) + { + + return null; + } + + @Override + public Collection getNearbyEntities(Location location, double x, double y, double z, Predicate filter) + { + + return null; + } + + @Override + public Collection getNearbyEntities(BoundingBox boundingBox) + { + + return null; + } + + @Override + public Collection getNearbyEntities(BoundingBox boundingBox, Predicate filter) + { + + return null; + } + + @Override + public RayTraceResult rayTraceEntities(Location start, Vector direction, double maxDistance) + { + + return null; + } + + @Override + public RayTraceResult rayTraceEntities(Location start, Vector direction, double maxDistance, double raySize) + { + + return null; + } + + @Override + public RayTraceResult rayTraceEntities(Location start, Vector direction, double maxDistance, Predicate filter) + { + + return null; + } + + @Override + public RayTraceResult rayTraceEntities(Location start, Vector direction, double maxDistance, double raySize, Predicate filter) + { + + return null; + } + + @Override + public RayTraceResult rayTraceBlocks(Location start, Vector direction, double maxDistance) + { + + return null; + } + + @Override + public RayTraceResult rayTraceBlocks(Location start, Vector direction, double maxDistance, FluidCollisionMode fluidCollisionMode) + { + + return null; + } + + @Override + public RayTraceResult rayTraceBlocks(Location start, Vector direction, double maxDistance, FluidCollisionMode fluidCollisionMode, boolean ignorePassableBlocks) + { + + return null; + } + + @Override + public RayTraceResult rayTrace(Location start, Vector direction, double maxDistance, FluidCollisionMode fluidCollisionMode, boolean ignorePassableBlocks, double raySize, Predicate filter) + { + + return null; + } + + @Override + public String getName() + { + + return null; + } + + @Override + public UUID getUID() + { + + return null; + } + + @Override + public Location getSpawnLocation() + { + + return null; + } + + @Override + public boolean setSpawnLocation(Location location) + { + + return false; + } + + @Override + public boolean setSpawnLocation(int x, int y, int z) + { + + return false; + } + + @Override + public long getTime() + { + + return 0; + } + + @Override + public void setTime(long time) + { + + } + + @Override + public long getFullTime() + { + + return 0; + } + + @Override + public void setFullTime(long time) + { + + } + + @Override + public boolean hasStorm() + { + + return false; + } + + @Override + public void setStorm(boolean hasStorm) + { + + } + + @Override + public int getWeatherDuration() + { + + return 0; + } + + @Override + public void setWeatherDuration(int duration) + { + + } + + @Override + public boolean isThundering() + { + + return false; + } + + @Override + public void setThundering(boolean thundering) + { + + } + + @Override + public int getThunderDuration() + { + + return 0; + } + + @Override + public void setThunderDuration(int duration) + { + + } + + @Override + public boolean createExplosion(double x, double y, double z, float power) + { + + return false; + } + + @Override + public boolean createExplosion(double x, double y, double z, float power, boolean setFire) + { + + return false; + } + + @Override + public boolean createExplosion(double x, double y, double z, float power, boolean setFire, boolean breakBlocks) + { + + return false; + } + + @Override + public boolean createExplosion(double x, double y, double z, float power, boolean setFire, boolean breakBlocks, Entity source) + { + + return false; + } + + @Override + public boolean createExplosion(Location loc, float power) + { + + return false; + } + + @Override + public boolean createExplosion(Location loc, float power, boolean setFire) + { + + return false; + } + + @Override + public boolean createExplosion(Location loc, float power, boolean setFire, boolean breakBlocks) + { + + return false; + } + + @Override + public boolean createExplosion(Location loc, float power, boolean setFire, boolean breakBlocks, Entity source) + { + + return false; + } + + @Override + public Environment getEnvironment() + { + + return environment; + } + + @Override + public long getSeed() + { + + return seed; + } + + @Override + public boolean getPVP() + { + + return false; + } + + @Override + public void setPVP(boolean pvp) + { + + } + + @Override + public ChunkGenerator getGenerator() + { + + return null; + } + + @Override + public void save() + { + + } + + @Override + public List getPopulators() + { + + return null; + } + + @Override + public T spawn(Location location, Class clazz) throws IllegalArgumentException + { + + return null; + } + + @Override + public T spawn(Location location, Class clazz, Consumer function) throws IllegalArgumentException + { + + return null; + } + + @Override + public FallingBlock spawnFallingBlock(Location location, MaterialData data) throws IllegalArgumentException + { + + return null; + } + + @Override + public FallingBlock spawnFallingBlock(Location location, BlockData data) throws IllegalArgumentException + { + + return null; + } + + @Override + public FallingBlock spawnFallingBlock(Location location, Material material, byte data) throws IllegalArgumentException + { + + return null; + } + + @Override + public void playEffect(Location location, Effect effect, int data) + { + + } + + @Override + public void playEffect(Location location, Effect effect, int data, int radius) + { + + } + + @Override + public void playEffect(Location location, Effect effect, T data) + { + + } + + @Override + public void playEffect(Location location, Effect effect, T data, int radius) + { + + } + + @Override + public ChunkSnapshot getEmptyChunkSnapshot(int x, int z, boolean includeBiome, boolean includeBiomeTemp) + { + + return null; + } + + @Override + public void setSpawnFlags(boolean allowMonsters, boolean allowAnimals) + { + + } + + @Override + public boolean getAllowAnimals() + { + + return false; + } + + @Override + public boolean getAllowMonsters() + { + + return false; + } + + @Override + public Biome getBiome(int x, int z) + { + + return null; + } + + @Override + public Biome getBiome(int x, int y, int z) + { + + return null; + } + + @Override + public void setBiome(int x, int z, Biome bio) + { + + } + + @Override + public void setBiome(int x, int y, int z, Biome bio) + { + + } + + @Override + public double getTemperature(int x, int z) + { + + return 0; + } + + @Override + public double getTemperature(int x, int y, int z) + { + + return 0; + } + + @Override + public double getHumidity(int x, int z) + { + + return 0; + } + + @Override + public double getHumidity(int x, int y, int z) + { + + return 0; + } + + @Override + public int getMaxHeight() + { + + return height; + } + + @Override + public int getSeaLevel() + { + + return 0; + } + + @Override + public boolean getKeepSpawnInMemory() + { + + return false; + } + + @Override + public void setKeepSpawnInMemory(boolean keepLoaded) + { + + } + + @Override + public boolean isAutoSave() + { + + return false; + } + + @Override + public void setAutoSave(boolean value) + { + + } + + @Override + public void setDifficulty(Difficulty difficulty) + { + + } + + @Override + public Difficulty getDifficulty() + { + + return null; + } + + @Override + public File getWorldFolder() + { + + return worldFolder; + } + + @Override + public WorldType getWorldType() + { + + return null; + } + + @Override + public boolean canGenerateStructures() + { + + return false; + } + + @Override + public boolean isHardcore() + { + + return false; + } + + @Override + public void setHardcore(boolean hardcore) + { + + } + + @Override + public long getTicksPerAnimalSpawns() + { + + return 0; + } + + @Override + public void setTicksPerAnimalSpawns(int ticksPerAnimalSpawns) + { + + } + + @Override + public long getTicksPerMonsterSpawns() + { + + return 0; + } + + @Override + public void setTicksPerMonsterSpawns(int ticksPerMonsterSpawns) + { + + } + + @Override + public long getTicksPerWaterSpawns() + { + + return 0; + } + + @Override + public void setTicksPerWaterSpawns(int ticksPerWaterSpawns) + { + + } + + @Override + public long getTicksPerWaterAmbientSpawns() + { + + return 0; + } + + @Override + public void setTicksPerWaterAmbientSpawns(int ticksPerAmbientSpawns) + { + + } + + @Override + public long getTicksPerAmbientSpawns() + { + + return 0; + } + + @Override + public void setTicksPerAmbientSpawns(int ticksPerAmbientSpawns) + { + + } + + @Override + public int getMonsterSpawnLimit() + { + + return 0; + } + + @Override + public void setMonsterSpawnLimit(int limit) + { + + } + + @Override + public int getAnimalSpawnLimit() + { + + return 0; + } + + @Override + public void setAnimalSpawnLimit(int limit) + { + + } + + @Override + public int getWaterAnimalSpawnLimit() + { + + return 0; + } + + @Override + public void setWaterAnimalSpawnLimit(int limit) + { + + } + + @Override + public int getWaterAmbientSpawnLimit() + { + + return 0; + } + + @Override + public void setWaterAmbientSpawnLimit(int limit) + { + + } + + @Override + public int getAmbientSpawnLimit() + { + + return 0; + } + + @Override + public void setAmbientSpawnLimit(int limit) + { + + } + + @Override + public void playSound(Location location, Sound sound, float volume, float pitch) + { + + } + + @Override + public void playSound(Location location, String sound, float volume, float pitch) + { + + } + + @Override + public void playSound(Location location, Sound sound, SoundCategory category, float volume, float pitch) + { + + } + + @Override + public void playSound(Location location, String sound, SoundCategory category, float volume, float pitch) + { + + } + + @Override + public String[] getGameRules() + { + + return null; + } + + @Override + public String getGameRuleValue(String rule) + { + + return null; + } + + @Override + public boolean setGameRuleValue(String rule, String value) + { + + return false; + } + + @Override + public boolean isGameRule(String rule) + { + + return false; + } + + @Override + public T getGameRuleValue(GameRule rule) + { + + return null; + } + + @Override + public T getGameRuleDefault(GameRule rule) + { + + return null; + } + + @Override + public boolean setGameRule(GameRule rule, T newValue) + { + + return false; + } + + @Override + public WorldBorder getWorldBorder() + { + + return null; + } + + @Override + public void spawnParticle(Particle particle, Location location, int count) + { + + } + + @Override + public void spawnParticle(Particle particle, double x, double y, double z, int count) + { + + } + + @Override + public void spawnParticle(Particle particle, Location location, int count, T data) + { + + } + + @Override + public void spawnParticle(Particle particle, double x, double y, double z, int count, T data) + { + + } + + @Override + public void spawnParticle(Particle particle, Location location, int count, double offsetX, double offsetY, double offsetZ) + { + + } + + @Override + public void spawnParticle(Particle particle, double x, double y, double z, int count, double offsetX, double offsetY, double offsetZ) + { + + } + + @Override + public void spawnParticle(Particle particle, Location location, int count, double offsetX, double offsetY, double offsetZ, T data) + { + + } + + @Override + public void spawnParticle(Particle particle, double x, double y, double z, int count, double offsetX, double offsetY, double offsetZ, T data) + { + + } + + @Override + public void spawnParticle(Particle particle, Location location, int count, double offsetX, double offsetY, double offsetZ, double extra) + { + + } + + @Override + public void spawnParticle(Particle particle, double x, double y, double z, int count, double offsetX, double offsetY, double offsetZ, double extra) + { + + } + + @Override + public void spawnParticle(Particle particle, Location location, int count, double offsetX, double offsetY, double offsetZ, double extra, T data) + { + + } + + @Override + public void spawnParticle(Particle particle, double x, double y, double z, int count, double offsetX, double offsetY, double offsetZ, double extra, T data) + { + + } + + @Override + public void spawnParticle(Particle particle, Location location, int count, double offsetX, double offsetY, double offsetZ, double extra, T data, boolean force) + { + + } + + @Override + public void spawnParticle(Particle particle, double x, double y, double z, int count, double offsetX, double offsetY, double offsetZ, double extra, T data, boolean force) + { + + } + + @Override + public Location locateNearestStructure(Location origin, StructureType structureType, int radius, boolean findUnexplored) + { + return null; + } + + @Override + public int getViewDistance() + { + return 0; + } + + @Override + public Spigot spigot() + { + return null; + } + + @Override + public Raid locateNearestRaid(Location location, int radius) + { + return null; + } + + @Override + public List getRaids() + { + return null; + } + + @Override + public DragonBattle getEnderDragonBattle() + { + return null; + } +} diff --git a/src/main/java/com/volmit/iris/util/PregenJob.java b/src/main/java/com/volmit/iris/util/PregenJob.java index 1ab9d91e2..55ad7e65f 100644 --- a/src/main/java/com/volmit/iris/util/PregenJob.java +++ b/src/main/java/com/volmit/iris/util/PregenJob.java @@ -4,6 +4,7 @@ import com.volmit.iris.Iris; import com.volmit.iris.IrisSettings; import com.volmit.iris.manager.gui.PregenGui; import com.volmit.iris.scaffold.IrisWorlds; +import com.volmit.iris.scaffold.engine.DirectWorldWriter; import com.volmit.iris.scaffold.engine.IrisAccess; import com.volmit.iris.scaffold.parallel.MultiBurst; import io.papermc.lib.PaperLib; @@ -60,12 +61,14 @@ public class PregenJob implements Listener private long pausedAt = 0; private double pms = 0; private boolean gleaming = false; + private final DirectWorldWriter writer; int xc = 0; private IrisAccess access = null; public PregenJob(World world, int size, MortarSender sender, Runnable onDone) { - gleaming = (IrisSettings.get().isUseGleamPregenerator() && PaperLib.isPaper()); + writer = new DirectWorldWriter(world.getWorldFolder()); + gleaming = (IrisSettings.get().isUseGleamPregenerator()); g.set(0); burst = new MultiBurst(gleaming ? IrisSettings.get().getMaxAsyncChunkPregenThreads() : tc()); instance = this; @@ -393,26 +396,48 @@ public class PregenJob implements Listener consumer.accept(new ChunkPosition(chunkX, chunkZ), Color.cyan.darker().darker().darker()); } - J.a(() -> { + Runnable g = () -> { try { working.acquire(); if(consumer != null) { consumer.accept(new ChunkPosition(cx, cz), Color.cyan); } - Chunk chunk = access().generatePaper(world, cx, cz); + int xx = cx; + int zz = cz; + + if(IrisSettings.get().isUseExperimentalGleamMCADirectWriteMode()) + { + access().directWriteChunk(world, cx, cz, writer); + } + + else + { + access().generatePaper(world, cx, cz); + } + working.release(); genned++; nogen = M.ms(); if(consumer != null) { - consumer.accept(new ChunkPosition(chunk.getX(), chunk.getZ()), Color.yellow); + if(IrisSettings.get().isUseExperimentalGleamMCADirectWriteMode()) + { + consumer.accept(new ChunkPosition(xx, zz), Color.blue); + + } + + else { + consumer.accept(new ChunkPosition(xx, zz), Color.yellow); + } } } catch (InterruptedException e) { e.printStackTrace(); } - }); + }; + + J.a(g); } else @@ -559,6 +584,8 @@ public class PregenJob implements Listener world.save(); Bukkit.dispatchCommand(Bukkit.getConsoleSender(), "save-all"); } + + writer.flush(); } public int max()