mirror of
https://github.com/VolmitSoftware/Iris.git
synced 2025-07-18 18:23:06 +00:00
Merge pull request #1 from VolmitSoftware/redesign-noise
Redesign noise
This commit is contained in:
Dan
GitHub
commit
59e8ba2297
@ -1,6 +1,5 @@
|
||||
package ninja.bytecode.iris;
|
||||
|
||||
import ninja.bytecode.iris.util.InterpolationType;
|
||||
import ninja.bytecode.iris.util.PerformanceMode;
|
||||
|
||||
public class Settings
|
||||
@ -23,17 +22,14 @@ public class Settings
|
||||
|
||||
public static class GeneratorSettings
|
||||
{
|
||||
public InterpolationType linearFunction = InterpolationType.BEZIER;
|
||||
public InterpolationType bilinearFunction = InterpolationType.PARAMETRIC_2;
|
||||
public InterpolationType trilinearFunction = InterpolationType.BEZIER;
|
||||
public double linearSampleFractureMultiplier = 11.4;
|
||||
public double linearSampleFractureScale = 0.21;
|
||||
public double horizontalZoom = 1; // 0.525
|
||||
public int hermiteSampleRadius = 6;
|
||||
public double horizontalZoom = 1;
|
||||
public double heightFracture = 155;
|
||||
public double beachScale = 76;
|
||||
public double landScale = 0.325;
|
||||
public double landChance = 0.62;
|
||||
public double roughness = 1.25;
|
||||
public double biomeEdgeScramble = 1550D; // 1550D
|
||||
public double roughness = 1.55;
|
||||
public double heightMultiplier = 0.806;
|
||||
public double heightExponentBase = 1;
|
||||
public double heightExponentMultiplier = 1.41;
|
||||
@ -46,6 +42,9 @@ public class Settings
|
||||
public double biomeScale = 2;
|
||||
public boolean flatBedrock = false;
|
||||
public boolean genObjects = true;
|
||||
public boolean genCarving = true;
|
||||
public boolean genCaverns = true;
|
||||
public boolean genCaves = true;
|
||||
public double carvingChance = 0.352;
|
||||
public double cavernChance = 0.321;
|
||||
public int minCarvingHeight = 75;
|
||||
|
||||
@ -267,4 +267,22 @@ public class PackController implements IrisController
|
||||
J.attempt(() -> new File(Iris.instance.getDataFolder(), "dimensions").delete());
|
||||
compiledDimensions.clear();
|
||||
}
|
||||
|
||||
public IrisBiome getBiomeById(String id)
|
||||
{
|
||||
if(!biomes.containsKey(id))
|
||||
{
|
||||
try
|
||||
{
|
||||
biomes.put(id, Iris.getController(PackController.class).loadBiome(id));
|
||||
}
|
||||
|
||||
catch(JSONException | IOException e)
|
||||
{
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
return biomes.get(id);
|
||||
}
|
||||
}
|
||||
|
||||
@ -19,10 +19,10 @@ 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;
|
||||
import ninja.bytecode.iris.generator.layer.GenLayerSnow;
|
||||
import ninja.bytecode.iris.pack.CompiledDimension;
|
||||
import ninja.bytecode.iris.pack.IrisBiome;
|
||||
import ninja.bytecode.iris.pack.IrisRegion;
|
||||
import ninja.bytecode.iris.util.AtomicChunkData;
|
||||
import ninja.bytecode.iris.util.ChunkPlan;
|
||||
import ninja.bytecode.iris.util.IrisInterpolation;
|
||||
@ -54,21 +54,22 @@ public class IrisGenerator extends ParallelChunkGenerator
|
||||
MB.of(Material.SMOOTH_BRICK, 2),
|
||||
MB.of(Material.SMOOTH_BRICK, 3),
|
||||
});
|
||||
public GMap<String, IrisBiome> biomeCache = new GMap<>();
|
||||
//@done
|
||||
|
||||
private double[][][] scatterCache;
|
||||
private CNG scatter;
|
||||
public GMap<String, IrisBiome> biomeCache = new GMap<>();
|
||||
private MB WATER = new MB(Material.STATIONARY_WATER);
|
||||
private MB BEDROCK = new MB(Material.BEDROCK);
|
||||
private GList<IrisBiome> internal;
|
||||
private GenLayerBase glBase;
|
||||
private GenLayerLayeredNoise glLNoise;
|
||||
private GenLayerRidge glRidge;
|
||||
private GenLayerBiome glBiome;
|
||||
private GenLayerCaves glCaves;
|
||||
private GenLayerCarving glCarving;
|
||||
private GenLayerCaverns glCaverns;
|
||||
private GenLayerSnow glSnow;
|
||||
private GenLayerBase glBase;
|
||||
private RNG rTerrain;
|
||||
private CNG lerpf;
|
||||
private CompiledDimension dim;
|
||||
private World world;
|
||||
private GMap<String, GenObjectGroup> schematicCache = new GMap<>();
|
||||
@ -104,6 +105,21 @@ public class IrisGenerator extends ParallelChunkGenerator
|
||||
}
|
||||
}
|
||||
|
||||
public int scatterInt(int x, int y, int z, int bound)
|
||||
{
|
||||
return (int) (scatter(x, y, z) * (double) (bound - 1));
|
||||
}
|
||||
|
||||
public double scatter(int x, int y, int z)
|
||||
{
|
||||
return scatterCache[Math.abs(x) % 16][Math.abs(y) % 16][Math.abs(z) % 16];
|
||||
}
|
||||
|
||||
public boolean scatterChance(int x, int y, int z, double chance)
|
||||
{
|
||||
return scatter(x, y, z) > chance;
|
||||
}
|
||||
|
||||
public GList<IrisBiome> getLoadedBiomes()
|
||||
{
|
||||
return internal;
|
||||
@ -114,15 +130,30 @@ 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));
|
||||
scatterCache = new double[16][][];
|
||||
scatter = new CNG(rTerrain.nextParallelRNG(52), 1, 1).scale(10);
|
||||
|
||||
for(int i = 0; i < 16; i++)
|
||||
{
|
||||
scatterCache[i] = new double[16][];
|
||||
|
||||
for(int j = 0; j < 16; j++)
|
||||
{
|
||||
scatterCache[i][j] = new double[16];
|
||||
|
||||
for(int k = 0; k < 16; k++)
|
||||
{
|
||||
scatterCache[i][j][k] = scatter.noise(i, j, k);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
@ -133,8 +164,8 @@ public class IrisGenerator extends ParallelChunkGenerator
|
||||
|
||||
public IrisBiome getBiome(int wxx, int wzx)
|
||||
{
|
||||
double wx = Math.round((double) wxx * Iris.settings.gen.horizontalZoom);
|
||||
double wz = Math.round((double) wzx * Iris.settings.gen.horizontalZoom);
|
||||
double wx = Math.round((double) wxx * (Iris.settings.gen.horizontalZoom / 1.90476190476));
|
||||
double wz = Math.round((double) wzx * (Iris.settings.gen.horizontalZoom / 1.90476190476));
|
||||
return glBiome.getBiome(wx * Iris.settings.gen.biomeScale, wz * Iris.settings.gen.biomeScale);
|
||||
}
|
||||
|
||||
@ -149,17 +180,13 @@ public class IrisGenerator extends ParallelChunkGenerator
|
||||
//@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);
|
||||
double wx = Math.round((double) wxx * (Iris.settings.gen.horizontalZoom / 1.90476190476));
|
||||
double wz = Math.round((double) wzx * (Iris.settings.gen.horizontalZoom / 1.90476190476));
|
||||
IrisBiome biome = getBiome(wxx, wzx);
|
||||
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);
|
||||
Iris.settings.gen.hermiteSampleRadius,
|
||||
(xf, zf) -> getBiomedHeight((int) Math.round(xf), (int) Math.round(zf), plan));
|
||||
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;
|
||||
@ -167,7 +194,20 @@ public class IrisGenerator extends ParallelChunkGenerator
|
||||
|
||||
if(height > 61 && height < 65 + (glLNoise.getHeight(wz, wx) * Iris.settings.gen.beachScale))
|
||||
{
|
||||
override = biome("Beach");
|
||||
IrisBiome beach = null;
|
||||
IrisRegion region = glBiome.getRegion(biome.getRegion());
|
||||
|
||||
if(region != null)
|
||||
{
|
||||
beach = region.getBeach();
|
||||
}
|
||||
|
||||
if(beach == null)
|
||||
{
|
||||
beach = biome("Beach");
|
||||
}
|
||||
|
||||
override = beach;
|
||||
}
|
||||
|
||||
else if(height < 63)
|
||||
@ -190,7 +230,7 @@ public class IrisGenerator extends ParallelChunkGenerator
|
||||
|
||||
for(int i = 0; i < max; i++)
|
||||
{
|
||||
MB mb = ROCK.get(glBase.scatterInt(wzx, i, wxx, ROCK.size()));
|
||||
MB mb = ROCK.get(scatterInt(wzx, i, wxx, ROCK.size()));
|
||||
boolean underwater = i >= height && i < seaLevel;
|
||||
boolean underground = i < height;
|
||||
|
||||
@ -199,7 +239,7 @@ public class IrisGenerator extends ParallelChunkGenerator
|
||||
mb = WATER;
|
||||
}
|
||||
|
||||
if(underground && (height - 1) - i < glBase.scatterInt(x, i, z, 4) + 2)
|
||||
if(underground && (height - 1) - i < scatterInt(x, i, z, 4) + 2)
|
||||
{
|
||||
mb = biome.getDirtRNG();
|
||||
}
|
||||
@ -247,7 +287,7 @@ public class IrisGenerator extends ParallelChunkGenerator
|
||||
mb = BEDROCK;
|
||||
}
|
||||
|
||||
if(!Iris.settings.gen.flatBedrock ? i <= 2 : i < glBase.scatterInt(x, i, z, 3))
|
||||
if(!Iris.settings.gen.flatBedrock ? i <= 2 : i < scatterInt(x, i, z, 3))
|
||||
{
|
||||
mb = BEDROCK;
|
||||
}
|
||||
@ -294,12 +334,11 @@ public class IrisGenerator extends ParallelChunkGenerator
|
||||
|
||||
if(xh == -1)
|
||||
{
|
||||
int wx = (int) Math.round((double) x * Iris.settings.gen.horizontalZoom);
|
||||
int wz = (int) Math.round((double) z * Iris.settings.gen.horizontalZoom);
|
||||
int wx = (int) Math.round((double) x * (Iris.settings.gen.horizontalZoom / 1.90476190476));
|
||||
int wz = (int) Math.round((double) z * (Iris.settings.gen.horizontalZoom / 1.90476190476));
|
||||
IrisBiome biome = glBiome.getBiome(wx * Iris.settings.gen.biomeScale, wz * Iris.settings.gen.biomeScale);
|
||||
double h = Iris.settings.gen.baseHeight + biome.getHeight();
|
||||
h += (glBase.getHeight(wx, wz) * 0.5) - (0.33 * 0.5);
|
||||
|
||||
plan.setHeight(x, z, h);
|
||||
return h;
|
||||
}
|
||||
@ -327,11 +366,6 @@ public class IrisGenerator extends ParallelChunkGenerator
|
||||
return rTerrain;
|
||||
}
|
||||
|
||||
public GenLayerBase getGlBase()
|
||||
{
|
||||
return glBase;
|
||||
}
|
||||
|
||||
public CompiledDimension getDimension()
|
||||
{
|
||||
return dim;
|
||||
|
||||
@ -13,7 +13,6 @@ import ninja.bytecode.shuriken.math.RNG;
|
||||
|
||||
public class GenLayerBase extends GenLayer
|
||||
{
|
||||
private double[][][] scatterCache;
|
||||
private CNG gen;
|
||||
private CNG fracture;
|
||||
private CNG hfracture;
|
||||
@ -24,9 +23,6 @@ public class GenLayerBase extends GenLayer
|
||||
{
|
||||
//@builder
|
||||
super(iris, world, random, rng);
|
||||
scatterCache = new double[16][][];
|
||||
CNG scatter = new CNG(rng.nextParallelRNG(5), 1, 1)
|
||||
.scale(10);
|
||||
hfracture = new CNG(rng.nextParallelRNG(6), 1, 2)
|
||||
.scale(0.0124);
|
||||
gen = new CNG(rng.nextParallelRNG(7), 0.19D, 7)
|
||||
@ -46,27 +42,12 @@ public class GenLayerBase extends GenLayer
|
||||
.scale(0.0034), 31)
|
||||
.scale(0.066), 58);
|
||||
superheight = new CNG(rng.nextParallelRNG(13), 1, 6)
|
||||
.scale(0.0025 * Iris.settings.gen.superHeightScale)
|
||||
.scale(0.025 * Iris.settings.gen.superHeightScale)
|
||||
.fractureWith(new CNG(rng.nextParallelRNG(14), 1, 1)
|
||||
.scale(0.021), 250);
|
||||
.scale(0.13), 250);
|
||||
fracture = new CNG(rng.nextParallelRNG(15), 0.6D, 4)
|
||||
.scale(0.118);
|
||||
//@done
|
||||
|
||||
for(int i = 0; i < 16; i++)
|
||||
{
|
||||
scatterCache[i] = new double[16][];
|
||||
|
||||
for(int j = 0; j < 16; j++)
|
||||
{
|
||||
scatterCache[i][j] = new double[16];
|
||||
|
||||
for(int k = 0; k < 16; k++)
|
||||
{
|
||||
scatterCache[i][j][k] = scatter.noise(i, j, k);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public double getHeight(double x, double z)
|
||||
@ -74,21 +55,6 @@ public class GenLayerBase extends GenLayer
|
||||
return M.clip(Math.pow(height.noise(x + (hfracture.noise(x, z) * Iris.settings.gen.heightFracture), z + (hfracture.noise(z, x) * Iris.settings.gen.heightFracture)), Iris.settings.gen.heightExponentBase + (superheight.noise(x, z) * Iris.settings.gen.heightExponentMultiplier)) * Iris.settings.gen.heightMultiplier, 0D, 1D);
|
||||
}
|
||||
|
||||
public int scatterInt(int x, int y, int z, int bound)
|
||||
{
|
||||
return (int) (scatter(x, y, z) * (double) (bound - 1));
|
||||
}
|
||||
|
||||
public double scatter(int x, int y, int z)
|
||||
{
|
||||
return scatterCache[Math.abs(x) % 16][Math.abs(y) % 16][Math.abs(z) % 16];
|
||||
}
|
||||
|
||||
public boolean scatterChance(int x, int y, int z, double chance)
|
||||
{
|
||||
return scatter(x, y, z) > chance;
|
||||
}
|
||||
|
||||
@Override
|
||||
public double generateLayer(double gnoise, double dx, double dz)
|
||||
{
|
||||
|
||||
@ -3,7 +3,6 @@ package ninja.bytecode.iris.generator.layer;
|
||||
import java.util.Random;
|
||||
import java.util.function.Function;
|
||||
|
||||
import org.bukkit.Material;
|
||||
import org.bukkit.World;
|
||||
|
||||
import ninja.bytecode.iris.Iris;
|
||||
@ -11,7 +10,6 @@ import ninja.bytecode.iris.generator.IrisGenerator;
|
||||
import ninja.bytecode.iris.pack.IrisBiome;
|
||||
import ninja.bytecode.iris.pack.IrisRegion;
|
||||
import ninja.bytecode.iris.util.GenLayer;
|
||||
import ninja.bytecode.iris.util.MaxingGenerator;
|
||||
import ninja.bytecode.iris.util.MaxingGenerator.EnumMaxingGenerator;
|
||||
import ninja.bytecode.shuriken.collections.GList;
|
||||
import ninja.bytecode.shuriken.collections.GMap;
|
||||
@ -22,27 +20,26 @@ import ninja.bytecode.shuriken.math.RNG;
|
||||
public class GenLayerBiome extends GenLayer
|
||||
{
|
||||
private EnumMaxingGenerator<IrisRegion> regionGenerator;
|
||||
private MaxingGenerator roads;
|
||||
private GMap<String, IrisRegion> regions;
|
||||
private Function<CNG, CNG> factory;
|
||||
private CNG pathCheck;
|
||||
private CNG fracture;
|
||||
private CNG island;
|
||||
|
||||
public GenLayerBiome(IrisGenerator iris, World world, Random random, RNG rng, GList<IrisBiome> biomes)
|
||||
{
|
||||
//@builder
|
||||
super(iris, world, random, rng);
|
||||
island = new CNG(rng.nextParallelRNG(10334), 1D, 3).scale(0.003 * Iris.settings.gen.landScale).fractureWith(new CNG(rng.nextParallelRNG(34), 1D, 12).scale(0.6), 180);
|
||||
fracture = new CNG(rng.nextParallelRNG(28), 1D, 24).scale(0.0021).fractureWith(new CNG(rng.nextParallelRNG(34), 1D, 12).scale(0.01), 12250);
|
||||
factory = (g) -> g.fractureWith(new CNG(rng.nextParallelRNG(29), 1D, 4).scale(0.02), 56);
|
||||
pathCheck = new CNG(rng.nextParallelRNG(31), 1D, 1).scale(0.00096);
|
||||
roads = new MaxingGenerator(rng.nextParallelRNG(32), 5, 0.00055, 8, factory);
|
||||
//@done
|
||||
|
||||
GMap<String, IrisRegion> regions = new GMap<>();
|
||||
regions = new GMap<>();
|
||||
|
||||
for(IrisBiome i : biomes)
|
||||
{
|
||||
if(i.getName().equals("Beach"))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
if(!regions.containsKey(i.getRegion()))
|
||||
{
|
||||
regions.put(i.getRegion(), new IrisRegion(i.getRegion()));
|
||||
@ -51,6 +48,11 @@ public class GenLayerBiome extends GenLayer
|
||||
regions.get(i.getRegion()).getBiomes().add(i);
|
||||
}
|
||||
|
||||
for(IrisRegion i : regions.values())
|
||||
{
|
||||
i.load();
|
||||
}
|
||||
|
||||
int v = 85034;
|
||||
regionGenerator = new EnumMaxingGenerator<IrisRegion>(rng.nextParallelRNG(v), 0.00522 * Iris.settings.gen.biomeScale * 0.189, 1, regions.v().toArray(new IrisRegion[regions.v().size()]), factory);
|
||||
|
||||
@ -68,35 +70,15 @@ public class GenLayerBiome extends GenLayer
|
||||
|
||||
public IrisBiome getBiome(double xx, double zz)
|
||||
{
|
||||
double x = xx + (fracture.noise(zz, xx) * 1550D);
|
||||
double z = zz - (fracture.noise(xx, zz) * 1550D);
|
||||
double x = xx + (Iris.settings.gen.biomeEdgeScramble == 0 ? 0 : (fracture.noise(zz, xx) * Iris.settings.gen.biomeEdgeScramble));
|
||||
double z = zz - (Iris.settings.gen.biomeEdgeScramble == 0 ? 0 : (fracture.noise(xx, zz) * Iris.settings.gen.biomeEdgeScramble));
|
||||
IrisBiome cbi = iris.biome("Ocean");
|
||||
double land = island.noise(x, z);
|
||||
double landChance = 1D - M.clip(Iris.settings.gen.landChance, 0D, 1D);
|
||||
|
||||
if(land > landChance && land < landChance + 0.0175)
|
||||
{
|
||||
cbi = iris.biome("Beach");
|
||||
}
|
||||
|
||||
else if(land > landChance + 0.0175)
|
||||
if(land > landChance + 0.0175)
|
||||
{
|
||||
cbi = getRegionGenerator(x, z).getChoice(x, z);
|
||||
|
||||
if(pathCheck.noise(x, z) > 0.33)
|
||||
{
|
||||
IrisBiome road = iris.biome("Beach");
|
||||
|
||||
if(cbi.getSurface().get(0).material.equals(Material.GRASS))
|
||||
{
|
||||
road = IrisBiome.ROAD_GRASSY;
|
||||
}
|
||||
|
||||
if(Math.abs(road.getHeight() - cbi.getHeight()) < 0.0001 && roads.hasBorder(4, 3, xx, zz))
|
||||
{
|
||||
return road;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
else if(land < 0.3)
|
||||
@ -112,4 +94,9 @@ public class GenLayerBiome extends GenLayer
|
||||
{
|
||||
return noise;
|
||||
}
|
||||
|
||||
public IrisRegion getRegion(String name)
|
||||
{
|
||||
return regions.get(name);
|
||||
}
|
||||
}
|
||||
|
||||
@ -70,6 +70,11 @@ public class GenLayerCarving extends GenLayer
|
||||
|
||||
public void genCarves(double wxx, double wzx, int x, int z, int s, IrisGenerator g, IrisBiome biome)
|
||||
{
|
||||
if(!Iris.settings.gen.genCarving)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if(s < Iris.settings.gen.minCarvingHeight)
|
||||
{
|
||||
return;
|
||||
@ -141,7 +146,7 @@ public class GenLayerCarving extends GenLayer
|
||||
}
|
||||
}
|
||||
|
||||
else if(hit > 1 && hit < g.getGlBase().scatterInt(x, i, z, 4) + 3)
|
||||
else if(hit > 1 && hit < g.scatterInt(x, i, z, 4) + 3)
|
||||
{
|
||||
if(!fail)
|
||||
{
|
||||
|
||||
@ -70,6 +70,11 @@ public class GenLayerCaverns extends GenLayer
|
||||
|
||||
public void genCaverns(double wxx, double wzx, int x, int z, int s, IrisGenerator g, IrisBiome biome)
|
||||
{
|
||||
if(!Iris.settings.gen.genCaverns)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if(s < Iris.settings.gen.minCavernHeight)
|
||||
{
|
||||
return;
|
||||
@ -141,7 +146,7 @@ public class GenLayerCaverns extends GenLayer
|
||||
}
|
||||
}
|
||||
|
||||
else if(hit > 1 && hit < g.getGlBase().scatterInt(x, i, z, 4) + 3)
|
||||
else if(hit > 1 && hit < g.scatterInt(x, i, z, 4) + 3)
|
||||
{
|
||||
if(!fail)
|
||||
{
|
||||
|
||||
@ -30,6 +30,11 @@ public class GenLayerCaves extends GenLayer
|
||||
|
||||
public void genCaves(double wxx, double wzx, int x, int z, int s, IrisGenerator g)
|
||||
{
|
||||
if(!Iris.settings.gen.genCaves)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
for(double itr = 0; itr < 0.1 * Iris.settings.gen.caveDensity; itr += 0.1)
|
||||
{
|
||||
double thickness = 0.25 + itr + (0.5 * caveClamp.noise(wxx, wzx));
|
||||
|
||||
@ -1,49 +0,0 @@
|
||||
package ninja.bytecode.iris.generator.layer;
|
||||
|
||||
import java.util.Random;
|
||||
|
||||
import org.bukkit.World;
|
||||
|
||||
import ninja.bytecode.iris.generator.IrisGenerator;
|
||||
import ninja.bytecode.iris.util.GenLayer;
|
||||
import ninja.bytecode.shuriken.math.CNG;
|
||||
import ninja.bytecode.shuriken.math.M;
|
||||
import ninja.bytecode.shuriken.math.RNG;
|
||||
|
||||
public class GenLayerFracture extends GenLayer
|
||||
{
|
||||
private CNG gen;
|
||||
private CNG cond;
|
||||
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, 2)
|
||||
.scale(0.023)
|
||||
.fractureWith(new CNG(rng.nextParallelRNG(41), 1D, 1)
|
||||
.scale(0.05), 333);
|
||||
cond = new CNG(rng.nextParallelRNG(42), 1D, 2)
|
||||
.scale(0.038)
|
||||
.fractureWith(new CNG(rng.nextParallelRNG(43), 1D, 1)
|
||||
.scale(0.025), 299);
|
||||
//@done
|
||||
}
|
||||
|
||||
@Override
|
||||
public double generateLayer(double noise, double dx, double dz)
|
||||
{
|
||||
double shootHeight = this.shootHeight + (cond.noise(dx, dz) * 0.035);
|
||||
|
||||
if(noise >= shootHeight)
|
||||
{
|
||||
double multiplier = M.rangeScale(0, 0.055, this.shootHeight, 1D, cond.noise(-dx, -dz));
|
||||
double on = gen.noise(dx, dz) * multiplier;
|
||||
|
||||
return noise + on;
|
||||
}
|
||||
|
||||
return noise;
|
||||
}
|
||||
}
|
||||
@ -1,56 +0,0 @@
|
||||
package ninja.bytecode.iris.generator.layer;
|
||||
|
||||
import java.util.Random;
|
||||
|
||||
import org.bukkit.World;
|
||||
|
||||
import ninja.bytecode.iris.generator.IrisGenerator;
|
||||
import ninja.bytecode.iris.util.GenLayer;
|
||||
import ninja.bytecode.shuriken.math.CNG;
|
||||
import ninja.bytecode.shuriken.math.RNG;
|
||||
|
||||
public class GenLayerRidge extends GenLayer
|
||||
{
|
||||
private CNG gen;
|
||||
private CNG fract;
|
||||
private CNG g;
|
||||
private CNG q;
|
||||
|
||||
public GenLayerRidge(IrisGenerator iris, World world, Random random, RNG rng)
|
||||
{
|
||||
//@builder
|
||||
super(iris, world, random, rng);
|
||||
q = new CNG(rng.nextParallelRNG(21), 1D, 2).scale(0.0211);
|
||||
g = new CNG(rng.nextParallelRNG(22), 1D, 2).scale(0.0011);
|
||||
fract = new CNG(rng.nextParallelRNG(23), 1D, 5).scale(0.0011);
|
||||
gen = new CNG(rng.nextParallelRNG(24), 0.19D, 16)
|
||||
.scale(0.012)
|
||||
.injectWith(CNG.MAX)
|
||||
.amp(0.5)
|
||||
.freq(1.1)
|
||||
.fractureWith(new CNG(rng.nextParallelRNG(25), 1, 6)
|
||||
.scale(0.018)
|
||||
.child(new CNG(rng.nextParallelRNG(26), 0.745, 2)
|
||||
.scale(0.1))
|
||||
.fractureWith(new CNG(rng.nextParallelRNG(27), 1, 3)
|
||||
.scale(0.15), 24), 44);
|
||||
}
|
||||
|
||||
public double getHeight(double x, double z)
|
||||
{
|
||||
return gen.noise(x, z);
|
||||
}
|
||||
|
||||
@Override
|
||||
public double generateLayer(double gnoise, double dx, double dz)
|
||||
{
|
||||
double d = gen.noise(gnoise, dx + (fract.noise(gnoise, dx, dz) * 1555), dz - (fract.noise(dz, dx, gnoise) * 1555));
|
||||
|
||||
if(d > g.noise(dx, dz) / 8D)
|
||||
{
|
||||
return q.noise(dx, dz, d) * (d / (7D * (g.noise(dz, dx, gnoise) + 0.1))) * (Math.PI / 2.78);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
@ -21,25 +21,10 @@ import ninja.bytecode.shuriken.math.RNG;
|
||||
public class IrisBiome
|
||||
{
|
||||
public static final double MAX_HEIGHT = 0.77768;
|
||||
public static final double IDEAL_HEIGHT = 0.1127;
|
||||
public static final double IDEAL_HEIGHT = 0.0527;
|
||||
public static final double MIN_HEIGHT = -0.0218;
|
||||
|
||||
//@builder
|
||||
private static final IrisBiome RIVER = new IrisBiome("River", Biome.RIVER)
|
||||
.surface(MB.of(Material.SAND))
|
||||
.coreBiome();
|
||||
private static final IrisBiome BEACH = new IrisBiome("Beach", Biome.BEACHES)
|
||||
.height(-0.078)
|
||||
.coreBiome()
|
||||
.surface(MB.of(Material.SAND));
|
||||
public static final IrisBiome ROAD_GRAVEL = new IrisBiome("Gravel Road", Biome.PLAINS)
|
||||
.surface(MB.of(Material.GRAVEL), MB.of(Material.COBBLESTONE))
|
||||
.coreBiome()
|
||||
.scatter(MB.of(Material.TORCH), 0.05);
|
||||
public static final IrisBiome ROAD_GRASSY = new IrisBiome("Grass Path", Biome.PLAINS)
|
||||
.surface(MB.of(Material.GRASS_PATH))
|
||||
.coreBiome()
|
||||
.scatter(MB.of(Material.TORCH), 0.05);
|
||||
private static final IrisBiome OCEAN = new IrisBiome("Ocean", Biome.OCEAN)
|
||||
.height(-0.5)
|
||||
.coreBiome()
|
||||
@ -83,26 +68,6 @@ public class IrisBiome
|
||||
return MIN_HEIGHT;
|
||||
}
|
||||
|
||||
public static IrisBiome getRiver()
|
||||
{
|
||||
return RIVER;
|
||||
}
|
||||
|
||||
public static IrisBiome getBeach()
|
||||
{
|
||||
return BEACH;
|
||||
}
|
||||
|
||||
public static IrisBiome getRoadGravel()
|
||||
{
|
||||
return ROAD_GRAVEL;
|
||||
}
|
||||
|
||||
public static IrisBiome getRoadGrassy()
|
||||
{
|
||||
return ROAD_GRASSY;
|
||||
}
|
||||
|
||||
public static IrisBiome getOcean()
|
||||
{
|
||||
return OCEAN;
|
||||
@ -146,7 +111,7 @@ public class IrisBiome
|
||||
|
||||
public IrisBiome(String name, Biome realBiome)
|
||||
{
|
||||
this.region = "Default";
|
||||
this.region = "default";
|
||||
this.core = false;
|
||||
this.name = name;
|
||||
this.realBiome = realBiome;
|
||||
@ -454,7 +419,7 @@ public class IrisBiome
|
||||
|
||||
public static GList<IrisBiome> getBiomes()
|
||||
{
|
||||
return map.v().remove(IrisBiome.BEACH, IrisBiome.OCEAN, IrisBiome.DEEP_OCEAN, IrisBiome.ROAD_GRASSY, IrisBiome.ROAD_GRAVEL, IrisBiome.BEACH, IrisBiome.RIVER);
|
||||
return map.v().remove(IrisBiome.OCEAN, IrisBiome.DEEP_OCEAN);
|
||||
}
|
||||
|
||||
public static GList<IrisBiome> getAllBiomes()
|
||||
|
||||
@ -1,18 +1,37 @@
|
||||
package ninja.bytecode.iris.pack;
|
||||
|
||||
import ninja.bytecode.iris.Iris;
|
||||
import ninja.bytecode.iris.controller.PackController;
|
||||
import ninja.bytecode.iris.util.MaxingGenerator.EnumMaxingGenerator;
|
||||
import ninja.bytecode.shuriken.collections.GList;
|
||||
import ninja.bytecode.shuriken.execution.J;
|
||||
import ninja.bytecode.shuriken.json.JSONObject;
|
||||
|
||||
public class IrisRegion
|
||||
{
|
||||
private String name;
|
||||
private GList<IrisBiome> biomes;
|
||||
private EnumMaxingGenerator<IrisBiome> gen;
|
||||
private double rarity;
|
||||
private IrisBiome beach;
|
||||
|
||||
public IrisRegion(String name)
|
||||
{
|
||||
this.name = name;
|
||||
this.biomes = new GList<>();
|
||||
rarity = 1;
|
||||
beach = null;
|
||||
}
|
||||
|
||||
public void load()
|
||||
{
|
||||
J.attempt(() ->
|
||||
{
|
||||
JSONObject o = Iris.getController(PackController.class).loadJSON("pack/regions/" + name + ".json");
|
||||
J.attempt(() -> name = o.getString("name"));
|
||||
J.attempt(() -> rarity = o.getDouble("rarity"));
|
||||
J.attempt(() -> beach = Iris.getController(PackController.class).getBiomeById(o.getString("beach")));
|
||||
});
|
||||
}
|
||||
|
||||
public EnumMaxingGenerator<IrisBiome> getGen()
|
||||
@ -45,13 +64,38 @@ public class IrisRegion
|
||||
this.biomes = biomes;
|
||||
}
|
||||
|
||||
public double getRarity()
|
||||
{
|
||||
return rarity;
|
||||
}
|
||||
|
||||
public void setRarity(double rarity)
|
||||
{
|
||||
this.rarity = rarity;
|
||||
}
|
||||
|
||||
public IrisBiome getBeach()
|
||||
{
|
||||
return beach;
|
||||
}
|
||||
|
||||
public void setBeach(IrisBiome beach)
|
||||
{
|
||||
this.beach = beach;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode()
|
||||
{
|
||||
final int prime = 31;
|
||||
int result = 1;
|
||||
result = prime * result + ((beach == null) ? 0 : beach.hashCode());
|
||||
result = prime * result + ((biomes == null) ? 0 : biomes.hashCode());
|
||||
result = prime * result + ((gen == null) ? 0 : gen.hashCode());
|
||||
result = prime * result + ((name == null) ? 0 : name.hashCode());
|
||||
long temp;
|
||||
temp = Double.doubleToLongBits(rarity);
|
||||
result = prime * result + (int) (temp ^ (temp >>> 32));
|
||||
return result;
|
||||
}
|
||||
|
||||
@ -65,6 +109,13 @@ public class IrisRegion
|
||||
if(getClass() != obj.getClass())
|
||||
return false;
|
||||
IrisRegion other = (IrisRegion) obj;
|
||||
if(beach == null)
|
||||
{
|
||||
if(other.beach != null)
|
||||
return false;
|
||||
}
|
||||
else if(!beach.equals(other.beach))
|
||||
return false;
|
||||
if(biomes == null)
|
||||
{
|
||||
if(other.biomes != null)
|
||||
@ -72,6 +123,13 @@ public class IrisRegion
|
||||
}
|
||||
else if(!biomes.equals(other.biomes))
|
||||
return false;
|
||||
if(gen == null)
|
||||
{
|
||||
if(other.gen != null)
|
||||
return false;
|
||||
}
|
||||
else if(!gen.equals(other.gen))
|
||||
return false;
|
||||
if(name == null)
|
||||
{
|
||||
if(other.name != null)
|
||||
@ -79,6 +137,8 @@ public class IrisRegion
|
||||
}
|
||||
else if(!name.equals(other.name))
|
||||
return false;
|
||||
if(Double.doubleToLongBits(rarity) != Double.doubleToLongBits(other.rarity))
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
@ -5,7 +5,6 @@ public enum InterpolationType
|
||||
LINEAR,
|
||||
PARAMETRIC_2,
|
||||
PARAMETRIC_4,
|
||||
PARAMETRIC_NH,
|
||||
BEZIER,
|
||||
NONE;
|
||||
}
|
||||
|
||||
@ -58,11 +58,6 @@ public class IrisInterpolation
|
||||
return blerpParametric(a, b, c, d, tx, ty, 4);
|
||||
}
|
||||
|
||||
if(type.equals(InterpolationType.PARAMETRIC_NH))
|
||||
{
|
||||
return blerpParametric(a, b, c, d, tx, ty, -0.5);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -76,83 +71,87 @@ public class IrisInterpolation
|
||||
return lerpParametric(lerpParametric(a, b, tx, v), lerpParametric(c, d, tx, v), ty, v);
|
||||
}
|
||||
|
||||
public static double getLinearNoise(int x, int z, NoiseProvider n, NoiseProvider f, InterpolationType type)
|
||||
public static double hermite(double p0, double p1, double p2, double p3, double mu, double tension, double bias)
|
||||
{
|
||||
int h = 29;
|
||||
int xa = x - h;
|
||||
int za = z - h;
|
||||
int xb = x + h;
|
||||
int zb = z + h;
|
||||
double hfx = f.noise(x, z) * Iris.settings.gen.linearSampleFractureMultiplier;
|
||||
double hfz = f.noise(z, x) * Iris.settings.gen.linearSampleFractureMultiplier;
|
||||
double na = n.noise(xa + hfx, za + hfz);
|
||||
double nb = n.noise(xa + hfx, zb - hfz);
|
||||
double nc = n.noise(xb - hfx, za + hfz);
|
||||
double nd = n.noise(xb - hfx, zb - hfz);
|
||||
double px = M.rangeScale(0, 1, xa, xb, x);
|
||||
double pz = M.rangeScale(0, 1, za, zb, z);
|
||||
double m0, m1, mu2, mu3;
|
||||
double a0, a1, a2, a3;
|
||||
|
||||
return blerp(na, nc, nb, nd, px, pz, type);
|
||||
mu2 = mu * mu;
|
||||
mu3 = mu2 * mu;
|
||||
m0 = (p1 - p0) * (1 + bias) * (1 - tension) / 2;
|
||||
m0 += (p2 - p1) * (1 - bias) * (1 - tension) / 2;
|
||||
m1 = (p2 - p1) * (1 + bias) * (1 - tension) / 2;
|
||||
m1 += (p3 - p2) * (1 - bias) * (1 - tension) / 2;
|
||||
a0 = 2 * mu3 - 3 * mu2 + 1;
|
||||
a1 = mu3 - 2 * mu2 + mu;
|
||||
a2 = mu3 - mu2;
|
||||
a3 = -2 * mu3 + 3 * mu2;
|
||||
|
||||
return (a0 * p1 + a1 * m0 + a2 * m1 + a3 * p2);
|
||||
}
|
||||
|
||||
public static double getBilinearNoise(int x, int z, NoiseProvider n, NoiseProvider f, InterpolationType linear, InterpolationType bilinear)
|
||||
public static double bihermite(double p00, double p01, double p02, double p03, double p10, double p11, double p12, double p13, double p20, double p21, double p22, double p23, double p30, double p31, double p32, double p33, double mux, double muy, double tension, double bias)
|
||||
{
|
||||
int h = 1;
|
||||
return hermite(hermite(p00, p01, p02, p03, muy, tension, bias), hermite(p10, p11, p12, p13, muy, tension, bias), hermite(p20, p21, p22, p23, muy, tension, bias), hermite(p30, p31, p32, p33, muy, tension, bias), mux, tension, bias);
|
||||
}
|
||||
|
||||
public static double cubic(double p0, double p1, double p2, double p3, double mu)
|
||||
{
|
||||
double a0, a1, a2, a3, mu2;
|
||||
|
||||
mu2 = mu * mu;
|
||||
a0 = p3 - p2 - p0 + p1;
|
||||
a1 = p0 - p1 - a0;
|
||||
a2 = p2 - p0;
|
||||
a3 = p1;
|
||||
|
||||
return a0 * mu * mu2 + a1 * mu2 + a2 * mu + a3;
|
||||
}
|
||||
|
||||
public static double bicubic(double p00, double p01, double p02, double p03, double p10, double p11, double p12, double p13, double p20, double p21, double p22, double p23, double p30, double p31, double p32, double p33, double mux, double muy)
|
||||
{
|
||||
return cubic(cubic(p00, p01, p02, p03, muy), cubic(p10, p11, p12, p13, muy), cubic(p20, p21, p22, p23, muy), cubic(p30, p31, p32, p33, muy), mux);
|
||||
}
|
||||
|
||||
public static double getHermiteNoise(int x, int z, int rad, NoiseProvider n)
|
||||
{
|
||||
int h = rad;
|
||||
int fx = x >> h;
|
||||
int fz = z >> h;
|
||||
int xa = (fx << h) - 15;
|
||||
int za = (fz << h) - 15;
|
||||
int xb = ((fx + 1) << h) + 15;
|
||||
int zb = ((fz + 1) << h) + 15;
|
||||
double na = getLinearNoise(xa, za, n, f, linear);
|
||||
double nb = getLinearNoise(xa, zb, n, f, linear);
|
||||
double nc = getLinearNoise(xb, za, n, f, linear);
|
||||
double nd = getLinearNoise(xb, zb, n, f, linear);
|
||||
double px = M.rangeScale(0, 1, xa, xb, x);
|
||||
double pz = M.rangeScale(0, 1, za, zb, z);
|
||||
|
||||
return blerp(na, nc, nb, nd, px, pz, bilinear);
|
||||
int x0 = ((fx - 1) << h);
|
||||
int z0 = ((fz - 1) << h);
|
||||
int x1 = (fx << h);
|
||||
int z1 = (fz << h);
|
||||
int x2 = ((fx + 1) << h);
|
||||
int z2 = ((fz + 1) << h);
|
||||
int x3 = ((fx + 2) << h);
|
||||
int z3 = ((fz + 2) << h);
|
||||
double px = M.rangeScale(0, 1, x1, x2, x);
|
||||
double pz = M.rangeScale(0, 1, z1, z2, z);
|
||||
//@builder
|
||||
return bihermite(
|
||||
n.noise(x0, z0),
|
||||
n.noise(x0, z1),
|
||||
n.noise(x0, z2),
|
||||
n.noise(x0, z3),
|
||||
n.noise(x1, z0),
|
||||
n.noise(x1, z1),
|
||||
n.noise(x1, z2),
|
||||
n.noise(x1, z3),
|
||||
n.noise(x2, z0),
|
||||
n.noise(x2, z1),
|
||||
n.noise(x2, z2),
|
||||
n.noise(x2, z3),
|
||||
n.noise(x3, z0),
|
||||
n.noise(x3, z1),
|
||||
n.noise(x3, z2),
|
||||
n.noise(x3, z3),
|
||||
px, pz, 0.01, 0);
|
||||
//@done
|
||||
}
|
||||
|
||||
public static double getTrilinearNoise(int x, int z, NoiseProvider n, NoiseProvider f, InterpolationType linear, InterpolationType bilinear, InterpolationType trilinear)
|
||||
public static double getNoise(int x, int z, int lrad, NoiseProvider n)
|
||||
{
|
||||
int h = 6;
|
||||
int fx = x >> h;
|
||||
int fz = z >> h;
|
||||
int xa = (fx << h);
|
||||
int za = (fz << h);
|
||||
int xb = ((fx + 1) << h);
|
||||
int zb = ((fz + 1) << h);
|
||||
double na = getBilinearNoise(xa, za, n, f, linear, bilinear);
|
||||
double nb = getBilinearNoise(xa, zb, n, f, linear, bilinear);
|
||||
double nc = getBilinearNoise(xb, za, n, f, linear, bilinear);
|
||||
double nd = getBilinearNoise(xb, zb, n, f, linear, bilinear);
|
||||
double px = M.rangeScale(0, 1, xa, xb, x);
|
||||
double pz = M.rangeScale(0, 1, za, zb, z);
|
||||
|
||||
return blerp(na, nc, nb, nd, px, pz, trilinear);
|
||||
}
|
||||
|
||||
public static double getNoise(int x, int z, NoiseProvider n, NoiseProvider fli, InterpolationType linear, InterpolationType bilinear, InterpolationType trilinear)
|
||||
{
|
||||
if(linear.equals(InterpolationType.NONE))
|
||||
{
|
||||
return n.noise(x, z);
|
||||
}
|
||||
|
||||
else if(bilinear.equals(InterpolationType.NONE))
|
||||
{
|
||||
return getLinearNoise(x, z, n, fli, linear);
|
||||
}
|
||||
|
||||
else if(trilinear.equals(InterpolationType.NONE))
|
||||
{
|
||||
return getBilinearNoise(x, z, n, fli, linear, bilinear);
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
return getTrilinearNoise(x, z, n, fli, linear, bilinear, trilinear);
|
||||
}
|
||||
return getHermiteNoise(x, z, lrad, n);
|
||||
}
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user