mirrors/Terra
1
0
Fork 0
mirror of https://github.com/PolyhedralDev/Terra.git synced 2026-02-16 10:30:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

finish new noise options, remove FastNoise

Browse Source
This commit is contained in:
dfsek
2021-02-17 01:30:52 -07:00
parent 84b8df6d96
commit 5ff016ea1f
40 changed files with 317 additions and 3027 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2658
common/src/main/java/com/dfsek/terra/api/math/noise/samplers/FastNoiseLite.java
View File

File diff suppressed because it is too large Load Diff

7
common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/CellularSampler.java
View File

@@ -187,7 +187,12 @@ public class CellularSampler extends NoiseFunction {
private ReturnType returnType = ReturnType.Distance;
private double jitterModifier = 1.0;
private NoiseSampler noiseLookup = new OpenSimplex2Sampler();
private NoiseSampler noiseLookup;
public CellularSampler(int seed) {
super(seed);
noiseLookup = new OpenSimplex2Sampler(seed);
}
public void setDistanceFunction(DistanceFunction distanceFunction) {
this.distanceFunction = distanceFunction;

17
common/src/main/java/com/dfsek/terra/api/math/noise/samplers/ConstantSampler.java → common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/ConstantSampler.java
View File

@@ -1,27 +1,16 @@
package com.dfsek.terra.api.math.noise.samplers;
import com.dfsek.terra.api.math.noise.NoiseSampler;
package com.dfsek.terra.api.math.noise.samplers.noise;
/**
* Sampler implementation that returns a constant.
*/
public class ConstantSampler implements NoiseSampler {
public class ConstantSampler extends NoiseFunction {
private final double constant;
public ConstantSampler(double constant) {
super(0);
this.constant = constant;
}
@Override
public double getNoise(double x, double y) {
return constant;
}
@Override
public double getNoise(double x, double y, double z) {
return constant;
}
@Override
public double getNoiseSeeded(int seed, double x, double y) {
return constant;

5
common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/NoiseFunction.java
View File

@@ -3,6 +3,7 @@ package com.dfsek.terra.api.math.noise.samplers.noise;
import com.dfsek.terra.api.math.noise.NoiseSampler;
import net.jafama.FastMath;
@SuppressWarnings("ManualMinMaxCalculation")
public abstract class NoiseFunction implements NoiseSampler {
// Hashing
protected static final int PRIME_X = 501125321;
@@ -13,6 +14,10 @@ public abstract class NoiseFunction implements NoiseSampler {
protected double frequency = 0.02d;
protected int seed = 2403;
public NoiseFunction(int seed) {
this.seed = seed;
}
protected static int fastFloor(double f) {
return f >= 0 ? (int) f : (int) f - 1;
}

4
common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/WhiteNoiseSampler.java
View File

@@ -3,6 +3,10 @@ package com.dfsek.terra.api.math.noise.samplers.noise;
public class WhiteNoiseSampler extends NoiseFunction {
private static final long POSITIVE_POW1 = 0b01111111111L << 52; // Bits that when applied to the exponent/sign section of a double, produce a positive number with a power of 1.
public WhiteNoiseSampler(int seed) {
super(seed);
}
@Override
public double getNoiseSeeded(int seed, double x, double y) {
long hashX = Double.doubleToRawLongBits(x) ^ seed;

4
common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/fractal/BrownianMotionSampler.java
View File

@@ -3,8 +3,8 @@ package com.dfsek.terra.api.math.noise.samplers.noise.fractal;
import com.dfsek.terra.api.math.noise.NoiseSampler;
public class BrownianMotionSampler extends FractalNoiseFunction {
public BrownianMotionSampler(NoiseSampler input) {
super(input);
public BrownianMotionSampler(int seed, NoiseSampler input) {
super(seed, input);
}
@Override

3
common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/fractal/FractalNoiseFunction.java
View File

@@ -11,7 +11,8 @@ public abstract class FractalNoiseFunction extends NoiseFunction {
protected double lacunarity = 2.0d;
protected double weightedStrength = 0.0d;
public FractalNoiseFunction(NoiseSampler input) {
public FractalNoiseFunction(int seed, NoiseSampler input) {
super(seed);
this.input = input;
}

5
common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/fractal/PingPongSampler.java
View File

@@ -5,10 +5,11 @@ import com.dfsek.terra.api.math.noise.NoiseSampler;
public class PingPongSampler extends FractalNoiseFunction {
private double pingPongStrength = 2.0;
public PingPongSampler(NoiseSampler input) {
super(input);
public PingPongSampler(int seed, NoiseSampler input) {
super(seed, input);
}
private static double pingPong(double t) {
t -= (int) (t * 0.5f) << 1;
return t < 1 ? t : 2 - t;

5
common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/fractal/RidgedFractalSampler.java
View File

@@ -3,8 +3,9 @@ package com.dfsek.terra.api.math.noise.samplers.noise.fractal;
import com.dfsek.terra.api.math.noise.NoiseSampler;
public class RidgedFractalSampler extends FractalNoiseFunction {
public RidgedFractalSampler(NoiseSampler input) {
super(input);
public RidgedFractalSampler(int seed, NoiseSampler input) {
super(seed, input);
}
@Override

4
common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/simplex/OpenSimplex2SSampler.java
View File

@@ -1,6 +1,10 @@
package com.dfsek.terra.api.math.noise.samplers.noise.simplex;
public class OpenSimplex2SSampler extends SimplexStyleSampler {
public OpenSimplex2SSampler(int seed) {
super(seed);
}
@Override
@SuppressWarnings("NumericOverflow")
public double getNoiseSeeded(int seed, double x, double y) {

4
common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/simplex/OpenSimplex2Sampler.java
View File

@@ -3,6 +3,10 @@ package com.dfsek.terra.api.math.noise.samplers.noise.simplex;
public class OpenSimplex2Sampler extends SimplexStyleSampler {
private static final double SQRT3 = 1.7320508075688772935274463415059;
public OpenSimplex2Sampler(int seed) {
super(seed);
}
@Override
public double getNoiseSeeded(int seed, double x, double y) {
// 2D OpenSimplex2 case uses the same algorithm as ordinary Simplex.

4
common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/simplex/PerlinSampler.java
View File

@@ -1,6 +1,10 @@
package com.dfsek.terra.api.math.noise.samplers.noise.simplex;
public class PerlinSampler extends SimplexStyleSampler {
public PerlinSampler(int seed) {
super(seed);
}
@Override
public double getNoiseSeeded(int seed, double x, double y) {
int x0 = fastFloor(x);

4
common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/simplex/SimplexStyleSampler.java
View File

@@ -68,6 +68,10 @@ public abstract class SimplexStyleSampler extends NoiseFunction {
1, 1, 0, 0, 0, -1, 1, 0, -1, 1, 0, 0, 0, -1, -1, 0
};
public SimplexStyleSampler(int seed) {
super(seed);
}
protected static double gradCoord(int seed, int xPrimed, int yPrimed, double xd, double yd) {
int hash = hash(seed, xPrimed, yPrimed);
hash ^= hash >> 15;

4
common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/value/ValueCubicSampler.java
View File

@@ -1,6 +1,10 @@
package com.dfsek.terra.api.math.noise.samplers.noise.value;
public class ValueCubicSampler extends ValueStyleNoise {
public ValueCubicSampler(int seed) {
super(seed);
}
@Override
public double getNoiseSeeded(int seed, double x, double y) {
int x1 = fastFloor(x);

4
common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/value/ValueSampler.java
View File

@@ -1,6 +1,10 @@
package com.dfsek.terra.api.math.noise.samplers.noise.value;
public class ValueSampler extends ValueStyleNoise {
public ValueSampler(int seed) {
super(seed);
}
@Override
public double getNoiseSeeded(int seed, double x, double y) {
int x0 = fastFloor(x);

4
common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/value/ValueStyleNoise.java
View File

@@ -3,6 +3,10 @@ package com.dfsek.terra.api.math.noise.samplers.noise.value;
import com.dfsek.terra.api.math.noise.samplers.noise.NoiseFunction;
public abstract class ValueStyleNoise extends NoiseFunction {
public ValueStyleNoise(int seed) {
super(seed);
}
protected static double valCoord(int seed, int xPrimed, int yPrimed) {
int hash = hash(seed, xPrimed, yPrimed);

12
common/src/main/java/com/dfsek/terra/config/GenericLoaders.java
View File

@@ -6,8 +6,8 @@ import com.dfsek.terra.api.core.TerraPlugin;
import com.dfsek.terra.api.math.GridSpawn;
import com.dfsek.terra.api.math.ProbabilityCollection;
import com.dfsek.terra.api.math.Range;
import com.dfsek.terra.api.math.noise.samplers.FastNoiseLite;
import com.dfsek.terra.api.math.noise.samplers.ImageSampler;
import com.dfsek.terra.api.math.noise.samplers.noise.CellularSampler;
import com.dfsek.terra.api.util.seeded.SourceSeeded;
import com.dfsek.terra.api.util.seeded.StageSeeded;
import com.dfsek.terra.api.world.palette.holder.PaletteHolder;
@@ -37,7 +37,6 @@ import com.dfsek.terra.config.loaders.config.biome.templates.stage.mutator.Repla
import com.dfsek.terra.config.loaders.config.biome.templates.stage.mutator.SmoothMutatorTemplate;
import com.dfsek.terra.config.loaders.config.function.FunctionTemplate;
import com.dfsek.terra.config.loaders.config.sampler.templates.DomainWarpTemplate;
import com.dfsek.terra.config.loaders.config.sampler.templates.FastNoiseTemplate;
import com.dfsek.terra.config.loaders.config.sampler.templates.ImageSamplerTemplate;
import com.dfsek.terra.config.loaders.config.sampler.templates.normalizer.ClampNormalizerTemplate;
import com.dfsek.terra.config.loaders.config.sampler.templates.normalizer.LinearNormalizerTemplate;
@@ -75,7 +74,6 @@ public class GenericLoaders implements LoaderRegistrar {
.registerLoader(TreeLayer.class, new TreeLayerLoader())
.registerLoader(MaterialSet.class, new MaterialSetLoader())
.registerLoader(OreHolder.class, new OreHolderLoader())
.registerLoader(FastNoiseTemplate.class, FastNoiseTemplate::new)
.registerLoader(ImageSamplerTemplate.class, ImageSamplerTemplate::new)
.registerLoader(DomainWarpTemplate.class, DomainWarpTemplate::new)
.registerLoader(LinearNormalizerTemplate.class, LinearNormalizerTemplate::new)
@@ -98,12 +96,8 @@ public class GenericLoaders implements LoaderRegistrar {
.registerLoader(ImageBiomeProvider.Align.class, (t, object, cf) -> ImageBiomeProvider.Align.valueOf((String) object))
.registerLoader(ExpanderStage.Type.class, (t, object, cf) -> ExpanderStage.Type.valueOf((String) object))
.registerLoader(MutatorStage.Type.class, (t, object, cf) -> MutatorStage.Type.valueOf((String) object))
.registerLoader(FastNoiseLite.NoiseType.class, (t, object, cf) -> FastNoiseLite.NoiseType.valueOf((String) object))
.registerLoader(FastNoiseLite.FractalType.class, (t, object, cf) -> FastNoiseLite.FractalType.valueOf((String) object))
.registerLoader(FastNoiseLite.DomainWarpType.class, (t, object, cf) -> FastNoiseLite.DomainWarpType.valueOf((String) object))
.registerLoader(FastNoiseLite.RotationType3D.class, (t, object, cf) -> FastNoiseLite.RotationType3D.valueOf((String) object))
.registerLoader(FastNoiseLite.CellularReturnType.class, (t, object, cf) -> FastNoiseLite.CellularReturnType.valueOf((String) object))
.registerLoader(FastNoiseLite.CellularDistanceFunction.class, (t, object, cf) -> FastNoiseLite.CellularDistanceFunction.valueOf((String) object))
.registerLoader(CellularSampler.ReturnType.class, (t, object, cf) -> CellularSampler.ReturnType.valueOf((String) object))
.registerLoader(CellularSampler.DistanceFunction.class, (t, object, cf) -> CellularSampler.DistanceFunction.valueOf((String) object))
.registerLoader(TerraFlora.Search.class, (t, o, l) -> TerraFlora.Search.valueOf(o.toString()));
}
}

2
common/src/main/java/com/dfsek/terra/config/builder/GeneratorBuilder.java
View File

@@ -3,8 +3,8 @@ package com.dfsek.terra.config.builder;
import com.dfsek.paralithic.eval.parser.Scope;
import com.dfsek.paralithic.eval.tokenizer.ParseException;
import com.dfsek.terra.api.math.noise.NoiseSampler;
import com.dfsek.terra.api.math.noise.samplers.ConstantSampler;
import com.dfsek.terra.api.math.noise.samplers.ExpressionSampler;
import com.dfsek.terra.api.math.noise.samplers.noise.ConstantSampler;
import com.dfsek.terra.api.util.seeded.NoiseSeeded;
import com.dfsek.terra.api.world.palette.holder.PaletteHolder;
import com.dfsek.terra.config.loaders.config.function.FunctionTemplate;

6
common/src/main/java/com/dfsek/terra/config/factories/FloraFactory.java
View File

@@ -1,7 +1,7 @@
package com.dfsek.terra.config.factories;
import com.dfsek.terra.api.core.TerraPlugin;
import com.dfsek.terra.api.math.noise.samplers.FastNoiseLite;
import com.dfsek.terra.api.math.noise.samplers.noise.WhiteNoiseSampler;
import com.dfsek.terra.api.platform.block.BlockData;
import com.dfsek.terra.api.world.flora.Flora;
import com.dfsek.terra.api.world.palette.NoisePalette;
@@ -13,9 +13,7 @@ import com.dfsek.terra.world.population.items.flora.TerraFlora;
public class FloraFactory implements TerraFactory<FloraTemplate, Flora> {
@Override
public TerraFlora build(FloraTemplate config, TerraPlugin main) {
FastNoiseLite whiteNoise = new FastNoiseLite();
whiteNoise.setNoiseType(FastNoiseLite.NoiseType.WhiteNoise);
Palette<BlockData> palette = new NoisePalette<>(whiteNoise, false);
Palette<BlockData> palette = new NoisePalette<>(new WhiteNoiseSampler(2403), false);
for(PaletteLayerHolder layer : config.getFloraPalette()) {
palette.add(layer.getLayer(), layer.getSize(), layer.getSampler());
}

8
common/src/main/java/com/dfsek/terra/config/loaders/config/FloraLayerLoader.java
View File

@@ -6,11 +6,10 @@ import com.dfsek.tectonic.loading.ConfigLoader;
import com.dfsek.tectonic.loading.TypeLoader;
import com.dfsek.terra.api.math.ProbabilityCollection;
import com.dfsek.terra.api.math.Range;
import com.dfsek.terra.api.math.noise.samplers.FastNoiseLite;
import com.dfsek.terra.api.math.noise.samplers.noise.WhiteNoiseSampler;
import com.dfsek.terra.api.util.seeded.NoiseSeeded;
import com.dfsek.terra.api.world.flora.Flora;
import com.dfsek.terra.config.loaders.Types;
import com.dfsek.terra.config.loaders.config.sampler.templates.FastNoiseTemplate;
import com.dfsek.terra.world.population.items.flora.FloraLayer;
import java.lang.reflect.Type;
@@ -35,10 +34,7 @@ public class FloraLayerLoader implements TypeLoader<FloraLayer> {
}
return new FloraLayer(density, range, items, sampler.apply(2403L));
}
FastNoiseTemplate def = new FastNoiseTemplate();
def.setType(FastNoiseLite.NoiseType.WhiteNoise);
def.setDimensions(3);
return new FloraLayer(density, range, items, def.apply(2403L));
return new FloraLayer(density, range, items, new WhiteNoiseSampler(2403));
}
}

20
common/src/main/java/com/dfsek/terra/config/loaders/config/TreeLayerLoader.java
View File

@@ -1,16 +1,14 @@
package com.dfsek.terra.config.loaders.config;
import com.dfsek.tectonic.config.Configuration;
import com.dfsek.tectonic.exception.ConfigException;
import com.dfsek.tectonic.exception.LoadException;
import com.dfsek.tectonic.loading.ConfigLoader;
import com.dfsek.tectonic.loading.TypeLoader;
import com.dfsek.terra.api.math.ProbabilityCollection;
import com.dfsek.terra.api.math.Range;
import com.dfsek.terra.api.math.noise.samplers.FastNoiseLite;
import com.dfsek.terra.api.math.noise.samplers.noise.WhiteNoiseSampler;
import com.dfsek.terra.api.util.seeded.NoiseSeeded;
import com.dfsek.terra.api.world.tree.Tree;
import com.dfsek.terra.config.loaders.Types;
import com.dfsek.terra.config.loaders.config.sampler.templates.FastNoiseTemplate;
import com.dfsek.terra.world.population.items.tree.TreeLayer;
import java.lang.reflect.Type;
@@ -26,19 +24,11 @@ public class TreeLayerLoader implements TypeLoader<TreeLayer> {
if(range == null) throw new LoadException("Tree range unspecified");
ProbabilityCollection<Tree> items = (ProbabilityCollection<Tree>) configLoader.loadType(Types.TREE_PROBABILITY_COLLECTION_TYPE, map.get("items"));
FastNoiseTemplate sampler = new FastNoiseTemplate();
if(map.containsKey("distribution")) {
try {
configLoader.load(sampler, new Configuration((Map<String, Object>) map.get("distribution")));
} catch(ConfigException e) {
throw new LoadException("Unable to load noise", e);
}
return new TreeLayer(density, range, items, sampler.apply(2403L));
NoiseSeeded noise = configLoader.loadClass(NoiseSeeded.class, map.get("distribution"));
return new TreeLayer(density, range, items, noise.apply(2403L));
}
sampler.setType(FastNoiseLite.NoiseType.WhiteNoise);
sampler.setDimensions(3);
return new TreeLayer(density, range, items, sampler.apply(2403L));
return new TreeLayer(density, range, items, new WhiteNoiseSampler(2403));
}
}

2
common/src/main/java/com/dfsek/terra/config/loaders/config/biome/templates/source/BiomeProviderTemplate.java
View File

@@ -4,7 +4,7 @@ import com.dfsek.tectonic.annotations.Default;
import com.dfsek.tectonic.annotations.Value;
import com.dfsek.tectonic.loading.object.ObjectTemplate;
import com.dfsek.terra.api.math.noise.NoiseSampler;
import com.dfsek.terra.api.math.noise.samplers.ConstantSampler;
import com.dfsek.terra.api.math.noise.samplers.noise.ConstantSampler;
import com.dfsek.terra.api.util.seeded.NoiseSeeded;
import com.dfsek.terra.biome.provider.BiomeProvider;
import com.dfsek.terra.registry.config.BiomeRegistry;

45
common/src/main/java/com/dfsek/terra/config/loaders/config/sampler/NoiseSamplerBuilderLoader.java
View File

@@ -5,52 +5,31 @@ import com.dfsek.tectonic.exception.ConfigException;
import com.dfsek.tectonic.exception.LoadException;
import com.dfsek.tectonic.loading.ConfigLoader;
import com.dfsek.tectonic.loading.TypeLoader;
import com.dfsek.tectonic.loading.object.ObjectTemplate;
import com.dfsek.terra.api.util.seeded.NoiseSeeded;
import com.dfsek.terra.config.loaders.config.sampler.templates.DomainWarpTemplate;
import com.dfsek.terra.config.loaders.config.sampler.templates.FastNoiseTemplate;
import com.dfsek.terra.config.loaders.config.sampler.templates.ImageSamplerTemplate;
import com.dfsek.terra.config.loaders.config.sampler.templates.normalizer.NormalizerTemplate;
import com.dfsek.terra.registry.config.NormalizerRegistry;
import com.dfsek.terra.registry.config.NoiseRegistry;
import java.lang.reflect.Type;
import java.util.Locale;
import java.util.Map;
@SuppressWarnings("unchecked")
public class NoiseSamplerBuilderLoader implements TypeLoader<NoiseSeeded> {
private final NormalizerRegistry normalizerRegistry;
private final NoiseRegistry noiseRegistry;
public NoiseSamplerBuilderLoader(NormalizerRegistry normalizerRegistry) {
this.normalizerRegistry = normalizerRegistry;
public NoiseSamplerBuilderLoader(NoiseRegistry noiseRegistry) {
this.noiseRegistry = noiseRegistry;
}
@Override
public NoiseSeeded load(Type t, Object c, ConfigLoader loader) throws LoadException {
Map<String, Object> map = (Map<String, Object>) c;
String samplerType = "NOISE";
if(map.containsKey("sampler-type")) {
samplerType = map.get("sampler-type").toString();
try {
ObjectTemplate<NoiseSeeded> normalizerTemplate = noiseRegistry.get(((String) map.get("type")).toUpperCase(Locale.ROOT)).get();
loader.load(normalizerTemplate, new Configuration(map));
return normalizerTemplate.get();
} catch(ConfigException e) {
throw new LoadException("Unable to load noise function: ", e);
}
switch(samplerType) {
case "NOISE":
return loader.loadClass(FastNoiseTemplate.class, map).get();
case "NORMALIZER":
try {
NormalizerTemplate<?> normalizerTemplate = normalizerRegistry.get((String) map.get("type")).get();
loader.load(normalizerTemplate, new Configuration(map));
return normalizerTemplate;
} catch(ConfigException e) {
throw new LoadException("Unable to load normalizer: ", e);
}
case "IMAGE": {
return loader.loadClass(ImageSamplerTemplate.class, map).get();
}
case "DOMAIN_WARP":
return loader.loadClass(DomainWarpTemplate.class, map).get();
}
throw new LoadException("No such noise sampler type \"" + samplerType + "\"");
}
}

227
common/src/main/java/com/dfsek/terra/config/loaders/config/sampler/templates/FastNoiseTemplate.java
View File

@@ -1,227 +0,0 @@
package com.dfsek.terra.config.loaders.config.sampler.templates;
import com.dfsek.tectonic.annotations.Default;
import com.dfsek.tectonic.annotations.Value;
import com.dfsek.terra.api.math.noise.NoiseSampler;
import com.dfsek.terra.api.math.noise.samplers.FastNoiseLite;
import com.dfsek.terra.api.util.seeded.NoiseSeeded;
@SuppressWarnings({"unused", "FieldMayBeFinal"})
public class FastNoiseTemplate extends SamplerTemplate<FastNoiseLite> implements NoiseSeeded {
@Value("type")
@Default
private FastNoiseLite.NoiseType type = FastNoiseLite.NoiseType.OpenSimplex2;
@Value("fractal.octaves")
@Default
private int octaves = 1;
@Value("fractal.type")
@Default
private FastNoiseLite.FractalType fractalType = FastNoiseLite.FractalType.None;
@Value("frequency")
@Default
private double frequency = 0.02D;
@Value("fractal.gain")
@Default
private double fractalGain = 0.5D;
@Value("fractal.lacunarity")
@Default
private double fractalLacunarity = 2.0D;
@Value("fractal.ping-pong")
@Default
private double pingPong = 2.0D;
@Value("fractal.weighted-strength")
@Default
private double weightedStrength = 0.0D;
@Value("salt")
@Default
private int seedOffset = 0;
@Value("cellular.distance")
@Default
private FastNoiseLite.CellularDistanceFunction cellularDistanceFunction = FastNoiseLite.CellularDistanceFunction.EuclideanSq;
@Value("cellular.return")
@Default
private FastNoiseLite.CellularReturnType cellularReturnType = FastNoiseLite.CellularReturnType.Distance;
@Value("cellular.jitter")
@Default
private double cellularJitter = 1.0D;
@Value("rotation-type")
@Default
private FastNoiseLite.RotationType3D rotationType3D = FastNoiseLite.RotationType3D.None;
@Value("dimensions")
@Default
private int dimensions = 2;
@Value("cellular.lookup")
@Default
private NoiseSeeded lookup;
@Override
public NoiseSampler apply(Long seed) {
FastNoiseLite noise = new FastNoiseLite((int) (seed + seedOffset));
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);
if(lookup != null) noise.setCellularNoiseLookup(lookup.apply(seed));
}
noise.setNoiseType(type);
noise.setRotationType3D(rotationType3D);
noise.setFrequency(frequency);
return noise;
}
public FastNoiseLite.NoiseType getType() {
return type;
}
public FastNoiseTemplate setType(FastNoiseLite.NoiseType type) {
this.type = type;
return this;
}
public int getSeedOffset() {
return seedOffset;
}
public void setSeedOffset(int seedOffset) {
this.seedOffset = seedOffset;
}
public FastNoiseLite.CellularDistanceFunction getCellularDistanceFunction() {
return cellularDistanceFunction;
}
public FastNoiseTemplate setCellularDistanceFunction(FastNoiseLite.CellularDistanceFunction cellularDistanceFunction) {
this.cellularDistanceFunction = cellularDistanceFunction;
return this;
}
public FastNoiseLite.CellularReturnType getCellularReturnType() {
return cellularReturnType;
}
public FastNoiseTemplate setCellularReturnType(FastNoiseLite.CellularReturnType cellularReturnType) {
this.cellularReturnType = cellularReturnType;
return this;
}
public double getCellularJitter() {
return cellularJitter;
}
public FastNoiseTemplate setCellularJitter(double cellularJitter) {
this.cellularJitter = cellularJitter;
return this;
}
public double getFractalGain() {
return fractalGain;
}
public FastNoiseTemplate setFractalGain(double fractalGain) {
this.fractalGain = fractalGain;
return this;
}
public double getFractalLacunarity() {
return fractalLacunarity;
}
public FastNoiseTemplate setFractalLacunarity(double fractalLacunarity) {
this.fractalLacunarity = fractalLacunarity;
return this;
}
public double getFrequency() {
return frequency;
}
public FastNoiseTemplate setFrequency(double frequency) {
this.frequency = frequency;
return this;
}
public double getPingPong() {
return pingPong;
}
public FastNoiseTemplate setPingPong(double pingPong) {
this.pingPong = pingPong;
return this;
}
public double getWeightedStrength() {
return weightedStrength;
}
public FastNoiseTemplate setWeightedStrength(double weightedStrength) {
this.weightedStrength = weightedStrength;
return this;
}
public int getOctaves() {
return octaves;
}
public FastNoiseTemplate setOctaves(int octaves) {
this.octaves = octaves;
return this;
}
public FastNoiseLite.FractalType getFractalType() {
return fractalType;
}
public FastNoiseTemplate setFractalType(FastNoiseLite.FractalType fractalType) {
this.fractalType = fractalType;
return this;
}
public FastNoiseLite.RotationType3D getRotationType3D() {
return rotationType3D;
}
public FastNoiseTemplate setRotationType3D(FastNoiseLite.RotationType3D rotationType3D) {
this.rotationType3D = rotationType3D;
return this;
}
public int getDimensions() {
return dimensions;
}
public void setDimensions(int dimensions) {
this.dimensions = dimensions;
}
@Override
public NoiseSeeded get() {
return this;
}
}

49
common/src/main/java/com/dfsek/terra/config/loaders/config/sampler/templates/noise/CellularNoiseTemplate.java Normal file
View File

@@ -0,0 +1,49 @@
package com.dfsek.terra.config.loaders.config.sampler.templates.noise;
import com.dfsek.tectonic.annotations.Default;
import com.dfsek.tectonic.annotations.Value;
import com.dfsek.terra.api.math.noise.NoiseSampler;
import com.dfsek.terra.api.math.noise.samplers.noise.CellularSampler;
import com.dfsek.terra.api.math.noise.samplers.noise.simplex.OpenSimplex2Sampler;
import com.dfsek.terra.api.util.seeded.NoiseSeeded;
public class CellularNoiseTemplate extends NoiseTemplate<CellularSampler> {
@Value("distance")
@Default
private CellularSampler.DistanceFunction cellularDistanceFunction = CellularSampler.DistanceFunction.EuclideanSq;
@Value("return")
@Default
private CellularSampler.ReturnType cellularReturnType = CellularSampler.ReturnType.Distance;
@Value("jitter")
@Default
private double cellularJitter = 1.0D;
@Value("lookup")
@Default
private NoiseSeeded lookup = new NoiseSeeded() {
@Override
public NoiseSampler apply(Long seed) {
return new OpenSimplex2Sampler((int) (long) seed);
}
@Override
public int getDimensions() {
return 2;
}
};
@Override
public NoiseSampler apply(Long seed) {
CellularSampler sampler = new CellularSampler((int) (long) seed);
sampler.setNoiseLookup(lookup.apply(seed));
sampler.setFrequency(frequency);
sampler.setJitterModifier(cellularJitter);
sampler.setReturnType(cellularReturnType);
sampler.setDistanceFunction(cellularDistanceFunction);
return sampler;
}
}

16
common/src/main/java/com/dfsek/terra/config/loaders/config/sampler/templates/noise/NoiseTemplate.java Normal file
View File

@@ -0,0 +1,16 @@
package com.dfsek.terra.config.loaders.config.sampler.templates.noise;
import com.dfsek.tectonic.annotations.Default;
import com.dfsek.tectonic.annotations.Value;
import com.dfsek.terra.api.math.noise.samplers.noise.NoiseFunction;
import com.dfsek.terra.config.loaders.config.sampler.templates.SamplerTemplate;
public abstract class NoiseTemplate<T extends NoiseFunction> extends SamplerTemplate<T> {
@Value("frequency")
@Default
protected double frequency = 0.02d;
@Value("salt")
@Default
protected int salt = 0;
}

22
common/src/main/java/com/dfsek/terra/config/loaders/config/sampler/templates/noise/SimpleNoiseTemplate.java Normal file
View File

@@ -0,0 +1,22 @@
package com.dfsek.terra.config.loaders.config.sampler.templates.noise;
import com.dfsek.terra.api.math.noise.NoiseSampler;
import com.dfsek.terra.api.math.noise.samplers.noise.NoiseFunction;
import java.util.function.Function;
public class SimpleNoiseTemplate extends NoiseTemplate<NoiseFunction> {
private final Function<Integer, NoiseFunction> samplerSupplier;
public SimpleNoiseTemplate(Function<Integer, NoiseFunction> samplerSupplier) {
this.samplerSupplier = samplerSupplier;
}
@Override
public NoiseSampler apply(Long seed) {
NoiseFunction sampler = samplerSupplier.apply((int) (long) seed);
sampler.setSeed((int) (long) seed);
sampler.setFrequency(frequency);
return sampler;
}
}

17
common/src/main/java/com/dfsek/terra/config/loaders/config/sampler/templates/noise/fractal/BrownianMotionTemplate.java Normal file
View File

@@ -0,0 +1,17 @@
package com.dfsek.terra.config.loaders.config.sampler.templates.noise.fractal;
import com.dfsek.terra.api.math.noise.NoiseSampler;
import com.dfsek.terra.api.math.noise.samplers.noise.fractal.BrownianMotionSampler;
public class BrownianMotionTemplate extends FractalTemplate<BrownianMotionSampler> {
@Override
public NoiseSampler apply(Long seed) {
BrownianMotionSampler sampler = new BrownianMotionSampler((int) (long) seed, function.apply(seed));
sampler.setFrequency(frequency);
sampler.setGain(fractalGain);
sampler.setLacunarity(fractalLacunarity);
sampler.setOctaves(octaves);
sampler.setWeightedStrength(weightedStrength);
return sampler;
}
}

28
common/src/main/java/com/dfsek/terra/config/loaders/config/sampler/templates/noise/fractal/FractalTemplate.java Normal file
View File

@@ -0,0 +1,28 @@
package com.dfsek.terra.config.loaders.config.sampler.templates.noise.fractal;
import com.dfsek.tectonic.annotations.Default;
import com.dfsek.tectonic.annotations.Value;
import com.dfsek.terra.api.math.noise.samplers.noise.fractal.FractalNoiseFunction;
import com.dfsek.terra.api.util.seeded.NoiseSeeded;
import com.dfsek.terra.config.loaders.config.sampler.templates.noise.NoiseTemplate;
public abstract class FractalTemplate<T extends FractalNoiseFunction> extends NoiseTemplate<T> {
@Value("octaves")
@Default
protected int octaves = 3;
@Value("gain")
@Default
protected double fractalGain = 0.5D;
@Value("lacunarity")
@Default
protected double fractalLacunarity = 2.0D;
@Value("weighted-strength")
@Default
protected double weightedStrength = 0.0D;
@Value("function")
protected NoiseSeeded function;
}

24
common/src/main/java/com/dfsek/terra/config/loaders/config/sampler/templates/noise/fractal/PingPongTemplate.java Normal file
View File

@@ -0,0 +1,24 @@
package com.dfsek.terra.config.loaders.config.sampler.templates.noise.fractal;
import com.dfsek.tectonic.annotations.Default;
import com.dfsek.tectonic.annotations.Value;
import com.dfsek.terra.api.math.noise.NoiseSampler;
import com.dfsek.terra.api.math.noise.samplers.noise.fractal.PingPongSampler;
public class PingPongTemplate extends FractalTemplate<PingPongSampler> {
@Value("ping-pong")
@Default
private double pingPong = 2.0D;
@Override
public NoiseSampler apply(Long seed) {
PingPongSampler sampler = new PingPongSampler((int) (long) seed, function.apply(seed));
sampler.setFrequency(frequency);
sampler.setGain(fractalGain);
sampler.setLacunarity(fractalLacunarity);
sampler.setOctaves(octaves);
sampler.setWeightedStrength(weightedStrength);
sampler.setPingPongStrength(pingPong);
return sampler;
}
}

17
common/src/main/java/com/dfsek/terra/config/loaders/config/sampler/templates/noise/fractal/RidgedFractalTemplate.java Normal file
View File

@@ -0,0 +1,17 @@
package com.dfsek.terra.config.loaders.config.sampler.templates.noise.fractal;
import com.dfsek.terra.api.math.noise.NoiseSampler;
import com.dfsek.terra.api.math.noise.samplers.noise.fractal.RidgedFractalSampler;
public class RidgedFractalTemplate extends FractalTemplate<RidgedFractalSampler> {
@Override
public NoiseSampler apply(Long seed) {
RidgedFractalSampler sampler = new RidgedFractalSampler((int) (long) seed, function.apply(seed));
sampler.setFrequency(frequency);
sampler.setGain(fractalGain);
sampler.setLacunarity(fractalLacunarity);
sampler.setOctaves(octaves);
sampler.setWeightedStrength(weightedStrength);
return sampler;
}
}

10
common/src/main/java/com/dfsek/terra/config/pack/ConfigPack.java
View File

@@ -52,7 +52,7 @@ import com.dfsek.terra.registry.config.BiomeRegistry;
import com.dfsek.terra.registry.config.CarverRegistry;
import com.dfsek.terra.registry.config.FloraRegistry;
import com.dfsek.terra.registry.config.LootRegistry;
import com.dfsek.terra.registry.config.NormalizerRegistry;
import com.dfsek.terra.registry.config.NoiseRegistry;
import com.dfsek.terra.registry.config.OreRegistry;
import com.dfsek.terra.registry.config.PaletteRegistry;
import com.dfsek.terra.registry.config.ScriptRegistry;
@@ -97,7 +97,7 @@ public class ConfigPack implements LoaderRegistrar {
private final CarverRegistry carverRegistry = new CarverRegistry();
private final NormalizerRegistry normalizerRegistry = new NormalizerRegistry();
private final NoiseRegistry noiseRegistry = new NoiseRegistry();
private final FunctionRegistry functionRegistry = new FunctionRegistry();
private final AbstractConfigLoader abstractConfigLoader = new AbstractConfigLoader();
@@ -281,7 +281,7 @@ public class ConfigPack implements LoaderRegistrar {
.registerLoader(LootTable.class, lootRegistry)
.registerLoader(UserDefinedCarver.class, carverRegistry)
.registerLoader(BufferedImage.class, new BufferedImageLoader(loader))
.registerLoader(NoiseSeeded.class, new NoiseSamplerBuilderLoader(normalizerRegistry))
.registerLoader(NoiseSeeded.class, new NoiseSamplerBuilderLoader(noiseRegistry))
.registerLoader(SingleBiomeProviderTemplate.class, () -> new SingleBiomeProviderTemplate(biomeRegistry))
.registerLoader(BiomePipelineTemplate.class, () -> new BiomePipelineTemplate(biomeRegistry, main))
.registerLoader(ImageSamplerTemplate.class, () -> new ImageProviderTemplate(biomeRegistry));
@@ -311,8 +311,8 @@ public class ConfigPack implements LoaderRegistrar {
return functionRegistry;
}
public NormalizerRegistry getNormalizerRegistry() {
return normalizerRegistry;
public NoiseRegistry getNormalizerRegistry() {
return noiseRegistry;
}
public CarverRegistry getCarverRegistry() {

7
common/src/main/java/com/dfsek/terra/config/templates/BiomeTemplate.java
View File

@@ -11,7 +11,7 @@ import com.dfsek.tectonic.exception.ValidationException;
import com.dfsek.terra.api.core.TerraPlugin;
import com.dfsek.terra.api.math.ProbabilityCollection;
import com.dfsek.terra.api.math.noise.NoiseSampler;
import com.dfsek.terra.api.math.noise.samplers.FastNoiseLite;
import com.dfsek.terra.api.math.noise.samplers.noise.ConstantSampler;
import com.dfsek.terra.api.math.parsii.BlankFunction;
import com.dfsek.terra.api.math.parsii.defined.UserDefinedFunction;
import com.dfsek.terra.api.platform.block.BlockData;
@@ -24,7 +24,6 @@ import com.dfsek.terra.api.world.palette.SinglePalette;
import com.dfsek.terra.api.world.palette.holder.PaletteHolder;
import com.dfsek.terra.carving.UserDefinedCarver;
import com.dfsek.terra.config.loaders.config.function.FunctionTemplate;
import com.dfsek.terra.config.loaders.config.sampler.templates.FastNoiseTemplate;
import com.dfsek.terra.config.pack.ConfigPack;
import com.dfsek.terra.world.population.items.TerraStructure;
import com.dfsek.terra.world.population.items.flora.FloraLayer;
@@ -248,12 +247,10 @@ public class BiomeTemplate extends AbstractableTemplate implements ValidatedConf
public BiomeTemplate(ConfigPack pack, TerraPlugin main) {
this.pack = pack;
FastNoiseTemplate builder = new FastNoiseTemplate();
builder.setType(FastNoiseLite.NoiseType.Constant);
biomeNoise = new NoiseSeeded() {
@Override
public NoiseSampler apply(Long seed) {
return builder.apply(seed);
return new ConstantSampler(0);
}
@Override

8
common/src/main/java/com/dfsek/terra/config/templates/PaletteTemplate.java
View File

@@ -4,10 +4,9 @@ import com.dfsek.tectonic.annotations.Abstractable;
import com.dfsek.tectonic.annotations.Default;
import com.dfsek.tectonic.annotations.Value;
import com.dfsek.terra.api.math.noise.NoiseSampler;
import com.dfsek.terra.api.math.noise.samplers.FastNoiseLite;
import com.dfsek.terra.api.math.noise.samplers.noise.WhiteNoiseSampler;
import com.dfsek.terra.api.util.seeded.NoiseSeeded;
import com.dfsek.terra.api.world.palette.holder.PaletteLayerHolder;
import com.dfsek.terra.config.loaders.config.sampler.templates.FastNoiseTemplate;
import java.util.List;
@@ -26,13 +25,10 @@ public class PaletteTemplate extends AbstractableTemplate {
private List<PaletteLayerHolder> palette;
public PaletteTemplate() {
FastNoiseTemplate builder = new FastNoiseTemplate();
builder.setType(FastNoiseLite.NoiseType.WhiteNoise);
builder.setDimensions(3);
this.noise = new NoiseSeeded() {
@Override
public NoiseSampler apply(Long seed) {
return builder.apply(seed);
return new WhiteNoiseSampler((int) (long) seed);
}
@Override

44
common/src/main/java/com/dfsek/terra/registry/config/NoiseRegistry.java
View File

@@ -1,11 +1,51 @@
package com.dfsek.terra.registry.config;
import com.dfsek.tectonic.loading.object.ObjectTemplate;
import com.dfsek.terra.api.math.noise.samplers.noise.NoiseFunction;
import com.dfsek.terra.api.math.noise.samplers.noise.WhiteNoiseSampler;
import com.dfsek.terra.api.math.noise.samplers.noise.simplex.OpenSimplex2SSampler;
import com.dfsek.terra.api.math.noise.samplers.noise.simplex.OpenSimplex2Sampler;
import com.dfsek.terra.api.math.noise.samplers.noise.simplex.PerlinSampler;
import com.dfsek.terra.api.math.noise.samplers.noise.value.ValueCubicSampler;
import com.dfsek.terra.api.math.noise.samplers.noise.value.ValueSampler;
import com.dfsek.terra.api.util.seeded.NoiseSeeded;
import com.dfsek.terra.config.loaders.config.sampler.templates.DomainWarpTemplate;
import com.dfsek.terra.config.loaders.config.sampler.templates.ImageSamplerTemplate;
import com.dfsek.terra.config.loaders.config.sampler.templates.noise.CellularNoiseTemplate;
import com.dfsek.terra.config.loaders.config.sampler.templates.noise.SimpleNoiseTemplate;
import com.dfsek.terra.config.loaders.config.sampler.templates.noise.fractal.BrownianMotionTemplate;
import com.dfsek.terra.config.loaders.config.sampler.templates.noise.fractal.PingPongTemplate;
import com.dfsek.terra.config.loaders.config.sampler.templates.noise.fractal.RidgedFractalTemplate;
import com.dfsek.terra.config.loaders.config.sampler.templates.normalizer.ClampNormalizerTemplate;
import com.dfsek.terra.config.loaders.config.sampler.templates.normalizer.LinearNormalizerTemplate;
import com.dfsek.terra.config.loaders.config.sampler.templates.normalizer.NormalNormalizerTemplate;
import com.dfsek.terra.registry.TerraRegistry;
import java.util.function.Supplier;
public class NoiseRegistry extends TerraRegistry<Supplier<ObjectTemplate<NoiseFunction>>> {
public class NoiseRegistry extends TerraRegistry<Supplier<ObjectTemplate<NoiseSeeded>>> {
public NoiseRegistry() {
add("LINEAR", LinearNormalizerTemplate::new);
add("NORMAL", NormalNormalizerTemplate::new);
add("CLAMP", ClampNormalizerTemplate::new);
add("IMAGE", ImageSamplerTemplate::new);
add("DOMAIN_WARP", DomainWarpTemplate::new);
add("FBM", BrownianMotionTemplate::new);
add("PINGPONG", PingPongTemplate::new);
add("RIDGED", RidgedFractalTemplate::new);
add("OPENSIMPLEX2", () -> new SimpleNoiseTemplate(OpenSimplex2Sampler::new));
add("OPENSIMPLEX2S", () -> new SimpleNoiseTemplate(OpenSimplex2SSampler::new));
add("PERLIN", () -> new SimpleNoiseTemplate(PerlinSampler::new));
add("VALUE", () -> new SimpleNoiseTemplate(ValueSampler::new));
add("VALUECUBIC", () -> new SimpleNoiseTemplate(ValueCubicSampler::new));
add("CELLULAR", CellularNoiseTemplate::new);
add("WHITENOISE", () -> new SimpleNoiseTemplate(WhiteNoiseSampler::new));
}
}

17
common/src/main/java/com/dfsek/terra/registry/config/NormalizerRegistry.java
View File

@@ -1,17 +0,0 @@
package com.dfsek.terra.registry.config;
import com.dfsek.terra.config.loaders.config.sampler.templates.normalizer.ClampNormalizerTemplate;
import com.dfsek.terra.config.loaders.config.sampler.templates.normalizer.LinearNormalizerTemplate;
import com.dfsek.terra.config.loaders.config.sampler.templates.normalizer.NormalNormalizerTemplate;
import com.dfsek.terra.config.loaders.config.sampler.templates.normalizer.NormalizerTemplate;
import com.dfsek.terra.registry.TerraRegistry;
import java.util.function.Supplier;
public class NormalizerRegistry extends TerraRegistry<Supplier<NormalizerTemplate<?>>> {
public NormalizerRegistry() {
add("LINEAR", LinearNormalizerTemplate::new);
add("NORMAL", NormalNormalizerTemplate::new);
add("CLAMP", ClampNormalizerTemplate::new);
}
}

5
common/src/main/java/com/dfsek/terra/world/population/items/ores/DeformedSphereOre.java
View File

@@ -2,7 +2,7 @@ package com.dfsek.terra.world.population.items.ores;
import com.dfsek.terra.api.core.TerraPlugin;
import com.dfsek.terra.api.math.Range;
import com.dfsek.terra.api.math.noise.samplers.FastNoiseLite;
import com.dfsek.terra.api.math.noise.samplers.noise.simplex.OpenSimplex2Sampler;
import com.dfsek.terra.api.math.vector.Vector3;
import com.dfsek.terra.api.platform.block.Block;
import com.dfsek.terra.api.platform.block.BlockData;
@@ -28,8 +28,7 @@ public class DeformedSphereOre extends Ore {
@Override
public void generate(Vector3 origin, Chunk c, Random r) {
WorldHandle handle = main.getWorldHandle();
FastNoiseLite ore = new FastNoiseLite(r.nextInt());
ore.setNoiseType(FastNoiseLite.NoiseType.OpenSimplex2);
OpenSimplex2Sampler ore = new OpenSimplex2Sampler(r.nextInt());
ore.setFrequency(deformFrequency);
int rad = size.get(r);
for(int x = -rad; x <= rad; x++) {

4
common/src/test/java/biome/DistributionTest.java
View File

@@ -36,7 +36,7 @@ import com.dfsek.terra.config.templates.AbstractableTemplate;
import com.dfsek.terra.debug.DebugLogger;
import com.dfsek.terra.registry.ConfigRegistry;
import com.dfsek.terra.registry.config.BiomeRegistry;
import com.dfsek.terra.registry.config.NormalizerRegistry;
import com.dfsek.terra.registry.config.NoiseRegistry;
import com.dfsek.terra.world.TerraWorld;
import javax.swing.*;
@@ -161,7 +161,7 @@ public class DistributionTest {
.registerLoader(ImageProviderTemplate.class, () -> new ImageProviderTemplate(biomeRegistry));
new GenericLoaders(null).register(pipeLoader);
pipeLoader.registerLoader(NoiseSeeded.class, new NoiseSamplerBuilderLoader(new NormalizerRegistry()));
pipeLoader.registerLoader(NoiseSeeded.class, new NoiseSamplerBuilderLoader(new NoiseRegistry()));
pipeLoader.load(template, folderLoader.get("pack.yml"));
return template.getBiomeProviderBuilder().build(seed);

13
common/src/test/java/noise/NoiseTool.java
View File

@@ -3,16 +3,14 @@ package noise;
import com.dfsek.tectonic.exception.ConfigException;
import com.dfsek.tectonic.loading.ConfigLoader;
import com.dfsek.terra.api.math.ProbabilityCollection;
import com.dfsek.terra.api.math.noise.samplers.noise.NoiseFunction;
import com.dfsek.terra.api.math.noise.samplers.noise.fractal.RidgedFractalSampler;
import com.dfsek.terra.api.math.noise.samplers.noise.simplex.OpenSimplex2Sampler;
import com.dfsek.terra.api.math.noise.NoiseSampler;
import com.dfsek.terra.api.util.seeded.NoiseSeeded;
import com.dfsek.terra.config.GenericLoaders;
import com.dfsek.terra.config.fileloaders.FolderLoader;
import com.dfsek.terra.config.loaders.ProbabilityCollectionLoader;
import com.dfsek.terra.config.loaders.config.BufferedImageLoader;
import com.dfsek.terra.config.loaders.config.sampler.NoiseSamplerBuilderLoader;
import com.dfsek.terra.registry.config.NormalizerRegistry;
import com.dfsek.terra.registry.config.NoiseRegistry;
import org.apache.commons.io.FileUtils;
import javax.swing.*;
@@ -99,7 +97,7 @@ public class NoiseTool {
FolderLoader folderLoader = new FolderLoader(Paths.get("./"));
ConfigLoader loader = new ConfigLoader();
loader.registerLoader(NoiseSeeded.class, new NoiseSamplerBuilderLoader(new NormalizerRegistry()))
loader.registerLoader(NoiseSeeded.class, new NoiseSamplerBuilderLoader(new NoiseRegistry()))
.registerLoader(BufferedImage.class, new BufferedImageLoader(folderLoader))
.registerLoader(ProbabilityCollection.class, new ProbabilityCollectionLoader());
@@ -130,9 +128,8 @@ public class NoiseTool {
loader.load(template, new FileInputStream(file));
System.out.println(template.getBuilder().getDimensions());
//NoiseSampler noise = template.getBuilder().apply((long) seed);
NoiseFunction noise = new RidgedFractalSampler(new OpenSimplex2Sampler());
noise.setSeed(seed);
NoiseSampler noise = template.getBuilder().apply((long) seed);
int size = 1024;

5
platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/geometry/DeformedSphereCommand.java
View File

@@ -1,6 +1,6 @@
package com.dfsek.terra.bukkit.command.command.geometry;
import com.dfsek.terra.api.math.noise.samplers.FastNoiseLite;
import com.dfsek.terra.api.math.noise.samplers.noise.simplex.OpenSimplex2Sampler;
import com.dfsek.terra.api.math.vector.Vector3;
import com.dfsek.terra.api.math.voxel.DeformedSphere;
import com.dfsek.terra.bukkit.BukkitCommandSender;
@@ -44,8 +44,7 @@ public class DeformedSphereCommand extends PlayerCommand {
LangUtil.send("command.geometry.deform.invalid-frequency", new BukkitCommandSender(sender), args[2]);
return true;
}
FastNoiseLite n = new FastNoiseLite((int) sender.getWorld().getSeed());
n.setNoiseType(FastNoiseLite.NoiseType.OpenSimplex2);
OpenSimplex2Sampler n = new OpenSimplex2Sampler((int) sender.getWorld().getSeed());
n.setFrequency(freq);
DeformedSphere sphere = new DeformedSphere(BukkitAdapter.adapt(sender).getLocation().toVector(), radius, deform, n);
for(Vector3 v : sphere.getGeometry()) {