Merge pull request #1 from VolmitSoftware/redesign-noise

Redesign noise

src/main/java/ninja/bytecode/iris/Settings.java

@@ -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 int hermiteSampleRadius = 6;
-		public InterpolationType bilinearFunction = InterpolationType.PARAMETRIC_2;
+		public double horizontalZoom = 1;
-		public InterpolationType trilinearFunction = InterpolationType.BEZIER;
-		public double linearSampleFractureMultiplier = 11.4;
-		public double linearSampleFractureScale = 0.21;
-		public double horizontalZoom = 1; // 0.525
 		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;

src/main/java/ninja/bytecode/iris/controller/PackController.java

@@ -161,7 +161,7 @@ public class PackController implements IrisController
 
 		ready = true;
 	}
-	
+
 	public CompiledDimension getDimension(String name)
 	{
 		return compiledDimensions.get(name);
@@ -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);
+	}
 }

src/main/java/ninja/bytecode/iris/generator/IrisGenerator.java

@@ -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 wx = Math.round((double) wxx * (Iris.settings.gen.horizontalZoom / 1.90476190476));
-		double wz = Math.round((double) wzx * Iris.settings.gen.horizontalZoom);
+		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 wx = Math.round((double) wxx * (Iris.settings.gen.horizontalZoom / 1.90476190476));
-		double wz = Math.round((double) wzx * Iris.settings.gen.horizontalZoom);
+		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), 
+				Iris.settings.gen.hermiteSampleRadius,
-				(a, b) -> lerpf.noise(a, b), 
+				(xf, zf) -> getBiomedHeight((int) Math.round(xf), (int) Math.round(zf), plan));
-				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;
@@ -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 wx = (int) Math.round((double) x * (Iris.settings.gen.horizontalZoom / 1.90476190476));
-			int wz = (int) Math.round((double) z * Iris.settings.gen.horizontalZoom);
+			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;

src/main/java/ninja/bytecode/iris/generator/layer/GenLayerBase.java

@@ -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)
 	{

src/main/java/ninja/bytecode/iris/generator/layer/GenLayerBiome.java

@@ -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);
+		regions = new GMap<>();
-		roads = new MaxingGenerator(rng.nextParallelRNG(32), 5, 0.00055, 8, factory);
-		//@done
-
-		GMap<String, IrisRegion> 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 x = xx + (Iris.settings.gen.biomeEdgeScramble == 0 ? 0 : (fracture.noise(zz, xx) * Iris.settings.gen.biomeEdgeScramble));
-		double z = zz - (fracture.noise(xx, zz) * 1550D);
+		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)
+		if(land > landChance + 0.0175)
-		{
-			cbi = iris.biome("Beach");
-		}
-
-		else 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);
+	}
 }

src/main/java/ninja/bytecode/iris/generator/layer/GenLayerCarving.java

@@ -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)
 						{

src/main/java/ninja/bytecode/iris/generator/layer/GenLayerCaverns.java

@@ -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)
 						{

src/main/java/ninja/bytecode/iris/generator/layer/GenLayerCaves.java

@@ -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));

src/main/java/ninja/bytecode/iris/generator/layer/GenLayerFracture.java

@@ -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;
-	}
-}

src/main/java/ninja/bytecode/iris/generator/layer/GenLayerRidge.java

@@ -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;
-	}
-}

src/main/java/ninja/bytecode/iris/pack/IrisBiome.java

@@ -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()

src/main/java/ninja/bytecode/iris/pack/IrisRegion.java

@@ -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;
 	}
 }

src/main/java/ninja/bytecode/iris/util/InterpolationType.java

@@ -5,7 +5,6 @@ public enum InterpolationType
 	LINEAR,
 	PARAMETRIC_2,
 	PARAMETRIC_4,
-	PARAMETRIC_NH,
 	BEZIER,
 	NONE;
 }

src/main/java/ninja/bytecode/iris/util/IrisInterpolation.java

@@ -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;
+		double m0, m1, mu2, mu3;
-		int xa = x - h;
+		double a0, a1, a2, a3;
-		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);
 
-		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 x0 = ((fx - 1) << h);
-		int za = (fz << h) - 15;
+		int z0 = ((fz - 1) << h);
-		int xb = ((fx + 1) << h) + 15;
+		int x1 = (fx << h);
-		int zb = ((fz + 1) << h) + 15;
+		int z1 = (fz << h);
-		double na = getLinearNoise(xa, za, n, f, linear);
+		int x2 = ((fx + 1) << h);
-		double nb = getLinearNoise(xa, zb, n, f, linear);
+		int z2 = ((fz + 1) << h);
-		double nc = getLinearNoise(xb, za, n, f, linear);
+		int x3 = ((fx + 2) << h);
-		double nd = getLinearNoise(xb, zb, n, f, linear);
+		int z3 = ((fz + 2) << h);
-		double px = M.rangeScale(0, 1, xa, xb, x);
+		double px = M.rangeScale(0, 1, x1, x2, x);
-		double pz = M.rangeScale(0, 1, za, zb, z);
+		double pz = M.rangeScale(0, 1, z1, z2, z);
-
+		//@builder
-		return blerp(na, nc, nb, nd, px, pz, bilinear);
+		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;
+		return getHermiteNoise(x, z, lrad, n);
-		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);
-		}
 	}
 }