From 0c5855a82d0877c8cdfb9c1ac35b465bd37d1e97 Mon Sep 17 00:00:00 2001 From: Daniel Mills Date: Sun, 16 Aug 2020 21:14:40 -0400 Subject: [PATCH] Alright --- .../iris/gen/TerrainChunkGenerator.java | 8 +- .../volmit/iris/gen/layer/GenLayerCave.java | 176 +++++++++--------- .../com/volmit/iris/object/IrisCaveLayer.java | 42 +++++ .../com/volmit/iris/object/IrisDimension.java | 27 +-- .../iris/object/IrisShapedGeneratorStyle.java | 44 +++++ 5 files changed, 189 insertions(+), 108 deletions(-) create mode 100644 src/main/java/com/volmit/iris/object/IrisCaveLayer.java create mode 100644 src/main/java/com/volmit/iris/object/IrisShapedGeneratorStyle.java diff --git a/src/main/java/com/volmit/iris/gen/TerrainChunkGenerator.java b/src/main/java/com/volmit/iris/gen/TerrainChunkGenerator.java index 605e6f73c..a061eb110 100644 --- a/src/main/java/com/volmit/iris/gen/TerrainChunkGenerator.java +++ b/src/main/java/com/volmit/iris/gen/TerrainChunkGenerator.java @@ -144,11 +144,15 @@ public abstract class TerrainChunkGenerator extends ParallelChunkGenerator for(int kv = Math.max(height, fluidHeight); kv < Math.min(Math.max(height, fluidHeight) + 16, 255); kv++) { Biome skyBiome = biome.getSkyBiome(masterRandom, rz, kv, rx); - sliver.set(kv, biome.getDerivative()); - sliver.set(k, skyBiome); + sliver.set(kv, skyBiome); } } + if(k <= Math.max(height, fluidHeight)) + { + sliver.set(k, biome.getGroundBiome(masterRandom, rz, k, rx)); + } + // Set Sea Material (water/lava) if(underwater) { diff --git a/src/main/java/com/volmit/iris/gen/layer/GenLayerCave.java b/src/main/java/com/volmit/iris/gen/layer/GenLayerCave.java index ed9d3a424..7cf096d8e 100644 --- a/src/main/java/com/volmit/iris/gen/layer/GenLayerCave.java +++ b/src/main/java/com/volmit/iris/gen/layer/GenLayerCave.java @@ -5,11 +5,11 @@ import org.bukkit.block.data.BlockData; import com.volmit.iris.gen.DimensionChunkGenerator; import com.volmit.iris.gen.atomics.AtomicSliver; -import com.volmit.iris.noise.CNG; import com.volmit.iris.noise.FastNoise; import com.volmit.iris.noise.FastNoise.CellularDistanceFunction; import com.volmit.iris.noise.FastNoise.CellularReturnType; import com.volmit.iris.noise.FastNoise.NoiseType; +import com.volmit.iris.object.IrisCaveLayer; import com.volmit.iris.util.B; import com.volmit.iris.util.CaveResult; import com.volmit.iris.util.GenLayer; @@ -21,16 +21,12 @@ public class GenLayerCave extends GenLayer public static final BlockData CAVE_AIR = B.getBlockData("CAVE_AIR"); public static final BlockData AIR = B.getBlockData("AIR"); private static final KList EMPTY = new KList<>(); - private CNG gincline; - private CNG shuffle; private FastNoise gg; public GenLayerCave(DimensionChunkGenerator iris, RNG rng) { //@builder super(iris, rng); - shuffle = CNG.signature(rng.nextParallelRNG(1348566)); - gincline = new CNG(rng.nextParallelRNG(26512), 1D, 3).scale(0.00452); gg = new FastNoise(324895 * rng.nextParallelRNG(49678).imax()); //@done } @@ -42,116 +38,124 @@ public class GenLayerCave extends GenLayer return EMPTY; } - int surface = data.getHighestBlock(); KList result = new KList<>(); - shuffle.scale(0.01); - double shuffleDistance = 72; gg.SetNoiseType(NoiseType.Cellular); gg.SetCellularReturnType(CellularReturnType.Distance2Sub); gg.SetCellularDistanceFunction(CellularDistanceFunction.Natural); - for(int i = 0; i < 3; i++) + for(int i = 0; i < iris.getDimension().getCaveLayers().size(); i++) { - double wx = wxx + (shuffle.noise(wxx, wzz) * shuffleDistance); - double wz = wzz + (shuffle.noise(wzz, wxx) * shuffleDistance); - double incline = 157; - double baseWidth = (14 * iris.getDimension().getCaveScale()); - double distanceCheck = 0.0132 * baseWidth; - double distanceTake = 0.0022 * baseWidth; - double drop = (-i * 17) + 44 + iris.getDimension().getCaveShift(); - double caveHeightNoise = incline * gincline.noise((wx + (10000 * i)), (wz - (10000 * i))); - caveHeightNoise += shuffle.fitDouble(-1, 1, wxx - caveHeightNoise, wzz + caveHeightNoise) * 3; + IrisCaveLayer layer = iris.getDimension().getCaveLayers().get(i); + generateCave(result, wxx, wzz, x, z, data, layer, i); + } - int ceiling = -256; - int floor = 512; + return result; + } - for(double tunnelHeight = 1; tunnelHeight <= baseWidth; tunnelHeight++) + public void generateCave(KList result, double wxx, double wzz, int x, int z, AtomicSliver data, IrisCaveLayer layer, int seed) + { + double scale = layer.getCaveZoom(); + + int surface = data.getHighestBlock(); + double wx = wxx + layer.getHorizontalSlope().get(rng, wxx, wzz); + double wz = wzz + layer.getHorizontalSlope().get(rng, -wzz, -wxx); + double baseWidth = (14 * scale); + double distanceCheck = 0.0132 * baseWidth; + double distanceTake = 0.0022 * baseWidth; + double caveHeightNoise = layer.getVerticalSlope().get(rng, wxx, wzz); + + int ceiling = -256; + int floor = 512; + + for(double tunnelHeight = 1; tunnelHeight <= baseWidth; tunnelHeight++) + { + double distance = (gg.GetCellular((float) ((wx + (10000 * seed)) / layer.getCaveZoom()), (float) ((wz - (10000 * seed)) / layer.getCaveZoom())) + 1D) / 2D; + if(distance < distanceCheck - (tunnelHeight * distanceTake)) { - double distance = (gg.GetCellular((float) wx + (10000 * i), (float) wz - (10000 * i)) + 1D) / 2D; - if(distance < distanceCheck - (tunnelHeight * distanceTake)) + int caveHeight = (int) Math.round(caveHeightNoise); + int pu = (int) (caveHeight + tunnelHeight); + int pd = (int) (caveHeight - tunnelHeight); + + if(pd > surface + 1) { - int caveHeight = (int) Math.round(caveHeightNoise - drop); - int pu = (int) (caveHeight + tunnelHeight); - int pd = (int) (caveHeight - tunnelHeight); + continue; + } - if(pd > surface + 1) + if(!layer.isCanBreakSurface() && pu > surface - 3) + { + continue; + } + + if((pu > 255 && pd > 255) || (pu < 0 && pd < 0)) + { + continue; + } + + if(data == null) + { + ceiling = pu > ceiling ? pu : ceiling; + floor = pu < floor ? pu : floor; + ceiling = pd > ceiling ? pd : ceiling; + floor = pd < floor ? pd : floor; + + if(tunnelHeight == 1) { - continue; + ceiling = caveHeight > ceiling ? caveHeight : ceiling; + floor = caveHeight < floor ? caveHeight : floor; } + } - if((pu > 255 && pd > 255) || (pu < 0 && pd < 0)) - { - continue; - } - - if(data == null) + else + { + if(dig(x, pu, z, data)) { ceiling = pu > ceiling ? pu : ceiling; floor = pu < floor ? pu : floor; + + if(pu > surface - 2) + { + if(dig(x, pu + 1, z, data)) + { + ceiling = pu + 1 > ceiling ? pu + 1 : ceiling; + floor = pu + 1 < floor ? pu + 1 : floor; + + if(dig(x, pu + 2, z, data)) + { + ceiling = pu + 2 > ceiling ? pu + 2 : ceiling; + floor = pu + 2 < floor ? pu + 2 : floor; + + if(dig(x, pu + 3, z, data)) + { + ceiling = pu + 3 > ceiling ? pu + 3 : ceiling; + floor = pu + 3 < floor ? pu + 3 : floor; + } + } + } + } + } + + if(dig(x, pd, z, data)) + { ceiling = pd > ceiling ? pd : ceiling; floor = pd < floor ? pd : floor; + } - if(tunnelHeight == 1) + if(tunnelHeight == 1) + { + if(dig(x, (int) (caveHeight), z, data)) { ceiling = caveHeight > ceiling ? caveHeight : ceiling; floor = caveHeight < floor ? caveHeight : floor; } } - - else - { - if(dig(x, pu, z, data)) - { - ceiling = pu > ceiling ? pu : ceiling; - floor = pu < floor ? pu : floor; - - if(pu > surface - 2) - { - if(dig(x, pu + 1, z, data)) - { - ceiling = pu + 1 > ceiling ? pu + 1 : ceiling; - floor = pu + 1 < floor ? pu + 1 : floor; - - if(dig(x, pu + 2, z, data)) - { - ceiling = pu + 2 > ceiling ? pu + 2 : ceiling; - floor = pu + 2 < floor ? pu + 2 : floor; - - if(dig(x, pu + 3, z, data)) - { - ceiling = pu + 3 > ceiling ? pu + 3 : ceiling; - floor = pu + 3 < floor ? pu + 3 : floor; - } - } - } - } - } - - if(dig(x, pd, z, data)) - { - ceiling = pd > ceiling ? pd : ceiling; - floor = pd < floor ? pd : floor; - } - - if(tunnelHeight == 1) - { - if(dig(x, (int) (caveHeight), z, data)) - { - ceiling = caveHeight > ceiling ? caveHeight : ceiling; - floor = caveHeight < floor ? caveHeight : floor; - } - } - } } } - - if(floor >= 0 && ceiling <= 255) - { - result.add(new CaveResult(floor, ceiling)); - } } - return result; + if(floor >= 0 && ceiling <= 255) + { + result.add(new CaveResult(floor, ceiling)); + } } public boolean dig(int x, int y, int z, AtomicSliver data) diff --git a/src/main/java/com/volmit/iris/object/IrisCaveLayer.java b/src/main/java/com/volmit/iris/object/IrisCaveLayer.java new file mode 100644 index 000000000..868f72ca8 --- /dev/null +++ b/src/main/java/com/volmit/iris/object/IrisCaveLayer.java @@ -0,0 +1,42 @@ +package com.volmit.iris.object; + +import com.volmit.iris.util.Desc; +import com.volmit.iris.util.DontObfuscate; +import com.volmit.iris.util.MinNumber; +import com.volmit.iris.util.Required; + +import lombok.Data; + +@Desc("Translate objects") +@Data +public class IrisCaveLayer +{ + @Required + @DontObfuscate + @Desc("The vertical slope this cave layer follows") + private IrisShapedGeneratorStyle verticalSlope = new IrisShapedGeneratorStyle(); + + @Required + @DontObfuscate + @Desc("The horizontal slope this cave layer follows") + private IrisShapedGeneratorStyle horizontalSlope = new IrisShapedGeneratorStyle(); + + @MinNumber(0.001) + @DontObfuscate + @Desc("The cave zoom. Higher values makes caves spread out further and branch less often, but are thicker.") + private double caveZoom = 1D; + + @MinNumber(0.001) + @DontObfuscate + @Desc("The cave thickness.") + private double caveThickness = 1D; + + @DontObfuscate + @Desc("If set to true, this cave layer can break the surface") + private boolean canBreakSurface = false; + + public IrisCaveLayer() + { + + } +} diff --git a/src/main/java/com/volmit/iris/object/IrisDimension.java b/src/main/java/com/volmit/iris/object/IrisDimension.java index 69b20dcde..6327513d4 100644 --- a/src/main/java/com/volmit/iris/object/IrisDimension.java +++ b/src/main/java/com/volmit/iris/object/IrisDimension.java @@ -43,24 +43,12 @@ public class IrisDimension extends IrisRegistrant @Desc("The human readable name of this dimension") private String name = "A Dimension"; - @MinNumber(0.0001) - @MaxNumber(64) - @DontObfuscate - @Desc("The Thickness scale of cave veins") - private double caveThickness = 1D; - @Required @MinNumber(0) @DontObfuscate @Desc("The version of this dimension. Changing this will stop users from accidentally upgrading (and breaking their worlds).") private int version = 1; - @MinNumber(0.0001) - @MaxNumber(512) - @DontObfuscate - @Desc("The cave web scale. Smaller values means scaled up vein networks.") - private double caveScale = 1D; - @DontObfuscate @Desc("The placement style of regions") private IrisGeneratorStyle regionStyle = NoiseStyle.CELLULAR_IRIS_DOUBLE.style(); @@ -93,12 +81,6 @@ public class IrisDimension extends IrisRegistrant @Desc("The placement style of biomes") private IrisGeneratorStyle skylandBiomeStyle = NoiseStyle.CELLULAR_IRIS_DOUBLE.style(); - @MinNumber(-256) - @MaxNumber(256) - @DontObfuscate - @Desc("Shift the Y value of the cave networks up or down.") - private double caveShift = 0D; - @DontObfuscate @Desc("Generate caves or not.") private boolean caves = true; @@ -267,6 +249,11 @@ public class IrisDimension extends IrisRegistrant @Desc("The noise style for rock types") private IrisGeneratorStyle rockStyle = NoiseStyle.STATIC.style(); + @ArrayType(min = 1, type = IrisCaveLayer.class) + @DontObfuscate + @Desc("Define cave layers") + private KList caveLayers = new KList<>(); + @DontObfuscate @Desc("The noise style for fluid types") private IrisGeneratorStyle fluidStyle = NoiseStyle.STATIC.style(); @@ -509,7 +496,7 @@ public class IrisDimension extends IrisRegistrant { return rockLayerGenerator.aquire(() -> { - RNG rngx = rng.nextParallelRNG((int) (getRockData().size() * getRegions().size() * getCaveScale() * getLandZoom() * 10357)); + RNG rngx = rng.nextParallelRNG((int) (getRockData().size() * getRegions().size() * getLandZoom() * 10357)); return rockStyle.create(rngx); }); } @@ -551,7 +538,7 @@ public class IrisDimension extends IrisRegistrant { return fluidLayerGenerator.aquire(() -> { - RNG rngx = rng.nextParallelRNG(getFluidData().size() * (int) (getRockData().size() * getRegions().size() * getCaveScale() * getLandZoom() * 10357)); + RNG rngx = rng.nextParallelRNG(getFluidData().size() * (int) (getRockData().size() * getRegions().size() * getLandZoom() * 10357)); return fluidStyle.create(rngx); }); } diff --git a/src/main/java/com/volmit/iris/object/IrisShapedGeneratorStyle.java b/src/main/java/com/volmit/iris/object/IrisShapedGeneratorStyle.java new file mode 100644 index 000000000..78add370a --- /dev/null +++ b/src/main/java/com/volmit/iris/object/IrisShapedGeneratorStyle.java @@ -0,0 +1,44 @@ +package com.volmit.iris.object; + +import com.volmit.iris.util.Desc; +import com.volmit.iris.util.DontObfuscate; +import com.volmit.iris.util.MaxNumber; +import com.volmit.iris.util.MinNumber; +import com.volmit.iris.util.RNG; +import com.volmit.iris.util.Required; + +import lombok.Data; + +@Desc("This represents a generator with a min and max height") +@Data +public class IrisShapedGeneratorStyle +{ + @Required + @DontObfuscate + @Desc("The generator id") + private IrisGeneratorStyle generator = new IrisGeneratorStyle(NoiseStyle.IRIS); + + @Required + @MinNumber(-256) + @MaxNumber(256) + @DontObfuscate + @Desc("The min block value") + private int min = 0; + + @Required + @MinNumber(-256) + @MaxNumber(256) + @DontObfuscate + @Desc("The max block value") + private int max = 0; + + public double get(RNG rng, double... dim) + { + return generator.create(rng).fitDouble(min, max, dim); + } + + public IrisShapedGeneratorStyle() + { + + } +}