mirrors/Iris
1
0
Fork 0
mirror of https://github.com/VolmitSoftware/Iris.git synced 2026-04-17 05:40:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

Gen Features

Browse Source
This commit is contained in:
Daniel Mills
2020-01-14 21:11:46 -05:00
parent 90846401a5
commit 417a759c40
14 changed files with 344 additions and 89 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
src/main/java/ninja/bytecode/iris/generator/IrisGenerator.java
View File

@@ -16,6 +16,7 @@ import ninja.bytecode.iris.generator.genobject.GenObjectGroup;
import ninja.bytecode.iris.generator.layer.GenLayerBase;
import ninja.bytecode.iris.generator.layer.GenLayerBiome;
import ninja.bytecode.iris.generator.layer.GenLayerCarving;
import ninja.bytecode.iris.generator.layer.GenLayerCaverns;
import ninja.bytecode.iris.generator.layer.GenLayerCaves;
import ninja.bytecode.iris.generator.layer.GenLayerLayeredNoise;
import ninja.bytecode.iris.generator.layer.GenLayerRidge;
@@ -30,6 +31,7 @@ import ninja.bytecode.iris.util.ParallelChunkGenerator;
import ninja.bytecode.shuriken.collections.GList;
import ninja.bytecode.shuriken.collections.GMap;
import ninja.bytecode.shuriken.logging.L;
import ninja.bytecode.shuriken.math.CNG;
import ninja.bytecode.shuriken.math.M;
import ninja.bytecode.shuriken.math.RNG;
@@ -63,8 +65,10 @@ public class IrisGenerator extends ParallelChunkGenerator
private GenLayerBiome glBiome;
private GenLayerCaves glCaves;
private GenLayerCarving glCarving;
private GenLayerCaverns glCaverns;
private GenLayerSnow glSnow;
private RNG rTerrain;
private CNG lerpf;
private CompiledDimension dim;
private World world;
private GMap<String, GenObjectGroup> schematicCache = new GMap<>();
@@ -87,7 +91,7 @@ public class IrisGenerator extends ParallelChunkGenerator
if(j.getName().equals(i.getName()))
{
internal.remove(j);
L.i(ChatColor.LIGHT_PURPLE + "Internal Biome: " + ChatColor.WHITE+ j.getName() + ChatColor.LIGHT_PURPLE + " overwritten by dimension " + ChatColor.WHITE + dim.getName());
L.i(ChatColor.LIGHT_PURPLE + "Internal Biome: " + ChatColor.WHITE + j.getName() + ChatColor.LIGHT_PURPLE + " overwritten by dimension " + ChatColor.WHITE + dim.getName());
}
}
}
@@ -110,12 +114,14 @@ public class IrisGenerator extends ParallelChunkGenerator
{
this.world = world;
rTerrain = new RNG(world.getSeed() + 1024);
lerpf = new CNG(rTerrain.nextParallelRNG(-10000), 1D, 2).scale(Iris.settings.gen.linearSampleFractureScale);
glBase = new GenLayerBase(this, world, random, rTerrain.nextParallelRNG(1));
glLNoise = new GenLayerLayeredNoise(this, world, random, rTerrain.nextParallelRNG(2));
glRidge = new GenLayerRidge(this, world, random, rTerrain.nextParallelRNG(3));
glBiome = new GenLayerBiome(this, world, random, rTerrain.nextParallelRNG(4), dim.getBiomes());
glCaves = new GenLayerCaves(this, world, random, rTerrain.nextParallelRNG(-1));
glCarving = new GenLayerCarving(this, world, random, rTerrain.nextParallelRNG(-2));
glCaverns = new GenLayerCaverns(this, world, random, rTerrain.nextParallelRNG(-3));
glSnow = new GenLayerSnow(this, world, random, rTerrain.nextParallelRNG(5));
}
@@ -140,17 +146,24 @@ public class IrisGenerator extends ParallelChunkGenerator
@Override
public Biome genColumn(int wxx, int wzx, int x, int z, ChunkPlan plan)
{
//@builder
int highest = 0;
int seaLevel = Iris.settings.gen.seaLevel;
double wx = Math.round((double) wxx * Iris.settings.gen.horizontalZoom);
double wz = Math.round((double) wzx * Iris.settings.gen.horizontalZoom);
IrisBiome biome = getBiome(wxx, wzx);
double hv = IrisInterpolation.getBicubicNoise(wxx, wzx, (xf, zf) -> getBiomedHeight((int) Math.round(xf), (int) Math.round(zf), plan));
double hv = IrisInterpolation.getNoise(wxx, wzx,
(xf, zf) -> getBiomedHeight((int) Math.round(xf), (int) Math.round(zf), plan),
(a, b) -> lerpf.noise(a, b),
Iris.settings.gen.linearFunction,
Iris.settings.gen.bilinearFunction,
Iris.settings.gen.trilinearFunction);
hv += glLNoise.generateLayer(hv * Iris.settings.gen.roughness * 215, wxx * Iris.settings.gen.roughness * 0.82, wzx * Iris.settings.gen.roughness * 0.82) * (1.6918 * (hv * 2.35));
hv -= glRidge.generateLayer(hv, wxx, wzx);
int height = (int) Math.round(M.clip(hv, 0D, 1D) * 253);
int max = Math.max(height, seaLevel);
IrisBiome override = null;
//@done
if(height > 61 && height < 65 + (glLNoise.getHeight(wz, wx) * Iris.settings.gen.beachScale))
{
@@ -245,6 +258,7 @@ public class IrisGenerator extends ParallelChunkGenerator
glCaves.genCaves(wxx, wzx, x, z, height, this);
glCarving.genCarves(wxx, wzx, x, z, height, this, biome);
glCaverns.genCaverns(wxx, wzx, x, z, height, this, biome);
plan.setRealHeight(x, z, highest);
return biome.getRealBiome();
}

3
src/main/java/ninja/bytecode/iris/generator/genobject/GenObjectDecorator.java
View File

@@ -12,7 +12,6 @@ import org.bukkit.generator.BlockPopulator;
import net.md_5.bungee.api.ChatColor;
import ninja.bytecode.iris.Iris;
import ninja.bytecode.iris.controller.PackController;
import ninja.bytecode.iris.controller.TimingsController;
import ninja.bytecode.iris.generator.IrisGenerator;
import ninja.bytecode.iris.generator.placer.BukkitPlacer;
@@ -27,7 +26,6 @@ import ninja.bytecode.shuriken.math.M;
public class GenObjectDecorator extends BlockPopulator
{
private GMap<String, GenObjectGroup> snowCache;
private GMap<Biome, IrisBiome> biomeMap;
private GMap<Biome, GMap<GenObjectGroup, Double>> populationCache;
private IPlacer placer;
@@ -37,7 +35,6 @@ public class GenObjectDecorator extends BlockPopulator
{
biomeMap = new GMap<>();
populationCache = new GMap<>();
snowCache = new GMap<>();
for(IrisBiome i : generator.getLoadedBiomes())
{

2
src/main/java/ninja/bytecode/iris/generator/genobject/GenObjectGroup.java
View File

@@ -1,7 +1,5 @@
package ninja.bytecode.iris.generator.genobject;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;

73
src/main/java/ninja/bytecode/iris/generator/layer/GenLayerCarving.java
View File

@@ -17,33 +17,22 @@ import ninja.bytecode.shuriken.math.RNG;
public class GenLayerCarving extends GenLayer
{
public CNG carver;
public CNG clipper;
private CNG carver;
private CNG fract;
private CNG ruff;
public GenLayerCarving(IrisGenerator iris, World world, Random random, RNG rng)
{
super(iris, world, random, rng);
//@builder
carver = new CNG(rng.nextParallelRNG(116), 1D, 3)
.scale(0.0285)
carver = new CNG(rng.nextParallelRNG(116), 1D, 7)
.scale(0.0057)
.amp(0.5)
.freq(1.1)
.fractureWith(new CNG(rng.nextParallelRNG(18), 1, 3)
.scale(0.005)
.child(new CNG(rng.nextParallelRNG(19), 0.745, 2)
.scale(0.1))
.fractureWith(new CNG(rng.nextParallelRNG(20), 1, 3)
.scale(0.08), 12), 33);
clipper = new CNG(rng.nextParallelRNG(117), 1D, 1)
.scale(0.0009)
.amp(0.0)
.freq(1.1)
.fractureWith(new CNG(rng.nextParallelRNG(18), 1, 3)
.scale(0.005)
.child(new CNG(rng.nextParallelRNG(19), 0.745, 2)
.scale(0.1))
.fractureWith(new CNG(rng.nextParallelRNG(20), 1, 3)
.scale(0.08), 12), 33);
.freq(1.1);
fract = new CNG(rng.nextParallelRNG(20), 1, 3)
.scale(0.0302);
ruff = new CNG(rng.nextParallelRNG(20), 1, 2)
.scale(0.0702);
//@done
}
@@ -66,6 +55,19 @@ public class GenLayerCarving extends GenLayer
return 0;
}
public double carve(double x, double y, double z)
{
double cx = 77D;
double cz = 11D;
double rx = ruff.noise(x, z, y) * cz;
double ry = ruff.noise(z, y, x) * cz;
double rz = ruff.noise(y, x, z) * cz;
double fx = fract.noise(x + rx, z - ry, y + rz) * cx;
double fy = fract.noise(z - ry, y + rx, x - rz) * cx;
double fz = fract.noise(y + rz, x - rx, z + ry) * cx;
return carver.noise(x + fx, y - fy, z + fz);
}
public void genCarves(double wxx, double wzx, int x, int z, int s, IrisGenerator g, IrisBiome biome)
{
if(s < Iris.settings.gen.minCarvingHeight)
@@ -73,25 +75,30 @@ public class GenLayerCarving extends GenLayer
return;
}
double ch = Iris.settings.gen.carvingChance;
int txy = (int) IrisInterpolation.lerp(Iris.settings.gen.minCarvingHeight, Iris.settings.gen.maxCarvingHeight, 0.5);
if(carve(wxx, txy, wzx) < ch / 2D)
{
return;
}
int hit = 0;
int carved = 0;
for(int i = Math.min(Iris.settings.gen.maxCarvingHeight, s); i > Iris.settings.gen.minCarvingHeight; i--)
{
if(clipper.noise(wzx, i, wxx) < Iris.settings.gen.carvingChance)
double hill = getHill(i);
if(hill < 0.065)
{
double hill = getHill(i);
continue;
}
if(hill < 0.065)
{
continue;
}
if(carver.noise(wxx, i, wzx) < IrisInterpolation.lerpBezier(0.01, 0.425, hill))
{
carved++;
g.setBlock(x, i, z, Material.AIR);
}
if(carve(wxx, i, wzx) < IrisInterpolation.lerpBezier(0, ch, hill))
{
carved++;
g.setBlock(x, i, z, Material.AIR);
}
}

172
src/main/java/ninja/bytecode/iris/generator/layer/GenLayerCaverns.java Normal file
View File

@@ -0,0 +1,172 @@
package ninja.bytecode.iris.generator.layer;
import java.util.Random;
import org.bukkit.Material;
import org.bukkit.World;
import ninja.bytecode.iris.Iris;
import ninja.bytecode.iris.generator.IrisGenerator;
import ninja.bytecode.iris.pack.IrisBiome;
import ninja.bytecode.iris.util.GenLayer;
import ninja.bytecode.iris.util.IrisInterpolation;
import ninja.bytecode.iris.util.MB;
import ninja.bytecode.shuriken.math.CNG;
import ninja.bytecode.shuriken.math.M;
import ninja.bytecode.shuriken.math.RNG;
public class GenLayerCaverns extends GenLayer
{
private CNG carver;
private CNG fract;
private CNG ruff;
public GenLayerCaverns(IrisGenerator iris, World world, Random random, RNG rng)
{
super(iris, world, random, rng);
//@builder
carver = new CNG(rng.nextParallelRNG(116), 1D, 7)
.scale(0.0057)
.amp(0.5)
.freq(1.1);
fract = new CNG(rng.nextParallelRNG(20), 1, 3)
.scale(0.0302);
ruff = new CNG(rng.nextParallelRNG(20), 1, 2)
.scale(0.0702);
//@done
}
public double getHill(double height)
{
double min = Iris.settings.gen.minCavernHeight;
double max = Iris.settings.gen.maxCavernHeight;
double mid = IrisInterpolation.lerp(min, max, 0.5);
if(height >= min && height <= mid)
{
return IrisInterpolation.lerpBezier(0, 1, M.lerpInverse(min, mid, height));
}
else if(height >= mid && height <= max)
{
return IrisInterpolation.lerpBezier(1, 0, M.lerpInverse(mid, max, height));
}
return 0;
}
public double cavern(double x, double y, double z)
{
double cx = 77D;
double cz = 11D;
double rx = ruff.noise(x, z, y) * cz;
double ry = ruff.noise(z, y, x) * cz;
double rz = ruff.noise(y, x, z) * cz;
double fx = fract.noise(x + rx, z - ry, y + rz) * cx;
double fy = fract.noise(z - ry, y + rx, x - rz) * cx;
double fz = fract.noise(y + rz, x - rx, z + ry) * cx;
return carver.noise(x + fx, y - fy, z + fz);
}
public void genCaverns(double wxx, double wzx, int x, int z, int s, IrisGenerator g, IrisBiome biome)
{
if(s < Iris.settings.gen.minCavernHeight)
{
return;
}
double ch = Iris.settings.gen.cavernChance;
int txy = (int) IrisInterpolation.lerp(Iris.settings.gen.minCavernHeight, Iris.settings.gen.maxCavernHeight, 0.5);
if(cavern(wxx, txy, wzx) < ch / 2D)
{
return;
}
int hit = 0;
int carved = 0;
for(int i = Math.min(Iris.settings.gen.maxCavernHeight, s); i > Iris.settings.gen.minCavernHeight; i--)
{
double hill = getHill(i);
if(hill < 0.065)
{
continue;
}
if(cavern(wxx, i, wzx) < IrisInterpolation.lerpBezier(0, ch, hill))
{
carved++;
g.setBlock(x, i, z, Material.AIR);
}
}
if(carved > 4)
{
boolean fail = false;
for(int i = Iris.settings.gen.maxCavernHeight; i > Iris.settings.gen.minCavernHeight; i--)
{
Material m = g.getType(x, i, z);
if(!m.equals(Material.AIR))
{
hit++;
if(hit == 1)
{
fail = false;
if(i > 5)
{
for(int j = i; j > i - 5; j--)
{
if(g.getType(x, j, z).equals(Material.AIR))
{
fail = true;
break;
}
}
}
if(!fail)
{
MB mb = biome.getSurface(wxx, wzx, g.getRTerrain());
g.setBlock(x, i, z, mb.material, mb.data);
}
else
{
g.setBlock(x, i, z, Material.AIR);
}
}
else if(hit > 1 && hit < g.getGlBase().scatterInt(x, i, z, 4) + 3)
{
if(!fail)
{
MB mb = biome.getDirtRNG();
g.setBlock(x, i, z, mb.material, mb.data);
}
else
{
g.setBlock(x, i, z, Material.AIR);
}
}
}
else
{
hit = 0;
}
}
}
}
@Override
public double generateLayer(double gnoise, double dx, double dz)
{
return gnoise;
}
}

6
src/main/java/ninja/bytecode/iris/generator/layer/GenLayerCaves.java
View File

@@ -22,10 +22,10 @@ public class GenLayerCaves extends GenLayer
public GenLayerCaves(IrisGenerator iris, World world, Random random, RNG rng)
{
super(iris, world, random, rng);
caveHeight = new CNG(rng.nextParallelRNG(-100001), 1D, 7).scale(0.00222);
caveGirth = new CNG(rng.nextParallelRNG(-100002), 1D, 12).scale(0.03);
caveHeight = new CNG(rng.nextParallelRNG(-100001), 1D, 3).scale(0.00222);
caveGirth = new CNG(rng.nextParallelRNG(-100002), 1D, 3).scale(0.03);
caveClamp = new CNG(rng.nextParallelRNG(-10000), 1D, 3).scale(0.1422);
caveVeins = new MaxingGenerator(rng.nextParallelRNG(-99999), 22, 0.002 * Iris.settings.gen.caveScale, 1, (g) -> g.fractureWith(new CNG(rng.nextParallelRNG(-5555), 1D, 4).scale(0.02), 70));
caveVeins = new MaxingGenerator(rng.nextParallelRNG(-99999), 4, 0.002 * Iris.settings.gen.caveScale, 1, (g) -> g.fractureWith(new CNG(rng.nextParallelRNG(-5555), 1D, 4).scale(0.02), 70));
}
public void genCaves(double wxx, double wzx, int x, int z, int s, IrisGenerator g)

6
src/main/java/ninja/bytecode/iris/generator/layer/GenLayerFracture.java
View File

@@ -14,17 +14,17 @@ public class GenLayerFracture extends GenLayer
{
private CNG gen;
private CNG cond;
private double shootHeight = 0.563;
private double shootHeight = 0.963;
public GenLayerFracture(IrisGenerator iris, World world, Random random, RNG rng)
{
//@builder
super(iris, world, random, rng);
gen = new CNG(rng.nextParallelRNG(40), 1D, 12)
gen = new CNG(rng.nextParallelRNG(40), 1D, 2)
.scale(0.023)
.fractureWith(new CNG(rng.nextParallelRNG(41), 1D, 1)
.scale(0.05), 333);
cond = new CNG(rng.nextParallelRNG(42), 1D, 12)
cond = new CNG(rng.nextParallelRNG(42), 1D, 2)
.scale(0.038)
.fractureWith(new CNG(rng.nextParallelRNG(43), 1D, 1)
.scale(0.025), 299);