From 022c95a862421c3810bff40bdb144b04aa35d290 Mon Sep 17 00:00:00 2001 From: dfsek Date: Mon, 16 Nov 2020 11:15:50 -0700 Subject: [PATCH] User defined noise functions --- .../biome/failsafe/FailoverGenerator.java | 2 +- .../dfsek/terra/config/base/ConfigPack.java | 18 ++- .../config/genconfig/biome/BiomeConfig.java | 2 +- .../config/genconfig/noise/NoiseConfig.java | 56 +++++++++ .../terra/generation/ElevationEquation.java | 44 +++++-- .../generation/ElevationInterpolator.java | 39 +++---- .../terra/generation/TerraChunkGenerator.java | 6 +- .../generation/UserDefinedGenerator.java | 45 ++++++-- .../terra/generation/config/NoiseBuilder.java | 109 ++++++++++++++++++ .../com/dfsek/terra/math/NoiseFunction.java | 7 ++ .../com/dfsek/terra/math/NoiseFunction2.java | 14 ++- .../com/dfsek/terra/math/NoiseFunction3.java | 14 ++- 12 files changed, 300 insertions(+), 56 deletions(-) create mode 100644 src/main/java/com/dfsek/terra/config/genconfig/noise/NoiseConfig.java create mode 100644 src/main/java/com/dfsek/terra/generation/config/NoiseBuilder.java create mode 100644 src/main/java/com/dfsek/terra/math/NoiseFunction.java diff --git a/src/main/java/com/dfsek/terra/biome/failsafe/FailoverGenerator.java b/src/main/java/com/dfsek/terra/biome/failsafe/FailoverGenerator.java index 6badad8e1..17469ba63 100644 --- a/src/main/java/com/dfsek/terra/biome/failsafe/FailoverGenerator.java +++ b/src/main/java/com/dfsek/terra/biome/failsafe/FailoverGenerator.java @@ -19,6 +19,6 @@ public final class FailoverGenerator extends UserDefinedGenerator { } public FailoverGenerator() throws ParseException { - super("0", null, new HashMap<>(), palette, new TreeMap<>(), false); + super("0", null, new HashMap<>(), palette, new TreeMap<>(), new HashMap<>(), false); } } diff --git a/src/main/java/com/dfsek/terra/config/base/ConfigPack.java b/src/main/java/com/dfsek/terra/config/base/ConfigPack.java index c7437dc10..dc516fb50 100644 --- a/src/main/java/com/dfsek/terra/config/base/ConfigPack.java +++ b/src/main/java/com/dfsek/terra/config/base/ConfigPack.java @@ -15,6 +15,7 @@ import com.dfsek.terra.config.genconfig.PaletteConfig; import com.dfsek.terra.config.genconfig.TreeConfig; import com.dfsek.terra.config.genconfig.biome.AbstractBiomeConfig; import com.dfsek.terra.config.genconfig.biome.BiomeConfig; +import com.dfsek.terra.config.genconfig.noise.NoiseConfig; import com.dfsek.terra.config.genconfig.structure.StructureConfig; import com.dfsek.terra.config.lang.LangUtil; import com.dfsek.terra.registry.FloraRegistry; @@ -56,8 +57,6 @@ public class ConfigPack extends YamlConfiguration { public final int blendAmp; public final boolean biomeBlend; public final double blendFreq; - public final int octaves; - public final double frequency; public final boolean vanillaCaves; public final boolean vanillaStructures; public final boolean vanillaDecoration; @@ -76,9 +75,11 @@ public class ConfigPack extends YamlConfiguration { private final FloraRegistry floraRegistry = new FloraRegistry(); private final Set allStructures = new HashSet<>(); private final Map definedVariables = new HashMap<>(); + private final Map noiseBuilders = new HashMap<>(); private final File dataFolder; private final String id; + @SuppressWarnings("unchecked") public ConfigPack(File file) throws IOException, InvalidConfigurationException { long l = System.nanoTime(); load(new File(file, "pack.yml")); @@ -87,6 +88,12 @@ public class ConfigPack extends YamlConfiguration { if(!contains("id")) throw new ConfigException("No ID specified!", "null"); this.id = getString("id"); + Map noise = Objects.requireNonNull(getConfigurationSection("noise")).getValues(false); + for(Map.Entry entry : noise.entrySet()) { + noiseBuilders.put(entry.getKey(), new NoiseConfig((ConfigurationSection) entry.getValue())); + Debug.info("Loaded noise function " + entry.getKey()); + } + ores = ConfigLoader.load(new File(file, "ores").toPath(), this, OreConfig.class); palettes = ConfigLoader.load(new File(file, "palettes").toPath(), this, PaletteConfig.class); @@ -141,9 +148,6 @@ public class ConfigPack extends YamlConfiguration { erosionThresh = getDouble("erode.threshold", 0.04); erosionOctaves = getInt("erode.octaves", 3); - octaves = getInt("noise.octaves", 4); - frequency = getDouble("noise.frequency", 1f / 96); - erosionName = getString("erode.grid"); vanillaCaves = getBoolean("vanilla.caves", false); @@ -210,6 +214,10 @@ public class ConfigPack extends YamlConfiguration { return grids.get(id); } + public Map getNoiseBuilders() { + return noiseBuilders; + } + public static synchronized void loadAll(JavaPlugin main) { configs.clear(); File file = new File(main.getDataFolder(), "packs"); diff --git a/src/main/java/com/dfsek/terra/config/genconfig/biome/BiomeConfig.java b/src/main/java/com/dfsek/terra/config/genconfig/biome/BiomeConfig.java index 32a044b85..97de6c1c1 100644 --- a/src/main/java/com/dfsek/terra/config/genconfig/biome/BiomeConfig.java +++ b/src/main/java/com/dfsek/terra/config/genconfig/biome/BiomeConfig.java @@ -171,7 +171,7 @@ public class BiomeConfig extends TerraConfig { try { // Get UserDefinedBiome instance representing this config. - UserDefinedGenerator gen = new UserDefinedGenerator(eq, elevation, config.getDefinedVariables(), palette.getPaletteMap(), slant, getBoolean("prevent-smooth", false)); + UserDefinedGenerator gen = new UserDefinedGenerator(eq, elevation, config.getDefinedVariables(), palette.getPaletteMap(), slant, config.getNoiseBuilders(), getBoolean("prevent-smooth", false)); gen.setElevationInterpolation(doElevationInterpolation); this.biome = new UserDefinedBiome(vanillaBiome, dec, gen, getBoolean("erodible", false), biomeID); } catch(ParseException e) { diff --git a/src/main/java/com/dfsek/terra/config/genconfig/noise/NoiseConfig.java b/src/main/java/com/dfsek/terra/config/genconfig/noise/NoiseConfig.java new file mode 100644 index 000000000..ef11a6415 --- /dev/null +++ b/src/main/java/com/dfsek/terra/config/genconfig/noise/NoiseConfig.java @@ -0,0 +1,56 @@ +package com.dfsek.terra.config.genconfig.noise; + +import com.dfsek.terra.config.exception.ConfigException; +import com.dfsek.terra.generation.config.NoiseBuilder; +import org.bukkit.configuration.ConfigurationSection; +import org.polydev.gaea.math.FastNoiseLite; + +public class NoiseConfig { + private final NoiseBuilder builder; + private final int dimensions; + + @SuppressWarnings("unchecked") + public NoiseConfig(ConfigurationSection section) throws ConfigException { + NoiseBuilder builder = new NoiseBuilder(); + try { + builder.setType(FastNoiseLite.NoiseType.valueOf((String) section.get("type"))); + builder.setFrequency(section.getDouble("frequency", 0.02D)); + + dimensions = section.getInt("dimensions", 3); + if(dimensions != 2 && dimensions != 3) + throw new ConfigException("Invalid number of dimensions: " + dimensions, "Noise"); + + builder.setRotationType3D(FastNoiseLite.RotationType3D.valueOf(section.getString("rotation", "None"))); + + if(section.contains("fractal")) { + builder.setFractalType(FastNoiseLite.FractalType.valueOf(section.getString("fractal.type", "FBm"))); + builder.setOctaves(section.getInt("fractal.octaves", 1)); + builder.setFractalGain(section.getDouble("fractal.gain", 0.5D)); + builder.setFractalLacunarity(section.getDouble("fractal.lacunarity", 2.0D)); + builder.setPingPong(section.getDouble("fractal.ping-pong", 2.0D)); + builder.setWeightedStrength(section.getDouble("fractal.weighted-strength", 0.0D)); + } + + if(section.contains("cellular")) { + builder.setCellularDistanceFunction(FastNoiseLite.CellularDistanceFunction.valueOf(section.getString("cellular.distance", "EuclideanSq"))); + builder.setCellularReturnType(FastNoiseLite.CellularReturnType.valueOf(section.getString("cellular.return", "Distance"))); + } + + if(section.contains("warp")) { + builder.setDomainWarpType(FastNoiseLite.DomainWarpType.valueOf(section.getString("warp.type", "OpenSimplex2"))); + builder.setDomainWarpAmp(section.getDouble("warp.amplitude", 1.0D)); + } + this.builder = builder; + } catch(IllegalArgumentException | ClassCastException e) { + throw new ConfigException(e.getMessage(), "Noise"); + } + } + + public NoiseBuilder getBuilder() { + return builder; + } + + public int getDimensions() { + return dimensions; + } +} diff --git a/src/main/java/com/dfsek/terra/generation/ElevationEquation.java b/src/main/java/com/dfsek/terra/generation/ElevationEquation.java index 8cff5e1fb..fc18d683e 100644 --- a/src/main/java/com/dfsek/terra/generation/ElevationEquation.java +++ b/src/main/java/com/dfsek/terra/generation/ElevationEquation.java @@ -1,35 +1,65 @@ package com.dfsek.terra.generation; +import com.dfsek.terra.config.genconfig.noise.NoiseConfig; +import com.dfsek.terra.math.NoiseFunction; import com.dfsek.terra.math.NoiseFunction2; -import org.polydev.gaea.math.FastNoiseLite; +import com.dfsek.terra.math.NoiseFunction3; +import org.bukkit.World; import parsii.eval.Expression; import parsii.eval.Parser; import parsii.eval.Scope; import parsii.eval.Variable; import parsii.tokenizer.ParseException; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; + public class ElevationEquation { private static final Object noiseLock = new Object(); private final Expression delegate; private final Scope s = new Scope(); - private final NoiseFunction2 n2 = new NoiseFunction2(); private final Variable xVar = s.getVariable("x"); private final Variable zVar = s.getVariable("z"); - public ElevationEquation(String equation) throws ParseException { + private final List noiseFunctions = new ArrayList<>(); + private boolean set = true; + + public ElevationEquation(String equation, Map noiseBuilders) throws ParseException { Parser p = new Parser(); - p.registerFunction("noise2", n2); + for(Map.Entry e : noiseBuilders.entrySet()) { + switch(e.getValue().getDimensions()) { + case 2: + NoiseFunction2 function2 = new NoiseFunction2(e.getValue().getBuilder()); + noiseFunctions.add(function2); + p.registerFunction(e.getKey(), function2); + break; + case 3: + NoiseFunction3 function3 = new NoiseFunction3(e.getValue().getBuilder()); + noiseFunctions.add(function3); + p.registerFunction(e.getKey(), function3); + break; + } + } delegate = p.parse(equation, s); } - public double getNoise(double x, double z, FastNoiseLite noiseLite) { + public double getNoise(double x, double z, World w) { synchronized(noiseLock) { xVar.setValue(x); zVar.setValue(z); - - n2.setNoise(noiseLite); + setNoise(w.getSeed()); return delegate.evaluate(); } } + + private void setNoise(long seed) { + if(set) { + set = false; + for(NoiseFunction n : noiseFunctions) { + n.setNoise(seed); + } + } + } } diff --git a/src/main/java/com/dfsek/terra/generation/ElevationInterpolator.java b/src/main/java/com/dfsek/terra/generation/ElevationInterpolator.java index e6d2c896d..eab81feb1 100644 --- a/src/main/java/com/dfsek/terra/generation/ElevationInterpolator.java +++ b/src/main/java/com/dfsek/terra/generation/ElevationInterpolator.java @@ -3,21 +3,18 @@ package com.dfsek.terra.generation; import com.dfsek.terra.biome.grid.TerraBiomeGrid; import org.bukkit.World; import org.polydev.gaea.generation.GenerationPhase; -import org.polydev.gaea.math.FastNoiseLite; import org.polydev.gaea.math.Interpolator; public class ElevationInterpolator { private final UserDefinedGenerator[][] gens = new UserDefinedGenerator[10][10]; private final double[][] values = new double[18][18]; - private final FastNoiseLite noise; private final int xOrigin; private final int zOrigin; private final TerraBiomeGrid grid; - public ElevationInterpolator(World w, int chunkX, int chunkZ, TerraBiomeGrid grid, FastNoiseLite noise) { + public ElevationInterpolator(World w, int chunkX, int chunkZ, TerraBiomeGrid grid) { this.xOrigin = chunkX << 4; this.zOrigin = chunkZ << 4; - this.noise = noise; this.grid = grid; for(int x = -2; x < 8; x++) { @@ -30,13 +27,13 @@ public class ElevationInterpolator { for(byte z = -1; z <= 16; z++) { UserDefinedGenerator generator = getGenerator(x, z); if(compareGens((x / 4), (z / 4)) && generator.interpolateElevation()) { - Interpolator interpolator = new Interpolator(biomeAvg(x / 4, z / 4), - biomeAvg((x / 4) + 1, z / 4), - biomeAvg(x / 4, (z / 4) + 1), - biomeAvg((x / 4) + 1, (z / 4) + 1), + Interpolator interpolator = new Interpolator(biomeAvg(x / 4, z / 4, w), + biomeAvg((x / 4) + 1, z / 4, w), + biomeAvg(x / 4, (z / 4) + 1, w), + biomeAvg((x / 4) + 1, (z / 4) + 1, w), Interpolator.Type.LINEAR); values[x + 1][z + 1] = interpolator.bilerp((double) (x % 4) / 4, (double) (z % 4) / 4); - } else values[x + 1][z + 1] = elevate(generator, xOrigin + x, zOrigin + z); + } else values[x + 1][z + 1] = elevate(generator, xOrigin + x, zOrigin + z, w); } } } @@ -60,20 +57,20 @@ public class ElevationInterpolator { return false; } - private double biomeAvg(int x, int z) { - return (elevate(getStoredGen(x + 1, z), x * 4 + 4 + xOrigin, z * 4 + zOrigin) - + elevate(getStoredGen(x - 1, z), x * 4 - 4 + xOrigin, z * 4 + zOrigin) - + elevate(getStoredGen(x, z + 1), x * 4 + xOrigin, z * 4 + 4 + zOrigin) - + elevate(getStoredGen(x, z - 1), x * 4 + xOrigin, z * 4 - 4 + zOrigin) - + elevate(getStoredGen(x, z), x * 4 + xOrigin, z * 4 + zOrigin) - + elevate(getStoredGen(x - 1, z - 1), x * 4 + xOrigin, z * 4 + zOrigin) - + elevate(getStoredGen(x - 1, z + 1), x * 4 + xOrigin, z * 4 + zOrigin) - + elevate(getStoredGen(x + 1, z - 1), x * 4 + xOrigin, z * 4 + zOrigin) - + elevate(getStoredGen(x + 1, z + 1), x * 4 + xOrigin, z * 4 + zOrigin)) / 9D; + private double biomeAvg(int x, int z, World w) { + return (elevate(getStoredGen(x + 1, z), x * 4 + 4 + xOrigin, z * 4 + zOrigin, w) + + elevate(getStoredGen(x - 1, z), x * 4 - 4 + xOrigin, z * 4 + zOrigin, w) + + elevate(getStoredGen(x, z + 1), x * 4 + xOrigin, z * 4 + 4 + zOrigin, w) + + elevate(getStoredGen(x, z - 1), x * 4 + xOrigin, z * 4 - 4 + zOrigin, w) + + elevate(getStoredGen(x, z), x * 4 + xOrigin, z * 4 + zOrigin, w) + + elevate(getStoredGen(x - 1, z - 1), x * 4 + xOrigin, z * 4 + zOrigin, w) + + elevate(getStoredGen(x - 1, z + 1), x * 4 + xOrigin, z * 4 + zOrigin, w) + + elevate(getStoredGen(x + 1, z - 1), x * 4 + xOrigin, z * 4 + zOrigin, w) + + elevate(getStoredGen(x + 1, z + 1), x * 4 + xOrigin, z * 4 + zOrigin, w)) / 9D; } - private double elevate(UserDefinedGenerator g, int x, int z) { - if(g.getElevationEquation() != null) return g.getElevationEquation().getNoise(x, z, noise); + private double elevate(UserDefinedGenerator g, int x, int z, World w) { + if(g.getElevationEquation() != null) return g.getElevationEquation().getNoise(x, z, w); return 0; } diff --git a/src/main/java/com/dfsek/terra/generation/TerraChunkGenerator.java b/src/main/java/com/dfsek/terra/generation/TerraChunkGenerator.java index 551cf67bd..8dea8e9fe 100644 --- a/src/main/java/com/dfsek/terra/generation/TerraChunkGenerator.java +++ b/src/main/java/com/dfsek/terra/generation/TerraChunkGenerator.java @@ -151,7 +151,7 @@ public class TerraChunkGenerator extends GaeaChunkGenerator { ElevationInterpolator elevationInterpolator; try(ProfileFuture ignore = TerraProfiler.fromWorld(world).measure("ElevationTime")) { - elevationInterpolator = new ElevationInterpolator(world, chunkX, chunkZ, tw.getGrid(), getNoiseGenerator()); + elevationInterpolator = new ElevationInterpolator(world, chunkX, chunkZ, tw.getGrid()); } for(byte x = 0; x < 16; x++) { @@ -203,12 +203,12 @@ public class TerraChunkGenerator extends GaeaChunkGenerator { @Override public int getNoiseOctaves(World world) { - return configPack.octaves; + return 1; } @Override public double getNoiseFrequency(World world) { - return configPack.frequency; + return 0.02; } @Override diff --git a/src/main/java/com/dfsek/terra/generation/UserDefinedGenerator.java b/src/main/java/com/dfsek/terra/generation/UserDefinedGenerator.java index e44770a4e..9e72e1638 100644 --- a/src/main/java/com/dfsek/terra/generation/UserDefinedGenerator.java +++ b/src/main/java/com/dfsek/terra/generation/UserDefinedGenerator.java @@ -1,6 +1,8 @@ package com.dfsek.terra.generation; import com.dfsek.terra.Debug; +import com.dfsek.terra.config.genconfig.noise.NoiseConfig; +import com.dfsek.terra.math.NoiseFunction; import com.dfsek.terra.math.NoiseFunction2; import com.dfsek.terra.math.NoiseFunction3; import com.dfsek.terra.util.DataUtil; @@ -17,6 +19,8 @@ import parsii.eval.Scope; import parsii.eval.Variable; import parsii.tokenizer.ParseException; +import java.util.ArrayList; +import java.util.List; import java.util.Map; @@ -31,21 +35,35 @@ public class UserDefinedGenerator extends Generator { private final Palette[] palettes = new Palette[256]; @SuppressWarnings({"unchecked", "rawtypes", "RedundantSuppression"}) private final Palette[] slantPalettes = new Palette[256]; - private final NoiseFunction2 n2 = new NoiseFunction2(); - private final NoiseFunction3 n3 = new NoiseFunction3(); private final ElevationEquation elevationEquation; private final boolean preventSmooth; private boolean elevationInterpolation; + private final List noiseFunctions = new ArrayList<>(); + private boolean set = true; - public UserDefinedGenerator(String equation, @Nullable String elevateEquation, Map userVariables, Map> paletteMap, Map> slantPaletteMap, boolean preventSmooth) + public UserDefinedGenerator(String equation, @Nullable String elevateEquation, Map userVariables, Map> paletteMap, Map> slantPaletteMap, Map noiseBuilders, boolean preventSmooth) throws ParseException { for(Map.Entry entry : userVariables.entrySet()) { s.getVariable(entry.getKey()).setValue(entry.getValue()); // Define all user variables. } Parser p = new Parser(); - p.registerFunction("noise2", n2); - p.registerFunction("noise3", n3); + + for(Map.Entry e : noiseBuilders.entrySet()) { + switch(e.getValue().getDimensions()) { + case 2: + NoiseFunction2 function2 = new NoiseFunction2(e.getValue().getBuilder()); + noiseFunctions.add(function2); + p.registerFunction(e.getKey(), function2); + break; + case 3: + NoiseFunction3 function3 = new NoiseFunction3(e.getValue().getBuilder()); + noiseFunctions.add(function3); + p.registerFunction(e.getKey(), function3); + break; + } + } + for(int y = 0; y < 256; y++) { Palette d = DataUtil.BLANK_PALETTE; for(Map.Entry> e : paletteMap.entrySet()) { @@ -66,12 +84,21 @@ public class UserDefinedGenerator extends Generator { } if(elevateEquation != null) { Debug.info("Using elevation equation"); - this.elevationEquation = new ElevationEquation(elevateEquation); + this.elevationEquation = new ElevationEquation(elevateEquation, noiseBuilders); } else this.elevationEquation = null; this.noiseExp = p.parse(equation, s); this.preventSmooth = preventSmooth; } + private void setNoise(long seed) { + if(set) { + set = false; + for(NoiseFunction n : noiseFunctions) { + n.setNoise(seed); + } + } + } + /** * Gets the 2D noise at a pair of coordinates using the provided FastNoiseLite instance. * @@ -86,8 +113,7 @@ public class UserDefinedGenerator extends Generator { xVar.setValue(x); yVar.setValue(0); zVar.setValue(z); - n2.setNoise(gen); - n3.setNoise(gen); + setNoise(w.getSeed()); return noiseExp.evaluate(); } } @@ -107,8 +133,7 @@ public class UserDefinedGenerator extends Generator { xVar.setValue(x); yVar.setValue(y); zVar.setValue(z); - n2.setNoise(gen); - n3.setNoise(gen); + setNoise(w.getSeed()); return noiseExp.evaluate(); } } diff --git a/src/main/java/com/dfsek/terra/generation/config/NoiseBuilder.java b/src/main/java/com/dfsek/terra/generation/config/NoiseBuilder.java new file mode 100644 index 000000000..7c51571bb --- /dev/null +++ b/src/main/java/com/dfsek/terra/generation/config/NoiseBuilder.java @@ -0,0 +1,109 @@ +package com.dfsek.terra.generation.config; + +import org.polydev.gaea.math.FastNoiseLite; + +public class NoiseBuilder { + private FastNoiseLite.NoiseType type = FastNoiseLite.NoiseType.OpenSimplex2; + private int octaves = 1; + private FastNoiseLite.FractalType fractalType = FastNoiseLite.FractalType.None; + private double frequency = 0.02D; + private double fractalGain = 0.5D; + private double fractalLacunarity = 2.0D; + private double pingPong = 2.0D; + private double weightedStrength = 0.0D; + + private FastNoiseLite.CellularDistanceFunction cellularDistanceFunction = FastNoiseLite.CellularDistanceFunction.EuclideanSq; + private FastNoiseLite.CellularReturnType cellularReturnType = FastNoiseLite.CellularReturnType.Distance; + private double cellularJitter = 1.0D; + + private FastNoiseLite.DomainWarpType domainWarpType = FastNoiseLite.DomainWarpType.OpenSimplex2; + private double domainWarpAmp = 1.0D; + + private FastNoiseLite.RotationType3D rotationType3D = FastNoiseLite.RotationType3D.None; + + public FastNoiseLite build(int seed) { + FastNoiseLite noise = new FastNoiseLite(seed); + if(!fractalType.equals(FastNoiseLite.FractalType.None)) { + noise.setFractalType(fractalType); + noise.setFractalOctaves(octaves); + noise.setFractalGain(fractalGain); + noise.setFractalLacunarity(fractalLacunarity); + if(fractalType.equals(FastNoiseLite.FractalType.PingPong)) noise.setFractalPingPongStrength(pingPong); + noise.setFractalWeightedStrength(weightedStrength); + } + if(type.equals(FastNoiseLite.NoiseType.Cellular)) { + noise.setCellularDistanceFunction(cellularDistanceFunction); + noise.setCellularReturnType(cellularReturnType); + noise.setCellularJitter(cellularJitter); + } + + noise.setDomainWarpType(domainWarpType); + noise.setDomainWarpAmp(domainWarpAmp); + + noise.setRotationType3D(rotationType3D); + + noise.setFrequency(frequency); + return noise; + } + + public void setFrequency(double frequency) { + this.frequency = frequency; + } + + public void setFractalGain(double fractalGain) { + this.fractalGain = fractalGain; + } + + public void setFractalLacunarity(double fractalLacunarity) { + this.fractalLacunarity = fractalLacunarity; + } + + public void setFractalType(FastNoiseLite.FractalType fractalType) { + this.fractalType = fractalType; + } + + public void setOctaves(int octaves) { + this.octaves = octaves; + } + + public void setPingPong(double pingPong) { + this.pingPong = pingPong; + } + + public void setWeightedStrength(double weightedStrength) { + this.weightedStrength = weightedStrength; + } + + public FastNoiseLite.NoiseType getType() { + return type; + } + + public void setType(FastNoiseLite.NoiseType type) { + this.type = type; + } + + public void setCellularDistanceFunction(FastNoiseLite.CellularDistanceFunction cellularDistanceFunction) { + this.cellularDistanceFunction = cellularDistanceFunction; + } + + public void setCellularReturnType(FastNoiseLite.CellularReturnType cellularReturnType) { + this.cellularReturnType = cellularReturnType; + } + + public void setCellularJitter(double cellularJitter) { + this.cellularJitter = cellularJitter; + } + + public void setDomainWarpAmp(double domainWarpAmp) { + this.domainWarpAmp = domainWarpAmp; + } + + public void setDomainWarpType(FastNoiseLite.DomainWarpType domainWarpType) { + this.domainWarpType = domainWarpType; + } + + public void setRotationType3D(FastNoiseLite.RotationType3D rotationType3D) { + this.rotationType3D = rotationType3D; + } +} + diff --git a/src/main/java/com/dfsek/terra/math/NoiseFunction.java b/src/main/java/com/dfsek/terra/math/NoiseFunction.java new file mode 100644 index 000000000..c6685666a --- /dev/null +++ b/src/main/java/com/dfsek/terra/math/NoiseFunction.java @@ -0,0 +1,7 @@ +package com.dfsek.terra.math; + +import parsii.eval.Function; + +public interface NoiseFunction extends Function { + void setNoise(long seed); +} diff --git a/src/main/java/com/dfsek/terra/math/NoiseFunction2.java b/src/main/java/com/dfsek/terra/math/NoiseFunction2.java index 3a011be24..3c15a18b4 100644 --- a/src/main/java/com/dfsek/terra/math/NoiseFunction2.java +++ b/src/main/java/com/dfsek/terra/math/NoiseFunction2.java @@ -1,15 +1,20 @@ package com.dfsek.terra.math; import com.dfsek.terra.config.base.ConfigUtil; +import com.dfsek.terra.generation.config.NoiseBuilder; import org.polydev.gaea.math.FastNoiseLite; import parsii.eval.Expression; -import parsii.eval.Function; import java.util.List; -public class NoiseFunction2 implements Function { +public class NoiseFunction2 implements NoiseFunction { private final Cache cache = new Cache(); private FastNoiseLite gen; + private final NoiseBuilder builder; + + public NoiseFunction2(NoiseBuilder builder) { + this.builder = builder; + } @Override public int getNumberOfArguments() { @@ -26,8 +31,9 @@ public class NoiseFunction2 implements Function { return true; } - public void setNoise(FastNoiseLite gen) { - this.gen = gen; + @Override + public void setNoise(long seed) { + this.gen = builder.build((int) seed); } private final class Cache { diff --git a/src/main/java/com/dfsek/terra/math/NoiseFunction3.java b/src/main/java/com/dfsek/terra/math/NoiseFunction3.java index 6f6a10c82..55840d60e 100644 --- a/src/main/java/com/dfsek/terra/math/NoiseFunction3.java +++ b/src/main/java/com/dfsek/terra/math/NoiseFunction3.java @@ -1,13 +1,18 @@ package com.dfsek.terra.math; +import com.dfsek.terra.generation.config.NoiseBuilder; import org.polydev.gaea.math.FastNoiseLite; import parsii.eval.Expression; -import parsii.eval.Function; import java.util.List; -public class NoiseFunction3 implements Function { +public class NoiseFunction3 implements NoiseFunction { private FastNoiseLite gen; + private final NoiseBuilder builder; + + public NoiseFunction3(NoiseBuilder builder) { + this.builder = builder; + } @Override public int getNumberOfArguments() { @@ -24,7 +29,8 @@ public class NoiseFunction3 implements Function { return true; } - public void setNoise(FastNoiseLite gen) { - this.gen = gen; + @Override + public void setNoise(long seed) { + this.gen = builder.build((int) seed); } }